

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


_lowerCAmelCase					:			str  				=			logging.get_logger(__name__)






class 	__magic_name__    (			lowerCAmelCase_      ):
			SCREAMING_SNAKE_CASE							   =						['input_features']





			def __init__(		self					,  __snake_case=80					,  __snake_case=1_6000					,  __snake_case=160					,  __snake_case=30					,  __snake_case=400					,  __snake_case=0.0					,  __snake_case=False					,  **__snake_case					,  )   -> Dict:




						'''simple docstring'''
						super().__init__(
						    feature_size=__snake_case					,  sampling_rate=__snake_case					,  padding_value=__snake_case					,  return_attention_mask=__snake_case					,  **__snake_case					,  )
						__a        =n_fft
						__a        =hop_length
						__a        =chunk_length
						__a        =chunk_length * sampling_rate
						__a        =self.n_samples // hop_length
						__a        =sampling_rate
						__a        =mel_filter_bank(
						    num_frequency_bins=1 + n_fft // 2					,  num_mel_filters=__snake_case					,  min_frequency=0.0					,  max_frequency=8000.0					,  sampling_rate=__snake_case					,  norm='slaney'					,  mel_scale='slaney'					,  )





			def 		__magic_name__    (		self					,  __snake_case					)   -> np.ndarray:




						'''simple docstring'''
						__a        =spectrogram(
						    __snake_case					,  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'					,  )
						__a        =log_spec[:, :-1]
						__a        =np.maximum(__snake_case					,  log_spec.max() - 8.0					)
						__a        =(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 		__magic_name__    (		__snake_case					,  __snake_case					,  __snake_case = 0.0					)   -> List[np.ndarray]:




						'''simple docstring'''
						if attention_mask is not None:
									__a        =np.array(__snake_case					,  np.intaa					)
									__a        =[]

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

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

						return normed_input_values





			def __call__(		self					,  __snake_case					,  __snake_case = True					,  __snake_case = None					,  __snake_case = None					,  __snake_case = None					,  __snake_case = "max_length"					,  __snake_case = None					,  __snake_case = None					,  __snake_case = None					,  **__snake_case					,  )   -> 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.'					)

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

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

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

						__a        =BatchFeature({'input_features': raw_speech}					)

						# convert into correct format for padding

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

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

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

						__a        =[self._np_extract_fbank_features(__snake_case					) for waveform in input_features[0]]

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

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

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

						return padded_inputs





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




						'''simple docstring'''
						__a        =copy.deepcopy(self.__dict__					)
						__a        =self.__class__.__name__
						if "mel_filters" in output:
									del output["mel_filters"]
						return output









from __future__ import annotations






def        UpperCamelCase_(							_snake_case   :  int	):




			"""simple docstring"""






			__a        =str(_snake_case	)
			return len(_snake_case	) == 9 and set(_snake_case	) == set('123456789'	)






def        UpperCamelCase_(							):




			"""simple docstring"""






			for base_num in range(9999       ,     4999       ,     -1	):
						__a        =100002 * base_num
						if is_9_pandigital(_snake_case	):
									return candidate

			for base_num in range(333       ,     99       ,     -1	):
						__a        =1002003 * base_num
						if is_9_pandigital(_snake_case	):
									return candidate

			return None


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






