




"""simple docstring"""






from math import ceil
from typing import List, Optional, Union

import numpy as np

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


lowercase__			=		logging.get_logger(__name__)






class lowerCAmelCase__      (	UpperCAmelCase__		):






			'''simple docstring'''



			lowerCamelCase__ =     ["audio_values", "audio_mask"]
			def __init__(    self    , lowercase=2048    , lowercase=1    , lowercase=[16, 16]    , lowercase=128    , lowercase=44100    , lowercase=86    , lowercase=2048    , lowercase=0.0    , **lowercase    , ):
							super().__init__(
							    feature_size=lowercase    , sampling_rate=lowercase    , padding_value=lowercase    , **lowercase    , )

							_lowerCamelCase	:     int       =       spectrogram_length
							_lowerCamelCase	:     List[str]       =       num_channels
							_lowerCamelCase	:     Tuple       =       patch_size
							_lowerCamelCase	:     Dict       =       feature_size // self.patch_size[1]
							_lowerCamelCase	:     List[str]       =       n_fft
							_lowerCamelCase	:     Dict       =       sampling_rate // hop_length_to_sampling_rate
							_lowerCamelCase	:     List[str]       =       sampling_rate
							_lowerCamelCase	:     Union[str, Any]       =       padding_value
							_lowerCamelCase	:     Tuple       =       mel_filter_bank(
							    num_frequency_bins=1 + n_fft // 2    , num_mel_filters=lowercase    , min_frequency=0.0    , max_frequency=22050.0    , sampling_rate=lowercase    , norm='slaney'    , mel_scale='slaney'    , ).T
			def    A_       (    self    , lowercase    ):
							_lowerCamelCase	:     Optional[Any]       =       spectrogram(
							    lowercase    , window_function(self.n_fft    , 'hann'    )    , frame_length=self.n_fft    , hop_length=self.hop_length    , power=2.0    , mel_filters=self.mel_filters.T    , log_mel='dB'    , db_range=80.0    , )
							_lowerCamelCase	:     Union[str, Any]       =       log_spec[:, :-1]
							_lowerCamelCase	:     List[str]       =       log_spec - 20.0
							_lowerCamelCase	:     Optional[int]       =       np.clip(log_spec / 40.0    , -2.0    , 0.0    ) + 1.0
							return log_spec






			def __call__(    self    , lowercase    , lowercase = None    , lowercase = True    , lowercase = None    , lowercase = False    , lowercase = False    , **lowercase    , ):



							if sampling_rate is not None:
											if sampling_rate != self.sampling_rate:
															raise ValueError(
															    'This feature extractor is set to support sampling rate'
															    F''' of {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled'''
															    F''' 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.'    )

							_lowerCamelCase	:     Optional[int]       =       isinstance(lowercase    , 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}'''    )
							_lowerCamelCase	:     Optional[Any]       =       is_batched_numpy or (
							    isinstance(lowercase    , (list, tuple)    ) and (isinstance(raw_speech[0]    , (np.ndarray, tuple, list)    ))
							)
							if is_batched:
											_lowerCamelCase	:     Any       =       [np.asarray([speech]    , dtype=np.floataa    ).T for speech in raw_speech]
							elif not is_batched and not isinstance(lowercase    , np.ndarray    ):
											_lowerCamelCase	:     Tuple       =       np.asarray(lowercase    , dtype=np.floataa    )
							elif isinstance(lowercase    , np.ndarray    ) and raw_speech.dtype is np.dtype(np.floataa    ):
											_lowerCamelCase	:     List[Any]       =       raw_speech.astype(np.floataa    )
							# always return batch
							if not is_batched:
											_lowerCamelCase	:     Union[str, Any]       =       [np.asarray([raw_speech]    ).T]

							# Convert audio signals to log mel spectrograms, truncate by time axis
							_lowerCamelCase	:     Optional[int]       =       [
							    self._np_extract_fbank_features(waveform.squeeze()    ).T[: self.spectrogram_length] for waveform in raw_speech
							]
							if isinstance(audio_features[0]    , lowercase    ):
											_lowerCamelCase	:     Any       =       [np.asarray(lowercase    , dtype=np.floataa    ) for feature in audio_features]

							# Create audio attention mask
							_lowerCamelCase	:     str       =       max(
							    [ceil(feature.shape[0] / self.patch_size[0]    ) * self.freq_len for feature in audio_features]    )  # The maximum number of audio patches in a batch
							if return_attention_mask:
											_lowerCamelCase	:     Optional[int]       =       [
											    (ceil(feature.shape[0] / self.patch_size[0]    ) * self.freq_len) * [1]
											    + (max_patch_len - ceil(feature.shape[0] / self.patch_size[0]    ) * self.freq_len) * [0]
											    for feature in audio_features
											]
											_lowerCamelCase	:     Optional[Any]       =       np.array(lowercase    ).astype(np.floataa    )

							# convert into correct format for padding
							_lowerCamelCase	:     List[Any]       =       max_patch_len // self.freq_len * self.patch_size[0]  # The maximum audio size in a batch
							_lowerCamelCase	:     int       =       np.ones([len(lowercase    ), 1, max_time_len, self.feature_size]    ).astype(np.floataa    )
							_lowerCamelCase	:     Union[str, Any]       =       padded_audio_features * self.padding_value
							for i in range(len(lowercase    )    ):
											_lowerCamelCase	:     Optional[Any]       =       audio_features[i]
											_lowerCamelCase	:     Any       =       feature

							# return as BatchFeature
							if return_attention_mask:
											_lowerCamelCase	:     int       =       {'audio_values': padded_audio_features, 'audio_mask': audio_mask}
							else:
											_lowerCamelCase	:     Any       =       {'audio_values': padded_audio_features}

							_lowerCamelCase	:     int       =       BatchFeature(data=lowercase    , tensor_type=lowercase    )
							return encoded_inputs
'''simple docstring'''




def __lowerCAmelCase					(				)      ->       Optional[Any]:
    __lowerCamelCase            =    0
    for i in range(1							,    10_01							):
        total += i**i
    return str(UpperCamelCase__							)[-10:]


if __name__ == "__main__":
  print(solution())
