


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


_lowerCamelCase     =			logging.get_logger(__name__)


class 			lowerCamelCase_		(			lowercase   ):





				"""simple docstring"""







				_lowerCAmelCase      :      Optional[int]      							=					["input_values", "attention_mask"]



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

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

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

								SCREAMING_SNAKE_CASE__     							=				window_function(window_length=self.sample_size       ,		name=self.win_function       ,		periodic=UpperCAmelCase__     )

								SCREAMING_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   lowerCAmelCase__		(						UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = 0.0     ):
								if attention_mask is not None:
												SCREAMING_SNAKE_CASE__     							=				np.array(UpperCAmelCase__       ,		np.intaa     )
												SCREAMING_SNAKE_CASE__     							=				[]

												for vector, length in zip(UpperCAmelCase__       ,		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(UpperCAmelCase__     )
								else:
												SCREAMING_SNAKE_CASE__     							=				[(x - x.mean()) / np.sqrt(x.var() + 1e-7     ) for x in input_values]

								return normed_input_values



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		):
								SCREAMING_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       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = False       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = False       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		**UpperCAmelCase__       ,		):
								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:
												SCREAMING_SNAKE_CASE__     							=				self._process_audio(
												    UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		**UpperCAmelCase__       ,		)
								else:
												SCREAMING_SNAKE_CASE__     							=				None

								if audio_target is not None:
												SCREAMING_SNAKE_CASE__     							=				self._process_audio(
												    UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		**UpperCAmelCase__       ,		)

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

								return inputs



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = False       ,		UpperCAmelCase__ = False       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = False       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		**UpperCAmelCase__       ,		):
								SCREAMING_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}'''     )
								SCREAMING_SNAKE_CASE__     							=				is_batched_numpy or (
								    isinstance(UpperCAmelCase__       ,		(list, tuple)     ) and (isinstance(speech[0]       ,		(np.ndarray, tuple, list)     ))
								)

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

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

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

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

								SCREAMING_SNAKE_CASE__     							=				self.pad(
								    UpperCAmelCase__       ,		padding=UpperCAmelCase__       ,		max_length=UpperCAmelCase__       ,		truncation=UpperCAmelCase__       ,		pad_to_multiple_of=UpperCAmelCase__       ,		return_attention_mask=UpperCAmelCase__       ,		**UpperCAmelCase__       ,		)

								SCREAMING_SNAKE_CASE__     							=				feature_size_hack

								# convert input values to correct format
								SCREAMING_SNAKE_CASE__     							=				padded_inputs["input_values"]
								if not isinstance(input_values[0]       ,		np.ndarray     ):
												SCREAMING_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     )
								):
												SCREAMING_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     ):
												SCREAMING_SNAKE_CASE__     							=				input_values.astype(np.floataa     )

								# convert attention_mask to correct format
								SCREAMING_SNAKE_CASE__     							=				padded_inputs.get("attention_mask"     )
								if attention_mask is not None:
												SCREAMING_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:
												SCREAMING_SNAKE_CASE__     							=				(
												    attention_mask
												    if self._get_padding_strategies(UpperCAmelCase__       ,		max_length=UpperCAmelCase__     ) is not PaddingStrategy.DO_NOT_PAD
												    else None
												)
												SCREAMING_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:
												SCREAMING_SNAKE_CASE__     							=				padded_inputs.convert_to_tensors(UpperCAmelCase__     )

								return padded_inputs






				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				super().to_dict()

								# Don't serialize these as they are derived from the other properties.
								SCREAMING_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




"""simple docstring"""






from maths.is_square_free import is_square_free
from maths.prime_factors import prime_factors


def __lowercase     (      lowerCamelCase_  :      int  ):
				SCREAMING_SNAKE_CASE__     							=				prime_factors(lowerCamelCase_  )
				if is_square_free(lowerCamelCase_  ):
								return -1 if len(lowerCamelCase_  ) % 2 else 1
				return 0


if __name__ == "__main__":
	import doctest

	doctest.testmod()
