'''simple docstring'''




from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Features, Value
from .base import TaskTemplate






@dataclass(frozen=lowerCAmelCase__      )
class 							a__(   lowerCAmelCase__      ):


			'''simple docstring'''






			UpperCAmelCase_     :	str						=			field(default='''language-modeling'''					,		metadata={'''include_in_asdict_even_if_is_default''': True}      )

			UpperCAmelCase_     :	ClassVar[Features]						=			Features({'''text''': Value('''string'''      )}      )
			UpperCAmelCase_     :	ClassVar[Features]						=			Features({}      )
			UpperCAmelCase_     :	str						=			"text"



			@property
			def 				a_			(  self):




					"""simple docstring"""


					return {self.text_column: "text"}





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


__lowercase        =    logging.get_logger(__name__)






class 							a__(   lowerCAmelCase__      ):


			'''simple docstring'''






			UpperCAmelCase_     :	Dict						=			['''input_values''', '''attention_mask''']



			def __init__(  self			,       __lowerCAmelCase = 1			,       __lowerCAmelCase = 16000			,       __lowerCAmelCase = 0.0			,       __lowerCAmelCase = False			,       __lowerCAmelCase = 80			,       __lowerCAmelCase = 16			,       __lowerCAmelCase = 64			,       __lowerCAmelCase = "hann_window"			,       __lowerCAmelCase = 1.0			,       __lowerCAmelCase = 80			,       __lowerCAmelCase = 7600			,       __lowerCAmelCase = 1E-1_0			,       __lowerCAmelCase = 2			,       __lowerCAmelCase = True			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					super().__init__(feature_size=__lowerCAmelCase			,       sampling_rate=__lowerCAmelCase			,       padding_value=__lowerCAmelCase			,       **__lowerCAmelCase)
					lowerCAmelCase     =    do_normalize
					lowerCAmelCase     =    return_attention_mask

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

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

					lowerCAmelCase     =    window_function(window_length=self.sample_size			,       name=self.win_function			,       periodic=__lowerCAmelCase)

					lowerCAmelCase     =    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"""			,       __lowerCAmelCase			,       )
					if reduction_factor != 2.0:
							warnings.warn(
							    """The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers"""			,       __lowerCAmelCase			,       )



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




					"""simple docstring"""


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

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

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

					return normed_input_values



			def 				a_			(  self			,       __lowerCAmelCase			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    spectrogram(
					    __lowerCAmelCase			,       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			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					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:
							lowerCAmelCase     =    self._process_audio(
							    __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       **__lowerCAmelCase			,       )
					else:
							lowerCAmelCase     =    None

					if audio_target is not None:
							lowerCAmelCase     =    self._process_audio(
							    __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       **__lowerCAmelCase			,       )

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

					return inputs



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = False			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


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

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

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

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

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

					lowerCAmelCase     =    self.pad(
					    __lowerCAmelCase			,       padding=__lowerCAmelCase			,       max_length=__lowerCAmelCase			,       truncation=__lowerCAmelCase			,       pad_to_multiple_of=__lowerCAmelCase			,       return_attention_mask=__lowerCAmelCase			,       **__lowerCAmelCase			,       )

					lowerCAmelCase     =    feature_size_hack

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

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

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

					if return_tensors is not None:
							lowerCAmelCase     =    padded_inputs.convert_to_tensors(__lowerCAmelCase)

					return padded_inputs







			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    super().to_dict()

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

					return output




