

"""simple docstring"""




import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device



def 						UpperCAmelCase__ (					A__ )   ->   List[Any]:




   """simple docstring"""
   lowerCamelCase__						       =      {}
   for name in unet.attn_processors.keys():
      lowerCamelCase__						       =      None if name.endswith("attn1.processor" ) else unet.config.cross_attention_dim
      if name.startswith("mid_block" ):
         lowerCamelCase__						       =      unet.config.block_out_channels[-1]
      elif name.startswith("up_blocks" ):
         lowerCamelCase__						       =      int(name[len("up_blocks." )] )
         lowerCamelCase__						       =      list(reversed(unet.config.block_out_channels ) )[block_id]
      elif name.startswith("down_blocks" ):
         lowerCamelCase__						       =      int(name[len("down_blocks." )] )
         lowerCamelCase__						       =      unet.config.block_out_channels[block_id]
      lowerCamelCase__						       =      (
          LoRAAttnProcessor2_0 if hasattr(A__						,     "scaled_dot_product_attention" ) else LoRAAttnProcessor
      )
      lowerCamelCase__						       =      lora_attn_processor_class(
          hidden_size=A__						,     cross_attention_dim=A__ )
   lowerCamelCase__						       =      AttnProcsLayers(A__ )
   return lora_attn_procs, unet_lora_layers



def 						UpperCAmelCase__ (					A__ )   ->   Union[str, Any]:




   """simple docstring"""
   lowerCamelCase__						       =      {}
   lowerCamelCase__						       =      (
       LoRAAttnProcessor2_0 if hasattr(A__						,     "scaled_dot_product_attention" ) else LoRAAttnProcessor
   )
   for name, module in text_encoder.named_modules():
      if name.endswith(A__ ):
         lowerCamelCase__						       =      lora_attn_processor_class(
             hidden_size=module.out_proj.out_features						,     cross_attention_dim=A__ )
   return text_lora_attn_procs



def 						UpperCAmelCase__ (					A__ )   ->   List[Any]:




   """simple docstring"""
   lowerCamelCase__						       =      create_text_encoder_lora_attn_procs(A__ )
   lowerCamelCase__						       =      AttnProcsLayers(A__ )
   return text_encoder_lora_layers



def 						UpperCAmelCase__ (					A__						,     A__=False )   ->   Optional[Any]:




   """simple docstring"""
   for _, attn_proc in text_lora_attn_procs.items():
      # set up.weights
      for layer_name, layer_module in attn_proc.named_modules():
         if layer_name.endswith("_lora" ):
            lowerCamelCase__						       =      (
                torch.randn_like(layer_module.up.weight )
                if randn_weight
                else torch.zeros_like(layer_module.up.weight )
            )
            lowerCamelCase__						       =      torch.nn.Parameter(A__ )


class 		_A							(      unittest.TestCase       ):





      def        _lowerCamelCase	(	self		) ->       Union[str, Any]:
         torch.manual_seed(0		)
         lowerCamelCase__						       =      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     ,    )
         lowerCamelCase__						       =      DDIMScheduler(
             beta_start=0.0_00_85     ,    beta_end=0.0_12     ,    beta_schedule="scaled_linear"     ,    clip_sample=SCREAMING_SNAKE_CASE__     ,    set_alpha_to_one=SCREAMING_SNAKE_CASE__     ,    steps_offset=1     ,    )
         torch.manual_seed(0		)
         lowerCamelCase__						       =      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     ,    )
         lowerCamelCase__						       =      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     ,    )
         lowerCamelCase__						       =      CLIPTextModel(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"		)

         lowerCamelCase__       ,							lowerCamelCase__						       =      create_unet_lora_layers(SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      create_text_encoder_lora_layers(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      {
             "unet": unet,
             "scheduler": scheduler,
             "vae": vae,
             "text_encoder": text_encoder,
             "tokenizer": tokenizer,
             "safety_checker": None,
             "feature_extractor": None,
         }
         lowerCamelCase__						       =      {
             "unet_lora_layers": unet_lora_layers,
             "text_encoder_lora_layers": text_encoder_lora_layers,
             "unet_lora_attn_procs": unet_lora_attn_procs,
         }
         return pipeline_components, lora_components





      def        _lowerCamelCase	(	self		) ->       Optional[Any]:
         lowerCamelCase__						       =      1
         lowerCamelCase__						       =      10
         lowerCamelCase__						       =      4
         lowerCamelCase__						       =      (32, 32)

         lowerCamelCase__						       =      torch.manual_seed(0		)
         lowerCamelCase__						       =      floats_tensor((batch_size, num_channels) + sizes		)
         lowerCamelCase__						       =      torch.randint(1     ,    SCREAMING_SNAKE_CASE__     ,    size=(batch_size, sequence_length)     ,    generator=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      {
             "prompt": "A painting of a squirrel eating a burger",
             "generator": generator,
             "num_inference_steps": 2,
             "guidance_scale": 6.0,
             "output_type": "numpy",
         }

         return noise, input_ids, pipeline_inputs

         # copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb





      def        _lowerCamelCase	(	self		) ->       Any:
         lowerCamelCase__						       =      77

         lowerCamelCase__						       =      torch.randint(2     ,    56     ,    size=(1, max_seq_length)     ,    generator=torch.manual_seed(0		)		)

         lowerCamelCase__						       =      {}
         lowerCamelCase__						       =      inputs
         return prepared_inputs





      def        _lowerCamelCase	(	self     ,    SCREAMING_SNAKE_CASE__		) ->       Optional[int]:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_components()
         LoraLoaderMixin.save_lora_weights(
             save_directory=SCREAMING_SNAKE_CASE__     ,    unet_lora_layers=lora_components["unet_lora_layers"]     ,    text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]     ,    )
         self.assertTrue(os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__     ,    "pytorch_lora_weights.bin"		)		)		)





      def        _lowerCamelCase	(	self		) ->       List[Any]:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_components()
         lowerCamelCase__						       =      StableDiffusionPipeline(**SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      sd_pipe.to(SCREAMING_SNAKE_CASE__		)
         sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__       ,							lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_inputs()

         lowerCamelCase__						       =      sd_pipe(**SCREAMING_SNAKE_CASE__		).images
         lowerCamelCase__						       =      original_images[0, -3:, -3:, -1]

         with tempfile.TemporaryDirectory() as tmpdirname:
            LoraLoaderMixin.save_lora_weights(
                save_directory=SCREAMING_SNAKE_CASE__     ,    unet_lora_layers=lora_components["unet_lora_layers"]     ,    text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]     ,    )
            self.assertTrue(os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__     ,    "pytorch_lora_weights.bin"		)		)		)
            sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      sd_pipe(**SCREAMING_SNAKE_CASE__		).images
         lowerCamelCase__						       =      lora_images[0, -3:, -3:, -1]

         # Outputs shouldn't match.
         self.assertFalse(torch.allclose(torch.from_numpy(SCREAMING_SNAKE_CASE__		)     ,    torch.from_numpy(SCREAMING_SNAKE_CASE__		)		)		)





      def        _lowerCamelCase	(	self		) ->       Optional[Any]:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_components()
         lowerCamelCase__						       =      StableDiffusionPipeline(**SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      sd_pipe.to(SCREAMING_SNAKE_CASE__		)
         sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__       ,							lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_inputs()

         lowerCamelCase__						       =      sd_pipe(**SCREAMING_SNAKE_CASE__		).images
         lowerCamelCase__						       =      original_images[0, -3:, -3:, -1]

         with tempfile.TemporaryDirectory() as tmpdirname:
            LoraLoaderMixin.save_lora_weights(
                save_directory=SCREAMING_SNAKE_CASE__     ,    unet_lora_layers=lora_components["unet_lora_layers"]     ,    text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]     ,    safe_serialization=SCREAMING_SNAKE_CASE__     ,    )
            self.assertTrue(os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__     ,    "pytorch_lora_weights.safetensors"		)		)		)
            sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      sd_pipe(**SCREAMING_SNAKE_CASE__		).images
         lowerCamelCase__						       =      lora_images[0, -3:, -3:, -1]

         # Outputs shouldn't match.
         self.assertFalse(torch.allclose(torch.from_numpy(SCREAMING_SNAKE_CASE__		)     ,    torch.from_numpy(SCREAMING_SNAKE_CASE__		)		)		)





      def        _lowerCamelCase	(	self		) ->       List[Any]:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_components()
         lowerCamelCase__						       =      lora_components["unet_lora_attn_procs"]
         lowerCamelCase__						       =      StableDiffusionPipeline(**SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      sd_pipe.to(SCREAMING_SNAKE_CASE__		)
         sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__       ,							lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_inputs()

         lowerCamelCase__						       =      sd_pipe(**SCREAMING_SNAKE_CASE__		).images
         lowerCamelCase__						       =      original_images[0, -3:, -3:, -1]

         with tempfile.TemporaryDirectory() as tmpdirname:
            lowerCamelCase__						       =      sd_pipe.unet
            unet.set_attn_processor(SCREAMING_SNAKE_CASE__		)
            unet.save_attn_procs(SCREAMING_SNAKE_CASE__		)
            self.assertTrue(os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__     ,    "pytorch_lora_weights.bin"		)		)		)
            sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      sd_pipe(**SCREAMING_SNAKE_CASE__		).images
         lowerCamelCase__						       =      lora_images[0, -3:, -3:, -1]

         # Outputs shouldn't match.
         self.assertFalse(torch.allclose(torch.from_numpy(SCREAMING_SNAKE_CASE__		)     ,    torch.from_numpy(SCREAMING_SNAKE_CASE__		)		)		)





      def        _lowerCamelCase	(	self		) ->       Dict:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_components()
         lowerCamelCase__						       =      StableDiffusionPipeline(**SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      self.get_dummy_tokens()

         # inference without lora
         lowerCamelCase__						       =      pipe.text_encoder(**SCREAMING_SNAKE_CASE__		)[0]
         assert outputs_without_lora.shape == (1, 77, 32)

         # create lora_attn_procs with zeroed out up.weights
         lowerCamelCase__						       =      create_text_encoder_lora_attn_procs(pipe.text_encoder		)
         set_lora_up_weights(SCREAMING_SNAKE_CASE__     ,    randn_weight=SCREAMING_SNAKE_CASE__		)

         # monkey patch
         pipe._modify_text_encoder(SCREAMING_SNAKE_CASE__		)

         # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
         del text_attn_procs
         gc.collect()

         # inference with lora
         lowerCamelCase__						       =      pipe.text_encoder(**SCREAMING_SNAKE_CASE__		)[0]
         assert outputs_with_lora.shape == (1, 77, 32)

         assert torch.allclose(
             SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

         # create lora_attn_procs with randn up.weights
         lowerCamelCase__						       =      create_text_encoder_lora_attn_procs(pipe.text_encoder		)
         set_lora_up_weights(SCREAMING_SNAKE_CASE__     ,    randn_weight=SCREAMING_SNAKE_CASE__		)

         # monkey patch
         pipe._modify_text_encoder(SCREAMING_SNAKE_CASE__		)

         # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
         del text_attn_procs
         gc.collect()

         # inference with lora
         lowerCamelCase__						       =      pipe.text_encoder(**SCREAMING_SNAKE_CASE__		)[0]
         assert outputs_with_lora.shape == (1, 77, 32)

         assert not torch.allclose(
             SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"





      def        _lowerCamelCase	(	self		) ->       List[str]:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_components()
         lowerCamelCase__						       =      StableDiffusionPipeline(**SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      self.get_dummy_tokens()

         # inference without lora
         lowerCamelCase__						       =      pipe.text_encoder(**SCREAMING_SNAKE_CASE__		)[0]
         assert outputs_without_lora.shape == (1, 77, 32)

         # create lora_attn_procs with randn up.weights
         lowerCamelCase__						       =      create_text_encoder_lora_attn_procs(pipe.text_encoder		)
         set_lora_up_weights(SCREAMING_SNAKE_CASE__     ,    randn_weight=SCREAMING_SNAKE_CASE__		)

         # monkey patch
         pipe._modify_text_encoder(SCREAMING_SNAKE_CASE__		)

         # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
         del text_attn_procs
         gc.collect()

         # inference with lora
         lowerCamelCase__						       =      pipe.text_encoder(**SCREAMING_SNAKE_CASE__		)[0]
         assert outputs_with_lora.shape == (1, 77, 32)

         assert not torch.allclose(
             SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		), "lora outputs should be different to without lora outputs"

         # remove monkey patch
         pipe._remove_text_encoder_monkey_patch()

         # inference with removed lora
         lowerCamelCase__						       =      pipe.text_encoder(**SCREAMING_SNAKE_CASE__		)[0]
         assert outputs_without_lora_removed.shape == (1, 77, 32)

         assert torch.allclose(
             SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		), "remove lora monkey patch should restore the original outputs"





      def        _lowerCamelCase	(	self		) ->       Optional[int]:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_components()
         lowerCamelCase__						       =      StableDiffusionPipeline(**SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      sd_pipe.to(SCREAMING_SNAKE_CASE__		)
         sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__       ,							lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_inputs()

         with tempfile.TemporaryDirectory() as tmpdirname:
            LoraLoaderMixin.save_lora_weights(
                save_directory=SCREAMING_SNAKE_CASE__     ,    unet_lora_layers=lora_components["unet_lora_layers"]     ,    text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]     ,    )
            self.assertTrue(os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__     ,    "pytorch_lora_weights.bin"		)		)		)
            sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      sd_pipe(**SCREAMING_SNAKE_CASE__		).images
         lowerCamelCase__						       =      lora_images[0, -3:, -3:, -1]

         lowerCamelCase__						       =      sd_pipe(**SCREAMING_SNAKE_CASE__     ,    cross_attention_kwargs={"scale": 0.5}		).images
         lowerCamelCase__						       =      lora_images_with_scale[0, -3:, -3:, -1]

         # Outputs shouldn't match.
         self.assertFalse(
             torch.allclose(torch.from_numpy(SCREAMING_SNAKE_CASE__		)     ,    torch.from_numpy(SCREAMING_SNAKE_CASE__		)		)		)





      def        _lowerCamelCase	(	self		) ->       List[str]:
         with tempfile.TemporaryDirectory() as tmpdirname:
            self.create_lora_weight_file(SCREAMING_SNAKE_CASE__		)

            lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_components()
            lowerCamelCase__						       =      StableDiffusionPipeline(**SCREAMING_SNAKE_CASE__		)
            lowerCamelCase__						       =      sd_pipe.to(SCREAMING_SNAKE_CASE__		)
            sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

            # check if vanilla attention processors are used
            for _, module in sd_pipe.unet.named_modules():
               if isinstance(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		):
                  self.assertIsInstance(module.processor     ,    (AttnProcessor, AttnProcessor2_0)		)

            # load LoRA weight file
            sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE__		)

            # check if lora attention processors are used
            for _, module in sd_pipe.unet.named_modules():
               if isinstance(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		):
                  lowerCamelCase__						       =      (
                      LoRAAttnProcessor2_0 if hasattr(SCREAMING_SNAKE_CASE__     ,    "scaled_dot_product_attention"		) else LoRAAttnProcessor
                  )
                  self.assertIsInstance(module.processor     ,    SCREAMING_SNAKE_CASE__		)





      @unittest.skipIf(torch_device != "cuda"     ,    "This test is supposed to run on GPU"		)
      def        _lowerCamelCase	(	self		) ->       Union[str, Any]:
         with tempfile.TemporaryDirectory() as tmpdirname:
            self.create_lora_weight_file(SCREAMING_SNAKE_CASE__		)

            lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_components()
            lowerCamelCase__						       =      StableDiffusionPipeline(**SCREAMING_SNAKE_CASE__		)
            lowerCamelCase__						       =      sd_pipe.to(SCREAMING_SNAKE_CASE__		)
            sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

            # enable XFormers
            sd_pipe.enable_xformers_memory_efficient_attention()

            # check if xFormers attention processors are used
            for _, module in sd_pipe.unet.named_modules():
               if isinstance(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		):
                  self.assertIsInstance(module.processor     ,    SCREAMING_SNAKE_CASE__		)

            # load LoRA weight file
            sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE__		)

            # check if lora attention processors are used
            for _, module in sd_pipe.unet.named_modules():
               if isinstance(SCREAMING_SNAKE_CASE__     ,    SCREAMING_SNAKE_CASE__		):
                  self.assertIsInstance(module.processor     ,    SCREAMING_SNAKE_CASE__		)





      @unittest.skipIf(torch_device != "cuda"     ,    "This test is supposed to run on GPU"		)
      def        _lowerCamelCase	(	self		) ->       Dict:
         lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_components()
         lowerCamelCase__						       =      StableDiffusionPipeline(**SCREAMING_SNAKE_CASE__		)
         lowerCamelCase__						       =      sd_pipe.to(SCREAMING_SNAKE_CASE__		)
         sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__       ,							lowerCamelCase__       ,							lowerCamelCase__						       =      self.get_dummy_inputs()

         # enable XFormers
         sd_pipe.enable_xformers_memory_efficient_attention()

         lowerCamelCase__						       =      sd_pipe(**SCREAMING_SNAKE_CASE__		).images
         lowerCamelCase__						       =      original_images[0, -3:, -3:, -1]

         with tempfile.TemporaryDirectory() as tmpdirname:
            LoraLoaderMixin.save_lora_weights(
                save_directory=SCREAMING_SNAKE_CASE__     ,    unet_lora_layers=lora_components["unet_lora_layers"]     ,    text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]     ,    )
            self.assertTrue(os.path.isfile(os.path.join(SCREAMING_SNAKE_CASE__     ,    "pytorch_lora_weights.bin"		)		)		)
            sd_pipe.load_lora_weights(SCREAMING_SNAKE_CASE__		)

         lowerCamelCase__						       =      sd_pipe(**SCREAMING_SNAKE_CASE__		).images
         lowerCamelCase__						       =      lora_images[0, -3:, -3:, -1]

         # Outputs shouldn't match.
         self.assertFalse(torch.allclose(torch.from_numpy(SCREAMING_SNAKE_CASE__		)     ,    torch.from_numpy(SCREAMING_SNAKE_CASE__		)		)		)







"""simple docstring"""




import math

import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute



def 						UpperCAmelCase__ (					A__ = 1						,     A__ = 1 )   ->   qiskit.result.counts.Counts:




   """simple docstring"""
   if isinstance(A__						,     A__ ) or isinstance(A__						,     A__ ):
      raise TypeError("inputs must be integers." )
   if (bit_a < 0) or (bit_a < 0):
      raise ValueError("inputs must be positive." )
   if (math.floor(A__ ) != bit_a) or (math.floor(A__ ) != bit_a):
      raise ValueError("inputs must be exact integers." )
   if (bit_a > 1) or (bit_a > 1):
      raise ValueError("inputs must be less or equal to 1." )

   # build registers
   lowerCamelCase__						       =      QuantumRegister(2						,     "qr" )
   lowerCamelCase__						       =      ClassicalRegister(2						,     "cr" )

   lowerCamelCase__						       =      QuantumCircuit(A__						,     A__ )

   # entanglement the qubits
   quantum_circuit.h(1 )
   quantum_circuit.cx(1						,     0 )

   # send the information
   lowerCamelCase__						       =      str(A__ ) + str(A__ )

   if c_information == "11":
      quantum_circuit.x(1 )
      quantum_circuit.z(1 )
   elif c_information == "10":
      quantum_circuit.z(1 )
   elif c_information == "01":
      quantum_circuit.x(1 )
   else:
      quantum_circuit.i(1 )

   # unentangled the circuit
   quantum_circuit.cx(1						,     0 )
   quantum_circuit.h(1 )

   # measure the circuit
   quantum_circuit.measure(A__						,     A__ )

   lowerCamelCase__						       =      Aer.get_backend("aer_simulator" )
   lowerCamelCase__						       =      execute(A__						,     A__						,     shots=1000 )

   return job.result().get_counts(A__ )


if __name__ == "__main__":
     print(F'''Counts for classical state send: {superdense_coding(1,1)}''')




