




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


_lowerCamelCase			:	Union[str, Any]							 =     logging.get_logger(__name__)


class        UpperCamelCase_					(				UpperCAmelCase__  ):

    '''simple docstring'''






    UpperCAmelCase__													=   ['''input_values''', '''attention_mask''']


    def __init__(    self   :			Tuple      ,				UpperCAmelCase__   :			Optional[Any] = 1      ,				UpperCAmelCase__   :			Any = 16_000      ,				UpperCAmelCase__   :			List[str] = 0.0      ,				UpperCAmelCase__   :			List[Any] = False      ,				UpperCAmelCase__   :			Optional[Any] = 80      ,				UpperCAmelCase__   :			Tuple = 16      ,				UpperCAmelCase__   :			Tuple = 64      ,				UpperCAmelCase__   :			List[str] = "hann_window"      ,				UpperCAmelCase__   :			Optional[int] = 1.0      ,				UpperCAmelCase__   :			str = 80      ,				UpperCAmelCase__   :			Any = 7_600      ,				UpperCAmelCase__   :			str = 1e-10      ,				UpperCAmelCase__   :			Optional[int] = 2      ,				UpperCAmelCase__   :			Tuple = True      ,				**UpperCAmelCase__   :			int      ,				)		->Optional[Any]:





           '''simple docstring'''

           super().__init__(feature_size=UpperCAmelCase__      ,				sampling_rate=UpperCAmelCase__      ,				padding_value=UpperCAmelCase__      ,				**UpperCAmelCase__)
           A__   				=					do_normalize
           A__   				=					return_attention_mask

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

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

           A__   				=					window_function(window_length=self.sample_size      ,				name=self.win_function      ,				periodic=UpperCAmelCase__)

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


    @staticmethod
    # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
    def  SCREAMING_SNAKE_CASE							(    UpperCAmelCase__   :			List[str]      ,				UpperCAmelCase__   :			Optional[Any]      ,				UpperCAmelCase__   :			Optional[Any] = 0.0)		->Optional[Any]:





           '''simple docstring'''

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

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

                         normed_input_values.append(UpperCAmelCase__)
           else:
                  A__   				=					[(x - x.mean()) / np.sqrt(x.var() + 1e-7) for x in input_values]

           return normed_input_values


    def  SCREAMING_SNAKE_CASE							(    self   :			List[Any]      ,				UpperCAmelCase__   :			Any      ,				)		->Tuple:





           '''simple docstring'''

           A__   				=					spectrogram(
               UpperCAmelCase__      ,				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   :			List[str]      ,				UpperCAmelCase__   :			List[str] = None      ,				UpperCAmelCase__   :			List[Any] = None      ,				UpperCAmelCase__   :			List[Any] = False      ,				UpperCAmelCase__   :			Optional[Any] = None      ,				UpperCAmelCase__   :			Optional[Any] = False      ,				UpperCAmelCase__   :			Union[str, Any] = None      ,				UpperCAmelCase__   :			int = None      ,				UpperCAmelCase__   :			Optional[int] = None      ,				UpperCAmelCase__   :			List[Any] = None      ,				**UpperCAmelCase__   :			Any      ,				)		->List[str]:





           '''simple docstring'''

           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:
                  A__   				=					self._process_audio(
                      UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				**UpperCAmelCase__      ,				)
           else:
                  A__   				=					None

           if audio_target is not None:
                  A__   				=					self._process_audio(
                      UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				UpperCAmelCase__      ,				**UpperCAmelCase__      ,				)

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

           return inputs


    def  SCREAMING_SNAKE_CASE							(    self   :			Optional[int]      ,				UpperCAmelCase__   :			List[str]      ,				UpperCAmelCase__   :			Optional[int] = False      ,				UpperCAmelCase__   :			str = False      ,				UpperCAmelCase__   :			str = None      ,				UpperCAmelCase__   :			Dict = False      ,				UpperCAmelCase__   :			Dict = None      ,				UpperCAmelCase__   :			int = None      ,				UpperCAmelCase__   :			Any = None      ,				**UpperCAmelCase__   :			Dict      ,				)		->Tuple:





           '''simple docstring'''

           A__   				=					isinstance(UpperCAmelCase__      ,				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}""")
           A__   				=					is_batched_numpy or (
               isinstance(UpperCAmelCase__      ,				(list, tuple)) and (isinstance(speech[0]      ,				(np.ndarray, tuple, list)))
           )

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

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

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

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

           A__   				=					self.pad(
               UpperCAmelCase__      ,				padding=UpperCAmelCase__      ,				max_length=UpperCAmelCase__      ,				truncation=UpperCAmelCase__      ,				pad_to_multiple_of=UpperCAmelCase__      ,				return_attention_mask=UpperCAmelCase__      ,				**UpperCAmelCase__      ,				)

           A__   				=					feature_size_hack

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

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

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

           if return_tensors is not None:
                  A__   				=					padded_inputs.convert_to_tensors(UpperCAmelCase__)

           return padded_inputs





    def  SCREAMING_SNAKE_CASE							(    self   :			Tuple)		->int:





           '''simple docstring'''

           A__   				=					super().to_dict()

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

           return output







from typing import TYPE_CHECKING

from ...file_utils import _LazyModule, is_tokenizers_available, is_torch_available, is_vision_available
from ...utils import OptionalDependencyNotAvailable


_lowerCamelCase			:	Union[str, Any]							 =     {"""configuration_dpt""": ["""DPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DPTConfig"""]}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase			:	Optional[Any]							 =     ["""DPTFeatureExtractor"""]
  _lowerCamelCase			:	int							 =     ["""DPTImageProcessor"""]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase			:	Optional[int]							 =     [
      """DPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """DPTForDepthEstimation""",
      """DPTForSemanticSegmentation""",
      """DPTModel""",
      """DPTPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_dpt import DPT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPTConfig

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .feature_extraction_dpt import DPTFeatureExtractor
    from .image_processing_dpt import DPTImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_dpt import (
        DPT_PRETRAINED_MODEL_ARCHIVE_LIST,
        DPTForDepthEstimation,
        DPTForSemanticSegmentation,
        DPTModel,
        DPTPreTrainedModel,
    )


else:
  import sys

  _lowerCamelCase			:	Any							 =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


