






import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import MaMaaaTokenizer, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)
from transformers.utils import is_sentencepiece_available


if is_sentencepiece_available():
  from transformers.models.mam_aaa.tokenization_mam_aaa import VOCAB_FILES_NAMES, save_json

from ...test_tokenization_common import TokenizerTesterMixin


if is_sentencepiece_available():
  __a      :       Dict				  =      get_tests_dir("fixtures/test_sentencepiece.model")


if is_torch_available():
  from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

__a      :       Tuple				  =      128022
__a      :       str				  =      128028


@require_sentencepiece
class       __lowercase      (	_UpperCamelCase			,      unittest.TestCase  ):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE   						=				MaMaaaTokenizer
     SCREAMING_SNAKE_CASE   						=				False
     SCREAMING_SNAKE_CASE   						=				False
     SCREAMING_SNAKE_CASE   						=				True




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         super().setUp()

         __A         =	["</s>", "<unk>", "▁This", "▁is", "▁a", "▁t", "est", "\u0120", "<pad>"]
         __A         =	dict(zip(__a ,	range(len(__a				)				)				)				)
         __A         =	Path(self.tmpdirname				)
         save_json(__a ,	save_dir / VOCAB_FILES_NAMES["""vocab_file"""]				)
         if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
             copyfile(__a ,	save_dir / VOCAB_FILES_NAMES["""spm_file"""]				)

         __A         =	MaMaaaTokenizer.from_pretrained(self.tmpdirname				)
         tokenizer.save_pretrained(self.tmpdirname				)




     def 		lowerCAmelCase_     (				self       :			Dict ,	**UpperCamelCase_       :			Dict				):


         """simple docstring"""



         return MaMaaaTokenizer.from_pretrained(self.tmpdirname ,	**__a				)




     def 		lowerCAmelCase_     (				self       :			str ,	UpperCamelCase_       :			Union[str, Any]				):


         """simple docstring"""



         return (
             "This is a test",
             "This is a test",
         )




     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	"</s>"
         __A         =	0

         self.assertEqual(self.get_tokenizer()._convert_token_to_id(__a				) ,	__a				)
         self.assertEqual(self.get_tokenizer()._convert_id_to_token(__a				) ,	__a				)




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         __A         =	self.get_tokenizer()
         __A         =	list(tokenizer.get_vocab().keys()				)

         self.assertEqual(vocab_keys[0] ,	"""</s>"""				)
         self.assertEqual(vocab_keys[1] ,	"""<unk>"""				)
         self.assertEqual(vocab_keys[-1] ,	"""<s>"""				)
         self.assertEqual(len(__a				) ,	tokenizer.vocab_size + len(tokenizer.get_added_vocab()				)				)




     @unittest.skip("""Skip this test while all models are still to be uploaded."""				)
     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         pass




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         __A         =	self.get_tokenizer()

         __A         =	tokenizer.tokenize("""This is a test"""				)
         self.assertListEqual(__a ,	["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]				)

         self.assertListEqual(
             tokenizer.convert_tokens_to_ids(__a				) ,	[2, 3, 4, 5, 6] ,	)

         __A         =	tokenizer.convert_ids_to_tokens([2, 3, 4, 5, 6]				)
         self.assertListEqual(__a ,	["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]				)

         __A         =	tokenizer.convert_tokens_to_string(__a				)
         self.assertEqual(__a ,	"""This is a test"""				)





     @slow
     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         __A         =	{"input_ids": [[128_022, 110_108, 397, 11, 38_272, 2_247, 124_811, 285, 18_105, 1_586, 207, 7, 39_534, 4_428, 397, 1_019, 18_105, 1_586, 207, 7, 41_337, 16_786, 241, 7, 20_214, 17, 125_690, 10_398, 7, 44_378, 58_069, 68_342, 7_798, 7_343, 11, 299, 33_310, 4, 158, 37_350, 94_077, 4_569, 299, 33_310, 90, 4, 52_840, 290, 4, 31_270, 112, 299, 682, 4, 52_840, 39_953, 14_079, 193, 52_519, 90_894, 17_894, 120_697, 11, 40_445, 551, 17, 1_019, 52_519, 90_894, 17_756, 963, 11, 40_445, 480, 17, 9_792, 1_120, 5_173, 1_393, 6_240, 16_786, 241, 120_996, 28, 1_245, 1_393, 118_240, 11_123, 1_019, 93_612, 2_691, 10_618, 98_058, 120_409, 1_928, 279, 4, 40_683, 367, 178, 207, 1_019, 103, 103_121, 506, 65_296, 5, 2], [128_022, 21_217, 367, 117, 125_450, 128, 719, 7, 7_308, 40, 93_612, 12_669, 1_116, 16_704, 71, 17_785, 3_699, 15_592, 35, 144, 9_584, 241, 11_943, 713, 950, 799, 2_247, 88_427, 150, 149, 118_813, 120_706, 1_019, 106_906, 81_518, 28, 1_224, 22_799, 397, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [128_022, 1_658, 123_311, 5_155, 5_578, 4_722, 279, 14_947, 2_366, 1_120, 1_197, 14, 1_348, 9_232, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
         # fmt: on

         self.tokenizer_integration_test_util(
             expected_encoding=__a ,	model_name="""facebook/m2m100_418M""" ,	revision="""c168bae485c864188cf9aa0e4108b0b6934dc91e""" ,	)


@require_torch
@require_sentencepiece
@require_tokenizers
class       __lowercase      (	unittest.TestCase  ):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE   						=				"facebook/m2m100_418M"
     SCREAMING_SNAKE_CASE   						=				[
         "In my opinion, there are two levels of response from the French government.",
         "NSA Affair Emphasizes Complete Lack of Debate on Intelligence",
     ]
     SCREAMING_SNAKE_CASE   						=				[
         "Selon moi, il y a deux niveaux de réponse de la part du gouvernement français.",
         "L'affaire NSA souligne l'absence totale de débat sur le renseignement",
     ]

     # fmt: off
     SCREAMING_SNAKE_CASE   						=				[EN_CODE, 5_93, 19_49, 11_57_81, 4, 7_15_86, 42_34, 6_06_33, 12_62_33, 4_32, 12_38_08, 1_55_92, 11_97, 11_71_32, 12_06_18, 5, 2]




     @classmethod
     def 		lowerCAmelCase_     (				cls       :			List[Any]				):


         """simple docstring"""



         __A         =	MaMaaaTokenizer.from_pretrained(
             cls.checkpoint_name ,	src_lang="""en""" ,	tgt_lang="""fr"""				)
         __A         =	1
         return cls




     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         self.assertEqual(self.tokenizer.get_lang_id("""ar"""				) ,	128_006				)
         self.assertEqual(self.tokenizer.get_lang_id("""en"""				) ,	128_022				)
         self.assertEqual(self.tokenizer.get_lang_id("""ro"""				) ,	128_076				)
         self.assertEqual(self.tokenizer.get_lang_id("""mr"""				) ,	128_063				)




     def 		lowerCAmelCase_     (				self       :			Union[str, Any]				):


         """simple docstring"""



         __A         =	self.tokenizer.get_vocab()
         self.assertEqual(len(__a				) ,	self.tokenizer.vocab_size				)
         self.assertEqual(vocab["""<unk>"""] ,	3				)
         self.assertIn(self.tokenizer.get_lang_token("""en"""				) ,	__a				)




     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         __A         =	"en"
         __A         =	self.tokenizer.batch_encode_plus(self.src_text				).input_ids[0]
         self.assertListEqual(self.expected_src_tokens ,	__a				)




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         self.assertIn(__a ,	self.tokenizer.all_special_ids				)
         # fmt: off
         __A         =	[FR_CODE, 5_364, 82, 8_642, 4, 294, 47, 8, 14_028, 136, 3_286, 9_706, 6, 90_797, 6, 144_012, 162, 88_128, 30_061, 5, 2]
         # fmt: on
         __A         =	self.tokenizer.decode(__a ,	skip_special_tokens=__a				)
         __A         =	self.tokenizer.decode(generated_ids[1:] ,	skip_special_tokens=__a				)
         self.assertEqual(__a ,	__a				)
         self.assertNotIn(self.tokenizer.eos_token ,	__a				)




     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	tempfile.mkdtemp()
         __A         =	self.tokenizer.lang_token_to_id
         self.tokenizer.save_pretrained(__a				)
         __A         =	MaMaaaTokenizer.from_pretrained(__a				)
         self.assertDictEqual(new_tok.lang_token_to_id ,	__a				)




     @require_torch
     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         __A         =	"en"
         __A         =	"fr"

         __A         =	self.tokenizer(self.src_text ,	text_target=self.tgt_text ,	padding=__a ,	return_tensors="""pt"""				)

         __A         =	shift_tokens_right(
             batch["""labels"""] ,	self.tokenizer.pad_token_id ,	self.tokenizer.eos_token_id				)

         for k in batch:
             __A         =	batch[k].tolist()
         # batch = {k: v.tolist() for k,v in batch.items()}
         # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
         # batch.decoder_inputs_ids[0][0] ==
         assert batch.input_ids[1][0] == EN_CODE
         assert batch.input_ids[1][-1] == 2
         assert batch.labels[1][0] == FR_CODE
         assert batch.labels[1][-1] == 2
         assert batch.decoder_input_ids[1][:2] == [2, FR_CODE]




     @require_torch
     def 		lowerCAmelCase_     (				self       :			int				):


         """simple docstring"""



         __A         =	"mr"
         self.assertListEqual(self.tokenizer.prefix_tokens ,	[self.tokenizer.get_lang_id("""mr"""				)]				)
         self.assertListEqual(self.tokenizer.suffix_tokens ,	[self.tokenizer.eos_token_id]				)

         __A         =	"zh"
         self.assertListEqual(self.tokenizer.prefix_tokens ,	[self.tokenizer.get_lang_id("""zh"""				)]				)
         self.assertListEqual(self.tokenizer.suffix_tokens ,	[self.tokenizer.eos_token_id]				)




     @require_torch
     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         __A         =	"mr"
         self.tokenizer._switch_to_target_mode()
         self.assertListEqual(self.tokenizer.prefix_tokens ,	[self.tokenizer.get_lang_id("""mr"""				)]				)
         self.assertListEqual(self.tokenizer.suffix_tokens ,	[self.tokenizer.eos_token_id]				)
         self.tokenizer._switch_to_input_mode()
         self.assertListEqual(self.tokenizer.prefix_tokens ,	[self.tokenizer.get_lang_id(self.tokenizer.src_lang				)]				)

         __A         =	"zh"
         self.tokenizer._switch_to_target_mode()
         self.assertListEqual(self.tokenizer.prefix_tokens ,	[self.tokenizer.get_lang_id("""zh"""				)]				)
         self.assertListEqual(self.tokenizer.suffix_tokens ,	[self.tokenizer.eos_token_id]				)
         self.tokenizer._switch_to_input_mode()
         self.assertListEqual(self.tokenizer.prefix_tokens ,	[self.tokenizer.get_lang_id(self.tokenizer.src_lang				)]				)





     @require_torch
     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         __A         =	self.tokenizer._build_translation_inputs("""A test""" ,	return_tensors="""pt""" ,	src_lang="""en""" ,	tgt_lang="""ar"""				)

         self.assertEqual(
             nested_simplify(__a				) ,	{
                 # en_XX, A, test, EOS
                 """input_ids""": [[128_022, 58, 4_183, 2]],
                 """attention_mask""": [[1, 1, 1, 1]],
                 # ar_AR
                 """forced_bos_token_id""": 128_006,
             } ,	)












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       :			Tuple ,	UpperCamelCase_       :			Tuple ,	UpperCamelCase_       :			Union[str, Any]=13 ,	UpperCamelCase_       :			Optional[Any]=30 ,	UpperCamelCase_       :			Optional[int]=2 ,	UpperCamelCase_       :			Optional[Any]=3 ,	UpperCamelCase_       :			int=True ,	UpperCamelCase_       :			str=True ,	UpperCamelCase_       :			str=32 ,	UpperCamelCase_       :			Tuple=2 ,	UpperCamelCase_       :			List[Any]=4 ,	UpperCamelCase_       :			List[str]=37 ,	UpperCamelCase_       :			Any="gelu" ,	UpperCamelCase_       :			Any=0.1 ,	UpperCamelCase_       :			Optional[Any]=0.1 ,	UpperCamelCase_       :			Any=10 ,	UpperCamelCase_       :			str=0.02 ,	UpperCamelCase_       :			Dict=3 ,	UpperCamelCase_       :			int=None ,	):


         """simple docstring"""



         __A         =	parent
         __A         =	batch_size
         __A         =	image_size
         __A         =	patch_size
         __A         =	num_channels
         __A         =	is_training
         __A         =	use_labels
         __A         =	hidden_size
         __A         =	num_hidden_layers
         __A         =	num_attention_heads
         __A         =	intermediate_size
         __A         =	hidden_act
         __A         =	hidden_dropout_prob
         __A         =	attention_probs_dropout_prob
         __A         =	type_sequence_label_size
         __A         =	initializer_range
         __A         =	scope

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




     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         __A         =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

         __A         =	None
         if self.use_labels:
             __A         =	ids_tensor([self.batch_size] ,	self.type_sequence_label_size				)

         __A         =	self.get_config()

         return config, pixel_values, labels




     def 		lowerCAmelCase_     (				self       :			int				):


         """simple docstring"""



         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=UpperCamelCase_ ,	initializer_range=self.initializer_range ,	)




     def 		lowerCAmelCase_     (				self       :			Tuple ,	UpperCamelCase_       :			int ,	UpperCamelCase_       :			List[str] ,	UpperCamelCase_       :			Optional[int]				):


         """simple docstring"""



         __A         =	TFViTModel(config=UpperCamelCase_				)
         __A         =	model(UpperCamelCase_ ,	training=UpperCamelCase_				)
         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.
         __A         =	self.image_size // 2
         __A         =	pixel_values[:, :, :image_size, :image_size]
         __A         =	model(UpperCamelCase_ ,	interpolate_pos_encoding=UpperCamelCase_ ,	training=UpperCamelCase_				)
         __A         =	(image_size // self.patch_size) ** 2 + 1
         self.parent.assertEqual(result.last_hidden_state.shape ,	(self.batch_size, seq_length, self.hidden_size)				)




     def 		lowerCAmelCase_     (				self       :			Tuple ,	UpperCamelCase_       :			Union[str, Any] ,	UpperCamelCase_       :			Optional[Any] ,	UpperCamelCase_       :			List[Any]				):


         """simple docstring"""



         __A         =	self.type_sequence_label_size
         __A         =	TFViTForImageClassification(UpperCamelCase_				)
         __A         =	model(UpperCamelCase_ ,	labels=UpperCamelCase_ ,	training=UpperCamelCase_				)
         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.
         __A         =	self.image_size // 2
         __A         =	pixel_values[:, :, :image_size, :image_size]
         __A         =	model(UpperCamelCase_ ,	interpolate_pos_encoding=UpperCamelCase_ ,	training=UpperCamelCase_				)
         self.parent.assertEqual(result.logits.shape ,	(self.batch_size, self.type_sequence_label_size)				)

         # test greyscale images
         __A         =	1
         __A         =	TFViTForImageClassification(UpperCamelCase_				)
         __A         =	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
         __A         =	model(UpperCamelCase_				)
         self.parent.assertEqual(result.logits.shape ,	(self.batch_size, self.type_sequence_label_size)				)





     def 		lowerCAmelCase_     (				self       :			Optional[int]				):


         """simple docstring"""



         __A         =	self.prepare_config_and_inputs()
         __A    ,	__A    ,	__A         =	config_and_inputs
         __A         =	{"""pixel_values""": pixel_values}
         return config, inputs_dict


@require_tf
class       __lowercase      (	lowercase_			,      lowercase_			,      unittest.TestCase  ):







     '''simple docstring'''
     SCREAMING_SNAKE_CASE   						=				(TFViTModel, TFViTForImageClassification) if is_tf_available() else ()
     SCREAMING_SNAKE_CASE   						=				(
         {"feature-extraction": TFViTModel, "image-classification": TFViTForImageClassification}
         if is_tf_available()
         else {}
     )

     SCREAMING_SNAKE_CASE   						=				False
     SCREAMING_SNAKE_CASE   						=				False
     SCREAMING_SNAKE_CASE   						=				False




     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         __A         =	TFViTModelTester(self				)
         __A         =	ConfigTester(self ,	config_class=UpperCamelCase_ ,	has_text_modality=UpperCamelCase_ ,	hidden_size=37				)




     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         self.config_tester.run_common_tests()




     @unittest.skip(reason="""ViT does not use inputs_embeds"""				)
     def 		lowerCAmelCase_     (				self       :			Dict				):


         """simple docstring"""



         pass




     @unittest.skip(reason="""ViT does not use inputs_embeds"""				)
     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         pass




     def 		lowerCAmelCase_     (				self       :			Tuple				):


         """simple docstring"""



         __A    ,	__A         =	self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
             __A         =	model_class(UpperCamelCase_				)
             self.assertIsInstance(model.get_input_embeddings() ,	(tf.keras.layers.Layer)				)
             __A         =	model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(UpperCamelCase_ ,	tf.keras.layers.Layer				)				)




     def 		lowerCAmelCase_     (				self       :			List[str]				):


         """simple docstring"""



         __A    ,	__A         =	self.model_tester.prepare_config_and_inputs_for_common()

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

             __A         =	["""pixel_values"""]
             self.assertListEqual(arg_names[:1] ,	UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         __A         =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase_				)




     def 		lowerCAmelCase_     (				self       :			str				):


         """simple docstring"""



         __A         =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_				)





     @slow
     def 		lowerCAmelCase_     (				self       :			Any				):


         """simple docstring"""



         __A         =	TFViTModel.from_pretrained("""google/vit-base-patch16-224"""				)
         self.assertIsNotNone(UpperCamelCase_				)



def 			_SCREAMING_SNAKE_CASE						( )						->      Union[str, Any]:





    """simple docstring"""

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






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







     '''simple docstring'''




     @cached_property
     def 		lowerCAmelCase_     (				self       :			List[Any]				):


         """simple docstring"""



         return ViTImageProcessor.from_pretrained("""google/vit-base-patch16-224"""				) if is_vision_available() else None





     @slow
     def 		lowerCAmelCase_     (				self       :			Optional[Any]				):


         """simple docstring"""



         __A         =	TFViTForImageClassification.from_pretrained("""google/vit-base-patch16-224"""				)

         __A         =	self.default_image_processor
         __A         =	prepare_img()
         __A         =	image_processor(images=UpperCamelCase_ ,	return_tensors="""tf"""				)

         # forward pass
         __A         =	model(**UpperCamelCase_				)

         # verify the logits
         __A         =	tf.TensorShape((1, 1_000)				)
         self.assertEqual(outputs.logits.shape ,	UpperCamelCase_				)

         __A         =	tf.constant([-0.2744, 0.8215, -0.0836]				)

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




