



"""simple docstring"""
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:   str								=		logging.get_logger(__name__)



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__ ):
   __lowerCAmelCase  :   Optional[Any]						=						['input_features', 'attention_mask']

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE=80      ,     _SCREAMING_SNAKE_CASE=16000      ,     _SCREAMING_SNAKE_CASE=80      ,     _SCREAMING_SNAKE_CASE=0.0      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      Dict:





    '''simple docstring'''




    super().__init__(feature_size=_SCREAMING_SNAKE_CASE      ,     sampling_rate=_SCREAMING_SNAKE_CASE      ,     padding_value=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE						)
    UpperCAmelCase	:					Union[str, Any]	=	num_mel_bins
    UpperCAmelCase	:					Tuple	=	do_ceptral_normalize
    UpperCAmelCase	:					Optional[int]	=	normalize_means
    UpperCAmelCase	:					Any	=	normalize_vars
    UpperCAmelCase	:					Any	=	True

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     )  ->      np.ndarray:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	waveform * (2**15)  # Kaldi compliance: 16-bit signed integers
    UpperCAmelCase	:					List[Any]	=	torch.from_numpy(_SCREAMING_SNAKE_CASE						).unsqueeze(0						)
    UpperCAmelCase	:					Dict	=	ta_kaldi.fbank(_SCREAMING_SNAKE_CASE      ,     num_mel_bins=self.num_mel_bins      ,     sample_frequency=self.sampling_rate						)
    return features.numpy()

   @staticmethod
   def 	SCREAMING_SNAKE_CASE     (   _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = True      ,     _SCREAMING_SNAKE_CASE = True      ,     _SCREAMING_SNAKE_CASE = 0.0      ,     )  ->      np.ndarray:





    '''simple docstring'''




    if normalize_means:
     UpperCAmelCase	:					Tuple	=	x[:input_length].mean(axis=0						)
     UpperCAmelCase	:					Optional[Any]	=	np.subtract(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
    if normalize_vars:
     UpperCAmelCase	:					Tuple	=	x[:input_length].std(axis=0						)
     UpperCAmelCase	:					Dict	=	np.divide(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

    if input_length < x.shape[0]:
     UpperCAmelCase	:					Optional[int]	=	padding_value

    # make sure array is in float32
    UpperCAmelCase	:					Any	=	x.astype(np.floataa						)

    return x

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = None						)  ->      List[np.ndarray]:





    '''simple docstring'''




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




   def __call__(   self      ,     _SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE = False      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = False      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     _SCREAMING_SNAKE_CASE = None      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      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} 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."""						)

    UpperCAmelCase	:					Union[str, Any]	=	isinstance(_SCREAMING_SNAKE_CASE      ,     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	:					Union[str, Any]	=	is_batched_numpy or (
        isinstance(_SCREAMING_SNAKE_CASE      ,     (list, tuple)						) and (isinstance(raw_speech[0]      ,     (np.ndarray, tuple, list)						))
    )

    if is_batched:
     UpperCAmelCase	:					Any	=	[np.asarray(_SCREAMING_SNAKE_CASE      ,     dtype=np.floataa						) for speech in raw_speech]
    elif not is_batched and not isinstance(_SCREAMING_SNAKE_CASE      ,     np.ndarray						):
     UpperCAmelCase	:					Union[str, Any]	=	np.asarray(_SCREAMING_SNAKE_CASE      ,     dtype=np.floataa						)
    elif isinstance(_SCREAMING_SNAKE_CASE      ,     np.ndarray						) and raw_speech.dtype is np.dtype(np.floataa						):
     UpperCAmelCase	:					Tuple	=	raw_speech.astype(np.floataa						)

    # always return batch
    if not is_batched:
     UpperCAmelCase	:					List[str]	=	[raw_speech]

    # extract fbank features
    UpperCAmelCase	:					Optional[int]	=	[self._extract_fbank_features(_SCREAMING_SNAKE_CASE						) for waveform in raw_speech]

    # convert into correct format for padding
    UpperCAmelCase	:					Optional[Any]	=	BatchFeature({"""input_features""": features}						)

    UpperCAmelCase	:					Tuple	=	self.pad(
        _SCREAMING_SNAKE_CASE      ,     padding=_SCREAMING_SNAKE_CASE      ,     max_length=_SCREAMING_SNAKE_CASE      ,     truncation=_SCREAMING_SNAKE_CASE      ,     pad_to_multiple_of=_SCREAMING_SNAKE_CASE      ,     return_attention_mask=_SCREAMING_SNAKE_CASE      ,     **_SCREAMING_SNAKE_CASE      ,     )

    # make sure list is in array format
    UpperCAmelCase	:					str	=	padded_inputs.get("""input_features"""						)
    if isinstance(input_features[0]      ,     _SCREAMING_SNAKE_CASE						):
     UpperCAmelCase	:					Optional[int]	=	[np.asarray(_SCREAMING_SNAKE_CASE      ,     dtype=np.floataa						) for feature in input_features]

    UpperCAmelCase	:					Optional[Any]	=	padded_inputs.get("""attention_mask"""						)
    if attention_mask is not None:
     UpperCAmelCase	:					int	=	[np.asarray(_SCREAMING_SNAKE_CASE      ,     dtype=np.intaa						) for array in attention_mask]

    # Utterance-level cepstral mean and variance normalization
    if self.do_ceptral_normalize:
     UpperCAmelCase	:					List[str]	=	(
         np.array(_SCREAMING_SNAKE_CASE      ,     dtype=np.intaa						)
         if self._get_padding_strategies(_SCREAMING_SNAKE_CASE      ,     max_length=_SCREAMING_SNAKE_CASE						) is not PaddingStrategy.DO_NOT_PAD
         else None
     )
     UpperCAmelCase	:					Optional[int]	=	self.normalize(
         padded_inputs["""input_features"""]      ,     attention_mask=_SCREAMING_SNAKE_CASE						)

    if return_tensors is not None:
     UpperCAmelCase	:					List[str]	=	padded_inputs.convert_to_tensors(_SCREAMING_SNAKE_CASE						)

    return padded_inputs





"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A:   List[str]								=		{
    "configuration_clipseg": [
        "CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "CLIPSegConfig",
        "CLIPSegTextConfig",
        "CLIPSegVisionConfig",
    ],
    "processing_clipseg": ["CLIPSegProcessor"],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A:   Optional[int]								=		[
          "CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST",
          "CLIPSegModel",
          "CLIPSegPreTrainedModel",
          "CLIPSegTextModel",
          "CLIPSegVisionModel",
          "CLIPSegForImageSegmentation",
      ]

if TYPE_CHECKING:
      from .configuration_clipseg import (
          CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP,
          CLIPSegConfig,
          CLIPSegTextConfig,
          CLIPSegVisionConfig,
      )
      from .processing_clipseg import CLIPSegProcessor

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_clipseg import (
                CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST,
                CLIPSegForImageSegmentation,
                CLIPSegModel,
                CLIPSegPreTrainedModel,
                CLIPSegTextModel,
                CLIPSegVisionModel,
            )

else:
      import sys

      A:   Tuple								=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
