



'''simple docstring'''






from __future__ import annotations

import inspect
import unittest

from transformers import ViTConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
   import tensorflow as tf

   from transformers import TFViTForImageClassification, TFViTModel


if is_vision_available():
   from PIL import Image

   from transformers import ViTImageProcessor



class 							lowercase       :


 """simple docstring"""


 def __init__(							self  ,a_  ,a_=13  ,a_=30  ,a_=2  ,a_=3  ,a_=True  ,a_=True  ,a_=32  ,a_=2  ,a_=4  ,a_=37  ,a_="gelu"  ,a_=0.1  ,a_=0.1  ,a_=10  ,a_=0.02  ,a_=3  ,a_=None  ,)		->   Dict:
        _UpperCAmelCase  :						int			     = parent
        _UpperCAmelCase  :						int			     = batch_size
        _UpperCAmelCase  :						int			     = image_size
        _UpperCAmelCase  :						Tuple			     = patch_size
        _UpperCAmelCase  :						int			     = num_channels
        _UpperCAmelCase  :						List[str]			     = is_training
        _UpperCAmelCase  :						List[str]			     = use_labels
        _UpperCAmelCase  :						Tuple			     = hidden_size
        _UpperCAmelCase  :						Union[str, Any]			     = num_hidden_layers
        _UpperCAmelCase  :						str			     = num_attention_heads
        _UpperCAmelCase  :						Dict			     = intermediate_size
        _UpperCAmelCase  :						Tuple			     = hidden_act
        _UpperCAmelCase  :						List[Any]			     = hidden_dropout_prob
        _UpperCAmelCase  :						int			     = attention_probs_dropout_prob
        _UpperCAmelCase  :						int			     = type_sequence_label_size
        _UpperCAmelCase  :						Dict			     = initializer_range
        _UpperCAmelCase  :						List[str]			     = scope

        # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
        _UpperCAmelCase  :						str			     = (image_size // patch_size) ** 2
        _UpperCAmelCase  :						Union[str, Any]			     = num_patches + 1







 def _snake_case (							self							)		->   List[str]:
        _UpperCAmelCase  :						Any			     = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

        _UpperCAmelCase  :						List[str]			     = None
        if self.use_labels:
               _UpperCAmelCase  :						List[Any]			     = ids_tensor([self.batch_size]  ,self.type_sequence_label_size							)

        _UpperCAmelCase  :						str			     = self.get_config()

        return config, pixel_values, labels







 def _snake_case (							self							)		->   Optional[int]:
        return ViTConfig(
            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=a_  ,initializer_range=self.initializer_range  ,)







 def _snake_case (							self  ,a_  ,a_  ,a_							)		->   str:
        _UpperCAmelCase  :						Any			     = TFViTModel(config=a_							)
        _UpperCAmelCase  :						int			     = model(a_  ,training=a_							)
        self.parent.assertEqual(result.last_hidden_state.shape  ,(self.batch_size, self.seq_length, self.hidden_size)							)

        # Test with an image with different size than the one specified in config.
        _UpperCAmelCase  :						Tuple			     = self.image_size // 2
        _UpperCAmelCase  :						Any			     = pixel_values[:, :, :image_size, :image_size]
        _UpperCAmelCase  :						Tuple			     = model(a_  ,interpolate_pos_encoding=a_  ,training=a_							)
        _UpperCAmelCase  :						int			     = (image_size // self.patch_size) ** 2 + 1
        self.parent.assertEqual(result.last_hidden_state.shape  ,(self.batch_size, seq_length, self.hidden_size)							)







 def _snake_case (							self  ,a_  ,a_  ,a_							)		->   Any:
        _UpperCAmelCase  :						Tuple			     = self.type_sequence_label_size
        _UpperCAmelCase  :						List[str]			     = TFViTForImageClassification(a_							)
        _UpperCAmelCase  :						int			     = model(a_  ,labels=a_  ,training=a_							)
        self.parent.assertEqual(result.logits.shape  ,(self.batch_size, self.type_sequence_label_size)							)

        # Test with an image with different size than the one specified in config.
        _UpperCAmelCase  :						str			     = self.image_size // 2
        _UpperCAmelCase  :						Optional[int]			     = pixel_values[:, :, :image_size, :image_size]
        _UpperCAmelCase  :						List[Any]			     = model(a_  ,interpolate_pos_encoding=a_  ,training=a_							)
        self.parent.assertEqual(result.logits.shape  ,(self.batch_size, self.type_sequence_label_size)							)

        # test greyscale images
        _UpperCAmelCase  :						Any			     = 1
        _UpperCAmelCase  :						Optional[Any]			     = TFViTForImageClassification(a_							)
        _UpperCAmelCase  :						Optional[Any]			     = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]							)
        _UpperCAmelCase  :						Dict			     = model(a_							)
        self.parent.assertEqual(result.logits.shape  ,(self.batch_size, self.type_sequence_label_size)							)







 def _snake_case (							self							)		->   Any:
        _UpperCAmelCase  :						int			     = self.prepare_config_and_inputs()
        _UpperCAmelCase     ,_UpperCAmelCase     ,_UpperCAmelCase  :						List[str]			     = config_and_inputs
        _UpperCAmelCase  :						Union[str, Any]			     = {"""pixel_values""": pixel_values}
        return config, inputs_dict







@require_tf
class 							lowercase       (  _lowerCamelCase					,					_lowerCamelCase					,					unittest.TestCase				):


 """simple docstring"""


 UpperCAmelCase							=  (TFViTModel, TFViTForImageClassification) if is_tf_available() else ()
 UpperCAmelCase							=  (
     {"""feature-extraction""": TFViTModel, """image-classification""": TFViTForImageClassification}
     if is_tf_available()
     else {}
 )

 UpperCAmelCase							=  False
 UpperCAmelCase							=  False
 UpperCAmelCase							=  False







 def _snake_case (							self							)		->   Any:
        _UpperCAmelCase  :						List[Any]			     = TFViTModelTester(self							)
        _UpperCAmelCase  :						List[Any]			     = ConfigTester(self  ,config_class=a_  ,has_text_modality=a_  ,hidden_size=37							)







 def _snake_case (							self							)		->   Tuple:
        self.config_tester.run_common_tests()







 @unittest.skip(reason="""ViT does not use inputs_embeds"""							)
 def _snake_case (							self							)		->   str:
        pass







 @unittest.skip(reason="""ViT does not use inputs_embeds"""							)
 def _snake_case (							self							)		->   Any:
        pass







 def _snake_case (							self							)		->   List[Any]:
        _UpperCAmelCase     ,_UpperCAmelCase  :						Optional[int]			     = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
               _UpperCAmelCase  :						str			     = model_class(a_							)
               self.assertIsInstance(model.get_input_embeddings()  ,(tf.keras.layers.Layer)							)
               _UpperCAmelCase  :						List[str]			     = model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(a_  ,tf.keras.layers.Layer							)							)







 def _snake_case (							self							)		->   Optional[Any]:
        _UpperCAmelCase     ,_UpperCAmelCase  :						Tuple			     = self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
               _UpperCAmelCase  :						List[str]			     = model_class(a_							)
               _UpperCAmelCase  :						Union[str, Any]			     = inspect.signature(model.call							)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               _UpperCAmelCase  :						Optional[int]			     = [*signature.parameters.keys()]

               _UpperCAmelCase  :						Dict			     = ["""pixel_values"""]
               self.assertListEqual(arg_names[:1]  ,a_							)







 def _snake_case (							self							)		->   List[Any]:
        _UpperCAmelCase  :						int			     = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*a_							)







 def _snake_case (							self							)		->   Optional[int]:
        _UpperCAmelCase  :						Any			     = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*a_							)







 @slow
 def _snake_case (							self							)		->   int:
        _UpperCAmelCase  :						Union[str, Any]			     = TFViTModel.from_pretrained("""google/vit-base-patch16-224"""							)
        self.assertIsNotNone(a_							)







def     snake_case_					(     )->		Optional[int]:





       '''simple docstring'''


       _UpperCAmelCase  :						Tuple			     = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		)
       return image



@require_tf
@require_vision
class 							lowercase       (  unittest.TestCase				):


 """simple docstring"""


 @cached_property
 def _snake_case (							self							)		->   Union[str, Any]:
        return ViTImageProcessor.from_pretrained("""google/vit-base-patch16-224"""							) if is_vision_available() else None







 @slow
 def _snake_case (							self							)		->   List[str]:
        _UpperCAmelCase  :						Optional[Any]			     = TFViTForImageClassification.from_pretrained("""google/vit-base-patch16-224"""							)

        _UpperCAmelCase  :						str			     = self.default_image_processor
        _UpperCAmelCase  :						Tuple			     = prepare_img()
        _UpperCAmelCase  :						Tuple			     = image_processor(images=a_  ,return_tensors="""tf"""							)

        # forward pass
        _UpperCAmelCase  :						Union[str, Any]			     = model(**a_							)

        # verify the logits
        _UpperCAmelCase  :						List[str]			     = tf.TensorShape((1, 1_000)							)
        self.assertEqual(outputs.logits.shape  ,a_							)

        _UpperCAmelCase  :						Any			     = tf.constant([-0.2744, 0.8215, -0.0836]							)

        tf.debugging.assert_near(outputs.logits[0, :3]  ,a_  ,atol=1E-4							)








'''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
A_							: List[str]						 =	"""src/transformers"""


# This is to make sure the transformers module imported is the one in the repo.
A_							: Optional[Any]						 =	direct_transformers_import(PATH_TO_TRANSFORMERS)

A_							: Union[str, Any]						 =	transformers.models.auto.configuration_auto.CONFIG_MAPPING

A_							: Dict						 =	{
    # 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     snake_case_					(     lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_       ,   lowerCAmelCase_		)->		Dict:





       '''simple docstring'''


       _UpperCAmelCase  :						Optional[Any]			     = 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
                     ):
                            _UpperCAmelCase  :						Tuple			     = 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
                     ):
                            _UpperCAmelCase  :						Any			     = 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:
                                   _UpperCAmelCase  :						List[str]			     = True
                     if attribute_used:
                            break
              if attribute_used:
                     break

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

       # Special cases to be allowed
       _UpperCAmelCase  :						Optional[Any]			     = True
       if not attribute_used:
              _UpperCAmelCase  :						List[Any]			     = 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:
                            _UpperCAmelCase  :						Tuple			     = True
                     elif attribute in ["tie_word_embeddings"] and default_value is False:
                            _UpperCAmelCase  :						Any			     = True

                     # Allow cases without checking the default value in the configuration class
                     elif attribute in attributes_to_allow + attributes_used_in_generation:
                            _UpperCAmelCase  :						Dict			     = True
                     elif attribute.endswith("""_token_id"""		):
                            _UpperCAmelCase  :						Optional[int]			     = True

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

       return attribute_used or case_allowed




def     snake_case_					(     lowerCAmelCase_		)->		Optional[Any]:





       '''simple docstring'''


       _UpperCAmelCase  :						Optional[int]			     = dict(inspect.signature(config_class.__init__		).parameters		)
       _UpperCAmelCase  :						Optional[int]			     = [x for x in list(signature.keys()		) if x not in ["""self""", """kwargs"""]]
       _UpperCAmelCase  :						Optional[int]			     = [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
       _UpperCAmelCase  :						List[Any]			     = {}
       if len(config_class.attribute_map		) > 0:
              _UpperCAmelCase  :						Optional[int]			     = {v: k for k, v in config_class.attribute_map.items()}

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

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

       _UpperCAmelCase  :						Any			     = []
       for config_param, default_value in zip(lowerCAmelCase_       ,   lowerCAmelCase_		):
              # `attributes` here is all the variant names for `config_param`
              _UpperCAmelCase  :						List[str]			     = [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     snake_case_					(     )->		Optional[Any]:





       '''simple docstring'''


       _UpperCAmelCase  :						Dict			     = {}
       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.)
              _UpperCAmelCase  :						List[Any]			     = [
                  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:
                     _UpperCAmelCase  :						Optional[int]			     = check_config_attributes_being_used(lowerCAmelCase_		)
                     if len(lowerCAmelCase_		) > 0:
                            _UpperCAmelCase  :						Tuple			     = unused_attributes

       if len(lowerCAmelCase_		) > 0:
              _UpperCAmelCase  :						Dict			     = """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()



