





'''simple docstring'''






from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand
def 							_lowerCamelCase(  UpperCamelCase__    : Namespace		)		->  Optional[Any]:
    return ConvertCommand(
        args.model_type    ,       args.tf_checkpoint    ,       args.pytorch_dump_output    ,       args.config    ,       args.finetuning_task_name		)


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   _lowercase						(							a				):


   @staticmethod
   def 					snake_case				( _UpperCAmelCase					):
       A       :       List[Any]							=						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       :       str							=						model_type
       A       :       Any							=						tf_checkpoint
       A       :       Union[str, Any]							=						pytorch_dump_output
       A       :       int							=						config
       A       :       Optional[int]							=						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       :       Optional[Any]							=						self._tf_checkpoint
               A       :       List[str]							=						''''''
           else:
               A       :       List[str]							=						self._tf_checkpoint
               A       :       Optional[int]							=						''''''
           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]'''					)







'''simple docstring'''






from ..utils import DummyObject, requires_backends


class   _lowercase						(							metaclass=a				):
   _UpperCamelCase       		=   ["""onnx"""]


   def __init__( self    ,   *_UpperCAmelCase    ,   **_UpperCAmelCase					):
       requires_backends(self    ,   ['''onnx''']					)


   @classmethod
   def 					snake_case				( cls    ,   *_UpperCAmelCase    ,   **_UpperCAmelCase					):
       requires_backends(cls    ,   ['''onnx''']					)


   @classmethod
   def 					snake_case				( cls    ,   *_UpperCAmelCase    ,   **_UpperCAmelCase					):
       requires_backends(cls    ,   ['''onnx''']					)
