






"""simple docstring"""


from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand




def     snake_case						(A_   :Namespace   ):







  '''simple docstring'''

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


_UpperCamelCase       :					List[str]									=		'\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 		snake_case						(						UpperCAmelCase ):





    @staticmethod
    def        lowerCamelCase__   (							A			:      ArgumentParser    ):


      '''simple docstring'''




      a  :    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			:      Union[str, Any]       ,	A			:      str       ,	A			:      str       ,	A			:      str       ,	A			:      str       ,	A			:      str       ,	*A			:      int       ,	):


      '''simple docstring'''




      a  :    Any       =     logging.get_logger('transformers-cli/converting'    )

      self._logger.info(F'''Loading model {model_type}'''    )
      a  :    Optional[int]       =     model_type
      a  :    Tuple       =     tf_checkpoint
      a  :    Any       =     pytorch_dump_output
      a  :    List[str]       =     config
      a  :    Dict       =     finetuning_task_name





    def        lowerCamelCase__   (							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():
          a  :    Dict       =     self._tf_checkpoint
          a  :    Any       =     ''
        else:
          a  :    Tuple       =     self._tf_checkpoint
          a  :    List[str]       =     ''
        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"""


import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin
from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
from .tokenization_wavaveca import WavaVecaCTCTokenizer






class 		snake_case						(						UpperCAmelCase ):
    __magic_name__					  =  '''Wav2Vec2FeatureExtractor'''
    __magic_name__					  =  '''AutoTokenizer'''





    def __init__(							self			:      Optional[int]       ,	A			:      int       ,	A			:      List[Any]    ):


      '''simple docstring'''




      super().__init__(A       ,	A    )
      a  :    int       =     self.feature_extractor
      a  :    List[Any]       =     False





    @classmethod
    def        lowerCamelCase__   (							cls			:      Optional[Any]       ,	A			:      str       ,	**A			:      Union[str, Any]    ):


      '''simple docstring'''




      try:
        return super().from_pretrained(A       ,	**A    )
      except OSError:
        warnings.warn(
            F'''Loading a tokenizer inside {cls.__name__} from a config that does not'''
            ' include a `tokenizer_class` attribute is deprecated and will be '
            'removed in v5. Please add `\'tokenizer_class\': \'Wav2Vec2CTCTokenizer\'`'
            ' attribute to either your `config.json` or `tokenizer_config.json` '
            'file to suppress this warning: '       ,	A       ,	)

        a  :    int       =     WavaVecaFeatureExtractor.from_pretrained(A       ,	**A    )
        a  :    Dict       =     WavaVecaCTCTokenizer.from_pretrained(A       ,	**A    )

        return cls(feature_extractor=A       ,	tokenizer=A    )





    def __call__(							self			:      str       ,	*A			:      int       ,	**A			:      Union[str, Any]    ):


      '''simple docstring'''




      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.'    )
        a  :    str       =     kwargs.pop('raw_speech'    )
      else:
        a  :    Dict       =     kwargs.pop('audio'       ,	A    )
      a  :    Any       =     kwargs.pop('sampling_rate'       ,	A    )
      a  :    Union[str, Any]       =     kwargs.pop('text'       ,	A    )
      if len(A    ) > 0:
        a  :    Optional[int]       =     args[0]
        a  :    List[Any]       =     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:
        a  :    List[Any]       =     self.feature_extractor(A       ,	*A       ,	sampling_rate=A       ,	**A    )
      if text is not None:
        a  :    List[str]       =     self.tokenizer(A       ,	**A    )

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





    def        lowerCamelCase__   (							self			:      Optional[int]       ,	*A			:      Tuple       ,	**A			:      List[Any]    ):


      '''simple docstring'''




      if self._in_target_context_manager:
        return self.current_processor.pad(*A       ,	**A    )

      a  :    Optional[int]       =     kwargs.pop('input_features'       ,	A    )
      a  :    List[Any]       =     kwargs.pop('labels'       ,	A    )
      if len(A    ) > 0:
        a  :    List[str]       =     args[0]
        a  :    Tuple       =     args[1:]

      if input_features is not None:
        a  :    str       =     self.feature_extractor.pad(A       ,	*A       ,	**A    )
      if labels is not None:
        a  :    Optional[Any]       =     self.tokenizer.pad(A       ,	**A    )

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





    def        lowerCamelCase__   (							self			:      Union[str, Any]       ,	*A			:      Optional[Any]       ,	**A			:      Tuple    ):


      '''simple docstring'''




      return self.tokenizer.batch_decode(*A       ,	**A    )





    def        lowerCamelCase__   (							self			:      Dict       ,	*A			:      Optional[Any]       ,	**A			:      str    ):


      '''simple docstring'''




      return self.tokenizer.decode(*A       ,	**A    )





    @contextmanager
    def        lowerCamelCase__   (							self			:      List[Any]    ):


      '''simple docstring'''




      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.'    )
      a  :    List[Any]       =     True
      a  :    Optional[Any]       =     self.tokenizer
      yield
      a  :    Union[str, Any]       =     self.feature_extractor
      a  :    List[Any]       =     False




