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_							=      logging.get_logger(__name__)


class 			UpperCAmelCase__    (		snake_case					):



  """simple docstring"""






  lowerCAmelCase__		:	Tuple    		= ['input_features']






  def __init__(				self:			Any				,				__lowerCAmelCase:			int=80				,				__lowerCAmelCase:			List[Any]=16_000				,				__lowerCAmelCase:			List[Any]=160				,				__lowerCAmelCase:			Any=30				,				__lowerCAmelCase:			Any=400				,				__lowerCAmelCase:			Union[str, Any]=0.0				,				__lowerCAmelCase:			List[str]=False				,				**__lowerCAmelCase:			Any				,				) -> int:




    '''simple docstring'''




    super().__init__(
        feature_size=__lowerCAmelCase				,				sampling_rate=__lowerCAmelCase				,				padding_value=__lowerCAmelCase				,				return_attention_mask=__lowerCAmelCase				,				**__lowerCAmelCase				,				)
    __UpperCAmelCase						    =       n_fft
    __UpperCAmelCase						    =       hop_length
    __UpperCAmelCase						    =       chunk_length
    __UpperCAmelCase						    =       chunk_length * sampling_rate
    __UpperCAmelCase						    =       self.n_samples // hop_length
    __UpperCAmelCase						    =       sampling_rate
    __UpperCAmelCase						    =       mel_filter_bank(
        num_frequency_bins=1 + n_fft // 2				,				num_mel_filters=__lowerCAmelCase				,				min_frequency=0.0				,				max_frequency=8000.0				,				sampling_rate=__lowerCAmelCase				,				norm="slaney"				,				mel_scale="slaney"				,				)






  def 	_UpperCAmelCase				(				self:			Union[str, Any]				,				__lowerCAmelCase:			np.array   ) -> np.ndarray:




    '''simple docstring'''




    __UpperCAmelCase						    =       spectrogram(
        __lowerCAmelCase				,				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"				,				)
    __UpperCAmelCase						    =       log_spec[:, :-1]
    __UpperCAmelCase						    =       np.maximum(__lowerCAmelCase				,				log_spec.max() - 8.0   )
    __UpperCAmelCase						    =       (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 	_UpperCAmelCase				(				__lowerCAmelCase:			List[np.ndarray]				,				__lowerCAmelCase:			List[np.ndarray]				,				__lowerCAmelCase:			float = 0.0   ) -> List[np.ndarray]:




    '''simple docstring'''




    if attention_mask is not None:
      __UpperCAmelCase						    =       np.array(__lowerCAmelCase				,				np.intaa   )
      __UpperCAmelCase						    =       []

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

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

    return normed_input_values






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




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

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

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

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

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

    # convert into correct format for padding

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

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

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

    __UpperCAmelCase						    =       [self._np_extract_fbank_features(__lowerCAmelCase   ) for waveform in input_features[0]]

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

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

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

    return padded_inputs






  def 	_UpperCAmelCase				(				self:			List[str]   ) -> Dict[str, Any]:




    '''simple docstring'''




    __UpperCAmelCase						    =       copy.deepcopy(self.__dict__   )
    __UpperCAmelCase						    =       self.__class__.__name__
    if "mel_filters" in output:
      del output["mel_filters"]
    return output




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__)



