"""simple docstring"""

import inspect
from typing import List, Optional, Union

import torch
from torch import nn
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPImageProcessor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput






class 		_lowercase (						nn.Module      ):



						"""simple docstring"""




						def __init__(				self							:    List[str]     , UpperCamelCase__							:    Dict     , UpperCamelCase__							:    Optional[Any]=1.0				)				->				List[str]:
													'''simple docstring'''



													super().__init__()

													__UpperCamelCase							=cut_size
													__UpperCamelCase							=cut_power





						def   UpperCAmelCase_ (				self							:    Any     , UpperCamelCase__							:    Dict     , UpperCamelCase__							:    Union[str, Any]				)				->				int:
													'''simple docstring'''



													__UpperCamelCase	,      __UpperCamelCase							=pixel_values.shape[2:4]
													__UpperCamelCase							=min(__UpperCAmelCase     , __UpperCAmelCase				)
													__UpperCamelCase							=min(__UpperCAmelCase     , __UpperCAmelCase     , self.cut_size				)
													__UpperCamelCase							=[]
													for _ in range(__UpperCAmelCase				):
																				__UpperCamelCase							=int(torch.rand([]				) ** self.cut_power * (max_size - min_size) + min_size				)
																				__UpperCamelCase							=torch.randint(0     , sideX - size + 1     , ()				)
																				__UpperCamelCase							=torch.randint(0     , sideY - size + 1     , ()				)
																				__UpperCamelCase							=pixel_values[:, :, offsety : offsety + size, offsetx : offsetx + size]
																				cutouts.append(F.adaptive_avg_poolad(__UpperCAmelCase     , self.cut_size				)				)
													return torch.cat(__UpperCAmelCase				)






def    lowerCAmelCase			(__UpperCamelCase							:    Any							,					__UpperCamelCase							:    Union[str, Any]			):
							"""simple docstring"""


							__UpperCamelCase							=F.normalize(__UpperCamelCase							,					dim=-1			)
							__UpperCamelCase							=F.normalize(__UpperCamelCase							,					dim=-1			)
							return (x - y).norm(dim=-1			).div(2			).arcsin().pow(2			).mul(2			)


def    lowerCAmelCase			(__UpperCamelCase							:    Union[str, Any]							,					__UpperCamelCase							:    int			):
							"""simple docstring"""


							for param in model.parameters():
														__UpperCamelCase							=value






class 		_lowercase (						SCREAMING_SNAKE_CASE_      ):



						"""simple docstring"""




						def __init__(				self							:    Tuple     , UpperCamelCase__							:    Optional[int]     , UpperCamelCase__							:    Optional[Any]     , UpperCamelCase__							:    List[Any]     , UpperCamelCase__							:    List[Any]     , UpperCamelCase__							:    Dict     , UpperCamelCase__							:    Tuple     , UpperCamelCase__							:    Optional[int]     , )				->				str:
													'''simple docstring'''



													super().__init__()
													self.register_modules(
													    vae=__UpperCAmelCase     , text_encoder=__UpperCAmelCase     , clip_model=__UpperCAmelCase     , tokenizer=__UpperCAmelCase     , unet=__UpperCAmelCase     , scheduler=__UpperCAmelCase     , feature_extractor=__UpperCAmelCase     , )

													__UpperCamelCase							=transforms.Normalize(mean=feature_extractor.image_mean     , std=feature_extractor.image_std				)
													__UpperCamelCase							=(
													    feature_extractor.size
													    if isinstance(feature_extractor.size     , __UpperCAmelCase				)
													    else feature_extractor.size['''shortest_edge''']
													)
													__UpperCamelCase							=MakeCutouts(self.cut_out_size				)

													set_requires_grad(self.text_encoder     , __UpperCAmelCase				)
													set_requires_grad(self.clip_model     , __UpperCAmelCase				)





						def   UpperCAmelCase_ (				self							:    List[str]     , UpperCamelCase__							:    Dict = "auto"				)				->				Any:
													'''simple docstring'''



													if slice_size == "auto":
																				# half the attention head size is usually a good trade-off between
																				# speed and memory
																				__UpperCamelCase							=self.unet.config.attention_head_dim // 2
													self.unet.set_attention_slice(__UpperCAmelCase				)





						def   UpperCAmelCase_ (				self							:    List[Any]				)				->				Any:
													'''simple docstring'''



													self.enable_attention_slicing(__UpperCAmelCase				)





						def   UpperCAmelCase_ (				self							:    Optional[int]				)				->				str:
													'''simple docstring'''



													set_requires_grad(self.vae     , __UpperCAmelCase				)





						def   UpperCAmelCase_ (				self							:    Optional[Any]				)				->				int:
													'''simple docstring'''



													set_requires_grad(self.vae     , __UpperCAmelCase				)





						def   UpperCAmelCase_ (				self							:    Any				)				->				Dict:
													'''simple docstring'''



													set_requires_grad(self.unet     , __UpperCAmelCase				)





						def   UpperCAmelCase_ (				self							:    Optional[int]				)				->				int:
													'''simple docstring'''



													set_requires_grad(self.unet     , __UpperCAmelCase				)





						@torch.enable_grad()
						def   UpperCAmelCase_ (				self							:    Optional[int]     , UpperCamelCase__							:    Dict     , UpperCamelCase__							:    Tuple     , UpperCamelCase__							:    Optional[Any]     , UpperCamelCase__							:    Optional[Any]     , UpperCamelCase__							:    int     , UpperCamelCase__							:    Dict     , UpperCamelCase__							:    Union[str, Any]     , UpperCamelCase__							:    Union[str, Any]     , UpperCamelCase__							:    Tuple=True     , )				->				Dict:
													'''simple docstring'''



													__UpperCamelCase							=latents.detach().requires_grad_()

													__UpperCamelCase							=self.scheduler.scale_model_input(__UpperCAmelCase     , __UpperCAmelCase				)

													# predict the noise residual
													__UpperCamelCase							=self.unet(__UpperCAmelCase     , __UpperCAmelCase     , encoder_hidden_states=__UpperCAmelCase				).sample

													if isinstance(self.scheduler     , (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)				):
																				__UpperCamelCase							=self.scheduler.alphas_cumprod[timestep]
																				__UpperCamelCase							=1 - alpha_prod_t
																				# compute predicted original sample from predicted noise also called
																				# "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
																				__UpperCamelCase							=(latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

																				__UpperCamelCase							=torch.sqrt(__UpperCAmelCase				)
																				__UpperCamelCase							=pred_original_sample * (fac) + latents * (1 - fac)
													elif isinstance(self.scheduler     , __UpperCAmelCase				):
																				__UpperCamelCase							=self.scheduler.sigmas[index]
																				__UpperCamelCase							=latents - sigma * noise_pred
													else:
																				raise ValueError(f"""scheduler type {type(self.scheduler				)} not supported"""				)

													__UpperCamelCase							=1 / self.vae.config.scaling_factor * sample
													__UpperCamelCase							=self.vae.decode(__UpperCAmelCase				).sample
													__UpperCamelCase							=(image / 2 + 0.5).clamp(0     , 1				)

													if use_cutouts:
																				__UpperCamelCase							=self.make_cutouts(__UpperCAmelCase     , __UpperCAmelCase				)
													else:
																				__UpperCamelCase							=transforms.Resize(self.cut_out_size				)(__UpperCAmelCase				)
													__UpperCamelCase							=self.normalize(__UpperCAmelCase				).to(latents.dtype				)

													__UpperCamelCase							=self.clip_model.get_image_features(__UpperCAmelCase				)
													__UpperCamelCase							=image_embeddings_clip / image_embeddings_clip.norm(p=2     , dim=-1     , keepdim=__UpperCAmelCase				)

													if use_cutouts:
																				__UpperCamelCase							=spherical_dist_loss(__UpperCAmelCase     , __UpperCAmelCase				)
																				__UpperCamelCase							=dists.view([num_cutouts, sample.shape[0], -1]				)
																				__UpperCamelCase							=dists.sum(2				).mean(0				).sum() * clip_guidance_scale
													else:
																				__UpperCamelCase							=spherical_dist_loss(__UpperCAmelCase     , __UpperCAmelCase				).mean() * clip_guidance_scale

													__UpperCamelCase							=-torch.autograd.grad(__UpperCAmelCase     , __UpperCAmelCase				)[0]

													if isinstance(self.scheduler     , __UpperCAmelCase				):
																				__UpperCamelCase							=latents.detach() + grads * (sigma**2)
																				__UpperCamelCase							=noise_pred_original
													else:
																				__UpperCamelCase							=noise_pred_original - torch.sqrt(__UpperCAmelCase				) * grads
													return noise_pred, latents





						@torch.no_grad()
						def __call__(				self							:    str     , UpperCamelCase__							:    str     , UpperCamelCase__							:    Tuple = 512     , UpperCamelCase__							:    List[Any] = 512     , UpperCamelCase__							:    str = 50     , UpperCamelCase__							:    List[Any] = 7.5     , UpperCamelCase__							:    str = 1     , UpperCamelCase__							:    Optional[Any] = 0.0     , UpperCamelCase__							:    str = 100     , UpperCamelCase__							:    Dict = None     , UpperCamelCase__							:    List[str] = 4     , UpperCamelCase__							:    Optional[int] = True     , UpperCamelCase__							:    int = None     , UpperCamelCase__							:    List[str] = None     , UpperCamelCase__							:    int = "pil"     , UpperCamelCase__							:    Optional[Any] = True     , )				->				List[str]:
													'''simple docstring'''



													if isinstance(__UpperCAmelCase     , __UpperCAmelCase				):
																				__UpperCamelCase							=1
													elif isinstance(__UpperCAmelCase     , __UpperCAmelCase				):
																				__UpperCamelCase							=len(__UpperCAmelCase				)
													else:
																				raise ValueError(f"""`prompt` has to be of type `str` or `list` but is {type(__UpperCAmelCase				)}"""				)

													if height % 8 != 0 or width % 8 != 0:
																				raise ValueError(f"""`height` and `width` have to be divisible by 8 but are {height} and {width}."""				)

													# get prompt text embeddings
													__UpperCamelCase							=self.tokenizer(
													    __UpperCAmelCase     , padding='''max_length'''     , max_length=self.tokenizer.model_max_length     , truncation=__UpperCAmelCase     , return_tensors='''pt'''     , )
													__UpperCamelCase							=self.text_encoder(text_input.input_ids.to(self.device				)				)[0]
													# duplicate text embeddings for each generation per prompt
													__UpperCamelCase							=text_embeddings.repeat_interleave(__UpperCAmelCase     , dim=0				)

													if clip_guidance_scale > 0:
																				if clip_prompt is not None:
																											__UpperCamelCase							=self.tokenizer(
																											    __UpperCAmelCase     , padding='''max_length'''     , max_length=self.tokenizer.model_max_length     , truncation=__UpperCAmelCase     , return_tensors='''pt'''     , ).input_ids.to(self.device				)
																				else:
																											__UpperCamelCase							=text_input.input_ids.to(self.device				)
																				__UpperCamelCase							=self.clip_model.get_text_features(__UpperCAmelCase				)
																				__UpperCamelCase							=text_embeddings_clip / text_embeddings_clip.norm(p=2     , dim=-1     , keepdim=__UpperCAmelCase				)
																				# duplicate text embeddings clip for each generation per prompt
																				__UpperCamelCase							=text_embeddings_clip.repeat_interleave(__UpperCAmelCase     , dim=0				)

													# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
													# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
													# corresponds to doing no classifier free guidance.
													__UpperCamelCase							=guidance_scale > 1.0
													# get unconditional embeddings for classifier free guidance
													if do_classifier_free_guidance:
																				__UpperCamelCase							=text_input.input_ids.shape[-1]
																				__UpperCamelCase							=self.tokenizer(['''''']     , padding='''max_length'''     , max_length=__UpperCAmelCase     , return_tensors='''pt'''				)
																				__UpperCamelCase							=self.text_encoder(uncond_input.input_ids.to(self.device				)				)[0]
																				# duplicate unconditional embeddings for each generation per prompt
																				__UpperCamelCase							=uncond_embeddings.repeat_interleave(__UpperCAmelCase     , dim=0				)

																				# For classifier free guidance, we need to do two forward passes.
																				# Here we concatenate the unconditional and text embeddings into a single batch
																				# to avoid doing two forward passes
																				__UpperCamelCase							=torch.cat([uncond_embeddings, text_embeddings]				)

													# get the initial random noise unless the user supplied it

													# Unlike in other pipelines, latents need to be generated in the target device
													# for 1-to-1 results reproducibility with the CompVis implementation.
													# However this currently doesn't work in `mps`.
													__UpperCamelCase							=(batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
													__UpperCamelCase							=text_embeddings.dtype
													if latents is None:
																				if self.device.type == "mps":
																											# randn does not work reproducibly on mps
																											__UpperCamelCase							=torch.randn(__UpperCAmelCase     , generator=__UpperCAmelCase     , device='''cpu'''     , dtype=__UpperCAmelCase				).to(
																											    self.device				)
																				else:
																											__UpperCamelCase							=torch.randn(__UpperCAmelCase     , generator=__UpperCAmelCase     , device=self.device     , dtype=__UpperCAmelCase				)
													else:
																				if latents.shape != latents_shape:
																											raise ValueError(f"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}"""				)
																				__UpperCamelCase							=latents.to(self.device				)

													# set timesteps
													__UpperCamelCase							='''offset''' in set(inspect.signature(self.scheduler.set_timesteps				).parameters.keys()				)
													__UpperCamelCase							={}
													if accepts_offset:
																				__UpperCamelCase							=1

													self.scheduler.set_timesteps(__UpperCAmelCase     , **__UpperCAmelCase				)

													# Some schedulers like PNDM have timesteps as arrays
													# It's more optimized to move all timesteps to correct device beforehand
													__UpperCamelCase							=self.scheduler.timesteps.to(self.device				)

													# scale the initial noise by the standard deviation required by the scheduler
													__UpperCamelCase							=latents * self.scheduler.init_noise_sigma

													# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
													# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
													# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
													# and should be between [0, 1]
													__UpperCamelCase							='''eta''' in set(inspect.signature(self.scheduler.step				).parameters.keys()				)
													__UpperCamelCase							={}
													if accepts_eta:
																				__UpperCamelCase							=eta

													# check if the scheduler accepts generator
													__UpperCamelCase							='''generator''' in set(inspect.signature(self.scheduler.step				).parameters.keys()				)
													if accepts_generator:
																				__UpperCamelCase							=generator

													for i, t in enumerate(self.progress_bar(__UpperCAmelCase				)				):
																				# expand the latents if we are doing classifier free guidance
																				__UpperCamelCase							=torch.cat([latents] * 2				) if do_classifier_free_guidance else latents
																				__UpperCamelCase							=self.scheduler.scale_model_input(__UpperCAmelCase     , __UpperCAmelCase				)

																				# predict the noise residual
																				__UpperCamelCase							=self.unet(__UpperCAmelCase     , __UpperCAmelCase     , encoder_hidden_states=__UpperCAmelCase				).sample

																				# perform classifier free guidance
																				if do_classifier_free_guidance:
																											__UpperCamelCase	,      __UpperCamelCase							=noise_pred.chunk(2				)
																											__UpperCamelCase							=noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

																				# perform clip guidance
																				if clip_guidance_scale > 0:
																											__UpperCamelCase							=(
																											    text_embeddings.chunk(2				)[1] if do_classifier_free_guidance else text_embeddings
																											)
																											__UpperCamelCase	,      __UpperCamelCase							=self.cond_fn(
																											    __UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase     , )

																				# compute the previous noisy sample x_t -> x_t-1
																				__UpperCamelCase							=self.scheduler.step(__UpperCAmelCase     , __UpperCAmelCase     , __UpperCAmelCase     , **__UpperCAmelCase				).prev_sample

													# scale and decode the image latents with vae
													__UpperCamelCase							=1 / self.vae.config.scaling_factor * latents
													__UpperCamelCase							=self.vae.decode(__UpperCAmelCase				).sample

													__UpperCamelCase							=(image / 2 + 0.5).clamp(0     , 1				)
													__UpperCamelCase							=image.cpu().permute(0     , 2     , 3     , 1				).numpy()

													if output_type == "pil":
																				__UpperCamelCase							=self.numpy_to_pil(__UpperCAmelCase				)

													if not return_dict:
																				return (image, None)

													return StableDiffusionPipelineOutput(images=__UpperCAmelCase     , nsfw_content_detected=__UpperCAmelCase				)





"""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						(					UpperCAmelCase ,   UpperCAmelCase=10 ,   UpperCAmelCase=10 ,   UpperCAmelCase=False ,   UpperCAmelCase=False     )						->Union[str, Any]:

   """simple docstring"""



   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(UpperCAmelCase ,   0 ,   -1     )     ) for frame in video]

   if torchify:
      a_						   =     [torch.from_numpy(UpperCAmelCase     ) for frame in video]

   return video
def    UpperCamelCase						(					UpperCAmelCase ,   UpperCAmelCase=False ,   UpperCAmelCase=False ,   UpperCAmelCase=False     )						->Optional[Any]:

   """simple docstring"""



   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=UpperCAmelCase ,   width=UpperCAmelCase ,   height=UpperCAmelCase ,   numpify=UpperCAmelCase ,   torchify=UpperCAmelCase ,   )
      video_inputs.append(UpperCAmelCase     )

   return video_inputs





class 							snake_case       (     unittest.TestCase		):







   def __init__( self       ,							__UpperCAmelCase       ,							__UpperCAmelCase=7       ,							__UpperCAmelCase=3       ,							__UpperCAmelCase=4       ,							__UpperCAmelCase=18       ,							__UpperCAmelCase=30       ,							__UpperCAmelCase=4_00       ,							__UpperCAmelCase=True       ,							__UpperCAmelCase=None       ,							__UpperCAmelCase=True       ,							__UpperCAmelCase=[0.5, 0.5, 0.5]       ,							__UpperCAmelCase=[0.5, 0.5, 0.5]       ,							__UpperCAmelCase=True       ,							__UpperCAmelCase=None       ,							)   ->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)   ->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 							snake_case       (     SCREAMING_SNAKE_CASE_							,       unittest.TestCase		):
   a_					:		int     					=     TvltImageProcessor if is_vision_available() else None







   def    UpperCAmelCase__	( self)   ->Optional[Any]:
      a_						   =     TvltImageProcessorTester(self)







   @property
   def    UpperCAmelCase__	( self)   ->int:
      return self.image_processor_tester.prepare_image_processor_dict()







   def    UpperCAmelCase__	( self)   ->int:
      a_						   =     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    UpperCAmelCase__	( self)   ->Any:
      # 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=__UpperCAmelCase)
      for video in video_inputs:
         self.assertIsInstance(__UpperCAmelCase       ,							__UpperCAmelCase)
         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(__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    UpperCAmelCase__	( self)   ->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=__UpperCAmelCase       ,							numpify=__UpperCAmelCase)
      for video in video_inputs:
         self.assertIsInstance(__UpperCAmelCase       ,							__UpperCAmelCase)
         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(__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    UpperCAmelCase__	( self)   ->Tuple:
      # 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=__UpperCAmelCase       ,							torchify=__UpperCAmelCase)
      for video in video_inputs:
         self.assertIsInstance(__UpperCAmelCase       ,							__UpperCAmelCase)
         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(__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"],
          )       ,							)