




import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    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  __magic_name__						(  __UpperCAmelCase    ,  unittest.TestCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							Union[str, Any]	      =					KandinskyVaaControlnetImgaImgPipeline
				SCREAMING_SNAKE_CASE__					:							List[Any]	      =					["image_embeds", "negative_image_embeds", "image", "hint"]
				SCREAMING_SNAKE_CASE__					:							Tuple	      =					["image_embeds", "negative_image_embeds", "image", "hint"]
				SCREAMING_SNAKE_CASE__					:							Any	      =					[
				    "generator",
				    "height",
				    "width",
				    "strength",
				    "guidance_scale",
				    "num_inference_steps",
				    "return_dict",
				    "guidance_scale",
				    "num_images_per_prompt",
				    "output_type",
				    "return_dict",
				]
				SCREAMING_SNAKE_CASE__					:							List[Any]	      =					False


				@property
				def     _A							(							self:   Tuple		):
											return 32


				@property
				def     _A							(							self:   Dict		):
											return 32


				@property
				def     _A							(							self:   List[str]		):
											return self.time_input_dim


				@property
				def     _A							(							self:   Optional[int]		):
											return self.time_input_dim * 4


				@property
				def     _A							(							self:   Any		):
											return 1_00


				@property
				def     _A							(							self:   Optional[int]		):
											torch.manual_seed(0		)

											SCREAMING_SNAKE_CASE_   	=    {
											    '''in_channels''': 8,
											    # Out channels is double in channels because predicts mean and variance
											    '''out_channels''': 8,
											    '''addition_embed_type''': '''image_hint''',
											    '''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,
											}

											SCREAMING_SNAKE_CASE_   	=    UNetaDConditionModel(**_lowerCamelCase		)
											return model


				@property
				def     _A							(							self:   Optional[int]		):
											return {
											    "block_out_channels": [32, 32, 64, 64],
											    "down_block_types": [
											        "DownEncoderBlock2D",
											        "DownEncoderBlock2D",
											        "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", "UpDecoderBlock2D", "UpDecoderBlock2D"],
											    "vq_embed_dim": 4,
											}


				@property
				def     _A							(							self:   str		):
											torch.manual_seed(0		)
											SCREAMING_SNAKE_CASE_   	=    VQModel(**self.dummy_movq_kwargs		)
											return model


				def     _A							(							self:   List[Any]		):
											SCREAMING_SNAKE_CASE_   	=    self.dummy_unet
											SCREAMING_SNAKE_CASE_   	=    self.dummy_movq

											SCREAMING_SNAKE_CASE_   	=    {
											    '''num_train_timesteps''': 10_00,
											    '''beta_schedule''': '''linear''',
											    '''beta_start''': 0.0_00_85,
											    '''beta_end''': 0.0_12,
											    '''clip_sample''': False,
											    '''set_alpha_to_one''': False,
											    '''steps_offset''': 0,
											    '''prediction_type''': '''epsilon''',
											    '''thresholding''': False,
											}

											SCREAMING_SNAKE_CASE_   	=    DDIMScheduler(**_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    {
											    '''unet''': unet,
											    '''scheduler''': scheduler,
											    '''movq''': movq,
											}

											return components


				def     _A							(							self:   Any		,					_lowerCamelCase:   Optional[Any]		,					_lowerCamelCase:   int=0		):
											SCREAMING_SNAKE_CASE_   	=    floats_tensor((1, self.text_embedder_hidden_size)		,					rng=random.Random(_lowerCamelCase		)		).to(_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    floats_tensor((1, self.text_embedder_hidden_size)		,					rng=random.Random(seed + 1		)		).to(
											    _lowerCamelCase		)
											# create init_image
											SCREAMING_SNAKE_CASE_   	=    floats_tensor((1, 3, 64, 64)		,					rng=random.Random(_lowerCamelCase		)		).to(_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    image.cpu().permute(0		,					2		,					3		,					1		)[0]
											SCREAMING_SNAKE_CASE_   	=    Image.fromarray(np.uinta(_lowerCamelCase		)		).convert('''RGB'''		).resize((2_56, 2_56)		)
											# create hint
											SCREAMING_SNAKE_CASE_   	=    floats_tensor((1, 3, 64, 64)		,					rng=random.Random(_lowerCamelCase		)		).to(_lowerCamelCase		)

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





				def     _A							(							self:   int		):
											SCREAMING_SNAKE_CASE_   	=    '''cpu'''

											SCREAMING_SNAKE_CASE_   	=    self.get_dummy_components()

											SCREAMING_SNAKE_CASE_   	=    self.pipeline_class(**_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    pipe.to(_lowerCamelCase		)

											pipe.set_progress_bar_config(disable=_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    pipe(**self.get_dummy_inputs(_lowerCamelCase		)		)
											SCREAMING_SNAKE_CASE_   	=    output.images

											SCREAMING_SNAKE_CASE_   	=    pipe(
											    **self.get_dummy_inputs(_lowerCamelCase		)		,					return_dict=_lowerCamelCase		,					)[0]

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

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

											SCREAMING_SNAKE_CASE_   	=    np.array(
											    [0.54_98_50_34, 0.55_50_93_65, 0.52_56_15_04, 0.5_57_04_94, 0.5_59_38_18, 0.5_26_39_79, 0.50_28_56_43, 0.5_06_98_46, 0.51_19_67_36]		)
											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  __magic_name__						(  unittest.TestCase):
				'''simple docstring'''







				def     _A							(							self:   Tuple		):
											# clean up the VRAM after each test
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()





				def     _A							(							self:   Any		):
											SCREAMING_SNAKE_CASE_   	=    load_numpy(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											    '''/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy'''		)

											SCREAMING_SNAKE_CASE_   	=    load_image(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main''' '''/kandinsky/cat.png'''		)
											SCREAMING_SNAKE_CASE_   	=    init_image.resize((5_12, 5_12)		)

											SCREAMING_SNAKE_CASE_   	=    load_image(
											    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
											    '''/kandinskyv22/hint_image_cat.png'''		)
											SCREAMING_SNAKE_CASE_   	=    torch.from_numpy(np.array(_lowerCamelCase		)		).float() / 2_55.0
											SCREAMING_SNAKE_CASE_   	=    hint.permute(2		,					0		,					1		).unsqueeze(0		)

											SCREAMING_SNAKE_CASE_   	=    '''A robot, 4k photo'''

											SCREAMING_SNAKE_CASE_   	=    KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
											    '''kandinsky-community/kandinsky-2-2-prior'''		,					torch_dtype=torch.floataa		)
											pipe_prior.to(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
											    '''kandinsky-community/kandinsky-2-2-controlnet-depth'''		,					torch_dtype=torch.floataa		)
											SCREAMING_SNAKE_CASE_   	=    pipeline.to(_lowerCamelCase		)

											pipeline.set_progress_bar_config(disable=_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    torch.Generator(device='''cpu'''		).manual_seed(0		)

											SCREAMING_SNAKE_CASE_	,	SCREAMING_SNAKE_CASE_   	=    pipe_prior(
											    _lowerCamelCase		,					image=_lowerCamelCase		,					strength=0.85		,					generator=_lowerCamelCase		,					negative_prompt=''''''		,					).to_tuple()

											SCREAMING_SNAKE_CASE_   	=    pipeline(
											    image=_lowerCamelCase		,					image_embeds=_lowerCamelCase		,					negative_image_embeds=_lowerCamelCase		,					hint=_lowerCamelCase		,					generator=_lowerCamelCase		,					num_inference_steps=1_00		,					height=5_12		,					width=5_12		,					strength=0.5		,					output_type='''np'''		,					)

											SCREAMING_SNAKE_CASE_   	=    output.images[0]

											assert image.shape == (5_12, 5_12, 3)

											assert_mean_pixel_difference(_lowerCamelCase		,					_lowerCamelCase		)








from typing import Any

def 			a   (_lowerCAmelCase     ):
							if not input_list:
														return []
							SCREAMING_SNAKE_CASE_   	=    [input_list.count(_lowerCAmelCase     ) for value in input_list]
							SCREAMING_SNAKE_CASE_   	=    max(_lowerCAmelCase     )  # Gets the maximum count in the input list.
							# Gets values of modes
							return sorted({input_list[i] for i, value in enumerate(_lowerCAmelCase     ) if value == y}     )


if __name__ == "__main__":
			import doctest

			doctest.testmod()


