"""simple docstring"""



from ...processing_utils import ProcessorMixin



class      _A	(						_UpperCAmelCase					):




    """simple docstring"""




    UpperCamelCase_	:					Dict							=					'''WhisperFeatureExtractor'''
    UpperCamelCase_	:					Tuple							=					'''WhisperTokenizer'''
    def __init__(		self							:     List[Any]	,      A_							:     int	,      A_							:     Dict    )    ->       Dict:
         super().__init__(A_	,      A_    )
         __snake_case				=							self.feature_extractor
         __snake_case				=							False
    def  lowercase					(		self							:     Any	,      A_							:     Union[str, Any]=None	,      A_							:     Optional[int]=None	,      A_							:     str=True    )    ->       Optional[Any]:
         return self.tokenizer.get_decoder_prompt_ids(task=A_	,      language=A_	,      no_timestamps=A_    )
    def __call__(		self							:     Optional[int]	,      *A_							:     List[Any]	,      **A_							:     List[str]    )    ->       int:
         # For backward compatibility
         if self._in_target_context_manager:
              return self.current_processor(*A_	,      **A_    )

         __snake_case				=							kwargs.pop('''audio'''	,      A_    )
         __snake_case				=							kwargs.pop('''sampling_rate'''	,      A_    )
         __snake_case				=							kwargs.pop('''text'''	,      A_    )
         if len(A_    ) > 0:
              __snake_case				=							args[0]
              __snake_case				=							args[1:]

         if audio is None and text is None:
              raise ValueError('''You need to specify either an `audio` or `text` input to process.'''    )

         if audio is not None:
              __snake_case				=							self.feature_extractor(A_	,      *A_	,      sampling_rate=A_	,      **A_    )
         if text is not None:
              __snake_case				=							self.tokenizer(A_	,      **A_    )

         if text is None:
              return inputs

         elif audio is None:
              return encodings
         else:
              __snake_case				=							encodings['''input_ids''']
              return inputs
    def  lowercase					(		self							:     str	,      *A_							:     List[str]	,      **A_							:     Any    )    ->       Any:
         return self.tokenizer.batch_decode(*A_	,      **A_    )
    def  lowercase					(		self							:     Tuple	,      *A_							:     str	,      **A_							:     Optional[int]    )    ->       List[Any]:
         return self.tokenizer.decode(*A_	,      **A_    )







    def  lowercase					(		self							:     Optional[int]	,      A_							:     str	,      A_							:     Union[str, Any]="np"    )    ->       Tuple:
         return self.tokenizer.get_prompt_ids(A_	,      return_tensors=A_    )
"""simple docstring"""



import qiskit





def    SCREAMING_SNAKE_CASE       (     snake_case,      snake_case):
     __snake_case				=							qiskit.Aer.get_backend('''aer_simulator''')

     # Create a Quantum Circuit acting on the q register
     __snake_case				=							qiskit.QuantumCircuit(snake_case,      snake_case)

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

     # Execute the circuit on the simulator
     __snake_case				=							qiskit.execute(snake_case,      snake_case,      shots=10_00)

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


if __name__ == "__main__":
       print(F"""Total count for various states are: {single_qubit_measure(1, 1)}""")