





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







 '''simple docstring'''

 def __init__(self				:   Dict       , UpperCAmelCase_				:   str       , UpperCAmelCase_				:   Optional[Any]=13       , UpperCAmelCase_				:   Optional[int]=10       , UpperCAmelCase_				:   Union[str, Any]=3       , UpperCAmelCase_				:   Union[str, Any]=2       , UpperCAmelCase_				:   str=2       , UpperCAmelCase_				:   Union[str, Any]=True       , UpperCAmelCase_				:   Tuple=True       , UpperCAmelCase_				:   Any=32       , UpperCAmelCase_				:   str=5       , UpperCAmelCase_				:   int=4       , UpperCAmelCase_				:   int=37       , UpperCAmelCase_				:   str="gelu"       , UpperCAmelCase_				:   Dict=0.1       , UpperCAmelCase_				:   Optional[int]=0.1       , UpperCAmelCase_				:   str=10       , UpperCAmelCase_				:   str=0.02       , UpperCAmelCase_				:   Dict="divided_space_time"       , UpperCAmelCase_				:   Optional[int]=None       , )       ->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__:      int			  =parent
   lowerCamelCase__:      Any			  =batch_size
   lowerCamelCase__:      Any			  =image_size
   lowerCamelCase__:      int			  =num_channels
   lowerCamelCase__:      Optional[Any]			  =patch_size
   lowerCamelCase__:      Optional[int]			  =num_frames
   lowerCamelCase__:      int			  =is_training
   lowerCamelCase__:      List[str]			  =use_labels
   lowerCamelCase__:      Union[str, Any]			  =hidden_size
   lowerCamelCase__:      str			  =num_hidden_layers
   lowerCamelCase__:      List[Any]			  =num_attention_heads
   lowerCamelCase__:      List[str]			  =intermediate_size
   lowerCamelCase__:      Dict			  =hidden_act
   lowerCamelCase__:      List[str]			  =hidden_dropout_prob
   lowerCamelCase__:      List[str]			  =attention_probs_dropout_prob
   lowerCamelCase__:      Optional[Any]			  =attention_type
   lowerCamelCase__:      Tuple			  =initializer_range
   lowerCamelCase__:      Optional[int]			  =scope
   lowerCamelCase__:      Union[str, Any]			  =num_labels

   # in TimeSformer, the number of spatial tokens equals num_frames * num_patches per frame + 1 CLS token
   lowerCamelCase__:      Union[str, Any]			  =(image_size // patch_size) ** 2
   lowerCamelCase__:      Dict			  =(num_frames) * self.num_patches_per_frame + 1

 def 							SCREAMING_SNAKE_CASE_					(self				:   str)       ->int:



   '''simple docstring'''



   lowerCamelCase__:      int			  =floats_tensor(
       [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size])

   lowerCamelCase__:      Tuple			  =None
   if self.use_labels:
     lowerCamelCase__:      List[Any]			  =ids_tensor([self.batch_size]       , self.num_labels)

   lowerCamelCase__:      Any			  =self.get_config()

   return config, pixel_values, labels

 def 							SCREAMING_SNAKE_CASE_					(self				:   List[Any])       ->int:



   '''simple docstring'''



   lowerCamelCase__:      List[Any]			  =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       , )
   lowerCamelCase__:      List[Any]			  =self.num_labels
   return config

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int]       , UpperCAmelCase_				:   Optional[int]       , UpperCAmelCase_				:   Tuple       , UpperCAmelCase_				:   List[str])       ->int:



   '''simple docstring'''



   lowerCamelCase__:      Any			  =TimesformerModel(config=UpperCAmelCase_)
   model.to(UpperCAmelCase_)
   model.eval()
   lowerCamelCase__:      Union[str, Any]			  =model(UpperCAmelCase_)
   self.parent.assertEqual(result.last_hidden_state.shape       , (self.batch_size, self.seq_length, self.hidden_size))

 def 							SCREAMING_SNAKE_CASE_					(self				:   List[str]       , UpperCAmelCase_				:   Optional[Any]       , UpperCAmelCase_				:   List[str]       , UpperCAmelCase_				:   List[str])       ->str:



   '''simple docstring'''



   lowerCamelCase__:      Union[str, Any]			  =TimesformerForVideoClassification(UpperCAmelCase_)
   model.to(UpperCAmelCase_)
   model.eval()

   lowerCamelCase__:      Optional[int]			  =model(UpperCAmelCase_)

   # verify the logits shape
   lowerCamelCase__:      int			  =torch.Size((self.batch_size, self.num_labels))
   self.parent.assertEqual(result.logits.shape       , UpperCAmelCase_)







 def 							SCREAMING_SNAKE_CASE_					(self				:   int)       ->Dict:



   '''simple docstring'''



   lowerCamelCase__:      List[Any]			  =self.prepare_config_and_inputs()
   lowerCamelCase__  ,					lowerCamelCase__  ,					lowerCamelCase__:      List[Any]			  =config_and_inputs
   lowerCamelCase__:      Any			  ={"pixel_values": pixel_values}
   return config, inputs_dict



@require_torch
class    _SCREAMING_SNAKE_CASE						(	__SCREAMING_SNAKE_CASE    ,							__SCREAMING_SNAKE_CASE    ,							unittest.TestCase    ):







 '''simple docstring'''
 lowercase_		=			(TimesformerModel, TimesformerForVideoClassification) if is_torch_available() else ()
 lowercase_		=			(
     {"feature-extraction": TimesformerModel, "video-classification": TimesformerForVideoClassification}
     if is_torch_available()
     else {}
 )

 lowercase_		=			False
 lowercase_		=			False
 lowercase_		=			False
 lowercase_		=			False

 def 							SCREAMING_SNAKE_CASE_					(self				:   Union[str, Any])       ->Any:



   '''simple docstring'''



   lowerCamelCase__:      str			  =TimesformerModelTester(self)
   lowerCamelCase__:      List[str]			  =ConfigTester(
       self       , config_class=UpperCAmelCase_       , has_text_modality=UpperCAmelCase_       , hidden_size=37)

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[Any]       , UpperCAmelCase_				:   str       , UpperCAmelCase_				:   str       , UpperCAmelCase_				:   Any=False)       ->Optional[Any]:



   '''simple docstring'''



   lowerCamelCase__:      List[str]			  =copy.deepcopy(UpperCAmelCase_)

   if return_labels:
     if model_class in get_values(UpperCAmelCase_):
       lowerCamelCase__:      str			  =torch.zeros(
           self.model_tester.batch_size       , dtype=torch.long       , device=UpperCAmelCase_)

   return inputs_dict

 def 							SCREAMING_SNAKE_CASE_					(self				:   Union[str, Any])       ->List[str]:



   '''simple docstring'''



   self.config_tester.run_common_tests()

 @unittest.skip(reason="TimeSformer does not use inputs_embeds")
 def 							SCREAMING_SNAKE_CASE_					(self				:   int)       ->List[str]:



   '''simple docstring'''



   pass

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



   '''simple docstring'''



   lowerCamelCase__  ,					lowerCamelCase__:      str			  =self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     lowerCamelCase__:      Any			  =model_class(UpperCAmelCase_)
     self.assertIsInstance(model.get_input_embeddings()       , (nn.Module))
     lowerCamelCase__:      List[Any]			  =model.get_output_embeddings()
     self.assertTrue(x is None or isinstance(UpperCAmelCase_       , nn.Linear))

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int])       ->Optional[Any]:



   '''simple docstring'''



   lowerCamelCase__  ,					lowerCamelCase__:      List[str]			  =self.model_tester.prepare_config_and_inputs_for_common()

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

     lowerCamelCase__:      Any			  =["pixel_values"]
     self.assertListEqual(arg_names[:1]       , UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_					(self				:   Optional[int])       ->Union[str, Any]:



   '''simple docstring'''



   lowerCamelCase__:      List[Any]			  =self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_					(self				:   Any)       ->Any:



   '''simple docstring'''



   lowerCamelCase__:      Dict			  =self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_video_classification(*UpperCAmelCase_)

 @slow
 def 							SCREAMING_SNAKE_CASE_					(self				:   List[str])       ->Union[str, Any]:



   '''simple docstring'''



   for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     lowerCamelCase__:      Union[str, Any]			  =TimesformerModel.from_pretrained(UpperCAmelCase_)
     self.assertIsNotNone(UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_					(self				:   str)       ->Any:



   '''simple docstring'''



   if not self.has_attentions:
     pass

   else:
     lowerCamelCase__  ,					lowerCamelCase__:      Any			  =self.model_tester.prepare_config_and_inputs_for_common()
     lowerCamelCase__:      Tuple			  =True

     for model_class in self.all_model_classes:
       lowerCamelCase__:      List[str]			  =self.model_tester.seq_length
       lowerCamelCase__:      Union[str, Any]			  =self.model_tester.num_frames

       lowerCamelCase__:      List[Any]			  =True
       lowerCamelCase__:      str			  =False
       lowerCamelCase__:      List[Any]			  =True
       lowerCamelCase__:      Union[str, Any]			  =model_class(UpperCAmelCase_)
       model.to(UpperCAmelCase_)
       model.eval()
       with torch.no_grad():
         lowerCamelCase__:      int			  =model(**self._prepare_for_class(UpperCAmelCase_       , UpperCAmelCase_))
       lowerCamelCase__:      str			  =outputs.attentions
       self.assertEqual(len(UpperCAmelCase_)       , self.model_tester.num_hidden_layers)

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

       # Check attention is always last and order is fine
       lowerCamelCase__:      Dict			  =True
       lowerCamelCase__:      Union[str, Any]			  =True
       lowerCamelCase__:      Optional[Any]			  =model_class(UpperCAmelCase_)
       model.to(UpperCAmelCase_)
       model.eval()
       with torch.no_grad():
         lowerCamelCase__:      Optional[Any]			  =model(**self._prepare_for_class(UpperCAmelCase_       , UpperCAmelCase_))

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

       lowerCamelCase__:      Optional[int]			  =outputs.attentions

       self.assertEqual(len(UpperCAmelCase_)       , 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				:   Union[str, Any])       ->List[Any]:



   '''simple docstring'''



   def check_hidden_states_output(UpperCAmelCase_				:   Union[str, Any]       , UpperCAmelCase_				:   Union[str, Any]       , UpperCAmelCase_				:   str):
     lowerCamelCase__:      str			  =model_class(UpperCAmelCase_)
     model.to(UpperCAmelCase_)
     model.eval()

     with torch.no_grad():
       lowerCamelCase__:      Tuple			  =model(**self._prepare_for_class(UpperCAmelCase_       , UpperCAmelCase_))

     lowerCamelCase__:      Union[str, Any]			  =outputs.hidden_states
     lowerCamelCase__:      Optional[Any]			  =self.model_tester.num_hidden_layers + 1
     self.assertEqual(len(UpperCAmelCase_)       , UpperCAmelCase_)

     lowerCamelCase__:      List[str]			  =self.model_tester.seq_length

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

   lowerCamelCase__  ,					lowerCamelCase__:      Optional[Any]			  =self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     lowerCamelCase__:      str			  =True
     check_hidden_states_output(UpperCAmelCase_       , UpperCAmelCase_       , UpperCAmelCase_)

     # check that output_hidden_states also work using config
     del inputs_dict["output_hidden_states"]
     lowerCamelCase__:      List[str]			  =True

     check_hidden_states_output(UpperCAmelCase_       , UpperCAmelCase_       , UpperCAmelCase_)





def      lowerCAmelCase_ (       )     ->		int:







  """simple docstring"""





  lowerCamelCase__:      List[str]			  =hf_hub_download(
      repo_id="hf-internal-testing/spaghetti-video"	,    filename="eating_spaghetti.npy"	,    repo_type="dataset"		)
  lowerCamelCase__:      List[str]			  =np.load(__a		)
  return list(__a		)






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







 '''simple docstring'''

 @cached_property
 def 							SCREAMING_SNAKE_CASE_					(self				:   int)       ->List[Any]:



   '''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				:   Any)       ->Tuple:



   '''simple docstring'''



   lowerCamelCase__:      Optional[int]			  =TimesformerForVideoClassification.from_pretrained("facebook/timesformer-base-finetuned-k400").to(
       UpperCAmelCase_)

   lowerCamelCase__:      Dict			  =self.default_image_processor
   lowerCamelCase__:      List[Any]			  =prepare_video()
   lowerCamelCase__:      Optional[Any]			  =image_processor(video[:8]       , return_tensors="pt").to(UpperCAmelCase_)

   # forward pass
   with torch.no_grad():
     lowerCamelCase__:      int			  =model(**UpperCAmelCase_)

   # verify the logits
   lowerCamelCase__:      List[str]			  =torch.Size((1, 400))
   self.assertEqual(outputs.logits.shape       , UpperCAmelCase_)

   lowerCamelCase__:      Optional[Any]			  =torch.tensor([-0.3016, -0.7713, -0.4205]).to(UpperCAmelCase_)

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








import os


# All paths are set with the intent you should run this script from the root of the repo with the command
# python utils/check_doctest_list.py
__A									=				"."


if __name__ == "__main__":
     __A									=				os.path.join(REPO_PATH, "utils/documentation_tests.txt")
     __A									=				[]
     __A									=				[]
     with open(doctest_file_path) as fp:
          for line in fp:
               __A									=				line.strip()
               __A									=				os.path.join(REPO_PATH, line)
               if not (os.path.isfile(path) or os.path.isdir(path)):
                    non_existent_paths.append(line)
               all_paths.append(path)
     if len(non_existent_paths) > 0:
          __A									=				"\n".join(non_existent_paths)
          raise ValueError(f'`utils/documentation_tests.txt` contains non-existent paths:\n{non_existent_paths}')
     if all_paths != sorted(all_paths):
          raise ValueError("Files in `utils/documentation_tests.txt` are not in alphabetical order.")

