






'''simple docstring'''





import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute
def        UpperCAmelCase      (   _lowercase = np.pi / 2,      _lowercase = np.pi / 2,      _lowercase = np.pi / 2      ):


    '''simple docstring'''



    _lowercase     =	QuantumRegister(3,      'qr'      )  # Define the number of quantum bits
    _lowercase     =	ClassicalRegister(1,      'cr'      )  # Define the number of classical bits

    _lowercase     =	QuantumCircuit(_lowercase,      _lowercase      )  # Define the quantum circuit.

    # Build the circuit
    quantum_circuit.u(_lowercase,      _lowercase,      _lowercase,      0      )  # Quantum State to teleport
    quantum_circuit.h(1      )  # add hadamard gate
    quantum_circuit.cx(
        1,      2      )  # add control gate with qubit 1 as control and 2 as target.
    quantum_circuit.cx(0,      1      )
    quantum_circuit.h(0      )
    quantum_circuit.cz(0,      2      )  # add control z gate.
    quantum_circuit.cx(1,      2      )

    quantum_circuit.measure([2],      [0]      )  # measure the qubit.

    # Simulate the circuit using qasm simulator
    _lowercase     =	Aer.get_backend('aer_simulator'      )
    _lowercase     =	execute(_lowercase,      _lowercase,      shots=1000      )

    return job.result().get_counts(_lowercase      )


if __name__ == "__main__":
   print(
       '''Total count for teleported state is: '''
       f"{quantum_teleportation(np.pi/2, np.pi/2, np.pi/2)}"
   )








import json
import os
import shutil
import tempfile
import unittest

from transformers import is_speech_available, is_torch_available
from transformers.models.speechta import SpeechTaTokenizer
from transformers.testing_utils import get_tests_dir, require_torch
from transformers.utils import FEATURE_EXTRACTOR_NAME


if is_speech_available() and is_torch_available():
   from transformers import SpeechTaFeatureExtractor, SpeechTaProcessor

   from .test_feature_extraction_speechta import floats_list


lowerCamelCase										=  get_tests_dir('''fixtures/test_sentencepiece_bpe_char.model''')

@require_torch
class 					snake_case_							(       unittest.TestCase      ):







   """simple docstring"""



   def 			SCREAMING_SNAKE_CASE__				(    self:	List[str]	)  ->		Union[str, Any]:


       """simple docstring"""



       _lowercase     =	tempfile.mkdtemp()

       _lowercase     =	SpeechTaTokenizer(snake_case__	)
       tokenizer.save_pretrained(self.tmpdirname	)

       _lowercase     =	{
           'feature_size': 1,
           'padding_value': 0.0,
           'sampling_rate': 16_000,
           'do_normalize': False,
           'num_mel_bins': 80,
           'hop_length': 16,
           'win_length': 64,
           'win_function': 'hann_window',
           'fmin': 80,
           'fmax': 7_600,
           'mel_floor': 1E-10,
           'reduction_factor': 2,
           'return_attention_mask': True,
       }

       _lowercase     =	os.path.join(self.tmpdirname   ,       snake_case__	)
       with open(self.feature_extraction_file   ,       'w'   ,       encoding='utf-8'	) as fp:
           fp.write(json.dumps(snake_case__	) + '\n'	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Union[str, Any]   ,       **snake_case__:	Union[str, Any]	)  ->		Union[str, Any]:


       """simple docstring"""



       return SpeechTaTokenizer.from_pretrained(self.tmpdirname   ,       **snake_case__	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]   ,       **snake_case__:	str	)  ->		int:


       """simple docstring"""



       return SpeechTaFeatureExtractor.from_pretrained(self.tmpdirname   ,       **snake_case__	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		Optional[int]:


       """simple docstring"""



       shutil.rmtree(self.tmpdirname	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	int	)  ->		List[str]:


       """simple docstring"""



       _lowercase     =	self.get_tokenizer()
       _lowercase     =	self.get_feature_extractor()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       processor.save_pretrained(self.tmpdirname	)
       _lowercase     =	SpeechTaProcessor.from_pretrained(self.tmpdirname	)

       self.assertEqual(processor.tokenizer.get_vocab()   ,       tokenizer.get_vocab()	)
       self.assertIsInstance(processor.tokenizer   ,       snake_case__	)

       self.assertEqual(processor.feature_extractor.to_json_string()   ,       feature_extractor.to_json_string()	)
       self.assertIsInstance(processor.feature_extractor   ,       snake_case__	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	int	)  ->		Any:


       """simple docstring"""



       _lowercase     =	SpeechTaProcessor(tokenizer=self.get_tokenizer()   ,       feature_extractor=self.get_feature_extractor()	)
       processor.save_pretrained(self.tmpdirname	)

       _lowercase     =	self.get_tokenizer(bos_token='(BOS)'   ,       eos_token='(EOS)'	)
       _lowercase     =	self.get_feature_extractor(do_normalize=snake_case__   ,       padding_value=1.0	)

       _lowercase     =	SpeechTaProcessor.from_pretrained(
           self.tmpdirname   ,       bos_token='(BOS)'   ,       eos_token='(EOS)'   ,       do_normalize=snake_case__   ,       padding_value=1.0	)

       self.assertEqual(processor.tokenizer.get_vocab()   ,       tokenizer_add_kwargs.get_vocab()	)
       self.assertIsInstance(processor.tokenizer   ,       snake_case__	)

       self.assertEqual(processor.feature_extractor.to_json_string()   ,       feature_extractor_add_kwargs.to_json_string()	)
       self.assertIsInstance(processor.feature_extractor   ,       snake_case__	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Union[str, Any]	)  ->		int:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       _lowercase     =	floats_list((3, 1_000)	)

       _lowercase     =	feature_extractor(audio=snake_case__   ,       return_tensors='np'	)
       _lowercase     =	processor(audio=snake_case__   ,       return_tensors='np'	)

       for key in input_feat_extract.keys():
           self.assertAlmostEqual(input_feat_extract[key].sum()   ,       input_processor[key].sum()   ,       delta=1E-2	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Tuple	)  ->		List[str]:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       _lowercase     =	floats_list((3, 1_000)	)

       _lowercase     =	feature_extractor(audio_target=snake_case__   ,       return_tensors='np'	)
       _lowercase     =	processor(audio_target=snake_case__   ,       return_tensors='np'	)

       for key in input_feat_extract.keys():
           self.assertAlmostEqual(input_feat_extract[key].sum()   ,       input_processor[key].sum()   ,       delta=1E-2	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		Dict:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       _lowercase     =	'This is a test string'

       _lowercase     =	processor(text=snake_case__	)
       _lowercase     =	tokenizer(snake_case__	)

       for key in encoded_tok.keys():
           self.assertListEqual(encoded_tok[key]   ,       encoded_processor[key]	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[int]	)  ->		int:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       _lowercase     =	'This is a test string'

       _lowercase     =	processor(text_target=snake_case__	)
       _lowercase     =	tokenizer(snake_case__	)

       for key in encoded_tok.keys():
           self.assertListEqual(encoded_tok[key]   ,       encoded_processor[key]	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Dict	)  ->		int:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       _lowercase     =	[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

       _lowercase     =	processor.batch_decode(snake_case__	)
       _lowercase     =	tokenizer.batch_decode(snake_case__	)

       self.assertListEqual(snake_case__   ,       snake_case__	)

   def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		List[Any]:


       """simple docstring"""



       _lowercase     =	self.get_feature_extractor()
       _lowercase     =	self.get_tokenizer()

       _lowercase     =	SpeechTaProcessor(tokenizer=snake_case__   ,       feature_extractor=snake_case__	)

       self.assertListEqual(
           processor.model_input_names   ,       feature_extractor.model_input_names   ,       msg='`processor` and `feature_extractor` model input names do not match'   ,       )
