

import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaImgaImgPipeline,
    KandinskyVaaPriorPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class     a__  (    snake_case							,		unittest.TestCase	):
			"""simple docstring"""







			__lowerCamelCase       				=				KandinskyVaaImgaImgPipeline
			__lowerCamelCase       				=				['image_embeds', 'negative_image_embeds', 'image']
			__lowerCamelCase       				=				[
			    'image_embeds',
			    'negative_image_embeds',
			    'image',
			]
			__lowerCamelCase       				=				[
			    'generator',
			    'height',
			    'width',
			    'strength',
			    'guidance_scale',
			    'num_inference_steps',
			    'return_dict',
			    'guidance_scale',
			    'num_images_per_prompt',
			    'output_type',
			    'return_dict',
			]
			__lowerCamelCase       				=				False


			@property
			def    UpperCamelCase						(			self				)     ->  Dict:
							'''simple docstring'''






							return 32


			@property
			def    UpperCamelCase						(			self				)     ->  str:
							'''simple docstring'''






							return 32


			@property
			def    UpperCamelCase						(			self				)     ->  Optional[Any]:
							'''simple docstring'''






							return self.time_input_dim


			@property
			def    UpperCamelCase						(			self				)     ->  List[str]:
							'''simple docstring'''






							return self.time_input_dim * 4


			@property
			def    UpperCamelCase						(			self				)     ->  Union[str, Any]:
							'''simple docstring'''






							return 100


			@property
			def    UpperCamelCase						(			self				)     ->  Any:
							'''simple docstring'''






							torch.manual_seed(0				)

							A__						=	{
							    "in_channels": 4,
							    # Out channels is double in channels because predicts mean and variance
							    "out_channels": 8,
							    "addition_embed_type": "image",
							    "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
							    "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
							    "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
							    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
							    "layers_per_block": 1,
							    "encoder_hid_dim": self.text_embedder_hidden_size,
							    "encoder_hid_dim_type": "image_proj",
							    "cross_attention_dim": self.cross_attention_dim,
							    "attention_head_dim": 4,
							    "resnet_time_scale_shift": "scale_shift",
							    "class_embed_type": None,
							}

							A__						=	UNetaDConditionModel(**lowercase				)
							return model


			@property
			def    UpperCamelCase						(			self				)     ->  Tuple:
							'''simple docstring'''






							return {
							    "block_out_channels": [32, 64],
							    "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
							    "in_channels": 3,
							    "latent_channels": 4,
							    "layers_per_block": 1,
							    "norm_num_groups": 8,
							    "norm_type": "spatial",
							    "num_vq_embeddings": 12,
							    "out_channels": 3,
							    "up_block_types": [
							        "AttnUpDecoderBlock2D",
							        "UpDecoderBlock2D",
							    ],
							    "vq_embed_dim": 4,
							}


			@property
			def    UpperCamelCase						(			self				)     ->  Dict:
							'''simple docstring'''






							torch.manual_seed(0				)
							A__						=	VQModel(**self.dummy_movq_kwargs				)
							return model


			def    UpperCamelCase						(			self				)     ->  Dict:
							'''simple docstring'''






							A__						=	self.dummy_unet
							A__						=	self.dummy_movq

							A__						=	{
							    "num_train_timesteps": 1000,
							    "beta_schedule": "linear",
							    "beta_start": 0.0_0085,
							    "beta_end": 0.012,
							    "clip_sample": False,
							    "set_alpha_to_one": False,
							    "steps_offset": 0,
							    "prediction_type": "epsilon",
							    "thresholding": False,
							}

							A__						=	DDIMScheduler(**lowercase				)

							A__						=	{
							    "unet": unet,
							    "scheduler": scheduler,
							    "movq": movq,
							}

							return components


			def    UpperCamelCase						(			self					,					lowercase					,					lowercase=0				)     ->  Any:
							'''simple docstring'''






							A__						=	floats_tensor((1, self.text_embedder_hidden_size)					,					rng=random.Random(lowercase				)				).to(lowercase				)
							A__						=	floats_tensor((1, self.text_embedder_hidden_size)					,					rng=random.Random(seed + 1				)				).to(
							    lowercase				)
							# create init_image
							A__						=	floats_tensor((1, 3, 64, 64)					,					rng=random.Random(lowercase				)				).to(lowercase				)
							A__						=	image.cpu().permute(0					,					2					,					3					,					1				)[0]
							A__						=	Image.fromarray(np.uinta(lowercase				)				).convert("RGB"				).resize((256, 256)				)

							if str(lowercase				).startswith("mps"				):
											A__						=	torch.manual_seed(lowercase				)
							else:
											A__						=	torch.Generator(device=lowercase				).manual_seed(lowercase				)
							A__						=	{
							    "image": init_image,
							    "image_embeds": image_embeds,
							    "negative_image_embeds": negative_image_embeds,
							    "generator": generator,
							    "height": 64,
							    "width": 64,
							    "num_inference_steps": 10,
							    "guidance_scale": 7.0,
							    "strength": 0.2,
							    "output_type": "np",
							}
							return inputs


			def    UpperCamelCase						(			self				)     ->  Any:
							'''simple docstring'''






							A__						=	"cpu"

							A__						=	self.get_dummy_components()

							A__						=	self.pipeline_class(**lowercase				)
							A__						=	pipe.to(lowercase				)

							pipe.set_progress_bar_config(disable=lowercase				)

							A__						=	pipe(**self.get_dummy_inputs(lowercase				)				)
							A__						=	output.images

							A__						=	pipe(
							    **self.get_dummy_inputs(lowercase				)					,					return_dict=lowercase					,					)[0]

							A__						=	image[0, -3:, -3:, -1]
							A__						=	image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							A__						=	np.array(
							    [0.619_9778, 0.6398_4406, 0.4614_5785, 0.6294_4984, 0.562_2215, 0.4730_6132, 0.4744_1456, 0.460_7606, 0.4871_9263]				)
							assert (
							    np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2
							), F' expected_slice {expected_slice}, but got {image_slice.flatten()}'
							assert (
							    np.abs(image_from_tuple_slice.flatten() - expected_slice				).max() < 1e-2
							), F' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'

@slow
@require_torch_gpu
class     a__  (    unittest.TestCase	):
			"""simple docstring"""







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






							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()


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






							A__						=	load_numpy(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
							    "/kandinskyv22/kandinskyv22_img2img_frog.npy"				)

							A__						=	load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"				)
							A__						=	"A red cartoon frog, 4k"

							A__						=	KandinskyVaaPriorPipeline.from_pretrained(
							    "kandinsky-community/kandinsky-2-2-prior"					,					torch_dtype=torch.floataa				)
							pipe_prior.to(lowercase				)

							A__						=	KandinskyVaaImgaImgPipeline.from_pretrained(
							    "kandinsky-community/kandinsky-2-2-decoder"					,					torch_dtype=torch.floataa				)
							A__						=	pipeline.to(lowercase				)

							pipeline.set_progress_bar_config(disable=lowercase				)

							A__						=	torch.Generator(device="cpu"				).manual_seed(0				)
							A__			, A__						=	pipe_prior(
							    lowercase					,					generator=lowercase					,					num_inference_steps=5					,					negative_prompt=""					,					).to_tuple()

							A__						=	pipeline(
							    image=lowercase					,					image_embeds=lowercase					,					negative_image_embeds=lowercase					,					generator=lowercase					,					num_inference_steps=100					,					height=768					,					width=768					,					strength=0.2					,					output_type="np"					,					)

							A__						=	output.images[0]

							assert image.shape == (768, 768, 3)

							assert_mean_pixel_difference(lowercase					,					lowercase				)








'''simple docstring'''

import os

from huggingface_hub.constants import HUGGINGFACE_HUB_CACHE, hf_cache_home


lowercase_					= HUGGINGFACE_HUB_CACHE


lowercase_					= """config.json"""
lowercase_					= """diffusion_pytorch_model.bin"""
lowercase_					= """diffusion_flax_model.msgpack"""
lowercase_					= """model.onnx"""
lowercase_					= """diffusion_pytorch_model.safetensors"""
lowercase_					= """weights.pb"""
lowercase_					= """https://huggingface.co"""
lowercase_					= default_cache_path
lowercase_					= """diffusers_modules"""
lowercase_					= os.getenv("""HF_MODULES_CACHE""", os.path.join(hf_cache_home, """modules"""))
lowercase_					= ["""fp16""", """non-ema"""]
lowercase_					= """.self_attn"""



