


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


__magic_name__						: Any    =				logging.get_logger(__name__)




class 			__snake_case   (lowerCamelCase  ):
							__a					 =       ['''input_features''']




							def __init__(     self:    Any     ,							A_:    List[str]=80     ,							A_:    Any=1_60_00     ,							A_:    str=1_60     ,							A_:    Any=30     ,							A_:    Any=4_00     ,							A_:    List[Any]=0.0     ,							A_:    Union[str, Any]=False     ,							**A_:    List[str]     ,							):
										super().__init__(
										    feature_size=A_     ,							sampling_rate=A_     ,							padding_value=A_     ,							return_attention_mask=A_     ,							**A_     ,							)
										__lowerCamelCase          =      n_fft
										__lowerCamelCase          =      hop_length
										__lowerCamelCase          =      chunk_length
										__lowerCamelCase          =      chunk_length * sampling_rate
										__lowerCamelCase          =      self.n_samples // hop_length
										__lowerCamelCase          =      sampling_rate
										__lowerCamelCase          =      mel_filter_bank(
										    num_frequency_bins=1 + n_fft // 2     ,							num_mel_filters=A_     ,							min_frequency=0.0     ,							max_frequency=8_000.0     ,							sampling_rate=A_     ,							norm="""slaney"""     ,							mel_scale="""slaney"""     ,							)




							def   __a   (     self:    Any     ,							A_:    np.array   ):
										__lowerCamelCase          =      spectrogram(
										    A_     ,							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          =      log_spec[:, :-1]
										__lowerCamelCase          =      np.maximum(A_     ,							log_spec.max() - 8.0   )
										__lowerCamelCase          =      (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   (     A_:    List[np.ndarray]     ,							A_:    List[np.ndarray]     ,							A_:    float = 0.0   ):
										if attention_mask is not None:
													__lowerCamelCase          =      np.array(A_     ,							np.intaa   )
													__lowerCamelCase          =      []

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

										return normed_input_values




							def __call__(     self:    Optional[Any]     ,							A_:    Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]     ,							A_:    bool = True     ,							A_:    Optional[int] = None     ,							A_:    Optional[Union[str, TensorType]] = None     ,							A_:    Optional[bool] = None     ,							A_:    Optional[str] = "max_length"     ,							A_:    Optional[int] = None     ,							A_:    Optional[int] = None     ,							A_:    Optional[bool] = None     ,							**A_:    List[str]     ,							):

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

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

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

										__lowerCamelCase          =      BatchFeature({"""input_features""": raw_speech}   )

										# convert into correct format for padding

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

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

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

										__lowerCamelCase          =      [self._np_extract_fbank_features(A_   ) for waveform in input_features[0]]

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

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

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

										return padded_inputs




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








"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


__magic_name__						: Tuple    =				{}


try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__magic_name__						: str    =				['MLukeTokenizer']

if TYPE_CHECKING:
					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_mluke import MLukeTokenizer


else:
					import sys

					__magic_name__						: int    =				_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




