

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


SCREAMING_SNAKE_CASE							:				List[Any]     	=			logging.get_logger(__name__)






class    snake_case     (      lowercase_		):






				"""simple docstring"""
				_a    	=     ["""input_features"""]



				def __init__(    self,     _lowercase=80,     _lowercase=16000,     _lowercase=160,     _lowercase=30,     _lowercase=400,     _lowercase=0.0,     _lowercase=False,     **_lowercase,     )     ->							Tuple:
											super().__init__(
											    feature_size=_lowercase,     sampling_rate=_lowercase,     padding_value=_lowercase,     return_attention_mask=_lowercase,     **_lowercase,     )
											SCREAMING_SNAKE_CASE_				=				n_fft
											SCREAMING_SNAKE_CASE_				=				hop_length
											SCREAMING_SNAKE_CASE_				=				chunk_length
											SCREAMING_SNAKE_CASE_				=				chunk_length * sampling_rate
											SCREAMING_SNAKE_CASE_				=				self.n_samples // hop_length
											SCREAMING_SNAKE_CASE_				=				sampling_rate
											SCREAMING_SNAKE_CASE_				=				mel_filter_bank(
											    num_frequency_bins=1 + n_fft // 2,     num_mel_filters=_lowercase,     min_frequency=0.0,     max_frequency=8_000.0,     sampling_rate=_lowercase,     norm='slaney',     mel_scale='slaney',     )



				def   a__					(    self,     _lowercase       )     ->							np.ndarray:
											SCREAMING_SNAKE_CASE_				=				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,     log_mel='log10',     )
											SCREAMING_SNAKE_CASE_				=				log_spec[:, :-1]
											SCREAMING_SNAKE_CASE_				=				np.maximum(_lowercase,     log_spec.max() - 8.0       )
											SCREAMING_SNAKE_CASE_				=				(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   a__					(    _lowercase,     _lowercase,     _lowercase = 0.0       )     ->							List[np.ndarray]:
											if attention_mask is not None:
																		SCREAMING_SNAKE_CASE_				=				np.array(_lowercase,     np.intaa       )
																		SCREAMING_SNAKE_CASE_				=				[]

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

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

											return normed_input_values



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

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

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

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

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

											# convert into correct format for padding

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

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

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

											SCREAMING_SNAKE_CASE_				=				[self._np_extract_fbank_features(_lowercase       ) for waveform in input_features[0]]

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

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

											if return_tensors is not None:
																		SCREAMING_SNAKE_CASE_				=				padded_inputs.convert_to_tensors(_lowercase       )

											return padded_inputs





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








'''simple docstring'''

def 							_UpperCamelCase				(   lowerCAmelCase__:					int = 1000   )      -> int:
							SCREAMING_SNAKE_CASE_				=				2**power
							SCREAMING_SNAKE_CASE_				=				str(lowerCAmelCase__   )
							SCREAMING_SNAKE_CASE_				=				list(lowerCAmelCase__   )
							SCREAMING_SNAKE_CASE_				=				0

							for i in list_num:
														sum_of_num += int(lowerCAmelCase__   )

							return sum_of_num


if __name__ == "__main__":
							SCREAMING_SNAKE_CASE							:				Tuple     	=			int(input("Enter the power of 2: ").strip())
							print("2 ^ ", power, " = ", 2**power)
							SCREAMING_SNAKE_CASE							:				str     	=			solution(power)
							print("Sum of the digits is: ", result)





