

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     :   int						     =  logging.get_logger(__name__)
class  _A		(  __magic_name__):
  SCREAMING_SNAKE_CASE    :      str       =  ['''input_values''', '''attention_mask''']

  def __init__(				self ,					_SCREAMING_SNAKE_CASE = 1 ,					_SCREAMING_SNAKE_CASE = 1_6000 ,					_SCREAMING_SNAKE_CASE = 0.0 ,					_SCREAMING_SNAKE_CASE = False ,					_SCREAMING_SNAKE_CASE = 80 ,					_SCREAMING_SNAKE_CASE = 16 ,					_SCREAMING_SNAKE_CASE = 64 ,					_SCREAMING_SNAKE_CASE = "hann_window" ,					_SCREAMING_SNAKE_CASE = 1.0 ,					_SCREAMING_SNAKE_CASE = 80 ,					_SCREAMING_SNAKE_CASE = 7600 ,					_SCREAMING_SNAKE_CASE = 1e-10 ,					_SCREAMING_SNAKE_CASE = 2 ,					_SCREAMING_SNAKE_CASE = True ,					**_SCREAMING_SNAKE_CASE ,					):





        """simple docstring"""







        super().__init__(feature_size=_SCREAMING_SNAKE_CASE ,					sampling_rate=_SCREAMING_SNAKE_CASE ,					padding_value=_SCREAMING_SNAKE_CASE ,					**_SCREAMING_SNAKE_CASE					)
        SCREAMING_SNAKE_CASE_				:  int           =     do_normalize
        SCREAMING_SNAKE_CASE_				:  List[str]           =     return_attention_mask

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

        SCREAMING_SNAKE_CASE_				:  Any           =     win_length * sampling_rate // 1000
        SCREAMING_SNAKE_CASE_				:  Any           =     hop_length * sampling_rate // 1000
        SCREAMING_SNAKE_CASE_				:  int           =     optimal_fft_length(self.sample_size					)
        SCREAMING_SNAKE_CASE_				:  str           =     (self.n_fft // 2) + 1

        SCREAMING_SNAKE_CASE_				:  Tuple           =     window_function(window_length=self.sample_size ,					name=self.win_function ,					periodic=_SCREAMING_SNAKE_CASE					)

        SCREAMING_SNAKE_CASE_				:  List[Any]           =     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' ,					_SCREAMING_SNAKE_CASE ,					)
        if reduction_factor != 2.0:
              warnings.warn(
                  'The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers' ,					_SCREAMING_SNAKE_CASE ,					)

  @staticmethod
  # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
  def  UpperCAmelCase    (				_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE = 0.0					):





        """simple docstring"""







        if attention_mask is not None:
              SCREAMING_SNAKE_CASE_				:  str           =     np.array(_SCREAMING_SNAKE_CASE ,					np.intaa					)
              SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     []

              for vector, length in zip(_SCREAMING_SNAKE_CASE ,					attention_mask.sum(-1					)					):
                    SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7					)
                    if length < normed_slice.shape[0]:
                          SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     padding_value

                    normed_input_values.append(_SCREAMING_SNAKE_CASE					)
        else:
              SCREAMING_SNAKE_CASE_				:  List[Any]           =     [(x - x.mean()) / np.sqrt(x.var() + 1e-7					) for x in input_values]

        return normed_input_values

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE ,					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  str           =     spectrogram(
            _SCREAMING_SNAKE_CASE ,					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 ,					_SCREAMING_SNAKE_CASE = None ,					_SCREAMING_SNAKE_CASE = None ,					_SCREAMING_SNAKE_CASE = False ,					_SCREAMING_SNAKE_CASE = None ,					_SCREAMING_SNAKE_CASE = False ,					_SCREAMING_SNAKE_CASE = None ,					_SCREAMING_SNAKE_CASE = None ,					_SCREAMING_SNAKE_CASE = None ,					_SCREAMING_SNAKE_CASE = None ,					**_SCREAMING_SNAKE_CASE ,					):





        """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:
              SCREAMING_SNAKE_CASE_				:  List[str]           =     self._process_audio(
                  _SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					**_SCREAMING_SNAKE_CASE ,					)
        else:
              SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     None

        if audio_target is not None:
              SCREAMING_SNAKE_CASE_				:  int           =     self._process_audio(
                  _SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE ,					**_SCREAMING_SNAKE_CASE ,					)

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

        return inputs

  def  UpperCAmelCase    (				self ,					_SCREAMING_SNAKE_CASE ,					_SCREAMING_SNAKE_CASE = False ,					_SCREAMING_SNAKE_CASE = False ,					_SCREAMING_SNAKE_CASE = None ,					_SCREAMING_SNAKE_CASE = False ,					_SCREAMING_SNAKE_CASE = None ,					_SCREAMING_SNAKE_CASE = None ,					_SCREAMING_SNAKE_CASE = None ,					**_SCREAMING_SNAKE_CASE ,					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Any           =     isinstance(_SCREAMING_SNAKE_CASE ,					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}"					)
        SCREAMING_SNAKE_CASE_				:  str           =     is_batched_numpy or (
            isinstance(_SCREAMING_SNAKE_CASE ,					(list, tuple)					) and (isinstance(speech[0] ,					(np.ndarray, tuple, list)					))
        )

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

        # always return batch
        if not is_batched:
              SCREAMING_SNAKE_CASE_				:  Any           =     [speech]

        # needed to make pad() work on spectrogram inputs
        SCREAMING_SNAKE_CASE_				:  Optional[Any]           =     self.feature_size

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

        SCREAMING_SNAKE_CASE_				:  List[str]           =     self.pad(
            _SCREAMING_SNAKE_CASE ,					padding=_SCREAMING_SNAKE_CASE ,					max_length=_SCREAMING_SNAKE_CASE ,					truncation=_SCREAMING_SNAKE_CASE ,					pad_to_multiple_of=_SCREAMING_SNAKE_CASE ,					return_attention_mask=_SCREAMING_SNAKE_CASE ,					**_SCREAMING_SNAKE_CASE ,					)

        SCREAMING_SNAKE_CASE_				:  Any           =     feature_size_hack

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

        # convert attention_mask to correct format
        SCREAMING_SNAKE_CASE_				:  Optional[int]           =     padded_inputs.get('attention_mask'					)
        if attention_mask is not None:
              SCREAMING_SNAKE_CASE_				:  List[Any]           =     [np.asarray(_SCREAMING_SNAKE_CASE ,					dtype=np.intaa					) for array in attention_mask]

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

        if return_tensors is not None:
              SCREAMING_SNAKE_CASE_				:  List[Any]           =     padded_inputs.convert_to_tensors(_SCREAMING_SNAKE_CASE					)

        return padded_inputs



  def  UpperCAmelCase    (				self					):





        """simple docstring"""







        SCREAMING_SNAKE_CASE_				:  Union[str, Any]           =     super().to_dict()

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

        return output









def    A_  (							a					,   a  ):

      """simple docstring"""



      return numa ^ numa < 0


if __name__ == "__main__":
    import doctest

    doctest.testmod()






