"""simple docstring"""






from __future__ import annotations

import copy
import os
import tempfile
from importlib import import_module
from math import isnan

from transformers import is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import _tf_gpu_memory_limit, require_tf, slow

from ..test_modeling_tf_common import ids_tensor


if is_tf_available():
       import numpy as np
       import tensorflow as tf

       from transformers import (
           TF_MODEL_FOR_CAUSAL_LM_MAPPING,
           TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
           TF_MODEL_FOR_MASKED_LM_MAPPING,
           TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
           TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
           TF_MODEL_FOR_PRETRAINING_MAPPING,
           TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
           TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
           TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
           TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
           TFSharedEmbeddings,
       )

       if _tf_gpu_memory_limit is not None:
              __A            =				tf.config.list_physical_devices("GPU")
              for gpu in gpus:
                     # Restrict TensorFlow to only allocate x GB of memory on the GPUs
                     try:
                            tf.config.set_logical_device_configuration(
                                gpu, [tf.config.LogicalDeviceConfiguration(memory_limit=_tf_gpu_memory_limit)]
                            )
                            __A            =				tf.config.list_logical_devices("GPU")
                            print("Logical GPUs", logical_gpus)
                     except RuntimeError as e:
                            # Virtual devices must be set before GPUs have been initialized
                            print(e)


@require_tf
class 					UpperCAmelCase		:



    """simple docstring"""

    _UpperCAmelCase			:List[Any]							=				None
    _UpperCAmelCase			:int							=				()
    _UpperCAmelCase			:List[Any]							=				()
    _UpperCAmelCase			:Optional[int]							=				True
    _UpperCAmelCase			:List[str]							=				True
    _UpperCAmelCase			:Any							=				True
    _UpperCAmelCase			:Optional[int]							=				False






    def _snake_case    (     self					,    _UpperCAmelCase					,    _UpperCAmelCase					,    _UpperCAmelCase=False							):
       lowercase__:     List[str]      =   copy.deepcopy(_UpperCAmelCase							)

       if model_class in get_values(_UpperCAmelCase							):
          lowercase__:     Union[str, Any]      =   {
              k: tf.tile(tf.expand_dims(_UpperCAmelCase					,    1							)					,    (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)							)
              if isinstance(_UpperCAmelCase					,    tf.Tensor							) and v.ndim > 0
              else v
              for k, v in inputs_dict.items()
          }

       if return_labels:
          if model_class in get_values(_UpperCAmelCase							):
             lowercase__:     str      =   tf.ones(self.model_tester.batch_size					,    dtype=tf.intaa							)
          elif model_class in get_values(_UpperCAmelCase							):
             lowercase__:     str      =   tf.zeros(self.model_tester.batch_size					,    dtype=tf.intaa							)
             lowercase__:     Union[str, Any]      =   tf.zeros(self.model_tester.batch_size					,    dtype=tf.intaa							)
          elif model_class in [
              *get_values(_UpperCAmelCase							),
              *get_values(_UpperCAmelCase							),
          ]:
             lowercase__:     List[str]      =   tf.zeros(self.model_tester.batch_size					,    dtype=tf.intaa							)
          elif model_class in get_values(_UpperCAmelCase							):
             lowercase__:     List[Any]      =   tf.zeros(self.model_tester.batch_size					,    dtype=tf.intaa							)
          elif model_class in [
              *get_values(_UpperCAmelCase							),
              *get_values(_UpperCAmelCase							),
              *get_values(_UpperCAmelCase							),
              *get_values(_UpperCAmelCase							),
              *get_values(_UpperCAmelCase							),
          ]:
             lowercase__:     Optional[int]      =   tf.zeros(
                 (self.model_tester.batch_size, self.model_tester.seq_length)					,    dtype=tf.intaa							)
       return inputs_dict






    @slow
    def _snake_case    (     self							):
       lowercase__:     Optional[Any]      =   self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
          lowercase__:     str      =   self._prepare_for_class(_UpperCAmelCase					,    _UpperCAmelCase							)
          lowercase__:     Optional[Any]      =   model_class(_UpperCAmelCase							)

          @tf.function
          def run_in_graph_mode():
             return model(_UpperCAmelCase							)

          lowercase__:     int      =   run_in_graph_mode()
          self.assertIsNotNone(_UpperCAmelCase							)






    @slow
    def _snake_case    (     self							):
       lowercase__:     Dict      =   self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
          lowercase__:     List[Any]      =   self._prepare_for_class(_UpperCAmelCase					,    _UpperCAmelCase							)
          lowercase__:     int      =   model_class(_UpperCAmelCase							)

          @tf.function(experimental_compile=_UpperCAmelCase							)
          def run_in_graph_mode():
             return model(_UpperCAmelCase							)

          lowercase__:     List[Any]      =   run_in_graph_mode()
          self.assertIsNotNone(_UpperCAmelCase							)






    @slow
    def _snake_case    (     self							):
       lowercase__:     Optional[int]      =   self.model_tester.prepare_config_and_inputs_for_common()
       for model_class in self.all_model_classes[:2]:
          lowercase__:     Dict      =   model_class(_UpperCAmelCase							)
          if getattr(_UpperCAmelCase					,    '''hf_compute_loss'''					,    _UpperCAmelCase							):
             # Test that model correctly compute the loss with kwargs
             lowercase__:     Dict      =   self._prepare_for_class(inputs_dict.copy()					,    _UpperCAmelCase					,    return_labels=_UpperCAmelCase							)
             # Is there a better way to remove these decoder inputs?
             lowercase__:     Optional[Any]      =   {
                 key: val
                 for key, val in prepared_for_class.items()
                 if key not in ('''head_mask''', '''decoder_head_mask''', '''cross_attn_head_mask''', '''decoder_input_ids''')
             }

             lowercase__:     int      =   {
                 '''labels''',
                 '''label''',
                 '''label_ids''',
                 '''start_positions''',
                 '''start_position''',
                 '''end_positions''',
                 '''end_position''',
                 '''next_sentence_label''',
             }
             lowercase__:     List[Any]      =   possible_label_cols.intersection(set(_UpperCAmelCase							)							)
             self.assertGreater(len(_UpperCAmelCase							)					,    0					,    msg='''No matching label names found!'''							)
             lowercase__:     Union[str, Any]      =   {key: val for key, val in prepared_for_class.items() if key in label_names}
             lowercase__:     List[Any]      =   {key: val for key, val in prepared_for_class.items() if key not in label_names}
             self.assertGreater(len(_UpperCAmelCase							)					,    0							)

             # Make sure it works with XLA!
             model.compile(optimizer=tf.keras.optimizers.SGD(0.0							)					,    jit_compile=_UpperCAmelCase							)
             # Make sure the model fits without crashing regardless of where we pass the labels
             lowercase__:     Tuple      =   model.fit(
                 _UpperCAmelCase					,    validation_data=_UpperCAmelCase					,    steps_per_epoch=1					,    validation_steps=1					,    shuffle=_UpperCAmelCase					,    verbose=0					,    )
             lowercase__:     int      =   history.history['''loss'''][0]
             self.assertTrue(not isnan(_UpperCAmelCase							)							)
             lowercase__:     List[Any]      =   history.history['''val_loss'''][0]
             self.assertTrue(not isnan(_UpperCAmelCase							)							)

             # Now test it with separate labels, to make sure that path works in XLA too.
             lowercase__:     Dict      =   model_class(_UpperCAmelCase							)
             model.compile(optimizer=tf.keras.optimizers.SGD(0.0							)					,    jit_compile=_UpperCAmelCase							)
             lowercase__:     Any      =   model.fit(
                 _UpperCAmelCase					,    _UpperCAmelCase					,    validation_data=(inputs_minus_labels, labels)					,    steps_per_epoch=1					,    validation_steps=1					,    shuffle=_UpperCAmelCase					,    verbose=0					,    )

             lowercase__:     int      =   history.history['''loss'''][0]
             self.assertTrue(not isnan(_UpperCAmelCase							)							)
             lowercase__:     Any      =   history.history['''val_loss'''][0]
             self.assertTrue(not isnan(_UpperCAmelCase							)							)






    @slow
    def _snake_case    (     self							):
       lowercase__:     Dict      =   self.model_tester.prepare_config_and_inputs_for_common()
       lowercase__:     Any      =   True
       lowercase__:     Dict      =   True

       if hasattr(_UpperCAmelCase					,    '''use_cache'''							):
          lowercase__:     Optional[Any]      =   True

       lowercase__:     Union[str, Any]      =   getattr(self.model_tester					,    '''encoder_seq_length'''					,    self.model_tester.seq_length							)
       lowercase__:     List[Any]      =   getattr(self.model_tester					,    '''key_length'''					,    _UpperCAmelCase							)

       for model_class in self.all_model_classes[:2]:
          lowercase__:     Any      =   self._prepare_for_class(_UpperCAmelCase					,    _UpperCAmelCase							)
          lowercase__:     Union[str, Any]      =   model_class(_UpperCAmelCase							)
          model.build()
          lowercase__:     Union[str, Any]      =   len(model(_UpperCAmelCase							)							)

          for key in list(class_inputs_dict.keys()							):
             # Remove keys not in the serving signature, as the SavedModel will not be compiled to deal with them
             if key not in model.input_signature:
                del class_inputs_dict[key]
             # Check it's a tensor, in case the inputs dict has some bools in it too
             elif isinstance(class_inputs_dict[key]					,    tf.Tensor							) and class_inputs_dict[key].dtype.is_integer:
                lowercase__:     Union[str, Any]      =   tf.cast(class_inputs_dict[key]					,    tf.intaa							)

          if set(class_inputs_dict.keys()							) != set(model.input_signature.keys()							):
             continue  # Some models have inputs that the preparation functions don't create, we skip those

          with tempfile.TemporaryDirectory() as tmpdirname:
             model.save_pretrained(_UpperCAmelCase					,    saved_model=_UpperCAmelCase							)
             lowercase__:     List[str]      =   os.path.join(_UpperCAmelCase					,    '''saved_model'''					,    '''1'''							)
             lowercase__:     int      =   tf.keras.models.load_model(_UpperCAmelCase							)
             lowercase__:     Optional[Any]      =   model(_UpperCAmelCase							)

             if self.is_encoder_decoder:
                lowercase__:     str      =   outputs['''encoder_hidden_states''']
                lowercase__:     str      =   outputs['''encoder_attentions''']
             else:
                lowercase__:     Optional[int]      =   outputs['''hidden_states''']
                lowercase__:     Tuple      =   outputs['''attentions''']

             self.assertEqual(len(_UpperCAmelCase							)					,    _UpperCAmelCase							)

             lowercase__:     Dict      =   getattr(
                 self.model_tester					,    '''expected_num_hidden_layers'''					,    self.model_tester.num_hidden_layers + 1							)

             self.assertEqual(len(_UpperCAmelCase							)					,    _UpperCAmelCase							)
             self.assertListEqual(
                 list(output_hidden_states[0].shape[-2:]							)					,    [self.model_tester.seq_length, self.model_tester.hidden_size]					,    )

             self.assertEqual(len(_UpperCAmelCase							)					,    self.model_tester.num_hidden_layers							)
             self.assertListEqual(
                 list(output_attentions[0].shape[-3:]							)					,    [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]					,    )






    @slow
    def _snake_case    (     self							):
       tf.keras.mixed_precision.set_global_policy('''mixed_float16'''							)

       # try/finally block to ensure subsequent tests run in float32
       try:
          lowercase__:     str      =   self.model_tester.prepare_config_and_inputs_for_common()
          for model_class in self.all_model_classes[:2]:
             lowercase__:     int      =   self._prepare_for_class(_UpperCAmelCase					,    _UpperCAmelCase							)
             lowercase__:     Tuple      =   model_class(_UpperCAmelCase							)
             lowercase__:     int      =   model(_UpperCAmelCase							)

             self.assertIsNotNone(_UpperCAmelCase							)
       finally:
          tf.keras.mixed_precision.set_global_policy('''float32'''							)






    @slow
    def _snake_case    (     self							):
       lowercase__:     Dict      =   self.model_tester.prepare_config_and_inputs_for_common()
       # head_mask and decoder_head_mask has different shapes than other input args
       if "head_mask" in inputs_dict:
          del inputs_dict["head_mask"]
       if "decoder_head_mask" in inputs_dict:
          del inputs_dict["decoder_head_mask"]
       if "cross_attn_head_mask" in inputs_dict:
          del inputs_dict["cross_attn_head_mask"]
       lowercase__:     str      =   {
           module_member
           for model_class in self.all_model_classes
           for module in (import_module(model_class.__module__							),)
           for module_member_name in dir(_UpperCAmelCase							)
           if module_member_name.endswith('''MainLayer'''							)
           for module_member in (getattr(_UpperCAmelCase					,    _UpperCAmelCase							),)
           if isinstance(_UpperCAmelCase					,    _UpperCAmelCase							)
           and tf.keras.layers.Layer in module_member.__bases__
           and getattr(_UpperCAmelCase					,    '''_keras_serializable'''					,    _UpperCAmelCase							)
       }

       for main_layer_class in tf_main_layer_classes:
          # T5MainLayer needs an embed_tokens parameter when called without the inputs_embeds parameter
          if "T5" in main_layer_class.__name__:
             # Take the same values than in TFT5ModelTester for this shared layer
             lowercase__:     Tuple      =   TFSharedEmbeddings(self.model_tester.vocab_size					,    self.model_tester.hidden_size					,    name='''shared'''							)
             lowercase__:     List[Any]      =   False
             lowercase__:     Any      =   main_layer_class(_UpperCAmelCase					,    embed_tokens=_UpperCAmelCase							)
          else:
             lowercase__:     Optional[Any]      =   main_layer_class(_UpperCAmelCase							)

          lowercase__:     int      =   {
              name: tf.keras.Input(tensor.shape[1:]					,    dtype=tensor.dtype							) for name, tensor in inputs_dict.items()
          }

          if hasattr(self.model_tester					,    '''num_labels'''							):
             lowercase__:     Optional[Any]      =   self.model_tester.num_labels
          else:
             lowercase__:     Tuple      =   2

          lowercase__:     Optional[int]      =   tf.data.Dataset.from_tensor_slices(
              (inputs_dict, np.ones((self.model_tester.batch_size, self.model_tester.seq_length, num_labels, 1)							))							).batch(1							)

          lowercase__:     Union[str, Any]      =   main_layer(_UpperCAmelCase							)[0]
          lowercase__:     str      =   tf.keras.layers.Dense(_UpperCAmelCase					,    activation='''softmax'''					,    name='''outputs'''							)(_UpperCAmelCase							)
          lowercase__:     Dict      =   tf.keras.models.Model(inputs=_UpperCAmelCase					,    outputs=[outputs]							)

          model.compile(loss='''binary_crossentropy'''					,    optimizer='''adam'''					,    metrics=['''binary_accuracy''']							)
          model.fit(_UpperCAmelCase					,    epochs=1							)

          with tempfile.TemporaryDirectory() as tmpdirname:
             lowercase__:     Optional[int]      =   os.path.join(_UpperCAmelCase					,    '''keras_model.h5'''							)
             model.save(_UpperCAmelCase							)
             if "T5" in main_layer_class.__name__:
                lowercase__:     Optional[Any]      =   tf.keras.models.load_model(
                    _UpperCAmelCase					,    custom_objects={
                        main_layer_class.__name__: main_layer_class,
                        '''TFSharedEmbeddings''': TFSharedEmbeddings,
                    }					,    )
             else:
                lowercase__:     Tuple      =   tf.keras.models.load_model(
                    _UpperCAmelCase					,    custom_objects={main_layer_class.__name__: main_layer_class}							)
             assert isinstance(_UpperCAmelCase					,    tf.keras.Model							)
             model(_UpperCAmelCase							)






    @slow
    def _snake_case    (     self							):
       lowercase__:     Optional[Any]      =   self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes[:2]:
          lowercase__:     int      =   model_class(_UpperCAmelCase							)

          lowercase__:     Tuple      =   copy.deepcopy(_UpperCAmelCase							)

          if not self.is_encoder_decoder:
             lowercase__:     List[str]      =   inputs['''input_ids''']
             del inputs["input_ids"]
          else:
             lowercase__:     Union[str, Any]      =   inputs['''input_ids''']
             lowercase__:     List[Any]      =   inputs.get('''decoder_input_ids'''					,    _UpperCAmelCase							)
             del inputs["input_ids"]
             inputs.pop('''decoder_input_ids'''					,    _UpperCAmelCase							)

          if not self.is_encoder_decoder:
             lowercase__:     str      =   model.get_input_embeddings()(_UpperCAmelCase							)
          else:
             lowercase__:     Dict      =   model.get_input_embeddings()(_UpperCAmelCase							)
             lowercase__:     str      =   model.get_input_embeddings()(_UpperCAmelCase							)

          lowercase__:     List[str]      =   self._prepare_for_class(_UpperCAmelCase					,    _UpperCAmelCase							)

          @tf.function
          def run_in_graph_mode():
             return model(_UpperCAmelCase							)

          lowercase__:     int      =   run_in_graph_mode()
          self.assertIsNotNone(_UpperCAmelCase							)






    def _snake_case    (     self					,    _UpperCAmelCase					,    _UpperCAmelCase							):
       lowercase__:     Dict      =   []
       if model.config.bos_token_id is not None:
          special_tokens.append(model.config.bos_token_id							)
       if model.config.pad_token_id is not None:
          special_tokens.append(model.config.pad_token_id							)
       if model.config.eos_token_id is not None:
          special_tokens.append(model.config.eos_token_id							)

       # create random bad tokens that are not special tokens
       lowercase__:     Optional[Any]      =   []
       while len(_UpperCAmelCase							) < num_bad_tokens:
          lowercase__:     Dict      =   tf.squeeze(ids_tensor((1, 1)					,    self.model_tester.vocab_size							)					,    0							).numpy()[0]
          if token not in special_tokens:
             bad_tokens.append(_UpperCAmelCase							)
       return bad_tokens






    def _snake_case    (     self					,    _UpperCAmelCase							):



       for token_id in output_ids[0].numpy().tolist():
          self.assertGreaterEqual(_UpperCAmelCase					,    0							)
          self.assertLess(_UpperCAmelCase					,    self.model_tester.vocab_size							)






    def _snake_case    (     self					,    _UpperCAmelCase					,    _UpperCAmelCase							):



       for bad_word_ids in bad_words_ids:
          # for all slices in batch
          for generated_ids_slice in generated_ids:
             # for all word idx
             for i in range(len(_UpperCAmelCase							)					,    len(_UpperCAmelCase							)							):
                # if tokens match
                if generated_ids_slice[i - len(_UpperCAmelCase							) : i] == bad_word_ids:
                   return True
       return False

"""simple docstring"""






import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import TvltImageProcessor



def SCREAMING_SNAKE_CASE__    (     __UpperCAmelCase ,					__UpperCAmelCase=1_0 ,					__UpperCAmelCase=1_0 ,					__UpperCAmelCase=False ,					__UpperCAmelCase=False				)						->						List[str]:
   lowercase__:     List[Any]      =   []
   for i in range(image_processor_tester.num_frames				):
      video.append(np.random.randint(2_5_5 ,					size=(image_processor_tester.num_channels, width, height) ,					dtype=np.uinta				)				)

   if not numpify and not torchify:
      # PIL expects the channel dimension as last dimension
      lowercase__:     Union[str, Any]      =   [Image.fromarray(np.moveaxis(__UpperCAmelCase ,					0 ,					-1				)				) for frame in video]

   if torchify:
      lowercase__:     List[str]      =   [torch.from_numpy(__UpperCAmelCase				) for frame in video]

   return video



def SCREAMING_SNAKE_CASE__    (     __UpperCAmelCase ,					__UpperCAmelCase=False ,					__UpperCAmelCase=False ,					__UpperCAmelCase=False				)						->						Tuple:
   assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

   lowercase__:     int      =   []
   for i in range(image_processor_tester.batch_size				):
      if equal_resolution:
         lowercase__:     Any      =   image_processor_tester.max_resolution
      else:
         lowercase__,				lowercase__:     Union[str, Any]      =   np.random.choice(
             np.arange(image_processor_tester.min_resolution ,					image_processor_tester.max_resolution				) ,					2				)
         lowercase__:     str      =   prepare_video(
             image_processor_tester=__UpperCAmelCase ,					width=__UpperCAmelCase ,					height=__UpperCAmelCase ,					numpify=__UpperCAmelCase ,					torchify=__UpperCAmelCase ,					)
      video_inputs.append(__UpperCAmelCase				)

   return video_inputs


class 					UpperCAmelCase		(unittest.TestCase						):



    """simple docstring"""

    def __init__(     self					,    _UpperCAmelCase					,    _UpperCAmelCase=7					,    _UpperCAmelCase=3					,    _UpperCAmelCase=4					,    _UpperCAmelCase=18					,    _UpperCAmelCase=30					,    _UpperCAmelCase=400					,    _UpperCAmelCase=True					,    _UpperCAmelCase=None					,    _UpperCAmelCase=True					,    _UpperCAmelCase=[0.5, 0.5, 0.5]					,    _UpperCAmelCase=[0.5, 0.5, 0.5]					,    _UpperCAmelCase=True					,    _UpperCAmelCase=None					,    ):
       lowercase__:     Any      =   size if size is not None else {'''shortest_edge''': 18}
       lowercase__:     List[Any]      =   crop_size if crop_size is not None else {'''height''': 18, '''width''': 18}

       lowercase__:     List[Any]      =   parent
       lowercase__:     List[str]      =   batch_size
       lowercase__:     Union[str, Any]      =   num_channels
       lowercase__:     List[Any]      =   num_frames
       lowercase__:     Tuple      =   image_size
       lowercase__:     List[Any]      =   min_resolution
       lowercase__:     Union[str, Any]      =   max_resolution
       lowercase__:     Dict      =   do_resize
       lowercase__:     List[Any]      =   size
       lowercase__:     str      =   do_normalize
       lowercase__:     int      =   image_mean
       lowercase__:     Any      =   image_std
       lowercase__:     List[Any]      =   do_center_crop
       lowercase__:     Optional[int]      =   crop_size






    def _snake_case    (     self							):
       return {
           "image_mean": self.image_mean,
           "image_std": self.image_std,
           "do_normalize": self.do_normalize,
           "do_resize": self.do_resize,
           "size": self.size,
           "do_center_crop": self.do_center_crop,
           "crop_size": self.crop_size,
       }



@require_torch
@require_vision
class 					UpperCAmelCase		(_UpperCAmelCase					,unittest.TestCase						):



    """simple docstring"""

    _UpperCAmelCase			:str							=				TvltImageProcessor if is_vision_available() else None






    def _snake_case    (     self							):
       lowercase__:     List[Any]      =   TvltImageProcessorTester(self							)






    @property
    def _snake_case    (     self							):
       return self.image_processor_tester.prepare_image_processor_dict()






    def _snake_case    (     self							):
       lowercase__:     List[str]      =   self.image_processing_class(**self.image_processor_dict							)
       self.assertTrue(hasattr(_UpperCAmelCase					,    '''image_mean'''							)							)
       self.assertTrue(hasattr(_UpperCAmelCase					,    '''image_std'''							)							)
       self.assertTrue(hasattr(_UpperCAmelCase					,    '''do_normalize'''							)							)
       self.assertTrue(hasattr(_UpperCAmelCase					,    '''do_resize'''							)							)
       self.assertTrue(hasattr(_UpperCAmelCase					,    '''do_center_crop'''							)							)
       self.assertTrue(hasattr(_UpperCAmelCase					,    '''size'''							)							)






    def _snake_case    (     self							):
       # Initialize image_processor
       lowercase__:     List[str]      =   self.image_processing_class(**self.image_processor_dict							)
       # create random PIL videos
       lowercase__:     str      =   prepare_video_inputs(self.image_processor_tester					,    equal_resolution=_UpperCAmelCase							)
       for video in video_inputs:
          self.assertIsInstance(_UpperCAmelCase					,    _UpperCAmelCase							)
          self.assertIsInstance(video[0]					,    Image.Image							)

       # Test not batched input
       lowercase__:     Union[str, Any]      =   image_processor(video_inputs[0]					,    return_tensors='''pt'''							).pixel_values
       self.assertEqual(
           encoded_videos.shape					,    (
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )					,    )

       # Test batched
       lowercase__:     Tuple      =   image_processor(_UpperCAmelCase					,    return_tensors='''pt'''							).pixel_values
       self.assertEqual(
           encoded_videos.shape					,    (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )					,    )






    def _snake_case    (     self							):
       # Initialize image_processor
       lowercase__:     str      =   self.image_processing_class(**self.image_processor_dict							)
       # create random numpy tensors
       lowercase__:     List[str]      =   prepare_video_inputs(self.image_processor_tester					,    equal_resolution=_UpperCAmelCase					,    numpify=_UpperCAmelCase							)
       for video in video_inputs:
          self.assertIsInstance(_UpperCAmelCase					,    _UpperCAmelCase							)
          self.assertIsInstance(video[0]					,    np.ndarray							)

       # Test not batched input
       lowercase__:     Optional[Any]      =   image_processor(video_inputs[0]					,    return_tensors='''pt'''							).pixel_values
       self.assertEqual(
           encoded_videos.shape					,    (
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )					,    )

       # Test batched
       lowercase__:     Tuple      =   image_processor(_UpperCAmelCase					,    return_tensors='''pt'''							).pixel_values
       self.assertEqual(
           encoded_videos.shape					,    (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )					,    )






    def _snake_case    (     self							):
       # Initialize image_processor
       lowercase__:     List[Any]      =   self.image_processing_class(**self.image_processor_dict							)
       # create random PyTorch tensors
       lowercase__:     Optional[int]      =   prepare_video_inputs(self.image_processor_tester					,    equal_resolution=_UpperCAmelCase					,    torchify=_UpperCAmelCase							)
       for video in video_inputs:
          self.assertIsInstance(_UpperCAmelCase					,    _UpperCAmelCase							)
          self.assertIsInstance(video[0]					,    torch.Tensor							)

       # Test not batched input
       lowercase__:     Optional[Any]      =   image_processor(video_inputs[0]					,    return_tensors='''pt'''							).pixel_values
       self.assertEqual(
           encoded_videos.shape					,    (
               1,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )					,    )

       # Test batched
       lowercase__:     List[Any]      =   image_processor(_UpperCAmelCase					,    return_tensors='''pt'''							).pixel_values
       self.assertEqual(
           encoded_videos.shape					,    (
               self.image_processor_tester.batch_size,
               self.image_processor_tester.num_frames,
               self.image_processor_tester.num_channels,
               self.image_processor_tester.crop_size['''height'''],
               self.image_processor_tester.crop_size['''width'''],
           )					,    )
