






from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand

def      lowerCAmelCase__	(    _a       :			Namespace    ):
		return ConvertCommand(
		    args.model_type  ,      args.tf_checkpoint  ,      args.pytorch_dump_output  ,      args.config  ,      args.finetuning_task_name    )


lowercase  :							Dict			  =    '''
transformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires
TensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.
'''




class 		UpperCAmelCase_						(	SCREAMING_SNAKE_CASE__					):


						'''simple docstring'''




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






						def __init__(	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE		,				*_SCREAMING_SNAKE_CASE		,				) ->				Optional[int]:
								snake_case_				:							Any						 =       logging.get_logger("transformers-cli/converting"				)

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






						def       _lowerCAmelCase       (	self				) ->				List[str]:
								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(_SCREAMING_SNAKE_CASE				)

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

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

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

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

										if "ckpt" in self._tf_checkpoint.lower():
												snake_case_				:							str						 =       self._tf_checkpoint
												snake_case_				:							Tuple						 =       ""
										else:
												snake_case_				:							str						 =       self._tf_checkpoint
												snake_case_				:							int						 =       ""
										convert_transfo_xl_checkpoint_to_pytorch(
										    _SCREAMING_SNAKE_CASE		,				self._config		,				self._pytorch_dump_output		,				_SCREAMING_SNAKE_CASE				)
								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(_SCREAMING_SNAKE_CASE				)

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

										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      lowerCAmelCase__	(    _a       :			int    ):
		snake_case_				:							str						 =       1
		for i in range(1  ,      num + 1    ):
				fact *= i
		return fact

def      lowerCAmelCase__	(    _a       :			int    ):
		snake_case_				:							List[str]						 =       0
		while number > 0:
				snake_case_				:							Dict						 =       number % 10
				sum_of_digits += last_digit
				snake_case_				:							List[Any]						 =       number // 10  # Removing the last_digit from the given number
		return sum_of_digits

def      lowerCAmelCase__	(    _a       :			int = 1_00    ):
		snake_case_				:							Optional[Any]						 =       factorial(_a    )
		snake_case_				:							Optional[int]						 =       split_and_add(_a    )
		return result


if __name__ == "__main__":
							print(solution(int(input('''Enter the Number: ''').strip())))
