
'''simple docstring'''





from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand







def snake_case_     (					lowercase__		):
  return ConvertCommand(
      args.model_type   ,       args.tf_checkpoint   ,       args.pytorch_dump_output   ,       args.config   ,       args.finetuning_task_name		)


SCREAMING_SNAKE_CASE     =       """
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_							(    A				):

 '''simple docstring'''







 @staticmethod
 def 							UpperCamelCase  (					snake_case__		:  ArgumentParser ):



   '''simple docstring'''




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







 def __init__(					self		:  List[str]			,				snake_case__		:  str			,				snake_case__		:  str			,				snake_case__		:  str			,				snake_case__		:  str			,				snake_case__		:  str			,				*snake_case__		:  Union[str, Any]			,				):



   '''simple docstring'''




   UpperCAmelCase__      :					str				       =							logging.get_logger("transformers-cli/converting" )

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







 def 							UpperCamelCase  (					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(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(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(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(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(snake_case__ )

     if "ckpt" in self._tf_checkpoint.lower():
       UpperCAmelCase__      :					Any				       =							self._tf_checkpoint
       UpperCAmelCase__      :					Union[str, Any]				       =							""
     else:
       UpperCAmelCase__      :					Tuple				       =							self._tf_checkpoint
       UpperCAmelCase__      :					Tuple				       =							""
     convert_transfo_xl_checkpoint_to_pytorch(
         snake_case__			,				self._config			,				self._pytorch_dump_output			,				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(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(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]" )





'''simple docstring'''





from ..utils import DummyObject, requires_backends






class 							UpperCAmelCase_							(    metaclass=A				):

 '''simple docstring'''
 lowercase_					:    Optional[int]				=							["torch", "transformers", "onnx"]







 def __init__(					self		:  Tuple			,				*snake_case__		:  str			,				**snake_case__		:  List[str] ):



   '''simple docstring'''




   requires_backends(self			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  Optional[int]			,				*snake_case__		:  Any			,				**snake_case__		:  List[Any] ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  List[str]			,				*snake_case__		:  Any			,				**snake_case__		:  Tuple ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )






class 							UpperCAmelCase_							(    metaclass=A				):

 '''simple docstring'''
 lowercase_					:    Tuple				=							["torch", "transformers", "onnx"]







 def __init__(					self		:  List[str]			,				*snake_case__		:  List[Any]			,				**snake_case__		:  Any ):



   '''simple docstring'''




   requires_backends(self			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  Dict			,				*snake_case__		:  Any			,				**snake_case__		:  Optional[int] ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  int			,				*snake_case__		:  Dict			,				**snake_case__		:  List[Any] ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )






class 							UpperCAmelCase_							(    metaclass=A				):

 '''simple docstring'''
 lowercase_					:    Optional[int]				=							["torch", "transformers", "onnx"]







 def __init__(					self		:  str			,				*snake_case__		:  Optional[int]			,				**snake_case__		:  str ):



   '''simple docstring'''




   requires_backends(self			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  Any			,				*snake_case__		:  List[str]			,				**snake_case__		:  Dict ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  str			,				*snake_case__		:  Dict			,				**snake_case__		:  Dict ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )






class 							UpperCAmelCase_							(    metaclass=A				):

 '''simple docstring'''
 lowercase_					:    int				=							["torch", "transformers", "onnx"]







 def __init__(					self		:  Any			,				*snake_case__		:  List[str]			,				**snake_case__		:  str ):



   '''simple docstring'''




   requires_backends(self			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  List[str]			,				*snake_case__		:  List[str]			,				**snake_case__		:  Optional[Any] ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  Optional[int]			,				*snake_case__		:  List[Any]			,				**snake_case__		:  int ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )






class 							UpperCAmelCase_							(    metaclass=A				):

 '''simple docstring'''
 lowercase_					:    Dict				=							["torch", "transformers", "onnx"]







 def __init__(					self		:  Any			,				*snake_case__		:  Optional[int]			,				**snake_case__		:  Any ):



   '''simple docstring'''




   requires_backends(self			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  Union[str, Any]			,				*snake_case__		:  str			,				**snake_case__		:  Optional[Any] ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  int			,				*snake_case__		:  int			,				**snake_case__		:  Tuple ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )






class 							UpperCAmelCase_							(    metaclass=A				):

 '''simple docstring'''
 lowercase_					:    Dict				=							["torch", "transformers", "onnx"]







 def __init__(					self		:  List[str]			,				*snake_case__		:  Tuple			,				**snake_case__		:  int ):



   '''simple docstring'''




   requires_backends(self			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  Optional[int]			,				*snake_case__		:  Tuple			,				**snake_case__		:  Dict ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )







 @classmethod
 def 							UpperCamelCase  (					cls		:  List[str]			,				*snake_case__		:  Dict			,				**snake_case__		:  List[Any] ):



   '''simple docstring'''




   requires_backends(cls			,				["torch", "transformers", "onnx"] )



