



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





					"""simple docstring"""






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

					# the current default level is logging.WARNING
					__SCREAMING_SNAKE_CASE :	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(lowerCAmelCase__		)

			def UpperCamelCase__      (							self  :				Tuple		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	logging.get_verbosity()

					__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	logging.get_logger("""transformers.models.bart.tokenization_bart"""		)
					__SCREAMING_SNAKE_CASE :	str					 =	"""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  :				List[str]		):





					"""simple docstring"""






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

					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	os.getenv("""TRANSFORMERS_VERBOSITY"""							,  lowerCAmelCase__		)
					__SCREAMING_SNAKE_CASE :	Any					 =	logging.log_levels[env_level_str]

					__SCREAMING_SNAKE_CASE :	Dict					 =	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
					__SCREAMING_SNAKE_CASE :	int					 =	""""""
					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()
					__SCREAMING_SNAKE_CASE :	str					 =	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]		):





					"""simple docstring"""






					transformers.utils.logging._reset_library_root_logger()

					__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	logging.get_logger("""transformers.models.bart.tokenization_bart"""		)
					__SCREAMING_SNAKE_CASE :	List[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(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_     (			):
		disable_progress_bar()
		assert are_progress_bars_disabled()

		enable_progress_bar()
		assert not are_progress_bars_disabled()




'''simple docstring'''




UpperCamelCase__ :			List[str]												=				'''0.21.0'''

from .accelerator import Accelerator
from .big_modeling import (
    cpu_offload,
    cpu_offload_with_hook,
    disk_offload,
    dispatch_model,
    init_empty_weights,
    init_on_device,
    load_checkpoint_and_dispatch,
)
from .data_loader import skip_first_batches
from .launchers import debug_launcher, notebook_launcher
from .state import PartialState
from .utils import (
    DeepSpeedPlugin,
    DistributedDataParallelKwargs,
    DistributedType,
    FullyShardedDataParallelPlugin,
    GradScalerKwargs,
    InitProcessGroupKwargs,
    find_executable_batch_size,
    infer_auto_device_map,
    is_rich_available,
    load_checkpoint_in_model,
    synchronize_rng_states,
)


if is_rich_available():
						from .utils import rich