'''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						:				List[Any]       ):
             _UpperCAmelCase     :  List[Any]							      =    logging.get_logger()

             # the current default level is logging.WARNING
             _UpperCAmelCase     :  int							      =    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(A       )




      def      _A	(       self						:				int       ):
             _UpperCAmelCase     :  int							      =    logging.get_verbosity()

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

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

             # restore to the original level
             logging.set_verbosity(A       )




      @mockenv(TRANSFORMERS_VERBOSITY="error"       )
      def      _A	(       self						:				Dict       ):
             # 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
             _UpperCAmelCase     :  str							      =    logging.get_logger("transformers.models.bart.tokenization_bart"       )

             _UpperCAmelCase     :  Optional[int]							      =    os.getenv("TRANSFORMERS_VERBOSITY"						,					A       )
             _UpperCAmelCase     :  Any							      =    logging.log_levels[env_level_str]

             _UpperCAmelCase     :  Tuple							      =    logging.get_verbosity()
             self.assertEqual(
                 A						,					A						,					F"""TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}"""						,					)

             # restore to the original level
             _UpperCAmelCase     :  int							      =    ""
             transformers.utils.logging._reset_library_root_logger()




      @mockenv(TRANSFORMERS_VERBOSITY="super-error"       )
      def      _A	(       self						:				Union[str, Any]       ):
             # reset for the env var to take effect, next time some logger call is made
             transformers.utils.logging._reset_library_root_logger()
             _UpperCAmelCase     :  List[Any]							      =    logging.logging.getLogger()
             with CaptureLogger(A       ) 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						:				List[Any]       ):
             # testing `logger.warning_advice()`
             transformers.utils.logging._reset_library_root_logger()

             _UpperCAmelCase     :  Optional[Any]							      =    logging.get_logger("transformers.models.bart.tokenization_bart"       )
             _UpperCAmelCase     :  List[Any]							      =    "Testing 1, 2, 3"

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

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

def 	UpperCamelCase_							(					)    ->    List[Any]:


       """simple docstring"""







       disable_progress_bar()
       assert are_progress_bars_disabled()

       enable_progress_bar()
       assert not are_progress_bars_disabled()








"""simple docstring"""
_snake_case     :		Optional[int]       						= [
    'DownloadConfig',
    'DownloadManager',
    'DownloadMode',
    'StreamingDownloadManager',
]

from .download_config import DownloadConfig
from .download_manager import DownloadManager, DownloadMode
from .streaming_download_manager import StreamingDownloadManager


