





'''simple docstring'''




from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand





def 	__lowerCamelCase			(      __lowerCAmelCase       :							Namespace		)		->  int:
   return ConvertCommand(
       args.model_type      ,    args.tf_checkpoint      ,    args.pytorch_dump_output      ,    args.config      ,    args.finetuning_task_name		)


_SCREAMING_SNAKE_CASE							     =			"\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 			_lowerCAmelCase		(			A__	):






     """simple docstring"""






     @staticmethod
     def      lowerCAmelCase			(   __snake_case							:			ArgumentParser						)->	int:
        snake_case 						=   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							:			Optional[Any]   ,       __snake_case							:			str   ,       __snake_case							:			str   ,       __snake_case							:			str   ,       __snake_case							:			str   ,       __snake_case							:			str   ,       *__snake_case							:			Union[str, Any]   ,       )->	Any:
        snake_case 						=   logging.get_logger("""transformers-cli/converting"""						)

        self._logger.info(f'''Loading model {model_type}'''						)
        snake_case 						=   model_type
        snake_case 						=   tf_checkpoint
        snake_case 						=   pytorch_dump_output
        snake_case 						=   config
        snake_case 						=   finetuning_task_name



     def      lowerCAmelCase			(   self							:			Union[str, Any]						)->	Optional[Any]:
        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():
              snake_case 						=   self._tf_checkpoint
              snake_case 						=   """"""
           else:
              snake_case 						=   self._tf_checkpoint
              snake_case 						=   """"""
           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 . import (
    albert,
    align,
    altclip,
    audio_spectrogram_transformer,
    auto,
    autoformer,
    bark,
    bart,
    barthez,
    bartpho,
    beit,
    bert,
    bert_generation,
    bert_japanese,
    bertweet,
    big_bird,
    bigbird_pegasus,
    biogpt,
    bit,
    blenderbot,
    blenderbot_small,
    blip,
    blip_a,
    bloom,
    bridgetower,
    byta,
    camembert,
    canine,
    chinese_clip,
    clap,
    clip,
    clipseg,
    codegen,
    conditional_detr,
    convbert,
    convnext,
    convnextva,
    cpm,
    cpmant,
    ctrl,
    cvt,
    dataavec,
    deberta,
    deberta_va,
    decision_transformer,
    deformable_detr,
    deit,
    deprecated,
    deta,
    detr,
    dialogpt,
    dinat,
    distilbert,
    dit,
    donut,
    dpr,
    dpt,
    efficientformer,
    efficientnet,
    electra,
    encodec,
    encoder_decoder,
    ernie,
    ernie_m,
    esm,
    falcon,
    flaubert,
    flava,
    fnet,
    focalnet,
    fsmt,
    funnel,
    git,
    glpn,
    gpta,
    gpt_bigcode,
    gpt_neo,
    gpt_neox,
    gpt_neox_japanese,
    gpt_swa,
    gptj,
    gptsan_japanese,
    graphormer,
    groupvit,
    herbert,
    hubert,
    ibert,
    imagegpt,
    informer,
    instructblip,
    jukebox,
    layoutlm,
    layoutlmva,
    layoutlmva,
    layoutxlm,
    led,
    levit,
    lilt,
    llama,
    longformer,
    longta,
    luke,
    lxmert,
    mam_aaa,
    marian,
    markuplm,
    maskaformer,
    maskformer,
    mbart,
    mbartaa,
    mega,
    megatron_bert,
    megatron_gpta,
    mgp_str,
    mluke,
    mobilebert,
    mobilenet_va,
    mobilenet_va,
    mobilevit,
    mobilevitva,
    mpnet,
    mra,
    mta,
    musicgen,
    mvp,
    nat,
    nezha,
    nllb,
    nllb_moe,
    nystromformer,
    oneformer,
    open_llama,
    openai,
    opt,
    owlvit,
    pegasus,
    pegasus_x,
    perceiver,
    phobert,
    pixastruct,
    plbart,
    poolformer,
    prophetnet,
    qdqbert,
    rag,
    realm,
    reformer,
    regnet,
    rembert,
    resnet,
    roberta,
    roberta_prelayernorm,
    roc_bert,
    roformer,
    rwkv,
    sam,
    segformer,
    sew,
    sew_d,
    speech_encoder_decoder,
    speech_to_text,
    speech_to_text_a,
    speechta,
    splinter,
    squeezebert,
    swiftformer,
    swin,
    swinasr,
    swinva,
    switch_transformers,
    ta,
    table_transformer,
    tapas,
    time_series_transformer,
    timesformer,
    timm_backbone,
    transfo_xl,
    trocr,
    tvlt,
    umta,
    unispeech,
    unispeech_sat,
    upernet,
    videomae,
    vilt,
    vision_encoder_decoder,
    vision_text_dual_encoder,
    visual_bert,
    vit,
    vit_hybrid,
    vit_mae,
    vit_msn,
    vivit,
    wavaveca,
    wavaveca_conformer,
    wavaveca_phoneme,
    wavaveca_with_lm,
    wavlm,
    whisper,
    x_clip,
    xglm,
    xlm,
    xlm_prophetnet,
    xlm_roberta,
    xlm_roberta_xl,
    xlnet,
    xmod,
    yolos,
    yoso,
)

