





'''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 snake_case__		(				self  :						Dict	)       ->	List[Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			logging.get_logger()

            # the current default level is logging.WARNING
            _UpperCamelCase							       =			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  :						str	)       ->	Optional[int]:

            '''simple docstring'''




            _UpperCamelCase							       =			logging.get_verbosity()

            _UpperCamelCase							       =			logging.get_logger('''transformers.models.bart.tokenization_bart'''	)
            _UpperCamelCase							       =			'''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  :						List[Any]	)       ->	int:

            '''simple docstring'''




            transformers.utils.logging._reset_library_root_logger()
            # this action activates the env var
            _UpperCamelCase							       =			logging.get_logger('''transformers.models.bart.tokenization_bart'''	)

            _UpperCamelCase							       =			os.getenv('''TRANSFORMERS_VERBOSITY'''			,					lowerCAmelCase__	)
            _UpperCamelCase							       =			logging.log_levels[env_level_str]

            _UpperCamelCase							       =			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
            _UpperCamelCase							       =			''''''
            transformers.utils.logging._reset_library_root_logger()





       @mockenv(TRANSFORMERS_VERBOSITY='''super-error'''	)
       def snake_case__		(				self  :						Optional[Any]	)       ->	Tuple:

            '''simple docstring'''




            transformers.utils.logging._reset_library_root_logger()
            _UpperCamelCase							       =			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  :						int	)       ->	List[Any]:

            '''simple docstring'''




            transformers.utils.logging._reset_library_root_logger()

            _UpperCamelCase							       =			logging.get_logger('''transformers.models.bart.tokenization_bart'''	)
            _UpperCamelCase							       =			'''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    a__							(							)						->						List[Any]:





     """simple docstring"""

     disable_progress_bar()
     assert are_progress_bars_disabled()

     enable_progress_bar()
     assert not are_progress_bars_disabled()










'''simple docstring'''

from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching







def    a__							(							)						->						Tuple:





     """simple docstring"""

     import os as original_os
     from os import path as original_path
     from os import rename as original_rename
     from os.path import dirname as original_dirname
     from os.path import join as original_join

     assert _test_patching.os is original_os
     assert _test_patching.path is original_path
     assert _test_patching.join is original_join

     assert _test_patching.renamed_os is original_os
     assert _test_patching.renamed_path is original_path
     assert _test_patching.renamed_join is original_join

     _UpperCamelCase							       =			'''__test_patch_submodule_mock__'''
     with patch_submodule(_test_patching,   '''os.path.join''',   lowercase ):
          # Every way to access os.path.join must be patched, and the rest must stay untouched

          # check os.path.join
          assert isinstance(_test_patching.os,   _PatchedModuleObj )
          assert isinstance(_test_patching.os.path,   _PatchedModuleObj )
          assert _test_patching.os.path.join is mock

          # check path.join
          assert isinstance(_test_patching.path,   _PatchedModuleObj )
          assert _test_patching.path.join is mock

          # check join
          assert _test_patching.join is mock

          # check that the other attributes are untouched
          assert _test_patching.os.rename is original_rename
          assert _test_patching.path.dirname is original_dirname
          assert _test_patching.os.path.dirname is original_dirname

          # Even renamed modules or objects must be patched

          # check renamed_os.path.join
          assert isinstance(_test_patching.renamed_os,   _PatchedModuleObj )
          assert isinstance(_test_patching.renamed_os.path,   _PatchedModuleObj )
          assert _test_patching.renamed_os.path.join is mock

          # check renamed_path.join
          assert isinstance(_test_patching.renamed_path,   _PatchedModuleObj )
          assert _test_patching.renamed_path.join is mock

          # check renamed_join
          assert _test_patching.renamed_join is mock

          # check that the other attributes are untouched
          assert _test_patching.renamed_os.rename is original_rename
          assert _test_patching.renamed_path.dirname is original_dirname
          assert _test_patching.renamed_os.path.dirname is original_dirname

     # check that everthing is back to normal when the patch is over

     assert _test_patching.os is original_os
     assert _test_patching.path is original_path
     assert _test_patching.join is original_join

     assert _test_patching.renamed_os is original_os
     assert _test_patching.renamed_path is original_path
     assert _test_patching.renamed_join is original_join







def    a__							(							)						->						Tuple:





     """simple docstring"""

     assert _test_patching.open is open

     _UpperCamelCase							       =			'''__test_patch_submodule_builtin_mock__'''
     # _test_patching has "open" in its globals
     assert _test_patching.open is open
     with patch_submodule(_test_patching,   '''open''',   lowercase ):
          assert _test_patching.open is mock

     # check that everthing is back to normal when the patch is over

     assert _test_patching.open is open







def    a__							(							)						->						Optional[Any]:





     """simple docstring"""

     _UpperCamelCase							       =			'''__test_patch_submodule_missing_mock__'''
     with patch_submodule(_test_patching,   '''pandas.read_csv''',   lowercase ):
          pass







def    a__							(							)						->						Optional[int]:





     """simple docstring"""

     _UpperCamelCase							       =			'''__test_patch_submodule_missing_builtin_mock__'''
     # _test_patching doesn't have "len" in its globals
     assert getattr(_test_patching,   '''len''',   lowercase ) is None
     with patch_submodule(_test_patching,   '''len''',   lowercase ):
          assert _test_patching.len is mock
     assert _test_patching.len is len







def    a__							(							)						->						Optional[Any]:





     """simple docstring"""

     _UpperCamelCase							       =			'''__test_patch_submodule_start_and_stop_mock__'''
     _UpperCamelCase							       =			patch_submodule(_test_patching,   '''open''',   lowercase )
     assert _test_patching.open is open
     patch.start()
     assert _test_patching.open is mock
     patch.stop()
     assert _test_patching.open is open







def    a__							(							)						->						List[str]:





     """simple docstring"""

     from os import rename as original_rename
     from os.path import dirname as original_dirname
     from os.path import join as original_join

     _UpperCamelCase							       =			'''__test_patch_submodule_successive_join__'''
     _UpperCamelCase							       =			'''__test_patch_submodule_successive_dirname__'''
     _UpperCamelCase							       =			'''__test_patch_submodule_successive_rename__'''
     assert _test_patching.os.path.join is original_join
     assert _test_patching.os.path.dirname is original_dirname
     assert _test_patching.os.rename is original_rename

     with patch_submodule(_test_patching,   '''os.path.join''',   lowercase ):
          with patch_submodule(_test_patching,   '''os.rename''',   lowercase ):
               with patch_submodule(_test_patching,   '''os.path.dirname''',   lowercase ):
                    assert _test_patching.os.path.join is mock_join
                    assert _test_patching.os.path.dirname is mock_dirname
                    assert _test_patching.os.rename is mock_rename

    # try another order
     with patch_submodule(_test_patching,   '''os.rename''',   lowercase ):
          with patch_submodule(_test_patching,   '''os.path.join''',   lowercase ):
               with patch_submodule(_test_patching,   '''os.path.dirname''',   lowercase ):
                    assert _test_patching.os.path.join is mock_join
                    assert _test_patching.os.path.dirname is mock_dirname
                    assert _test_patching.os.rename is mock_rename

     assert _test_patching.os.path.join is original_join
     assert _test_patching.os.path.dirname is original_dirname
     assert _test_patching.os.rename is original_rename







def    a__							(							)						->						str:





     """simple docstring"""

     _UpperCamelCase							       =			'''__test_patch_submodule_doesnt_exist_mock__'''
     with patch_submodule(_test_patching,   '''__module_that_doesn_exist__.__attribute_that_doesn_exist__''',   lowercase ):
          pass
     with patch_submodule(_test_patching,   '''os.__attribute_that_doesn_exist__''',   lowercase ):
          pass



