

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






class _UpperCamelCase							(							a__      ):
			'''simple docstring'''







			lowerCamelCase__							=['input_values', 'attention_mask']
			def __init__(	self							:       List[str]					,					a							:       Dict = 1					,					a							:       Optional[Any] = 1_6000					,					a							:       Optional[int] = 0.0					,					a							:       Dict = False					,					a							:       List[str] = 80					,					a							:       Dict = 16					,					a							:       Union[str, Any] = 64					,					a							:       Tuple = "hann_window"					,					a							:       Tuple = 1.0					,					a							:       Optional[Any] = 80					,					a							:       Dict = 7600					,					a							:       Tuple = 1e-10					,					a							:       Optional[Any] = 2					,					a							:       Dict = True					,					**a							:       Dict					,					)							->				Union[str, Any]:

				"""simple docstring"""

				super().__init__(feature_size=_UpperCAmelCase					,					sampling_rate=_UpperCAmelCase					,					padding_value=_UpperCAmelCase					,					**_UpperCAmelCase		)
				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				do_normalize
				SCREAMING_SNAKE_CASE      :					Any    =				return_attention_mask

				SCREAMING_SNAKE_CASE      :					int    =				num_mel_bins
				SCREAMING_SNAKE_CASE      :					str    =				hop_length
				SCREAMING_SNAKE_CASE      :					Any    =				win_length
				SCREAMING_SNAKE_CASE      :					int    =				win_function
				SCREAMING_SNAKE_CASE      :					int    =				frame_signal_scale
				SCREAMING_SNAKE_CASE      :					int    =				fmin
				SCREAMING_SNAKE_CASE      :					int    =				fmax
				SCREAMING_SNAKE_CASE      :					Any    =				mel_floor
				SCREAMING_SNAKE_CASE      :					Tuple    =				reduction_factor

				SCREAMING_SNAKE_CASE      :					Tuple    =				win_length * sampling_rate // 1000
				SCREAMING_SNAKE_CASE      :					Optional[int]    =				hop_length * sampling_rate // 1000
				SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				optimal_fft_length(self.sample_size		)
				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				(self.n_fft // 2) + 1

				SCREAMING_SNAKE_CASE      :					Dict    =				window_function(window_length=self.sample_size					,					name=self.win_function					,					periodic=_UpperCAmelCase		)

				SCREAMING_SNAKE_CASE      :					Any    =				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 							__UpperCamelCase       (	a							:       str					,					a							:       Optional[int]					,					a							:       Union[str, Any] = 0.0		)							->				Optional[int]:

				"""simple docstring"""

				if attention_mask is not None:
					SCREAMING_SNAKE_CASE      :					Any    =				np.array(_UpperCAmelCase					,					np.intaa		)
					SCREAMING_SNAKE_CASE      :					Any    =				[]

					for vector, length in zip(_UpperCAmelCase					,					attention_mask.sum(-1		)		):
						SCREAMING_SNAKE_CASE      :					List[Any]    =				(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7		)
						if length < normed_slice.shape[0]:
							SCREAMING_SNAKE_CASE      :					Optional[int]    =				padding_value

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

				return normed_input_values
			def 							__UpperCamelCase       (	self							:       Any					,					a							:       Any					,					)							->				str:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					str    =				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[Any]					,					a							:       str = None					,					a							:       Any = None					,					a							:       Dict = False					,					a							:       str = None					,					a							:       int = False					,					a							:       List[str] = None					,					a							:       str = None					,					a							:       Any = None					,					a							:       List[str] = None					,					**a							:       Dict					,					)							->				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:
					SCREAMING_SNAKE_CASE      :					Optional[Any]    =				self._process_audio(
					    _UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					**_UpperCAmelCase					,					)
				else:
					SCREAMING_SNAKE_CASE      :					Optional[int]    =				None

				if audio_target is not None:
					SCREAMING_SNAKE_CASE      :					List[Any]    =				self._process_audio(
					    _UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					_UpperCAmelCase					,					**_UpperCAmelCase					,					)

					if inputs is None:
						return inputs_target
					else:
						SCREAMING_SNAKE_CASE      :					Optional[int]    =				inputs_target['input_values']
						SCREAMING_SNAKE_CASE      :					Optional[Any]    =				inputs_target.get("attention_mask"		)
						if decoder_attention_mask is not None:
							SCREAMING_SNAKE_CASE      :					Optional[int]    =				decoder_attention_mask

				return inputs
			def 							__UpperCamelCase       (	self							:       Optional[int]					,					a							:       Any					,					a							:       int = False					,					a							:       List[str] = False					,					a							:       Any = None					,					a							:       Any = False					,					a							:       Optional[Any] = None					,					a							:       Tuple = None					,					a							:       str = None					,					**a							:       str					,					)							->				Dict:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					List[str]    =				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}"		)
				SCREAMING_SNAKE_CASE      :					Optional[int]    =				is_batched_numpy or (
				    isinstance(_UpperCAmelCase					,					(list, tuple)		) and (isinstance(speech[0]					,					(np.ndarray, tuple, list)		))
				)

				if is_batched:
					SCREAMING_SNAKE_CASE      :					Tuple    =				[np.asarray(_UpperCAmelCase					,					dtype=np.floataa		) for speech in speech]
				elif not is_batched and not isinstance(_UpperCAmelCase					,					np.ndarray		):
					SCREAMING_SNAKE_CASE      :					List[Any]    =				np.asarray(_UpperCAmelCase					,					dtype=np.floataa		)
				elif isinstance(_UpperCAmelCase					,					np.ndarray		) and speech.dtype is np.dtype(np.floataa		):
					SCREAMING_SNAKE_CASE      :					Optional[int]    =				speech.astype(np.floataa		)

				# always return batch
				if not is_batched:
					SCREAMING_SNAKE_CASE      :					List[str]    =				[speech]

				# needed to make pad() work on spectrogram inputs
				SCREAMING_SNAKE_CASE      :					int    =				self.feature_size

				# convert into correct format for padding
				if is_target:
					SCREAMING_SNAKE_CASE      :					str    =				[self._extract_mel_features(_UpperCAmelCase		) for waveform in speech]
					SCREAMING_SNAKE_CASE      :					List[Any]    =				BatchFeature({"input_values": features}		)
					SCREAMING_SNAKE_CASE      :					List[Any]    =				self.num_mel_bins
				else:
					SCREAMING_SNAKE_CASE      :					Optional[Any]    =				BatchFeature({"input_values": speech}		)

				SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				self.pad(
				    _UpperCAmelCase					,					padding=_UpperCAmelCase					,					max_length=_UpperCAmelCase					,					truncation=_UpperCAmelCase					,					pad_to_multiple_of=_UpperCAmelCase					,					return_attention_mask=_UpperCAmelCase					,					**_UpperCAmelCase					,					)

				SCREAMING_SNAKE_CASE      :					Tuple    =				feature_size_hack

				# convert input values to correct format
				SCREAMING_SNAKE_CASE      :					Optional[Any]    =				padded_inputs['input_values']
				if not isinstance(input_values[0]					,					np.ndarray		):
					SCREAMING_SNAKE_CASE      :					Dict    =				[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		)
				):
					SCREAMING_SNAKE_CASE      :					Any    =				[array.astype(np.floataa		) for array in input_values]
				elif isinstance(_UpperCAmelCase					,					np.ndarray		) and input_values.dtype is np.dtype(np.floataa		):
					SCREAMING_SNAKE_CASE      :					Any    =				input_values.astype(np.floataa		)

				# convert attention_mask to correct format
				SCREAMING_SNAKE_CASE      :					Dict    =				padded_inputs.get("attention_mask"		)
				if attention_mask is not None:
					SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				[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:
					SCREAMING_SNAKE_CASE      :					str    =				(
					    attention_mask
					    if self._get_padding_strategies(_UpperCAmelCase					,					max_length=_UpperCAmelCase		) is not PaddingStrategy.DO_NOT_PAD
					    else None
					)
					SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				self.zero_mean_unit_var_norm(
					    padded_inputs["input_values"]					,					attention_mask=_UpperCAmelCase					,					padding_value=self.padding_value		)

				if return_tensors is not None:
					SCREAMING_SNAKE_CASE      :					List[Any]    =				padded_inputs.convert_to_tensors(_UpperCAmelCase		)

				return padded_inputs






			def 							__UpperCamelCase       (	self							:       str		)							->				Dict:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					List[str]    =				super().to_dict()

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

				return output






'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase__    :      List[str]						=    {
    '''configuration_git''': ['''GIT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GitConfig''', '''GitVisionConfig'''],
    '''processing_git''': ['''GitProcessor'''],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  lowercase__    :      Any						=    [
      '''GIT_PRETRAINED_MODEL_ARCHIVE_LIST''',
      '''GitForCausalLM''',
      '''GitModel''',
      '''GitPreTrainedModel''',
      '''GitVisionModel''',
  ]

if TYPE_CHECKING:
  from .configuration_git import GIT_PRETRAINED_CONFIG_ARCHIVE_MAP, GitConfig, GitVisionConfig
  from .processing_git import GitProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_git import (
        GIT_PRETRAINED_MODEL_ARCHIVE_LIST,
        GitForCausalLM,
        GitModel,
        GitPreTrainedModel,
        GitVisionModel,
    )

else:
  import sys

  lowercase__    :      List[str]						=    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)