

"""simple docstring"""
import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

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


_A							=  logging.get_logger(__name__)

class       lowerCamelCase	(       lowerCAmelCase__   ):


  '''simple docstring'''







  SCREAMING_SNAKE_CASE					      =  ['input_features']



  def __init__(self							,       _lowerCamelCase=80							,       _lowerCamelCase=16000							,       _lowerCamelCase=160							,       _lowerCamelCase=30							,       _lowerCamelCase=400							,       _lowerCamelCase=0.0							,       _lowerCamelCase=False							,       **_lowerCamelCase							,       ):


        """simple docstring"""

        super().__init__(
            feature_size=_lowerCamelCase							,       sampling_rate=_lowerCamelCase							,       padding_value=_lowerCamelCase							,       return_attention_mask=_lowerCamelCase							,       **_lowerCamelCase							,       )
        UpperCAmelCase__			:							List[Any]							=    n_fft
        UpperCAmelCase__			:							int							=    hop_length
        UpperCAmelCase__			:							Any							=    chunk_length
        UpperCAmelCase__			:							str							=    chunk_length * sampling_rate
        UpperCAmelCase__			:							Tuple							=    self.n_samples // hop_length
        UpperCAmelCase__			:							Optional[Any]							=    sampling_rate
        UpperCAmelCase__			:							Optional[int]							=    mel_filter_bank(
            num_frequency_bins=1 + n_fft // 2							,       num_mel_filters=_lowerCamelCase							,       min_frequency=0.0							,       max_frequency=8_000.0							,       sampling_rate=_lowerCamelCase							,       norm="""slaney"""							,       mel_scale="""slaney"""							,       )



  def  _a      (self							,       _lowerCamelCase	):


        """simple docstring"""

        UpperCAmelCase__			:							int							=    spectrogram(
            _lowerCamelCase							,       window_function(self.n_fft							,       """hann"""	)							,       frame_length=self.n_fft							,       hop_length=self.hop_length							,       power=2.0							,       mel_filters=self.mel_filters							,       log_mel="""log10"""							,       )
        UpperCAmelCase__			:							Tuple							=    log_spec[:, :-1]
        UpperCAmelCase__			:							List[Any]							=    np.maximum(_lowerCamelCase							,       log_spec.max() - 8.0	)
        UpperCAmelCase__			:							Optional[int]							=    (log_spec + 4.0) / 4.0
        return log_spec



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


        """simple docstring"""

        if attention_mask is not None:
              UpperCAmelCase__			:							Tuple							=    np.array(_lowerCamelCase							,       np.intaa	)
              UpperCAmelCase__			:							List[str]							=    []

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

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

        return normed_input_values



  def __call__(self							,       _lowerCamelCase							,       _lowerCamelCase = True							,       _lowerCamelCase = None							,       _lowerCamelCase = None							,       _lowerCamelCase = None							,       _lowerCamelCase = "max_length"							,       _lowerCamelCase = None							,       _lowerCamelCase = None							,       _lowerCamelCase = None							,       **_lowerCamelCase							,       ):


        """simple docstring"""

        if sampling_rate is not None:
              if sampling_rate != self.sampling_rate:
                    raise ValueError(
                        F"""The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"""
                        F""" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"""
                        F""" was sampled with {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."""	)

        UpperCAmelCase__			:							Dict							=    isinstance(_lowerCamelCase							,       np.ndarray	) and len(raw_speech.shape	) > 1
        if is_batched_numpy and len(raw_speech.shape	) > 2:
              raise ValueError(F"""Only mono-channel audio is supported for input to {self}"""	)
        UpperCAmelCase__			:							List[Any]							=    is_batched_numpy or (
            isinstance(_lowerCamelCase							,       (list, tuple)	) and (isinstance(raw_speech[0]							,       (np.ndarray, tuple, list)	))
        )

        if is_batched:
              UpperCAmelCase__			:							Tuple							=    [np.asarray([speech]							,       dtype=np.floataa	).T for speech in raw_speech]
        elif not is_batched and not isinstance(_lowerCamelCase							,       np.ndarray	):
              UpperCAmelCase__			:							Any							=    np.asarray(_lowerCamelCase							,       dtype=np.floataa	)
        elif isinstance(_lowerCamelCase							,       np.ndarray	) and raw_speech.dtype is np.dtype(np.floataa	):
              UpperCAmelCase__			:							List[str]							=    raw_speech.astype(np.floataa	)

        # always return batch
        if not is_batched:
              UpperCAmelCase__			:							Optional[Any]							=    [np.asarray([raw_speech]	).T]

        UpperCAmelCase__			:							Tuple							=    BatchFeature({"""input_features""": raw_speech}	)

        # convert into correct format for padding

        UpperCAmelCase__			:							Optional[Any]							=    self.pad(
            _lowerCamelCase							,       padding=_lowerCamelCase							,       max_length=max_length if max_length else self.n_samples							,       truncation=_lowerCamelCase							,       pad_to_multiple_of=_lowerCamelCase							,       return_attention_mask=return_attention_mask or do_normalize							,       )

        # zero-mean and unit-variance normalization
        if do_normalize:
              UpperCAmelCase__			:							Optional[int]							=    self.zero_mean_unit_var_norm(
                  padded_inputs["""input_features"""]							,       attention_mask=padded_inputs["""attention_mask"""]							,       padding_value=self.padding_value							,       )
              UpperCAmelCase__			:							List[str]							=    np.stack(padded_inputs["""input_features"""]							,       axis=0	)

        # make sure list is in array format
        UpperCAmelCase__			:							Dict							=    padded_inputs.get("""input_features"""	).transpose(2							,       0							,       1	)

        UpperCAmelCase__			:							Tuple							=    [self._np_extract_fbank_features(_lowerCamelCase	) for waveform in input_features[0]]

        if isinstance(input_features[0]							,       _lowerCamelCase	):
              UpperCAmelCase__			:							str							=    [np.asarray(_lowerCamelCase							,       dtype=np.floataa	) for feature in input_features]
        else:
              UpperCAmelCase__			:							Union[str, Any]							=    input_features

        if return_attention_mask:
              # rescale from sample (48000) to feature (3000)
              UpperCAmelCase__			:							Any							=    padded_inputs["""attention_mask"""][:, :: self.hop_length]

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

        return padded_inputs




  def  _a      (self	):


        """simple docstring"""

        UpperCAmelCase__			:							Optional[Any]							=    copy.deepcopy(self.__dict__	)
        UpperCAmelCase__			:							Any							=    self.__class__.__name__
        if "mel_filters" in output:
              del output["mel_filters"]
        return output




"""simple docstring"""
from __future__ import annotations

from functools import lru_cache
from math import ceil

_A							=  1_00

_A							=  set(range(3, NUM_PRIMES, 2))
primes.add(2)
_A							=  42

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
    if prime not in primes:
        continue
    primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))




@lru_cache(maxsize=1_00    )
def 					a__						(						lowerCAmelCase    )	-> set[int]:
      if number_to_partition < 0:
            return set()
      elif number_to_partition == 0:
            return {1}

      UpperCAmelCase__			:							set[int]							=    set()
      UpperCAmelCase__			:							int
      UpperCAmelCase__			:							int

      for prime in primes:
            if prime > number_to_partition:
                  continue
            for sub in partition(number_to_partition - prime    ):
                  ret.add(sub * prime    )

      return ret




def 					a__						(						lowerCAmelCase = 50_00    )	-> int | None:
      for number_to_partition in range(1			,	lowerCAmelCase    ):
            if len(partition(lowerCAmelCase    )    ) > number_unique_partitions:
                  return number_to_partition
      return None


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

