



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


__a      =				logging.get_logger(__name__)
class 				lowerCamelCase  (			_lowerCAmelCase				):






					'''simple docstring'''





					_A		:			Union[str, Any]						=     ["""input_values""", """attention_mask"""]






					def __init__(       self:							Optional[int]						,     snake_case:							int = 1						,     snake_case:							int = 16_000						,     snake_case:							float = 0.0						,     snake_case:							bool = False						,     snake_case:							int = 80						,     snake_case:							int = 16						,     snake_case:							int = 64						,     snake_case:							str = "hann_window"						,     snake_case:							float = 1.0						,     snake_case:							float = 80						,     snake_case:							float = 7_600						,     snake_case:							float = 1E-10						,     snake_case:							int = 2						,     snake_case:							bool = True						,     **snake_case:							Tuple						,     )   ->	Union[str, Any]:
											super().__init__(feature_size=snake_case						,     sampling_rate=snake_case						,     padding_value=snake_case						,     **snake_case						)
											snake_case_ :Optional[int]						=			do_normalize
											snake_case_ :Optional[int]						=			return_attention_mask

											snake_case_ :str						=			num_mel_bins
											snake_case_ :Tuple						=			hop_length
											snake_case_ :Optional[Any]						=			win_length
											snake_case_ :Optional[Any]						=			win_function
											snake_case_ :Any						=			frame_signal_scale
											snake_case_ :int						=			fmin
											snake_case_ :Any						=			fmax
											snake_case_ :Optional[Any]						=			mel_floor
											snake_case_ :str						=			reduction_factor

											snake_case_ :int						=			win_length * sampling_rate // 1_000
											snake_case_ :List[Any]						=			hop_length * sampling_rate // 1_000
											snake_case_ :str						=			optimal_fft_length(self.sample_size						)
											snake_case_ :Optional[Any]						=			(self.n_fft // 2) + 1

											snake_case_ :Any						=			window_function(window_length=self.sample_size						,     name=self.win_function						,     periodic=snake_case						)

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






					@staticmethod
					# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
					def    lowerCAmelCase_				(       snake_case:							List[np.ndarray]						,     snake_case:							List[np.ndarray]						,     snake_case:							float = 0.0						)   ->	List[np.ndarray]:
											if attention_mask is not None:
																	snake_case_ :Tuple						=			np.array(snake_case						,     np.intaa						)
																	snake_case_ :Tuple						=			[]

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

																							normed_input_values.append(snake_case						)
											else:
																	snake_case_ :Union[str, Any]						=			[(x - x.mean()) / np.sqrt(x.var() + 1E-7						) for x in input_values]

											return normed_input_values






					def    lowerCAmelCase_				(       self:							Optional[int]						,     snake_case:							np.ndarray						,     )   ->	np.ndarray:
											snake_case_ :List[str]						=			spectrogram(
											    snake_case						,     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:							Dict						,     snake_case:							Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None						,     snake_case:							Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None						,     snake_case:							Union[bool, str, PaddingStrategy] = False						,     snake_case:							Optional[int] = None						,     snake_case:							bool = False						,     snake_case:							Optional[int] = None						,     snake_case:							Optional[bool] = None						,     snake_case:							Optional[Union[str, TensorType]] = None						,     snake_case:							Optional[int] = None						,     **snake_case:							Union[str, Any]						,     )   ->	BatchFeature:
											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_ :str						=			self._process_audio(
																	    snake_case						,     snake_case						,     snake_case						,     snake_case						,     snake_case						,     snake_case						,     snake_case						,     snake_case						,     **snake_case						,     )
											else:
																	snake_case_ :Optional[Any]						=			None

											if audio_target is not None:
																	snake_case_ :Optional[Any]						=			self._process_audio(
																	    snake_case						,     snake_case						,     snake_case						,     snake_case						,     snake_case						,     snake_case						,     snake_case						,     snake_case						,     **snake_case						,     )

																	if inputs is None:
																							return inputs_target
																	else:
																							snake_case_ :Optional[Any]						=			inputs_target["""input_values"""]
																							snake_case_ :Union[str, Any]						=			inputs_target.get("""attention_mask"""						)
																							if decoder_attention_mask is not None:
																													snake_case_ :str						=			decoder_attention_mask

											return inputs






					def    lowerCAmelCase_				(       self:							Optional[Any]						,     snake_case:							Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]						,     snake_case:							bool = False						,     snake_case:							Union[bool, str, PaddingStrategy] = False						,     snake_case:							Optional[int] = None						,     snake_case:							bool = False						,     snake_case:							Optional[int] = None						,     snake_case:							Optional[bool] = None						,     snake_case:							Optional[Union[str, TensorType]] = None						,     **snake_case:							int						,     )   ->	BatchFeature:
											snake_case_ :str						=			isinstance(snake_case						,     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_ :str						=			is_batched_numpy or (
											    isinstance(snake_case						,     (list, tuple)						) and (isinstance(speech[0]						,     (np.ndarray, tuple, list)						))
											)

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

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

											# needed to make pad() work on spectrogram inputs
											snake_case_ :Optional[int]						=			self.feature_size

											# convert into correct format for padding
											if is_target:
																	snake_case_ :str						=			[self._extract_mel_features(snake_case						) for waveform in speech]
																	snake_case_ :str						=			BatchFeature({"""input_values""": features}						)
																	snake_case_ :List[Any]						=			self.num_mel_bins
											else:
																	snake_case_ :Optional[Any]						=			BatchFeature({"""input_values""": speech}						)

											snake_case_ :Any						=			self.pad(
											    snake_case						,     padding=snake_case						,     max_length=snake_case						,     truncation=snake_case						,     pad_to_multiple_of=snake_case						,     return_attention_mask=snake_case						,     **snake_case						,     )

											snake_case_ :Dict						=			feature_size_hack

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

											# convert attention_mask to correct format
											snake_case_ :Union[str, Any]						=			padded_inputs.get("""attention_mask"""						)
											if attention_mask is not None:
																	snake_case_ :Optional[int]						=			[np.asarray(snake_case						,     dtype=np.intaa						) for array in attention_mask]

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

											if return_tensors is not None:
																	snake_case_ :Union[str, Any]						=			padded_inputs.convert_to_tensors(snake_case						)

											return padded_inputs






					def    lowerCAmelCase_				(       self:							Dict						)   ->	Dict[str, Any]:
											snake_case_ :Optional[int]						=			super().to_dict()

											# Don't serialize these as they are derived from the other properties.
											snake_case_ :Optional[int]						=			["""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 typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__a      =				{
    "configuration_altclip": [
        "ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "AltCLIPConfig",
        "AltCLIPTextConfig",
        "AltCLIPVisionConfig",
    ],
    "processing_altclip": ["AltCLIPProcessor"],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a      =				[
						    "ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "AltCLIPPreTrainedModel",
						    "AltCLIPModel",
						    "AltCLIPTextModel",
						    "AltCLIPVisionModel",
						]


if TYPE_CHECKING:
						from .configuration_altclip import (
						    ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    AltCLIPConfig,
						    AltCLIPTextConfig,
						    AltCLIPVisionConfig,
						)
						from .processing_altclip import AltCLIPProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_altclip import (
												    ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
												    AltCLIPModel,
												    AltCLIPPreTrainedModel,
												    AltCLIPTextModel,
												    AltCLIPVisionModel,
												)


else:
						import sys

						__a      =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
