






'''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 						_UpperCamelCase							(     snake_case__							,			snake_case__=10							,			snake_case__=10							,			snake_case__=False							,			snake_case__=False							):
						__A		   =      []
						for i in range(image_processor_tester.num_frames							):
												video.append(np.random.randint(255							,			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
												__A		   =      [Image.fromarray(np.moveaxis(__lowerCamelCase							,			0							,			-1							)							) for frame in video]

						if torchify:
												__A		   =      [torch.from_numpy(__lowerCamelCase							) for frame in video]

						return video


def 						_UpperCamelCase							(     snake_case__							,			snake_case__=False							,			snake_case__=False							,			snake_case__=False							):
						assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

						__A		   =      []
						for i in range(image_processor_tester.batch_size							):
												if equal_resolution:
																		__A		   =      __A		   =      image_processor_tester.max_resolution
												else:
																		__A   ,				__A		   =      np.random.choice(
																		    np.arange(image_processor_tester.min_resolution							,			image_processor_tester.max_resolution							)							,			2							)
																		__A		   =      prepare_video(
																		    image_processor_tester=__lowerCamelCase							,			width=__lowerCamelCase							,			height=__lowerCamelCase							,			numpify=__lowerCamelCase							,			torchify=__lowerCamelCase							,			)
												video_inputs.append(__lowerCamelCase							)

						return video_inputs






class 					a__    (			unittest.TestCase						):
					'''simple docstring'''







					def __init__(self    :	List[str]				,				lowercase__    :	List[Any]				,				lowercase__    :	Optional[int]=7				,				lowercase__    :	Optional[int]=3				,				lowercase__    :	str=4				,				lowercase__    :	Optional[Any]=18				,				lowercase__    :	Dict=30				,				lowercase__    :	List[Any]=400				,				lowercase__    :	Optional[int]=True				,				lowercase__    :	List[Any]=None				,				lowercase__    :	List[str]=True				,				lowercase__    :	List[str]=[0.5, 0.5, 0.5]				,				lowercase__    :	int=[0.5, 0.5, 0.5]				,				lowercase__    :	str=True				,				lowercase__    :	Tuple=None				,				)  ->       List[str]:
											__A		   =      size if size is not None else {"shortest_edge": 18}
											__A		   =      crop_size if crop_size is not None else {"height": 18, "width": 18}

											__A		   =      parent
											__A		   =      batch_size
											__A		   =      num_channels
											__A		   =      num_frames
											__A		   =      image_size
											__A		   =      min_resolution
											__A		   =      max_resolution
											__A		   =      do_resize
											__A		   =      size
											__A		   =      do_normalize
											__A		   =      image_mean
											__A		   =      image_std
											__A		   =      do_center_crop
											__A		   =      crop_size






					def     _UpperCamelCase   (self    :	int					)  ->       Tuple:
											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 					a__    (			snake_case_ ,						unittest.TestCase						):
					'''simple docstring'''







					_snake_case             =  TvltImageProcessor if is_vision_available() else None






					def     _UpperCamelCase   (self    :	List[Any]					)  ->       Any:
											__A		   =      TvltImageProcessorTester(self					)






					@property
					def     _UpperCamelCase   (self    :	str					)  ->       Any:
											return self.image_processor_tester.prepare_image_processor_dict()






					def     _UpperCamelCase   (self    :	Dict					)  ->       Tuple:
											__A		   =      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[str]					)  ->       List[str]:
											# Initialize image_processor
											__A		   =      self.image_processing_class(**self.image_processor_dict					)
											# create random PIL videos
											__A		   =      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
											__A		   =      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
											__A		   =      image_processor(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    :	Dict					)  ->       Optional[int]:
											# Initialize image_processor
											__A		   =      self.image_processing_class(**self.image_processor_dict					)
											# create random numpy tensors
											__A		   =      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
											__A		   =      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
											__A		   =      image_processor(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]					)  ->       int:
											# Initialize image_processor
											__A		   =      self.image_processing_class(**self.image_processor_dict					)
											# create random PyTorch tensors
											__A		   =      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
											__A		   =      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
											__A		   =      image_processor(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 						_UpperCamelCase							(     snake_case__							,			snake_case__							):
      if n < 0:
            return 0
      # table[i] represents the number of ways to get to amount i
      __A		   =      [0] * (n + 1)

      # There is exactly 1 way to get to zero(You pick no coins).
      __A		   =      1

      # Pick all coins one by one and update table[] values
      # after the index greater than or equal to the value of the
      # picked coin
      for coin_val in s:
            for j in range(snake_case__							,			n + 1							):
                  table[j] += table[j - coin_val]

      return table[n]


if __name__ == "__main__":
       import doctest

       doctest.testmod()


