





'''simple docstring'''






import warnings
from contextlib import contextmanager

from ....processing_utils import ProcessorMixin







class 		UpperCAmelCase   (				lowercase_):


  """simple docstring"""







  lowerCAmelCase_					=				"""MCTCTFeatureExtractor"""
  lowerCAmelCase_					=				"""AutoTokenizer"""


  def __init__(				self    :					int							,	UpperCamelCase__    :					Dict							,	UpperCamelCase__    :					Optional[Any]  )     ->						Optional[int]:
    super().__init__(UpperCamelCase__							,	UpperCamelCase__  )
    _UpperCamelCase       			=self.feature_extractor
    _UpperCamelCase       			=False


  def __call__(				self    :					Tuple							,	*UpperCamelCase__    :					List[Any]							,	**UpperCamelCase__    :					Optional[int]  )     ->						str:
    # For backward compatibility
    if self._in_target_context_manager:
      return self.current_processor(*UpperCamelCase__							,	**UpperCamelCase__  )

    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'''							,	UpperCamelCase__  )
    _UpperCamelCase       			=kwargs.pop('''sampling_rate'''							,	UpperCamelCase__  )
    _UpperCamelCase       			=kwargs.pop('''text'''							,	UpperCamelCase__  )
    if len(UpperCamelCase__  ) > 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(UpperCamelCase__							,	*UpperCamelCase__							,	sampling_rate=UpperCamelCase__							,	**UpperCamelCase__  )
    if text is not None:
      _UpperCamelCase       			=self.tokenizer(UpperCamelCase__							,	**UpperCamelCase__  )

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


  def   UpperCamelCase__      (				self    :					int							,	*UpperCamelCase__    :					int							,	**UpperCamelCase__    :					List[str]  )     ->						int:
    return self.tokenizer.batch_decode(*UpperCamelCase__							,	**UpperCamelCase__  )


  def   UpperCamelCase__      (				self    :					Dict							,	*UpperCamelCase__    :					List[Any]							,	**UpperCamelCase__    :					int  )     ->						Tuple:
    # For backward compatibility
    if self._in_target_context_manager:
      return self.current_processor.pad(*UpperCamelCase__							,	**UpperCamelCase__  )

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

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

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


  def   UpperCamelCase__      (				self    :					Optional[Any]							,	*UpperCamelCase__    :					Dict							,	**UpperCamelCase__    :					int  )     ->						List[Any]:
    return self.tokenizer.decode(*UpperCamelCase__							,	**UpperCamelCase__  )




  @contextmanager
  def   UpperCamelCase__      (				self    :					List[Any]  )     ->						Tuple:
    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













'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_tf_available,
    is_torch_available,
)


__lowerCamelCase						: str		=   {
    'configuration_speech_to_text': ['SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Speech2TextConfig'],
    'processing_speech_to_text': ['Speech2TextProcessor'],
}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase						: List[str]		=   ['Speech2TextTokenizer']

try:
      if not is_speech_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase						: str		=   ['Speech2TextFeatureExtractor']

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase						: Optional[Any]		=   [
          'TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
          'TFSpeech2TextForConditionalGeneration',
          'TFSpeech2TextModel',
          'TFSpeech2TextPreTrainedModel',
      ]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __lowerCamelCase						: Union[str, Any]		=   [
          'SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
          'Speech2TextForConditionalGeneration',
          'Speech2TextModel',
          'Speech2TextPreTrainedModel',
      ]


if TYPE_CHECKING:
      from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
      from .processing_speech_to_text import SpeechaTextProcessor

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_speech_to_text import SpeechaTextTokenizer

      try:
            if not is_speech_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_speech_to_text import (
                TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFSpeechaTextForConditionalGeneration,
                TFSpeechaTextModel,
                TFSpeechaTextPreTrainedModel,
            )

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_speech_to_text import (
                SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
                SpeechaTextForConditionalGeneration,
                SpeechaTextModel,
                SpeechaTextPreTrainedModel,
            )

else:
      import sys

      __lowerCamelCase						: Optional[int]		=   _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






