

import inspect
import unittest

from transformers import ViTConfig
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_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, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch
					from torch import nn

					from transformers import ViTForImageClassification, ViTForMaskedImageModeling, ViTModel
					from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import ViTImageProcessor





class       snake_case_  :







			'''simple docstring'''

			def __init__(	self					:							Union[str, Any]				,  _UpperCamelCase					:							int				,  _UpperCamelCase					:							List[str]=1_3				,  _UpperCamelCase					:							Optional[Any]=3_0				,  _UpperCamelCase					:							Tuple=2				,  _UpperCamelCase					:							Union[str, Any]=3				,  _UpperCamelCase					:							Union[str, Any]=True				,  _UpperCamelCase					:							Optional[int]=True				,  _UpperCamelCase					:							int=3_2				,  _UpperCamelCase					:							Optional[int]=5				,  _UpperCamelCase					:							Union[str, Any]=4				,  _UpperCamelCase					:							int=3_7				,  _UpperCamelCase					:							List[Any]="gelu"				,  _UpperCamelCase					:							Union[str, Any]=0.1				,  _UpperCamelCase					:							Dict=0.1				,  _UpperCamelCase					:							Dict=1_0				,  _UpperCamelCase					:							Any=0.02				,  _UpperCamelCase					:							Optional[int]=None				,  _UpperCamelCase					:							Union[str, Any]=2				,  ) ->str:
									snake_case_  =      parent
									snake_case_  =      batch_size
									snake_case_  =      image_size
									snake_case_  =      patch_size
									snake_case_  =      num_channels
									snake_case_  =      is_training
									snake_case_  =      use_labels
									snake_case_  =      hidden_size
									snake_case_  =      num_hidden_layers
									snake_case_  =      num_attention_heads
									snake_case_  =      intermediate_size
									snake_case_  =      hidden_act
									snake_case_  =      hidden_dropout_prob
									snake_case_  =      attention_probs_dropout_prob
									snake_case_  =      type_sequence_label_size
									snake_case_  =      initializer_range
									snake_case_  =      scope
									snake_case_  =      encoder_stride

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







			def 							snake_case__(	self					:							List[Any]				) ->Optional[int]:
									snake_case_  =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

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

									snake_case_  =      self.get_config()

									return config, pixel_values, labels







			def 							snake_case__(	self					:							List[str]				) ->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=_UpperCamelCase				,  initializer_range=self.initializer_range				,  encoder_stride=self.encoder_stride				,  )







			def 							snake_case__(	self					:							List[str]				,  _UpperCamelCase					:							List[str]				,  _UpperCamelCase					:							Any				,  _UpperCamelCase					:							Any				) ->Dict:
									snake_case_  =      ViTModel(config=_UpperCamelCase				)
									model.to(_UpperCamelCase				)
									model.eval()
									snake_case_  =      model(_UpperCamelCase				)
									self.parent.assertEqual(result.last_hidden_state.shape				,  (self.batch_size, self.seq_length, self.hidden_size)				)







			def 							snake_case__(	self					:							Dict				,  _UpperCamelCase					:							List[str]				,  _UpperCamelCase					:							Union[str, Any]				,  _UpperCamelCase					:							Optional[int]				) ->List[Any]:
									snake_case_  =      ViTForMaskedImageModeling(config=_UpperCamelCase				)
									model.to(_UpperCamelCase				)
									model.eval()
									snake_case_  =      model(_UpperCamelCase				)
									self.parent.assertEqual(
									    result.reconstruction.shape				,  (self.batch_size, self.num_channels, self.image_size, self.image_size)				)

									# test greyscale images
									snake_case_  =      1
									snake_case_  =      ViTForMaskedImageModeling(_UpperCamelCase				)
									model.to(_UpperCamelCase				)
									model.eval()

									snake_case_  =      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
									snake_case_  =      model(_UpperCamelCase				)
									self.parent.assertEqual(result.reconstruction.shape				,  (self.batch_size, 1, self.image_size, self.image_size)				)







			def 							snake_case__(	self					:							Union[str, Any]				,  _UpperCamelCase					:							Optional[int]				,  _UpperCamelCase					:							str				,  _UpperCamelCase					:							Any				) ->int:
									snake_case_  =      self.type_sequence_label_size
									snake_case_  =      ViTForImageClassification(_UpperCamelCase				)
									model.to(_UpperCamelCase				)
									model.eval()
									snake_case_  =      model(_UpperCamelCase				,  labels=_UpperCamelCase				)
									self.parent.assertEqual(result.logits.shape				,  (self.batch_size, self.type_sequence_label_size)				)

									# test greyscale images
									snake_case_  =      1
									snake_case_  =      ViTForImageClassification(_UpperCamelCase				)
									model.to(_UpperCamelCase				)
									model.eval()

									snake_case_  =      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
									snake_case_  =      model(_UpperCamelCase				)
									self.parent.assertEqual(result.logits.shape				,  (self.batch_size, self.type_sequence_label_size)				)







			def 							snake_case__(	self					:							List[Any]				) ->Tuple:
									snake_case_  =      self.prepare_config_and_inputs()
									(
									    (
									    snake_case_
									),       (
									    snake_case_
									),       (
									    snake_case_
									),       
									)  =      config_and_inputs
									snake_case_  =      {'''pixel_values''': pixel_values}
									return config, inputs_dict






@require_torch
class       snake_case_  (						__A      ,			__A      ,			unittest.TestCase   ):







			'''simple docstring'''

			SCREAMING_SNAKE_CASE	:  Optional[Any]		     =							(
			    (
			        ViTModel,
			        ViTForImageClassification,
			        ViTForMaskedImageModeling,
			    )
			    if is_torch_available()
			    else ()
			)
			SCREAMING_SNAKE_CASE	:  Any		     =							(
			    {"feature-extraction": ViTModel, "image-classification": ViTForImageClassification}
			    if is_torch_available()
			    else {}
			)
			SCREAMING_SNAKE_CASE	:  int		     =							True

			SCREAMING_SNAKE_CASE	:  Union[str, Any]		     =							False
			SCREAMING_SNAKE_CASE	:  int		     =							False
			SCREAMING_SNAKE_CASE	:  str		     =							False







			def 							snake_case__(	self					:							Tuple				) ->int:
									snake_case_  =      ViTModelTester(self				)
									snake_case_  =      ConfigTester(self				,  config_class=_UpperCamelCase				,  has_text_modality=_UpperCamelCase				,  hidden_size=3_7				)







			def 							snake_case__(	self					:							Dict				) ->Any:
									self.config_tester.run_common_tests()







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







			def 							snake_case__(	self					:							int				) ->Tuple:
									snake_case_,       snake_case_  =      self.model_tester.prepare_config_and_inputs_for_common()

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







			def 							snake_case__(	self					:							Any				) ->Any:
									snake_case_,       snake_case_  =      self.model_tester.prepare_config_and_inputs_for_common()

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

															snake_case_  =      ['''pixel_values''']
															self.assertListEqual(arg_names[:1]				,  _UpperCamelCase				)







			def 							snake_case__(	self					:							Union[str, Any]				) ->str:
									snake_case_  =      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_UpperCamelCase				)







			def 							snake_case__(	self					:							Union[str, Any]				) ->Optional[int]:
									snake_case_  =      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCamelCase				)







			def 							snake_case__(	self					:							Union[str, Any]				) ->str:
									snake_case_  =      self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase				)







			@slow
			def 							snake_case__(	self					:							List[str]				) ->int:
									for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															snake_case_  =      ViTModel.from_pretrained(_UpperCamelCase				)
															self.assertIsNotNone(_UpperCamelCase				)






def     __SCREAMING_SNAKE_CASE   ():
						snake_case_  =      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''			)
						return image





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







			'''simple docstring'''

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







			@slow
			def 							snake_case__(	self					:							str				) ->Any:
									snake_case_  =      ViTForImageClassification.from_pretrained('''google/vit-base-patch16-224'''				).to(_UpperCamelCase				)

									snake_case_  =      self.default_image_processor
									snake_case_  =      prepare_img()
									snake_case_  =      image_processor(images=_UpperCamelCase				,  return_tensors='''pt'''				).to(_UpperCamelCase				)

									# forward pass
									with torch.no_grad():
															snake_case_  =      model(**_UpperCamelCase				)

									# verify the logits
									snake_case_  =      torch.Size((1, 1_0_0_0)				)
									self.assertEqual(outputs.logits.shape				,  _UpperCamelCase				)

									snake_case_  =      torch.tensor([-0.2744, 0.8215, -0.0836]				).to(_UpperCamelCase				)

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







			@slow
			def 							snake_case__(	self					:							List[str]				) ->str:
									# ViT models have an `interpolate_pos_encoding` argument in their forward method,
									# allowing to interpolate the pre-trained position embeddings in order to use
									# the model on higher resolutions. The DINO model by Facebook AI leverages this
									# to visualize self-attention on higher resolution images.
									snake_case_  =      ViTModel.from_pretrained('''facebook/dino-vits8'''				).to(_UpperCamelCase				)

									snake_case_  =      ViTImageProcessor.from_pretrained('''facebook/dino-vits8'''				,  size=4_8_0				)
									snake_case_  =      prepare_img()
									snake_case_  =      image_processor(images=_UpperCamelCase				,  return_tensors='''pt'''				)
									snake_case_  =      inputs.pixel_values.to(_UpperCamelCase				)

									# forward pass
									with torch.no_grad():
															snake_case_  =      model(_UpperCamelCase				,  interpolate_pos_encoding=_UpperCamelCase				)

									# verify the logits
									snake_case_  =      torch.Size((1, 3_6_0_1, 3_8_4)				)
									self.assertEqual(outputs.last_hidden_state.shape				,  _UpperCamelCase				)

									snake_case_  =      torch.tensor(
									    [[4.2340, 4.3906, -6.6692], [4.5463, 1.8928, -6.7257], [4.4429, 0.8496, -5.8585]]				).to(_UpperCamelCase				)

									self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]				,  _UpperCamelCase				,  atol=1e-4				)				)







			@slow
			@require_accelerate
			@require_torch_gpu
			def 							snake_case__(	self					:							List[Any]				) ->Tuple:
									snake_case_  =      ViTModel.from_pretrained('''facebook/dino-vits8'''				,  torch_dtype=torch.floataa				,  device_map='''auto'''				)
									snake_case_  =      self.default_image_processor

									snake_case_  =      prepare_img()
									snake_case_  =      image_processor(images=_UpperCamelCase				,  return_tensors='''pt'''				)
									snake_case_  =      inputs.pixel_values.to(_UpperCamelCase				)

									# forward pass to make sure inference works in fp16
									with torch.no_grad():
															snake_case_  =      model(_UpperCamelCase				)





"""simple docstring"""

import argparse


a							      =     '''docs/source/_static/js/custom.js'''






def 		_snake_case	(   _snake_case				:   Dict				)       ->   Any:






      '''simple docstring'''


      with open(_snake_case							,    encoding='utf-8'							,    newline='\n'				) as f:
            _A     =  f.readlines()
      _A     =  0

      # First let's put the right version
      while not lines[index].startswith('const stableVersion ='				):
            index += 1
      _A     =  F'''const stableVersion = "v{version}"\n'''

      # Then update the dictionary
      while not lines[index].startswith('const versionMapping = {'				):
            index += 1

      # We go until the end
      while not lines[index].startswith('}'				):
            index += 1
      # We add the new version at the end
      lines[index - 1] += F'''    "v{version}": "v{version}",\n'''

      with open(_snake_case							,    'w'							,    encoding='utf-8'							,    newline='\n'				) as f:
            f.writelines(_snake_case				)


if __name__ == "__main__":
       a							      =     argparse.ArgumentParser()
       parser.add_argument('''--version''', help='''Release version.''')
       a							      =     parser.parse_args()
       update_custom_js(args.version)

