




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


a_				:    Optional[Any]										=     logging.get_logger(__name__)

class __lowercase(      lowercase__				):




					'''simple docstring'''


					__a						:						Optional[Any]     		= ['input_features']
					def __init__(    self						,	__a=80						,	__a=16000						,	__a=160						,	__a=30						,	__a=400						,	__a=0.0						,	__a=False						,	**__a						,	):
								super().__init__(
								    feature_size=__UpperCamelCase						,	sampling_rate=__UpperCamelCase						,	padding_value=__UpperCamelCase						,	return_attention_mask=__UpperCamelCase						,	**__UpperCamelCase						,	)
								__lowerCamelCase					:	Dict	       =				n_fft
								__lowerCamelCase					:	Union[str, Any]	       =				hop_length
								__lowerCamelCase					:	int	       =				chunk_length
								__lowerCamelCase					:	List[Any]	       =				chunk_length * sampling_rate
								__lowerCamelCase					:	Tuple	       =				self.n_samples // hop_length
								__lowerCamelCase					:	List[Any]	       =				sampling_rate
								__lowerCamelCase					:	Union[str, Any]	       =				mel_filter_bank(
								    num_frequency_bins=1 + n_fft // 2						,	num_mel_filters=__UpperCamelCase						,	min_frequency=0.0						,	max_frequency=8_000.0						,	sampling_rate=__UpperCamelCase						,	norm='slaney'						,	mel_scale='slaney'						,	)
					def     snake_case_				(    self						,	__a     ):
								__lowerCamelCase					:	Tuple	       =				spectrogram(
								    __UpperCamelCase						,	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'						,	)
								__lowerCamelCase					:	Any	       =				log_spec[:, :-1]
								__lowerCamelCase					:	List[str]	       =				np.maximum(__UpperCamelCase						,	log_spec.max() - 8.0     )
								__lowerCamelCase					:	int	       =				(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     snake_case_				(    __a						,	__a						,	__a = 0.0     ):
								if attention_mask is not None:
											__lowerCamelCase					:	Optional[int]	       =				np.array(__UpperCamelCase						,	np.intaa     )
											__lowerCamelCase					:	str	       =				[]

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

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

								return normed_input_values
					def __call__(    self						,	__a						,	__a = True						,	__a = None						,	__a = None						,	__a = None						,	__a = "max_length"						,	__a = None						,	__a = None						,	__a = None						,	**__a						,	):

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

								__lowerCamelCase					:	Dict	       =				isinstance(__UpperCamelCase						,	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}'''     )
								__lowerCamelCase					:	Tuple	       =				is_batched_numpy or (
								    isinstance(__UpperCamelCase						,	(list, tuple)     ) and (isinstance(raw_speech[0]						,	(np.ndarray, tuple, list)     ))
								)

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

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

								__lowerCamelCase					:	Optional[Any]	       =				BatchFeature({'input_features': raw_speech}     )

								# convert into correct format for padding

								__lowerCamelCase					:	Tuple	       =				self.pad(
								    __UpperCamelCase						,	padding=__UpperCamelCase						,	max_length=max_length if max_length else self.n_samples						,	truncation=__UpperCamelCase						,	pad_to_multiple_of=__UpperCamelCase						,	return_attention_mask=return_attention_mask or do_normalize						,	)

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

								# make sure list is in array format
								__lowerCamelCase					:	Union[str, Any]	       =				padded_inputs.get('input_features'     ).transpose(2						,	0						,	1     )

								__lowerCamelCase					:	Optional[Any]	       =				[self._np_extract_fbank_features(__UpperCamelCase     ) for waveform in input_features[0]]

								if isinstance(input_features[0]						,	__UpperCamelCase     ):
											__lowerCamelCase					:	Optional[int]	       =				[np.asarray(__UpperCamelCase						,	dtype=np.floataa     ) for feature in input_features]
								else:
											__lowerCamelCase					:	List[Any]	       =				input_features

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

								if return_tensors is not None:
											__lowerCamelCase					:	Any	       =				padded_inputs.convert_to_tensors(__UpperCamelCase     )

								return padded_inputs





					def     snake_case_				(    self     ):
								__lowerCamelCase					:	Tuple	       =				copy.deepcopy(self.__dict__     )
								__lowerCamelCase					:	str	       =				self.__class__.__name__
								if "mel_filters" in output:
											del output["mel_filters"]
								return output









"""simple docstring"""
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin

class __lowercase(      lowercase__				):




					'''simple docstring'''


					__a						:						List[str]     		= 'Speech2TextFeatureExtractor'
					__a						:						Optional[int]     		= 'Speech2TextTokenizer'
					def __init__(    self						,	__a						,	__a     ):
								super().__init__(__a						,	__a     )
								__lowerCamelCase					:	Union[str, Any]	       =				self.feature_extractor
								__lowerCamelCase					:	List[str]	       =				False
					def __call__(    self						,	*__a						,	**__a     ):
								# For backward compatibility
								if self._in_target_context_manager:
											return self.current_processor(*__a						,	**__a     )

								if "raw_speech" in kwargs:
											warnings.warn('Using `raw_speech` as a keyword argument is deprecated. Use `audio` instead.'     )
											__lowerCamelCase					:	str	       =				kwargs.pop('raw_speech'     )
								else:
											__lowerCamelCase					:	Optional[Any]	       =				kwargs.pop('audio'						,	__a     )
								__lowerCamelCase					:	Optional[Any]	       =				kwargs.pop('sampling_rate'						,	__a     )
								__lowerCamelCase					:	Optional[int]	       =				kwargs.pop('text'						,	__a     )
								if len(__a     ) > 0:
											__lowerCamelCase					:	Optional[int]	       =				args[0]
											__lowerCamelCase					:	str	       =				args[1:]

								if audio is None and text is None:
											raise ValueError('You need to specify either an `audio` or `text` input to process.'     )

								if audio is not None:
											__lowerCamelCase					:	Dict	       =				self.feature_extractor(__a						,	*__a						,	sampling_rate=__a						,	**__a     )
								if text is not None:
											__lowerCamelCase					:	Optional[int]	       =				self.tokenizer(__a						,	**__a     )

								if text is None:
											return inputs
								elif audio is None:
											return encodings
								else:
											__lowerCamelCase					:	Any	       =				encodings['input_ids']
											return inputs
					def     snake_case_				(    self						,	*__a						,	**__a     ):
								return self.tokenizer.batch_decode(*__a						,	**__a     )
					def     snake_case_				(    self						,	*__a						,	**__a     ):
								return self.tokenizer.decode(*__a						,	**__a     )





					@contextmanager
					def     snake_case_				(    self     ):
								warnings.warn(
								    '`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your '
								    'labels by using the argument `text` of the regular `__call__` method (either in the same call as '
								    'your audio inputs, or in a separate call.'     )
								__lowerCamelCase					:	int	       =				True
								__lowerCamelCase					:	Union[str, Any]	       =				self.tokenizer
								yield
								__lowerCamelCase					:	Tuple	       =				self.feature_extractor
								__lowerCamelCase					:	List[str]	       =				False



