






"""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    __UpperCAmelCase(       unittest.TestCase							):




						"""simple docstring"""




						def 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Dict=	logging.get_logger()

												# the current default level is logging.WARNING
												lowercase__    :				List[str]=	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 		UpperCAmelCase_	(       self      ):
												'''simple docstring'''
												lowercase__    :				Tuple=	logging.get_verbosity()

												lowercase__    :				str=	logging.get_logger("transformers.models.bart.tokenization_bart"      )
												lowercase__    :				int=	"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 		UpperCAmelCase_	(       self      ):
												'''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
												lowercase__    :				Optional[int]=	logging.get_logger("transformers.models.bart.tokenization_bart"      )

												lowercase__    :				Union[str, Any]=	os.getenv("TRANSFORMERS_VERBOSITY"	,  snake_case__      )
												lowercase__    :				List[Any]=	logging.log_levels[env_level_str]

												lowercase__    :				Dict=	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
												lowercase__    :				Tuple=	""
												transformers.utils.logging._reset_library_root_logger()




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

												lowercase__    :				Dict=	logging.get_logger("transformers.models.bart.tokenization_bart"      )
												lowercase__    :				Optional[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(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 						lowercase__()    ->str:




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


a			:    Union[str, Any]				 =		{
    """configuration_pegasus_x""": ["""PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP""", """PegasusXConfig"""],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			a			:    int				 =		[
			    """PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST""",
			    """PegasusXForConditionalGeneration""",
			    """PegasusXModel""",
			    """PegasusXPreTrainedModel""",
			]


if TYPE_CHECKING:
			from .configuration_pegasus_x import PEGASUS_X_PRETRAINED_CONFIG_ARCHIVE_MAP, PegasusXConfig

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_pegasus_x import (
						    PEGASUS_X_PRETRAINED_MODEL_ARCHIVE_LIST,
						    PegasusXForConditionalGeneration,
						    PegasusXModel,
						    PegasusXPreTrainedModel,
						)


else:
			import sys

			a			:    Optional[Any]				 =		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






