'''simple docstring'''

import math
from typing import Dict, Iterable, List, Optional, Tuple, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    is_torch_available,
    is_torch_tensor,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_torch_available():
  import torch

if is_vision_available():
  import PIL


__a:			List[str]	       =       logging.get_logger(__name__)
def       __UpperCamelCase	(       UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase					):
 def constraint_to_multiple_of(UpperCAmelCase		,					UpperCAmelCase		,					UpperCAmelCase=0		,					UpperCAmelCase=None					):
  lowercase__    :   Dict						= round(val / multiple					) * multiple

  if max_val is not None and x > max_val:
   lowercase__    :   List[str]						= math.floor(val / multiple					) * multiple

  if x < min_val:
   lowercase__    :   str						= math.ceil(val / multiple					) * multiple

  return x

 lowercase__    :   Optional[int]						= (output_size, output_size) if isinstance(UpperCAmelCase		,					UpperCAmelCase					) else output_size

 lowercase__			,							lowercase__    :   Union[str, Any]						= get_image_size(UpperCAmelCase					)
 lowercase__			,							lowercase__    :   List[Any]						= output_size

 # determine new height and width
 lowercase__    :   int						= output_height / input_height
 lowercase__    :   List[Any]						= output_width / input_width

 if keep_aspect_ratio:
  # scale as little as possible
  if abs(1 - scale_width					) < abs(1 - scale_height					):
   # fit width
   lowercase__    :   Dict						= scale_width
  else:
   # fit height
   lowercase__    :   Tuple						= scale_height

 lowercase__    :   int						= constraint_to_multiple_of(scale_height * input_height		,					multiple=UpperCAmelCase					)
 lowercase__    :   str						= constraint_to_multiple_of(scale_width * input_width		,					multiple=UpperCAmelCase					)

 return (new_height, new_width)





class       UpperCAmelCase  (						a__ ):





       '''simple docstring'''



       SCREAMING_SNAKE_CASE 		=   ["pixel_values"]

       def __init__(						self     ,       __lowerCAmelCase = True     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = PILImageResampling.BILINEAR     ,       __lowerCAmelCase = False     ,       __lowerCAmelCase = 1     ,       __lowerCAmelCase = True     ,       __lowerCAmelCase = 1 / 255     ,       __lowerCAmelCase = True     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       **__lowerCAmelCase     ,       )  ->  None:
        super().__init__(**__lowerCAmelCase			)
        lowercase__    :   str						= size if size is not None else {'''height''': 384, '''width''': 384}
        lowercase__    :   Tuple						= get_size_dict(__lowerCAmelCase			)
        lowercase__    :   Dict						= do_resize
        lowercase__    :   str						= size
        lowercase__    :   Dict						= keep_aspect_ratio
        lowercase__    :   Union[str, Any]						= ensure_multiple_of
        lowercase__    :   str						= resample
        lowercase__    :   int						= do_rescale
        lowercase__    :   List[Any]						= rescale_factor
        lowercase__    :   List[str]						= do_normalize
        lowercase__    :   Dict						= image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
        lowercase__    :   Any						= image_std if image_std is not None else IMAGENET_STANDARD_STD

       def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase     ,       __lowerCAmelCase = False     ,       __lowerCAmelCase = 1     ,       __lowerCAmelCase = PILImageResampling.BICUBIC     ,       __lowerCAmelCase = None     ,       **__lowerCAmelCase     ,       )  ->  np.ndarray:
        lowercase__    :   int						= get_size_dict(__lowerCAmelCase			)
        if "height" not in size or "width" not in size:
         raise ValueError(F"""The size dictionary must contain the keys 'height' and 'width'. Got {size.keys()}"""			)
        lowercase__    :   Dict						= get_resize_output_image_size(
            __lowerCAmelCase     ,       output_size=(size['''height'''], size['''width'''])     ,       keep_aspect_ratio=__lowerCAmelCase     ,       multiple=__lowerCAmelCase     ,       )
        return resize(__lowerCAmelCase     ,       size=__lowerCAmelCase     ,       resample=__lowerCAmelCase     ,       data_format=__lowerCAmelCase     ,       **__lowerCAmelCase			)

       def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase     ,       __lowerCAmelCase = None     ,       **__lowerCAmelCase     ,       )  ->  List[Any]:
        return rescale(__lowerCAmelCase     ,       scale=__lowerCAmelCase     ,       data_format=__lowerCAmelCase     ,       **__lowerCAmelCase			)

       def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase     ,       __lowerCAmelCase     ,       __lowerCAmelCase = None     ,       **__lowerCAmelCase     ,       )  ->  np.ndarray:
        return normalize(__lowerCAmelCase     ,       mean=__lowerCAmelCase     ,       std=__lowerCAmelCase     ,       data_format=__lowerCAmelCase     ,       **__lowerCAmelCase			)

       def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = None     ,       __lowerCAmelCase = ChannelDimension.FIRST     ,       **__lowerCAmelCase     ,       )  ->  PIL.Image.Image:
        lowercase__    :   Dict						= do_resize if do_resize is not None else self.do_resize
        lowercase__    :   Optional[Any]						= size if size is not None else self.size
        lowercase__    :   List[Any]						= get_size_dict(__lowerCAmelCase			)
        lowercase__    :   List[Any]						= keep_aspect_ratio if keep_aspect_ratio is not None else self.keep_aspect_ratio
        lowercase__    :   Optional[Any]						= ensure_multiple_of if ensure_multiple_of is not None else self.ensure_multiple_of
        lowercase__    :   Tuple						= resample if resample is not None else self.resample
        lowercase__    :   Dict						= do_rescale if do_rescale is not None else self.do_rescale
        lowercase__    :   List[str]						= rescale_factor if rescale_factor is not None else self.rescale_factor
        lowercase__    :   Optional[Any]						= do_normalize if do_normalize is not None else self.do_normalize
        lowercase__    :   Optional[int]						= image_mean if image_mean is not None else self.image_mean
        lowercase__    :   Tuple						= image_std if image_std is not None else self.image_std

        lowercase__    :   Optional[int]						= 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 or resample is None:
         raise ValueError('''Size and resample must be specified if do_resize 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.'''			)

        # All transformations expect numpy arrays.
        lowercase__    :   str						= [to_numpy_array(__lowerCAmelCase			) for image in images]

        if do_resize:
         lowercase__    :   Union[str, Any]						= [self.resize(image=__lowerCAmelCase     ,       size=__lowerCAmelCase     ,       resample=__lowerCAmelCase			) for image in images]

        if do_rescale:
         lowercase__    :   List[Any]						= [self.rescale(image=__lowerCAmelCase     ,       scale=__lowerCAmelCase			) for image in images]

        if do_normalize:
         lowercase__    :   str						= [self.normalize(image=__lowerCAmelCase     ,       mean=__lowerCAmelCase     ,       std=__lowerCAmelCase			) for image in images]

        lowercase__    :   Tuple						= [to_channel_dimension_format(__lowerCAmelCase     ,       __lowerCAmelCase			) for image in images]

        lowercase__    :   str						= {'''pixel_values''': images}
        return BatchFeature(data=__lowerCAmelCase     ,       tensor_type=__lowerCAmelCase			)


       def _lowerCAmelCase(						self     ,       __lowerCAmelCase     ,       __lowerCAmelCase = None			)  ->  int:
        lowercase__    :   Dict						= outputs.logits

        # Resize logits and compute semantic segmentation maps
        if target_sizes is not None:
         if len(__lowerCAmelCase			) != len(__lowerCAmelCase			):
          raise ValueError(
              '''Make sure that you pass in as many target sizes as the batch dimension of the logits'''			)

         if is_torch_tensor(__lowerCAmelCase			):
          lowercase__    :   Optional[Any]						= target_sizes.numpy()

         lowercase__    :   Dict						= []

         for idx in range(len(__lowerCAmelCase			)			):
          lowercase__    :   Optional[Any]						= torch.nn.functional.interpolate(
              logits[idx].unsqueeze(dim=0			)     ,       size=target_sizes[idx]     ,       mode='''bilinear'''     ,       align_corners=__lowerCAmelCase			)
          lowercase__    :   Optional[Any]						= resized_logits[0].argmax(dim=0			)
          semantic_segmentation.append(__lowerCAmelCase			)
        else:
         lowercase__    :   int						= logits.argmax(dim=1			)
         lowercase__    :   Optional[Any]						= [semantic_segmentation[i] for i in range(semantic_segmentation.shape[0]			)]

        return semantic_segmentation


'''simple docstring'''

import qiskit
def       __UpperCamelCase	(       UpperCAmelCase		,					UpperCAmelCase					):
 lowercase__    :   Dict						= qiskit.Aer.get_backend('''aer_simulator'''					)

 # Create a Quantum Circuit acting on the q register
 lowercase__    :   Any						= qiskit.QuantumCircuit(UpperCAmelCase		,					UpperCAmelCase					)

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

 # Execute the circuit on the simulator
 lowercase__    :   Any						= 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__":
  print(F'Total count for various states are: {single_qubit_measure(1, 1)}')

