




"""simple docstring"""






import os
import unittest

from huggingface_hub.utils import are_progress_bars_disabled

import transformers.models.bart.tokenization_bart
from transformers import logging
from transformers.testing_utils import CaptureLogger, mockenv, mockenv_context
from transformers.utils.logging import disable_progress_bar, enable_progress_bar






class lowerCAmelCase__			(  unittest.TestCase		):






			'''simple docstring'''



			def       A_					(						self						):
							_lowerCamelCase  :    int					=					logging.get_logger()

							# the current default level is logging.WARNING
							_lowerCamelCase  :    Tuple					=					logging.get_verbosity()

							logging.set_verbosity_error()
							self.assertEqual(logger.getEffectiveLevel()						,   logging.get_verbosity()						)

							logging.set_verbosity_warning()
							self.assertEqual(logger.getEffectiveLevel()						,   logging.get_verbosity()						)

							logging.set_verbosity_info()
							self.assertEqual(logger.getEffectiveLevel()						,   logging.get_verbosity()						)

							logging.set_verbosity_debug()
							self.assertEqual(logger.getEffectiveLevel()						,   logging.get_verbosity()						)

							# restore to the original level
							logging.set_verbosity(lowercase						)
			def       A_					(						self						):
							_lowerCamelCase  :    Union[str, Any]					=					logging.get_verbosity()

							_lowerCamelCase  :    Any					=					logging.get_logger('transformers.models.bart.tokenization_bart'						)
							_lowerCamelCase  :    Tuple					=					'Testing 1, 2, 3'

							# should be able to log warnings (if default settings weren't overridden by `pytest --log-level-all`)
							if level_origin <= logging.WARNING:
											with CaptureLogger(lowercase						) as cl:
															logger.warning(lowercase						)
											self.assertEqual(cl.out						,   msg + '\n'						)

							# this is setting the level for all of `transformers.*` loggers
							logging.set_verbosity_error()

							# should not be able to log warnings
							with CaptureLogger(lowercase						) as cl:
											logger.warning(lowercase						)
							self.assertEqual(cl.out						,   ''						)

							# should be able to log warnings again
							logging.set_verbosity_warning()
							with CaptureLogger(lowercase						) as cl:
											logger.warning(lowercase						)
							self.assertEqual(cl.out						,   msg + '\n'						)

							# restore to the original level
							logging.set_verbosity(lowercase						)
			@mockenv(TRANSFORMERS_VERBOSITY='error'						)
			def       A_					(						self						):
							# reset for the env var to take effect, next time some logger call is made
							transformers.utils.logging._reset_library_root_logger()
							# this action activates the env var
							_lowerCamelCase  :    int					=					logging.get_logger('transformers.models.bart.tokenization_bart'						)

							_lowerCamelCase  :    Any					=					os.getenv('TRANSFORMERS_VERBOSITY'						,   lowercase						)
							_lowerCamelCase  :    Union[str, Any]					=					logging.log_levels[env_level_str]

							_lowerCamelCase  :    Optional[int]					=					logging.get_verbosity()
							self.assertEqual(
							    lowercase						,   lowercase						,   F'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}'''						,   )

							# restore to the original level
							_lowerCamelCase  :    str					=					''
							transformers.utils.logging._reset_library_root_logger()
			@mockenv(TRANSFORMERS_VERBOSITY='super-error'						)
			def       A_					(						self						):
							# reset for the env var to take effect, next time some logger call is made
							transformers.utils.logging._reset_library_root_logger()
							_lowerCamelCase  :    List[Any]					=					logging.logging.getLogger()
							with CaptureLogger(lowercase						) as cl:
											# this action activates the env var
											logging.get_logger('transformers.models.bart.tokenization_bart'						)
							self.assertIn('Unknown option TRANSFORMERS_VERBOSITY=super-error'						,   cl.out						)

							# no need to restore as nothing was changed






			def       A_					(						self						):
							# testing `logger.warning_advice()`
							transformers.utils.logging._reset_library_root_logger()

							_lowerCamelCase  :    Optional[Any]					=					logging.get_logger('transformers.models.bart.tokenization_bart'						)
							_lowerCamelCase  :    Tuple					=					'Testing 1, 2, 3'

							with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='1'						):
											# nothing should be logged as env var disables this method
											with CaptureLogger(lowercase						) as cl:
															logger.warning_advice(lowercase						)
											self.assertEqual(cl.out						,   ''						)

							with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=''						):
											# should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
											with CaptureLogger(lowercase						) as cl:
															logger.warning_advice(lowercase						)
											self.assertEqual(cl.out						,   msg + '\n'						)







def   _snake_case    (       ):
				disable_progress_bar()
				assert are_progress_bars_disabled()

				enable_progress_bar()
				assert not are_progress_bars_disabled()





"""simple docstring"""






def   _snake_case    (       lowercase__	):
				return "".join(chr(ord(lowercase__	) - 32	) if 'a' <= char <= 'z' else char for char in word	)


if __name__ == "__main__":
			from doctest import testmod

			testmod()