import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import TimesformerConfig
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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import (
		    MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
		    TimesformerForVideoClassification,
		    TimesformerModel,
		)
		from transformers.models.timesformer.modeling_timesformer import TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from transformers import VideoMAEImageProcessor




class   _UpperCamelCase :


			"""simple docstring"""






			def __init__(  self ,  lowerCAmelCase__ ,  lowerCAmelCase__=13 ,  lowerCAmelCase__=10 ,  lowerCAmelCase__=3 ,  lowerCAmelCase__=2 ,  lowerCAmelCase__=2 ,  lowerCAmelCase__=True ,  lowerCAmelCase__=True ,  lowerCAmelCase__=32 ,  lowerCAmelCase__=5 ,  lowerCAmelCase__=4 ,  lowerCAmelCase__=37 ,  lowerCAmelCase__="gelu" ,  lowerCAmelCase__=0.1 ,  lowerCAmelCase__=0.1 ,  lowerCAmelCase__=10 ,  lowerCAmelCase__=0.02 ,  lowerCAmelCase__="divided_space_time" ,  lowerCAmelCase__=None ,  )	->   List[Any]:

							'''simple docstring'''


							__lowercase					     =				parent
							__lowercase					     =				batch_size
							__lowercase					     =				image_size
							__lowercase					     =				num_channels
							__lowercase					     =				patch_size
							__lowercase					     =				num_frames
							__lowercase					     =				is_training
							__lowercase					     =				use_labels
							__lowercase					     =				hidden_size
							__lowercase					     =				num_hidden_layers
							__lowercase					     =				num_attention_heads
							__lowercase					     =				intermediate_size
							__lowercase					     =				hidden_act
							__lowercase					     =				hidden_dropout_prob
							__lowercase					     =				attention_probs_dropout_prob
							__lowercase					     =				attention_type
							__lowercase					     =				initializer_range
							__lowercase					     =				scope
							__lowercase					     =				num_labels

							# in TimeSformer, the number of spatial tokens equals num_frames * num_patches per frame + 1 CLS token
							__lowercase					     =				(image_size // patch_size) ** 2
							__lowercase					     =				(num_frames) * self.num_patches_per_frame + 1





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[int]:

							'''simple docstring'''


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

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

							__lowercase					     =				self.get_config()

							return config, pixel_values, labels





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[int]:

							'''simple docstring'''


							__lowercase					     =				TimesformerConfig(
							    image_size=self.image_size ,  patch_size=self.patch_size ,  num_channels=self.num_channels ,  num_frames=self.num_frames ,  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 ,  attention_type=self.attention_type ,  )
							__lowercase					     =				self.num_labels
							return config





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   Optional[int]:

							'''simple docstring'''


							__lowercase					     =				TimesformerModel(config=lowerCAmelCase__		)
							model.to(lowerCAmelCase__		)
							model.eval()
							__lowercase					     =				model(lowerCAmelCase__		)
							self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.seq_length, self.hidden_size)		)





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)	->   Dict:

							'''simple docstring'''


							__lowercase					     =				TimesformerForVideoClassification(lowerCAmelCase__		)
							model.to(lowerCAmelCase__		)
							model.eval()

							__lowercase					     =				model(lowerCAmelCase__		)

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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				self.prepare_config_and_inputs()
							__lowercase     ,	__lowercase     ,	__lowercase					     =				config_and_inputs
							__lowercase					     =				{'''pixel_values''': pixel_values}
							return config, inputs_dict




@require_torch
class   _UpperCamelCase (		_UpperCAmelCase		,_UpperCAmelCase		,unittest.TestCase					):


			"""simple docstring"""






			__a    :					Union[str, Any]     					=		(TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
			__a    :					Union[str, Any]     					=		(
			    {'''feature-extraction''': TimesformerModel, '''video-classification''': TimesformerForVideoClassification}
			    if is_torch_available()
			    else {}
			)

			__a    :					Tuple     					=		False
			__a    :					List[str]     					=		False
			__a    :					List[Any]     					=		False
			__a    :					str     					=		False





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				TimesformerModelTester(self		)
							__lowercase					     =				ConfigTester(
							    self ,  config_class=lowerCAmelCase__ ,  has_text_modality=lowerCAmelCase__ ,  hidden_size=37		)





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__=False		)	->   int:

							'''simple docstring'''


							__lowercase					     =				copy.deepcopy(lowerCAmelCase__		)

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

							return inputs_dict





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   List[str]:

							'''simple docstring'''


							self.config_tester.run_common_tests()





			@unittest.skip(reason='''TimeSformer does not use inputs_embeds'''		)
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Union[str, Any]:

							'''simple docstring'''


							pass





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   List[str]:

							'''simple docstring'''


							__lowercase     ,	__lowercase					     =				self.model_tester.prepare_config_and_inputs_for_common()

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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Dict:

							'''simple docstring'''


							__lowercase     ,	__lowercase					     =				self.model_tester.prepare_config_and_inputs_for_common()

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

											__lowercase					     =				['''pixel_values''']
											self.assertListEqual(arg_names[:1] ,  lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


							__lowercase					     =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


							__lowercase					     =				self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_video_classification(*lowerCAmelCase__		)





			@slow
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase					     =				TimesformerModel.from_pretrained(lowerCAmelCase__		)
											self.assertIsNotNone(lowerCAmelCase__		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							if not self.has_attentions:
											pass

							else:
											__lowercase     ,	__lowercase					     =				self.model_tester.prepare_config_and_inputs_for_common()
											__lowercase					     =				True

											for model_class in self.all_model_classes:
															__lowercase					     =				self.model_tester.seq_length
															__lowercase					     =				self.model_tester.num_frames

															__lowercase					     =				True
															__lowercase					     =				False
															__lowercase					     =				True
															__lowercase					     =				model_class(lowerCAmelCase__		)
															model.to(lowerCAmelCase__		)
															model.eval()
															with torch.no_grad():
																			__lowercase					     =				model(**self._prepare_for_class(lowerCAmelCase__ ,  lowerCAmelCase__		)		)
															__lowercase					     =				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"]
															__lowercase					     =				True
															__lowercase					     =				model_class(lowerCAmelCase__		)
															model.to(lowerCAmelCase__		)
															model.eval()
															with torch.no_grad():
																			__lowercase					     =				model(**self._prepare_for_class(lowerCAmelCase__ ,  lowerCAmelCase__		)		)
															__lowercase					     =				outputs.attentions
															self.assertEqual(len(lowerCAmelCase__		) ,  self.model_tester.num_hidden_layers		)

															# attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
															self.assertListEqual(
															    list(attentions[0].shape[-3:]		) ,  [self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1] ,  )
															__lowercase					     =				len(lowerCAmelCase__		)

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

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

															__lowercase					     =				outputs.attentions

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

															# attentions has shape (batch_size x num_frames) x num_heads x (num_patches per frame + 1) x (num_patches per frame + 1)
															self.assertListEqual(
															    list(self_attentions[0].shape[-3:]		) ,  [self.model_tester.num_attention_heads, seq_len // num_frames + 1, seq_len // num_frames + 1] ,  )





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[Any]:

							'''simple docstring'''


							def check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		):
											__lowercase					     =				model_class(lowerCAmelCase__		)
											model.to(lowerCAmelCase__		)
											model.eval()

											with torch.no_grad():
															__lowercase					     =				model(**self._prepare_for_class(lowerCAmelCase__ ,  lowerCAmelCase__		)		)

											__lowercase					     =				outputs.hidden_states
											__lowercase					     =				self.model_tester.num_hidden_layers + 1
											self.assertEqual(len(lowerCAmelCase__		) ,  lowerCAmelCase__		)

											__lowercase					     =				self.model_tester.seq_length

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

							__lowercase     ,	__lowercase					     =				self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
											__lowercase					     =				True
											check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)

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

											check_hidden_states_output(lowerCAmelCase__ ,  lowerCAmelCase__ ,  lowerCAmelCase__		)





def 							UpperCAmelCase		(       ):







				"""simple docstring"""



				__lowercase					     =				hf_hub_download(
				    repo_id='''hf-internal-testing/spaghetti-video'''				,     filename='''eating_spaghetti.npy'''				,     repo_type='''dataset'''				)
				__lowercase					     =				np.load(lowercase				)
				return list(lowercase				)




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


			"""simple docstring"""






			@cached_property
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


							return (
							    VideoMAEImageProcessor(image_mean=[0.5, 0.5, 0.5] ,  image_std=[0.5, 0.5, 0.5]		)
							    if is_vision_available()
							    else None
							)





			@slow
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Optional[Any]:

							'''simple docstring'''


							__lowercase					     =				TimesformerForVideoClassification.from_pretrained('''facebook/timesformer-base-finetuned-k400'''		).to(
							    lowerCAmelCase__		)

							__lowercase					     =				self.default_image_processor
							__lowercase					     =				prepare_video()
							__lowercase					     =				image_processor(video[:8] ,  return_tensors='''pt'''		).to(lowerCAmelCase__		)

							# forward pass
							with torch.no_grad():
											__lowercase					     =				model(**lowerCAmelCase__		)

							# verify the logits
							__lowercase					     =				torch.Size((1, 4_00)		)
							self.assertEqual(outputs.logits.shape ,  lowerCAmelCase__		)

							__lowercase					     =				torch.tensor([-0.3016, -0.7713, -0.4205]		).to(lowerCAmelCase__		)

							self.assertTrue(torch.allclose(outputs.logits[0, :3] ,  lowerCAmelCase__ ,  atol=1E-4		)		)
from ...configuration_utils import PretrainedConfig
from ...utils import logging


__a    :	List[Any]         =    logging.get_logger(__name__)

__a    :	List[Any]         =    {
    """MIT/ast-finetuned-audioset-10-10-0.4593""": (
        """https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json"""
    ),
}




class   _UpperCamelCase (		_UpperCAmelCase					):


			"""simple docstring"""






			__a    :					Optional[Any]     					=		'''audio-spectrogram-transformer'''





			def __init__(  self ,  lowerCAmelCase__=7_68 ,  lowerCAmelCase__=12 ,  lowerCAmelCase__=12 ,  lowerCAmelCase__=30_72 ,  lowerCAmelCase__="gelu" ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=0.02 ,  lowerCAmelCase__=1E-12 ,  lowerCAmelCase__=16 ,  lowerCAmelCase__=True ,  lowerCAmelCase__=10 ,  lowerCAmelCase__=10 ,  lowerCAmelCase__=10_24 ,  lowerCAmelCase__=1_28 ,  **lowerCAmelCase__ ,  )	->   Optional[Any]:

							'''simple docstring'''


							super().__init__(**lowerCAmelCase__		)

							__lowercase					     =				hidden_size
							__lowercase					     =				num_hidden_layers
							__lowercase					     =				num_attention_heads
							__lowercase					     =				intermediate_size
							__lowercase					     =				hidden_act
							__lowercase					     =				hidden_dropout_prob
							__lowercase					     =				attention_probs_dropout_prob
							__lowercase					     =				initializer_range
							__lowercase					     =				layer_norm_eps
							__lowercase					     =				patch_size
							__lowercase					     =				qkv_bias
							__lowercase					     =				frequency_stride
							__lowercase					     =				time_stride
							__lowercase					     =				max_length
							__lowercase					     =				num_mel_bins