






from typing import Dict, List, Optional, Union

import numpy as np

from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from .utils import PaddingStrategy, TensorType, is_tf_tensor, is_torch_tensor, logging, to_numpy


lowercase  :							Optional[int]			  =    logging.get_logger(__name__)




class 		UpperCAmelCase_						(	SCREAMING_SNAKE_CASE__					):


						'''simple docstring'''




						def __init__(	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE				) ->				Optional[Any]:
								snake_case_				:							int						 =       feature_size
								snake_case_				:							List[Any]						 =       sampling_rate
								snake_case_				:							Tuple						 =       padding_value

								snake_case_				:							List[str]						 =       kwargs.pop("padding_side"		,				"right"				)
								snake_case_				:							List[Any]						 =       kwargs.pop("return_attention_mask"		,				_SCREAMING_SNAKE_CASE				)

								super().__init__(**_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE = True		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = False		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				) ->				BatchFeature:
								# If we have a list of dicts, let's convert it in a dict of lists
								# We do this to allow using this method as a collate_fn function in PyTorch Dataloader
								if isinstance(_SCREAMING_SNAKE_CASE		,				(list, tuple)				) and isinstance(processed_features[0]		,				(dict, BatchFeature)				):
										snake_case_				:							Union[str, Any]						 =       {
										    key: [example[key] for example in processed_features] for key in processed_features[0].keys()
										}

								# The model's main input name, usually `input_values`, has be passed for padding
								if self.model_input_names[0] not in processed_features:
										raise ValueError(
										    "You should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature`"
										    f''' to this method that includes {self.model_input_names[0]}, but you provided'''
										    f''' {list(processed_features.keys()				)}'''				)

								snake_case_				:							Any						 =       processed_features[self.model_input_names[0]]
								snake_case_				:							Optional[int]						 =       (
								    return_attention_mask if return_attention_mask is not None else self.return_attention_mask
								)

								if len(_SCREAMING_SNAKE_CASE				) == 0:
										if return_attention_mask:
												snake_case_				:							int						 =       []
										return processed_features

								# If we have PyTorch/TF tensors or lists as inputs, we cast them as Numpy arrays
								# and rebuild them afterwards if no return_tensors is specified
								# Note that we lose the specific device the tensor may be on for PyTorch

								snake_case_				:							List[str]						 =       required_input[0]
								if isinstance(_SCREAMING_SNAKE_CASE		,				(list, tuple)				):
										# first_element might be an empty list/tuple in some edge cases so we grab the first non empty element.
										snake_case_				:							List[str]						 =       0
										while len(required_input[index]				) == 0:
												index += 1
										if index < len(_SCREAMING_SNAKE_CASE				):
												snake_case_				:							str						 =       required_input[index][0]

								if return_tensors is None:
										if is_tf_tensor(_SCREAMING_SNAKE_CASE				):
												snake_case_				:							int						 =       "tf"
										elif is_torch_tensor(_SCREAMING_SNAKE_CASE				):
												snake_case_				:							Dict						 =       "pt"
										elif isinstance(_SCREAMING_SNAKE_CASE		,				(int, float, list, tuple, np.ndarray)				):
												snake_case_				:							Optional[Any]						 =       "np"
										else:
												raise ValueError(
												    f'''type of {first_element} unknown: {type(_SCREAMING_SNAKE_CASE				)}. '''
												    "Should be one of a python, numpy, pytorch or tensorflow object."				)

								for key, value in processed_features.items():
										if isinstance(value[0]		,				(int, float)				):
												snake_case_				:							List[str]						 =       to_numpy(_SCREAMING_SNAKE_CASE				)
										else:
												snake_case_				:							Optional[Any]						 =       [to_numpy(_SCREAMING_SNAKE_CASE				) for v in value]

        # Convert padding_strategy in PaddingStrategy
								snake_case_				:							Dict						 =       self._get_padding_strategies(padding=_SCREAMING_SNAKE_CASE		,				max_length=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Dict						 =       processed_features[self.model_input_names[0]]

								snake_case_				:							Optional[int]						 =       len(_SCREAMING_SNAKE_CASE				)
								if not all(len(_SCREAMING_SNAKE_CASE				) == batch_size for v in processed_features.values()				):
										raise ValueError("Some items in the output dictionary have a different batch size than others."				)

								snake_case_				:							Optional[Any]						 =       []
								for i in range(_SCREAMING_SNAKE_CASE				):
										snake_case_				:							Tuple						 =       {k: v[i] for k, v in processed_features.items()}
										# truncation
										snake_case_				:							Optional[int]						 =       self._truncate(
										    _SCREAMING_SNAKE_CASE		,				max_length=_SCREAMING_SNAKE_CASE		,				pad_to_multiple_of=_SCREAMING_SNAKE_CASE		,				truncation=_SCREAMING_SNAKE_CASE		,				)
										truncated_inputs.append(_SCREAMING_SNAKE_CASE				)

								if padding_strategy == PaddingStrategy.LONGEST:
										# make sure that `max_length` cannot be longer than the longest truncated length
										snake_case_				:							Optional[Any]						 =       max(len(input_slice[self.model_input_names[0]]				) for input_slice in truncated_inputs				)
										snake_case_				:							str						 =       PaddingStrategy.MAX_LENGTH

								snake_case_				:							Union[str, Any]						 =       {}
								for i in range(_SCREAMING_SNAKE_CASE				):
										# padding
										snake_case_				:							Optional[Any]						 =       self._pad(
										    truncated_inputs[i]		,				max_length=_SCREAMING_SNAKE_CASE		,				padding_strategy=_SCREAMING_SNAKE_CASE		,				pad_to_multiple_of=_SCREAMING_SNAKE_CASE		,				return_attention_mask=_SCREAMING_SNAKE_CASE		,				)

										for key, value in outputs.items():
												if key not in batch_outputs:
														snake_case_				:							Tuple						 =       []
												if value.dtype is np.dtype(np.floataa				):
														snake_case_				:							Union[str, Any]						 =       value.astype(np.floataa				)
												batch_outputs[key].append(_SCREAMING_SNAKE_CASE				)

								return BatchFeature(_SCREAMING_SNAKE_CASE		,				tensor_type=_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = PaddingStrategy.DO_NOT_PAD		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				) ->				dict:
								snake_case_				:							int						 =       processed_features[self.model_input_names[0]]

								if padding_strategy == PaddingStrategy.LONGEST:
										snake_case_				:							str						 =       len(_SCREAMING_SNAKE_CASE				)

								if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
										snake_case_				:							Optional[Any]						 =       ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

								snake_case_				:							str						 =       padding_strategy != PaddingStrategy.DO_NOT_PAD and len(_SCREAMING_SNAKE_CASE				) < max_length

								if return_attention_mask and "attention_mask" not in processed_features:
										snake_case_				:							Tuple						 =       np.ones(len(_SCREAMING_SNAKE_CASE				)		,				dtype=np.intaa				)

								if needs_to_be_padded:
										snake_case_				:							Optional[Any]						 =       max_length - len(_SCREAMING_SNAKE_CASE				)
										if self.padding_side == "right":
												if return_attention_mask:
														snake_case_				:							int						 =       np.pad(
														    processed_features["attention_mask"]		,				(0, difference)				)
												snake_case_				:							Any						 =       ((0, difference), (0, 0)) if self.feature_size > 1 else (0, difference)
												snake_case_				:							Any						 =       np.pad(
												    _SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				"constant"		,				constant_values=self.padding_value				)
										elif self.padding_side == "left":
												if return_attention_mask:
														snake_case_				:							int						 =       np.pad(
														    processed_features["attention_mask"]		,				(difference, 0)				)
												snake_case_				:							int						 =       ((difference, 0), (0, 0)) if self.feature_size > 1 else (difference, 0)
												snake_case_				:							Tuple						 =       np.pad(
												    _SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				"constant"		,				constant_values=self.padding_value				)
										else:
												raise ValueError("Invalid padding strategy:" + str(self.padding_side				)				)

								return processed_features






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				) ->				List[str]:
								if not truncation:
										return processed_features
								elif truncation and max_length is None:
										raise ValueError("When setting ``truncation=True``, make sure that ``max_length`` is defined."				)

								snake_case_				:							List[str]						 =       processed_features[self.model_input_names[0]]

								# find `max_length` that fits `pad_to_multiple_of`
								if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
										snake_case_				:							int						 =       ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

								snake_case_				:							Any						 =       len(_SCREAMING_SNAKE_CASE				) > max_length

								if needs_to_be_truncated:
										snake_case_				:							Dict						 =       processed_features[self.model_input_names[0]][:max_length]
										if "attention_mask" in processed_features:
												snake_case_				:							Tuple						 =       processed_features["attention_mask"][:max_length]

								return processed_features






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE=False		,				_SCREAMING_SNAKE_CASE=None				) ->				List[str]:

								# Get padding strategy
								if padding is not False:
										if padding is True:
												snake_case_				:							Dict						 =       PaddingStrategy.LONGEST  # Default to pad to the longest sequence in the batch
										elif not isinstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				):
												snake_case_				:							Optional[Any]						 =       PaddingStrategy(_SCREAMING_SNAKE_CASE				)
										elif isinstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				):
												snake_case_				:							Optional[Any]						 =       padding
								else:
										snake_case_				:							Union[str, Any]						 =       PaddingStrategy.DO_NOT_PAD

								# Set max length if needed
								if max_length is None:
										if padding_strategy == PaddingStrategy.MAX_LENGTH:
												raise ValueError(
												    f'''When setting ``padding={PaddingStrategy.MAX_LENGTH}``, make sure that max_length is defined'''				)

        # Test if we have a padding value
								if padding_strategy != PaddingStrategy.DO_NOT_PAD and (self.padding_value is None):
										raise ValueError(
										    "Asking to pad but the feature_extractor does not have a padding value. Please select a value to use"
										    " as `padding_value`. For example: `feature_extractor.padding_value = 0.0`."				)

								return padding_strategy








import qiskit

def      lowerCAmelCase__	(    _a       :			int  ,      _a       :			int    ):
		snake_case_				:							Tuple						 =       qiskit.Aer.get_backend("aer_simulator"    )

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

		# Apply X (NOT) Gate to Qubits 0 & 1
		circuit.x(0    )
		circuit.x(1    )

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

		# Execute the circuit on the qasm simulator
		snake_case_				:							Any						 =       qiskit.execute(_a  ,      _a  ,      shots=10_00    )

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


if __name__ == "__main__":
							lowercase  :							List[Any]			  =    single_qubit_measure(2, 2)
							print(F"""Total count for various states are: {counts}""")
