


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


lowerCAmelCase    :     Tuple					=						logging.get_logger(__name__)
class 	UpperCamelCase__					( SCREAMING_SNAKE_CASE_	):



     """simple docstring"""






     __magic_name__    			=    ["input_features"]







     def __init__( self      ,	snake_case__=80      ,	snake_case__=1_6000      ,	snake_case__=160      ,	snake_case__=30      ,	snake_case__=400      ,	snake_case__=0.0      ,	snake_case__=False      ,	**snake_case__      ,	):

            '''simple docstring'''

            super().__init__(
                feature_size=__UpperCamelCase      ,	sampling_rate=__UpperCamelCase      ,	padding_value=__UpperCamelCase      ,	return_attention_mask=__UpperCamelCase      ,	**__UpperCamelCase      ,	)
            _lowerCAmelCase    :							List[Any]   			=       n_fft
            _lowerCAmelCase    :							List[Any]   			=       hop_length
            _lowerCAmelCase    :							Dict   			=       chunk_length
            _lowerCAmelCase    :							Dict   			=       chunk_length * sampling_rate
            _lowerCAmelCase    :							Union[str, Any]   			=       self.n_samples // hop_length
            _lowerCAmelCase    :							Union[str, Any]   			=       sampling_rate
            _lowerCAmelCase    :							int   			=       mel_filter_bank(
                num_frequency_bins=1 + n_fft // 2      ,	num_mel_filters=__UpperCamelCase      ,	min_frequency=0.0      ,	max_frequency=8000.0      ,	sampling_rate=__UpperCamelCase      ,	norm='slaney'      ,	mel_scale='slaney'      ,	)







     def a	( self      ,	snake_case__   ):

            '''simple docstring'''

            _lowerCAmelCase    :							List[Any]   			=       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    :							List[Any]   			=       log_spec[:, :-1]
            _lowerCAmelCase    :							Optional[Any]   			=       np.maximum(__UpperCamelCase      ,	log_spec.max() - 8.0   )
            _lowerCAmelCase    :							Optional[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 a	( snake_case__      ,	snake_case__      ,	snake_case__ = 0.0   ):

            '''simple docstring'''

            if attention_mask is not None:
                   _lowerCAmelCase    :							List[str]   			=       np.array(__UpperCamelCase      ,	np.intaa   )
                   _lowerCAmelCase    :							List[str]   			=       []

                   for vector, length in zip(__UpperCamelCase      ,	attention_mask.sum(-1   )   ):
                          _lowerCAmelCase    :							Union[str, Any]   			=       (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7   )
                          if length < normed_slice.shape[0]:
                                 _lowerCAmelCase    :							List[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      ,	snake_case__      ,	snake_case__ = True      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__ = "max_length"      ,	snake_case__ = None      ,	snake_case__ = None      ,	snake_case__ = None      ,	**snake_case__      ,	):

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

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

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

            _lowerCAmelCase    :							List[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    :							Any   			=       self.zero_mean_unit_var_norm(
                       padded_inputs['input_features']      ,	attention_mask=padded_inputs['attention_mask']      ,	padding_value=self.padding_value      ,	)
                   _lowerCAmelCase    :							List[Any]   			=       np.stack(padded_inputs['input_features']      ,	axis=0   )

            # make sure list is in array format
            _lowerCAmelCase    :							Dict   			=       padded_inputs.get('input_features'   ).transpose(2      ,	0      ,	1   )

            _lowerCAmelCase    :							Dict   			=       [self._np_extract_fbank_features(__UpperCamelCase   ) for waveform in input_features[0]]

            if isinstance(input_features[0]      ,	__UpperCamelCase   ):
                   _lowerCAmelCase    :							Dict   			=       [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    :							Optional[int]   			=       padded_inputs['attention_mask'][:, :: self.hop_length]

            if return_tensors is not None:
                   _lowerCAmelCase    :							Optional[int]   			=       padded_inputs.convert_to_tensors(__UpperCamelCase   )

            return padded_inputs







     def a	( self   ):

            '''simple docstring'''

            _lowerCAmelCase    :							Optional[int]   			=       copy.deepcopy(self.__dict__   )
            _lowerCAmelCase    :							Tuple   			=       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_torch_available


lowerCAmelCase    :     Any					=						{
    """configuration_x_clip""": [
        """XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XCLIPConfig""",
        """XCLIPTextConfig""",
        """XCLIPVisionConfig""",
    ],
    """processing_x_clip""": ["""XCLIPProcessor"""],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCAmelCase    :     Optional[Any]					=						[
           """XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """XCLIPModel""",
           """XCLIPPreTrainedModel""",
           """XCLIPTextModel""",
           """XCLIPVisionModel""",
       ]

if TYPE_CHECKING:
       from .configuration_x_clip import (
           XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
           XCLIPConfig,
           XCLIPTextConfig,
           XCLIPVisionConfig,
       )
       from .processing_x_clip import XCLIPProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_x_clip import (
                  XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
                  XCLIPModel,
                  XCLIPPreTrainedModel,
                  XCLIPTextModel,
                  XCLIPVisionModel,
              )

else:
       import sys

       lowerCAmelCase    :     Dict					=						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

