



from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand

def        a						(      _UpperCAmelCase							:					Namespace						):







		'''simple docstring'''





		return ConvertCommand(
		    args.model_type ,   args.tf_checkpoint ,   args.pytorch_dump_output ,   args.config ,   args.finetuning_task_name						)


__A   			="\ntransformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires\nTensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.\n"

class 		UpperCAmelCase__			(			__UpperCamelCase   ):




			'''simple docstring'''






			@staticmethod
			def  snake_case__     (   a_							: ArgumentParser ):
					'''simple docstring'''





					__UpperCAmelCase    :     str													=	parser.add_parser(
					    '''convert'''       ,       help='''CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints.'''       ,       )
					train_parser.add_argument('''--model_type'''       ,       type=a_       ,       required=a_       ,       help='''Model\'s type.''' )
					train_parser.add_argument(
					    '''--tf_checkpoint'''       ,       type=a_       ,       required=a_       ,       help='''TensorFlow checkpoint path or folder.''' )
					train_parser.add_argument(
					    '''--pytorch_dump_output'''       ,       type=a_       ,       required=a_       ,       help='''Path to the PyTorch saved model output.''' )
					train_parser.add_argument('''--config'''       ,       type=a_       ,       default=''''''       ,       help='''Configuration file path or folder.''' )
					train_parser.add_argument(
					    '''--finetuning_task_name'''       ,       type=a_       ,       default=a_       ,       help='''Optional fine-tuning task name if the TF model was a finetuned model.'''       ,       )
					train_parser.set_defaults(func=a_ )




			def __init__(   self							: Union[str, Any]       ,       a_							: str       ,       a_							: str       ,       a_							: str       ,       a_							: str       ,       a_							: str       ,       *a_							: Tuple       ,       ):
					'''simple docstring'''





					__UpperCAmelCase    :     Union[str, Any]													=	logging.get_logger('''transformers-cli/converting''' )

					self._logger.info(F'Loading model {model_type}' )
					__UpperCAmelCase    :     List[str]													=	model_type
					__UpperCAmelCase    :     Tuple													=	tf_checkpoint
					__UpperCAmelCase    :     Tuple													=	pytorch_dump_output
					__UpperCAmelCase    :     Optional[Any]													=	config
					__UpperCAmelCase    :     int													=	finetuning_task_name




			def  snake_case__     (   self							: List[Any] ):
					'''simple docstring'''





					if self._model_type == "albert":
							try:
									from ..models.albert.convert_albert_original_tf_checkpoint_to_pytorch import (
									    convert_tf_checkpoint_to_pytorch,
									)
							except ImportError:
									raise ImportError(a_ )

							convert_tf_checkpoint_to_pytorch(self._tf_checkpoint       ,       self._config       ,       self._pytorch_dump_output )
					elif self._model_type == "bert":
							try:
									from ..models.bert.convert_bert_original_tf_checkpoint_to_pytorch import (
									    convert_tf_checkpoint_to_pytorch,
									)
							except ImportError:
									raise ImportError(a_ )

							convert_tf_checkpoint_to_pytorch(self._tf_checkpoint       ,       self._config       ,       self._pytorch_dump_output )
					elif self._model_type == "funnel":
							try:
									from ..models.funnel.convert_funnel_original_tf_checkpoint_to_pytorch import (
									    convert_tf_checkpoint_to_pytorch,
									)
							except ImportError:
									raise ImportError(a_ )

							convert_tf_checkpoint_to_pytorch(self._tf_checkpoint       ,       self._config       ,       self._pytorch_dump_output )
					elif self._model_type == "t5":
							try:
									from ..models.ta.convert_ta_original_tf_checkpoint_to_pytorch import convert_tf_checkpoint_to_pytorch
							except ImportError:
									raise ImportError(a_ )

							convert_tf_checkpoint_to_pytorch(self._tf_checkpoint       ,       self._config       ,       self._pytorch_dump_output )
					elif self._model_type == "gpt":
							from ..models.openai.convert_openai_original_tf_checkpoint_to_pytorch import (
							    convert_openai_checkpoint_to_pytorch,
							)

							convert_openai_checkpoint_to_pytorch(self._tf_checkpoint       ,       self._config       ,       self._pytorch_dump_output )
					elif self._model_type == "transfo_xl":
							try:
									from ..models.transfo_xl.convert_transfo_xl_original_tf_checkpoint_to_pytorch import (
									    convert_transfo_xl_checkpoint_to_pytorch,
									)
							except ImportError:
									raise ImportError(a_ )

							if "ckpt" in self._tf_checkpoint.lower():
									__UpperCAmelCase    :     Any													=	self._tf_checkpoint
									__UpperCAmelCase    :     Dict													=	''''''
							else:
									__UpperCAmelCase    :     str													=	self._tf_checkpoint
									__UpperCAmelCase    :     Tuple													=	''''''
							convert_transfo_xl_checkpoint_to_pytorch(
							    a_       ,       self._config       ,       self._pytorch_dump_output       ,       a_ )
					elif self._model_type == "gpt2":
							try:
									from ..models.gpta.convert_gpta_original_tf_checkpoint_to_pytorch import (
									    convert_gpta_checkpoint_to_pytorch,
									)
							except ImportError:
									raise ImportError(a_ )

							convert_gpta_checkpoint_to_pytorch(self._tf_checkpoint       ,       self._config       ,       self._pytorch_dump_output )
					elif self._model_type == "xlnet":
							try:
									from ..models.xlnet.convert_xlnet_original_tf_checkpoint_to_pytorch import (
									    convert_xlnet_checkpoint_to_pytorch,
									)
							except ImportError:
									raise ImportError(a_ )

							convert_xlnet_checkpoint_to_pytorch(
							    self._tf_checkpoint       ,       self._config       ,       self._pytorch_dump_output       ,       self._finetuning_task_name )
					elif self._model_type == "xlm":
							from ..models.xlm.convert_xlm_original_pytorch_checkpoint_to_pytorch import (
							    convert_xlm_checkpoint_to_pytorch,
							)

							convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint       ,       self._pytorch_dump_output )
					elif self._model_type == "lxmert":
							from ..models.lxmert.convert_lxmert_original_tf_checkpoint_to_pytorch import (
							    convert_lxmert_checkpoint_to_pytorch,
							)

							convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint       ,       self._pytorch_dump_output )
					elif self._model_type == "rembert":
							from ..models.rembert.convert_rembert_tf_checkpoint_to_pytorch import (
							    convert_rembert_tf_checkpoint_to_pytorch,
							)

							convert_rembert_tf_checkpoint_to_pytorch(self._tf_checkpoint       ,       self._config       ,       self._pytorch_dump_output )
					else:
							raise ValueError(
							    '''--model_type should be selected in the list [bert, gpt, gpt2, t5, transfo_xl, xlnet, xlm, lxmert]''' )










import qiskit

def        a						(      _UpperCAmelCase							:					int ,   _UpperCAmelCase							:					int						):







		'''simple docstring'''





		__UpperCAmelCase    :     List[str]													=	qiskit.Aer.get_backend('''aer_simulator'''						)

		__UpperCAmelCase    :     Optional[Any]													=	qiskit.QuantumCircuit(4 ,   2						)
		# encode inputs in qubits 0 and 1
		if bita == 1:
				qc_ha.x(0						)
		if bita == 1:
				qc_ha.x(1						)
		qc_ha.barrier()

		# use cnots to write XOR of the inputs on qubit2
		qc_ha.cx(0 ,   2						)
		qc_ha.cx(1 ,   2						)

		# use ccx / toffoli gate to write AND of the inputs on qubit3
		qc_ha.ccx(0 ,   1 ,   3						)
		qc_ha.barrier()

		# extract outputs
		qc_ha.measure(2 ,   0						)  # extract XOR value
		qc_ha.measure(3 ,   1						)  # extract AND value

		# Execute the circuit on the qasm simulator
		__UpperCAmelCase    :     str													=	qiskit.execute(_UpperCAmelCase ,   _UpperCAmelCase ,   shots=10_00						)

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


if __name__ == "__main__":
				__A   			=half_adder(1, 1)
				print(f'''Half Adder Output Qubit Counts: {counts}''')





