


'''simple docstring'''







from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand





def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			Namespace   ) ->	Tuple:
						return ConvertCommand(
						    args.model_type,			args.tf_checkpoint,			args.pytorch_dump_output,			args.config,			args.finetuning_task_name   )


snake_case_     :       int						=  "\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 					__a      (_UpperCAmelCase     ):

							@staticmethod
							def     UpperCAmelCase__	(							__magic_name__							:     ArgumentParser   )					->       Any:







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

							def __init__(							self							:     List[Any]       ,     __magic_name__							:     str       ,     __magic_name__							:     str       ,     __magic_name__							:     str       ,     __magic_name__							:     str       ,     __magic_name__							:     str       ,     *__magic_name__							:     Dict       ,     )					->       Union[str, Any]:







													"""simple docstring"""
													UpperCAmelCase_			:      Optional[Any]     						=  logging.get_logger('''transformers-cli/converting'''   )

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



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

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

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

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

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

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

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

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












'''simple docstring'''







def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			int,			SCREAMING_SNAKE_CASE__      :			int   ) ->	int:
						return abs(SCREAMING_SNAKE_CASE__   ) if a == 0 else greatest_common_divisor(b % a,			SCREAMING_SNAKE_CASE__   )





def        lowerCamelCase_      (  SCREAMING_SNAKE_CASE__      :			int,			SCREAMING_SNAKE_CASE__      :			int   ) ->	int:
						while y:  # --> when y=0 then loop will terminate and return x as final GCD.
												UpperCAmelCase_						,       UpperCAmelCase_			:      Optional[Any]     						=  y, x % y
						return abs(SCREAMING_SNAKE_CASE__   )





def        lowerCamelCase_      (  ) ->	Optional[int]:
						try:
												UpperCAmelCase_			:      Optional[Any]     						=  input('''Enter two integers separated by comma (,): '''   ).split(''','''   )
												UpperCAmelCase_			:      Optional[int]     						=  int(nums[0]   )
												UpperCAmelCase_			:      List[Any]     						=  int(nums[1]   )
												print(
												    F"""greatest_common_divisor({num_a}, {num_a}) = """
												    F"""{greatest_common_divisor(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   )}"""   )
												print(F"""By iterative gcd({num_a}, {num_a}) = {gcd_by_iterative(SCREAMING_SNAKE_CASE__,			SCREAMING_SNAKE_CASE__   )}"""   )
						except (IndexError, UnboundLocalError, ValueError):
												print('''Wrong input'''   )


if __name__ == "__main__":
					main()





