





import unittest

from huggingface_hub import hf_hub_download

from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VideoMAEFeatureExtractor
from transformers.pipelines import VideoClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_decord,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
)

from .test_pipelines_common import ANY



@is_pipeline_test
@require_torch_or_tf
@require_vision
@require_decord
class  __lowerCAmelCase	(      unittest.TestCase					):
   lowerCamelCase_					:					List[Any]	      =				MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING






   def       lowerCamelCase  (self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__   )					->       str:


       '''simple docstring'''



       snake_case_						:   int           =  hf_hub_download(
           repo_id='''nateraw/video-demo''' ,							filename='''archery.mp4''' ,							repo_type='''dataset'''   )
       snake_case_						:   List[str]           =  VideoClassificationPipeline(model=__magic_name__ ,							image_processor=__magic_name__ ,							top_k=2   )
       snake_case_						:   Any           =  [
           example_video_filepath,
           '''https://huggingface.co/datasets/nateraw/video-demo/resolve/main/archery.mp4''',
       ]
       return video_classifier, examples






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


       '''simple docstring'''



       for example in examples:
           snake_case_						:   Optional[Any]           =  video_classifier(__magic_name__   )

           self.assertEqual(
               __magic_name__ ,							[
                   {'''score''': ANY(__magic_name__   ), '''label''': ANY(__magic_name__   )},
                   {'''score''': ANY(__magic_name__   ), '''label''': ANY(__magic_name__   )},
               ] ,							)






   @require_torch
   def       lowerCamelCase  (self   )					->       int:


       '''simple docstring'''



       snake_case_						:   Optional[int]           =  '''hf-internal-testing/tiny-random-VideoMAEForVideoClassification'''
       snake_case_						:   int           =  VideoMAEFeatureExtractor(
           size={'''shortest_edge''': 10} ,							crop_size={'''height''': 10, '''width''': 10}   )
       snake_case_						:   int           =  pipeline(
           '''video-classification''' ,							model=__magic_name__ ,							feature_extractor=__magic_name__ ,							frame_sampling_rate=4   )

       snake_case_						:   str           =  hf_hub_download(repo_id='''nateraw/video-demo''' ,							filename='''archery.mp4''' ,							repo_type='''dataset'''   )
       snake_case_						:   Optional[int]           =  video_classifier(__magic_name__ ,							top_k=2   )
       self.assertEqual(
           nested_simplify(__magic_name__ ,							decimals=4   ) ,							[{'''score''': 0.5_199, '''label''': '''LABEL_0'''}, {'''score''': 0.4_801, '''label''': '''LABEL_1'''}] ,							)

       snake_case_						:   int           =  video_classifier(
           [
               video_file_path,
               video_file_path,
           ] ,							top_k=2 ,							)
       self.assertEqual(
           nested_simplify(__magic_name__ ,							decimals=4   ) ,							[
               [{'''score''': 0.5_199, '''label''': '''LABEL_0'''}, {'''score''': 0.4_801, '''label''': '''LABEL_1'''}],
               [{'''score''': 0.5_199, '''label''': '''LABEL_0'''}, {'''score''': 0.4_801, '''label''': '''LABEL_1'''}],
           ] ,							)






   @require_tf
   def       lowerCamelCase  (self   )					->       Optional[Any]:


       '''simple docstring'''



       pass







import flax.linen as nn
import jax.numpy as jnp

from .attention_flax import FlaxTransformeraDModel
from .resnet_flax import FlaxDownsampleaD, FlaxResnetBlockaD, FlaxUpsampleaD



class  __lowerCAmelCase	(      nn.Module					):
			lowerCamelCase_					:					int
			lowerCamelCase_					:					int
			lowerCamelCase_					:					float	      =				0.0
			lowerCamelCase_					:					int	      =				1
			lowerCamelCase_					:					int	      =				1
			lowerCamelCase_					:					bool	      =				True
			lowerCamelCase_					:					bool	      =				False
			lowerCamelCase_					:					bool	      =				False
			lowerCamelCase_					:					bool	      =				False
			lowerCamelCase_					:					jnp.dtype	      =				jnp.floataa






			def       lowerCamelCase  (self   )					->       Tuple:


							'''simple docstring'''



							snake_case_						:   Tuple           =  []
							snake_case_						:   List[str]           =  []

							for i in range(self.num_layers   ):
											snake_case_						:   Tuple           =  self.in_channels if i == 0 else self.out_channels

											snake_case_						:   Dict           =  FlaxResnetBlockaD(
											    in_channels=__magic_name__ ,							out_channels=self.out_channels ,							dropout_prob=self.dropout ,							dtype=self.dtype ,							)
											resnets.append(__magic_name__   )

											snake_case_						:   str           =  FlaxTransformeraDModel(
											    in_channels=self.out_channels ,							n_heads=self.num_attention_heads ,							d_head=self.out_channels // self.num_attention_heads ,							depth=1 ,							use_linear_projection=self.use_linear_projection ,							only_cross_attention=self.only_cross_attention ,							use_memory_efficient_attention=self.use_memory_efficient_attention ,							dtype=self.dtype ,							)
											attentions.append(__magic_name__   )

							snake_case_						:   Union[str, Any]           =  resnets
							snake_case_						:   Union[str, Any]           =  attentions

							if self.add_downsample:
											snake_case_						:   List[str]           =  FlaxDownsampleaD(self.out_channels ,							dtype=self.dtype   )






			def __call__(self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__=True   )					->       List[Any]:


							'''simple docstring'''



							snake_case_						:   str           =  ()

							for resnet, attn in zip(self.resnets ,							self.attentions   ):
											snake_case_						:   Optional[Any]           =  resnet(__magic_name__ ,							__magic_name__ ,							deterministic=__magic_name__   )
											snake_case_						:   List[str]           =  attn(__magic_name__ ,							__magic_name__ ,							deterministic=__magic_name__   )
											output_states += (hidden_states,)

							if self.add_downsample:
											snake_case_						:   Union[str, Any]           =  self.downsamplers_a(__magic_name__   )
											output_states += (hidden_states,)

							return hidden_states, output_states




class  __lowerCAmelCase	(      nn.Module					):
			lowerCamelCase_					:					int
			lowerCamelCase_					:					int
			lowerCamelCase_					:					float	      =				0.0
			lowerCamelCase_					:					int	      =				1
			lowerCamelCase_					:					bool	      =				True
			lowerCamelCase_					:					jnp.dtype	      =				jnp.floataa






			def       lowerCamelCase  (self   )					->       Dict:


							'''simple docstring'''



							snake_case_						:   Optional[Any]           =  []

							for i in range(self.num_layers   ):
											snake_case_						:   List[Any]           =  self.in_channels if i == 0 else self.out_channels

											snake_case_						:   Tuple           =  FlaxResnetBlockaD(
											    in_channels=__magic_name__ ,							out_channels=self.out_channels ,							dropout_prob=self.dropout ,							dtype=self.dtype ,							)
											resnets.append(__magic_name__   )
							snake_case_						:   Dict           =  resnets

							if self.add_downsample:
											snake_case_						:   Optional[int]           =  FlaxDownsampleaD(self.out_channels ,							dtype=self.dtype   )






			def __call__(self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__=True   )					->       Optional[Any]:


							'''simple docstring'''



							snake_case_						:   Any           =  ()

							for resnet in self.resnets:
											snake_case_						:   List[Any]           =  resnet(__magic_name__ ,							__magic_name__ ,							deterministic=__magic_name__   )
											output_states += (hidden_states,)

							if self.add_downsample:
											snake_case_						:   str           =  self.downsamplers_a(__magic_name__   )
											output_states += (hidden_states,)

							return hidden_states, output_states




class  __lowerCAmelCase	(      nn.Module					):
			lowerCamelCase_					:					int
			lowerCamelCase_					:					int
			lowerCamelCase_					:					int
			lowerCamelCase_					:					float	      =				0.0
			lowerCamelCase_					:					int	      =				1
			lowerCamelCase_					:					int	      =				1
			lowerCamelCase_					:					bool	      =				True
			lowerCamelCase_					:					bool	      =				False
			lowerCamelCase_					:					bool	      =				False
			lowerCamelCase_					:					bool	      =				False
			lowerCamelCase_					:					jnp.dtype	      =				jnp.floataa






			def       lowerCamelCase  (self   )					->       str:


							'''simple docstring'''



							snake_case_						:   Optional[Any]           =  []
							snake_case_						:   Optional[Any]           =  []

							for i in range(self.num_layers   ):
											snake_case_						:   List[Any]           =  self.in_channels if (i == self.num_layers - 1) else self.out_channels
											snake_case_						:   Optional[int]           =  self.prev_output_channel if i == 0 else self.out_channels

											snake_case_						:   Dict           =  FlaxResnetBlockaD(
											    in_channels=resnet_in_channels + res_skip_channels ,							out_channels=self.out_channels ,							dropout_prob=self.dropout ,							dtype=self.dtype ,							)
											resnets.append(__magic_name__   )

											snake_case_						:   List[str]           =  FlaxTransformeraDModel(
											    in_channels=self.out_channels ,							n_heads=self.num_attention_heads ,							d_head=self.out_channels // self.num_attention_heads ,							depth=1 ,							use_linear_projection=self.use_linear_projection ,							only_cross_attention=self.only_cross_attention ,							use_memory_efficient_attention=self.use_memory_efficient_attention ,							dtype=self.dtype ,							)
											attentions.append(__magic_name__   )

							snake_case_						:   List[Any]           =  resnets
							snake_case_						:   Tuple           =  attentions

							if self.add_upsample:
											snake_case_						:   List[Any]           =  FlaxUpsampleaD(self.out_channels ,							dtype=self.dtype   )






			def __call__(self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__=True   )					->       Union[str, Any]:


							'''simple docstring'''



							for resnet, attn in zip(self.resnets ,							self.attentions   ):
											# pop res hidden states
											snake_case_						:   Dict           =  res_hidden_states_tuple[-1]
											snake_case_						:   List[Any]           =  res_hidden_states_tuple[:-1]
											snake_case_						:   Optional[int]           =  jnp.concatenate((hidden_states, res_hidden_states) ,							axis=-1   )

											snake_case_						:   Tuple           =  resnet(__magic_name__ ,							__magic_name__ ,							deterministic=__magic_name__   )
											snake_case_						:   Tuple           =  attn(__magic_name__ ,							__magic_name__ ,							deterministic=__magic_name__   )

							if self.add_upsample:
											snake_case_						:   Optional[Any]           =  self.upsamplers_a(__magic_name__   )

							return hidden_states




class  __lowerCAmelCase	(      nn.Module					):
			lowerCamelCase_					:					int
			lowerCamelCase_					:					int
			lowerCamelCase_					:					int
			lowerCamelCase_					:					float	      =				0.0
			lowerCamelCase_					:					int	      =				1
			lowerCamelCase_					:					bool	      =				True
			lowerCamelCase_					:					jnp.dtype	      =				jnp.floataa






			def       lowerCamelCase  (self   )					->       int:


							'''simple docstring'''



							snake_case_						:   Union[str, Any]           =  []

							for i in range(self.num_layers   ):
											snake_case_						:   Tuple           =  self.in_channels if (i == self.num_layers - 1) else self.out_channels
											snake_case_						:   Optional[Any]           =  self.prev_output_channel if i == 0 else self.out_channels

											snake_case_						:   int           =  FlaxResnetBlockaD(
											    in_channels=resnet_in_channels + res_skip_channels ,							out_channels=self.out_channels ,							dropout_prob=self.dropout ,							dtype=self.dtype ,							)
											resnets.append(__magic_name__   )

							snake_case_						:   Tuple           =  resnets

							if self.add_upsample:
											snake_case_						:   List[str]           =  FlaxUpsampleaD(self.out_channels ,							dtype=self.dtype   )






			def __call__(self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__=True   )					->       List[Any]:


							'''simple docstring'''



							for resnet in self.resnets:
											# pop res hidden states
											snake_case_						:   Tuple           =  res_hidden_states_tuple[-1]
											snake_case_						:   List[Any]           =  res_hidden_states_tuple[:-1]
											snake_case_						:   Dict           =  jnp.concatenate((hidden_states, res_hidden_states) ,							axis=-1   )

											snake_case_						:   Optional[Any]           =  resnet(__magic_name__ ,							__magic_name__ ,							deterministic=__magic_name__   )

							if self.add_upsample:
											snake_case_						:   Optional[int]           =  self.upsamplers_a(__magic_name__   )

							return hidden_states




class  __lowerCAmelCase	(      nn.Module					):
			lowerCamelCase_					:					int
			lowerCamelCase_					:					float	      =				0.0
			lowerCamelCase_					:					int	      =				1
			lowerCamelCase_					:					int	      =				1
			lowerCamelCase_					:					bool	      =				False
			lowerCamelCase_					:					bool	      =				False
			lowerCamelCase_					:					jnp.dtype	      =				jnp.floataa






			def       lowerCamelCase  (self   )					->       str:


							'''simple docstring'''



							snake_case_						:   Dict           =  [
							    FlaxResnetBlockaD(
							        in_channels=self.in_channels ,							out_channels=self.in_channels ,							dropout_prob=self.dropout ,							dtype=self.dtype ,							)
							]

							snake_case_						:   int           =  []

							for _ in range(self.num_layers   ):
											snake_case_						:   str           =  FlaxTransformeraDModel(
											    in_channels=self.in_channels ,							n_heads=self.num_attention_heads ,							d_head=self.in_channels // self.num_attention_heads ,							depth=1 ,							use_linear_projection=self.use_linear_projection ,							use_memory_efficient_attention=self.use_memory_efficient_attention ,							dtype=self.dtype ,							)
											attentions.append(__magic_name__   )

											snake_case_						:   Dict           =  FlaxResnetBlockaD(
											    in_channels=self.in_channels ,							out_channels=self.in_channels ,							dropout_prob=self.dropout ,							dtype=self.dtype ,							)
											resnets.append(__magic_name__   )

							snake_case_						:   Optional[Any]           =  resnets
							snake_case_						:   Optional[int]           =  attentions






			def __call__(self ,							__magic_name__ ,							__magic_name__ ,							__magic_name__ ,							__magic_name__=True   )					->       Optional[int]:


							'''simple docstring'''



							snake_case_						:   List[Any]           =  self.resnets[0](__magic_name__ ,							__magic_name__   )
							for attn, resnet in zip(self.attentions ,							self.resnets[1:]   ):
											snake_case_						:   Tuple           =  attn(__magic_name__ ,							__magic_name__ ,							deterministic=__magic_name__   )
											snake_case_						:   Union[str, Any]           =  resnet(__magic_name__ ,							__magic_name__ ,							deterministic=__magic_name__   )

							return hidden_states
