





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       ):




      def     lowercase__   (      self      :			Optional[Any]  )    ->				Any:
            _lowerCAmelCase												=							logging.get_logger()

            # the current default level is logging.WARNING
            _lowerCAmelCase												=							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(__snake_case  )




      def     lowercase__   (      self      :			Union[str, Any]  )    ->				Tuple:
            _lowerCAmelCase												=							logging.get_verbosity()

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

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

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




      @mockenv(TRANSFORMERS_VERBOSITY="""error"""  )
      def     lowercase__   (      self      :			Any  )    ->				Optional[Any]:
            # 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												=							logging.get_logger("""transformers.models.bart.tokenization_bart"""  )

            _lowerCAmelCase												=							os.getenv("""TRANSFORMERS_VERBOSITY"""      ,      __snake_case  )
            _lowerCAmelCase												=							logging.log_levels[env_level_str]

            _lowerCAmelCase												=							logging.get_verbosity()
            self.assertEqual(
                __snake_case      ,      __snake_case      ,      f"TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}"      ,      )

            # restore to the original level
            _lowerCAmelCase												=							""""""
            transformers.utils.logging._reset_library_root_logger()




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

            _lowerCAmelCase												=							logging.get_logger("""transformers.models.bart.tokenization_bart"""  )
            _lowerCAmelCase												=							"""Testing 1, 2, 3"""

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

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




def        UpperCamelCase__				(		):





      """simple docstring"""


      disable_progress_bar()
      assert are_progress_bars_disabled()

      enable_progress_bar()
      assert not are_progress_bars_disabled()













'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available


A__    :       int              ={'''tokenization_herbert''': ['''HerbertTokenizer''']}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A__    :       Dict              =['''HerbertTokenizerFast''']


if TYPE_CHECKING:
      from .tokenization_herbert import HerbertTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_herbert_fast import HerbertTokenizerFast

else:
      import sys

      A__    :       List[Any]              =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






