





"""simple docstring"""





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        _lowerCamelCase      :


						def __init__(self   ,							__a   ,							__a=13   ,							__a=10   ,							__a=3   ,							__a=2   ,							__a=2   ,							__a=True   ,							__a=True   ,							__a=32   ,							__a=5   ,							__a=4   ,							__a=37   ,							__a="gelu"   ,							__a=0.1   ,							__a=0.1   ,							__a=10   ,							__a=0.02   ,							__a="divided_space_time"   ,							__a=None   ,							) ->   Dict:
								UpperCamelCase   =	parent
								UpperCamelCase   =	batch_size
								UpperCamelCase   =	image_size
								UpperCamelCase   =	num_channels
								UpperCamelCase   =	patch_size
								UpperCamelCase   =	num_frames
								UpperCamelCase   =	is_training
								UpperCamelCase   =	use_labels
								UpperCamelCase   =	hidden_size
								UpperCamelCase   =	num_hidden_layers
								UpperCamelCase   =	num_attention_heads
								UpperCamelCase   =	intermediate_size
								UpperCamelCase   =	hidden_act
								UpperCamelCase   =	hidden_dropout_prob
								UpperCamelCase   =	attention_probs_dropout_prob
								UpperCamelCase   =	attention_type
								UpperCamelCase   =	initializer_range
								UpperCamelCase   =	scope
								UpperCamelCase   =	num_labels

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


						def     snake_case_   (self		) ->   str:
								UpperCamelCase   =	floats_tensor(
								    [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]		)

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

								UpperCamelCase   =	self.get_config()

								return config, pixel_values, labels


						def     snake_case_   (self		) ->   Union[str, Any]:
								UpperCamelCase   =	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   ,							)
								UpperCamelCase   =	self.num_labels
								return config


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a		) ->   List[str]:
								UpperCamelCase   =	TimesformerModel(config=__a		)
								model.to(__a		)
								model.eval()
								UpperCamelCase   =	model(__a		)
								self.parent.assertEqual(result.last_hidden_state.shape   ,							(self.batch_size, self.seq_length, self.hidden_size)		)


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a		) ->   List[str]:
								UpperCamelCase   =	TimesformerForVideoClassification(__a		)
								model.to(__a		)
								model.eval()

								UpperCamelCase   =	model(__a		)

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




						def     snake_case_   (self		) ->   Any:
								UpperCamelCase   =	self.prepare_config_and_inputs()
								UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   =	config_and_inputs
								UpperCamelCase   =	{"pixel_values": pixel_values}
								return config, inputs_dict





@require_torch
class        _lowerCamelCase      (       _lowercase  ,			_lowercase  ,			unittest.TestCase ):
						UpperCAmelCase_ =			(TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
						UpperCAmelCase_ =			(
						    {"feature-extraction": TimesformerModel, "video-classification": TimesformerForVideoClassification}
						    if is_torch_available()
						    else {}
						)

						UpperCAmelCase_ =			False
						UpperCAmelCase_ =			False
						UpperCAmelCase_ =			False
						UpperCAmelCase_ =			False


						def     snake_case_   (self		) ->   List[str]:
								UpperCamelCase   =	TimesformerModelTester(self		)
								UpperCamelCase   =	ConfigTester(
								    self   ,							config_class=__a   ,							has_text_modality=__a   ,							hidden_size=37		)


						def     snake_case_   (self   ,							__a   ,							__a   ,							__a=False		) ->   str:
								UpperCamelCase   =	copy.deepcopy(__a		)

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

								return inputs_dict


						def     snake_case_   (self		) ->   Dict:
								self.config_tester.run_common_tests()


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


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

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


						def     snake_case_   (self		) ->   Dict:
								UpperCamelCase   ,				UpperCamelCase   =	self.model_tester.prepare_config_and_inputs_for_common()

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

										UpperCamelCase   =	["pixel_values"]
										self.assertListEqual(arg_names[:1]   ,							__a		)


						def     snake_case_   (self		) ->   Optional[int]:
								UpperCamelCase   =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*__a		)


						def     snake_case_   (self		) ->   List[str]:
								UpperCamelCase   =	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_video_classification(*__a		)


						@slow
						def     snake_case_   (self		) ->   List[Any]:
								for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										UpperCamelCase   =	TimesformerModel.from_pretrained(__a		)
										self.assertIsNotNone(__a		)


						def     snake_case_   (self		) ->   Dict:
								if not self.has_attentions:
										pass

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

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

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

												# check that output_attentions also work using config
												del inputs_dict["output_attentions"]
												UpperCamelCase   =	True
												UpperCamelCase   =	model_class(__a		)
												model.to(__a		)
												model.eval()
												with torch.no_grad():
														UpperCamelCase   =	model(**self._prepare_for_class(__a   ,							__a		)		)
												UpperCamelCase   =	outputs.attentions
												self.assertEqual(len(__a		)   ,							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]   ,							)
												UpperCamelCase   =	len(__a		)

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

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

												UpperCamelCase   =	outputs.attentions

												self.assertEqual(len(__a		)   ,							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     snake_case_   (self		) ->   List[str]:
								def check_hidden_states_output(__a   ,							__a   ,							__a		):
										UpperCamelCase   =	model_class(__a		)
										model.to(__a		)
										model.eval()

										with torch.no_grad():
												UpperCamelCase   =	model(**self._prepare_for_class(__a   ,							__a		)		)

										UpperCamelCase   =	outputs.hidden_states
										UpperCamelCase   =	self.model_tester.num_hidden_layers + 1
										self.assertEqual(len(__a		)   ,							__a		)

										UpperCamelCase   =	self.model_tester.seq_length

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

								UpperCamelCase   ,				UpperCamelCase   =	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										UpperCamelCase   =	True
										check_hidden_states_output(__a   ,							__a   ,							__a		)

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

										check_hidden_states_output(__a   ,							__a   ,							__a		)



def       a__					(					):




		"""simple docstring"""


		UpperCamelCase   =	hf_hub_download(
		    repo_id="hf-internal-testing/spaghetti-video"  ,	filename="eating_spaghetti.npy"  ,	repo_type="dataset"    )
		UpperCamelCase   =	np.load(_SCREAMING_SNAKE_CASE    )
		return list(_SCREAMING_SNAKE_CASE    )






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


						@cached_property
						def     snake_case_   (self		) ->   str:
								# logits were tested with a different mean and std, so we use the same here
								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     snake_case_   (self		) ->   Any:
								UpperCamelCase   =	TimesformerForVideoClassification.from_pretrained("facebook/timesformer-base-finetuned-k400"		).to(
								    __a		)

								UpperCamelCase   =	self.default_image_processor
								UpperCamelCase   =	prepare_video()
								UpperCamelCase   =	image_processor(video[:8]   ,							return_tensors="pt"		).to(__a		)

								# forward pass
								with torch.no_grad():
										UpperCamelCase   =	model(**__a		)

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

								UpperCamelCase   =	torch.tensor([-0.3016, -0.7713, -0.4205]		).to(__a		)

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













"""simple docstring"""





import argparse
from collections import defaultdict


def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    ):




		"""simple docstring"""


		UpperCamelCase   =	F"{file}_{class_name}_{test_name}"
		done_test[_id] += 1

		with open(_SCREAMING_SNAKE_CASE  ,	"r"    ) as f:
				UpperCamelCase   =	f.readlines()

		UpperCamelCase   =	F"class {class_name}("
		UpperCamelCase   =	F"{4 * ' '}def {test_name}("
		UpperCamelCase   =	F"{8 * ' '}{correct_line.split()[0]}"
		UpperCamelCase   =	F"{16 * ' '}{correct_line.split()[0]}"
		UpperCamelCase   =	False
		UpperCamelCase   =	False
		UpperCamelCase   =	False
		UpperCamelCase   =	False
		UpperCamelCase   =	0
		UpperCamelCase   =	0

		UpperCamelCase   =	[]
		for line in lines:
				if line.startswith(_SCREAMING_SNAKE_CASE    ):
						UpperCamelCase   =	True
				elif in_class and line.startswith(_SCREAMING_SNAKE_CASE    ):
						UpperCamelCase   =	True
				elif in_class and in_func and (line.startswith(_SCREAMING_SNAKE_CASE    ) or line.startswith(_SCREAMING_SNAKE_CASE    )):
						UpperCamelCase   =	len(line.split(correct_line.split()[0]    )[0]    )
						count += 1

						if count == done_test[_id]:
								UpperCamelCase   =	True

				if in_class and in_func and in_line:
						if ")" not in line:
								continue
						else:
								UpperCamelCase   =	True

				if in_class and in_func and in_line and insert_line:
						new_lines.append(F"{spaces * ' '}{correct_line}"    )
						UpperCamelCase   =	UpperCamelCase   =	UpperCamelCase   =	UpperCamelCase   =	False
				else:
						new_lines.append(_SCREAMING_SNAKE_CASE    )

		with open(_SCREAMING_SNAKE_CASE  ,	"w"    ) as f:
				for line in new_lines:
						f.write(_SCREAMING_SNAKE_CASE    )


def       a__					(					_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE=None    ):




		"""simple docstring"""


		if fail is not None:
				with open(_SCREAMING_SNAKE_CASE  ,	"r"    ) as f:
						UpperCamelCase   =	{l.strip() for l in f.readlines()}
		else:
				UpperCamelCase   =	None

		with open(_SCREAMING_SNAKE_CASE  ,	"r"    ) as f:
				UpperCamelCase   =	f.readlines()

		UpperCamelCase   =	defaultdict(_SCREAMING_SNAKE_CASE    )
		for line in correct_lines:
				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   ,				UpperCamelCase   =	line.split(";"    )
				if test_failures is None or "::".join([file, class_name, test_name]    ) in test_failures:
						overwrite_file(_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE  ,	_SCREAMING_SNAKE_CASE    )


if __name__ == "__main__":
						lowerCAmelCase__     			=			argparse.ArgumentParser()
						parser.add_argument('''--correct_filename''', help='''filename of tests with expected result''')
						parser.add_argument('''--fail_filename''', help='''filename of test failures''', type=str, default=None)
						lowerCAmelCase__     			=			parser.parse_args()

						main(args.correct_filename, args.fail_filename)






