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






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Optional[Any]													=	logging.get_logger()

											# the current default level is logging.WARNING
											lowercase_     :					List[Any]													=	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(__SCREAMING_SNAKE_CASE		)






					def      _snake_case   (       self		):


											"""simple docstring"""





											lowercase_     :					Any													=	logging.get_verbosity()

											lowercase_     :					Optional[int]													=	logging.get_logger('''transformers.models.bart.tokenization_bart'''		)
											lowercase_     :					Optional[Any]													=	'''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(__SCREAMING_SNAKE_CASE		) as cl:
																							logger.warning(__SCREAMING_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(__SCREAMING_SNAKE_CASE		) as cl:
																	logger.warning(__SCREAMING_SNAKE_CASE		)
											self.assertEqual(cl.out    ,							''''''		)

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

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






					@mockenv(TRANSFORMERS_VERBOSITY='''error'''		)
					def      _snake_case   (       self		):


											"""simple docstring"""





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

											lowercase_     :					Dict													=	os.getenv('''TRANSFORMERS_VERBOSITY'''    ,							__SCREAMING_SNAKE_CASE		)
											lowercase_     :					str													=	logging.log_levels[env_level_str]

											lowercase_     :					Optional[int]													=	logging.get_verbosity()
											self.assertEqual(
											    __SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							F'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}'''    ,							)

											# restore to the original level
											lowercase_     :					List[str]													=	''''''
											transformers.utils.logging._reset_library_root_logger()






					@mockenv(TRANSFORMERS_VERBOSITY='''super-error'''		)
					def      _snake_case   (       self		):


											"""simple docstring"""





											transformers.utils.logging._reset_library_root_logger()
											lowercase_     :					str													=	logging.logging.getLogger()
											with CaptureLogger(__SCREAMING_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      _snake_case   (       self		):


											"""simple docstring"""





											transformers.utils.logging._reset_library_root_logger()

											lowercase_     :					Optional[int]													=	logging.get_logger('''transformers.models.bart.tokenization_bart'''		)
											lowercase_     :					Dict													=	'''Testing 1, 2, 3'''

											with mockenv_context(TRANSFORMERS_NO_ADVISORY_WARNINGS='''1'''		):
																	# nothing should be logged as env var disables this method
																	with CaptureLogger(__SCREAMING_SNAKE_CASE		) as cl:
																							logger.warning_advice(__SCREAMING_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(__SCREAMING_SNAKE_CASE		) as cl:
																							logger.warning_advice(__SCREAMING_SNAKE_CASE		)
																	self.assertEqual(cl.out    ,							msg + '''\n'''		)







def  snake_case_		(    ):



						"""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_torch_available


_lowercase			:  List[Any]   							=	{
    "configuration_x_clip": [
        "XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "XCLIPConfig",
        "XCLIPTextConfig",
        "XCLIPVisionConfig",
    ],
    "processing_x_clip": ["XCLIPProcessor"],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							_lowercase			:  int   							=	[
							    "XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "XCLIPModel",
							    "XCLIPPreTrainedModel",
							    "XCLIPTextModel",
							    "XCLIPVisionModel",
							]

if TYPE_CHECKING:
							from .configuration_x_clip import (
							    XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    XCLIPConfig,
							    XCLIPTextConfig,
							    XCLIPVisionConfig,
							)
							from .processing_x_clip import XCLIPProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_x_clip import (
														    XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    XCLIPModel,
														    XCLIPPreTrainedModel,
														    XCLIPTextModel,
														    XCLIPVisionModel,
														)

else:
							import sys

							_lowercase			:  List[str]   							=	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



