


from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


__a     =			logging.get_logger(__name__)


if is_vision_available():
   import PIL






class   __lowercase				(  A_  ):
      UpperCamelCase								=       ['''pixel_values''']





      def __init__(		self						:					Optional[int]					,       __lowerCamelCase						:					List[str] = True					,       __lowerCamelCase						:					Any = None					,       __lowerCamelCase						:					List[str] = PILImageResampling.BICUBIC					,       __lowerCamelCase						:					Dict = True					,       __lowerCamelCase						:					Any = None					,       __lowerCamelCase						:					Any = True					,       __lowerCamelCase						:					Optional[int] = 1 / 2_5_5					,       __lowerCamelCase						:					Optional[int] = True					,       __lowerCamelCase						:					List[str] = None					,       __lowerCamelCase						:					Optional[int] = None					,       __lowerCamelCase						:					str = True					,       **__lowerCamelCase						:					str					,       )    ->   Optional[int]:






         """simple docstring"""







         super().__init__(**__lowerCamelCase       )
         UpperCAmelCase							=     size if size is not None else {"""shortest_edge""": 2_2_4}
         UpperCAmelCase							=     get_size_dict(__lowerCamelCase					,       default_to_square=__lowerCamelCase       )
         UpperCAmelCase							=     crop_size if crop_size is not None else {"""height""": 2_2_4, """width""": 2_2_4}
         UpperCAmelCase							=     get_size_dict(__lowerCamelCase					,       default_to_square=__lowerCamelCase					,       param_name="""crop_size"""       )

         UpperCAmelCase							=     do_resize
         UpperCAmelCase							=     size
         UpperCAmelCase							=     resample
         UpperCAmelCase							=     do_center_crop
         UpperCAmelCase							=     crop_size
         UpperCAmelCase							=     do_rescale
         UpperCAmelCase							=     rescale_factor
         UpperCAmelCase							=     do_normalize
         UpperCAmelCase							=     image_mean if image_mean is not None else OPENAI_CLIP_MEAN
         UpperCAmelCase							=     image_std if image_std is not None else OPENAI_CLIP_STD
         UpperCAmelCase							=     do_convert_rgb





      def        _lowercase				(		self						:					str					,       __lowerCamelCase						:					List[Any]					,       __lowerCamelCase						:					Optional[int]					,       __lowerCamelCase						:					List[Any] = PILImageResampling.BICUBIC					,       __lowerCamelCase						:					Union[str, Any] = None					,       **__lowerCamelCase						:					Optional[Any]					,       )    ->   Any:






         """simple docstring"""







         UpperCAmelCase							=     get_size_dict(__lowerCamelCase					,       default_to_square=__lowerCamelCase       )
         if "shortest_edge" not in size:
            raise ValueError(F"""The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}"""       )
         UpperCAmelCase							=     get_resize_output_image_size(__lowerCamelCase					,       size=size["""shortest_edge"""]					,       default_to_square=__lowerCamelCase       )
         return resize(__lowerCamelCase					,       size=__lowerCamelCase					,       resample=__lowerCamelCase					,       data_format=__lowerCamelCase					,       **__lowerCamelCase       )





      def        _lowercase				(		self						:					List[Any]					,       __lowerCamelCase						:					List[Any]					,       __lowerCamelCase						:					List[Any]					,       __lowerCamelCase						:					int = None					,       **__lowerCamelCase						:					Any					,       )    ->   Tuple:






         """simple docstring"""







         UpperCAmelCase							=     get_size_dict(__lowerCamelCase       )
         if "height" not in size or "width" not in size:
            raise ValueError(F"""The `size` parameter must contain the keys (height, width). Got {size.keys()}"""       )
         return center_crop(__lowerCamelCase					,       size=(size["""height"""], size["""width"""])					,       data_format=__lowerCamelCase					,       **__lowerCamelCase       )





      def        _lowercase				(		self						:					List[str]					,       __lowerCamelCase						:					Optional[int]					,       __lowerCamelCase						:					int					,       __lowerCamelCase						:					int = None					,       **__lowerCamelCase						:					List[str]					,       )    ->   Union[str, Any]:






         """simple docstring"""







         return rescale(__lowerCamelCase					,       scale=__lowerCamelCase					,       data_format=__lowerCamelCase					,       **__lowerCamelCase       )





      def        _lowercase				(		self						:					int					,       __lowerCamelCase						:					Dict					,       __lowerCamelCase						:					Union[str, Any]					,       __lowerCamelCase						:					int					,       __lowerCamelCase						:					int = None					,       **__lowerCamelCase						:					Union[str, Any]					,       )    ->   int:






         """simple docstring"""







         return normalize(__lowerCamelCase					,       mean=__lowerCamelCase					,       std=__lowerCamelCase					,       data_format=__lowerCamelCase					,       **__lowerCamelCase       )





      def        _lowercase				(		self						:					Dict					,       __lowerCamelCase						:					Union[str, Any]					,       __lowerCamelCase						:					Optional[int] = None					,       __lowerCamelCase						:					Optional[int] = None					,       __lowerCamelCase						:					Optional[int] = None					,       __lowerCamelCase						:					Any = None					,       __lowerCamelCase						:					str = None					,       __lowerCamelCase						:					Dict = None					,       __lowerCamelCase						:					List[Any] = None					,       __lowerCamelCase						:					Optional[Any] = None					,       __lowerCamelCase						:					Dict = None					,       __lowerCamelCase						:					List[Any] = None					,       __lowerCamelCase						:					str = None					,       __lowerCamelCase						:					Optional[Any] = None					,       __lowerCamelCase						:					List[str] = ChannelDimension.FIRST					,       **__lowerCamelCase						:					Tuple					,       )    ->   Tuple:






         """simple docstring"""







         UpperCAmelCase							=     do_resize if do_resize is not None else self.do_resize
         UpperCAmelCase							=     size if size is not None else self.size
         UpperCAmelCase							=     get_size_dict(__lowerCamelCase					,       param_name="""size"""					,       default_to_square=__lowerCamelCase       )
         UpperCAmelCase							=     resample if resample is not None else self.resample
         UpperCAmelCase							=     do_center_crop if do_center_crop is not None else self.do_center_crop
         UpperCAmelCase							=     crop_size if crop_size is not None else self.crop_size
         UpperCAmelCase							=     get_size_dict(__lowerCamelCase					,       param_name="""crop_size"""					,       default_to_square=__lowerCamelCase       )
         UpperCAmelCase							=     do_rescale if do_rescale is not None else self.do_rescale
         UpperCAmelCase							=     rescale_factor if rescale_factor is not None else self.rescale_factor
         UpperCAmelCase							=     do_normalize if do_normalize is not None else self.do_normalize
         UpperCAmelCase							=     image_mean if image_mean is not None else self.image_mean
         UpperCAmelCase							=     image_std if image_std is not None else self.image_std
         UpperCAmelCase							=     do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

         UpperCAmelCase							=     make_list_of_images(__lowerCamelCase       )

         if not valid_images(__lowerCamelCase       ):
            raise ValueError(
                """Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, """
                """torch.Tensor, tf.Tensor or jax.ndarray."""       )

         if do_resize and size is None:
            raise ValueError("""Size must be specified if do_resize is True."""       )

         if do_center_crop and crop_size is None:
            raise ValueError("""Crop size must be specified if do_center_crop is True."""       )

         if do_rescale and rescale_factor is None:
            raise ValueError("""Rescale factor must be specified if do_rescale is True."""       )

         if do_normalize and (image_mean is None or image_std is None):
            raise ValueError("""Image mean and std must be specified if do_normalize is True."""       )

         # PIL RGBA images are converted to RGB
         if do_convert_rgb:
            UpperCAmelCase							=     [convert_to_rgb(__lowerCamelCase       ) for image in images]

         # All transformations expect numpy arrays.
         UpperCAmelCase							=     [to_numpy_array(__lowerCamelCase       ) for image in images]

         if do_resize:
            UpperCAmelCase							=     [self.resize(image=__lowerCamelCase					,       size=__lowerCamelCase					,       resample=__lowerCamelCase       ) for image in images]

         if do_center_crop:
            UpperCAmelCase							=     [self.center_crop(image=__lowerCamelCase					,       size=__lowerCamelCase       ) for image in images]

         if do_rescale:
            UpperCAmelCase							=     [self.rescale(image=__lowerCamelCase					,       scale=__lowerCamelCase       ) for image in images]

         if do_normalize:
            UpperCAmelCase							=     [self.normalize(image=__lowerCamelCase					,       mean=__lowerCamelCase					,       std=__lowerCamelCase       ) for image in images]

         UpperCAmelCase							=     [to_channel_dimension_format(__lowerCamelCase					,       __lowerCamelCase       ) for image in images]

         UpperCAmelCase							=     {"""pixel_values""": images}
         return BatchFeature(data=__lowerCamelCase					,       tensor_type=__lowerCamelCase       )







import math

import qiskit
def   _UpperCamelCase				(						lowerCAmelCase_ = 1  ,						lowerCAmelCase_ = 1  ,						lowerCAmelCase_ = 1   )						->qiskit.result.counts.Counts:
   if (
       isinstance(lowerCAmelCase_  ,						lowerCAmelCase_   )
       or isinstance(lowerCAmelCase_  ,						lowerCAmelCase_   )
       or isinstance(lowerCAmelCase_  ,						lowerCAmelCase_   )
   ):
      raise TypeError("""inputs must be integers."""   )

   if (input_a < 0) or (input_a < 0) or (carry_in < 0):
      raise ValueError("""inputs must be positive."""   )

   if (
       (math.floor(lowerCAmelCase_   ) != input_a)
       or (math.floor(lowerCAmelCase_   ) != input_a)
       or (math.floor(lowerCAmelCase_   ) != carry_in)
   ):
      raise ValueError("""inputs must be exact integers."""   )

   if (input_a > 2) or (input_a > 2) or (carry_in > 2):
      raise ValueError("""inputs must be less or equal to 2."""   )

   # build registers
   UpperCAmelCase							=     qiskit.QuantumRegister(4  ,						"""qr"""   )
   UpperCAmelCase							=     qiskit.ClassicalRegister(2  ,						"""cr"""   )
   # list the entries
   UpperCAmelCase							=     [input_a, input_a, carry_in]

   UpperCAmelCase							=     qiskit.QuantumCircuit(lowerCAmelCase_  ,						lowerCAmelCase_   )

   for i in range(0  ,						3   ):
      if entry[i] == 2:
         quantum_circuit.h(lowerCAmelCase_   )  # for hadamard entries
      elif entry[i] == 1:
         quantum_circuit.x(lowerCAmelCase_   )  # for 1 entries
      elif entry[i] == 0:
         quantum_circuit.i(lowerCAmelCase_   )  # for 0 entries

    # build the circuit
   quantum_circuit.ccx(0  ,						1  ,						3   )  # ccx = toffoli gate
   quantum_circuit.cx(0  ,						1   )
   quantum_circuit.ccx(1  ,						2  ,						3   )
   quantum_circuit.cx(1  ,						2   )
   quantum_circuit.cx(0  ,						1   )

   quantum_circuit.measure([2, 3]  ,						lowerCAmelCase_   )  # measure the last two qbits

   UpperCAmelCase							=     qiskit.Aer.get_backend("""aer_simulator"""   )
   UpperCAmelCase							=     qiskit.execute(lowerCAmelCase_  ,						lowerCAmelCase_  ,						shots=1_0_0_0   )

   return job.result().get_counts(lowerCAmelCase_   )


if __name__ == "__main__":
 print(F"""Total sum count for state is: {quantum_full_adder(1, 1, 1)}""")



