


"""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   _UpperCamelCase  (   UpperCAmelCase__       ,unittest.TestCase		):
							'''simple docstring'''







							__UpperCAmelCase						:    Tuple				      =KandinskyVaaControlnetImgaImgPipeline
							__UpperCAmelCase						:    Optional[int]				      =["""image_embeds""", """negative_image_embeds""", """image""", """hint"""]
							__UpperCAmelCase						:    str				      =["""image_embeds""", """negative_image_embeds""", """image""", """hint"""]
							__UpperCAmelCase						:    str				      =[
							    """generator""",
							    """height""",
							    """width""",
							    """strength""",
							    """guidance_scale""",
							    """num_inference_steps""",
							    """return_dict""",
							    """guidance_scale""",
							    """num_images_per_prompt""",
							    """output_type""",
							    """return_dict""",
							]
							__UpperCAmelCase						:    Optional[int]				      =False

							@property
							def 			snake_case				(     self	):
										return 32

							@property
							def 			snake_case				(     self	):
										return 32

							@property
							def 			snake_case				(     self	):
										return self.time_input_dim

							@property
							def 			snake_case				(     self	):
										return self.time_input_dim * 4

							@property
							def 			snake_case				(     self	):
										return 1_00

							@property
							def 			snake_case				(     self	):
										torch.manual_seed(0	)

										__lowerCAmelCase				    =			{
										    "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,
										}

										__lowerCAmelCase				    =			UNetaDConditionModel(**UpperCAmelCase__	)
										return model

							@property
							def 			snake_case				(     self	):
										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 			snake_case				(     self	):
										torch.manual_seed(0	)
										__lowerCAmelCase				    =			VQModel(**self.dummy_movq_kwargs	)
										return model

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.dummy_unet
										__lowerCAmelCase				    =			self.dummy_movq

										__lowerCAmelCase				    =			{
										    "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,
										}

										__lowerCAmelCase				    =			DDIMScheduler(**UpperCAmelCase__	)

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

										return components

							def 			snake_case				(     self    ,   __a    ,   __a=0	):
										__lowerCAmelCase				    =			floats_tensor((1, self.text_embedder_hidden_size)    ,   rng=random.Random(UpperCAmelCase__	)	).to(UpperCAmelCase__	)
										__lowerCAmelCase				    =			floats_tensor((1, self.text_embedder_hidden_size)    ,   rng=random.Random(seed + 1	)	).to(
										    UpperCAmelCase__	)
										# create init_image
										__lowerCAmelCase				    =			floats_tensor((1, 3, 64, 64)    ,   rng=random.Random(UpperCAmelCase__	)	).to(UpperCAmelCase__	)
										__lowerCAmelCase				    =			image.cpu().permute(0    ,   2    ,   3    ,   1	)[0]
										__lowerCAmelCase				    =			Image.fromarray(np.uinta(UpperCAmelCase__	)	).convert("RGB"	).resize((2_56, 2_56)	)
										# create hint
										__lowerCAmelCase				    =			floats_tensor((1, 3, 64, 64)    ,   rng=random.Random(UpperCAmelCase__	)	).to(UpperCAmelCase__	)

										if str(UpperCAmelCase__	).startswith("mps"	):
													__lowerCAmelCase				    =			torch.manual_seed(UpperCAmelCase__	)
										else:
													__lowerCAmelCase				    =			torch.Generator(device=UpperCAmelCase__	).manual_seed(UpperCAmelCase__	)
										__lowerCAmelCase				    =			{
										    "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 			snake_case				(     self	):
										__lowerCAmelCase				    =			"cpu"

										__lowerCAmelCase				    =			self.get_dummy_components()

										__lowerCAmelCase				    =			self.pipeline_class(**UpperCAmelCase__	)
										__lowerCAmelCase				    =			pipe.to(UpperCAmelCase__	)

										pipe.set_progress_bar_config(disable=UpperCAmelCase__	)

										__lowerCAmelCase				    =			pipe(**self.get_dummy_inputs(UpperCAmelCase__	)	)
										__lowerCAmelCase				    =			output.images

										__lowerCAmelCase				    =			pipe(
										    **self.get_dummy_inputs(UpperCAmelCase__	)    ,   return_dict=UpperCAmelCase__    ,   )[0]

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

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

										__lowerCAmelCase				    =			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   _UpperCamelCase  (   unittest.TestCase		):
							'''simple docstring'''







							def 			snake_case				(     self	):
										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()



							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			load_numpy(
										    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
										    "/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy"	)

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

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

										__lowerCAmelCase				    =			"A robot, 4k photo"

										__lowerCAmelCase				    =			KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
										    "kandinsky-community/kandinsky-2-2-prior"    ,   torch_dtype=torch.floataa	)
										pipe_prior.to(UpperCAmelCase__	)

										__lowerCAmelCase				    =			KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
										    "kandinsky-community/kandinsky-2-2-controlnet-depth"    ,   torch_dtype=torch.floataa	)
										__lowerCAmelCase				    =			pipeline.to(UpperCAmelCase__	)

										pipeline.set_progress_bar_config(disable=UpperCAmelCase__	)

										__lowerCAmelCase				    =			torch.Generator(device="cpu"	).manual_seed(0	)

										__lowerCAmelCase    ,	__lowerCAmelCase				    =			pipe_prior(
										    UpperCAmelCase__    ,   image=UpperCAmelCase__    ,   strength=0.8_5    ,   generator=UpperCAmelCase__    ,   negative_prompt=""    ,   ).to_tuple()

										__lowerCAmelCase				    =			pipeline(
										    image=UpperCAmelCase__    ,   image_embeds=UpperCAmelCase__    ,   negative_image_embeds=UpperCAmelCase__    ,   hint=UpperCAmelCase__    ,   generator=UpperCAmelCase__    ,   num_inference_steps=1_00    ,   height=5_12    ,   width=5_12    ,   strength=0.5    ,   output_type="np"    ,   )

										__lowerCAmelCase				    =			output.images[0]

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

										assert_mean_pixel_difference(UpperCAmelCase__    ,   UpperCAmelCase__	)










def SCREAMING_SNAKE_CASE				(       lowercase_ ,				lowercase_						)   ->       int:



       """simple docstring"""

       return int(input_a == input_a == 0						)







def SCREAMING_SNAKE_CASE				(       )   ->       None:



       """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()


