






"""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 AutoImageProcessor, ViTImageProcessor
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_image_processing import CustomImageProcessor  # noqa E402


__SCREAMING_SNAKE_CASE   =   get_tests_dir('fixtures')




class 						__UpperCamelCase     (     unittest.TestCase						):
					def        UpperCAmelCase__ (							self							:	str   )	->       Union[str, Any]:
											# A mock response for an HTTP head request to emulate server down
											lowerCAmelCase   :Optional[int]						=			mock.Mock()
											lowerCAmelCase   :str						=			500
											lowerCAmelCase   :int						=			{}
											lowerCAmelCase   :Optional[Any]						=			HTTPError
											lowerCAmelCase   :int						=			{}

											# Download this model to make sure it's in the cache.
											lowerCAmelCase   :List[str]						=			ViTImageProcessor.from_pretrained('hf-internal-testing/tiny-random-vit'   )
											# Under the mock environment we get a 500 error when trying to reach the model.
											with mock.patch('requests.Session.request'     , return_value=UpperCAmelCase   ) as mock_head:
																	lowerCAmelCase   :Dict						=			ViTImageProcessor.from_pretrained('hf-internal-testing/tiny-random-vit'   )
																	# This check we did call the fake head request
																	mock_head.assert_called()
					def        UpperCAmelCase__ (							self							:	Tuple   )	->       Any:
											# This test is for deprecated behavior and can be removed in v5
											lowerCAmelCase   :List[str]						=			ViTImageProcessor.from_pretrained(
											    'https://huggingface.co/hf-internal-testing/tiny-random-vit/resolve/main/preprocessor_config.json'   )
					def        UpperCAmelCase__ (							self							:	str   )	->       Optional[int]:
											with self.assertRaises(UpperCAmelCase   ):
																	# config is in subfolder, the following should not work without specifying the subfolder
																	lowerCAmelCase   :Tuple						=			AutoImageProcessor.from_pretrained('hf-internal-testing/stable-diffusion-all-variants'   )

											lowerCAmelCase   :Union[str, Any]						=			AutoImageProcessor.from_pretrained(
											    'hf-internal-testing/stable-diffusion-all-variants'     , subfolder='feature_extractor'   )

											self.assertIsNotNone(UpperCAmelCase   )




@is_staging_test
class 						__UpperCamelCase     (     unittest.TestCase						):
					@classmethod
					def        UpperCAmelCase__ (							cls							:	List[str]   )	->       Union[str, Any]:
											lowerCAmelCase   :Optional[int]						=			TOKEN
											HfFolder.save_token(UpperCAmelCase   )
					@classmethod
					def        UpperCAmelCase__ (							cls							:	Dict   )	->       str:
											try:
																	delete_repo(token=cls._token     , repo_id='test-image-processor'   )
											except HTTPError:
																	pass

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

											try:
																	delete_repo(token=cls._token     , repo_id='test-dynamic-image-processor'   )
											except HTTPError:
																	pass
					def        UpperCAmelCase__ (							self							:	int   )	->       Optional[Any]:
											lowerCAmelCase   :str						=			ViTImageProcessor.from_pretrained(UpperCAmelCase   )
											image_processor.push_to_hub('test-image-processor'     , use_auth_token=self._token   )

											lowerCAmelCase   :Any						=			ViTImageProcessor.from_pretrained(f"""{USER}/test-image-processor"""   )
											for k, v in image_processor.__dict__.items():
																	self.assertEqual(UpperCAmelCase     , getattr(UpperCAmelCase     , UpperCAmelCase   )   )

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

											# Push to hub via save_pretrained
											with tempfile.TemporaryDirectory() as tmp_dir:
																	image_processor.save_pretrained(
																	    UpperCAmelCase     , repo_id='test-image-processor'     , push_to_hub=UpperCAmelCase     , use_auth_token=self._token   )

											lowerCAmelCase   :List[Any]						=			ViTImageProcessor.from_pretrained(f"""{USER}/test-image-processor"""   )
											for k, v in image_processor.__dict__.items():
																	self.assertEqual(UpperCAmelCase     , getattr(UpperCAmelCase     , UpperCAmelCase   )   )
					def        UpperCAmelCase__ (							self							:	Tuple   )	->       Optional[Any]:
											lowerCAmelCase   :List[str]						=			ViTImageProcessor.from_pretrained(UpperCAmelCase   )
											image_processor.push_to_hub('valid_org/test-image-processor'     , use_auth_token=self._token   )

											lowerCAmelCase   :Optional[int]						=			ViTImageProcessor.from_pretrained('valid_org/test-image-processor'   )
											for k, v in image_processor.__dict__.items():
																	self.assertEqual(UpperCAmelCase     , getattr(UpperCAmelCase     , UpperCAmelCase   )   )

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

											# Push to hub via save_pretrained
											with tempfile.TemporaryDirectory() as tmp_dir:
																	image_processor.save_pretrained(
																	    UpperCAmelCase     , repo_id='valid_org/test-image-processor-org'     , push_to_hub=UpperCAmelCase     , use_auth_token=self._token   )

											lowerCAmelCase   :List[str]						=			ViTImageProcessor.from_pretrained('valid_org/test-image-processor-org'   )
											for k, v in image_processor.__dict__.items():
																	self.assertEqual(UpperCAmelCase     , getattr(UpperCAmelCase     , UpperCAmelCase   )   )
					def        UpperCAmelCase__ (							self							:	Union[str, Any]   )	->       Union[str, Any]:
											CustomImageProcessor.register_for_auto_class()
											lowerCAmelCase   :Any						=			CustomImageProcessor.from_pretrained(UpperCAmelCase   )

											image_processor.push_to_hub('test-dynamic-image-processor'     , use_auth_token=self._token   )

											# This has added the proper auto_map field to the config
											self.assertDictEqual(
											    image_processor.auto_map     , {'AutoImageProcessor': 'custom_image_processing.CustomImageProcessor'}     , )

											lowerCAmelCase   :Optional[Any]						=			AutoImageProcessor.from_pretrained(
											    f"""{USER}/test-dynamic-image-processor"""     , trust_remote_code=UpperCAmelCase   )
											# Can't make an isinstance check because the new_image_processor is from the CustomImageProcessor class of a dynamic module
											self.assertEqual(new_image_processor.__class__.__name__     , 'CustomImageProcessor'   )







"""simple docstring"""


import qiskit


def        UpperCAmelCase      (					a__     ,      a__ ):





						'''simple docstring'''






						lowerCAmelCase   :List[Any]						=			qiskit.Aer.get_backend('aer_simulator' )

						# Create a Quantum Circuit acting on the q register
						lowerCAmelCase   :Optional[int]						=			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
						lowerCAmelCase   :Dict						=			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__":
		__SCREAMING_SNAKE_CASE   =   single_qubit_measure(2, 2)
		print(F"""Total count for various states are: {counts}""")