


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, prepare_video_inputs


if is_torch_available():
       import torch

if is_vision_available():
       from PIL import Image

       from transformers import VivitImageProcessor

class 					__magic_name__		(   unittest.TestCase):


     def __init__(					self							:   Optional[Any]							,		lowerCamelCase__							:   Optional[Any]							,		lowerCamelCase__							:   str=7							,		lowerCamelCase__							:   Tuple=3							,		lowerCamelCase__							:   str=10							,		lowerCamelCase__							:   Any=18							,		lowerCamelCase__							:   List[Any]=30							,		lowerCamelCase__							:   Tuple=400							,		lowerCamelCase__							:   int=True							,		lowerCamelCase__							:   Union[str, Any]=None							,		lowerCamelCase__							:   Optional[int]=True							,		lowerCamelCase__							:   int=[0.5, 0.5, 0.5]							,		lowerCamelCase__							:   Optional[Any]=[0.5, 0.5, 0.5]							,		lowerCamelCase__							:   Any=None							,		)     ->					Union[str, Any]:





      '''simple docstring'''






      UpperCamelCase__    :			int      				=      size if size is not None else {"""shortest_edge""": 18}
      UpperCamelCase__    :			Optional[int]      				=      crop_size if crop_size is not None else {"""height""": 18, """width""": 18}

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


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





      '''simple docstring'''






      return {
          "image_mean": self.image_mean,
          "image_std": self.image_std,
          "do_normalize": self.do_normalize,
          "do_resize": self.do_resize,
          "size": self.size,
          "crop_size": self.crop_size,
      }



@require_torch
@require_vision
class 					__magic_name__		(   _UpperCAmelCase    , unittest.TestCase):
     A:						int								=					VivitImageProcessor if is_vision_available() else None


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





      '''simple docstring'''






      UpperCamelCase__    :			List[str]      				=      VivitImageProcessingTester(self	)


     @property
     def    UpperCAmelCase__		(					self							:   List[str]	)     ->					Dict:





      '''simple docstring'''






      return self.image_processor_tester.prepare_image_processor_dict()


     def    UpperCAmelCase__		(					self							:   str	)     ->					Optional[int]:





      '''simple docstring'''






      UpperCamelCase__    :			Union[str, Any]      				=      self.image_processing_class(**self.image_processor_dict	)
      self.assertTrue(hasattr(lowercase_							,		'''image_mean'''	)	)
      self.assertTrue(hasattr(lowercase_							,		'''image_std'''	)	)
      self.assertTrue(hasattr(lowercase_							,		'''do_normalize'''	)	)
      self.assertTrue(hasattr(lowercase_							,		'''do_resize'''	)	)
      self.assertTrue(hasattr(lowercase_							,		'''do_center_crop'''	)	)
      self.assertTrue(hasattr(lowercase_							,		'''size'''	)	)


     def    UpperCAmelCase__		(					self							:   List[Any]	)     ->					str:





      '''simple docstring'''






      UpperCamelCase__    :			Dict      				=      self.image_processing_class.from_dict(self.image_processor_dict	)
      self.assertEqual(image_processor.size							,		{'''shortest_edge''': 18}	)
      self.assertEqual(image_processor.crop_size							,		{'''height''': 18, '''width''': 18}	)

      UpperCamelCase__    :			Any      				=      self.image_processing_class.from_dict(self.image_processor_dict							,		size=42							,		crop_size=84	)
      self.assertEqual(image_processor.size							,		{'''shortest_edge''': 42}	)
      self.assertEqual(image_processor.crop_size							,		{'''height''': 84, '''width''': 84}	)


     def    UpperCAmelCase__		(					self							:   int	)     ->					Dict:





      '''simple docstring'''






      UpperCamelCase__    :			Optional[int]      				=      self.image_processing_class(**self.image_processor_dict	)
      # create random PIL videos
      UpperCamelCase__    :			Optional[Any]      				=      prepare_video_inputs(self.image_processor_tester							,		equal_resolution=lowercase_	)
      for video in video_inputs:
       self.assertIsInstance(lowercase_							,		lowercase_	)
       self.assertIsInstance(video[0]							,		Image.Image	)

      # Test not batched input
      UpperCamelCase__    :			Tuple      				=      image_processing(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
      UpperCamelCase__    :			Dict      				=      image_processing(lowercase_							,		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    UpperCAmelCase__		(					self							:   Union[str, Any]	)     ->					Any:





      '''simple docstring'''






      UpperCamelCase__    :			Optional[int]      				=      self.image_processing_class(**self.image_processor_dict	)
      # create random numpy tensors
      UpperCamelCase__    :			Dict      				=      prepare_video_inputs(self.image_processor_tester							,		equal_resolution=lowercase_							,		numpify=lowercase_	)
      for video in video_inputs:
       self.assertIsInstance(lowercase_							,		lowercase_	)
       self.assertIsInstance(video[0]							,		np.ndarray	)

      # Test not batched input
      UpperCamelCase__    :			List[str]      				=      image_processing(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
      UpperCamelCase__    :			int      				=      image_processing(lowercase_							,		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    UpperCAmelCase__		(					self							:   Optional[int]	)     ->					List[str]:





      '''simple docstring'''






      UpperCamelCase__    :			int      				=      self.image_processing_class(**self.image_processor_dict	)
      # create random PyTorch tensors
      UpperCamelCase__    :			Dict      				=      prepare_video_inputs(self.image_processor_tester							,		equal_resolution=lowercase_							,		torchify=lowercase_	)
      for video in video_inputs:
       self.assertIsInstance(lowercase_							,		lowercase_	)
       self.assertIsInstance(video[0]							,		torch.Tensor	)

      # Test not batched input
      UpperCamelCase__    :			Dict      				=      image_processing(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
      UpperCamelCase__    :			int      				=      image_processing(lowercase_							,		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'''],
          )							,		)



'''simple docstring'''




def 							lowerCamelCase	(      UpperCAmelCase__       :					int      ,      UpperCAmelCase__       :					int )			->      bool:
							return numa ^ numa < 0


if __name__ == "__main__":
						import doctest

						doctest.testmod()





