



'''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				:    Union[str, Any]     						=logging.get_logger(__name__)



class 		lowerCamelCase__      (						A     ):




					'''simple docstring'''



					A_						    =						["""input_features"""]




					def __init__(  self				:	Optional[int]     ,  UpperCamelCase_				:	Union[str, Any]=80     ,  UpperCamelCase_				:	Optional[int]=1_6000     ,  UpperCamelCase_				:	Dict=160     ,  UpperCamelCase_				:	Dict=30     ,  UpperCamelCase_				:	Optional[Any]=400     ,  UpperCamelCase_				:	int=0.0     ,  UpperCamelCase_				:	Tuple=False     ,  **UpperCamelCase_				:	Optional[Any]     ,  )  ->       Optional[Any]:



						'''simple docstring'''





						super().__init__(
						    feature_size=UpperCamelCase_     ,  sampling_rate=UpperCamelCase_     ,  padding_value=UpperCamelCase_     ,  return_attention_mask=UpperCamelCase_     ,  **UpperCamelCase_     ,  )
						_lowercase					:       List[str]       =		n_fft
						_lowercase					:       List[Any]       =		hop_length
						_lowercase					:       Optional[Any]       =		chunk_length
						_lowercase					:       Optional[int]       =		chunk_length * sampling_rate
						_lowercase					:       List[Any]       =		self.n_samples // hop_length
						_lowercase					:       List[Any]       =		sampling_rate
						_lowercase					:       Optional[Any]       =		mel_filter_bank(
						    num_frequency_bins=1 + n_fft // 2     ,  num_mel_filters=UpperCamelCase_     ,  min_frequency=0.0     ,  max_frequency=80_00.0     ,  sampling_rate=UpperCamelCase_     ,  norm='slaney'     ,  mel_scale='slaney'     ,  )




					def 						__UpperCAmelCase     (  self				:	Optional[int]     ,  UpperCamelCase_				:	np.array					)  ->       np.ndarray:



						'''simple docstring'''





						_lowercase					:       Optional[int]       =		spectrogram(
						    UpperCamelCase_     ,  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'     ,  )
						_lowercase					:       Union[str, Any]       =		log_spec[:, :-1]
						_lowercase					:       Dict       =		np.maximum(UpperCamelCase_     ,  log_spec.max() - 8.0					)
						_lowercase					:       Tuple       =		(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 						__UpperCAmelCase     (  UpperCamelCase_				:	List[np.ndarray]     ,  UpperCamelCase_				:	List[np.ndarray]     ,  UpperCamelCase_				:	float = 0.0					)  ->       List[np.ndarray]:



						'''simple docstring'''





						if attention_mask is not None:
							_lowercase					:       List[str]       =		np.array(UpperCamelCase_     ,  np.intaa					)
							_lowercase					:       Optional[Any]       =		[]

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

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

						return normed_input_values




					def __call__(  self				:	Tuple     ,  UpperCamelCase_				:	Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]     ,  UpperCamelCase_				:	bool = True     ,  UpperCamelCase_				:	Optional[int] = None     ,  UpperCamelCase_				:	Optional[Union[str, TensorType]] = None     ,  UpperCamelCase_				:	Optional[bool] = None     ,  UpperCamelCase_				:	Optional[str] = "max_length"     ,  UpperCamelCase_				:	Optional[int] = None     ,  UpperCamelCase_				:	Optional[int] = None     ,  UpperCamelCase_				:	Optional[bool] = None     ,  **UpperCamelCase_				:	int     ,  )  ->       BatchFeature:



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

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

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

						# always return batch
						if not is_batched:
							_lowercase					:       Tuple       =		[np.asarray([raw_speech]					).T]

						_lowercase					:       Dict       =		BatchFeature({'input_features': raw_speech}					)

						# convert into correct format for padding

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

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

						# make sure list is in array format
						_lowercase					:       str       =		padded_inputs.get('input_features'					).transpose(2     ,  0     ,  1					)

						_lowercase					:       List[Any]       =		[self._np_extract_fbank_features(UpperCamelCase_					) for waveform in input_features[0]]

						if isinstance(input_features[0]     ,  UpperCamelCase_					):
							_lowercase					:       Any       =		[np.asarray(UpperCamelCase_     ,  dtype=np.floataa					) for feature in input_features]
						else:
							_lowercase					:       List[str]       =		input_features

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

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

						return padded_inputs




					def 						__UpperCAmelCase     (  self				:	Dict					)  ->       Dict[str, Any]:



						'''simple docstring'''





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





'''simple docstring'''

def 						__UpperCamelCase				(							_lowercase					) ->			bool:
	return str(_lowercase					) == str(_lowercase					)[::-1]







def 						__UpperCamelCase				(							_lowercase					) ->			int:
	return int(_lowercase					) + int(str(_lowercase					)[::-1]					)







def 						__UpperCamelCase				(							_lowercase = 1_0000					) ->			int:
	_lowercase					:       List[str]       =		[]
	for num in range(1,				_lowercase					):
		_lowercase					:       Tuple       =		0
		_lowercase					:       Tuple       =		num
		while iterations < 50:
			_lowercase					:       Union[str, Any]       =		sum_reverse(_lowercase					)
			iterations += 1
			if is_palindrome(_lowercase					):
				break
		else:
			lychrel_nums.append(_lowercase					)
	return len(_lowercase					)


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