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 	_UpperCAmelCase				(				self:			int   ) -> Dict:




    '''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 	_UpperCAmelCase				(				self:			Union[str, Any]   ) -> List[str]:




    '''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 	_UpperCAmelCase				(				self:			Union[str, Any]   ) -> Optional[Any]:




    '''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 	_UpperCAmelCase				(				self:			Optional[int]   ) -> List[str]:




    '''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 	_UpperCAmelCase				(				self:			Union[str, Any]   ) -> Optional[int]:




    '''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       __lowerCAmelCase      (						)    ->  Any:
  disable_progress_bar()
  assert are_progress_bars_disabled()

  enable_progress_bar()
  assert not are_progress_bars_disabled()




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


a_							=      {
    """configuration_altclip""": [
        """ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """AltCLIPConfig""",
        """AltCLIPTextConfig""",
        """AltCLIPVisionConfig""",
    ],
    """processing_altclip""": ["""AltCLIPProcessor"""],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       a_							=      [
           """ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """AltCLIPPreTrainedModel""",
           """AltCLIPModel""",
           """AltCLIPTextModel""",
           """AltCLIPVisionModel""",
       ]


if TYPE_CHECKING:
       from .configuration_altclip import (
           ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
           AltCLIPConfig,
           AltCLIPTextConfig,
           AltCLIPVisionConfig,
       )
       from .processing_altclip import AltCLIPProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_altclip import (
                  ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
                  AltCLIPModel,
                  AltCLIPPreTrainedModel,
                  AltCLIPTextModel,
                  AltCLIPVisionModel,
              )


else:
       import sys

       a_							=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



