


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


_snake_case					:		List[str]   =    logging.get_logger(__name__)

class     a		(__lowercase				):




							"""simple docstring"""


							__UpperCAmelCase   :							List[str]					  =  ["input_features"]

							def __init__(							self	:  Optional[Any]   ,     lowerCamelCase	:  Union[str, Any]=80   ,     lowerCamelCase	:  Union[str, Any]=16000   ,     lowerCamelCase	:  List[Any]=160   ,     lowerCamelCase	:  Dict=30   ,     lowerCamelCase	:  Optional[int]=400   ,     lowerCamelCase	:  str=0.0   ,     lowerCamelCase	:  Tuple=False   ,     **lowerCamelCase	:  str   ,     )     ->   List[str]:
														super().__init__(
														    feature_size=_a   ,     sampling_rate=_a   ,     padding_value=_a   ,     return_attention_mask=_a   ,     **_a   ,     )
														__snake_case		:      List[Any]										=       n_fft
														__snake_case		:      int										=       hop_length
														__snake_case		:      Optional[Any]										=       chunk_length
														__snake_case		:      Optional[int]										=       chunk_length * sampling_rate
														__snake_case		:      Union[str, Any]										=       self.n_samples // hop_length
														__snake_case		:      Dict										=       sampling_rate
														__snake_case		:      str										=       mel_filter_bank(
														    num_frequency_bins=1 + n_fft // 2   ,     num_mel_filters=_a   ,     min_frequency=0.0   ,     max_frequency=8000.0   ,     sampling_rate=_a   ,     norm="slaney"   ,     mel_scale="slaney"   ,     )

							def    __snake_case (							self	:  List[Any]   ,     lowerCamelCase	:  Dict    )     ->   np.ndarray:
														__snake_case		:      Union[str, Any]										=       spectrogram(
														    _a   ,     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"   ,     )
														__snake_case		:      Any										=       log_spec[:, :-1]
														__snake_case		:      Optional[Any]										=       np.maximum(_a   ,     log_spec.max() - 8.0    )
														__snake_case		:      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    __snake_case (							lowerCamelCase	:  Any   ,     lowerCamelCase	:  Optional[Any]   ,     lowerCamelCase	:  List[str] = 0.0    )     ->   List[np.ndarray]:
														if attention_mask is not None:
																					__snake_case		:      str										=       np.array(_a   ,     np.intaa    )
																					__snake_case		:      Tuple										=       []

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

																												normed_input_values.append(_a    )
														else:
																					__snake_case		:      Union[str, Any]										=       [(x - x.mean()) / np.sqrt(x.var() + 1E-7    ) for x in input_values]

														return normed_input_values

							def __call__(							self	:  Any   ,     lowerCamelCase	:  Optional[Any]   ,     lowerCamelCase	:  Any = True   ,     lowerCamelCase	:  List[str] = None   ,     lowerCamelCase	:  List[Any] = None   ,     lowerCamelCase	:  Union[str, Any] = None   ,     lowerCamelCase	:  Optional[int] = "max_length"   ,     lowerCamelCase	:  List[Any] = None   ,     lowerCamelCase	:  Optional[Any] = None   ,     lowerCamelCase	:  Any = None   ,     **lowerCamelCase	:  Tuple   ,     )     ->   BatchFeature:

														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."    )

														__snake_case		:      str										=       isinstance(_a   ,     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}'    )
														__snake_case		:      List[str]										=       is_batched_numpy or (
														    isinstance(_a   ,     (list, tuple)    ) and (isinstance(raw_speech[0]   ,     (np.ndarray, tuple, list)    ))
														)

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

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

														__snake_case		:      str										=       BatchFeature({"input_features": raw_speech}    )

														# convert into correct format for padding

														__snake_case		:      Any										=       self.pad(
														    _a   ,     padding=_a   ,     max_length=max_length if max_length else self.n_samples   ,     truncation=_a   ,     pad_to_multiple_of=_a   ,     return_attention_mask=return_attention_mask or do_normalize   ,     )

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

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

														__snake_case		:      Optional[Any]										=       [self._np_extract_fbank_features(_a    ) for waveform in input_features[0]]

														if isinstance(input_features[0]   ,     _a    ):
																					__snake_case		:      Dict										=       [np.asarray(_a   ,     dtype=np.floataa    ) for feature in input_features]
														else:
																					__snake_case		:      Dict										=       input_features

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

														if return_tensors is not None:
																					__snake_case		:      Optional[Any]										=       padded_inputs.convert_to_tensors(_a    )

														return padded_inputs






							def    __snake_case (							self	:  List[Any]    )     ->   Dict[str, Any]:
														__snake_case		:      str										=       copy.deepcopy(self.__dict__    )
														__snake_case		:      int										=       self.__class__.__name__
														if "mel_filters" in output:
																					del output["mel_filters"]
														return output





from __future__ import annotations

from functools import lru_cache
from math import ceil

_snake_case					:		Tuple      =    100

_snake_case					:		int      =    set(range(3, NUM_PRIMES, 2))
primes.add(2)
_snake_case					:		int

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_0_0     )
def     lowerCAmelCase_					( __lowerCamelCase     ):
							if number_to_partition < 0:
														return set()
							elif number_to_partition == 0:
														return {1}

							__snake_case		:      set[int]										=       set()
							__snake_case		:      int
							__snake_case		:      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     lowerCAmelCase_					( __lowerCamelCase = 5_0_0_0     ):
							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() = }''')

