import argparse

import torch

from diffusers import UNetaDConditionModel






def    UpperCAmelCase__(						lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_=None							,	lowerCamelCase_=None							,	lowerCamelCase_=None  ):



			"""simple docstring"""





			assert isinstance(lowerCamelCase_							,	lowerCamelCase_  ), "Paths should be a list of dicts containing 'old' and 'new' keys."

			# Splits the attention layers into three variables.
			if attention_paths_to_split is not None:
						for path, path_map in attention_paths_to_split.items():
									_snake_case              =      old_checkpoint[path]
									_snake_case              =      old_tensor.shape[0] // 3

									_snake_case              =      (-1, channels) if len(old_tensor.shape  ) == 3 else (-1)

									_snake_case              =      old_tensor.shape[0] // config["num_head_channels"] // 3

									_snake_case              =      old_tensor.reshape((num_heads, 3 * channels // num_heads) + old_tensor.shape[1:]  )
									_snake_case       , _snake_case       , _snake_case              =      old_tensor.split(channels // num_heads							,	dim=1  )

									_snake_case              =      query.reshape(lowerCamelCase_  )
									_snake_case              =      key.reshape(lowerCamelCase_  )
									_snake_case              =      value.reshape(lowerCamelCase_  )

			for path in paths:
						_snake_case              =      path["new"]

						# These have already been assigned
						if attention_paths_to_split is not None and new_path in attention_paths_to_split:
									continue

						if additional_replacements is not None:
									for replacement in additional_replacements:
												_snake_case              =      new_path.replace(replacement["old"]							,	replacement["new"]  )

        # proj_attn.weight has to be converted from conv 1D to linear
						_snake_case              =      old_checkpoint[path["old"]]
						_snake_case              =      ["proj_attn.weight"]
						_snake_case              =      ["proj_out.weight", "proj_in.weight"]
						if any(k in new_path for k in names  ):
									_snake_case              =      weight[:, :, 0]
						elif any(k in new_path for k in names_a  ) and len(weight.shape  ) > 2 and ".attentions." not in new_path:
									_snake_case              =      weight[:, :, 0]
						else:
									_snake_case              =      weight






def    UpperCAmelCase__(						lowerCamelCase_							,	lowerCamelCase_=0  ):



			"""simple docstring"""





			_snake_case              =      []
			for old_item in old_list:
						_snake_case              =      old_item

						#         new_item = new_item.replace('norm.weight', 'group_norm.weight')
						#         new_item = new_item.replace('norm.bias', 'group_norm.bias')

						#         new_item = new_item.replace('proj_out.weight', 'proj_attn.weight')
						#         new_item = new_item.replace('proj_out.bias', 'proj_attn.bias')

						#         new_item = shave_segments(new_item, n_shave_prefix_segments=n_shave_prefix_segments)

						mapping.append({"old": old_item, "new": new_item}  )

			return mapping






def    UpperCAmelCase__(						lowerCamelCase_							,	lowerCamelCase_=1  ):



			"""simple docstring"""





			if n_shave_prefix_segments >= 0:
						return ".".join(path.split("."  )[n_shave_prefix_segments:]  )
			else:
						return ".".join(path.split("."  )[:n_shave_prefix_segments]  )






def    UpperCAmelCase__(						lowerCamelCase_							,	lowerCamelCase_=0  ):



			"""simple docstring"""





			_snake_case              =      []
			for old_item in old_list:
						mapping.append({"old": old_item, "new": old_item}  )

			return mapping






def    UpperCAmelCase__(						lowerCamelCase_							,	lowerCamelCase_=0  ):



			"""simple docstring"""





			_snake_case              =      []
			for old_item in old_list:
						_snake_case              =      old_item.replace("in_layers.0"							,	"norm1"  )
						_snake_case              =      new_item.replace("in_layers.2"							,	"conv1"  )

						_snake_case              =      new_item.replace("out_layers.0"							,	"norm2"  )
						_snake_case              =      new_item.replace("out_layers.3"							,	"conv2"  )

						_snake_case              =      new_item.replace("emb_layers.1"							,	"time_emb_proj"  )
						_snake_case              =      new_item.replace("skip_connection"							,	"conv_shortcut"  )

						_snake_case              =      shave_segments(lowerCamelCase_							,	n_shave_prefix_segments=lowerCamelCase_  )

						if "temopral_conv" not in old_item:
									mapping.append({"old": old_item, "new": new_item}  )

			return mapping






def    UpperCAmelCase__(						lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_=None							,	lowerCamelCase_=False  ):



			"""simple docstring"""





			_snake_case              =      {}
			_snake_case              =      list(checkpoint.keys()  )

			_snake_case              =      "model.diffusion_model."

			# at least a 100 parameters have to start with `model_ema` in order for the checkpoint to be EMA
			if sum(k.startswith("model_ema"  ) for k in keys  ) > 100 and extract_ema:
						print(f'Checkpoint {path} has both EMA and non-EMA weights.'  )
						print(
						    "In this conversion only the EMA weights are extracted. If you want to instead extract the non-EMA"
						    " weights (useful to continue fine-tuning), please make sure to remove the `--extract_ema` flag."  )
						for key in keys:
									if key.startswith("model.diffusion_model"  ):
												_snake_case              =      "model_ema." + "".join(key.split("."  )[1:]  )
												_snake_case              =      checkpoint.pop(lowerCamelCase_  )
			else:
						if sum(k.startswith("model_ema"  ) for k in keys  ) > 100:
									print(
									    "In this conversion only the non-EMA weights are extracted. If you want to instead extract the EMA"
									    " weights (usually better for inference), please make sure to add the `--extract_ema` flag."  )

						for key in keys:
									_snake_case              =      checkpoint.pop(lowerCamelCase_  )

			_snake_case              =      {}

			_snake_case              =      unet_state_dict["time_embed.0.weight"]
			_snake_case              =      unet_state_dict["time_embed.0.bias"]
			_snake_case              =      unet_state_dict["time_embed.2.weight"]
			_snake_case              =      unet_state_dict["time_embed.2.bias"]

			if config["class_embed_type"] is None:
						# No parameters to port
						...
			elif config["class_embed_type"] == "timestep" or config["class_embed_type"] == "projection":
						_snake_case              =      unet_state_dict["label_emb.0.0.weight"]
						_snake_case              =      unet_state_dict["label_emb.0.0.bias"]
						_snake_case              =      unet_state_dict["label_emb.0.2.weight"]
						_snake_case              =      unet_state_dict["label_emb.0.2.bias"]
			else:
						raise NotImplementedError(f'Not implemented `class_embed_type`: {config["class_embed_type"]}'  )

			_snake_case              =      unet_state_dict["input_blocks.0.0.weight"]
			_snake_case              =      unet_state_dict["input_blocks.0.0.bias"]

			_snake_case              =      [v for v in unet_state_dict if v.startswith("input_blocks.0.1"  )]
			_snake_case              =      renew_attention_paths(lowerCamelCase_  )
			_snake_case              =      {"old": "input_blocks.0.1", "new": "transformer_in"}
			assign_to_checkpoint(lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )

			_snake_case              =      unet_state_dict["out.0.weight"]
			_snake_case              =      unet_state_dict["out.0.bias"]
			_snake_case              =      unet_state_dict["out.2.weight"]
			_snake_case              =      unet_state_dict["out.2.bias"]

			# Retrieves the keys for the input blocks only
			_snake_case              =      len({".".join(layer.split("."  )[:2]  ) for layer in unet_state_dict if "input_blocks" in layer}  )
			_snake_case              =      {
			    layer_id: [key for key in unet_state_dict if f'input_blocks.{layer_id}' in key]
			    for layer_id in range(lowerCamelCase_  )
			}

			# Retrieves the keys for the middle blocks only
			_snake_case              =      len({".".join(layer.split("."  )[:2]  ) for layer in unet_state_dict if "middle_block" in layer}  )
			_snake_case              =      {
			    layer_id: [key for key in unet_state_dict if f'middle_block.{layer_id}' in key]
			    for layer_id in range(lowerCamelCase_  )
			}

			# Retrieves the keys for the output blocks only
			_snake_case              =      len({".".join(layer.split("."  )[:2]  ) for layer in unet_state_dict if "output_blocks" in layer}  )
			_snake_case              =      {
			    layer_id: [key for key in unet_state_dict if f'output_blocks.{layer_id}' in key]
			    for layer_id in range(lowerCamelCase_  )
			}

			for i in range(1							,	lowerCamelCase_  ):
						_snake_case              =      (i - 1) // (config["layers_per_block"] + 1)
						_snake_case              =      (i - 1) % (config["layers_per_block"] + 1)

						_snake_case              =      [
						    key for key in input_blocks[i] if f'input_blocks.{i}.0' in key and f'input_blocks.{i}.0.op' not in key
						]
						_snake_case              =      [key for key in input_blocks[i] if f'input_blocks.{i}.1' in key]
						_snake_case              =      [key for key in input_blocks[i] if f'input_blocks.{i}.2' in key]

						if f'input_blocks.{i}.op.weight' in unet_state_dict:
									_snake_case              =      unet_state_dict.pop(
									    f'input_blocks.{i}.op.weight'  )
									_snake_case              =      unet_state_dict.pop(
									    f'input_blocks.{i}.op.bias'  )

						_snake_case              =      renew_resnet_paths(lowerCamelCase_  )
						_snake_case              =      {"old": f'input_blocks.{i}.0', "new": f'down_blocks.{block_id}.resnets.{layer_in_block_id}'}
						assign_to_checkpoint(
						    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )

						_snake_case              =      [key for key in resnets if "temopral_conv" in key]
						_snake_case              =      renew_temp_conv_paths(lowerCamelCase_  )
						_snake_case              =      {
						    "old": f'input_blocks.{i}.0.temopral_conv',
						    "new": f'down_blocks.{block_id}.temp_convs.{layer_in_block_id}',
						}
						assign_to_checkpoint(
						    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )

						if len(lowerCamelCase_  ):
									_snake_case              =      renew_attention_paths(lowerCamelCase_  )
									_snake_case              =      {"old": f'input_blocks.{i}.1', "new": f'down_blocks.{block_id}.attentions.{layer_in_block_id}'}
									assign_to_checkpoint(
									    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )

						if len(lowerCamelCase_  ):
									_snake_case              =      renew_attention_paths(lowerCamelCase_  )
									_snake_case              =      {
									    "old": f'input_blocks.{i}.2',
									    "new": f'down_blocks.{block_id}.temp_attentions.{layer_in_block_id}',
									}
									assign_to_checkpoint(
									    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )

			_snake_case              =      middle_blocks[0]
			_snake_case              =      [key for key in resnet_a if "temopral_conv" in key]
			_snake_case              =      middle_blocks[1]
			_snake_case              =      middle_blocks[2]
			_snake_case              =      middle_blocks[3]
			_snake_case              =      [key for key in resnet_a if "temopral_conv" in key]

			_snake_case              =      renew_resnet_paths(lowerCamelCase_  )
			_snake_case              =      {"old": "middle_block.0", "new": "mid_block.resnets.0"}
			assign_to_checkpoint(
			    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	config=lowerCamelCase_							,	additional_replacements=[meta_path]  )

			_snake_case              =      renew_temp_conv_paths(lowerCamelCase_  )
			_snake_case              =      {"old": "middle_block.0.temopral_conv", "new": "mid_block.temp_convs.0"}
			assign_to_checkpoint(
			    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	config=lowerCamelCase_							,	additional_replacements=[meta_path]  )

			_snake_case              =      renew_resnet_paths(lowerCamelCase_  )
			_snake_case              =      {"old": "middle_block.3", "new": "mid_block.resnets.1"}
			assign_to_checkpoint(
			    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	config=lowerCamelCase_							,	additional_replacements=[meta_path]  )

			_snake_case              =      renew_temp_conv_paths(lowerCamelCase_  )
			_snake_case              =      {"old": "middle_block.3.temopral_conv", "new": "mid_block.temp_convs.1"}
			assign_to_checkpoint(
			    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	config=lowerCamelCase_							,	additional_replacements=[meta_path]  )

			_snake_case              =      renew_attention_paths(lowerCamelCase_  )
			_snake_case              =      {"old": "middle_block.1", "new": "mid_block.attentions.0"}
			assign_to_checkpoint(
			    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )

			_snake_case              =      renew_attention_paths(lowerCamelCase_  )
			_snake_case              =      {"old": "middle_block.2", "new": "mid_block.temp_attentions.0"}
			assign_to_checkpoint(
			    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )

			for i in range(lowerCamelCase_  ):
						_snake_case              =      i // (config["layers_per_block"] + 1)
						_snake_case              =      i % (config["layers_per_block"] + 1)
						_snake_case              =      [shave_segments(lowerCamelCase_							,	2  ) for name in output_blocks[i]]
						_snake_case              =      {}

						for layer in output_block_layers:
									_snake_case       , _snake_case              =      layer.split("."  )[0], shave_segments(lowerCamelCase_							,	1  )
									if layer_id in output_block_list:
												output_block_list[layer_id].append(lowerCamelCase_  )
									else:
												_snake_case              =      [layer_name]

						if len(lowerCamelCase_  ) > 1:
									_snake_case              =      [key for key in output_blocks[i] if f'output_blocks.{i}.0' in key]
									_snake_case              =      [key for key in output_blocks[i] if f'output_blocks.{i}.1' in key]
									_snake_case              =      [key for key in output_blocks[i] if f'output_blocks.{i}.2' in key]

									_snake_case              =      renew_resnet_paths(lowerCamelCase_  )
									_snake_case              =      renew_resnet_paths(lowerCamelCase_  )

									_snake_case              =      {"old": f'output_blocks.{i}.0', "new": f'up_blocks.{block_id}.resnets.{layer_in_block_id}'}
									assign_to_checkpoint(
									    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )

									_snake_case              =      [key for key in resnets if "temopral_conv" in key]
									_snake_case              =      renew_temp_conv_paths(lowerCamelCase_  )
									_snake_case              =      {
									    "old": f'output_blocks.{i}.0.temopral_conv',
									    "new": f'up_blocks.{block_id}.temp_convs.{layer_in_block_id}',
									}
									assign_to_checkpoint(
									    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )

									_snake_case              =      {k: sorted(lowerCamelCase_  ) for k, v in output_block_list.items()}
									if ["conv.bias", "conv.weight"] in output_block_list.values():
												_snake_case              =      list(output_block_list.values()  ).index(["conv.bias", "conv.weight"]  )
												_snake_case              =      unet_state_dict[
												    f'output_blocks.{i}.{index}.conv.weight'
												]
												_snake_case              =      unet_state_dict[
												    f'output_blocks.{i}.{index}.conv.bias'
												]

												# Clear attentions as they have been attributed above.
												if len(lowerCamelCase_  ) == 2:
															_snake_case              =      []

									if len(lowerCamelCase_  ):
												_snake_case              =      renew_attention_paths(lowerCamelCase_  )
												_snake_case              =      {
												    "old": f'output_blocks.{i}.1',
												    "new": f'up_blocks.{block_id}.attentions.{layer_in_block_id}',
												}
												assign_to_checkpoint(
												    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )

									if len(lowerCamelCase_  ):
												_snake_case              =      renew_attention_paths(lowerCamelCase_  )
												_snake_case              =      {
												    "old": f'output_blocks.{i}.2',
												    "new": f'up_blocks.{block_id}.temp_attentions.{layer_in_block_id}',
												}
												assign_to_checkpoint(
												    lowerCamelCase_							,	lowerCamelCase_							,	lowerCamelCase_							,	additional_replacements=[meta_path]							,	config=lowerCamelCase_  )
						else:
									_snake_case              =      renew_resnet_paths(lowerCamelCase_							,	n_shave_prefix_segments=1  )
									for path in resnet_0_paths:
												_snake_case              =      ".".join(["output_blocks", str(lowerCamelCase_  ), path["old"]]  )
												_snake_case              =      ".".join(["up_blocks", str(lowerCamelCase_  ), "resnets", str(lowerCamelCase_  ), path["new"]]  )
												_snake_case              =      unet_state_dict[old_path]

									_snake_case              =      [l for l in output_block_layers if "temopral_conv" in l]
									for path in temopral_conv_paths:
												_snake_case              =      path.split("temopral_conv."  )[-1]
												_snake_case              =      ".".join(["output_blocks", str(lowerCamelCase_  ), str(lowerCamelCase_  ), "temopral_conv", pruned_path]  )
												_snake_case              =      ".".join(["up_blocks", str(lowerCamelCase_  ), "temp_convs", str(lowerCamelCase_  ), pruned_path]  )
												_snake_case              =      unet_state_dict[old_path]

			return new_checkpoint


if __name__ == "__main__":
			_SCREAMING_SNAKE_CASE:						str    	=       argparse.ArgumentParser()

			parser.add_argument(
			    '''--checkpoint_path''', default=None, type=str, required=True, help='''Path to the checkpoint to convert.'''
			)
			parser.add_argument('''--dump_path''', default=None, type=str, required=True, help='''Path to the output model.''')
			_SCREAMING_SNAKE_CASE:						List[str]    	=       parser.parse_args()

			_SCREAMING_SNAKE_CASE:						Any    	=       torch.load(args.checkpoint_path, map_location='''cpu''')
			_SCREAMING_SNAKE_CASE:						Optional[Any]    	=       UNetaDConditionModel()

			_SCREAMING_SNAKE_CASE:						Dict    	=       convert_ldm_unet_checkpoint(unet_checkpoint, unet.config)

			_SCREAMING_SNAKE_CASE:						Optional[int]    	=       set(unet.state_dict().keys()) - set(converted_ckpt.keys())
			_SCREAMING_SNAKE_CASE:						List[Any]    	=       set(converted_ckpt.keys()) - set(unet.state_dict().keys())

			assert len(diff_a) == len(diff_a) == 0, "Converted weights don't match"

			# load state_dict
			unet.load_state_dict(converted_ckpt)

			unet.save_pretrained(args.dump_path)

			# -- finish converting the unet --


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__(						lowerCamelCase_							,	lowerCamelCase_=10							,	lowerCamelCase_=10							,	lowerCamelCase_=False							,	lowerCamelCase_=False  ):



			"""simple docstring"""





			_snake_case              =      []
			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
						_snake_case              =      [Image.fromarray(np.moveaxis(lowerCamelCase_							,	0							,	-1  )  ) for frame in video]

			if torchify:
						_snake_case              =      [torch.from_numpy(lowerCamelCase_  ) for frame in video]

			return video






def    UpperCAmelCase__(						lowerCamelCase_							,	lowerCamelCase_=False							,	lowerCamelCase_=False							,	lowerCamelCase_=False  ):



			"""simple docstring"""





			assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

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

			return video_inputs

class 	_SCREAMING_SNAKE_CASE							(     unittest.TestCase							):






		"""simple docstring"""







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






					"""simple docstring"""
					_snake_case              =      size if size is not None else {"shortest_edge": 18}
					_snake_case              =      crop_size if crop_size is not None else {"height": 18, "width": 18}

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







		def 				_a				(			self    :				List[Any]   ):






					"""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,
					    "do_center_crop": self.do_center_crop,
					    "crop_size": self.crop_size,
					}

@require_torch
@require_vision
class 	_SCREAMING_SNAKE_CASE							(     _lowercase      ,     unittest.TestCase							):






		"""simple docstring"""







		A_						 =      TvltImageProcessor if is_vision_available() else None



		def 				_a				(			self    :				str   ):






					"""simple docstring"""
					_snake_case              =      TvltImageProcessorTester(self   )



		@property
		def 				_a				(			self    :				List[Any]   ):






					"""simple docstring"""
					return self.image_processor_tester.prepare_image_processor_dict()



		def 				_a				(			self    :				Dict   ):






					"""simple docstring"""
					_snake_case              =      self.image_processing_class(**self.image_processor_dict   )
					self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,					"image_mean"   )   )
					self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,					"image_std"   )   )
					self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,					"do_normalize"   )   )
					self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,					"do_resize"   )   )
					self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,					"do_center_crop"   )   )
					self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE  ,					"size"   )   )



		def 				_a				(			self    :				Optional[Any]   ):






					"""simple docstring"""
					# Initialize image_processor
					_snake_case              =      self.image_processing_class(**self.image_processor_dict   )
					# create random PIL videos
					_snake_case              =      prepare_video_inputs(self.image_processor_tester  ,					equal_resolution=__SCREAMING_SNAKE_CASE   )
					for video in video_inputs:
								self.assertIsInstance(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE   )
								self.assertIsInstance(video[0]  ,					Image.Image   )

					# Test not batched input
					_snake_case              =      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
					_snake_case              =      image_processor(__SCREAMING_SNAKE_CASE  ,					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 				_a				(			self    :				str   ):






					"""simple docstring"""
					# Initialize image_processor
					_snake_case              =      self.image_processing_class(**self.image_processor_dict   )
					# create random numpy tensors
					_snake_case              =      prepare_video_inputs(self.image_processor_tester  ,					equal_resolution=__SCREAMING_SNAKE_CASE  ,					numpify=__SCREAMING_SNAKE_CASE   )
					for video in video_inputs:
								self.assertIsInstance(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE   )
								self.assertIsInstance(video[0]  ,					np.ndarray   )

					# Test not batched input
					_snake_case              =      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
					_snake_case              =      image_processor(__SCREAMING_SNAKE_CASE  ,					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 				_a				(			self    :				int   ):






					"""simple docstring"""
					# Initialize image_processor
					_snake_case              =      self.image_processing_class(**self.image_processor_dict   )
					# create random PyTorch tensors
					_snake_case              =      prepare_video_inputs(self.image_processor_tester  ,					equal_resolution=__SCREAMING_SNAKE_CASE  ,					torchify=__SCREAMING_SNAKE_CASE   )
					for video in video_inputs:
								self.assertIsInstance(__SCREAMING_SNAKE_CASE  ,					__SCREAMING_SNAKE_CASE   )
								self.assertIsInstance(video[0]  ,					torch.Tensor   )

					# Test not batched input
					_snake_case              =      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
					_snake_case              =      image_processor(__SCREAMING_SNAKE_CASE  ,					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"],
					    )  ,					)

