





"""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       (		__lowerCAmelCase	, unittest.TestCase		):
							lowerCamelCase     :      Tuple         =KandinskyVaaControlnetImgaImgPipeline
							lowerCamelCase     :      Tuple         =["""image_embeds""", """negative_image_embeds""", """image""", """hint"""]
							lowerCamelCase     :      int         =["""image_embeds""", """negative_image_embeds""", """image""", """hint"""]
							lowerCamelCase     :      Optional[int]         =[
							    """generator""",
							    """height""",
							    """width""",
							    """strength""",
							    """guidance_scale""",
							    """num_inference_steps""",
							    """return_dict""",
							    """guidance_scale""",
							    """num_images_per_prompt""",
							    """output_type""",
							    """return_dict""",
							]
							lowerCamelCase     :      str         =False






							@property
							def 					__a     (     self   )			->				int:
								return 32






							@property
							def 					__a     (     self   )			->				Optional[Any]:
								return 32






							@property
							def 					__a     (     self   )			->				int:
								return self.time_input_dim






							@property
							def 					__a     (     self   )			->				Union[str, Any]:
								return self.time_input_dim * 4






							@property
							def 					__a     (     self   )			->				str:
								return 100






							@property
							def 					__a     (     self   )			->				List[Any]:
								torch.manual_seed(0   )

								a   :	Optional[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,
								}

								a   :	List[Any]			=       UNetaDConditionModel(**_UpperCamelCase   )
								return model






							@property
							def 					__a     (     self   )			->				List[Any]:
								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   )
								a   :	List[Any]			=       VQModel(**self.dummy_movq_kwargs   )
								return model






							def 					__a     (     self   )			->				Tuple:
								a   :	Union[str, Any]			=       self.dummy_unet
								a   :	Dict			=       self.dummy_movq

								a   :	List[str]			=       {
								    """num_train_timesteps""": 1000,
								    """beta_schedule""": """linear""",
								    """beta_start""": 0.00_085,
								    """beta_end""": 0.012,
								    """clip_sample""": False,
								    """set_alpha_to_one""": False,
								    """steps_offset""": 0,
								    """prediction_type""": """epsilon""",
								    """thresholding""": False,
								}

								a   :	Dict			=       DDIMScheduler(**_UpperCamelCase   )

								a   :	Optional[Any]			=       {
								    """unet""": unet,
								    """scheduler""": scheduler,
								    """movq""": movq,
								}

								return components






							def 					__a     (     self   ,      lowerCAmelCase__   ,      lowerCAmelCase__=0   )			->				str:
								a   :	Union[str, Any]			=       floats_tensor((1, self.text_embedder_hidden_size)   ,      rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )
								a   :	str			=       floats_tensor((1, self.text_embedder_hidden_size)   ,      rng=random.Random(seed + 1   )   ).to(
								    _UpperCamelCase   )
								# create init_image
								a   :	int			=       floats_tensor((1, 3, 64, 64)   ,      rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )
								a   :	Optional[Any]			=       image.cpu().permute(0   ,      2   ,      3   ,      1   )[0]
								a   :	int			=       Image.fromarray(np.uinta(_UpperCamelCase   )   ).convert("RGB"   ).resize((256, 256)   )
								# create hint
								a   :	List[Any]			=       floats_tensor((1, 3, 64, 64)   ,      rng=random.Random(_UpperCamelCase   )   ).to(_UpperCamelCase   )

								if str(_UpperCamelCase   ).startswith("mps"   ):
									a   :	Any			=       torch.manual_seed(_UpperCamelCase   )
								else:
									a   :	Any			=       torch.Generator(device=_UpperCamelCase   ).manual_seed(_UpperCamelCase   )
								a   :	List[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 					__a     (     self   )			->				Dict:
								a   :	str			=       """cpu"""

								a   :	Tuple			=       self.get_dummy_components()

								a   :	Union[str, Any]			=       self.pipeline_class(**_UpperCamelCase   )
								a   :	str			=       pipe.to(_UpperCamelCase   )

								pipe.set_progress_bar_config(disable=_UpperCamelCase   )

								a   :	List[str]			=       pipe(**self.get_dummy_inputs(_UpperCamelCase   )   )
								a   :	Any			=       output.images

								a   :	Dict			=       pipe(
								    **self.get_dummy_inputs(_UpperCamelCase   )   ,      return_dict=_UpperCamelCase   ,      )[0]

								a   :	Optional[int]			=       image[0, -3:, -3:, -1]
								a   :	int			=       image_from_tuple[0, -3:, -3:, -1]

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

								a   :	str			=       np.array(
								    [0.54_985_034, 0.55_509_365, 0.52_561_504, 0.5_570_494, 0.5_593_818, 0.5_263_979, 0.50_285_643, 0.5_069_846, 0.51_196_736]   )
								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		):






							def 					__a     (     self   )			->				Dict:
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()






							def 					__a     (     self   )			->				int:
								a   :	Union[str, Any]			=       load_numpy(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
								    "/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy"   )

								a   :	Any			=       load_image(
								    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"   )
								a   :	Optional[int]			=       init_image.resize((512, 512)   )

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

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

								a   :	Optional[int]			=       KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
								    "kandinsky-community/kandinsky-2-2-prior"   ,      torch_dtype=torch.floataa   )
								pipe_prior.to(_UpperCamelCase   )

								a   :	str			=       KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
								    "kandinsky-community/kandinsky-2-2-controlnet-depth"   ,      torch_dtype=torch.floataa   )
								a   :	List[str]			=       pipeline.to(_UpperCamelCase   )

								pipeline.set_progress_bar_config(disable=_UpperCamelCase   )

								a   :	str			=       torch.Generator(device="cpu"   ).manual_seed(0   )

								a   :	Union[str, Any]			=       pipe_prior(
								    _UpperCamelCase   ,      image=_UpperCamelCase   ,      strength=0.85   ,      generator=_UpperCamelCase   ,      negative_prompt=""   ,      ).to_tuple()

								a   :	Optional[Any]			=       pipeline(
								    image=_UpperCamelCase   ,      image_embeds=_UpperCamelCase   ,      negative_image_embeds=_UpperCamelCase   ,      hint=_UpperCamelCase   ,      generator=_UpperCamelCase   ,      num_inference_steps=100   ,      height=512   ,      width=512   ,      strength=0.5   ,      output_type="np"   ,      )

								a   :	List[Any]			=       output.images[0]

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

								assert_mean_pixel_difference(_UpperCamelCase   ,      _UpperCamelCase   )









"""simple docstring"""




import qiskit






def    _SCREAMING_SNAKE_CASE	(			_lowercase		:					int					, _lowercase		:					int      )				->qiskit.result.counts.Counts:






	'''simple docstring'''






	a   :	Union[str, Any]			=       qiskit.Aer.get_backend("aer_simulator"      )

	# Create a Quantum Circuit acting on the q register
	a   :	Optional[Any]			=       qiskit.QuantumCircuit(_lowercase					, _lowercase      )

	# Map the quantum measurement to the classical bits
	circuit.measure([0]					, [0]      )

	# Execute the circuit on the simulator
	a   :	Optional[int]			=       qiskit.execute(_lowercase					, _lowercase					, shots=1000      )

	# Return the histogram data of the results of the experiment.
	return job.result().get_counts(_lowercase      )


if __name__ == "__main__":
		print(F'''Total count for various states are: {single_qubit_measure(1, 1)}''')


