





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    :       Any	,			UpperCAmelCase_    :       Optional[int]	,			UpperCAmelCase_    :       Any=13	,			UpperCAmelCase_    :       Optional[Any]=10	,			UpperCAmelCase_    :       Dict=3	,			UpperCAmelCase_    :       Optional[int]=2	,			UpperCAmelCase_    :       Optional[int]=2	,			UpperCAmelCase_    :       Union[str, Any]=True	,			UpperCAmelCase_    :       List[str]=True	,			UpperCAmelCase_    :       Union[str, Any]=32	,			UpperCAmelCase_    :       List[Any]=5	,			UpperCAmelCase_    :       List[str]=4	,			UpperCAmelCase_    :       Optional[int]=37	,			UpperCAmelCase_    :       List[Any]="gelu"	,			UpperCAmelCase_    :       Tuple=0.1	,			UpperCAmelCase_    :       List[Any]=0.1	,			UpperCAmelCase_    :       Optional[Any]=10	,			UpperCAmelCase_    :       int=0.02	,			UpperCAmelCase_    :       Optional[int]="divided_space_time"	,			UpperCAmelCase_    :       Tuple=None	,			)	->List[str]:



   '''simple docstring'''



   lowerCamelCase__:				Optional[Any]        =parent
   lowerCamelCase__:				Union[str, Any]        =batch_size
   lowerCamelCase__:				Dict        =image_size
   lowerCamelCase__:				str        =num_channels
   lowerCamelCase__:				str        =patch_size
   lowerCamelCase__:				Any        =num_frames
   lowerCamelCase__:				Optional[Any]        =is_training
   lowerCamelCase__:				int        =use_labels
   lowerCamelCase__:				Tuple        =hidden_size
   lowerCamelCase__:				Dict        =num_hidden_layers
   lowerCamelCase__:				int        =num_attention_heads
   lowerCamelCase__:				Tuple        =intermediate_size
   lowerCamelCase__:				List[str]        =hidden_act
   lowerCamelCase__:				Any        =hidden_dropout_prob
   lowerCamelCase__:				str        =attention_probs_dropout_prob
   lowerCamelCase__:				Optional[Any]        =attention_type
   lowerCamelCase__:				str        =initializer_range
   lowerCamelCase__:				List[Any]        =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__:				str        =(num_frames) * self.num_patches_per_frame + 1

 def 							SCREAMING_SNAKE_CASE_ (self    :       str)	->Dict:



   '''simple docstring'''



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

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

   lowerCamelCase__:				Dict        =self.get_config()

   return config, pixel_values, labels

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



   '''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__:				Optional[Any]        =self.num_labels
   return config

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



   '''simple docstring'''



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

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



   '''simple docstring'''



   lowerCamelCase__:				Optional[Any]        =TimesformerForVideoClassification(snake_case__)
   model.to(snake_case__)
   model.eval()

   lowerCamelCase__:				List[str]        =model(snake_case__)

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







 def 							SCREAMING_SNAKE_CASE_ (self    :       int)	->Tuple:



   '''simple docstring'''



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



@require_torch
class        _SCREAMING_SNAKE_CASE						(     lowerCamelCase__   ,							lowerCamelCase__   ,							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    :       List[Any])	->Dict:



   '''simple docstring'''



   lowerCamelCase__:				Optional[int]        =TimesformerModelTester(self)
   lowerCamelCase__:				Dict        =ConfigTester(
       self	,			config_class=snake_case__	,			has_text_modality=snake_case__	,			hidden_size=37)

 def 							SCREAMING_SNAKE_CASE_ (self    :       Tuple	,			UpperCAmelCase_    :       int	,			UpperCAmelCase_    :       Optional[int]	,			UpperCAmelCase_    :       int=False)	->Tuple:



   '''simple docstring'''



   lowerCamelCase__:				Union[str, Any]        =copy.deepcopy(snake_case__)

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

   return inputs_dict

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



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



   '''simple docstring'''



   lowerCamelCase__:				int        =self.model_tester.prepare_config_and_inputs_for_common()

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

 def 							SCREAMING_SNAKE_CASE_ (self    :       Any)	->Dict:



   '''simple docstring'''



   lowerCamelCase__:				str        =self.model_tester.prepare_config_and_inputs_for_common()

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

     lowerCamelCase__:				Tuple        =['''pixel_values''']
     self.assertListEqual(arg_names[:1]	,			snake_case__)

 def 							SCREAMING_SNAKE_CASE_ (self    :       Dict)	->Dict:



   '''simple docstring'''



   lowerCamelCase__:				List[str]        =self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*snake_case__)

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



   '''simple docstring'''



   lowerCamelCase__:				List[Any]        =self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_video_classification(*snake_case__)

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



   '''simple docstring'''



   for model_name in TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     lowerCamelCase__:				List[str]        =TimesformerModel.from_pretrained(snake_case__)
     self.assertIsNotNone(snake_case__)

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



   '''simple docstring'''



   if not self.has_attentions:
     pass

   else:
     lowerCamelCase__:				Dict        =self.model_tester.prepare_config_and_inputs_for_common()
     lowerCamelCase__:				Dict        =True

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

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

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

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

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

       lowerCamelCase__:				Optional[Any]        =outputs.attentions

       self.assertEqual(len(snake_case__)	,			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    :       Any)	->int:



   '''simple docstring'''



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

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

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

     lowerCamelCase__:				Optional[int]        =self.model_tester.seq_length

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

   lowerCamelCase__:				str        =self.model_tester.prepare_config_and_inputs_for_common()

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

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

     check_hidden_states_output(snake_case__	,			snake_case__	,			snake_case__)





def 					lowerCAmelCase_			(	)					->		List[Any]:







  """simple docstring"""





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






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







 '''simple docstring'''

 @cached_property
 def 							SCREAMING_SNAKE_CASE_ (self    :       Dict)	->Union[str, 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    :       Union[str, Any])	->int:



   '''simple docstring'''



   lowerCamelCase__:				Tuple        =TimesformerForVideoClassification.from_pretrained("facebook/timesformer-base-finetuned-k400").to(
       snake_case__)

   lowerCamelCase__:				List[Any]        =self.default_image_processor
   lowerCamelCase__:				Union[str, Any]        =prepare_video()
   lowerCamelCase__:				str        =image_processor(video[:8]	,			return_tensors="pt").to(snake_case__)

   # forward pass
   with torch.no_grad():
     lowerCamelCase__:				List[Any]        =model(**snake_case__)

   # verify the logits
   lowerCamelCase__:				int        =torch.Size((1, 400))
   self.assertEqual(outputs.logits.shape	,			snake_case__)

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

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








from math import pow





def 					lowerCAmelCase_			(	__a     ,   __a     ,   __a     ,   __a     ,   __a     ,   )					->		tuple[int, int]:







  """simple docstring"""





  if current_sum == needed_sum:
    # If the sum of the powers is equal to needed_sum, then we have a solution.
    solutions_count += 1
    return current_sum, solutions_count

  lowerCamelCase__:				Optional[Any]        =int(pow(__a     ,   __a		)		)
  if current_sum + i_to_n <= needed_sum:
    # If the sum of the powers is less than needed_sum, then continue adding powers.
    current_sum += i_to_n
    lowerCamelCase__  , lowerCamelCase__:				int        =backtrack(
        __a     ,   __a     ,   current_number + 1     ,   __a     ,   __a		)
    current_sum -= i_to_n
  if i_to_n < needed_sum:
    # If the power of i is less than needed_sum, then try with the next power.
    lowerCamelCase__  , lowerCamelCase__:				Dict        =backtrack(
        __a     ,   __a     ,   current_number + 1     ,   __a     ,   __a		)
  return current_sum, solutions_count





def 					lowerCAmelCase_			(	__a     ,   __a		)					->		int:







  """simple docstring"""





  if not (1 <= needed_sum <= 1000 and 2 <= power <= 10):
    raise ValueError(
        "Invalid input\n"
        "needed_sum must be between 1 and 1000, power between 2 and 10."		)

  return backtrack(__a     ,   __a     ,   1     ,   0     ,   0		)[1]  # Return the solutions_count


if __name__ == "__main__":
     import doctest

     doctest.testmod()

