




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       lowercase_    (      self							)    ->      Optional[Any]:



							'''simple docstring'''
							__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(lowerCamelCase__							)


			def       lowercase_    (      self							)    ->      Optional[Any]:



							'''simple docstring'''
							__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(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       lowercase_    (      self							)    ->      Optional[int]:



							'''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		       =    logging.get_logger('transformers.models.bart.tokenization_bart'							)

							__lowerCamelCase		       =    os.getenv('TRANSFORMERS_VERBOSITY'			,						lowerCamelCase__							)
							__lowerCamelCase		       =    logging.log_levels[env_level_str]

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


			@mockenv(TRANSFORMERS_VERBOSITY='super-error'							)
			def       lowercase_    (      self							)    ->      Dict:



							'''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		       =    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       lowercase_    (      self							)    ->      Dict:



							'''simple docstring'''
							# 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(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_		(       )     ->       Dict:





				"""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, 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__)
