
"""simple docstring"""






from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand



def      lowerCAmelCase__			(		__magic_name__      )						->Tuple:
			return ConvertCommand(
			    args.model_type			,   args.tf_checkpoint			,   args.pytorch_dump_output			,   args.config			,   args.finetuning_task_name      )


_lowercase							=				'''
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 					__a     ( __a       ):



							'''simple docstring'''







							@staticmethod
							def   SCREAMING_SNAKE_CASE						(     _lowerCamelCase       )			->							List[str]:




										'''simple docstring'''
										__lowercase       =       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=_lowerCamelCase  ,    required=_lowerCamelCase  ,    help="Model's type."       )
										train_parser.add_argument(
										    "--tf_checkpoint"  ,    type=_lowerCamelCase  ,    required=_lowerCamelCase  ,    help="TensorFlow checkpoint path or folder."       )
										train_parser.add_argument(
										    "--pytorch_dump_output"  ,    type=_lowerCamelCase  ,    required=_lowerCamelCase  ,    help="Path to the PyTorch saved model output."       )
										train_parser.add_argument("--config"  ,    type=_lowerCamelCase  ,    default=""  ,    help="Configuration file path or folder."       )
										train_parser.add_argument(
										    "--finetuning_task_name"  ,    type=_lowerCamelCase  ,    default=_lowerCamelCase  ,    help="Optional fine-tuning task name if the TF model was a finetuned model."  ,    )
										train_parser.set_defaults(func=_lowerCamelCase       )
							def __init__(     self  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    *_lowerCamelCase  ,    )			->							Optional[Any]:




										'''simple docstring'''
										__lowercase       =       logging.get_logger("transformers-cli/converting"       )

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





							def   SCREAMING_SNAKE_CASE						(     self       )			->							Optional[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(_lowerCamelCase       )

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

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

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

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

													if "ckpt" in self._tf_checkpoint.lower():
																__lowercase       =       self._tf_checkpoint
																__lowercase       =       ""
													else:
																__lowercase       =       self._tf_checkpoint
																__lowercase       =       ""
													convert_transfo_xl_checkpoint_to_pytorch(
													    _lowerCamelCase  ,    self._config  ,    self._pytorch_dump_output  ,    _lowerCamelCase       )
										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(_lowerCamelCase       )

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

													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 					__a     ( __a       ):



							'''simple docstring'''







							_lowerCamelCase					:			List[Any]          =   """Wav2Vec2FeatureExtractor"""
							_lowerCamelCase					:			Any          =   """AutoTokenizer"""
							def __init__(     self  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							List[str]:




										'''simple docstring'''
										super().__init__(_lowerCamelCase  ,    _lowerCamelCase       )
										__lowercase       =       self.feature_extractor
										__lowercase       =       False
							@classmethod
							def   SCREAMING_SNAKE_CASE						(     cls  ,    _lowerCamelCase  ,    **_lowerCamelCase       )			->							Any:




										'''simple docstring'''
										try:
													return super().from_pretrained(_lowerCamelCase  ,    **_lowerCamelCase       )
										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: "  ,    _lowerCamelCase  ,    )

													__lowercase       =       WavaVecaFeatureExtractor.from_pretrained(_lowerCamelCase  ,    **_lowerCamelCase       )
													__lowercase       =       WavaVecaCTCTokenizer.from_pretrained(_lowerCamelCase  ,    **_lowerCamelCase       )

													return cls(feature_extractor=_lowerCamelCase  ,    tokenizer=_lowerCamelCase       )
							def __call__(     self  ,    *_lowerCamelCase  ,    **_lowerCamelCase       )			->							List[Any]:




										'''simple docstring'''
										# For backward compatibility
										if self._in_target_context_manager:
													return self.current_processor(*_lowerCamelCase  ,    **_lowerCamelCase       )

										if "raw_speech" in kwargs:
													warnings.warn("Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead."       )
													__lowercase       =       kwargs.pop("raw_speech"       )
										else:
													__lowercase       =       kwargs.pop("audio"  ,    _lowerCamelCase       )
										__lowercase       =       kwargs.pop("sampling_rate"  ,    _lowerCamelCase       )
										__lowercase       =       kwargs.pop("text"  ,    _lowerCamelCase       )
										if len(_lowerCamelCase       ) > 0:
													__lowercase       =       args[0]
													__lowercase       =       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:
													__lowercase       =       self.feature_extractor(_lowerCamelCase  ,    *_lowerCamelCase  ,    sampling_rate=_lowerCamelCase  ,    **_lowerCamelCase       )
										if text is not None:
													__lowercase       =       self.tokenizer(_lowerCamelCase  ,    **_lowerCamelCase       )

										if text is None:
													return inputs
										elif audio is None:
													return encodings
										else:
													__lowercase       =       encodings["input_ids"]
													return inputs
							def   SCREAMING_SNAKE_CASE						(     self  ,    *_lowerCamelCase  ,    **_lowerCamelCase       )			->							List[str]:




										'''simple docstring'''
										# For backward compatibility
										if self._in_target_context_manager:
													return self.current_processor.pad(*_lowerCamelCase  ,    **_lowerCamelCase       )

										__lowercase       =       kwargs.pop("input_features"  ,    _lowerCamelCase       )
										__lowercase       =       kwargs.pop("labels"  ,    _lowerCamelCase       )
										if len(_lowerCamelCase       ) > 0:
													__lowercase       =       args[0]
													__lowercase       =       args[1:]

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

										if labels is None:
													return input_features
										elif input_features is None:
													return labels
										else:
													__lowercase       =       labels["input_ids"]
													return input_features
							def   SCREAMING_SNAKE_CASE						(     self  ,    *_lowerCamelCase  ,    **_lowerCamelCase       )			->							Optional[int]:




										'''simple docstring'''
										return self.tokenizer.batch_decode(*_lowerCamelCase  ,    **_lowerCamelCase       )
							def   SCREAMING_SNAKE_CASE						(     self  ,    *_lowerCamelCase  ,    **_lowerCamelCase       )			->							Dict:




										'''simple docstring'''
										return self.tokenizer.decode(*_lowerCamelCase  ,    **_lowerCamelCase       )





							@contextmanager
							def   SCREAMING_SNAKE_CASE						(     self       )			->							str:




										'''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."       )
										__lowercase       =       True
										__lowercase       =       self.tokenizer
										yield
										__lowercase       =       self.feature_extractor
										__lowercase       =       False





