





from typing import List, Optional, Union

import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi

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       __A					(					lowerCAmelCase				):

			'''simple docstring'''







			lowerCAmelCase_							  =		["""input_features""", """attention_mask"""]





			def __init__(					self ,						__lowerCAmelCase=8_0 ,						__lowerCAmelCase=1_6_0_0_0 ,						__lowerCAmelCase=8_0 ,						__lowerCAmelCase=0.0 ,						__lowerCAmelCase=True ,						__lowerCAmelCase=True ,						__lowerCAmelCase=True ,						**__lowerCAmelCase ,						):



				'''simple docstring'''







				super().__init__(feature_size=__lowerCAmelCase ,						sampling_rate=__lowerCAmelCase ,						padding_value=__lowerCAmelCase ,						**__lowerCAmelCase							)
				lowerCamelCase__              =	num_mel_bins
				lowerCamelCase__              =	do_ceptral_normalize
				lowerCamelCase__              =	normalize_means
				lowerCamelCase__              =	normalize_vars
				lowerCamelCase__              =	True





			def 	__lowerCamelCase       (					self ,						__lowerCAmelCase ,						):



				'''simple docstring'''







				lowerCamelCase__              =	waveform * (2**1_5)  # Kaldi compliance: 16-bit signed integers
				lowerCamelCase__              =	torch.from_numpy(__lowerCAmelCase							).unsqueeze(0							)
				lowerCamelCase__              =	ta_kaldi.fbank(__lowerCAmelCase ,						num_mel_bins=self.num_mel_bins ,						sample_frequency=self.sampling_rate							)
				return features.numpy()





			@staticmethod
			def 	__lowerCamelCase       (					__lowerCAmelCase ,						__lowerCAmelCase ,						__lowerCAmelCase = True ,						__lowerCAmelCase = True ,						__lowerCAmelCase = 0.0 ,						):



				'''simple docstring'''







				if normalize_means:
					lowerCamelCase__              =	x[:input_length].mean(axis=0							)
					lowerCamelCase__              =	np.subtract(__lowerCAmelCase ,						__lowerCAmelCase							)
				if normalize_vars:
					lowerCamelCase__              =	x[:input_length].std(axis=0							)
					lowerCamelCase__              =	np.divide(__lowerCAmelCase ,						__lowerCAmelCase							)

				if input_length < x.shape[0]:
					lowerCamelCase__              =	padding_value

				# make sure array is in float32
				lowerCamelCase__              =	x.astype(np.floataa							)

				return x





			def 	__lowerCamelCase       (					self ,						__lowerCAmelCase ,						__lowerCAmelCase = None							):



				'''simple docstring'''







				lowerCamelCase__              =	attention_mask.sum(-1							) if attention_mask is not None else [x.shape[0] for x in input_features]
				return [
				    self.utterance_cmvn(__lowerCAmelCase ,						__lowerCAmelCase ,						self.normalize_means ,						self.normalize_vars ,						self.padding_value							)
				    for x, n in zip(__lowerCAmelCase ,						__lowerCAmelCase							)
				]





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



				'''simple docstring'''







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

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

				if is_batched:
					lowerCamelCase__              =	[np.asarray(__lowerCAmelCase ,						dtype=np.floataa							) for speech in raw_speech]
				elif not is_batched and not isinstance(__lowerCAmelCase ,						np.ndarray							):
					lowerCamelCase__              =	np.asarray(__lowerCAmelCase ,						dtype=np.floataa							)
				elif isinstance(__lowerCAmelCase ,						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__              =	[raw_speech]

				# extract fbank features
				lowerCamelCase__              =	[self._extract_fbank_features(__lowerCAmelCase							) for waveform in raw_speech]

				# convert into correct format for padding
				lowerCamelCase__              =	BatchFeature({'''input_features''': features}							)

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

				# make sure list is in array format
				lowerCamelCase__              =	padded_inputs.get('''input_features'''							)
				if isinstance(input_features[0] ,						__lowerCAmelCase							):
					lowerCamelCase__              =	[np.asarray(__lowerCAmelCase ,						dtype=np.floataa							) for feature in input_features]

				lowerCamelCase__              =	padded_inputs.get('''attention_mask'''							)
				if attention_mask is not None:
					lowerCamelCase__              =	[np.asarray(__lowerCAmelCase ,						dtype=np.intaa							) for array in attention_mask]

				# Utterance-level cepstral mean and variance normalization
				if self.do_ceptral_normalize:
					lowerCamelCase__              =	(
					    np.array(__lowerCAmelCase ,						dtype=np.intaa							)
					    if self._get_padding_strategies(__lowerCAmelCase ,						max_length=__lowerCAmelCase							) is not PaddingStrategy.DO_NOT_PAD
					    else None
					)
					lowerCamelCase__              =	self.normalize(
					    padded_inputs['''input_features'''] ,						attention_mask=__lowerCAmelCase							)

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

				return padded_inputs










import warnings

from ...utils import logging
from .image_processing_owlvit import OwlViTImageProcessor


_a						=   logging.get_logger(__name__)






class       __A					(					lowerCAmelCase				):

			'''simple docstring'''







			def __init__(					self ,						*__lowerCAmelCase ,						**__lowerCAmelCase							):



				'''simple docstring'''







				warnings.warn(
				    '''The class OwlViTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please'''
				    ''' use OwlViTImageProcessor instead.''' ,						__lowerCAmelCase ,						)
				super().__init__(*__lowerCAmelCase ,						**__lowerCAmelCase							)



