


from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Namespace    ):
     return ConvertCommand(
         args.model_type      ,					args.tf_checkpoint      ,					args.pytorch_dump_output      ,					args.config      ,					args.finetuning_task_name    )


_A			=						'\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    UpperCAmelCase__	( A_		):



     """simple docstring"""






     @staticmethod
     def _a (      A_   )  ->	Dict:
          __UpperCamelCase   							=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 ,       A_ ,       A_ ,       A_ ,       A_ ,       A_ ,       *A_ ,       )  ->	Tuple:
          __UpperCamelCase   							=logging.get_logger('transformers-cli/converting'   )

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






     def _a (      self   )  ->	Tuple:
          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():
                    __UpperCamelCase   							=self._tf_checkpoint
                    __UpperCamelCase   							=''
               else:
                    __UpperCamelCase   							=self._tf_checkpoint
                    __UpperCamelCase   							=''
               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]'   )









import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin






class    UpperCAmelCase__	( A_		):



    """simple docstring"""






    UpperCAmelCase__						:		Optional[int]              =  "MCTCTFeatureExtractor"
    UpperCAmelCase__						:		str              =  "AutoTokenizer"






    def __init__(      self ,       A_ ,       A_   )  ->	Dict:
         super().__init__(A_ ,       A_   )
         __UpperCamelCase   							=self.feature_extractor
         __UpperCamelCase   							=False






    def __call__(      self ,       *A_ ,       **A_   )  ->	Optional[Any]:
         # For backward compatibility
         if self._in_target_context_manager:
              return self.current_processor(*A_ ,       **A_   )

         if "raw_speech" in kwargs:
              warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'   )
              __UpperCamelCase   							=kwargs.pop('raw_speech'   )
         else:
              __UpperCamelCase   							=kwargs.pop('audio' ,       A_   )
         __UpperCamelCase   							=kwargs.pop('sampling_rate' ,       A_   )
         __UpperCamelCase   							=kwargs.pop('text' ,       A_   )
         if len(A_   ) > 0:
              __UpperCamelCase   							=args[0]
              __UpperCamelCase   							=args[1:]

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

         if audio is not None:
              __UpperCamelCase   							=self.feature_extractor(A_ ,       *A_ ,       sampling_rate=A_ ,       **A_   )
         if text is not None:
              __UpperCamelCase   							=self.tokenizer(A_ ,       **A_   )

         if text is None:
              return inputs
         elif audio is None:
              return encodings
         else:
              __UpperCamelCase   							=encodings['input_ids']
              return inputs






    def _a (      self ,       *A_ ,       **A_   )  ->	str:
         return self.tokenizer.batch_decode(*A_ ,       **A_   )






    def _a (      self ,       *A_ ,       **A_   )  ->	List[Any]:
         # For backward compatibility
         if self._in_target_context_manager:
              return self.current_processor.pad(*A_ ,       **A_   )

         __UpperCamelCase   							=kwargs.pop('input_features' ,       A_   )
         __UpperCamelCase   							=kwargs.pop('labels' ,       A_   )
         if len(A_   ) > 0:
              __UpperCamelCase   							=args[0]
              __UpperCamelCase   							=args[1:]

         if input_features is not None:
              __UpperCamelCase   							=self.feature_extractor.pad(A_ ,       *A_ ,       **A_   )
         if labels is not None:
              __UpperCamelCase   							=self.tokenizer.pad(A_ ,       **A_   )

         if labels is None:
              return input_features
         elif input_features is None:
              return labels
         else:
              __UpperCamelCase   							=labels['input_ids']
              return input_features






    def _a (      self ,       *A_ ,       **A_   )  ->	Optional[int]:
         return self.tokenizer.decode(*A_ ,       **A_   )






    @contextmanager
    def _a (      self   )  ->	str:
         warnings.warn(
             '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
             'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
             'your audio inputs, or in a separate call.'   )
         __UpperCamelCase   							=True
         __UpperCamelCase   							=self.tokenizer
         yield
         __UpperCamelCase   							=self.feature_extractor
         __UpperCamelCase   							=False





