




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


lowerCAmelCase_						=			{
    'configuration_transfo_xl': ['TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TransfoXLConfig'],
    'tokenization_transfo_xl': ['TransfoXLCorpus', 'TransfoXLTokenizer'],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCAmelCase_						=			[
     'TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'AdaptiveEmbedding',
     'TransfoXLForSequenceClassification',
     'TransfoXLLMHeadModel',
     'TransfoXLModel',
     'TransfoXLPreTrainedModel',
     'load_tf_weights_in_transfo_xl',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 lowerCAmelCase_						=			[
     'TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST',
     'TFAdaptiveEmbedding',
     'TFTransfoXLForSequenceClassification',
     'TFTransfoXLLMHeadModel',
     'TFTransfoXLMainLayer',
     'TFTransfoXLModel',
     'TFTransfoXLPreTrainedModel',
 ]


if TYPE_CHECKING:
 from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
 from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_transfo_xl import (
      TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      AdaptiveEmbedding,
      TransfoXLForSequenceClassification,
      TransfoXLLMHeadModel,
      TransfoXLModel,
      TransfoXLPreTrainedModel,
      load_tf_weights_in_transfo_xl,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_transfo_xl import (
      TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFAdaptiveEmbedding,
      TFTransfoXLForSequenceClassification,
      TFTransfoXLLMHeadModel,
      TFTransfoXLMainLayer,
      TFTransfoXLModel,
      TFTransfoXLPreTrainedModel,
  )

else:
 import sys

 lowerCAmelCase_						=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





import warnings
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


lowerCAmelCase_						=			logging.get_logger(__name__)
class 						_A (  _lowerCamelCase				):
  _UpperCamelCase       :      str			=      ['''input_values''', '''attention_mask''']






  def __init__(  self		:     Optional[Any]				,						_A		:     int = 1				,						_A		:     int = 16_000				,						_A		:     float = 0.0				,						_A		:     bool = False				,						_A		:     int = 80				,						_A		:     int = 16				,						_A		:     int = 64				,						_A		:     str = "hann_window"				,						_A		:     float = 1.0				,						_A		:     float = 80				,						_A		:     float = 7_600				,						_A		:     float = 1E-10				,						_A		:     int = 2				,						_A		:     bool = True				,						**_A		:     int				,						)		->   Union[str, Any]:






       """simple docstring"""







       super().__init__(feature_size=_A				,						sampling_rate=_A				,						padding_value=_A				,						**_A				)
       lowercase :       str       =			do_normalize
       lowercase :       int       =			return_attention_mask

       lowercase :       Union[str, Any]       =			num_mel_bins
       lowercase :       Union[str, Any]       =			hop_length
       lowercase :       Dict       =			win_length
       lowercase :       Union[str, Any]       =			win_function
       lowercase :       int       =			frame_signal_scale
       lowercase :       Dict       =			fmin
       lowercase :       Optional[Any]       =			fmax
       lowercase :       str       =			mel_floor
       lowercase :       Dict       =			reduction_factor

       lowercase :       List[Any]       =			win_length * sampling_rate // 1_000
       lowercase :       Union[str, Any]       =			hop_length * sampling_rate // 1_000
       lowercase :       Optional[Any]       =			optimal_fft_length(self.sample_size				)
       lowercase :       Dict       =			(self.n_fft // 2) + 1

       lowercase :       Any       =			window_function(window_length=self.sample_size				,						name=self.win_function				,						periodic=_A				)

       lowercase :       Dict       =			mel_filter_bank(
           num_frequency_bins=self.n_freqs				,						num_mel_filters=self.num_mel_bins				,						min_frequency=self.fmin				,						max_frequency=self.fmax				,						sampling_rate=self.sampling_rate				,						norm='''slaney'''				,						mel_scale='''slaney'''				,						)

       if frame_signal_scale != 1.0:
            warnings.warn(
                '''The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers'''				,						_A				,						)
       if reduction_factor != 2.0:
            warnings.warn(
                '''The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers'''				,						_A				,						)






  @staticmethod
  # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
  def  __a      (  _A		:     List[np.ndarray]				,						_A		:     List[np.ndarray]				,						_A		:     float = 0.0				)		->   List[np.ndarray]:






       """simple docstring"""







       if attention_mask is not None:
            lowercase :       Optional[int]       =			np.array(_A				,						np.intaa				)
            lowercase :       Dict       =			[]

            for vector, length in zip(_A				,						attention_mask.sum(-1				)				):
                 lowercase :       Dict       =			(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7				)
                 if length < normed_slice.shape[0]:
                      lowercase :       List[str]       =			padding_value

                 normed_input_values.append(_A				)
       else:
            lowercase :       Dict       =			[(x - x.mean()) / np.sqrt(x.var() + 1E-7				) for x in input_values]

       return normed_input_values






  def  __a      (  self		:     Any				,						_A		:     np.ndarray				,						)		->   np.ndarray:






       """simple docstring"""







       lowercase :       Tuple       =			spectrogram(
           _A				,						window=self.window				,						frame_length=self.sample_size				,						hop_length=self.sample_stride				,						fft_length=self.n_fft				,						mel_filters=self.mel_filters				,						mel_floor=self.mel_floor				,						log_mel='''log10'''				,						)
       return log_mel_spec.T






  def __call__(  self		:     List[Any]				,						_A		:     Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None				,						_A		:     Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None				,						_A		:     Union[bool, str, PaddingStrategy] = False				,						_A		:     Optional[int] = None				,						_A		:     bool = False				,						_A		:     Optional[int] = None				,						_A		:     Optional[bool] = None				,						_A		:     Optional[Union[str, TensorType]] = None				,						_A		:     Optional[int] = None				,						**_A		:     Tuple				,						)		->   BatchFeature:






       """simple docstring"""







       if audio is None and audio_target is None:
            raise ValueError('''You must provide either `audio` or `audio_target` values.'''				)

       if sampling_rate is not None:
            if sampling_rate != self.sampling_rate:
                 raise ValueError(
                     f"""The model corresponding to this feature extractor: {self} was trained using a sampling rate of"""
                     f""" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"""
                     f""" {self.sampling_rate} and not {sampling_rate}."""				)
       else:
            logger.warning(
                '''It is strongly recommended to pass the ``sampling_rate`` argument to this function. '''
                '''Failing to do so can result in silent errors that might be hard to debug.'''				)

       if audio is not None:
            lowercase :       Any       =			self._process_audio(
                _A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						**_A				,						)
       else:
            lowercase :       Any       =			None

       if audio_target is not None:
            lowercase :       Tuple       =			self._process_audio(
                _A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						_A				,						**_A				,						)

            if inputs is None:
                 return inputs_target
            else:
                 lowercase :       Any       =			inputs_target['''input_values''']
                 lowercase :       Dict       =			inputs_target.get('''attention_mask'''				)
                 if decoder_attention_mask is not None:
                      lowercase :       Union[str, Any]       =			decoder_attention_mask

       return inputs






  def  __a      (  self		:     List[Any]				,						_A		:     Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]				,						_A		:     bool = False				,						_A		:     Union[bool, str, PaddingStrategy] = False				,						_A		:     Optional[int] = None				,						_A		:     bool = False				,						_A		:     Optional[int] = None				,						_A		:     Optional[bool] = None				,						_A		:     Optional[Union[str, TensorType]] = None				,						**_A		:     Any				,						)		->   BatchFeature:






       """simple docstring"""







       lowercase :       Optional[int]       =			isinstance(_A				,						np.ndarray				) and len(speech.shape				) > 1
       if is_batched_numpy and len(speech.shape				) > 2:
            raise ValueError(f"""Only mono-channel audio is supported for input to {self}"""				)
       lowercase :       int       =			is_batched_numpy or (
           isinstance(_A				,						(list, tuple)				) and (isinstance(speech[0]				,						(np.ndarray, tuple, list)				))
       )

       if is_batched:
            lowercase :       Optional[int]       =			[np.asarray(_A				,						dtype=np.floataa				) for speech in speech]
       elif not is_batched and not isinstance(_A				,						np.ndarray				):
            lowercase :       List[str]       =			np.asarray(_A				,						dtype=np.floataa				)
       elif isinstance(_A				,						np.ndarray				) and speech.dtype is np.dtype(np.floataa				):
            lowercase :       List[str]       =			speech.astype(np.floataa				)

       # always return batch
       if not is_batched:
            lowercase :       Union[str, Any]       =			[speech]

       # needed to make pad() work on spectrogram inputs
       lowercase :       Any       =			self.feature_size

       # convert into correct format for padding
       if is_target:
            lowercase :       int       =			[self._extract_mel_features(_A				) for waveform in speech]
            lowercase :       Any       =			BatchFeature({'''input_values''': features}				)
            lowercase :       Optional[Any]       =			self.num_mel_bins
       else:
            lowercase :       Optional[Any]       =			BatchFeature({'''input_values''': speech}				)

       lowercase :       Optional[int]       =			self.pad(
           _A				,						padding=_A				,						max_length=_A				,						truncation=_A				,						pad_to_multiple_of=_A				,						return_attention_mask=_A				,						**_A				,						)

       lowercase :       str       =			feature_size_hack

       # convert input values to correct format
       lowercase :       List[Any]       =			padded_inputs['''input_values''']
       if not isinstance(input_values[0]				,						np.ndarray				):
            lowercase :       List[str]       =			[np.asarray(_A				,						dtype=np.floataa				) for array in input_values]
       elif (
           not isinstance(_A				,						np.ndarray				)
           and isinstance(input_values[0]				,						np.ndarray				)
           and input_values[0].dtype is np.dtype(np.floataa				)
       ):
            lowercase :       List[str]       =			[array.astype(np.floataa				) for array in input_values]
       elif isinstance(_A				,						np.ndarray				) and input_values.dtype is np.dtype(np.floataa				):
            lowercase :       Optional[Any]       =			input_values.astype(np.floataa				)

       # convert attention_mask to correct format
       lowercase :       int       =			padded_inputs.get('''attention_mask'''				)
       if attention_mask is not None:
            lowercase :       Union[str, Any]       =			[np.asarray(_A				,						dtype=np.intaa				) for array in attention_mask]

       # zero-mean and unit-variance normalization
       if not is_target and self.do_normalize:
            lowercase :       Any       =			(
                attention_mask
                if self._get_padding_strategies(_A				,						max_length=_A				) is not PaddingStrategy.DO_NOT_PAD
                else None
            )
            lowercase :       Optional[int]       =			self.zero_mean_unit_var_norm(
                padded_inputs['''input_values''']				,						attention_mask=_A				,						padding_value=self.padding_value				)

       if return_tensors is not None:
            lowercase :       Tuple       =			padded_inputs.convert_to_tensors(_A				)

       return padded_inputs






  def  __a      (  self		:     Optional[Any]				)		->   Dict[str, Any]:






       """simple docstring"""







       lowercase :       Optional[Any]       =			super().to_dict()

       # Don't serialize these as they are derived from the other properties.
       lowercase :       Optional[int]       =			['''window''', '''mel_filters''', '''sample_size''', '''sample_stride''', '''n_fft''', '''n_freqs''']
       for name in names:
            if name in output:
                 del output[name]

       return output