'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A_     :						Optional[Any]    							={
    '''configuration_upernet''': ['''UperNetConfig'''],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 A_     :						List[str]    							=[
     '''UperNetForSemanticSegmentation''',
     '''UperNetPreTrainedModel''',
 ]


if TYPE_CHECKING:
 from .configuration_upernet import UperNetConfig

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_upernet import UperNetForSemanticSegmentation, UperNetPreTrainedModel


else:
 import sys

 A_     :						Dict    							=_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






'''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_     :						List[Any]    							=logging.get_logger(__name__)


class     __UpperCAmelCase       ( __a		):
  __A :				int											= ['input_values', 'attention_mask']





  def __init__(	self    ,     _lowerCamelCase = 1    ,     _lowerCamelCase = 1_6000    ,     _lowerCamelCase = 0.0    ,     _lowerCamelCase = False    ,     _lowerCamelCase = 80    ,     _lowerCamelCase = 16    ,     _lowerCamelCase = 64    ,     _lowerCamelCase = "hann_window"    ,     _lowerCamelCase = 1.0    ,     _lowerCamelCase = 80    ,     _lowerCamelCase = 7600    ,     _lowerCamelCase = 1E-10    ,     _lowerCamelCase = 2    ,     _lowerCamelCase = True    ,     **_lowerCamelCase    ,     ):
     super().__init__(feature_size=_lowerCamelCase    ,     sampling_rate=_lowerCamelCase    ,     padding_value=_lowerCamelCase    ,     **_lowerCamelCase )
     lowerCAmelCase_			=      do_normalize
     lowerCAmelCase_			=      return_attention_mask

     lowerCAmelCase_			=      num_mel_bins
     lowerCAmelCase_			=      hop_length
     lowerCAmelCase_			=      win_length
     lowerCAmelCase_			=      win_function
     lowerCAmelCase_			=      frame_signal_scale
     lowerCAmelCase_			=      fmin
     lowerCAmelCase_			=      fmax
     lowerCAmelCase_			=      mel_floor
     lowerCAmelCase_			=      reduction_factor

     lowerCAmelCase_			=      win_length * sampling_rate // 1000
     lowerCAmelCase_			=      hop_length * sampling_rate // 1000
     lowerCAmelCase_			=      optimal_fft_length(self.sample_size )
     lowerCAmelCase_			=      (self.n_fft // 2) + 1

     lowerCAmelCase_			=      window_function(window_length=self.sample_size    ,     name=self.win_function    ,     periodic=_lowerCamelCase )

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





  @staticmethod
  # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
  def 						UpperCAmelCase_	(	_lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase = 0.0 ):
     if attention_mask is not None:
        lowerCAmelCase_			=      np.array(_lowerCamelCase    ,     np.intaa )
        lowerCAmelCase_			=      []

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

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

     return normed_input_values





  def 						UpperCAmelCase_	(	self    ,     _lowerCamelCase    ,     ):
     lowerCAmelCase_			=      spectrogram(
         _lowerCamelCase    ,     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    ,     _lowerCamelCase = None    ,     _lowerCamelCase = None    ,     _lowerCamelCase = False    ,     _lowerCamelCase = None    ,     _lowerCamelCase = False    ,     _lowerCamelCase = None    ,     _lowerCamelCase = None    ,     _lowerCamelCase = None    ,     _lowerCamelCase = None    ,     **_lowerCamelCase    ,     ):
     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:
        lowerCAmelCase_			=      self._process_audio(
            _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     **_lowerCamelCase    ,     )
     else:
        lowerCAmelCase_			=      None

     if audio_target is not None:
        lowerCAmelCase_			=      self._process_audio(
            _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     _lowerCamelCase    ,     **_lowerCamelCase    ,     )

        if inputs is None:
           return inputs_target
        else:
           lowerCAmelCase_			=      inputs_target['''input_values''']
           lowerCAmelCase_			=      inputs_target.get('''attention_mask''' )
           if decoder_attention_mask is not None:
              lowerCAmelCase_			=      decoder_attention_mask

     return inputs





  def 						UpperCAmelCase_	(	self    ,     _lowerCamelCase    ,     _lowerCamelCase = False    ,     _lowerCamelCase = False    ,     _lowerCamelCase = None    ,     _lowerCamelCase = False    ,     _lowerCamelCase = None    ,     _lowerCamelCase = None    ,     _lowerCamelCase = None    ,     **_lowerCamelCase    ,     ):
     lowerCAmelCase_			=      isinstance(_lowerCamelCase    ,     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}''' )
     lowerCAmelCase_			=      is_batched_numpy or (
         isinstance(_lowerCamelCase    ,     (list, tuple) ) and (isinstance(speech[0]    ,     (np.ndarray, tuple, list) ))
     )

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

     # always return batch
     if not is_batched:
        lowerCAmelCase_			=      [speech]

     # needed to make pad() work on spectrogram inputs
     lowerCAmelCase_			=      self.feature_size

     # convert into correct format for padding
     if is_target:
        lowerCAmelCase_			=      [self._extract_mel_features(_lowerCamelCase ) for waveform in speech]
        lowerCAmelCase_			=      BatchFeature({'''input_values''': features} )
        lowerCAmelCase_			=      self.num_mel_bins
     else:
        lowerCAmelCase_			=      BatchFeature({'''input_values''': speech} )

     lowerCAmelCase_			=      self.pad(
         _lowerCamelCase    ,     padding=_lowerCamelCase    ,     max_length=_lowerCamelCase    ,     truncation=_lowerCamelCase    ,     pad_to_multiple_of=_lowerCamelCase    ,     return_attention_mask=_lowerCamelCase    ,     **_lowerCamelCase    ,     )

     lowerCAmelCase_			=      feature_size_hack

     # convert input values to correct format
     lowerCAmelCase_			=      padded_inputs['''input_values''']
     if not isinstance(input_values[0]    ,     np.ndarray ):
        lowerCAmelCase_			=      [np.asarray(_lowerCamelCase    ,     dtype=np.floataa ) for array in input_values]
     elif (
         not isinstance(_lowerCamelCase    ,     np.ndarray )
         and isinstance(input_values[0]    ,     np.ndarray )
         and input_values[0].dtype is np.dtype(np.floataa )
     ):
        lowerCAmelCase_			=      [array.astype(np.floataa ) for array in input_values]
     elif isinstance(_lowerCamelCase    ,     np.ndarray ) and input_values.dtype is np.dtype(np.floataa ):
        lowerCAmelCase_			=      input_values.astype(np.floataa )

     # convert attention_mask to correct format
     lowerCAmelCase_			=      padded_inputs.get('''attention_mask''' )
     if attention_mask is not None:
        lowerCAmelCase_			=      [np.asarray(_lowerCamelCase    ,     dtype=np.intaa ) for array in attention_mask]

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

     if return_tensors is not None:
        lowerCAmelCase_			=      padded_inputs.convert_to_tensors(_lowerCamelCase )

     return padded_inputs







  def 						UpperCAmelCase_	(	self ):
     lowerCAmelCase_			=      super().to_dict()

     # Don't serialize these as they are derived from the other properties.
     lowerCAmelCase_			=      ['''window''', '''mel_filters''', '''sample_size''', '''sample_stride''', '''n_fft''', '''n_freqs''']
     for name in names:
        if name in output:
           del output[name]

     return output





