import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs




class    _UpperCamelCase      (						_UpperCAmelCase ):


			"""simple docstring"""






			def __init__(   self      ,   lowerCAmelCase__      ,   lowerCAmelCase__=None      ,   lowerCAmelCase__=True      ,   lowerCAmelCase__=None      ,   **lowerCAmelCase__						)     ->					Any:

							'''simple docstring'''


							__lowercase 			=							parent
							__lowercase 			=							config_class
							__lowercase 			=							has_text_modality
							__lowercase 			=							kwargs
							__lowercase 			=							common_properties





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Any:

							'''simple docstring'''


							__lowercase 			=							self.config_class(**self.inputs_dict						)
							__lowercase 			=							(
							    ['''hidden_size''', '''num_attention_heads''', '''num_hidden_layers''']
							    if self.common_properties is None
							    else self.common_properties
							)

							# Add common fields for text models
							if self.has_text_modality:
											common_properties.extend(['''vocab_size''']						)

							# Test that config has the common properties as getters
							for prop in common_properties:
											self.parent.assertTrue(hasattr(lowerCAmelCase__      ,   lowerCAmelCase__						)      ,   msg=F"`{prop}` does not exist"						)

							# Test that config has the common properties as setter
							for idx, name in enumerate(lowerCAmelCase__						):
											try:
															setattr(lowerCAmelCase__      ,   lowerCAmelCase__      ,   lowerCAmelCase__						)
															self.parent.assertEqual(
															    getattr(lowerCAmelCase__      ,   lowerCAmelCase__						)      ,   lowerCAmelCase__      ,   msg=F"`{name} value {idx} expected, but was {getattr(lowerCAmelCase__      ,   lowerCAmelCase__						)}"						)
											except NotImplementedError:
															# Some models might not be able to implement setters for common_properties
															# In that case, a NotImplementedError is raised
															pass

        # Test if config class can be called with Config(prop_name=..)
							for idx, name in enumerate(lowerCAmelCase__						):
											try:
															__lowercase 			=							self.config_class(**{name: idx}						)
															self.parent.assertEqual(
															    getattr(lowerCAmelCase__      ,   lowerCAmelCase__						)      ,   lowerCAmelCase__      ,   msg=F"`{name} value {idx} expected, but was {getattr(lowerCAmelCase__      ,   lowerCAmelCase__						)}"						)
											except NotImplementedError:
															# Some models might not be able to implement setters for common_properties
															# In that case, a NotImplementedError is raised
															pass





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Dict:

							'''simple docstring'''


							__lowercase 			=							self.config_class(**self.inputs_dict						)
							__lowercase 			=							json.loads(config.to_json_string()						)
							for key, value in self.inputs_dict.items():
											self.parent.assertEqual(obj[key]      ,   lowerCAmelCase__						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					str:

							'''simple docstring'''


							__lowercase 			=							self.config_class(**self.inputs_dict						)

							with tempfile.TemporaryDirectory() as tmpdirname:
											__lowercase 			=							os.path.join(lowerCAmelCase__      ,   '''config.json'''						)
											config_first.to_json_file(lowerCAmelCase__						)
											__lowercase 			=							self.config_class.from_json_file(lowerCAmelCase__						)

							self.parent.assertEqual(config_second.to_dict()      ,   config_first.to_dict()						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Optional[Any]:

							'''simple docstring'''


							__lowercase 			=							self.config_class(**self.inputs_dict						)

							with tempfile.TemporaryDirectory() as tmpdirname:
											config_first.save_pretrained(lowerCAmelCase__						)
											__lowercase 			=							self.config_class.from_pretrained(lowerCAmelCase__						)

							self.parent.assertEqual(config_second.to_dict()      ,   config_first.to_dict()						)





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

							'''simple docstring'''


							__lowercase 			=							self.config_class(**self.inputs_dict						)

							__lowercase 			=							'''test'''
							with tempfile.TemporaryDirectory() as tmpdirname:
											__lowercase 			=							os.path.join(lowerCAmelCase__      ,   lowerCAmelCase__						)
											config_first.save_pretrained(lowerCAmelCase__						)
											__lowercase 			=							self.config_class.from_pretrained(lowerCAmelCase__      ,   subfolder=lowerCAmelCase__						)

							self.parent.assertEqual(config_second.to_dict()      ,   config_first.to_dict()						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					int:

							'''simple docstring'''


							__lowercase 			=							self.config_class(**self.inputs_dict      ,   num_labels=5						)
							self.parent.assertEqual(len(config.idalabel						)      ,   5						)
							self.parent.assertEqual(len(config.labelaid						)      ,   5						)

							__lowercase 			=							3
							self.parent.assertEqual(len(config.idalabel						)      ,   3						)
							self.parent.assertEqual(len(config.labelaid						)      ,   3						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Any:

							'''simple docstring'''


							if self.config_class.is_composition:
											return
							__lowercase 			=							self.config_class()
							self.parent.assertIsNotNone(lowerCAmelCase__						)





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

							'''simple docstring'''


							__lowercase 			=							copy.deepcopy(lowerCAmelCase__						)
							__lowercase 			=							self.config_class(**lowerCAmelCase__						)
							__lowercase 			=							[]
							for key, value in config_common_kwargs.items():
											if key == "torch_dtype":
															if not is_torch_available():
																			continue
															else:
																			import torch

																			if config.torch_dtype != torch.floataa:
																							wrong_values.append(('''torch_dtype''', config.torch_dtype, torch.floataa)						)
											elif getattr(lowerCAmelCase__      ,   lowerCAmelCase__						) != value:
															wrong_values.append((key, getattr(lowerCAmelCase__      ,   lowerCAmelCase__						), value)						)

							if len(lowerCAmelCase__						) > 0:
											__lowercase 			=							'''\n'''.join([F"- {v[0]}: got {v[1]} instead of {v[2]}" for v in wrong_values]						)
											raise ValueError(F"The following keys were not properly set in the config:\n{errors}"						)





			def        _SCREAMING_SNAKE_CASE			(   self						)     ->					Optional[Any]:

							'''simple docstring'''


							self.create_and_test_config_common_properties()
							self.create_and_test_config_to_json_string()
							self.create_and_test_config_to_json_file()
							self.create_and_test_config_from_and_save_pretrained()
							self.create_and_test_config_from_and_save_pretrained_subfolder()
							self.create_and_test_config_with_num_labels()
							self.check_config_can_be_init_without_params()
							self.check_config_arguments_init()
import qiskit





def 				UpperCAmelCase						(    lowercase							,			lowercase							):







				"""simple docstring"""



				__lowercase 			=							qiskit.Aer.get_backend('''aer_simulator'''							)

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

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

				# Execute the circuit on the simulator
				__lowercase 			=							qiskit.execute(lowercase							,			lowercase							,			shots=1000							)

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


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