


'''simple docstring'''





import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import VivitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, 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


if is_torch_available():
					import torch
					from torch import nn

					from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VivitForVideoClassification, VivitModel
					from transformers.models.vivit.modeling_vivit import VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from transformers import VivitImageProcessor
class 	a__				:





			'''simple docstring'''

			def __init__(     self       : Dict ,						lowerCAmelCase_       : str ,						lowerCAmelCase_       : List[Any]=2 ,						lowerCAmelCase_       : str=True ,						lowerCAmelCase_       : int=True ,						lowerCAmelCase_       : List[str]=10 ,						lowerCAmelCase_       : Any=10 ,						lowerCAmelCase_       : Dict=8 ,						lowerCAmelCase_       : List[str]=[2, 4, 4] ,						lowerCAmelCase_       : Any=3 ,						lowerCAmelCase_       : Tuple=768 ,						lowerCAmelCase_       : List[Any]=5 ,						lowerCAmelCase_       : int=4 ,						lowerCAmelCase_       : Dict=37 ,						lowerCAmelCase_       : Dict="gelu_fast" ,						lowerCAmelCase_       : List[Any]=0.0 ,						lowerCAmelCase_       : Union[str, Any]=0.0 ,						lowerCAmelCase_       : Tuple=0.02 ,						lowerCAmelCase_       : Union[str, Any]=1E-06 ,						lowerCAmelCase_       : Optional[Any]=True ,						lowerCAmelCase_       : List[Any]=None ,						)			->		Optional[Any]:
						__A=  parent
						__A=  batch_size
						__A=  is_training
						__A=  use_labels
						__A=  num_labels
						__A=  image_size
						__A=  num_frames
						__A=  tubelet_size
						__A=  num_channels
						__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=  initializer_range
						__A=  layer_norm_eps
						__A=  qkv_bias
						__A=  scope

						__A=  (
						    (self.image_size // self.tubelet_size[2])
						    * (self.image_size // self.tubelet_size[1])
						    * (self.num_frames // self.tubelet_size[0])
						) + 1  # CLS token
			def 				lowerCAmelCase    (     self       : Union[str, Any]  )			->		Union[str, Any]:
						__A=  floats_tensor(
						    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]  )

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

						__A=  self.get_config()

						return config, pixel_values, labels
			def 				lowerCAmelCase    (     self       : Dict  )			->		Optional[int]:
						__A=  VivitConfig(
						    num_frames=self.num_frames ,						image_size=self.image_size ,						tubelet_size=self.tubelet_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 ,						initializer_range=self.initializer_range ,						layer_norm_eps=self.layer_norm_eps ,						qkv_bias=self.qkv_bias ,						)
						__A=  self.num_labels
						return config
			def 				lowerCAmelCase    (     self       : Optional[Any] ,						lowerCAmelCase_       : Optional[Any] ,						lowerCAmelCase_       : List[str] ,						lowerCAmelCase_       : Union[str, Any]  )			->		List[Any]:
						__A=  VivitModel(config=lowerCAmelCase_  )
						model.to(lowerCAmelCase_  )
						model.eval()
						__A=  model(lowerCAmelCase_  )
						self.parent.assertEqual(result.last_hidden_state.shape ,						(self.batch_size, self.seq_length, self.hidden_size)  )
			def 				lowerCAmelCase    (     self       : Any ,						lowerCAmelCase_       : List[Any] ,						lowerCAmelCase_       : Tuple ,						lowerCAmelCase_       : Tuple  )			->		Dict:
						__A=  VivitForVideoClassification(lowerCAmelCase_  )
						model.to(lowerCAmelCase_  )
						model.eval()

						__A=  model(lowerCAmelCase_  )

						# verify the logits shape
						__A=  torch.Size((self.batch_size, self.num_labels)  )
						self.parent.assertEqual(result.logits.shape ,						lowerCAmelCase_  )

			def 				lowerCAmelCase    (     self       : Tuple  )			->		int:
						__A=  self.prepare_config_and_inputs()
						__A,  __A,  __A=  config_and_inputs
						__A=  {'pixel_values': pixel_values}
						return config, inputs_dict


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





			'''simple docstring'''

			A	:							Tuple							= (VivitModel, VivitForVideoClassification) if is_torch_available() else ()

			A	:							int							= False
			A	:							Optional[Any]							= False
			A	:							int							= False
			A	:							int							= False
			def 				lowerCAmelCase    (     self       : str  )			->		Dict:
						__A=  VivitModelTester(self  )
						__A=  ConfigTester(self ,						config_class=lowerCAmelCase_ ,						has_text_modality=lowerCAmelCase_ ,						hidden_size=37  )
			def 				lowerCAmelCase    (     self       : Union[str, Any] ,						lowerCAmelCase_       : Optional[Any] ,						lowerCAmelCase_       : Optional[Any] ,						lowerCAmelCase_       : Dict=False  )			->		Union[str, Any]:
						__A=  copy.deepcopy(lowerCAmelCase_  )

						if return_labels:
									if model_class in get_values(lowerCAmelCase_  ):
												__A=  torch.zeros(
												    self.model_tester.batch_size ,						dtype=torch.long ,						device=lowerCAmelCase_  )

						return inputs_dict
			def 				lowerCAmelCase    (     self       : Union[str, Any]  )			->		Tuple:
						self.config_tester.run_common_tests()
			@unittest.skip(reason='Vivit does not use inputs_embeds'  )
			def 				lowerCAmelCase    (     self       : List[Any]  )			->		Optional[int]:
						pass
			def 				lowerCAmelCase    (     self       : str  )			->		int:
						__A,  __A=  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									__A=  model_class(lowerCAmelCase_  )
									self.assertIsInstance(model.get_input_embeddings() ,						(nn.Module)  )
									__A=  model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(lowerCAmelCase_ ,						nn.Linear  )  )
			def 				lowerCAmelCase    (     self       : Optional[int]  )			->		Optional[int]:
						__A,  __A=  self.model_tester.prepare_config_and_inputs_for_common()

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

									__A=  ['pixel_values', 'head_mask']
									self.assertListEqual(arg_names[:2] ,						lowerCAmelCase_  )
			def 				lowerCAmelCase    (     self       : str  )			->		int:
						__A=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowerCAmelCase_  )
			def 				lowerCAmelCase    (     self       : int  )			->		Any:
						__A=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_video_classification(*lowerCAmelCase_  )
			@slow
			def 				lowerCAmelCase    (     self       : Any  )			->		Optional[int]:
						for model_name in VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__A=  VivitModel.from_pretrained(lowerCAmelCase_  )
									self.assertIsNotNone(lowerCAmelCase_  )
			def 				lowerCAmelCase    (     self       : Tuple  )			->		List[Any]:
						__A,  __A=  self.model_tester.prepare_config_and_inputs_for_common()
						__A=  True

						for model_class in self.all_model_classes:
									__A=  self.model_tester.seq_length

									__A=  True
									__A=  False
									__A=  True
									__A=  model_class(lowerCAmelCase_  )
									model.to(lowerCAmelCase_  )
									model.eval()
									with torch.no_grad():
												__A=  model(**self._prepare_for_class(lowerCAmelCase_ ,						lowerCAmelCase_  )  )
									__A=  outputs.attentions
									self.assertEqual(len(lowerCAmelCase_  ) ,						self.model_tester.num_hidden_layers  )

									# check that output_attentions also work using config
									del inputs_dict["output_attentions"]
									__A=  True
									__A=  model_class(lowerCAmelCase_  )
									model.to(lowerCAmelCase_  )
									model.eval()
									with torch.no_grad():
												__A=  model(**self._prepare_for_class(lowerCAmelCase_ ,						lowerCAmelCase_  )  )
									__A=  outputs.attentions
									self.assertEqual(len(lowerCAmelCase_  ) ,						self.model_tester.num_hidden_layers  )

									self.assertListEqual(
									    list(attentions[0].shape[-3:]  ) ,						[self.model_tester.num_attention_heads, seq_len, seq_len] ,						)
									__A=  len(lowerCAmelCase_  )

									# Check attention is always last and order is fine
									__A=  True
									__A=  True
									__A=  model_class(lowerCAmelCase_  )
									model.to(lowerCAmelCase_  )
									model.eval()
									with torch.no_grad():
												__A=  model(**self._prepare_for_class(lowerCAmelCase_ ,						lowerCAmelCase_  )  )

									self.assertEqual(out_len + 1 ,						len(lowerCAmelCase_  )  )

									__A=  outputs.attentions

									self.assertEqual(len(lowerCAmelCase_  ) ,						self.model_tester.num_hidden_layers  )

									self.assertListEqual(
									    list(self_attentions[0].shape[-3:]  ) ,						[self.model_tester.num_attention_heads, seq_len, seq_len] ,						)
			def 				lowerCAmelCase    (     self       : Optional[Any]  )			->		Tuple:
						def check_hidden_states_output(lowerCAmelCase_       : Dict ,						lowerCAmelCase_       : Optional[int] ,						lowerCAmelCase_       : Dict  ):
									__A=  model_class(lowerCAmelCase_  )
									model.to(lowerCAmelCase_  )
									model.eval()

									with torch.no_grad():
												__A=  model(**self._prepare_for_class(lowerCAmelCase_ ,						lowerCAmelCase_  )  )

									__A=  outputs.hidden_states
									__A=  self.model_tester.num_hidden_layers + 1
									self.assertEqual(len(lowerCAmelCase_  ) ,						lowerCAmelCase_  )

									__A=  self.model_tester.seq_length

									self.assertListEqual(
									    list(hidden_states[0].shape[-2:]  ) ,						[seq_length, self.model_tester.hidden_size] ,						)

						__A,  __A=  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									__A=  True
									check_hidden_states_output(lowerCAmelCase_ ,						lowerCAmelCase_ ,						lowerCAmelCase_  )

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									__A=  True

									check_hidden_states_output(lowerCAmelCase_ ,						lowerCAmelCase_ ,						lowerCAmelCase_  )

			@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'  )
			def 				lowerCAmelCase    (     self       : str  )			->		Any:
						pass






def 	UpperCAmelCase__(							):






			"""simple docstring"""




			__A=  hf_hub_download(
			    repo_id='hf-internal-testing/spaghetti-video',filename='eating_spaghetti_32_frames.npy',repo_type='dataset'   )
			__A=  np.load(_SCREAMING_SNAKE_CASE   )
			return list(_SCREAMING_SNAKE_CASE   )






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





			'''simple docstring'''

			@cached_property
			def 				lowerCAmelCase    (     self       : Union[str, Any]  )			->		List[str]:
						return VivitImageProcessor() if is_vision_available() else None

			@slow
			def 				lowerCAmelCase    (     self       : List[str]  )			->		List[Any]:
						__A=  VivitForVideoClassification.from_pretrained('google/vivit-b-16x2-kinetics400'  ).to(lowerCAmelCase_  )

						__A=  self.default_image_processor
						__A=  prepare_video()
						__A=  image_processor(lowerCAmelCase_ ,						return_tensors='pt'  ).to(lowerCAmelCase_  )

						# forward pass
						with torch.no_grad():
									__A=  model(**lowerCAmelCase_  )

						# verify the logits
						__A=  torch.Size((1, 400)  )
						self.assertEqual(outputs.logits.shape ,						lowerCAmelCase_  )

						# taken from original model
						__A=  torch.tensor([-1.05_43, 2.07_64, -0.21_04, 0.44_39, -0.96_58]  ).to(lowerCAmelCase_  )

						self.assertTrue(torch.allclose(outputs.logits[0, :5] ,						lowerCAmelCase_ ,						atol=1E-4  )  )







'''simple docstring'''





from typing import Any
class 	a__				:





			'''simple docstring'''

			def __init__(     self       : Any  )			->		int:
						__A=  []
						__A=  0
			def __str__(     self       : Tuple  )			->		Dict:
						__A=  '<' + str(self.stack  )[1:-1] + '>'
						return printed
			def 				lowerCAmelCase    (     self       : Tuple ,						lowerCAmelCase_       : Any  )			->		None:
						self.stack.append(lowerCAmelCase_  )
						__A=  self.length + 1
			def 				lowerCAmelCase    (     self       : int  )			->		Any:
						self.rotate(1  )
						__A=  self.stack[self.length - 1]
						__A=  self.stack[:-1]
						self.rotate(self.length - 1  )
						__A=  self.length - 1
						return dequeued
			def 				lowerCAmelCase    (     self       : Optional[int] ,						lowerCAmelCase_       : int  )			->		None:
						for _ in range(lowerCAmelCase_  ):
									__A=  self.stack[0]
									__A=  self.stack[1:]
									self.put(lowerCAmelCase_  )
									__A=  self.length - 1
			def 				lowerCAmelCase    (     self       : Tuple  )			->		Any:
						__A=  self.get()
						self.put(lowerCAmelCase_  )
						self.rotate(self.length - 1  )
						return front
			def 				lowerCAmelCase    (     self       : Dict  )			->		int:
						return self.length



