


"""simple docstring"""







import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
		import torch

if is_vision_available():
		from PIL import Image

		from transformers import ChineseCLIPImageProcessor




class 					UpperCamelCase_      (					unittest.TestCase):

	"""simple docstring"""





	def __init__(					self     :							Dict     ,     UpperCAmelCase__     :							int     ,     UpperCAmelCase__     :							Optional[Any]=7     ,     UpperCAmelCase__     :							Optional[int]=3     ,     UpperCAmelCase__     :							Union[str, Any]=1_8     ,     UpperCAmelCase__     :							Union[str, Any]=3_0     ,     UpperCAmelCase__     :							int=4_0_0     ,     UpperCAmelCase__     :							Any=True     ,     UpperCAmelCase__     :							List[str]=None     ,     UpperCAmelCase__     :							List[Any]=True     ,     UpperCAmelCase__     :							Optional[int]=None     ,     UpperCAmelCase__     :							Optional[Any]=True     ,     UpperCAmelCase__     :							Tuple=[0.48_145_466, 0.4_578_275, 0.40_821_073]     ,     UpperCAmelCase__     :							str=[0.26_862_954, 0.26_130_258, 0.27_577_711]     ,     UpperCAmelCase__     :							Tuple=True     ,     )			->      List[Any]:
						__SCREAMING_SNAKE_CASE		  =							size if size is not None else {"height": 2_2_4, "width": 2_2_4}
						__SCREAMING_SNAKE_CASE		  =							crop_size if crop_size is not None else {"height": 1_8, "width": 1_8}
						__SCREAMING_SNAKE_CASE		  =							parent
						__SCREAMING_SNAKE_CASE		  =							batch_size
						__SCREAMING_SNAKE_CASE		  =							num_channels
						__SCREAMING_SNAKE_CASE		  =							image_size
						__SCREAMING_SNAKE_CASE		  =							min_resolution
						__SCREAMING_SNAKE_CASE		  =							max_resolution
						__SCREAMING_SNAKE_CASE		  =							do_resize
						__SCREAMING_SNAKE_CASE		  =							size
						__SCREAMING_SNAKE_CASE		  =							do_center_crop
						__SCREAMING_SNAKE_CASE		  =							crop_size
						__SCREAMING_SNAKE_CASE		  =							do_normalize
						__SCREAMING_SNAKE_CASE		  =							image_mean
						__SCREAMING_SNAKE_CASE		  =							image_std
						__SCREAMING_SNAKE_CASE		  =							do_convert_rgb




	def     UpperCAmelCase_ (					self     :							Dict  )			->      Any:
						return {
						    "do_resize": self.do_resize,
						    "size": self.size,
						    "do_center_crop": self.do_center_crop,
						    "crop_size": self.crop_size,
						    "do_normalize": self.do_normalize,
						    "image_mean": self.image_mean,
						    "image_std": self.image_std,
						    "do_convert_rgb": self.do_convert_rgb,
						}




	def     UpperCAmelCase_ (					self     :							List[Any]     ,     UpperCAmelCase__     :							Tuple=False     ,     UpperCAmelCase__     :							Dict=False     ,     UpperCAmelCase__     :							List[Any]=False  )			->      Union[str, Any]:
						assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

						if equal_resolution:
											__SCREAMING_SNAKE_CASE		  =							[]
											for i in range(self.batch_size  ):
																image_inputs.append(
																    np.random.randint(
																        2_5_5     ,     size=(self.num_channels, self.max_resolution, self.max_resolution)     ,     dtype=np.uinta  )  )
						else:
											__SCREAMING_SNAKE_CASE		  =							[]
											for i in range(self.batch_size  ):
																__SCREAMING_SNAKE_CASE  ,    __SCREAMING_SNAKE_CASE		  =							np.random.choice(np.arange(self.min_resolution     ,     self.max_resolution  )     ,     2  )
																image_inputs.append(np.random.randint(2_5_5     ,     size=(self.num_channels, width, height)     ,     dtype=np.uinta  )  )

						if not numpify and not torchify:
											# PIL expects the channel dimension as last dimension
											__SCREAMING_SNAKE_CASE		  =							[Image.fromarray(np.moveaxis(__snake_case     ,     0     ,     -1  )  ) for x in image_inputs]

						if torchify:
											__SCREAMING_SNAKE_CASE		  =							[torch.from_numpy(__snake_case  ) for x in image_inputs]

						return image_inputs




@require_torch
@require_vision
class 					UpperCamelCase_      (					A__     ,    unittest.TestCase):

	"""simple docstring"""





	snake_case__							:    Optional[int]          =     ChineseCLIPImageProcessor if is_vision_available() else None




	def     UpperCAmelCase_ (					self     :							Union[str, Any]  )			->      Union[str, Any]:
						__SCREAMING_SNAKE_CASE		  =							ChineseCLIPImageProcessingTester(self     ,     do_center_crop=__snake_case  )




	@property
	def     UpperCAmelCase_ (					self     :							int  )			->      List[str]:
						return self.image_processor_tester.prepare_image_processor_dict()




	def     UpperCAmelCase_ (					self     :							List[str]  )			->      int:
						__SCREAMING_SNAKE_CASE		  =							self.image_processing_class(**self.image_processor_dict  )
						self.assertTrue(hasattr(__snake_case     ,     "do_resize"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "size"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "do_center_crop"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "center_crop"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "do_normalize"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "image_mean"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "image_std"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "do_convert_rgb"  )  )




	def     UpperCAmelCase_ (					self     :							Tuple  )			->      Optional[int]:
						__SCREAMING_SNAKE_CASE		  =							self.image_processing_class.from_dict(self.image_processor_dict  )
						self.assertEqual(image_processor.size     ,     {"height": 2_2_4, "width": 2_2_4}  )
						self.assertEqual(image_processor.crop_size     ,     {"height": 1_8, "width": 1_8}  )

						__SCREAMING_SNAKE_CASE		  =							self.image_processing_class.from_dict(self.image_processor_dict     ,     size=4_2     ,     crop_size=8_4  )
						self.assertEqual(image_processor.size     ,     {"shortest_edge": 4_2}  )
						self.assertEqual(image_processor.crop_size     ,     {"height": 8_4, "width": 8_4}  )




	def     UpperCAmelCase_ (					self     :							Any  )			->      Union[str, Any]:
						pass




	def     UpperCAmelCase_ (					self     :							int  )			->      List[Any]:
						# Initialize image_processing
						__SCREAMING_SNAKE_CASE		  =							self.image_processing_class(**self.image_processor_dict  )
						# create random PIL images
						__SCREAMING_SNAKE_CASE		  =							self.image_processor_tester.prepare_inputs(equal_resolution=__snake_case  )
						for image in image_inputs:
											self.assertIsInstance(__snake_case     ,     Image.Image  )

						# Test not batched input
						__SCREAMING_SNAKE_CASE		  =							image_processing(image_inputs[0]     ,     return_tensors="pt"  ).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,     (
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size["height"],
						        self.image_processor_tester.crop_size["width"],
						    )     ,     )

						# Test batched
						__SCREAMING_SNAKE_CASE		  =							image_processing(__snake_case     ,     return_tensors="pt"  ).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,     (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size["height"],
						        self.image_processor_tester.crop_size["width"],
						    )     ,     )




	def     UpperCAmelCase_ (					self     :							Tuple  )			->      Optional[int]:
						# Initialize image_processing
						__SCREAMING_SNAKE_CASE		  =							self.image_processing_class(**self.image_processor_dict  )
						# create random numpy tensors
						__SCREAMING_SNAKE_CASE		  =							self.image_processor_tester.prepare_inputs(equal_resolution=__snake_case     ,     numpify=__snake_case  )
						for image in image_inputs:
											self.assertIsInstance(__snake_case     ,     np.ndarray  )

						# Test not batched input
						__SCREAMING_SNAKE_CASE		  =							image_processing(image_inputs[0]     ,     return_tensors="pt"  ).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,     (
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size["height"],
						        self.image_processor_tester.crop_size["width"],
						    )     ,     )

						# Test batched
						__SCREAMING_SNAKE_CASE		  =							image_processing(__snake_case     ,     return_tensors="pt"  ).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,     (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size["height"],
						        self.image_processor_tester.crop_size["width"],
						    )     ,     )




	def     UpperCAmelCase_ (					self     :							List[Any]  )			->      List[Any]:
						# Initialize image_processing
						__SCREAMING_SNAKE_CASE		  =							self.image_processing_class(**self.image_processor_dict  )
						# create random PyTorch tensors
						__SCREAMING_SNAKE_CASE		  =							self.image_processor_tester.prepare_inputs(equal_resolution=__snake_case     ,     torchify=__snake_case  )
						for image in image_inputs:
											self.assertIsInstance(__snake_case     ,     torch.Tensor  )

						# Test not batched input
						__SCREAMING_SNAKE_CASE		  =							image_processing(image_inputs[0]     ,     return_tensors="pt"  ).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,     (
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size["height"],
						        self.image_processor_tester.crop_size["width"],
						    )     ,     )

						# Test batched
						__SCREAMING_SNAKE_CASE		  =							image_processing(__snake_case     ,     return_tensors="pt"  ).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,     (
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.crop_size["height"],
						        self.image_processor_tester.crop_size["width"],
						    )     ,     )




@require_torch
@require_vision
class 					UpperCamelCase_      (					A__     ,    unittest.TestCase):

	"""simple docstring"""





	snake_case__							:    Any          =     ChineseCLIPImageProcessor if is_vision_available() else None




	def     UpperCAmelCase_ (					self     :							List[str]  )			->      Optional[int]:
						__SCREAMING_SNAKE_CASE		  =							ChineseCLIPImageProcessingTester(self     ,     num_channels=4     ,     do_center_crop=__snake_case  )
						__SCREAMING_SNAKE_CASE		  =							3




	@property
	def     UpperCAmelCase_ (					self     :							Union[str, Any]  )			->      Any:
						return self.image_processor_tester.prepare_image_processor_dict()




	def     UpperCAmelCase_ (					self     :							Dict  )			->      int:
						__SCREAMING_SNAKE_CASE		  =							self.image_processing_class(**self.image_processor_dict  )
						self.assertTrue(hasattr(__snake_case     ,     "do_resize"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "size"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "do_center_crop"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "center_crop"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "do_normalize"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "image_mean"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "image_std"  )  )
						self.assertTrue(hasattr(__snake_case     ,     "do_convert_rgb"  )  )




	def     UpperCAmelCase_ (					self     :							Union[str, Any]  )			->      Any:
						pass




	def     UpperCAmelCase_ (					self     :							Tuple  )			->      int:
						# Initialize image_processing
						__SCREAMING_SNAKE_CASE		  =							self.image_processing_class(**self.image_processor_dict  )
						# create random PIL images
						__SCREAMING_SNAKE_CASE		  =							self.image_processor_tester.prepare_inputs(equal_resolution=__snake_case  )
						for image in image_inputs:
											self.assertIsInstance(__snake_case     ,     Image.Image  )

						# Test not batched input
						__SCREAMING_SNAKE_CASE		  =							image_processing(image_inputs[0]     ,     return_tensors="pt"  ).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,     (
						        1,
						        self.expected_encoded_image_num_channels,
						        self.image_processor_tester.crop_size["height"],
						        self.image_processor_tester.crop_size["width"],
						    )     ,     )

						# Test batched
						__SCREAMING_SNAKE_CASE		  =							image_processing(__snake_case     ,     return_tensors="pt"  ).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,     (
						        self.image_processor_tester.batch_size,
						        self.expected_encoded_image_num_channels,
						        self.image_processor_tester.crop_size["height"],
						        self.image_processor_tester.crop_size["width"],
						    )     ,     )







'''simple docstring'''




import inspect
import os
import re

from transformers.configuration_utils import PretrainedConfig
from transformers.utils import direct_transformers_import


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_config_docstrings.py
_SCREAMING_SNAKE_CASE							     =			"src/transformers"


# This is to make sure the transformers module imported is the one in the repo.
_SCREAMING_SNAKE_CASE							     =			direct_transformers_import(PATH_TO_TRANSFORMERS)

_SCREAMING_SNAKE_CASE							     =			transformers.models.auto.configuration_auto.CONFIG_MAPPING

_SCREAMING_SNAKE_CASE							     =			{
    # used to compute the property `self.chunk_length`
    "EncodecConfig": ["overlap"],
    # used as `self.bert_model = BertModel(config, ...)`
    "DPRConfig": True,
    # not used in modeling files, but it's an important information
    "FSMTConfig": ["langs"],
    # used internally in the configuration class file
    "GPTNeoConfig": ["attention_types"],
    # used internally in the configuration class file
    "EsmConfig": ["is_folding_model"],
    # used during training (despite we don't have training script for these models yet)
    "Mask2FormerConfig": ["ignore_value"],
    # `ignore_value` used during training (despite we don't have training script for these models yet)
    # `norm` used in conversion script (despite not using in the modeling file)
    "OneFormerConfig": ["ignore_value", "norm"],
    # used during preprocessing and collation, see `collating_graphormer.py`
    "GraphormerConfig": ["spatial_pos_max"],
    # used internally in the configuration class file
    "T5Config": ["feed_forward_proj"],
    # used internally in the configuration class file
    # `tokenizer_class` get default value `T5Tokenizer` intentionally
    "MT5Config": ["feed_forward_proj", "tokenizer_class"],
    "UMT5Config": ["feed_forward_proj", "tokenizer_class"],
    # used internally in the configuration class file
    "LongT5Config": ["feed_forward_proj"],
    # used internally in the configuration class file
    "SwitchTransformersConfig": ["feed_forward_proj"],
    # having default values other than `1e-5` - we can't fix them without breaking
    "BioGptConfig": ["layer_norm_eps"],
    # having default values other than `1e-5` - we can't fix them without breaking
    "GLPNConfig": ["layer_norm_eps"],
    # having default values other than `1e-5` - we can't fix them without breaking
    "SegformerConfig": ["layer_norm_eps"],
    # having default values other than `1e-5` - we can't fix them without breaking
    "CvtConfig": ["layer_norm_eps"],
    # having default values other than `1e-5` - we can't fix them without breaking
    "PerceiverConfig": ["layer_norm_eps"],
    # used internally to calculate the feature size
    "InformerConfig": ["num_static_real_features", "num_time_features"],
    # used internally to calculate the feature size
    "TimeSeriesTransformerConfig": ["num_static_real_features", "num_time_features"],
    # used internally to calculate the feature size
    "AutoformerConfig": ["num_static_real_features", "num_time_features"],
    # used internally to calculate `mlp_dim`
    "SamVisionConfig": ["mlp_ratio"],
    # For (head) training, but so far not implemented
    "ClapAudioConfig": ["num_classes"],
    # Not used, but providing useful information to users
    "SpeechT5HifiGanConfig": ["sampling_rate"],
}


# TODO (ydshieh): Check the failing cases, try to fix them or move some cases to the above block once we are sure
SPECIAL_CASES_TO_ALLOW.update(
    {
        "CLIPSegConfig": True,
        "DeformableDetrConfig": True,
        "DetaConfig": True,
        "DinatConfig": True,
        "DonutSwinConfig": True,
        "EfficientFormerConfig": True,
        "FSMTConfig": True,
        "JukeboxConfig": True,
        "LayoutLMv2Config": True,
        "MaskFormerSwinConfig": True,
        "MT5Config": True,
        "NatConfig": True,
        "OneFormerConfig": True,
        "PerceiverConfig": True,
        "RagConfig": True,
        "SpeechT5Config": True,
        "SwinConfig": True,
        "Swin2SRConfig": True,
        "Swinv2Config": True,
        "SwitchTransformersConfig": True,
        "TableTransformerConfig": True,
        "TapasConfig": True,
        "TransfoXLConfig": True,
        "UniSpeechConfig": True,
        "UniSpeechSatConfig": True,
        "WavLMConfig": True,
        "WhisperConfig": True,
        # TODO: @Arthur (for `alignment_head` and `alignment_layer`)
        "JukeboxPriorConfig": True,
        # TODO: @Younes (for `is_decoder`)
        "Pix2StructTextConfig": True,
    }
)





def 	__lowerCamelCase			(      __lowerCAmelCase       :							Any      ,    __lowerCAmelCase       :							Dict      ,    __lowerCAmelCase       :							List[str]      ,    __lowerCAmelCase       :							Union[str, Any]		)		->  List[Any]:
   snake_case 						=   False
   for attribute in attributes:
      for modeling_source in source_strings:
         # check if we can find `config.xxx`, `getattr(config, "xxx", ...)` or `getattr(self.config, "xxx", ...)`
         if (
             F'''config.{attribute}''' in modeling_source
             or F'''getattr(config, "{attribute}"''' in modeling_source
             or F'''getattr(self.config, "{attribute}"''' in modeling_source
         ):
            snake_case 						=   True
         # Deal with multi-line cases
         elif (
             re.search(
                 rF'''getattr[ \t\v\n\r\f]*\([ \t\v\n\r\f]*(self\.)?config,[ \t\v\n\r\f]*"{attribute}"'''      ,    __lowerCAmelCase      ,    )
             is not None
         ):
            snake_case 						=   True
         # `SequenceSummary` is called with `SequenceSummary(config)`
         elif attribute in [
             "summary_type",
             "summary_use_proj",
             "summary_activation",
             "summary_last_dropout",
             "summary_proj_to_labels",
             "summary_first_dropout",
         ]:
            if "SequenceSummary" in modeling_source:
               snake_case 						=   True
         if attribute_used:
            break
      if attribute_used:
         break

    # common and important attributes, even if they do not always appear in the modeling files
   snake_case 						=   [
       """bos_index""",
       """eos_index""",
       """pad_index""",
       """unk_index""",
       """mask_index""",
       """image_size""",
       """use_cache""",
       """out_features""",
       """out_indices""",
   ]
   snake_case 						=   ["""encoder_no_repeat_ngram_size"""]

   # Special cases to be allowed
   snake_case 						=   True
   if not attribute_used:
      snake_case 						=   False
      for attribute in attributes:
         # Allow if the default value in the configuration class is different from the one in `PretrainedConfig`
         if attribute in ["is_encoder_decoder"] and default_value is True:
            snake_case 						=   True
         elif attribute in ["tie_word_embeddings"] and default_value is False:
            snake_case 						=   True

         # Allow cases without checking the default value in the configuration class
         elif attribute in attributes_to_allow + attributes_used_in_generation:
            snake_case 						=   True
         elif attribute.endswith("""_token_id"""		):
            snake_case 						=   True

         # configuration class specific cases
         if not case_allowed:
            snake_case 						=   SPECIAL_CASES_TO_ALLOW.get(config_class.__name__      ,    []		)
            snake_case 						=   allowed_cases is True or attribute in allowed_cases

   return attribute_used or case_allowed





def 	__lowerCamelCase			(      __lowerCAmelCase       :							Union[str, Any]		)		->  List[Any]:
   snake_case 						=   dict(inspect.signature(config_class.__init__		).parameters		)
   snake_case 						=   [x for x in list(signature.keys()		) if x not in ["""self""", """kwargs"""]]
   snake_case 						=   [signature[param].default for param in parameter_names]

   # If `attribute_map` exists, an attribute can have different names to be used in the modeling files, and as long
   # as one variant is used, the test should pass
   snake_case 						=   {}
   if len(config_class.attribute_map		) > 0:
      snake_case 						=   {v: k for k, v in config_class.attribute_map.items()}

   # Get the path to modeling source files
   snake_case 						=   inspect.getsourcefile(__lowerCAmelCase		)
   snake_case 						=   os.path.dirname(__lowerCAmelCase		)
   # Let's check against all frameworks: as long as one framework uses an attribute, we are good.
   snake_case 						=   [os.path.join(__lowerCAmelCase      ,    __lowerCAmelCase		) for fn in os.listdir(__lowerCAmelCase		) if fn.startswith("""modeling_"""		)]

   # Get the source code strings
   snake_case 						=   []
   for path in modeling_paths:
      if os.path.isfile(__lowerCAmelCase		):
         with open(__lowerCAmelCase		) as fp:
            modeling_sources.append(fp.read()		)

   snake_case 						=   []
   for config_param, default_value in zip(__lowerCAmelCase      ,    __lowerCAmelCase		):
      # `attributes` here is all the variant names for `config_param`
      snake_case 						=   [config_param]
      # some configuration classes have non-empty `attribute_map`, and both names could be used in the
      # corresponding modeling files. As long as one of them appears, it is fine.
      if config_param in reversed_attribute_map:
         attributes.append(reversed_attribute_map[config_param]		)

      if not check_attribute_being_used(__lowerCAmelCase      ,    __lowerCAmelCase      ,    __lowerCAmelCase      ,    __lowerCAmelCase		):
         unused_attributes.append(attributes[0]		)

   return sorted(__lowerCAmelCase		)





def 	__lowerCamelCase			(      )		->  Optional[Any]:
   snake_case 						=   {}
   for _config_class in list(CONFIG_MAPPING.values()		):
      # Skip deprecated models
      if "models.deprecated" in _config_class.__module__:
         continue
      # Some config classes are not in `CONFIG_MAPPING` (e.g. `CLIPVisionConfig`, `Blip2VisionConfig`, etc.)
      snake_case 						=   [
          cls
          for name, cls in inspect.getmembers(
              inspect.getmodule(_config_class		)      ,    lambda __lowerCAmelCase		: inspect.isclass(__lowerCAmelCase		)
              and issubclass(__lowerCAmelCase      ,    __lowerCAmelCase		)
              and inspect.getmodule(__lowerCAmelCase		) == inspect.getmodule(_config_class		)      ,    )
      ]
      for config_class in config_classes_in_module:
         snake_case 						=   check_config_attributes_being_used(__lowerCAmelCase		)
         if len(__lowerCAmelCase		) > 0:
            snake_case 						=   unused_attributes

   if len(__lowerCAmelCase		) > 0:
      snake_case 						=   """The following configuration classes contain unused attributes in the corresponding modeling files:\n"""
      for name, attributes in configs_with_unused_attributes.items():
         error += F'''{name}: {attributes}\n'''

      raise ValueError(__lowerCAmelCase		)


if __name__ == "__main__":
 check_config_attributes()

