





import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu




class 					_lowerCamelCase			(     unittest.TestCase     ):



      """simple docstring"""






      def     UpperCAmelCase		(			self )							-> str:






        '''simple docstring'''






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







      @property
      def     UpperCAmelCase		(			self )							-> Optional[int]:






        '''simple docstring'''






        __snake_case :					str          =							1
        __snake_case :					int          =							3
        __snake_case :					List[str]          =							(32, 32)

        __snake_case :					Tuple          =							floats_tensor((batch_size, num_channels) + sizes					,    rng=random.Random(0 ) ).to(lowerCAmelCase_ )
        return image







      @property
      def     UpperCAmelCase		(			self )							-> List[str]:






        '''simple docstring'''






        torch.manual_seed(0 )
        __snake_case :					List[str]          =							UNetaDConditionModel(
            block_out_channels=(32, 64)					,    layers_per_block=2					,    sample_size=32					,    in_channels=4					,    out_channels=4					,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")					,    up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")					,    cross_attention_dim=32					,    )
        return model







      @property
      def     UpperCAmelCase		(			self )							-> Tuple:






        '''simple docstring'''






        torch.manual_seed(0 )
        __snake_case :					Union[str, Any]          =							AutoencoderKL(
            block_out_channels=[32, 64]					,    in_channels=3					,    out_channels=3					,    down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]					,    up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]					,    latent_channels=4					,    )
        return model







      @property
      def     UpperCAmelCase		(			self )							-> Any:






        '''simple docstring'''






        torch.manual_seed(0 )
        __snake_case :					Dict          =							CLIPTextConfig(
            bos_token_id=0					,    eos_token_id=2					,    hidden_size=32					,    intermediate_size=37					,    layer_norm_eps=1E-05					,    num_attention_heads=4					,    num_hidden_layers=5					,    pad_token_id=1					,    vocab_size=1000					,    )
        return CLIPTextModel(lowerCAmelCase_ )







      @property
      def     UpperCAmelCase		(			self )							-> str:






        '''simple docstring'''






        def extract(*UpperCAmelCase					,    **UpperCAmelCase ):




          class 					_lowerCamelCase			:



                """simple docstring"""






                def __init__(			self )							-> int:






                  '''simple docstring'''






                  __snake_case :					Tuple          =							torch.ones([0] )







                def     UpperCAmelCase		(			self					,    UpperCAmelCase )							-> Optional[Any]:






                  '''simple docstring'''






                  self.pixel_values.to(lowerCAmelCase_ )
                  return self




          return Out()

        return extract







      def     UpperCAmelCase		(			self )							-> Tuple:






        '''simple docstring'''






        __snake_case :					List[str]          =							"cpu"  # ensure determinism for the device-dependent torch.Generator
        __snake_case :					Optional[Any]          =							self.dummy_cond_unet
        __snake_case :					List[str]          =							DDIMScheduler(
            beta_start=0.00_085					,    beta_end=0.012					,    beta_schedule="scaled_linear"					,    clip_sample=lowerCAmelCase_					,    set_alpha_to_one=lowerCAmelCase_					,    )

        __snake_case :					Dict          =							self.dummy_vae
        __snake_case :					Optional[Any]          =							self.dummy_text_encoder
        __snake_case :					Optional[int]          =							CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

        # make sure here that pndm scheduler skips prk
        __snake_case :					str          =							StableDiffusionPipeline(
            unet=lowerCAmelCase_					,    scheduler=lowerCAmelCase_					,    vae=lowerCAmelCase_					,    text_encoder=lowerCAmelCase_					,    tokenizer=lowerCAmelCase_					,    safety_checker=lowerCAmelCase_					,    feature_extractor=self.dummy_extractor					,    )
        __snake_case :					Union[str, Any]          =							sd_pipe.to(lowerCAmelCase_ )
        sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_ )

        __snake_case :					Optional[Any]          =							"A painting of a squirrel eating a burger"

        __snake_case :					str          =							torch.Generator(device=lowerCAmelCase_ ).manual_seed(0 )
        __snake_case :					str          =							sd_pipe([prompt]					,    generator=lowerCAmelCase_					,    guidance_scale=6.0					,    num_inference_steps=2					,    output_type="np" )
        __snake_case :					Any          =							output.images

        __snake_case :					Union[str, Any]          =							torch.Generator(device=lowerCAmelCase_ ).manual_seed(0 )
        __snake_case :					int          =							sd_pipe(
            [prompt]					,    generator=lowerCAmelCase_					,    guidance_scale=6.0					,    num_inference_steps=2					,    output_type="np"					,    return_dict=lowerCAmelCase_					,    )[0]

        __snake_case :					List[str]          =							image[0, -3:, -3:, -1]
        __snake_case :					int          =							image_from_tuple[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        __snake_case :					Tuple          =							np.array([0.5_756, 0.6_118, 0.5_005, 0.5_041, 0.5_471, 0.4_726, 0.4_976, 0.4_865, 0.4_864] )

        assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
        assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2







      def     UpperCAmelCase		(			self )							-> List[str]:






        '''simple docstring'''






        __snake_case :					Optional[int]          =							"cpu"  # ensure determinism for the device-dependent torch.Generator
        __snake_case :					List[str]          =							self.dummy_cond_unet
        __snake_case :					List[str]          =							PNDMScheduler(skip_prk_steps=lowerCAmelCase_ )
        __snake_case :					Any          =							self.dummy_vae
        __snake_case :					Optional[int]          =							self.dummy_text_encoder
        __snake_case :					Optional[Any]          =							CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

        # make sure here that pndm scheduler skips prk
        __snake_case :					List[str]          =							StableDiffusionPipeline(
            unet=lowerCAmelCase_					,    scheduler=lowerCAmelCase_					,    vae=lowerCAmelCase_					,    text_encoder=lowerCAmelCase_					,    tokenizer=lowerCAmelCase_					,    safety_checker=lowerCAmelCase_					,    feature_extractor=self.dummy_extractor					,    )
        __snake_case :					Any          =							sd_pipe.to(lowerCAmelCase_ )
        sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_ )

        __snake_case :					Union[str, Any]          =							"A painting of a squirrel eating a burger"
        __snake_case :					Any          =							torch.Generator(device=lowerCAmelCase_ ).manual_seed(0 )
        __snake_case :					Dict          =							sd_pipe([prompt]					,    generator=lowerCAmelCase_					,    guidance_scale=6.0					,    num_inference_steps=2					,    output_type="np" )

        __snake_case :					str          =							output.images

        __snake_case :					Tuple          =							torch.Generator(device=lowerCAmelCase_ ).manual_seed(0 )
        __snake_case :					Optional[Any]          =							sd_pipe(
            [prompt]					,    generator=lowerCAmelCase_					,    guidance_scale=6.0					,    num_inference_steps=2					,    output_type="np"					,    return_dict=lowerCAmelCase_					,    )[0]

        __snake_case :					Union[str, Any]          =							image[0, -3:, -3:, -1]
        __snake_case :					Optional[int]          =							image_from_tuple[0, -3:, -3:, -1]

        assert image.shape == (1, 64, 64, 3)
        __snake_case :					str          =							np.array([0.5_125, 0.5_716, 0.4_828, 0.5_060, 0.5_650, 0.4_768, 0.5_185, 0.4_895, 0.4_993] )

        assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2
        assert np.abs(image_from_tuple_slice.flatten() - expected_slice ).max() < 1E-2







      def     UpperCAmelCase		(			self )							-> Union[str, Any]:






        '''simple docstring'''






        __snake_case :					Dict          =							StableDiffusionPipeline.from_pretrained(
            "hf-internal-testing/tiny-stable-diffusion-lms-pipe"					,    safety_checker=lowerCAmelCase_ )
        assert isinstance(lowerCAmelCase_					,    lowerCAmelCase_ )
        assert isinstance(pipe.scheduler					,    lowerCAmelCase_ )
        assert pipe.safety_checker is None

        __snake_case :					Optional[int]          =							pipe("example prompt"					,    num_inference_steps=2 ).images[0]
        assert image is not None

        # check that there's no error when saving a pipeline with one of the models being None
        with tempfile.TemporaryDirectory() as tmpdirname:
          pipe.save_pretrained(lowerCAmelCase_ )
          __snake_case :					int          =							StableDiffusionPipeline.from_pretrained(lowerCAmelCase_ )

        # sanity check that the pipeline still works
        assert pipe.safety_checker is None
        __snake_case :					Optional[int]          =							pipe("example prompt"					,    num_inference_steps=2 ).images[0]
        assert image is not None







      @unittest.skipIf(torch_device != "cuda"					,    "This test requires a GPU" )
      def     UpperCAmelCase		(			self )							-> List[Any]:






        '''simple docstring'''






        __snake_case :					Tuple          =							self.dummy_cond_unet
        __snake_case :					List[str]          =							PNDMScheduler(skip_prk_steps=lowerCAmelCase_ )
        __snake_case :					Tuple          =							self.dummy_vae
        __snake_case :					Any          =							self.dummy_text_encoder
        __snake_case :					int          =							CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip" )

        # put models in fp16
        __snake_case :					str          =							unet.half()
        __snake_case :					Union[str, Any]          =							vae.half()
        __snake_case :					List[Any]          =							bert.half()

        # make sure here that pndm scheduler skips prk
        __snake_case :					List[str]          =							StableDiffusionPipeline(
            unet=lowerCAmelCase_					,    scheduler=lowerCAmelCase_					,    vae=lowerCAmelCase_					,    text_encoder=lowerCAmelCase_					,    tokenizer=lowerCAmelCase_					,    safety_checker=lowerCAmelCase_					,    feature_extractor=self.dummy_extractor					,    )
        __snake_case :					List[str]          =							sd_pipe.to(lowerCAmelCase_ )
        sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_ )

        __snake_case :					Union[str, Any]          =							"A painting of a squirrel eating a burger"
        __snake_case :					Dict          =							sd_pipe([prompt]					,    num_inference_steps=2					,    output_type="np" ).images

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




@nightly
@require_torch_gpu
class 					_lowerCamelCase			(     unittest.TestCase     ):



      """simple docstring"""






      def     UpperCAmelCase		(			self )							-> Tuple:






        '''simple docstring'''






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







      def     UpperCAmelCase		(			self )							-> Optional[int]:






        '''simple docstring'''






        __snake_case :					Dict          =							StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"					,    safety_checker=lowerCAmelCase_ )
        __snake_case :					int          =							LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config )
        __snake_case :					Optional[Any]          =							sd_pipe.to(lowerCAmelCase_ )
        sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_ )

        __snake_case :					Optional[Any]          =							(
            "portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle"
            " coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with"
            " anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and"
            " children from bahnhof zoo, detailed "
        )
        __snake_case :					str          =							4003660346
        __snake_case :					Tuple          =							7

        # without safety guidance (sld_guidance_scale = 0)
        __snake_case :					Any          =							torch.manual_seed(lowerCAmelCase_ )
        __snake_case :					int          =							sd_pipe(
            [prompt]					,    generator=lowerCAmelCase_					,    guidance_scale=lowerCAmelCase_					,    num_inference_steps=50					,    output_type="np"					,    width=512					,    height=512					,    sld_guidance_scale=0					,    )

        __snake_case :					Dict          =							output.images
        __snake_case :					Tuple          =							image[0, -3:, -3:, -1]
        __snake_case :					str          =							[0.2_278, 0.2_231, 0.2_249, 0.2_333, 0.2_303, 0.1_885, 0.2_273, 0.2_144, 0.2_176]

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

        assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2

        # without safety guidance (strong configuration)
        __snake_case :					str          =							torch.manual_seed(lowerCAmelCase_ )
        __snake_case :					Tuple          =							sd_pipe(
            [prompt]					,    generator=lowerCAmelCase_					,    guidance_scale=lowerCAmelCase_					,    num_inference_steps=50					,    output_type="np"					,    width=512					,    height=512					,    sld_guidance_scale=2000					,    sld_warmup_steps=7					,    sld_threshold=0.025					,    sld_momentum_scale=0.5					,    sld_mom_beta=0.7					,    )

        __snake_case :					Union[str, Any]          =							output.images
        __snake_case :					Optional[int]          =							image[0, -3:, -3:, -1]
        __snake_case :					Optional[int]          =							[0.2_383, 0.2_276, 0.236, 0.2_192, 0.2_186, 0.2_053, 0.1_971, 0.1_901, 0.1_719]

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

        assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2







      def     UpperCAmelCase		(			self )							-> Union[str, Any]:






        '''simple docstring'''






        __snake_case :					List[str]          =							StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"					,    safety_checker=lowerCAmelCase_ )
        __snake_case :					Optional[int]          =							LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config )
        __snake_case :					Optional[Any]          =							sd_pipe.to(lowerCAmelCase_ )
        sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_ )

        __snake_case :					List[str]          =							"padme amidala taking a bath artwork, safe for work, no nudity"
        __snake_case :					List[str]          =							2734971755
        __snake_case :					Tuple          =							7

        __snake_case :					str          =							torch.manual_seed(lowerCAmelCase_ )
        __snake_case :					Optional[int]          =							sd_pipe(
            [prompt]					,    generator=lowerCAmelCase_					,    guidance_scale=lowerCAmelCase_					,    num_inference_steps=50					,    output_type="np"					,    width=512					,    height=512					,    sld_guidance_scale=0					,    )

        __snake_case :					Any          =							output.images
        __snake_case :					Union[str, Any]          =							image[0, -3:, -3:, -1]
        __snake_case :					Dict          =							[0.3_502, 0.3_622, 0.3_396, 0.3_642, 0.3_478, 0.3_318, 0.35, 0.3_348, 0.3_297]

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

        assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2

        __snake_case :					Optional[int]          =							torch.manual_seed(lowerCAmelCase_ )
        __snake_case :					List[str]          =							sd_pipe(
            [prompt]					,    generator=lowerCAmelCase_					,    guidance_scale=lowerCAmelCase_					,    num_inference_steps=50					,    output_type="np"					,    width=512					,    height=512					,    sld_guidance_scale=2000					,    sld_warmup_steps=7					,    sld_threshold=0.025					,    sld_momentum_scale=0.5					,    sld_mom_beta=0.7					,    )

        __snake_case :					str          =							output.images
        __snake_case :					List[str]          =							image[0, -3:, -3:, -1]
        __snake_case :					Tuple          =							[0.5_531, 0.5_206, 0.4_895, 0.5_156, 0.5_182, 0.4_751, 0.4_802, 0.4_803, 0.4_443]

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

        assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2







      def     UpperCAmelCase		(			self )							-> Optional[Any]:






        '''simple docstring'''






        __snake_case :					Dict          =							StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5" )
        __snake_case :					Tuple          =							sd_pipe.to(lowerCAmelCase_ )
        sd_pipe.set_progress_bar_config(disable=lowerCAmelCase_ )

        __snake_case :					int          =							(
            "the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."
            " leyendecker"
        )
        __snake_case :					Dict          =							1044355234
        __snake_case :					int          =							12

        __snake_case :					List[str]          =							torch.manual_seed(lowerCAmelCase_ )
        __snake_case :					Tuple          =							sd_pipe(
            [prompt]					,    generator=lowerCAmelCase_					,    guidance_scale=lowerCAmelCase_					,    num_inference_steps=50					,    output_type="np"					,    width=512					,    height=512					,    sld_guidance_scale=0					,    )

        __snake_case :					str          =							output.images
        __snake_case :					int          =							image[0, -3:, -3:, -1]
        __snake_case :					Union[str, Any]          =							np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] )

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

        assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-7

        __snake_case :					List[Any]          =							torch.manual_seed(lowerCAmelCase_ )
        __snake_case :					Tuple          =							sd_pipe(
            [prompt]					,    generator=lowerCAmelCase_					,    guidance_scale=lowerCAmelCase_					,    num_inference_steps=50					,    output_type="np"					,    width=512					,    height=512					,    sld_guidance_scale=2000					,    sld_warmup_steps=7					,    sld_threshold=0.025					,    sld_momentum_scale=0.5					,    sld_mom_beta=0.7					,    )

        __snake_case :					Optional[int]          =							output.images
        __snake_case :					Dict          =							image[0, -3:, -3:, -1]
        __snake_case :					int          =							np.array([0.5_818, 0.6_285, 0.6_835, 0.6_019, 0.625, 0.6_754, 0.6_096, 0.6_334, 0.6_561] )
        assert image.shape == (1, 512, 512, 3)

        assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2







'''simple docstring'''


import qiskit
def 						snake_case_       (UpperCamelCase			:    int					,		UpperCamelCase			:    int ):





							'''simple docstring'''


							_a      	=							qiskit.Aer.get_backend('''aer_simulator''' )

							_a      	=							qiskit.QuantumCircuit(4					,		2 )
							# encode inputs in qubits 0 and 1
							if bita == 1:
														qc_ha.x(0 )
							if bita == 1:
														qc_ha.x(1 )
							qc_ha.barrier()

							# use cnots to write XOR of the inputs on qubit2
							qc_ha.cx(0					,		2 )
							qc_ha.cx(1					,		2 )

							# use ccx / toffoli gate to write AND of the inputs on qubit3
							qc_ha.ccx(0					,		1					,		3 )
							qc_ha.barrier()

							# extract outputs
							qc_ha.measure(2					,		0 )  # extract XOR value
							qc_ha.measure(3					,		1 )  # extract AND value

							# Execute the circuit on the qasm simulator
							_a      	=							qiskit.execute(UpperCamelCase					,		UpperCamelCase					,		shots=1000 )

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


if __name__ == "__main__":
				_snake_case : Tuple  				=						half_adder(1, 1)
				print(F'''Half Adder Output Qubit Counts: {counts}''')

