

'''simple docstring'''





import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


UpperCAmelCase__ :     Any				    =    logging.get_logger(__name__)







class        a__       (   UpperCAmelCase       ):







  """simple docstring"""




  UpperCAmelCase__      : List[str]			       =["""input_features"""]


  def __init__(			self    : str				,				UpperCAmelCase__    : Tuple=8_0				,				UpperCAmelCase__    : Tuple=1_6_0_0_0				,				UpperCAmelCase__    : List[str]=1_6_0				,				UpperCAmelCase__    : List[Any]=3_0				,				UpperCAmelCase__    : str=4_0_0				,				UpperCAmelCase__    : Any=0.0				,				UpperCAmelCase__    : Optional[int]=False				,				**UpperCAmelCase__    : List[Any]				,				)					->Any:
        """simple docstring"""







        super().__init__(
            feature_size=UpperCAmelCase__				,				sampling_rate=UpperCAmelCase__				,				padding_value=UpperCAmelCase__				,				return_attention_mask=UpperCAmelCase__				,				**UpperCAmelCase__				,				)
        SCREAMING_SNAKE_CASE :      List[str]       =   n_fft
        SCREAMING_SNAKE_CASE :      Optional[int]       =   hop_length
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   chunk_length
        SCREAMING_SNAKE_CASE :      str       =   chunk_length * sampling_rate
        SCREAMING_SNAKE_CASE :      List[str]       =   self.n_samples // hop_length
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   sampling_rate
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   mel_filter_bank(
            num_frequency_bins=1 + n_fft // 2				,				num_mel_filters=UpperCAmelCase__				,				min_frequency=0.0				,				max_frequency=8_0_0_0.0				,				sampling_rate=UpperCAmelCase__				,				norm="""slaney"""				,				mel_scale="""slaney"""				,				)


  def  _lowercase      (			self    : Optional[int]				,				UpperCAmelCase__    : np.array		)					->np.ndarray:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Optional[int]       =   spectrogram(
            UpperCAmelCase__				,				window_function(self.n_fft				,				"""hann"""		)				,				frame_length=self.n_fft				,				hop_length=self.hop_length				,				power=2.0				,				mel_filters=self.mel_filters				,				log_mel="""log10"""				,				)
        SCREAMING_SNAKE_CASE :      str       =   log_spec[:, :-1]
        SCREAMING_SNAKE_CASE :      Union[str, Any]       =   np.maximum(UpperCAmelCase__				,				log_spec.max() - 8.0		)
        SCREAMING_SNAKE_CASE :      List[Any]       =   (log_spec + 4.0) / 4.0
        return log_spec


  @staticmethod
  # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
  def  _lowercase      (			UpperCAmelCase__    : List[np.ndarray]				,				UpperCAmelCase__    : List[np.ndarray]				,				UpperCAmelCase__    : float = 0.0		)					->List[np.ndarray]:
        """simple docstring"""







        if attention_mask is not None:
              SCREAMING_SNAKE_CASE :      List[str]       =   np.array(UpperCAmelCase__				,				np.intaa		)
              SCREAMING_SNAKE_CASE :      Dict       =   []

              for vector, length in zip(UpperCAmelCase__				,				attention_mask.sum(-1		)		):
                    SCREAMING_SNAKE_CASE :      Tuple       =   (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7		)
                    if length < normed_slice.shape[0]:
                          SCREAMING_SNAKE_CASE :      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 __call__(			self    : Optional[int]				,				UpperCAmelCase__    : Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]				,				UpperCAmelCase__    : bool = True				,				UpperCAmelCase__    : Optional[int] = None				,				UpperCAmelCase__    : Optional[Union[str, TensorType]] = None				,				UpperCAmelCase__    : Optional[bool] = None				,				UpperCAmelCase__    : Optional[str] = "max_length"				,				UpperCAmelCase__    : Optional[int] = None				,				UpperCAmelCase__    : Optional[int] = None				,				UpperCAmelCase__    : Optional[bool] = None				,				**UpperCAmelCase__    : Dict				,				)					->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.__class__.__name__} was trained using a"
                        f" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"
                        f" was sampled with {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."""		)

        SCREAMING_SNAKE_CASE :      List[Any]       =   isinstance(UpperCAmelCase__				,				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}"		)
        SCREAMING_SNAKE_CASE :      Tuple       =   is_batched_numpy or (
            isinstance(UpperCAmelCase__				,				(list, tuple)		) and (isinstance(raw_speech[0]				,				(np.ndarray, tuple, list)		))
        )

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

        # always return batch
        if not is_batched:
              SCREAMING_SNAKE_CASE :      Optional[Any]       =   [np.asarray([raw_speech]		).T]

        SCREAMING_SNAKE_CASE :      List[str]       =   BatchFeature({"""input_features""": raw_speech}		)

        # convert into correct format for padding

        SCREAMING_SNAKE_CASE :      Tuple       =   self.pad(
            UpperCAmelCase__				,				padding=UpperCAmelCase__				,				max_length=max_length if max_length else self.n_samples				,				truncation=UpperCAmelCase__				,				pad_to_multiple_of=UpperCAmelCase__				,				return_attention_mask=return_attention_mask or do_normalize				,				)

        # zero-mean and unit-variance normalization
        if do_normalize:
              SCREAMING_SNAKE_CASE :      Optional[Any]       =   self.zero_mean_unit_var_norm(
                  padded_inputs["""input_features"""]				,				attention_mask=padded_inputs["""attention_mask"""]				,				padding_value=self.padding_value				,				)
              SCREAMING_SNAKE_CASE :      Union[str, Any]       =   np.stack(padded_inputs["""input_features"""]				,				axis=0		)

        # make sure list is in array format
        SCREAMING_SNAKE_CASE :      str       =   padded_inputs.get("""input_features"""		).transpose(2				,				0				,				1		)

        SCREAMING_SNAKE_CASE :      str       =   [self._np_extract_fbank_features(UpperCAmelCase__		) for waveform in input_features[0]]

        if isinstance(input_features[0]				,				UpperCAmelCase__		):
              SCREAMING_SNAKE_CASE :      int       =   [np.asarray(UpperCAmelCase__				,				dtype=np.floataa		) for feature in input_features]
        else:
              SCREAMING_SNAKE_CASE :      List[Any]       =   input_features

        if return_attention_mask:
              # rescale from sample (48000) to feature (3000)
              SCREAMING_SNAKE_CASE :      List[str]       =   padded_inputs["""attention_mask"""][:, :: self.hop_length]

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

        return padded_inputs




  def  _lowercase      (			self    : List[str]		)					->Dict[str, Any]:
        """simple docstring"""







        SCREAMING_SNAKE_CASE :      Dict       =   copy.deepcopy(self.__dict__		)
        SCREAMING_SNAKE_CASE :      Optional[Any]       =   self.__class__.__name__
        if "mel_filters" in output:
              del output["mel_filters"]
        return output







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


UpperCAmelCase__ :     str				    =    {"""processing_layoutxlm""": ["""LayoutXLMProcessor"""]}

try:
  if not is_sentencepiece_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase__ :     Any				    =    ["""LayoutXLMTokenizer"""]

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  UpperCAmelCase__ :     List[str]				    =    ["""LayoutXLMTokenizerFast"""]

if TYPE_CHECKING:
  from .processing_layoutxlm import LayoutXLMProcessor

  try:
    if not is_sentencepiece_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_layoutxlm import LayoutXLMTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_layoutxlm_fast import LayoutXLMTokenizerFast

else:
  import sys

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




