





'''simple docstring'''




import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoFeatureExtractor, WavaVecaFeatureExtractor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / """utils"""))

from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


_A:					Any							=				get_tests_dir("""fixtures""")






class UpperCAmelCase							(		unittest.TestCase							):



    def 					__lowerCamelCase						(  self					):
     # A mock response for an HTTP head request to emulate server down
     __UpperCAmelCase					=   mock.Mock()
     __UpperCAmelCase					=   500
     __UpperCAmelCase					=   {}
     __UpperCAmelCase					=   HTTPError
     __UpperCAmelCase					=   {}

     # Download this model to make sure it's in the cache.
     __UpperCAmelCase					=   WavaVecaFeatureExtractor.from_pretrained('hf-internal-testing/tiny-random-wav2vec2'					)
     # Under the mock environment we get a 500 error when trying to reach the model.
     with mock.patch('requests.Session.request'     ,			return_value=__A					) as mock_head:
      __UpperCAmelCase					=   WavaVecaFeatureExtractor.from_pretrained('hf-internal-testing/tiny-random-wav2vec2'					)
      # This check we did call the fake head request
      mock_head.assert_called()




    def 					__lowerCamelCase						(  self					):
     # This test is for deprecated behavior and can be removed in v5
     __UpperCAmelCase					=   WavaVecaFeatureExtractor.from_pretrained(
         'https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json'					)






@is_staging_test
class UpperCAmelCase							(		unittest.TestCase							):



    @classmethod
    def 					__lowerCamelCase						(  cls					):
     __UpperCAmelCase					=   TOKEN
     HfFolder.save_token(__A					)



    @classmethod
    def 					__lowerCamelCase						(  cls					):
     try:
      delete_repo(token=cls._token     ,			repo_id='test-feature-extractor'					)
     except HTTPError:
      pass

     try:
      delete_repo(token=cls._token     ,			repo_id='valid_org/test-feature-extractor-org'					)
     except HTTPError:
      pass

     try:
      delete_repo(token=cls._token     ,			repo_id='test-dynamic-feature-extractor'					)
     except HTTPError:
      pass



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   WavaVecaFeatureExtractor.from_pretrained(__A					)
     feature_extractor.push_to_hub('test-feature-extractor'     ,			use_auth_token=self._token					)

     __UpperCAmelCase					=   WavaVecaFeatureExtractor.from_pretrained(f'{USER}/test-feature-extractor'					)
     for k, v in feature_extractor.__dict__.items():
      self.assertEqual(__A     ,			getattr(__A     ,			__A					)					)

     # Reset repo
     delete_repo(token=self._token     ,			repo_id='test-feature-extractor'					)

     # Push to hub via save_pretrained
     with tempfile.TemporaryDirectory() as tmp_dir:
      feature_extractor.save_pretrained(
          __A     ,			repo_id='test-feature-extractor'     ,			push_to_hub=__A     ,			use_auth_token=self._token					)

     __UpperCAmelCase					=   WavaVecaFeatureExtractor.from_pretrained(f'{USER}/test-feature-extractor'					)
     for k, v in feature_extractor.__dict__.items():
      self.assertEqual(__A     ,			getattr(__A     ,			__A					)					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   WavaVecaFeatureExtractor.from_pretrained(__A					)
     feature_extractor.push_to_hub('valid_org/test-feature-extractor'     ,			use_auth_token=self._token					)

     __UpperCAmelCase					=   WavaVecaFeatureExtractor.from_pretrained('valid_org/test-feature-extractor'					)
     for k, v in feature_extractor.__dict__.items():
      self.assertEqual(__A     ,			getattr(__A     ,			__A					)					)

     # Reset repo
     delete_repo(token=self._token     ,			repo_id='valid_org/test-feature-extractor'					)

     # Push to hub via save_pretrained
     with tempfile.TemporaryDirectory() as tmp_dir:
      feature_extractor.save_pretrained(
          __A     ,			repo_id='valid_org/test-feature-extractor-org'     ,			push_to_hub=__A     ,			use_auth_token=self._token					)

     __UpperCAmelCase					=   WavaVecaFeatureExtractor.from_pretrained('valid_org/test-feature-extractor-org'					)
     for k, v in feature_extractor.__dict__.items():
      self.assertEqual(__A     ,			getattr(__A     ,			__A					)					)




    def 					__lowerCamelCase						(  self					):
     CustomFeatureExtractor.register_for_auto_class()
     __UpperCAmelCase					=   CustomFeatureExtractor.from_pretrained(__A					)

     feature_extractor.push_to_hub('test-dynamic-feature-extractor'     ,			use_auth_token=self._token					)

     # This has added the proper auto_map field to the config
     self.assertDictEqual(
         feature_extractor.auto_map     ,			{'AutoFeatureExtractor': 'custom_feature_extraction.CustomFeatureExtractor'}     ,			)

     __UpperCAmelCase					=   AutoFeatureExtractor.from_pretrained(
         f'{USER}/test-dynamic-feature-extractor'     ,			trust_remote_code=__A					)
     # Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module
     self.assertEqual(new_feature_extractor.__class__.__name__     ,			'CustomFeatureExtractor'					)












'''simple docstring'''




import math

import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute







def _lowerCAmelCase     (      _lowerCAmelCase = 3    )->     qiskit.result.counts.Counts:
 if isinstance(_lowerCAmelCase       ,    _lowerCAmelCase    ):
  raise TypeError('number of qubits must be a integer.'    )
 if number_of_qubits <= 0:
  raise ValueError('number of qubits must be > 0.'    )
 if math.floor(_lowerCAmelCase    ) != number_of_qubits:
  raise ValueError('number of qubits must be exact integer.'    )
 if number_of_qubits > 10:
  raise ValueError('number of qubits too large to simulate(>10).'    )

 __UpperCAmelCase					=   QuantumRegister(_lowerCAmelCase       ,    'qr'    )
 __UpperCAmelCase					=   ClassicalRegister(_lowerCAmelCase       ,    'cr'    )

 __UpperCAmelCase					=   QuantumCircuit(_lowerCAmelCase       ,    _lowerCAmelCase    )

 __UpperCAmelCase					=   number_of_qubits

 for i in range(_lowerCAmelCase    ):
  quantum_circuit.h(number_of_qubits - i - 1    )
  counter -= 1
  for j in range(_lowerCAmelCase    ):
   quantum_circuit.cp(np.pi / 2 ** (counter - j)       ,    _lowerCAmelCase       ,    _lowerCAmelCase    )

 for k in range(number_of_qubits // 2    ):
  quantum_circuit.swap(_lowerCAmelCase       ,    number_of_qubits - k - 1    )

 # measure all the qubits
 quantum_circuit.measure(_lowerCAmelCase       ,    _lowerCAmelCase    )
 # simulate with 10000 shots
 __UpperCAmelCase					=   Aer.get_backend('qasm_simulator'    )
 __UpperCAmelCase					=   execute(_lowerCAmelCase       ,    _lowerCAmelCase       ,    shots=1_00_00    )

 return job.result().get_counts(_lowerCAmelCase    )


if __name__ == "__main__":
    print(
        F"""Total count for quantum fourier transform state is: \
    {quantum_fourier_transform(3)}"""
    )





