
"""simple docstring"""

class __lowerCAmelCase		:





     def __init__(     self     ,					__UpperCAmelCase				):

      '''simple docstring'''




      __UpperCamelCase      =	len(__UpperCAmelCase				)
      __UpperCamelCase      =	[0] * len_array

      if len_array > 0:
       __UpperCamelCase      =	array[0]

      for i in range(1     ,					__UpperCAmelCase				):
       __UpperCamelCase      =	self.prefix_sum[i - 1] + array[i]





     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase     ,					__UpperCAmelCase				):

      '''simple docstring'''




      if start == 0:
       return self.prefix_sum[end]

      return self.prefix_sum[end] - self.prefix_sum[start - 1]







     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase				):

      '''simple docstring'''




      __UpperCamelCase      =	{0}
      for sum_item in self.prefix_sum:
       if sum_item - target_sum in sums:
        return True

       sums.add(__UpperCAmelCase				)

      return False


if __name__ == "__main__":
      import doctest

      doctest.testmod()







"""simple docstring"""

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


UpperCamelCase     :    int       =			logging.get_logger(__name__)

class __lowerCAmelCase		(				__SCREAMING_SNAKE_CASE      ):
     lowercase						       =						["input_values", "attention_mask"]





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

      '''simple docstring'''




      super().__init__(feature_size=__UpperCAmelCase     ,					sampling_rate=__UpperCAmelCase     ,					padding_value=__UpperCAmelCase     ,					**__UpperCAmelCase				)
      __UpperCamelCase      =	do_normalize
      __UpperCamelCase      =	return_attention_mask

      __UpperCamelCase      =	num_mel_bins
      __UpperCamelCase      =	hop_length
      __UpperCamelCase      =	win_length
      __UpperCamelCase      =	win_function
      __UpperCamelCase      =	frame_signal_scale
      __UpperCamelCase      =	fmin
      __UpperCamelCase      =	fmax
      __UpperCamelCase      =	mel_floor
      __UpperCamelCase      =	reduction_factor

      __UpperCamelCase      =	win_length * sampling_rate // 1000
      __UpperCamelCase      =	hop_length * sampling_rate // 1000
      __UpperCamelCase      =	optimal_fft_length(self.sample_size				)
      __UpperCamelCase      =	(self.n_fft // 2) + 1

      __UpperCamelCase      =	window_function(window_length=self.sample_size     ,					name=self.win_function     ,					periodic=__UpperCAmelCase				)

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





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

      '''simple docstring'''




      if attention_mask is not None:
       __UpperCamelCase      =	np.array(__UpperCAmelCase     ,					np.intaa				)
       __UpperCamelCase      =	[]

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

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

      return normed_input_values





     def 						UpperCAmelCase (     self     ,					__UpperCAmelCase     ,					):

      '''simple docstring'''




      __UpperCamelCase      =	spectrogram(
          __UpperCAmelCase     ,					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     ,					__UpperCAmelCase = None     ,					__UpperCAmelCase = None     ,					__UpperCAmelCase = False     ,					__UpperCAmelCase = None     ,					__UpperCAmelCase = False     ,					__UpperCAmelCase = None     ,					__UpperCAmelCase = None     ,					__UpperCAmelCase = None     ,					__UpperCAmelCase = None     ,					**__UpperCAmelCase     ,					):

      '''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:
       __UpperCamelCase      =	self._process_audio(
           __UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					**__UpperCAmelCase     ,					)
      else:
       __UpperCamelCase      =	None

      if audio_target is not None:
       __UpperCamelCase      =	self._process_audio(
           __UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					__UpperCAmelCase     ,					**__UpperCAmelCase     ,					)

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

      return inputs





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

      '''simple docstring'''




      __UpperCamelCase      =	isinstance(__UpperCAmelCase     ,					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}'				)
      __UpperCamelCase      =	is_batched_numpy or (
          isinstance(__UpperCAmelCase     ,					(list, tuple)				) and (isinstance(speech[0]     ,					(np.ndarray, tuple, list)				))
      )

      if is_batched:
       __UpperCamelCase      =	[np.asarray(__UpperCAmelCase     ,					dtype=np.floataa				) for speech in speech]
      elif not is_batched and not isinstance(__UpperCAmelCase     ,					np.ndarray				):
       __UpperCamelCase      =	np.asarray(__UpperCAmelCase     ,					dtype=np.floataa				)
      elif isinstance(__UpperCAmelCase     ,					np.ndarray				) and speech.dtype is np.dtype(np.floataa				):
       __UpperCamelCase      =	speech.astype(np.floataa				)

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

      # needed to make pad() work on spectrogram inputs
      __UpperCamelCase      =	self.feature_size

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

      __UpperCamelCase      =	self.pad(
          __UpperCAmelCase     ,					padding=__UpperCAmelCase     ,					max_length=__UpperCAmelCase     ,					truncation=__UpperCAmelCase     ,					pad_to_multiple_of=__UpperCAmelCase     ,					return_attention_mask=__UpperCAmelCase     ,					**__UpperCAmelCase     ,					)

      __UpperCamelCase      =	feature_size_hack

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

      # convert attention_mask to correct format
      __UpperCamelCase      =	padded_inputs.get('attention_mask'				)
      if attention_mask is not None:
       __UpperCamelCase      =	[np.asarray(__UpperCAmelCase     ,					dtype=np.intaa				) for array in attention_mask]

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

      if return_tensors is not None:
       __UpperCamelCase      =	padded_inputs.convert_to_tensors(__UpperCAmelCase				)

      return padded_inputs







     def 						UpperCAmelCase (     self				):

      '''simple docstring'''




      __UpperCamelCase      =	super().to_dict()

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

      return output



