code: 
  
  
  '''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  )  )
  
  
  
  
style_context: 
  
  
  '''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
  
  
  
  