






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 	_UpperCAmelCase  (  unittest.TestCase		):




      """simple docstring"""



      def 			snake_case_      (   self		):



          '''simple docstring'''
          lowerCAmelCase__   :Tuple      							=				logging.get_logger()

          # the current default level is logging.WARNING
          lowerCAmelCase__   :List[Any]      							=				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(_lowerCAmelCase		)
      def 			snake_case_      (   self		):



          '''simple docstring'''
          lowerCAmelCase__   :Union[str, Any]      							=				logging.get_verbosity()

          lowerCAmelCase__   :List[str]      							=				logging.get_logger("transformers.models.bart.tokenization_bart"		)
          lowerCAmelCase__   :Any      							=				"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(_lowerCAmelCase		) as cl:
                  logger.warning(_lowerCAmelCase		)
              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(_lowerCAmelCase		) as cl:
              logger.warning(_lowerCAmelCase		)
          self.assertEqual(cl.out    ,	""		)

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

          # restore to the original level
          logging.set_verbosity(_lowerCAmelCase		)
      @mockenv(TRANSFORMERS_VERBOSITY="error"		)
      def 			snake_case_      (   self		):



          '''simple docstring'''
          # 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__   :Optional[Any]      							=				logging.get_logger("transformers.models.bart.tokenization_bart"		)

          lowerCAmelCase__   :Dict      							=				os.getenv("TRANSFORMERS_VERBOSITY"    ,	_lowerCAmelCase		)
          lowerCAmelCase__   :Tuple      							=				logging.log_levels[env_level_str]

          lowerCAmelCase__   :Tuple      							=				logging.get_verbosity()
          self.assertEqual(
              _lowerCAmelCase    ,	_lowerCAmelCase    ,	f'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}'''    ,	)

          # restore to the original level
          lowerCAmelCase__   :Dict      							=				""
          transformers.utils.logging._reset_library_root_logger()
      @mockenv(TRANSFORMERS_VERBOSITY="super-error"		)
      def 			snake_case_      (   self		):



          '''simple docstring'''
          # reset for the env var to take effect, next time some logger call is made
          transformers.utils.logging._reset_library_root_logger()
          lowerCAmelCase__   :Dict      							=				logging.logging.getLogger()
          with CaptureLogger(_lowerCAmelCase		) 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 			snake_case_      (   self		):



          '''simple docstring'''
          # testing `logger.warning_advice()`
          transformers.utils.logging._reset_library_root_logger()

          lowerCAmelCase__   :int      							=				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(_lowerCAmelCase		) as cl:
                  logger.warning_advice(_lowerCAmelCase		)
              self.assertEqual(cl.out    ,	""		)

          with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS=""		):
              # should log normally as TRANSFORMERS_NO_ADVISORY_WARNINGS is unset
              with CaptureLogger(_lowerCAmelCase		) as cl:
                  logger.warning_advice(_lowerCAmelCase		)
              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()











def 				snake_case__							(							UpperCAmelCase							:  str       ):
    return "".join(chr(ord(UpperCAmelCase       ) - 3_2       ) if "a" <= char <= "z" else char for char in word       )


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

 testmod()



