
"""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__          = logging.get_logger(__name__)

class       lowerCAmelCase__				(						A_	):
     __a						=					["""input_values""", """attention_mask"""]







     def __init__(							self			:			str    ,      _lowerCamelCase			:			int = 1    ,      _lowerCamelCase			:			int = 16000    ,      _lowerCamelCase			:			float = 0.0    ,      _lowerCamelCase			:			bool = False    ,      _lowerCamelCase			:			int = 80    ,      _lowerCamelCase			:			int = 16    ,      _lowerCamelCase			:			int = 64    ,      _lowerCamelCase			:			str = "hann_window"    ,      _lowerCamelCase			:			float = 1.0    ,      _lowerCamelCase			:			float = 80    ,      _lowerCamelCase			:			float = 7600    ,      _lowerCamelCase			:			float = 1e-10    ,      _lowerCamelCase			:			int = 2    ,      _lowerCamelCase			:			bool = True    ,      **_lowerCamelCase			:			Any    ,      ):
       super().__init__(feature_size=_lowerCamelCase    ,      sampling_rate=_lowerCamelCase    ,      padding_value=_lowerCamelCase    ,      **_lowerCamelCase			)
       _snake_case					     =       do_normalize
       _snake_case					     =       return_attention_mask

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

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

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

       _snake_case					     =       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      lowercase	(							_lowerCamelCase			:			List[np.ndarray]    ,      _lowerCamelCase			:			List[np.ndarray]    ,      _lowerCamelCase			:			float = 0.0			):
       if attention_mask is not None:
         _snake_case					     =       np.array(_lowerCamelCase    ,      np.intaa			)
         _snake_case					     =       []

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

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

       return normed_input_values







     def      lowercase	(							self			:			Union[str, Any]    ,      _lowerCamelCase			:			np.ndarray    ,      ):
       _snake_case					     =       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			:			List[str]    ,      _lowerCamelCase			:			Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None    ,      _lowerCamelCase			:			Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None    ,      _lowerCamelCase			:			Union[bool, str, PaddingStrategy] = False    ,      _lowerCamelCase			:			Optional[int] = None    ,      _lowerCamelCase			:			bool = False    ,      _lowerCamelCase			:			Optional[int] = None    ,      _lowerCamelCase			:			Optional[bool] = None    ,      _lowerCamelCase			:			Optional[Union[str, TensorType]] = None    ,      _lowerCamelCase			:			Optional[int] = None    ,      **_lowerCamelCase			:			Tuple    ,      ):
       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:
         _snake_case					     =       self._process_audio(
             _lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase    ,      _lowerCamelCase    ,      **_lowerCamelCase    ,      )
       else:
         _snake_case					     =       None

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

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

       return inputs







     def      lowercase	(							self			:			Union[str, Any]    ,      _lowerCamelCase			:			Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]    ,      _lowerCamelCase			:			bool = False    ,      _lowerCamelCase			:			Union[bool, str, PaddingStrategy] = False    ,      _lowerCamelCase			:			Optional[int] = None    ,      _lowerCamelCase			:			bool = False    ,      _lowerCamelCase			:			Optional[int] = None    ,      _lowerCamelCase			:			Optional[bool] = None    ,      _lowerCamelCase			:			Optional[Union[str, TensorType]] = None    ,      **_lowerCamelCase			:			Optional[int]    ,      ):
       _snake_case					     =       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}'''			)
       _snake_case					     =       is_batched_numpy or (
           isinstance(_lowerCamelCase    ,      (list, tuple)			) and (isinstance(speech[0]    ,      (np.ndarray, tuple, list)			))
       )

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

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

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

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

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

       _snake_case					     =       feature_size_hack

       # convert input values to correct format
       _snake_case					     =       padded_inputs['''input_values''']
       if not isinstance(input_values[0]    ,      np.ndarray			):
         _snake_case					     =       [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			)
       ):
         _snake_case					     =       [array.astype(np.floataa			) for array in input_values]
       elif isinstance(_lowerCamelCase    ,      np.ndarray			) and input_values.dtype is np.dtype(np.floataa			):
         _snake_case					     =       input_values.astype(np.floataa			)

       # convert attention_mask to correct format
       _snake_case					     =       padded_inputs.get('''attention_mask'''			)
       if attention_mask is not None:
         _snake_case					     =       [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:
         _snake_case					     =       (
             attention_mask
             if self._get_padding_strategies(_lowerCamelCase    ,      max_length=_lowerCamelCase			) is not PaddingStrategy.DO_NOT_PAD
             else None
         )
         _snake_case					     =       self.zero_mean_unit_var_norm(
             padded_inputs['''input_values''']    ,      attention_mask=_lowerCamelCase    ,      padding_value=self.padding_value			)

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

       return padded_inputs







     def      lowercase	(							self			:			Optional[int]			):
       _snake_case					     =       super().to_dict()

       # Don't serialize these as they are derived from the other properties.
       _snake_case					     =       ['''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"""



from math import pow
def 					_UpperCAmelCase      ( __lowerCamelCase   :       int ,					__lowerCamelCase   :       int ,					__lowerCamelCase   :       int ,					__lowerCamelCase   :       int ,					__lowerCamelCase   :       int ,					)     ->					tuple[int, int]:
  if current_sum == needed_sum:
    # If the sum of the powers is equal to needed_sum, then we have a solution.
    solutions_count += 1
    return current_sum, solutions_count

  _snake_case					     =       int(pow(__lowerCamelCase ,					__lowerCamelCase		)		)
  if current_sum + i_to_n <= needed_sum:
    # If the sum of the powers is less than needed_sum, then continue adding powers.
    current_sum += i_to_n
    _snake_case     ,					_snake_case					     =       backtrack(
        __lowerCamelCase ,					__lowerCamelCase ,					current_number + 1 ,					__lowerCamelCase ,					__lowerCamelCase		)
    current_sum -= i_to_n
  if i_to_n < needed_sum:
    # If the power of i is less than needed_sum, then try with the next power.
    _snake_case     ,					_snake_case					     =       backtrack(
        __lowerCamelCase ,					__lowerCamelCase ,					current_number + 1 ,					__lowerCamelCase ,					__lowerCamelCase		)
  return current_sum, solutions_count
def 					_UpperCAmelCase      ( __lowerCamelCase   :       int ,					__lowerCamelCase   :       int		)     ->					int:
  if not (1 <= needed_sum <= 10_00 and 2 <= power <= 10):
    raise ValueError(
        '''Invalid input\n'''
        '''needed_sum must be between 1 and 1000, power between 2 and 10.'''		)

  return backtrack(__lowerCamelCase ,					__lowerCamelCase ,					1 ,					0 ,					0		)[1]  # Return the solutions_count


if __name__ == "__main__":
 import doctest

 doctest.testmod()



