






import warnings
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


lowercase  :							Dict			  =    logging.get_logger(__name__)




class 		UpperCAmelCase_						(	SCREAMING_SNAKE_CASE__					):


						'''simple docstring'''




						A     :   str						=					['input_values', 'attention_mask']






						def __init__(	self		,				_SCREAMING_SNAKE_CASE = 1		,				_SCREAMING_SNAKE_CASE = 1_6000		,				_SCREAMING_SNAKE_CASE = 0.0		,				_SCREAMING_SNAKE_CASE = False		,				_SCREAMING_SNAKE_CASE = 80		,				_SCREAMING_SNAKE_CASE = 16		,				_SCREAMING_SNAKE_CASE = 64		,				_SCREAMING_SNAKE_CASE = "hann_window"		,				_SCREAMING_SNAKE_CASE = 1.0		,				_SCREAMING_SNAKE_CASE = 80		,				_SCREAMING_SNAKE_CASE = 7600		,				_SCREAMING_SNAKE_CASE = 1e-10		,				_SCREAMING_SNAKE_CASE = 2		,				_SCREAMING_SNAKE_CASE = True		,				**_SCREAMING_SNAKE_CASE		,				) ->				Tuple:
								super().__init__(feature_size=_SCREAMING_SNAKE_CASE		,				sampling_rate=_SCREAMING_SNAKE_CASE		,				padding_value=_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE				)
								snake_case_				:							Union[str, Any]						 =       do_normalize
								snake_case_				:							Tuple						 =       return_attention_mask

								snake_case_				:							Union[str, Any]						 =       num_mel_bins
								snake_case_				:							Union[str, Any]						 =       hop_length
								snake_case_				:							Tuple						 =       win_length
								snake_case_				:							Any						 =       win_function
								snake_case_				:							str						 =       frame_signal_scale
								snake_case_				:							List[Any]						 =       fmin
								snake_case_				:							Optional[int]						 =       fmax
								snake_case_				:							Optional[int]						 =       mel_floor
								snake_case_				:							List[Any]						 =       reduction_factor

								snake_case_				:							Any						 =       win_length * sampling_rate // 1000
								snake_case_				:							Any						 =       hop_length * sampling_rate // 1000
								snake_case_				:							int						 =       optimal_fft_length(self.sample_size				)
								snake_case_				:							Optional[int]						 =       (self.n_fft // 2) + 1

								snake_case_				:							Union[str, Any]						 =       window_function(window_length=self.sample_size		,				name=self.win_function		,				periodic=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Optional[Any]						 =       mel_filter_bank(
								    num_frequency_bins=self.n_freqs		,				num_mel_filters=self.num_mel_bins		,				min_frequency=self.fmin		,				max_frequency=self.fmax		,				sampling_rate=self.sampling_rate		,				norm="slaney"		,				mel_scale="slaney"		,				)

								if frame_signal_scale != 1.0:
										warnings.warn(
										    "The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers"		,				_SCREAMING_SNAKE_CASE		,				)
								if reduction_factor != 2.0:
										warnings.warn(
										    "The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers"		,				_SCREAMING_SNAKE_CASE		,				)






						@staticmethod
						# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
						def       _lowerCAmelCase       (	_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE = 0.0				) ->				List[np.ndarray]:
								if attention_mask is not None:
										snake_case_				:							int						 =       np.array(_SCREAMING_SNAKE_CASE		,				np.intaa				)
										snake_case_				:							Tuple						 =       []

										for vector, length in zip(_SCREAMING_SNAKE_CASE		,				attention_mask.sum(-1				)				):
												snake_case_				:							Union[str, Any]						 =       (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7				)
												if length < normed_slice.shape[0]:
														snake_case_				:							int						 =       padding_value

												normed_input_values.append(_SCREAMING_SNAKE_CASE				)
								else:
										snake_case_				:							Any						 =       [(x - x.mean()) / np.sqrt(x.var() + 1e-7				) for x in input_values]

								return normed_input_values






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE		,				) ->				np.ndarray:
								snake_case_				:							Optional[Any]						 =       spectrogram(
								    _SCREAMING_SNAKE_CASE		,				window=self.window		,				frame_length=self.sample_size		,				hop_length=self.sample_stride		,				fft_length=self.n_fft		,				mel_filters=self.mel_filters		,				mel_floor=self.mel_floor		,				log_mel="log10"		,				)
								return log_mel_spec.T






						def __call__(	self		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = False		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = False		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				**_SCREAMING_SNAKE_CASE		,				) ->				BatchFeature:
								if audio is None and audio_target is None:
										raise ValueError("You must provide either `audio` or `audio_target` values."				)

								if sampling_rate is not None:
										if sampling_rate != self.sampling_rate:
												raise ValueError(
												    f'''The model corresponding to this feature extractor: {self} was trained using a sampling rate of'''
												    f''' {self.sampling_rate}. Please make sure that the provided audio input was sampled with'''
												    f''' {self.sampling_rate} and not {sampling_rate}.'''				)
								else:
										logger.warning(
										    "It is strongly recommended to pass the ``sampling_rate`` argument to this function. "
										    "Failing to do so can result in silent errors that might be hard to debug."				)

								if audio is not None:
										snake_case_				:							Any						 =       self._process_audio(
										    _SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE		,				)
								else:
										snake_case_				:							Union[str, Any]						 =       None

								if audio_target is not None:
										snake_case_				:							List[Any]						 =       self._process_audio(
										    _SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE		,				)

										if inputs is None:
												return inputs_target
										else:
												snake_case_				:							Any						 =       inputs_target["input_values"]
												snake_case_				:							str						 =       inputs_target.get("attention_mask"				)
												if decoder_attention_mask is not None:
														snake_case_				:							Tuple						 =       decoder_attention_mask

								return inputs






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE = False		,				_SCREAMING_SNAKE_CASE = False		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = False		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = None		,				**_SCREAMING_SNAKE_CASE		,				) ->				BatchFeature:
								snake_case_				:							Tuple						 =       isinstance(_SCREAMING_SNAKE_CASE		,				np.ndarray				) and len(speech.shape				) > 1
								if is_batched_numpy and len(speech.shape				) > 2:
										raise ValueError(f'''Only mono-channel audio is supported for input to {self}'''				)
								snake_case_				:							Union[str, Any]						 =       is_batched_numpy or (
								    isinstance(_SCREAMING_SNAKE_CASE		,				(list, tuple)				) and (isinstance(speech[0]		,				(np.ndarray, tuple, list)				))
								)

								if is_batched:
										snake_case_				:							str						 =       [np.asarray(_SCREAMING_SNAKE_CASE		,				dtype=np.floataa				) for speech in speech]
								elif not is_batched and not isinstance(_SCREAMING_SNAKE_CASE		,				np.ndarray				):
										snake_case_				:							List[str]						 =       np.asarray(_SCREAMING_SNAKE_CASE		,				dtype=np.floataa				)
								elif isinstance(_SCREAMING_SNAKE_CASE		,				np.ndarray				) and speech.dtype is np.dtype(np.floataa				):
										snake_case_				:							Union[str, Any]						 =       speech.astype(np.floataa				)

								# always return batch
								if not is_batched:
										snake_case_				:							Dict						 =       [speech]

								# needed to make pad() work on spectrogram inputs
								snake_case_				:							int						 =       self.feature_size

								# convert into correct format for padding
								if is_target:
										snake_case_				:							str						 =       [self._extract_mel_features(_SCREAMING_SNAKE_CASE				) for waveform in speech]
										snake_case_				:							Optional[Any]						 =       BatchFeature({"input_values": features}				)
										snake_case_				:							Dict						 =       self.num_mel_bins
								else:
										snake_case_				:							Dict						 =       BatchFeature({"input_values": speech}				)

								snake_case_				:							List[str]						 =       self.pad(
								    _SCREAMING_SNAKE_CASE		,				padding=_SCREAMING_SNAKE_CASE		,				max_length=_SCREAMING_SNAKE_CASE		,				truncation=_SCREAMING_SNAKE_CASE		,				pad_to_multiple_of=_SCREAMING_SNAKE_CASE		,				return_attention_mask=_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE		,				)

								snake_case_				:							Any						 =       feature_size_hack

								# convert input values to correct format
								snake_case_				:							int						 =       padded_inputs["input_values"]
								if not isinstance(input_values[0]		,				np.ndarray				):
										snake_case_				:							int						 =       [np.asarray(_SCREAMING_SNAKE_CASE		,				dtype=np.floataa				) for array in input_values]
								elif (
								    not isinstance(_SCREAMING_SNAKE_CASE		,				np.ndarray				)
								    and isinstance(input_values[0]		,				np.ndarray				)
								    and input_values[0].dtype is np.dtype(np.floataa				)
								):
										snake_case_				:							str						 =       [array.astype(np.floataa				) for array in input_values]
								elif isinstance(_SCREAMING_SNAKE_CASE		,				np.ndarray				) and input_values.dtype is np.dtype(np.floataa				):
										snake_case_				:							Dict						 =       input_values.astype(np.floataa				)

								# convert attention_mask to correct format
								snake_case_				:							List[Any]						 =       padded_inputs.get("attention_mask"				)
								if attention_mask is not None:
										snake_case_				:							Any						 =       [np.asarray(_SCREAMING_SNAKE_CASE		,				dtype=np.intaa				) for array in attention_mask]

								# zero-mean and unit-variance normalization
								if not is_target and self.do_normalize:
										snake_case_				:							List[Any]						 =       (
										    attention_mask
										    if self._get_padding_strategies(_SCREAMING_SNAKE_CASE		,				max_length=_SCREAMING_SNAKE_CASE				) is not PaddingStrategy.DO_NOT_PAD
										    else None
										)
										snake_case_				:							List[str]						 =       self.zero_mean_unit_var_norm(
										    padded_inputs["input_values"]		,				attention_mask=_SCREAMING_SNAKE_CASE		,				padding_value=self.padding_value				)

								if return_tensors is not None:
										snake_case_				:							str						 =       padded_inputs.convert_to_tensors(_SCREAMING_SNAKE_CASE				)

								return padded_inputs






						def       _lowerCAmelCase       (	self				) ->				Dict[str, Any]:
								snake_case_				:							Any						 =       super().to_dict()

								# Don't serialize these as they are derived from the other properties.
								snake_case_				:							Dict						 =       ["window", "mel_filters", "sample_size", "sample_stride", "n_fft", "n_freqs"]
								for name in names:
										if name in output:
												del output[name]

								return output








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}""")
