




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






class 					lowercase(     __a ):







 '''simple docstring'''





 lowercase__ 					=					["input_values", "attention_mask"]


 def __init__(				self:		Union[str, Any],      a_:		int = 1,      a_:		int = 16_000,      a_:		float = 0.0,      a_:		bool = False,      a_:		int = 80,      a_:		int = 16,      a_:		int = 64,      a_:		str = "hann_window",      a_:		float = 1.0,      a_:		float = 80,      a_:		float = 7_600,      a_:		float = 1E-10,      a_:		int = 2,      a_:		bool = True,      **a_:		Optional[Any],      ):




   '''simple docstring'''



   super().__init__(feature_size=a_,      sampling_rate=a_,      padding_value=a_,      **a_		)
   _snake_case							:		Any								=  do_normalize
   _snake_case							:		Optional[int]								=  return_attention_mask

   _snake_case							:		Optional[Any]								=  num_mel_bins
   _snake_case							:		Optional[Any]								=  hop_length
   _snake_case							:		List[Any]								=  win_length
   _snake_case							:		int								=  win_function
   _snake_case							:		Dict								=  frame_signal_scale
   _snake_case							:		Union[str, Any]								=  fmin
   _snake_case							:		Union[str, Any]								=  fmax
   _snake_case							:		Optional[Any]								=  mel_floor
   _snake_case							:		Optional[int]								=  reduction_factor

   _snake_case							:		List[str]								=  win_length * sampling_rate // 1_000
   _snake_case							:		str								=  hop_length * sampling_rate // 1_000
   _snake_case							:		Optional[int]								=  optimal_fft_length(self.sample_size		)
   _snake_case							:		List[str]								=  (self.n_fft // 2) + 1

   _snake_case							:		int								=  window_function(window_length=self.sample_size,      name=self.win_function,      periodic=a_		)

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


 @staticmethod
 # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
 def  UpperCamelCase_   (				a_:		List[np.ndarray],      a_:		List[np.ndarray],      a_:		float = 0.0		):




   '''simple docstring'''



   if attention_mask is not None:
     _snake_case							:		Union[str, Any]								=  np.array(a_,      np.intaa		)
     _snake_case							:		Optional[int]								=  []

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

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

   return normed_input_values


 def  UpperCamelCase_   (				self:		str,      a_:		np.ndarray,      ):




   '''simple docstring'''



   _snake_case							:		Tuple								=  spectrogram(
       a_,      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:		Tuple,      a_:		Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None,      a_:		Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None,      a_:		Union[bool, str, PaddingStrategy] = False,      a_:		Optional[int] = None,      a_:		bool = False,      a_:		Optional[int] = None,      a_:		Optional[bool] = None,      a_:		Optional[Union[str, TensorType]] = None,      a_:		Optional[int] = None,      **a_:		Any,      ):




   '''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:
     _snake_case							:		Optional[Any]								=  self._process_audio(
         a_,      a_,      a_,      a_,      a_,      a_,      a_,      a_,      **a_,      )
   else:
     _snake_case							:		Optional[int]								=  None

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

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

   return inputs


 def  UpperCamelCase_   (				self:		Dict,      a_:		Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]],      a_:		bool = False,      a_:		Union[bool, str, PaddingStrategy] = False,      a_:		Optional[int] = None,      a_:		bool = False,      a_:		Optional[int] = None,      a_:		Optional[bool] = None,      a_:		Optional[Union[str, TensorType]] = None,      **a_:		List[str],      ):




   '''simple docstring'''



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

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

   # always return batch
   if not is_batched:
     _snake_case							:		Optional[int]								=  [speech]

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

   # convert into correct format for padding
   if is_target:
     _snake_case							:		str								=  [self._extract_mel_features(a_		) for waveform in speech]
     _snake_case							:		Dict								=  BatchFeature({"""input_values""": features}		)
     _snake_case							:		Tuple								=  self.num_mel_bins
   else:
     _snake_case							:		Tuple								=  BatchFeature({"""input_values""": speech}		)

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

   _snake_case							:		int								=  feature_size_hack

   # convert input values to correct format
   _snake_case							:		List[str]								=  padded_inputs["""input_values"""]
   if not isinstance(input_values[0],      np.ndarray		):
     _snake_case							:		Optional[Any]								=  [np.asarray(a_,      dtype=np.floataa		) for array in input_values]
   elif (
       not isinstance(a_,      np.ndarray		)
       and isinstance(input_values[0],      np.ndarray		)
       and input_values[0].dtype is np.dtype(np.floataa		)
   ):
     _snake_case							:		str								=  [array.astype(np.floataa		) for array in input_values]
   elif isinstance(a_,      np.ndarray		) and input_values.dtype is np.dtype(np.floataa		):
     _snake_case							:		Optional[Any]								=  input_values.astype(np.floataa		)

   # convert attention_mask to correct format
   _snake_case							:		Optional[Any]								=  padded_inputs.get("""attention_mask"""		)
   if attention_mask is not None:
     _snake_case							:		Dict								=  [np.asarray(a_,      dtype=np.intaa		) for array in attention_mask]

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

   if return_tensors is not None:
     _snake_case							:		Union[str, Any]								=  padded_inputs.convert_to_tensors(a_		)

   return padded_inputs


 def  UpperCamelCase_   (				self:		Dict		):




   '''simple docstring'''



   _snake_case							:		List[Any]								=  super().to_dict()

   # Don't serialize these as they are derived from the other properties.
   _snake_case							:		List[str]								=  ["""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"""


import re
import warnings
from contextlib import contextmanager

from ...processing_utils import ProcessorMixin






class 					lowercase(     __a ):







 '''simple docstring'''





 lowercase__ 					=					["image_processor", "tokenizer"]
 lowercase__ 					=					"AutoImageProcessor"
 lowercase__ 					=					"AutoTokenizer"


 def __init__(				self:		List[str],      a_:		List[str]=None,      a_:		Tuple=None,      **a_:		Tuple		):




   '''simple docstring'''



   _snake_case							:		str								=  None
   if "feature_extractor" in kwargs:
     warnings.warn(
         """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
         """ instead.""",      a_,      )
     _snake_case							:		str								=  kwargs.pop("""feature_extractor"""		)

   _snake_case							:		Union[str, Any]								=  image_processor if image_processor is not None else feature_extractor
   if image_processor is None:
     raise ValueError("""You need to specify an `image_processor`."""		)
   if tokenizer is None:
     raise ValueError("""You need to specify a `tokenizer`."""		)

   super().__init__(a_,      a_		)
   _snake_case							:		Dict								=  self.image_processor
   _snake_case							:		Any								=  False


 def __call__(				self:		Any,      *a_:		Any,      **a_:		Tuple		):




   '''simple docstring'''



   if self._in_target_context_manager:
     return self.current_processor(*a_,      **a_		)

   _snake_case							:		Dict								=  kwargs.pop("""images""",      a_		)
   _snake_case							:		Optional[Any]								=  kwargs.pop("""text""",      a_		)
   if len(a_		) > 0:
     _snake_case							:		Optional[int]								=  args[0]
     _snake_case							:		Tuple								=  args[1:]

   if images is None and text is None:
     raise ValueError("""You need to specify either an `images` or `text` input to process."""		)

   if images is not None:
     _snake_case							:		Tuple								=  self.image_processor(a_,      *a_,      **a_		)
   if text is not None:
     _snake_case							:		Tuple								=  self.tokenizer(a_,      **a_		)

   if text is None:
     return inputs
   elif images is None:
     return encodings
   else:
     _snake_case							:		List[str]								=  encodings["""input_ids"""]
     return inputs


 def  UpperCamelCase_   (				self:		Optional[int],      *a_:		Tuple,      **a_:		List[str]		):




   '''simple docstring'''



   return self.tokenizer.batch_decode(*a_,      **a_		)


 def  UpperCamelCase_   (				self:		int,      *a_:		List[str],      **a_:		int		):




   '''simple docstring'''



   return self.tokenizer.decode(*a_,      **a_		)


 @contextmanager
 def  UpperCamelCase_   (				self:		Dict		):




   '''simple docstring'''



   warnings.warn(
       """`as_target_processor` is deprecated and will be removed in v5 of Transformers. You can process your """
       """labels by using the argument `text` of the regular `__call__` method (either in the same call as """
       """your images inputs, or in a separate call."""		)
   _snake_case							:		Any								=  True
   _snake_case							:		Optional[int]								=  self.tokenizer
   yield
   _snake_case							:		int								=  self.image_processor
   _snake_case							:		Optional[int]								=  False


 def  UpperCamelCase_   (				self:		Dict,      a_:		Optional[Any],      a_:		str=False,      a_:		Optional[Any]=None		):




   '''simple docstring'''



   if added_vocab is None:
     _snake_case							:		Dict								=  self.tokenizer.get_added_vocab()

   _snake_case							:		str								=  {}

   while tokens:
     _snake_case							:		Union[str, Any]								=  re.search(r"""<s_(.*?)>""",      a_,      re.IGNORECASE		)
     if start_token is None:
       break
     _snake_case							:		List[Any]								=  start_token.group(1		)
     _snake_case							:		str								=  re.search(rf"</s_{key}>",      a_,      re.IGNORECASE		)
     _snake_case							:		Dict								=  start_token.group()
     if end_token is None:
       _snake_case							:		List[Any]								=  tokens.replace(a_,      """"""		)
     else:
       _snake_case							:		List[str]								=  end_token.group()
       _snake_case							:		str								=  re.escape(a_		)
       _snake_case							:		str								=  re.escape(a_		)
       _snake_case							:		Union[str, Any]								=  re.search(f"{start_token_escaped}(.*?){end_token_escaped}",      a_,      re.IGNORECASE		)
       if content is not None:
         _snake_case							:		int								=  content.group(1		).strip()
         if r"<s_" in content and r"</s_" in content:  # non-leaf node
           _snake_case							:		List[Any]								=  self.tokenajson(a_,      is_inner_value=a_,      added_vocab=a_		)
           if value:
             if len(a_		) == 1:
               _snake_case							:		List[str]								=  value[0]
             _snake_case							:		List[str]								=  value
         else:  # leaf nodes
           _snake_case							:		Tuple								=  []
           for leaf in content.split(r"""<sep/>"""		):
             _snake_case							:		Tuple								=  leaf.strip()
             if leaf in added_vocab and leaf[0] == "<" and leaf[-2:] == "/>":
               _snake_case							:		int								=  leaf[1:-2]  # for categorical special tokens
             output[key].append(a_		)
           if len(output[key]		) == 1:
             _snake_case							:		int								=  output[key][0]

       _snake_case							:		Any								=  tokens[tokens.find(a_		) + len(a_		) :].strip()
       if tokens[:6] == r"<sep/>":  # non-leaf nodes
         return [output] + self.tokenajson(tokens[6:],      is_inner_value=a_,      added_vocab=a_		)

   if len(a_		):
     return [output] if is_inner_value else output
   else:
     return [] if is_inner_value else {"text_sequence": tokens}


 @property
 def  UpperCamelCase_   (				self:		Optional[int]		):




   '''simple docstring'''



   warnings.warn(
       """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.""",      a_,      )
   return self.image_processor_class


 @property
 def  UpperCamelCase_   (				self:		Tuple		):




   '''simple docstring'''



   warnings.warn(
       """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.""",      a_,      )
   return self.image_processor


