


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   UpperCAmelCase__       (     self       :   str       ):






										'''simple docstring'''






										lowercase_  							=			logging.get_logger()

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

					def   UpperCAmelCase__       (     self       :   int       ):






										'''simple docstring'''






										lowercase_  							=			logging.get_verbosity()

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

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

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

					@mockenv(TRANSFORMERS_VERBOSITY="""error"""       )
					def   UpperCAmelCase__       (     self       :   Any       ):






										'''simple docstring'''






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

										lowercase_  							=			os.getenv("""TRANSFORMERS_VERBOSITY"""							,					UpperCamelCase__       )
										lowercase_  							=			logging.log_levels[env_level_str]

										lowercase_  							=			logging.get_verbosity()
										self.assertEqual(
										    UpperCamelCase__							,					UpperCamelCase__							,					F'''TRANSFORMERS_VERBOSITY={env_level_str}/{env_level}, but internal verbosity is {current_level}'''							,					)

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

					@mockenv(TRANSFORMERS_VERBOSITY="""super-error"""       )
					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										transformers.utils.logging._reset_library_root_logger()
										lowercase_  							=			logging.logging.getLogger()
										with CaptureLogger(UpperCamelCase__       ) 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       :   Optional[int]       ):






										'''simple docstring'''






										transformers.utils.logging._reset_library_root_logger()

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

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

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



def 			UpperCAmelCase_				(      ):
					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_sentencepiece_available,
    is_speech_available,
    is_torch_available,
)


a					  =     {
    'configuration_trocr': ['TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TrOCRConfig'],
    'processing_trocr': ['TrOCRProcessor'],
}


try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							a					  =     [
							    'TROCR_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'TrOCRForCausalLM',
							    'TrOCRPreTrainedModel',
							]


if TYPE_CHECKING:
							from .configuration_trocr import TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP, TrOCRConfig
							from .processing_trocr import TrOCRProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_trocr import TROCR_PRETRAINED_MODEL_ARCHIVE_LIST, TrOCRForCausalLM, TrOCRPreTrainedModel

else:
							import sys

							a					  =     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


