




"""simple docstring"""


from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand


def       UpperCAmelCase__ (snake_case__							:      Namespace					):
  """simple docstring"""

  return ConvertCommand(
      args.model_type	,     args.tf_checkpoint	,     args.pytorch_dump_output	,     args.config	,     args.finetuning_task_name					)


A_      			=       '''
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				):







 '''simple docstring'''





 @staticmethod
 def 				UpperCamelCase_     (       a_:	ArgumentParser	):




   '''simple docstring'''



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


 def __init__(       self:	Any,   a_:	str,   a_:	str,   a_:	str,   a_:	str,   a_:	str,   *a_:	int,   ):




   '''simple docstring'''



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

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


 def 				UpperCamelCase_     (       self:	Union[str, 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(a_	)

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

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

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

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

     if "ckpt" in self._tf_checkpoint.lower():
       _snake_case							:	Tuple			=						self._tf_checkpoint
       _snake_case							:	Any			=						""""""
     else:
       _snake_case							:	Any			=						self._tf_checkpoint
       _snake_case							:	Dict			=						""""""
     convert_transfo_xl_checkpoint_to_pytorch(
         a_,   self._config,   self._pytorch_dump_output,   a_	)
   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(a_	)

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

     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 ...processing_utils import ProcessorMixin






class       lowercase(  __a				):







 '''simple docstring'''





 lowercase__				      =      ["image_processor", "feature_extractor"]
 lowercase__				      =      "TvltImageProcessor"
 lowercase__				      =      "TvltFeatureExtractor"


 def __init__(       self:	Dict,   a_:	Union[str, Any],   a_:	Union[str, Any]	):




   '''simple docstring'''



   super().__init__(image_processor=a_,   feature_extractor=a_	)

   _snake_case							:	Any			=						image_processor
   _snake_case							:	Dict			=						feature_extractor


 def __call__(       self:	int,   a_:	str=None,   a_:	Tuple=None,   a_:	Dict=None,   a_:	str=None,   a_:	Optional[int]=False,   a_:	Tuple=False,   *a_:	List[str],   **a_:	int,   ):




   '''simple docstring'''



   if images is None and audio is None:
     raise ValueError("""You need to specify either an `images` or `audio` input to process."""	)

   _snake_case							:	Optional[int]			=						None
   if images is not None:
     _snake_case							:	Tuple			=						self.image_processor(a_,   mask_pixel=a_,   *a_,   **a_	)
   if images_mixed is not None:
     _snake_case							:	Optional[int]			=						self.image_processor(a_,   is_mixed=a_,   *a_,   **a_	)
   if audio is not None:
     _snake_case							:	Any			=						self.feature_extractor(
         a_,   *a_,   sampling_rate=a_,   mask_audio=a_,   **a_	)

   _snake_case							:	List[str]			=						{}
   if audio is not None:
     output_dict.update(a_	)
   if images is not None:
     output_dict.update(a_	)
   if images_mixed_dict is not None:
     output_dict.update(a_	)
   return output_dict


 @property
 def 				UpperCamelCase_     (       self:	List[str]	):




   '''simple docstring'''



   _snake_case							:	Dict			=						self.image_processor.model_input_names
   _snake_case							:	List[str]			=						self.feature_extractor.model_input_names
   return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names	)	)


