





'''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


_SCREAMING_SNAKE_CASE	 =							logging.get_logger(__name__)

class    lowerCAmelCase_		(		__magic_name__		):
 __lowerCamelCase						:							Tuple         =					["input_values", "attention_mask"]




 def __init__(	self			,     _lowerCAmelCase = 1			,     _lowerCAmelCase = 16000			,     _lowerCAmelCase = 0.0			,     _lowerCAmelCase = False			,     _lowerCAmelCase = 80			,     _lowerCAmelCase = 16			,     _lowerCAmelCase = 64			,     _lowerCAmelCase = "hann_window"			,     _lowerCAmelCase = 1.0			,     _lowerCAmelCase = 80			,     _lowerCAmelCase = 7600			,     _lowerCAmelCase = 1E-10			,     _lowerCAmelCase = 2			,     _lowerCAmelCase = True			,     **_lowerCAmelCase			,     )    ->							str:
     super().__init__(feature_size=_lowerCAmelCase			,     sampling_rate=_lowerCAmelCase			,     padding_value=_lowerCAmelCase			,     **_lowerCAmelCase		)
     _lowerCAmelCase				=      do_normalize
     _lowerCAmelCase				=      return_attention_mask

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

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

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

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




 @staticmethod
 # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
 def 							_snake_case   (	_lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase = 0.0		)    ->							List[np.ndarray]:
     if attention_mask is not None:
         _lowerCAmelCase				=      np.array(_lowerCAmelCase			,     np.intaa		)
         _lowerCAmelCase				=      []

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

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

     return normed_input_values




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     )    ->							np.ndarray:
     _lowerCAmelCase				=      spectrogram(
         _lowerCAmelCase			,     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			,     _lowerCAmelCase = None			,     _lowerCAmelCase = None			,     _lowerCAmelCase = False			,     _lowerCAmelCase = None			,     _lowerCAmelCase = False			,     _lowerCAmelCase = None			,     _lowerCAmelCase = None			,     _lowerCAmelCase = None			,     _lowerCAmelCase = None			,     **_lowerCAmelCase			,     )    ->							BatchFeature:
     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:
         _lowerCAmelCase				=      self._process_audio(
             _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     _lowerCAmelCase			,     **_lowerCAmelCase			,     )
     else:
         _lowerCAmelCase				=      None

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

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

     return inputs




 def 							_snake_case   (	self			,     _lowerCAmelCase			,     _lowerCAmelCase = False			,     _lowerCAmelCase = False			,     _lowerCAmelCase = None			,     _lowerCAmelCase = False			,     _lowerCAmelCase = None			,     _lowerCAmelCase = None			,     _lowerCAmelCase = None			,     **_lowerCAmelCase			,     )    ->							BatchFeature:
     _lowerCAmelCase				=      isinstance(_lowerCAmelCase			,     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}'''		)
     _lowerCAmelCase				=      is_batched_numpy or (
         isinstance(_lowerCAmelCase			,     (list, tuple)		) and (isinstance(speech[0]			,     (np.ndarray, tuple, list)		))
     )

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

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

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

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

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

     _lowerCAmelCase				=      feature_size_hack

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

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

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

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

     return padded_inputs





 def 							_snake_case   (	self		)    ->							Dict[str, Any]:
     _lowerCAmelCase				=      super().to_dict()

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

     return output









'''simple docstring'''


_SCREAMING_SNAKE_CASE	 =							range(2, 20 + 1)
_SCREAMING_SNAKE_CASE	 =							[10**k for k in range(ks[-1] + 1)]
_SCREAMING_SNAKE_CASE	 =							{}


def 	__a(SCREAMING_SNAKE_CASE_  :					Tuple		,       SCREAMING_SNAKE_CASE_  :					str		,       SCREAMING_SNAKE_CASE_  :					Any		,       SCREAMING_SNAKE_CASE_  :					List[str]    ):



    '''simple docstring'''





    _lowerCAmelCase				=      sum(a_i[j] for j in range(SCREAMING_SNAKE_CASE_		,       len(SCREAMING_SNAKE_CASE_    )    )    )
    _lowerCAmelCase				=      sum(a_i[j] * base[j] for j in range(min(len(SCREAMING_SNAKE_CASE_    )		,       SCREAMING_SNAKE_CASE_    )    )    )

    _lowerCAmelCase			,			_lowerCAmelCase				=      0, 0
    _lowerCAmelCase				=      n - i

    _lowerCAmelCase				=      memo.get(SCREAMING_SNAKE_CASE_    )

    if sub_memo is not None:
        _lowerCAmelCase				=      sub_memo.get(SCREAMING_SNAKE_CASE_    )

        if jumps is not None and len(SCREAMING_SNAKE_CASE_    ) > 0:
            # find and make the largest jump without going over
            _lowerCAmelCase				=      -1
            for _k in range(len(SCREAMING_SNAKE_CASE_    ) - 1		,       -1		,       -1    ):
                if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
                    _lowerCAmelCase				=      _k
                    break

            if max_jump >= 0:
                _lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase				=      jumps[max_jump]
                # since the difference between jumps is cached, add c
                _lowerCAmelCase				=      diff + c
                for j in range(min(SCREAMING_SNAKE_CASE_		,       len(SCREAMING_SNAKE_CASE_    )    )    ):
                    _lowerCAmelCase			,			_lowerCAmelCase				=      divmod(SCREAMING_SNAKE_CASE_		,       10    )
                if new_c > 0:
                    add(SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_    )

        else:
            _lowerCAmelCase				=      []
    else:
        _lowerCAmelCase				=      {c: []}
        _lowerCAmelCase				=      sub_memo

    if dn >= max_dn or c + diff >= base[k]:
        return diff, dn

    if k > ks[0]:
        while True:
            # keep doing smaller jumps
            _lowerCAmelCase			,			_lowerCAmelCase				=      next_term(SCREAMING_SNAKE_CASE_		,       k - 1		,       i + dn		,       SCREAMING_SNAKE_CASE_    )
            diff += _diff
            dn += terms_jumped

            if dn >= max_dn or c + diff >= base[k]:
                break
    else:
        # would be too small a jump, just compute sequential terms instead
        _lowerCAmelCase			,			_lowerCAmelCase				=      compute(SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_		,       i + dn		,       SCREAMING_SNAKE_CASE_    )
        diff += _diff
        dn += terms_jumped

    _lowerCAmelCase				=      sub_memo[c]

    # keep jumps sorted by # of terms skipped
    _lowerCAmelCase				=      0
    while j < len(SCREAMING_SNAKE_CASE_    ):
        if jumps[j][1] > dn:
            break
        j += 1

    # cache the jump for this value digitsum(b) and c
    sub_memo[c].insert(SCREAMING_SNAKE_CASE_		,       (diff, dn, k)    )
    return (diff, dn)


def 	__a(SCREAMING_SNAKE_CASE_  :					Dict		,       SCREAMING_SNAKE_CASE_  :					int		,       SCREAMING_SNAKE_CASE_  :					Dict		,       SCREAMING_SNAKE_CASE_  :					Union[str, Any]    ):



    '''simple docstring'''





    if i >= n:
        return 0, i
    if k > len(SCREAMING_SNAKE_CASE_    ):
        a_i.extend([0 for _ in range(k - len(SCREAMING_SNAKE_CASE_    )    )]    )

    # note: a_i -> b * 10^k + c
    # ds_b -> digitsum(b)
    # ds_c -> digitsum(c)
    _lowerCAmelCase				=      i
    _lowerCAmelCase			,			_lowerCAmelCase			,			_lowerCAmelCase				=      0, 0, 0
    for j in range(len(SCREAMING_SNAKE_CASE_    )    ):
        if j >= k:
            ds_b += a_i[j]
        else:
            ds_c += a_i[j]

    while i < n:
        i += 1
        _lowerCAmelCase				=      ds_c + ds_b
        diff += addend
        _lowerCAmelCase				=      0
        for j in range(SCREAMING_SNAKE_CASE_    ):
            _lowerCAmelCase				=      a_i[j] + addend
            _lowerCAmelCase			,			_lowerCAmelCase				=      divmod(SCREAMING_SNAKE_CASE_		,       10    )

            ds_c += a_i[j]

        if addend > 0:
            break

    if addend > 0:
        add(SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_		,       SCREAMING_SNAKE_CASE_    )
    return diff, i - start_i


def 	__a(SCREAMING_SNAKE_CASE_  :					List[Any]		,       SCREAMING_SNAKE_CASE_  :					int		,       SCREAMING_SNAKE_CASE_  :					Any    ):



    '''simple docstring'''





    for j in range(SCREAMING_SNAKE_CASE_		,       len(SCREAMING_SNAKE_CASE_    )    ):
        _lowerCAmelCase				=      digits[j] + addend
        if s >= 10:
            _lowerCAmelCase			,			_lowerCAmelCase				=      divmod(SCREAMING_SNAKE_CASE_		,       10    )
            _lowerCAmelCase				=      addend // 10 + quotient
        else:
            _lowerCAmelCase				=      s
            _lowerCAmelCase				=      addend // 10

        if addend == 0:
            break

    while addend > 0:
        _lowerCAmelCase			,			_lowerCAmelCase				=      divmod(SCREAMING_SNAKE_CASE_		,       10    )
        digits.append(SCREAMING_SNAKE_CASE_    )


def 	__a(SCREAMING_SNAKE_CASE_  :					int = 10**15    ):



    '''simple docstring'''





    _lowerCAmelCase				=      [1]
    _lowerCAmelCase				=      1
    _lowerCAmelCase				=      0
    while True:
        _lowerCAmelCase			,			_lowerCAmelCase				=      next_term(SCREAMING_SNAKE_CASE_		,       20		,       i + dn		,       SCREAMING_SNAKE_CASE_    )
        dn += terms_jumped
        if dn == n - i:
            break

    _lowerCAmelCase				=      0
    for j in range(len(SCREAMING_SNAKE_CASE_    )    ):
        a_n += digits[j] * 10**j
    return a_n


if __name__ == "__main__":
       print(f'''{solution() = }''')


