





import copy
import tempfile
import unittest

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

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


class 						lowerCamelCase       (unittest.TestCase      ):







							"""simple docstring"""




							@parameterized.expand([(None,), ("foo.json",)]						)
							def  A_     ( self     :					List[Any],			_UpperCAmelCase     :					Optional[int]						)				->			Union[str, Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						GenerationConfig(
														    do_sample=_UpperCAmelCase,			temperature=0.7,			length_penalty=1.0,			bad_words_ids=[[1, 2, 3], [4, 5]],			)
														with tempfile.TemporaryDirectory() as tmp_dir:
																					config.save_pretrained(_UpperCAmelCase,			config_name=_UpperCAmelCase						)
																					SCREAMING_SNAKE_CASE__       :      Any     =						GenerationConfig.from_pretrained(_UpperCAmelCase,			config_name=_UpperCAmelCase						)

														# Checks parameters that were specified
														self.assertEqual(loaded_config.do_sample,			_UpperCAmelCase						)
														self.assertEqual(loaded_config.temperature,			0.7						)
														self.assertEqual(loaded_config.length_penalty,			1.0						)
														self.assertEqual(loaded_config.bad_words_ids,			[[1, 2, 3], [4, 5]]						)

														# Checks parameters that were not specified (defaults)
														self.assertEqual(loaded_config.top_k,			5_0						)
														self.assertEqual(loaded_config.max_length,			2_0						)
														self.assertEqual(loaded_config.max_time,			_UpperCAmelCase						)






							def  A_     ( self     :					List[str]						)				->			str:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						AutoConfig.from_pretrained("gpt2"						)
														SCREAMING_SNAKE_CASE__       :      int     =						GenerationConfig.from_model_config(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						GenerationConfig()

														# The generation config has loaded a few non-default parameters from the model config
														self.assertNotEqual(_UpperCAmelCase,			_UpperCAmelCase						)

														# One of those parameters is eos_token_id -- check if it matches
														self.assertNotEqual(generation_config_from_model.eos_token_id,			default_generation_config.eos_token_id						)
														self.assertEqual(generation_config_from_model.eos_token_id,			model_config.eos_token_id						)






							def  A_     ( self     :					str						)				->			List[str]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						GenerationConfig()
														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						{
														    "max_new_tokens": 1_0_2_4,
														    "foo": "bar",
														}
														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						copy.deepcopy(_UpperCAmelCase						)
														SCREAMING_SNAKE_CASE__       :      Any     =						generation_config.update(**_UpperCAmelCase						)

														# update_kwargs was not modified (no side effects)
														self.assertEqual(_UpperCAmelCase,			_UpperCAmelCase						)

														# update_kwargs was used to update the config on valid attributes
														self.assertEqual(generation_config.max_new_tokens,			1_0_2_4						)

														# `.update()` returns a dictionary of unused kwargs
														self.assertEqual(_UpperCAmelCase,			{"foo": "bar"}						)






							def  A_     ( self     :					Tuple						)				->			Any:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      str     =						GenerationConfig()
														SCREAMING_SNAKE_CASE__       :      Any     =						"bar"

														with tempfile.TemporaryDirectory("test-generation-config"						) as tmp_dir:
																					generation_config.save_pretrained(_UpperCAmelCase						)

																					SCREAMING_SNAKE_CASE__       :      int     =						GenerationConfig.from_pretrained(_UpperCAmelCase						)
														# update_kwargs was used to update the config on valid attributes
														self.assertEqual(new_config.foo,			"bar"						)

														SCREAMING_SNAKE_CASE__       :      Any     =						GenerationConfig.from_model_config(_UpperCAmelCase						)
														assert not hasattr(_UpperCAmelCase,			"foo"						)  # no new kwargs should be initialized if from config






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





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      List[Any]     =						GenerationConfig()
														self.assertEqual(default_config.temperature,			1.0						)
														self.assertEqual(default_config.do_sample,			_UpperCAmelCase						)
														self.assertEqual(default_config.num_beams,			1						)

														SCREAMING_SNAKE_CASE__       :      int     =						GenerationConfig(
														    do_sample=_UpperCAmelCase,			temperature=0.7,			length_penalty=1.0,			bad_words_ids=[[1, 2, 3], [4, 5]],			)
														self.assertEqual(config.temperature,			0.7						)
														self.assertEqual(config.do_sample,			_UpperCAmelCase						)
														self.assertEqual(config.num_beams,			1						)

														with tempfile.TemporaryDirectory() as tmp_dir:
																					config.save_pretrained(_UpperCAmelCase						)
																					SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						GenerationConfig.from_pretrained(_UpperCAmelCase,			temperature=1.0						)

														self.assertEqual(loaded_config.temperature,			1.0						)
														self.assertEqual(loaded_config.do_sample,			_UpperCAmelCase						)
														self.assertEqual(loaded_config.num_beams,			1						)  # default value


@is_staging_test
class 						lowerCamelCase       (unittest.TestCase      ):







							"""simple docstring"""




							@classmethod
							def  A_     ( cls     :					Optional[int]						)				->			Tuple:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Dict     =						TOKEN
														HfFolder.save_token(_UpperCAmelCase						)






							@classmethod
							def  A_     ( cls     :					str						)				->			Any:





														"""simple docstring"""
														try:
																					delete_repo(token=cls._token,			repo_id="test-generation-config"						)
														except HTTPError:
																					pass

														try:
																					delete_repo(token=cls._token,			repo_id="valid_org/test-generation-config-org"						)
														except HTTPError:
																					pass






							def  A_     ( self     :					Tuple						)				->			List[Any]:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      Dict     =						GenerationConfig(
														    do_sample=_UpperCAmelCase,			temperature=0.7,			length_penalty=1.0,			)
														config.push_to_hub("test-generation-config",			use_auth_token=self._token						)

														SCREAMING_SNAKE_CASE__       :      List[str]     =						GenerationConfig.from_pretrained(F'''{USER}/test-generation-config'''						)
														for k, v in config.to_dict().items():
																					if k != "transformers_version":
																												self.assertEqual(_UpperCAmelCase,			getattr(_UpperCAmelCase,			_UpperCAmelCase						)						)

        # Reset repo
														delete_repo(token=self._token,			repo_id="test-generation-config"						)

														# Push to hub via save_pretrained
														with tempfile.TemporaryDirectory() as tmp_dir:
																					config.save_pretrained(
																					    _UpperCAmelCase,			repo_id="test-generation-config",			push_to_hub=_UpperCAmelCase,			use_auth_token=self._token						)

														SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						GenerationConfig.from_pretrained(F'''{USER}/test-generation-config'''						)
														for k, v in config.to_dict().items():
																					if k != "transformers_version":
																												self.assertEqual(_UpperCAmelCase,			getattr(_UpperCAmelCase,			_UpperCAmelCase						)						)






							def  A_     ( self     :					int						)				->			Dict:





														"""simple docstring"""
														SCREAMING_SNAKE_CASE__       :      int     =						GenerationConfig(
														    do_sample=_UpperCAmelCase,			temperature=0.7,			length_penalty=1.0,			)
														config.push_to_hub("valid_org/test-generation-config-org",			use_auth_token=self._token						)

														SCREAMING_SNAKE_CASE__       :      Optional[int]     =						GenerationConfig.from_pretrained("valid_org/test-generation-config-org"						)
														for k, v in config.to_dict().items():
																					if k != "transformers_version":
																												self.assertEqual(_UpperCAmelCase,			getattr(_UpperCAmelCase,			_UpperCAmelCase						)						)

        # Reset repo
														delete_repo(token=self._token,			repo_id="valid_org/test-generation-config-org"						)

														# Push to hub via save_pretrained
														with tempfile.TemporaryDirectory() as tmp_dir:
																					config.save_pretrained(
																					    _UpperCAmelCase,			repo_id="valid_org/test-generation-config-org",			push_to_hub=_UpperCAmelCase,			use_auth_token=self._token						)

														SCREAMING_SNAKE_CASE__       :      Optional[Any]     =						GenerationConfig.from_pretrained("valid_org/test-generation-config-org"						)
														for k, v in config.to_dict().items():
																					if k != "transformers_version":
																												self.assertEqual(_UpperCAmelCase,			getattr(_UpperCAmelCase,			_UpperCAmelCase						)						)













import qiskit




def _a (  SCREAMING_SNAKE_CASE__      :  int			,				SCREAMING_SNAKE_CASE__      :  int       )	->    qiskit.result.counts.Counts:

							'''simple docstring'''






							SCREAMING_SNAKE_CASE__       :      Union[str, Any]     =						qiskit.Aer.get_backend("aer_simulator"       )

							# Create a Quantum Circuit acting on the q register
							SCREAMING_SNAKE_CASE__       :      List[Any]     =						qiskit.QuantumCircuit(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__       )

							# 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
							SCREAMING_SNAKE_CASE__       :      int     =						qiskit.execute(SCREAMING_SNAKE_CASE__			,				SCREAMING_SNAKE_CASE__			,				shots=10_00       )

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


if __name__ == "__main__":
		_lowerCamelCase :    List[str]  							= single_qubit_measure(2, 2)
		print(f"Total count for various states are: {counts}")






