





from typing import List, Optional, Union

import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


lowerCAmelCase_    =				logging.get_logger(__name__)



class 					__lowerCAmelCase       (			_a     ):
			lowerCamelCase_     :     Any       			=      ['''input_features''', '''attention_mask''']






			def __init__(self					,							__magic_name__=80					,							__magic_name__=1_6000					,							__magic_name__=80					,							__magic_name__=0.0					,							__magic_name__=True					,							__magic_name__=True					,							__magic_name__=True					,							**__magic_name__					,							)     ->   Optional[Any]:


							'''simple docstring'''



							super().__init__(feature_size=__magic_name__					,							sampling_rate=__magic_name__					,							padding_value=__magic_name__					,							**__magic_name__    )
							snake_case_						:    Union[str, Any]				=  num_mel_bins
							snake_case_						:    Optional[Any]				=  do_ceptral_normalize
							snake_case_						:    List[Any]				=  normalize_means
							snake_case_						:    str				=  normalize_vars
							snake_case_						:    Optional[Any]				=  True






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


							'''simple docstring'''



							snake_case_						:    List[Any]				=  waveform * (2**15)  # Kaldi compliance: 16-bit signed integers
							snake_case_						:    Tuple				=  torch.from_numpy(__magic_name__    ).unsqueeze(0    )
							snake_case_						:    str				=  ta_kaldi.fbank(__magic_name__					,							num_mel_bins=self.num_mel_bins					,							sample_frequency=self.sampling_rate    )
							return features.numpy()






			@staticmethod
			def 			lowerCamelCase  (__magic_name__					,							__magic_name__					,							__magic_name__ = True					,							__magic_name__ = True					,							__magic_name__ = 0.0					,							)     ->   np.ndarray:


							'''simple docstring'''



							if normalize_means:
											snake_case_						:    Optional[int]				=  x[:input_length].mean(axis=0    )
											snake_case_						:    Optional[int]				=  np.subtract(__magic_name__					,							__magic_name__    )
							if normalize_vars:
											snake_case_						:    Optional[int]				=  x[:input_length].std(axis=0    )
											snake_case_						:    Optional[Any]				=  np.divide(__magic_name__					,							__magic_name__    )

							if input_length < x.shape[0]:
											snake_case_						:    List[str]				=  padding_value

							# make sure array is in float32
							snake_case_						:    Dict				=  x.astype(np.floataa    )

							return x






			def 			lowerCamelCase  (self					,							__magic_name__					,							__magic_name__ = None    )     ->   List[np.ndarray]:


							'''simple docstring'''



							snake_case_						:    Dict				=  attention_mask.sum(-1    ) if attention_mask is not None else [x.shape[0] for x in input_features]
							return [
							    self.utterance_cmvn(__magic_name__					,							__magic_name__					,							self.normalize_means					,							self.normalize_vars					,							self.padding_value    )
							    for x, n in zip(__magic_name__					,							__magic_name__    )
							]






			def __call__(self					,							__magic_name__					,							__magic_name__ = False					,							__magic_name__ = None					,							__magic_name__ = False					,							__magic_name__ = None					,							__magic_name__ = None					,							__magic_name__ = None					,							__magic_name__ = None					,							**__magic_name__					,							)     ->   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} was trained using a sampling rate of'''
															    F''' {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with'''
															    F''' {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_						:    List[str]				=  isinstance(__magic_name__					,							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_						:    int				=  is_batched_numpy or (
							    isinstance(__magic_name__					,							(list, tuple)    ) and (isinstance(raw_speech[0]					,							(np.ndarray, tuple, list)    ))
							)

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

							# always return batch
							if not is_batched:
											snake_case_						:    Union[str, Any]				=  [raw_speech]

							# extract fbank features
							snake_case_						:    List[str]				=  [self._extract_fbank_features(__magic_name__    ) for waveform in raw_speech]

							# convert into correct format for padding
							snake_case_						:    Dict				=  BatchFeature({'''input_features''': features}    )

							snake_case_						:    List[Any]				=  self.pad(
							    __magic_name__					,							padding=__magic_name__					,							max_length=__magic_name__					,							truncation=__magic_name__					,							pad_to_multiple_of=__magic_name__					,							return_attention_mask=__magic_name__					,							**__magic_name__					,							)

							# make sure list is in array format
							snake_case_						:    Tuple				=  padded_inputs.get('''input_features'''    )
							if isinstance(input_features[0]					,							__magic_name__    ):
											snake_case_						:    str				=  [np.asarray(__magic_name__					,							dtype=np.floataa    ) for feature in input_features]

							snake_case_						:    Optional[int]				=  padded_inputs.get('''attention_mask'''    )
							if attention_mask is not None:
											snake_case_						:    int				=  [np.asarray(__magic_name__					,							dtype=np.intaa    ) for array in attention_mask]

							# Utterance-level cepstral mean and variance normalization
							if self.do_ceptral_normalize:
											snake_case_						:    Optional[int]				=  (
											    np.array(__magic_name__					,							dtype=np.intaa    )
											    if self._get_padding_strategies(__magic_name__					,							max_length=__magic_name__    ) is not PaddingStrategy.DO_NOT_PAD
											    else None
											)
											snake_case_						:    List[Any]				=  self.normalize(
											    padded_inputs['''input_features''']					,							attention_mask=__magic_name__    )

							if return_tensors is not None:
											snake_case_						:    Any				=  padded_inputs.convert_to_tensors(__magic_name__    )

							return padded_inputs







def      lowerCamelCase_						(				_UpperCamelCase ,				_UpperCamelCase )		->						str:






				"""simple docstring"""


				return "\n".join(
				    f'''{number} * {i} = {number * i}''' for i in range(1 ,				number_of_terms + 1 ) )


if __name__ == "__main__":
	print(multiplication_table(number=5, number_of_terms=1_0))
