
'''simple docstring'''
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    UNetaDConditionModel,
    VideoToVideoSDPipeline,
)
from diffusers.utils import floats_tensor, is_xformers_available, skip_mps
from diffusers.utils.testing_utils import enable_full_determinism, slow, torch_device

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


@skip_mps
class 			SCREAMING_SNAKE_CASE__      (     snake_case_							,       unittest.TestCase):
				lowerCAmelCase_     			=							VideoToVideoSDPipeline
				lowerCAmelCase_     			=							TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({"""video"""}) - {"""image""", """width""", """height"""}
				lowerCAmelCase_     			=							TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""video"""}) - {"""image"""}
				lowerCAmelCase_     			=							PipelineTesterMixin.required_optional_params - {"""latents"""}
				lowerCAmelCase_     			=							False

				# No `output_type`.
				lowerCAmelCase_     			=							frozenset(
				    [
				        """num_inference_steps""",
				        """generator""",
				        """latents""",
				        """return_dict""",
				        """callback""",
				        """callback_steps""",
				    ])







				def 						UpperCAmelCase_    (       self     )->		int:







											'''simple docstring'''






											torch.manual_seed(0     )
											UpperCamelCase   			=     UNetaDConditionModel(
											    block_out_channels=(32, 64, 64, 64)						,				layers_per_block=2						,				sample_size=32						,				in_channels=4						,				out_channels=4						,				down_block_types=('CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'CrossAttnDownBlock3D', 'DownBlock3D')						,				up_block_types=('UpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D', 'CrossAttnUpBlock3D')						,				cross_attention_dim=32						,				attention_head_dim=4						,				)
											UpperCamelCase   			=     DDIMScheduler(
											    beta_start=0.00_085						,				beta_end=0.012						,				beta_schedule='scaled_linear'						,				clip_sample=A_						,				set_alpha_to_one=A_						,				)
											torch.manual_seed(0     )
											UpperCamelCase   			=     AutoencoderKL(
											    block_out_channels=[32, 64]						,				in_channels=3						,				out_channels=3						,				down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']						,				up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']						,				latent_channels=4						,				sample_size=128						,				)
											torch.manual_seed(0     )
											UpperCamelCase   			=     CLIPTextConfig(
											    bos_token_id=0						,				eos_token_id=2						,				hidden_size=32						,				intermediate_size=37						,				layer_norm_eps=1e-05						,				num_attention_heads=4						,				num_hidden_layers=5						,				pad_token_id=1						,				vocab_size=1000						,				hidden_act='gelu'						,				projection_dim=512						,				)
											UpperCamelCase   			=     CLIPTextModel(A_     )
											UpperCamelCase   			=     CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'     )

											UpperCamelCase   			=     {
											    'unet': unet,
											    'scheduler': scheduler,
											    'vae': vae,
											    'text_encoder': text_encoder,
											    'tokenizer': tokenizer,
											}
											return components







				def 						UpperCAmelCase_    (       self						,				A_						,				A_=0     )->		Optional[Any]:







											'''simple docstring'''






											UpperCamelCase   			=     floats_tensor((1, 3, 3, 32, 32)						,				rng=random.Random(A_     )     ).to(A_     )

											if str(A_     ).startswith('mps'     ):
																		UpperCamelCase   			=     torch.manual_seed(A_     )
											else:
																		UpperCamelCase   			=     torch.Generator(device=A_     ).manual_seed(A_     )
											UpperCamelCase   			=     {
											    'prompt': 'A painting of a squirrel eating a burger',
											    'video': video,
											    'generator': generator,
											    'num_inference_steps': 2,
											    'guidance_scale': 6.0,
											    'output_type': 'pt',
											}
											return inputs







				def 						UpperCAmelCase_    (       self     )->		str:







											'''simple docstring'''






											UpperCamelCase   			=     'cpu'  # ensure determinism for the device-dependent torch.Generator
											UpperCamelCase   			=     self.get_dummy_components()
											UpperCamelCase   			=     VideoToVideoSDPipeline(**A_     )
											UpperCamelCase   			=     sd_pipe.to(A_     )
											sd_pipe.set_progress_bar_config(disable=A_     )

											UpperCamelCase   			=     self.get_dummy_inputs(A_     )
											UpperCamelCase   			=     'np'
											UpperCamelCase   			=     sd_pipe(**A_     ).frames
											UpperCamelCase   			=     frames[0][-3:, -3:, -1]

											assert frames[0].shape == (32, 32, 3)
											UpperCamelCase   			=     np.array([106, 117, 113, 174, 137, 112, 148, 151, 131]     )

											assert np.abs(image_slice.flatten() - expected_slice     ).max() < 1e-2







				@unittest.skipIf(
				    torch_device != 'cuda' or not is_xformers_available()						,				reason='XFormers attention is only available with CUDA and `xformers` installed'						,				)
				def 						UpperCAmelCase_    (       self     )->		Tuple:







											'''simple docstring'''






											self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=A_						,				expected_max_diff=5e-3     )







				@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'     )
				def 						UpperCAmelCase_    (       self     )->		Optional[Any]:







											'''simple docstring'''






											pass







				@unittest.skip(reason='Batching needs to be properly figured out first for this pipeline.'     )
				def 						UpperCAmelCase_    (       self     )->		Union[str, Any]:







											'''simple docstring'''






											pass







				@unittest.skip(reason='`num_images_per_prompt` argument is not supported for this pipeline.'     )
				def 						UpperCAmelCase_    (       self     )->		Dict:







											'''simple docstring'''






											pass







				def 						UpperCAmelCase_    (       self     )->		Dict:







											'''simple docstring'''






											return super().test_progress_bar()


@slow
@skip_mps
class 			SCREAMING_SNAKE_CASE__      (     unittest.TestCase):







				def 						UpperCAmelCase_    (       self     )->		Dict:







											'''simple docstring'''






											UpperCamelCase   			=     VideoToVideoSDPipeline.from_pretrained('cerspense/zeroscope_v2_XL'						,				torch_dtype=torch.floataa     )
											pipe.enable_model_cpu_offload()

											# 10 frames
											UpperCamelCase   			=     torch.Generator(device='cpu'     ).manual_seed(0     )
											UpperCamelCase   			=     torch.randn((1, 10, 3, 1024, 576)						,				generator=A_     )
											UpperCamelCase   			=     video.to('cuda'     )

											UpperCamelCase   			=     'Spiderman is surfing'

											UpperCamelCase   			=     pipe(A_						,				video=A_						,				generator=A_						,				num_inference_steps=3						,				output_type='pt'     ).frames

											UpperCamelCase   			=     np.array([-1.0_458_984, -1.1_279_297, -0.9_663_086, -0.91_503_906, -0.75_097_656]     )
											assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array     ).sum() < 1e-2






'''simple docstring'''
from collections import OrderedDict
from typing import Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...feature_extraction_utils import FeatureExtractionMixin
from ...onnx import OnnxConfig
from ...onnx.utils import compute_effective_axis_dimension
from ...tokenization_utils_base import PreTrainedTokenizerBase
from ...utils import TensorType, logging


lowerCAmelCase					:    Any           = logging.get_logger(__name__)

lowerCAmelCase					:    Optional[int]           = {
    'deepmind/language-perceiver': 'https://huggingface.co/deepmind/language-perceiver/resolve/main/config.json',
    # See all Perceiver models at https://huggingface.co/models?filter=perceiver
}


class 			SCREAMING_SNAKE_CASE__      (     snake_case_):
				lowerCAmelCase_     			=							"""perceiver"""







				def __init__(       self						,				A_=256						,				A_=1280						,				A_=768						,				A_=1						,				A_=26						,				A_=8						,				A_=8						,				A_=None						,				A_=None						,				A_="kv"						,				A_=1						,				A_=1						,				A_="gelu"						,				A_=0.1						,				A_=0.02						,				A_=1e-12						,				A_=True						,				A_=262						,				A_=2048						,				A_=56						,				A_=[368, 496]						,				A_=16						,				A_=1920						,				A_=16						,				A_=[1, 16, 224, 224]						,				**A_						,				)->		str:







											'''simple docstring'''






											super().__init__(**A_     )

											UpperCamelCase   			=     num_latents
											UpperCamelCase   			=     d_latents
											UpperCamelCase   			=     d_model
											UpperCamelCase   			=     num_blocks
											UpperCamelCase   			=     num_self_attends_per_block
											UpperCamelCase   			=     num_self_attention_heads
											UpperCamelCase   			=     num_cross_attention_heads
											UpperCamelCase   			=     qk_channels
											UpperCamelCase   			=     v_channels
											UpperCamelCase   			=     cross_attention_shape_for_attention
											UpperCamelCase   			=     self_attention_widening_factor
											UpperCamelCase   			=     cross_attention_widening_factor
											UpperCamelCase   			=     hidden_act
											UpperCamelCase   			=     attention_probs_dropout_prob
											UpperCamelCase   			=     initializer_range
											UpperCamelCase   			=     layer_norm_eps
											UpperCamelCase   			=     use_query_residual
											# masked language modeling attributes
											UpperCamelCase   			=     vocab_size
											UpperCamelCase   			=     max_position_embeddings
											# image classification attributes
											UpperCamelCase   			=     image_size
											# flow attributes
											UpperCamelCase   			=     train_size
											# multimodal autoencoding attributes
											UpperCamelCase   			=     num_frames
											UpperCamelCase   			=     audio_samples_per_frame
											UpperCamelCase   			=     samples_per_patch
											UpperCamelCase   			=     output_shape


class 			SCREAMING_SNAKE_CASE__      (     snake_case_):







				@property
				def 						UpperCAmelCase_    (       self     )->		Mapping[str, Mapping[int, str]]:







											'''simple docstring'''






											if self.task == "multiple-choice":
																		UpperCamelCase   			=     {0: 'batch', 1: 'choice', 2: 'sequence'}
											else:
																		UpperCamelCase   			=     {0: 'batch', 1: 'sequence'}
											return OrderedDict(
											    [
											        ('inputs', dynamic_axis),
											        ('attention_mask', dynamic_axis),
											    ]     )







				@property
				def 						UpperCAmelCase_    (       self     )->		float:







											'''simple docstring'''






											return 1e-4







				def 						UpperCAmelCase_    (       self						,				A_						,				A_ = -1						,				A_ = -1						,				A_ = -1						,				A_ = False						,				A_ = None						,				A_ = 3						,				A_ = 40						,				A_ = 40						,				)->		Mapping[str, Any]:







											'''simple docstring'''






											if isinstance(A_						,				A_     ):
																		# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
																		UpperCamelCase   			=     compute_effective_axis_dimension(
																		    A_						,				fixed_dimension=OnnxConfig.default_fixed_batch						,				num_token_to_add=0     )
																		# If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
																		UpperCamelCase   			=     preprocessor.num_special_tokens_to_add(A_     )
																		UpperCamelCase   			=     compute_effective_axis_dimension(
																		    A_						,				fixed_dimension=OnnxConfig.default_fixed_sequence						,				num_token_to_add=A_     )
																		# Generate dummy inputs according to compute batch and sequence
																		UpperCamelCase   			=     [' '.join(['a']     ) * seq_length] * batch_size
																		UpperCamelCase   			=     dict(preprocessor(A_						,				return_tensors=A_     )     )
																		UpperCamelCase   			=     inputs.pop('input_ids'     )
																		return inputs
											elif isinstance(A_						,				A_     ) and preprocessor.model_input_names[0] == "pixel_values":
																		# If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
																		UpperCamelCase   			=     compute_effective_axis_dimension(A_						,				fixed_dimension=OnnxConfig.default_fixed_batch     )
																		UpperCamelCase   			=     self._generate_dummy_images(A_						,				A_						,				A_						,				A_     )
																		UpperCamelCase   			=     dict(preprocessor(images=A_						,				return_tensors=A_     )     )
																		UpperCamelCase   			=     inputs.pop('pixel_values'     )
																		return inputs
											else:
																		raise ValueError(
																		    'Unable to generate dummy inputs for the model. Please provide a tokenizer or a preprocessor.'     )




