

"""simple docstring"""






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       snake_case__  ( lowerCAmelCase_					,  unittest.TestCase     ):
			SCREAMING_SNAKE_CASE__     				=						KandinskyVaaControlnetImgaImgPipeline
			SCREAMING_SNAKE_CASE__     				=						['''image_embeds''', '''negative_image_embeds''', '''image''', '''hint''']
			SCREAMING_SNAKE_CASE__     				=						['''image_embeds''', '''negative_image_embeds''', '''image''', '''hint''']
			SCREAMING_SNAKE_CASE__     				=						[
			    '''generator''',
			    '''height''',
			    '''width''',
			    '''strength''',
			    '''guidance_scale''',
			    '''num_inference_steps''',
			    '''return_dict''',
			    '''guidance_scale''',
			    '''num_images_per_prompt''',
			    '''output_type''',
			    '''return_dict''',
			]
			SCREAMING_SNAKE_CASE__     				=						False







			@property
			def 			__lowerCAmelCase				(			self			: Optional[Any]  ):





								'''simple docstring'''



								return 32







			@property
			def 			__lowerCAmelCase				(			self			: Dict  ):





								'''simple docstring'''



								return 32







			@property
			def 			__lowerCAmelCase				(			self			: Dict  ):





								'''simple docstring'''



								return self.time_input_dim







			@property
			def 			__lowerCAmelCase				(			self			: Optional[Any]  ):





								'''simple docstring'''



								return self.time_input_dim * 4







			@property
			def 			__lowerCAmelCase				(			self			: List[str]  ):





								'''simple docstring'''



								return 1_00







			@property
			def 			__lowerCAmelCase				(			self			: Dict  ):





								'''simple docstring'''



								torch.manual_seed(0  )

								UpperCAmelCase			:   List[Any]      =				{
								    "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,
								}

								UpperCAmelCase			:   Tuple      =				UNetaDConditionModel(**lowercase  )
								return model







			@property
			def 			__lowerCAmelCase				(			self			: Union[str, Any]  ):





								'''simple docstring'''



								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 			__lowerCAmelCase				(			self			: Any  ):





								'''simple docstring'''



								torch.manual_seed(0  )
								UpperCAmelCase			:   int      =				VQModel(**self.dummy_movq_kwargs  )
								return model







			def 			__lowerCAmelCase				(			self			: Dict  ):





								'''simple docstring'''



								UpperCAmelCase			:   Optional[Any]      =				self.dummy_unet
								UpperCAmelCase			:   Any      =				self.dummy_movq

								UpperCAmelCase			:   Union[str, Any]      =				{
								    "num_train_timesteps": 10_00,
								    "beta_schedule": "linear",
								    "beta_start": 0.0_0_0_8_5,
								    "beta_end": 0.0_1_2,
								    "clip_sample": False,
								    "set_alpha_to_one": False,
								    "steps_offset": 0,
								    "prediction_type": "epsilon",
								    "thresholding": False,
								}

								UpperCAmelCase			:   Union[str, Any]      =				DDIMScheduler(**lowercase  )

								UpperCAmelCase			:   int      =				{
								    "unet": unet,
								    "scheduler": scheduler,
								    "movq": movq,
								}

								return components







			def 			__lowerCAmelCase				(			self			: Dict			,  lowercase			: Optional[int]			,  lowercase			: str=0  ):





								'''simple docstring'''



								UpperCAmelCase			:   str      =				floats_tensor((1, self.text_embedder_hidden_size)			,  rng=random.Random(lowercase  )  ).to(lowercase  )
								UpperCAmelCase			:   int      =				floats_tensor((1, self.text_embedder_hidden_size)			,  rng=random.Random(seed + 1  )  ).to(
								    lowercase  )
								# create init_image
								UpperCAmelCase			:   Union[str, Any]      =				floats_tensor((1, 3, 64, 64)			,  rng=random.Random(lowercase  )  ).to(lowercase  )
								UpperCAmelCase			:   List[Any]      =				image.cpu().permute(0			,  2			,  3			,  1  )[0]
								UpperCAmelCase			:   Union[str, Any]      =				Image.fromarray(np.uinta(lowercase  )  ).convert("RGB"  ).resize((2_56, 2_56)  )
								# create hint
								UpperCAmelCase			:   Optional[Any]      =				floats_tensor((1, 3, 64, 64)			,  rng=random.Random(lowercase  )  ).to(lowercase  )

								if str(lowercase  ).startswith("mps"  ):
													UpperCAmelCase			:   List[Any]      =				torch.manual_seed(lowercase  )
								else:
													UpperCAmelCase			:   List[Any]      =				torch.Generator(device=lowercase  ).manual_seed(lowercase  )
								UpperCAmelCase			:   Optional[Any]      =				{
								    "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 			__lowerCAmelCase				(			self			: Dict  ):





								'''simple docstring'''



								UpperCAmelCase			:   str      =				"cpu"

								UpperCAmelCase			:   int      =				self.get_dummy_components()

								UpperCAmelCase			:   List[str]      =				self.pipeline_class(**lowercase  )
								UpperCAmelCase			:   Union[str, Any]      =				pipe.to(lowercase  )

								pipe.set_progress_bar_config(disable=lowercase  )

								UpperCAmelCase			:   List[Any]      =				pipe(**self.get_dummy_inputs(lowercase  )  )
								UpperCAmelCase			:   Tuple      =				output.images

								UpperCAmelCase			:   Dict      =				pipe(
								    **self.get_dummy_inputs(lowercase  )			,  return_dict=lowercase			,  )[0]

								UpperCAmelCase			:   Optional[Any]      =				image[0, -3:, -3:, -1]
								UpperCAmelCase			:   List[Any]      =				image_from_tuple[0, -3:, -3:, -1]

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

								UpperCAmelCase			:   Optional[int]      =				np.array(
								    [0.5_4_9_8_5_0_3_4, 0.5_5_5_0_9_3_6_5, 0.5_2_5_6_1_5_0_4, 0.5_5_7_0_4_9_4, 0.5_5_9_3_8_1_8, 0.5_2_6_3_9_7_9, 0.5_0_2_8_5_6_4_3, 0.5_0_6_9_8_4_6, 0.5_1_1_9_6_7_3_6]  )
								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       snake_case__  ( unittest.TestCase     ):







			def 			__lowerCAmelCase				(			self			: str  ):





								'''simple docstring'''



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







			def 			__lowerCAmelCase				(			self			: int  ):





								'''simple docstring'''



								UpperCAmelCase			:   Optional[int]      =				load_numpy(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
								    "/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy"  )

								UpperCAmelCase			:   Union[str, Any]      =				load_image(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"  )
								UpperCAmelCase			:   str      =				init_image.resize((5_12, 5_12)  )

								UpperCAmelCase			:   int      =				load_image(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
								    "/kandinskyv22/hint_image_cat.png"  )
								UpperCAmelCase			:   str      =				torch.from_numpy(np.array(lowercase  )  ).float() / 2_5_5.0
								UpperCAmelCase			:   str      =				hint.permute(2			,  0			,  1  ).unsqueeze(0  )

								UpperCAmelCase			:   Tuple      =				"A robot, 4k photo"

								UpperCAmelCase			:   str      =				KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
								    "kandinsky-community/kandinsky-2-2-prior"			,  torch_dtype=torch.floataa  )
								pipe_prior.to(lowercase  )

								UpperCAmelCase			:   List[Any]      =				KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
								    "kandinsky-community/kandinsky-2-2-controlnet-depth"			,  torch_dtype=torch.floataa  )
								UpperCAmelCase			:   Optional[int]      =				pipeline.to(lowercase  )

								pipeline.set_progress_bar_config(disable=lowercase  )

								UpperCAmelCase			:   int      =				torch.Generator(device="cpu"  ).manual_seed(0  )

								UpperCAmelCase      ,							UpperCAmelCase			:   int      =				pipe_prior(
								    lowercase			,  image=lowercase			,  strength=0.8_5			,  generator=lowercase			,  negative_prompt=""			,  ).to_tuple()

								UpperCAmelCase			:   List[Any]      =				pipeline(
								    image=lowercase			,  image_embeds=lowercase			,  negative_image_embeds=lowercase			,  hint=lowercase			,  generator=lowercase			,  num_inference_steps=1_00			,  height=5_12			,  width=5_12			,  strength=0.5			,  output_type="np"			,  )

								UpperCAmelCase			:   Any      =				output.images[0]

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

								assert_mean_pixel_difference(lowercase			,  lowercase  )





"""simple docstring"""






def   lowercase_	(    _lowercase       :		int							,      _lowercase       :		int	):




					'''simple docstring'''






					return int(input_a == input_a == 0	)



def   lowercase_	(    ):




					'''simple docstring'''






					print("Truth Table of NOR Gate:"	)
					print("|   Input 1   |  Input 2  | Output |"	)
					print(F"""|      0      |    0      |  {nor_gate(0							,      0	)}     |"""	)
					print(F"""|      0      |    1      |  {nor_gate(0							,      1	)}     |"""	)
					print(F"""|      1      |    0      |  {nor_gate(1							,      0	)}     |"""	)
					print(F"""|      1      |    1      |  {nor_gate(1							,      1	)}     |"""	)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	main()


