

'''simple docstring'''





import warnings
from typing import Any, Dict, List, Optional, Union

import numpy as np

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


_UpperCAmelCase	:     Union[str, Any]		       = logging.get_logger(__name__)







class 				lowercase       ( lowercase_    ):
				__SCREAMING_SNAKE_CASE      :				Optional[int]     =    ['''input_values''', '''attention_mask''']




				def __init__(      self   ,     snake_case = 1   ,     snake_case = 1_6000   ,     snake_case = 0.0   ,     snake_case = False   ,     snake_case = 80   ,     snake_case = 16   ,     snake_case = 64   ,     snake_case = "hann_window"   ,     snake_case = 1.0   ,     snake_case = 80   ,     snake_case = 7600   ,     snake_case = 1e-1_0   ,     snake_case = 2   ,     snake_case = True   ,     **snake_case   ,     ):
											super().__init__(feature_size=UpperCamelCase__   ,     sampling_rate=UpperCamelCase__   ,     padding_value=UpperCamelCase__   ,     **UpperCamelCase__ )
											snake_case_           =					do_normalize
											snake_case_           =					return_attention_mask

											snake_case_           =					num_mel_bins
											snake_case_           =					hop_length
											snake_case_           =					win_length
											snake_case_           =					win_function
											snake_case_           =					frame_signal_scale
											snake_case_           =					fmin
											snake_case_           =					fmax
											snake_case_           =					mel_floor
											snake_case_           =					reduction_factor

											snake_case_           =					win_length * sampling_rate // 1000
											snake_case_           =					hop_length * sampling_rate // 1000
											snake_case_           =					optimal_fft_length(self.sample_size )
											snake_case_           =					(self.n_fft // 2) + 1

											snake_case_           =					window_function(window_length=self.sample_size   ,     name=self.win_function   ,     periodic=UpperCamelCase__ )

											snake_case_           =					mel_filter_bank(
											    num_frequency_bins=self.n_freqs   ,     num_mel_filters=self.num_mel_bins   ,     min_frequency=self.fmin   ,     max_frequency=self.fmax   ,     sampling_rate=self.sampling_rate   ,     norm='slaney'   ,     mel_scale='slaney'   ,     )

											if frame_signal_scale != 1.0:
																		warnings.warn(
																		    'The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers'   ,     UpperCamelCase__   ,     )
											if reduction_factor != 2.0:
																		warnings.warn(
																		    'The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers'   ,     UpperCamelCase__   ,     )




				@staticmethod
				# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
				def 					a							(      snake_case   ,     snake_case   ,     snake_case = 0.0 ):







											if attention_mask is not None:
																		snake_case_           =					np.array(UpperCamelCase__   ,     np.intaa )
																		snake_case_           =					[]

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

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

											return normed_input_values




				def 					a							(      self   ,     snake_case   ,     ):
											snake_case_           =					spectrogram(
											    UpperCamelCase__   ,     window=self.window   ,     frame_length=self.sample_size   ,     hop_length=self.sample_stride   ,     fft_length=self.n_fft   ,     mel_filters=self.mel_filters   ,     mel_floor=self.mel_floor   ,     log_mel='log10'   ,     )
											return log_mel_spec.T




				def __call__(      self   ,     snake_case = None   ,     snake_case = None   ,     snake_case = False   ,     snake_case = None   ,     snake_case = False   ,     snake_case = None   ,     snake_case = None   ,     snake_case = None   ,     snake_case = None   ,     **snake_case   ,     ):







											if audio is None and audio_target is None:
																		raise ValueError('You must provide either `audio` or `audio_target` values.' )

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

											if audio is not None:
																		snake_case_           =					self._process_audio(
																		    UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     **UpperCamelCase__   ,     )
											else:
																		snake_case_           =					None

											if audio_target is not None:
																		snake_case_           =					self._process_audio(
																		    UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     UpperCamelCase__   ,     **UpperCamelCase__   ,     )

																		if inputs is None:
																									return inputs_target
																		else:
																									snake_case_           =					inputs_target['input_values']
																									snake_case_           =					inputs_target.get('attention_mask' )
																									if decoder_attention_mask is not None:
																																snake_case_           =					decoder_attention_mask

											return inputs




				def 					a							(      self   ,     snake_case   ,     snake_case = False   ,     snake_case = False   ,     snake_case = None   ,     snake_case = False   ,     snake_case = None   ,     snake_case = None   ,     snake_case = None   ,     **snake_case   ,     ):
											snake_case_           =					isinstance(UpperCamelCase__   ,     np.ndarray ) and len(speech.shape ) > 1
											if is_batched_numpy and len(speech.shape ) > 2:
																		raise ValueError(F'''Only mono-channel audio is supported for input to {self}''' )
											snake_case_           =					is_batched_numpy or (
											    isinstance(UpperCamelCase__   ,     (list, tuple) ) and (isinstance(speech[0]   ,     (np.ndarray, tuple, list) ))
											)

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

											# always return batch
											if not is_batched:
																		snake_case_           =					[speech]

											# needed to make pad() work on spectrogram inputs
											snake_case_           =					self.feature_size

											# convert into correct format for padding
											if is_target:
																		snake_case_           =					[self._extract_mel_features(UpperCamelCase__ ) for waveform in speech]
																		snake_case_           =					BatchFeature({'input_values': features} )
																		snake_case_           =					self.num_mel_bins
											else:
																		snake_case_           =					BatchFeature({'input_values': speech} )

											snake_case_           =					self.pad(
											    UpperCamelCase__   ,     padding=UpperCamelCase__   ,     max_length=UpperCamelCase__   ,     truncation=UpperCamelCase__   ,     pad_to_multiple_of=UpperCamelCase__   ,     return_attention_mask=UpperCamelCase__   ,     **UpperCamelCase__   ,     )

											snake_case_           =					feature_size_hack

											# convert input values to correct format
											snake_case_           =					padded_inputs['input_values']
											if not isinstance(input_values[0]   ,     np.ndarray ):
																		snake_case_           =					[np.asarray(UpperCamelCase__   ,     dtype=np.floataa ) for array in input_values]
											elif (
											    not isinstance(UpperCamelCase__   ,     np.ndarray )
											    and isinstance(input_values[0]   ,     np.ndarray )
											    and input_values[0].dtype is np.dtype(np.floataa )
											):
																		snake_case_           =					[array.astype(np.floataa ) for array in input_values]
											elif isinstance(UpperCamelCase__   ,     np.ndarray ) and input_values.dtype is np.dtype(np.floataa ):
																		snake_case_           =					input_values.astype(np.floataa )

											# convert attention_mask to correct format
											snake_case_           =					padded_inputs.get('attention_mask' )
											if attention_mask is not None:
																		snake_case_           =					[np.asarray(UpperCamelCase__   ,     dtype=np.intaa ) for array in attention_mask]

											# zero-mean and unit-variance normalization
											if not is_target and self.do_normalize:
																		snake_case_           =					(
																		    attention_mask
																		    if self._get_padding_strategies(UpperCamelCase__   ,     max_length=UpperCamelCase__ ) is not PaddingStrategy.DO_NOT_PAD
																		    else None
																		)
																		snake_case_           =					self.zero_mean_unit_var_norm(
																		    padded_inputs['input_values']   ,     attention_mask=UpperCamelCase__   ,     padding_value=self.padding_value )

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

											return padded_inputs




				def 					a							(      self ):
											snake_case_           =					super().to_dict()

											# Don't serialize these as they are derived from the other properties.
											snake_case_           =					['window', 'mel_filters', 'sample_size', 'sample_stride', 'n_fft', 'n_freqs']
											for name in names:
																		if name in output:
																									del output[name]

											return output







_UpperCAmelCase	:     str		       = [0, 2, 4, 6, 8]
_UpperCAmelCase	:     Any		       = [1, 3, 5, 7, 9]





def       __lowerCamelCase			(				UpperCamelCase__     ,							UpperCamelCase__     ,							UpperCamelCase__     ,							UpperCamelCase__   ):







							'''simple docstring'''






							if remaining_length == 0:
														if digits[0] == 0 or digits[-1] == 0:
																					return 0

														for i in range(length // 2 - 1     ,							-1     ,							-1   ):
																					remainder += digits[i] + digits[length - i - 1]

																					if remainder % 2 == 0:
																												return 0

																					remainder //= 10

														return 1

							if remaining_length == 1:
														if remainder % 2 == 0:
																					return 0

														snake_case_           =					0
														for digit in range(10   ):
																					snake_case_           =					digit
																					result += reversible_numbers(
																					    0     ,							(remainder + 2 * digit) // 10     ,							UpperCamelCase__     ,							UpperCamelCase__   )
														return result

							snake_case_           =					0
							for digita in range(10   ):
														snake_case_           =					digita

														if (remainder + digita) % 2 == 0:
																					snake_case_           =					ODD_DIGITS
														else:
																					snake_case_           =					EVEN_DIGITS

														for digita in other_parity_digits:
																					snake_case_           =					digita
																					result += reversible_numbers(
																					    remaining_length - 2     ,							(remainder + digita + digita) // 10     ,							UpperCamelCase__     ,							UpperCamelCase__     ,							)
							return result





def       __lowerCamelCase			(				UpperCamelCase__ = 9   ):







							'''simple docstring'''






							snake_case_           =					0
							for length in range(1     ,							max_power + 1   ):
														result += reversible_numbers(UpperCamelCase__     ,							0     ,							[0] * length     ,							UpperCamelCase__   )
							return result


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




