
from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						Namespace       ) ->       List[str]:

				"""simple docstring"""







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


_SCREAMING_SNAKE_CASE    :      List[str]          =			'\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__		(    SCREAMING_SNAKE_CASE_   ):







	'''simple docstring'''





	@staticmethod
	def   __snake_case				(			UpperCamelCase__		):
					A__  :	Dict         =							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=UpperCamelCase__				,       required=UpperCamelCase__				,       help='''Model\'s type.'''		)
					train_parser.add_argument(
					    '''--tf_checkpoint'''				,       type=UpperCamelCase__				,       required=UpperCamelCase__				,       help='''TensorFlow checkpoint path or folder.'''		)
					train_parser.add_argument(
					    '''--pytorch_dump_output'''				,       type=UpperCamelCase__				,       required=UpperCamelCase__				,       help='''Path to the PyTorch saved model output.'''		)
					train_parser.add_argument('''--config'''				,       type=UpperCamelCase__				,       default=''''''				,       help='''Configuration file path or folder.'''		)
					train_parser.add_argument(
					    '''--finetuning_task_name'''				,       type=UpperCamelCase__				,       default=UpperCamelCase__				,       help='''Optional fine-tuning task name if the TF model was a finetuned model.'''				,       )
					train_parser.set_defaults(func=UpperCamelCase__		)





	def __init__(			self				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       UpperCamelCase__				,       *UpperCamelCase__				,       ):
					A__  :	List[Any]         =							logging.get_logger('''transformers-cli/converting'''		)

					self._logger.info(F"Loading model {model_type}"		)
					A__  :	Tuple         =							model_type
					A__  :	List[str]         =							tf_checkpoint
					A__  :	List[Any]         =							pytorch_dump_output
					A__  :	Dict         =							config
					A__  :	Any         =							finetuning_task_name





	def   __snake_case				(			self		):
					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(UpperCamelCase__		)

									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(UpperCamelCase__		)

									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(UpperCamelCase__		)

									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(UpperCamelCase__		)

									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(UpperCamelCase__		)

									if "ckpt" in self._tf_checkpoint.lower():
													A__  :	Tuple         =							self._tf_checkpoint
													A__  :	Optional[Any]         =							''''''
									else:
													A__  :	List[str]         =							self._tf_checkpoint
													A__  :	Tuple         =							''''''
									convert_transfo_xl_checkpoint_to_pytorch(
									    UpperCamelCase__				,       self._config				,       self._pytorch_dump_output				,       UpperCamelCase__		)
					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(UpperCamelCase__		)

									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(UpperCamelCase__		)

									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]'''		)

def 				SCREAMING_SNAKE_CASE     (      ) ->       Optional[int]:

				"""simple docstring"""







				A__  :	Optional[Any]         =							0
				for i in range(1							,						10_01       ):
								total += i**i
				return str(__UpperCamelCase       )[-10:]


if __name__ == "__main__":
					print(solution())