


'''simple docstring'''






import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import (
		    MODEL_MAPPING,
		    BeitForImageClassification,
		    BeitForMaskedImageModeling,
		    BeitForSemanticSegmentation,
		    BeitModel,
		)
		from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		import PIL
		from PIL import Image

		from transformers import BeitImageProcessor




class 						a__							:





							'''simple docstring'''






							def __init__(						self   ,       lowerCamelCase_   ,       lowerCamelCase_=1_00   ,       lowerCamelCase_=13   ,       lowerCamelCase_=30   ,       lowerCamelCase_=2   ,       lowerCamelCase_=3   ,       lowerCamelCase_=True   ,       lowerCamelCase_=True   ,       lowerCamelCase_=32   ,       lowerCamelCase_=4   ,       lowerCamelCase_=4   ,       lowerCamelCase_=37   ,       lowerCamelCase_="gelu"   ,       lowerCamelCase_=0.1   ,       lowerCamelCase_=0.1   ,       lowerCamelCase_=10   ,       lowerCamelCase_=0.02   ,       lowerCamelCase_=3   ,       lowerCamelCase_=None   ,       lowerCamelCase_=[0, 1, 2, 3]   ,       )			->				List[str]:
														lowerCAmelCase__			  =      parent
														lowerCAmelCase__			  =      1_00
														lowerCAmelCase__			  =      batch_size
														lowerCAmelCase__			  =      image_size
														lowerCAmelCase__			  =      patch_size
														lowerCAmelCase__			  =      num_channels
														lowerCAmelCase__			  =      is_training
														lowerCAmelCase__			  =      use_labels
														lowerCAmelCase__			  =      hidden_size
														lowerCAmelCase__			  =      num_hidden_layers
														lowerCAmelCase__			  =      num_attention_heads
														lowerCAmelCase__			  =      intermediate_size
														lowerCAmelCase__			  =      hidden_act
														lowerCAmelCase__			  =      hidden_dropout_prob
														lowerCAmelCase__			  =      attention_probs_dropout_prob
														lowerCAmelCase__			  =      type_sequence_label_size
														lowerCAmelCase__			  =      initializer_range
														lowerCAmelCase__			  =      scope
														lowerCAmelCase__			  =      out_indices
														lowerCAmelCase__			  =      num_labels

														# in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
														lowerCAmelCase__			  =      (image_size // patch_size) ** 2
														lowerCAmelCase__			  =      num_patches + 1







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__			  =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

														lowerCAmelCase__			  =      None
														lowerCAmelCase__			  =      None
														if self.use_labels:
																					lowerCAmelCase__			  =      ids_tensor([self.batch_size]   ,       self.type_sequence_label_size  )
																					lowerCAmelCase__			  =      ids_tensor([self.batch_size, self.image_size, self.image_size]   ,       self.num_labels  )

														lowerCAmelCase__			  =      self.get_config()

														return config, pixel_values, labels, pixel_labels







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Tuple:
														return BeitConfig(
														    vocab_size=self.vocab_size   ,       image_size=self.image_size   ,       patch_size=self.patch_size   ,       num_channels=self.num_channels   ,       hidden_size=self.hidden_size   ,       num_hidden_layers=self.num_hidden_layers   ,       num_attention_heads=self.num_attention_heads   ,       intermediate_size=self.intermediate_size   ,       hidden_act=self.hidden_act   ,       hidden_dropout_prob=self.hidden_dropout_prob   ,       attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,       is_decoder=lowerCamelCase_   ,       initializer_range=self.initializer_range   ,       out_indices=self.out_indices   ,       )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				List[Any]:
														lowerCAmelCase__			  =      BeitModel(config=lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()
														lowerCAmelCase__			  =      model(lowerCamelCase_  )
														self.parent.assertEqual(result.last_hidden_state.shape   ,       (self.batch_size, self.seq_length, self.hidden_size)  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      BeitForMaskedImageModeling(config=lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()
														lowerCAmelCase__			  =      model(lowerCamelCase_  )
														self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.seq_length - 1, self.vocab_size)  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				Optional[Any]:
														lowerCAmelCase__			  =      self.type_sequence_label_size
														lowerCAmelCase__			  =      BeitForImageClassification(lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()
														lowerCAmelCase__			  =      model(lowerCamelCase_   ,       labels=lowerCamelCase_  )
														self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.type_sequence_label_size)  )

														# test greyscale images
														lowerCAmelCase__			  =      1
														lowerCAmelCase__			  =      BeitForImageClassification(lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()

														lowerCAmelCase__			  =      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
														lowerCAmelCase__			  =      model(lowerCamelCase_   ,       labels=lowerCamelCase_  )
														self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.type_sequence_label_size)  )







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				List[Any]:
														lowerCAmelCase__			  =      self.num_labels
														lowerCAmelCase__			  =      BeitForSemanticSegmentation(lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()
														lowerCAmelCase__			  =      model(lowerCamelCase_  )
														self.parent.assertEqual(
														    result.logits.shape   ,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)  )
														lowerCAmelCase__			  =      model(lowerCamelCase_   ,       labels=lowerCamelCase_  )
														self.parent.assertEqual(
														    result.logits.shape   ,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														lowerCAmelCase__			  =      self.prepare_config_and_inputs()
														lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__			  =      config_and_inputs
														lowerCAmelCase__			  =      {'''pixel_values''': pixel_values}
														return config, inputs_dict




@require_torch
class 						a__							(				a__							,							a__							,							unittest.TestCase    ):





							'''simple docstring'''






							lowercase__     :  str      		= (
							    (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
							    if is_torch_available()
							    else ()
							)
							lowercase__     :  List[Any]      		= (
							    {
							        "feature-extraction": BeitModel,
							        "image-classification": BeitForImageClassification,
							        "image-segmentation": BeitForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							lowercase__     :  Tuple      		= False
							lowercase__     :  Dict      		= False
							lowercase__     :  Optional[int]      		= False







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														lowerCAmelCase__			  =      BeitModelTester(self  )
														lowerCAmelCase__			  =      ConfigTester(self   ,       config_class=lowerCamelCase_   ,       has_text_modality=lowerCamelCase_   ,       hidden_size=37  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														self.config_tester.run_common_tests()







							@unittest.skip(reason='''BEiT does not use inputs_embeds'''  )
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														pass







							@require_torch_multi_gpu
							@unittest.skip(reason='''BEiT has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''  )
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[Any]:
														pass







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														lowerCAmelCase__  ,   lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					lowerCAmelCase__			  =      model_class(lowerCamelCase_  )
																					self.assertIsInstance(model.get_input_embeddings()   ,       (nn.Module)  )
																					lowerCAmelCase__			  =      model.get_output_embeddings()
																					self.assertTrue(x is None or isinstance(lowerCamelCase_   ,       nn.Linear  )  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				str:
														lowerCAmelCase__  ,   lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					lowerCAmelCase__			  =      model_class(lowerCamelCase_  )
																					lowerCAmelCase__			  =      inspect.signature(model.forward  )
																					# signature.parameters is an OrderedDict => so arg_names order is deterministic
																					lowerCAmelCase__			  =      [*signature.parameters.keys()]

																					lowerCAmelCase__			  =      ['''pixel_values''']
																					self.assertListEqual(arg_names[:1]   ,       lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_image_classification(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														if not self.model_tester.is_training:
																					return

														lowerCAmelCase__  ,   lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs_for_common()
														lowerCAmelCase__			  =      True

														for model_class in self.all_model_classes:
																					# we don't test BeitForMaskedImageModeling
																					if model_class in [*get_values(lowerCamelCase_  ), BeitForMaskedImageModeling]:
																												continue

																					lowerCAmelCase__			  =      model_class(lowerCamelCase_  )
																					model.to(lowerCamelCase_  )
																					model.train()
																					lowerCAmelCase__			  =      self._prepare_for_class(lowerCamelCase_   ,       lowerCamelCase_   ,       return_labels=lowerCamelCase_  )
																					lowerCAmelCase__			  =      model(**lowerCamelCase_  ).loss
																					loss.backward()







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														lowerCAmelCase__  ,   lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs_for_common()
														if not self.model_tester.is_training:
																					return

														lowerCAmelCase__			  =      False
														lowerCAmelCase__			  =      True

														for model_class in self.all_model_classes:
																					# we don't test BeitForMaskedImageModeling
																					if (
																					    model_class in [*get_values(lowerCamelCase_  ), BeitForMaskedImageModeling]
																					    or not model_class.supports_gradient_checkpointing
																					):
																												continue

																					lowerCAmelCase__			  =      model_class(lowerCamelCase_  )
																					model.gradient_checkpointing_enable()
																					model.to(lowerCamelCase_  )
																					model.train()
																					lowerCAmelCase__			  =      self._prepare_for_class(lowerCamelCase_   ,       lowerCamelCase_   ,       return_labels=lowerCamelCase_  )
																					lowerCAmelCase__			  =      model(**lowerCamelCase_  ).loss
																					loss.backward()







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__  ,   lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs_for_common()

														lowerCAmelCase__			  =      _config_zero_init(lowerCamelCase_  )
														for model_class in self.all_model_classes:
																					lowerCAmelCase__			  =      model_class(config=lowerCamelCase_  )
																					for name, param in model.named_parameters():
																												# we skip lambda parameters as these require special initial values
																												# determined by config.layer_scale_init_value
																												if "lambda" in name:
																																			continue
																												if param.requires_grad:
																																			self.assertIn(
																																			    ((param.data.mean() * 1e9).round() / 1e9).item()   ,       [0.0, 1.0]   ,       msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""   ,       )







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					lowerCAmelCase__			  =      BeitModel.from_pretrained(lowerCamelCase_  )
																					self.assertIsNotNone(lowerCamelCase_  )


def    _snake_case  (	)		->       Optional[int]:
							lowerCAmelCase__			  =      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
							return image






@require_torch
@require_vision
class 						a__							(				unittest.TestCase    ):





							'''simple docstring'''






							@cached_property
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														return BeitImageProcessor.from_pretrained('''microsoft/beit-base-patch16-224'''  ) if is_vision_available() else None







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														lowerCAmelCase__			  =      BeitForMaskedImageModeling.from_pretrained('''microsoft/beit-base-patch16-224-pt22k'''  ).to(lowerCamelCase_  )

														lowerCAmelCase__			  =      self.default_image_processor
														lowerCAmelCase__			  =      prepare_img()
														lowerCAmelCase__			  =      image_processor(images=lowerCamelCase_   ,       return_tensors='''pt'''  ).pixel_values.to(lowerCamelCase_  )

														# prepare bool_masked_pos
														lowerCAmelCase__			  =      torch.ones((1, 1_96)   ,       dtype=torch.bool  ).to(lowerCamelCase_  )

														# forward pass
														with torch.no_grad():
																					lowerCAmelCase__			  =      model(pixel_values=lowerCamelCase_   ,       bool_masked_pos=lowerCamelCase_  )
														lowerCAmelCase__			  =      outputs.logits

														# verify the logits
														lowerCAmelCase__			  =      torch.Size((1, 1_96, 81_92)  )
														self.assertEqual(logits.shape   ,       lowerCamelCase_  )

														lowerCAmelCase__			  =      torch.tensor(
														    [[-3.2_437, 0.5_072, -13.9_174], [-3.2_456, 0.4_948, -13.9_401], [-3.2_033, 0.5_121, -13.8_550]]  ).to(lowerCamelCase_  )

														self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]   ,       lowerCamelCase_   ,       atol=1e-2  )  )







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__			  =      BeitForImageClassification.from_pretrained('''microsoft/beit-base-patch16-224'''  ).to(lowerCamelCase_  )

														lowerCAmelCase__			  =      self.default_image_processor
														lowerCAmelCase__			  =      prepare_img()
														lowerCAmelCase__			  =      image_processor(images=lowerCamelCase_   ,       return_tensors='''pt'''  ).to(lowerCamelCase_  )

														# forward pass
														with torch.no_grad():
																					lowerCAmelCase__			  =      model(**lowerCamelCase_  )
														lowerCAmelCase__			  =      outputs.logits

														# verify the logits
														lowerCAmelCase__			  =      torch.Size((1, 10_00)  )
														self.assertEqual(logits.shape   ,       lowerCamelCase_  )

														lowerCAmelCase__			  =      torch.tensor([-1.2_385, -1.0_987, -1.0_108]  ).to(lowerCamelCase_  )

														self.assertTrue(torch.allclose(logits[0, :3]   ,       lowerCamelCase_   ,       atol=1e-4  )  )

														lowerCAmelCase__			  =      2_81
														self.assertEqual(logits.argmax(-1  ).item()   ,       lowerCamelCase_  )







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														lowerCAmelCase__			  =      BeitForImageClassification.from_pretrained('''microsoft/beit-large-patch16-224-pt22k-ft22k'''  ).to(
														    lowerCamelCase_  )

														lowerCAmelCase__			  =      self.default_image_processor
														lowerCAmelCase__			  =      prepare_img()
														lowerCAmelCase__			  =      image_processor(images=lowerCamelCase_   ,       return_tensors='''pt'''  ).to(lowerCamelCase_  )

														# forward pass
														with torch.no_grad():
																					lowerCAmelCase__			  =      model(**lowerCamelCase_  )
														lowerCAmelCase__			  =      outputs.logits

														# verify the logits
														lowerCAmelCase__			  =      torch.Size((1, 2_18_41)  )
														self.assertEqual(logits.shape   ,       lowerCamelCase_  )

														lowerCAmelCase__			  =      torch.tensor([1.6_881, -0.2_787, 0.5_901]  ).to(lowerCamelCase_  )

														self.assertTrue(torch.allclose(logits[0, :3]   ,       lowerCamelCase_   ,       atol=1e-4  )  )

														lowerCAmelCase__			  =      23_96
														self.assertEqual(logits.argmax(-1  ).item()   ,       lowerCamelCase_  )







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__			  =      BeitForSemanticSegmentation.from_pretrained('''microsoft/beit-base-finetuned-ade-640-640'''  )
														lowerCAmelCase__			  =      model.to(lowerCamelCase_  )

														lowerCAmelCase__			  =      BeitImageProcessor(do_resize=lowerCamelCase_   ,       size=6_40   ,       do_center_crop=lowerCamelCase_  )

														lowerCAmelCase__			  =      load_dataset('''hf-internal-testing/fixtures_ade20k'''   ,       split='''test'''  )
														lowerCAmelCase__			  =      Image.open(ds[0]['''file''']  )
														lowerCAmelCase__			  =      image_processor(images=lowerCamelCase_   ,       return_tensors='''pt'''  ).to(lowerCamelCase_  )

														# forward pass
														with torch.no_grad():
																					lowerCAmelCase__			  =      model(**lowerCamelCase_  )
														lowerCAmelCase__			  =      outputs.logits

														# verify the logits
														lowerCAmelCase__			  =      torch.Size((1, 1_50, 1_60, 1_60)  )
														self.assertEqual(logits.shape   ,       lowerCamelCase_  )

														lowerCAmelCase__			  =      version.parse(PIL.__version__  ) < version.parse('''9.0.0'''  )

														if is_pillow_less_than_a:
																					lowerCAmelCase__			  =      torch.tensor(
																					    [
																					        [[-4.9_225, -2.3_954, -3.0_522], [-2.8_822, -1.0_046, -1.7_561], [-2.9_549, -1.3_228, -2.1_347]],
																					        [[-5.8_168, -3.4_129, -4.0_778], [-3.8_651, -2.2_214, -3.0_277], [-3.8_356, -2.4_643, -3.3_535]],
																					        [[-0.0_078, 3.9_952, 4.0_754], [2.9_856, 4.6_944, 5.0_035], [3.2_413, 4.7_813, 4.9_969]],
																					    ]   ,       device=lowerCamelCase_   ,       )
														else:
																					lowerCAmelCase__			  =      torch.tensor(
																					    [
																					        [[-4.8_960, -2.3_688, -3.0_355], [-2.8_478, -0.9_836, -1.7_418], [-2.9_449, -1.3_332, -2.1_456]],
																					        [[-5.8_081, -3.4_124, -4.1_006], [-3.8_561, -2.2_081, -3.0_323], [-3.8_365, -2.4_601, -3.3_669]],
																					        [[-0.0_309, 3.9_868, 4.0_540], [2.9_640, 4.6_877, 4.9_976], [3.2_081, 4.7_690, 4.9_942]],
																					    ]   ,       device=lowerCamelCase_   ,       )

														self.assertTrue(torch.allclose(logits[0, :3, :3, :3]   ,       lowerCamelCase_   ,       atol=1e-4  )  )







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      BeitForSemanticSegmentation.from_pretrained('''microsoft/beit-base-finetuned-ade-640-640'''  )
														lowerCAmelCase__			  =      model.to(lowerCamelCase_  )

														lowerCAmelCase__			  =      BeitImageProcessor(do_resize=lowerCamelCase_   ,       size=6_40   ,       do_center_crop=lowerCamelCase_  )

														lowerCAmelCase__			  =      load_dataset('''hf-internal-testing/fixtures_ade20k'''   ,       split='''test'''  )
														lowerCAmelCase__			  =      Image.open(ds[0]['''file''']  )
														lowerCAmelCase__			  =      image_processor(images=lowerCamelCase_   ,       return_tensors='''pt'''  ).to(lowerCamelCase_  )

														# forward pass
														with torch.no_grad():
																					lowerCAmelCase__			  =      model(**lowerCamelCase_  )

														lowerCAmelCase__			  =      outputs.logits.detach().cpu()

														lowerCAmelCase__			  =      image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase_   ,       target_sizes=[(5_00, 3_00)]  )
														lowerCAmelCase__			  =      torch.Size((5_00, 3_00)  )
														self.assertEqual(segmentation[0].shape   ,       lowerCamelCase_  )

														lowerCAmelCase__			  =      image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase_  )
														lowerCAmelCase__			  =      torch.Size((1_60, 1_60)  )
														self.assertEqual(segmentation[0].shape   ,       lowerCamelCase_  )



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



		"""simple docstring"""

		def 					__A   ( self	)  -> Dict:







					'''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(A	)







		def 					__A   ( self	)  -> Tuple:







					'''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(A	) as cl:
											logger.warning(A	)
								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(A	) as cl:
								logger.warning(A	)
					self.assertEqual(cl.out		,      """"""	)

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

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







		@mockenv(TRANSFORMERS_VERBOSITY="""error"""	)
		def 					__A   ( self	)  -> Union[str, Any]:







					'''simple docstring'''







					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"""		,      A	)
					lowerCamelCase    		=  logging.log_levels[env_level_str]

					lowerCamelCase    		=  logging.get_verbosity()
					self.assertEqual(
					    A		,      A		,      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 					__A   ( self	)  -> Union[str, Any]:







					'''simple docstring'''







					transformers.utils.logging._reset_library_root_logger()
					lowerCamelCase    		=  logging.logging.getLogger()
					with CaptureLogger(A	) 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 					__A   ( self	)  -> Optional[Any]:







					'''simple docstring'''







					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(A	) as cl:
											logger.warning_advice(A	)
								self.assertEqual(cl.out		,      """"""	)

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






def 	__lowerCamelCase						(							):





			'''simple docstring'''




			disable_progress_bar()
			assert are_progress_bars_disabled()

			enable_progress_bar()
			assert not are_progress_bars_disabled()

