





from typing import List, Optional, Union

import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


UpperCAmelCase_     							= logging.get_logger(__name__)






class     lowercase__       (	__lowerCamelCase				):

   '''simple docstring'''


   a						:							Optional[int]   		=		["input_features", "attention_mask"]




   def __init__(    self,		__magic_name__=80,		__magic_name__=16000,		__magic_name__=80,		__magic_name__=0.0,		__magic_name__=True,		__magic_name__=True,		__magic_name__=True,		**__magic_name__,		) ->      Any:






       """simple docstring"""
       super().__init__(feature_size=__magic_name__,		sampling_rate=__magic_name__,		padding_value=__magic_name__,		**__magic_name__							)
       UpperCamelCase__							:				Optional[int]          =      num_mel_bins
       UpperCamelCase__							:				Tuple          =      do_ceptral_normalize
       UpperCamelCase__							:				str          =      normalize_means
       UpperCamelCase__							:				Optional[Any]          =      normalize_vars
       UpperCamelCase__							:				Optional[Any]          =      True




   def       UpperCamelCase__  (    self,		__magic_name__,		) ->      np.ndarray:






       """simple docstring"""
       UpperCamelCase__							:				Tuple          =      waveform * (2**15)  # Kaldi compliance: 16-bit signed integers
       UpperCamelCase__							:				str          =      torch.from_numpy(__magic_name__							).unsqueeze(0							)
       UpperCamelCase__							:				Any          =      ta_kaldi.fbank(__magic_name__,		num_mel_bins=self.num_mel_bins,		sample_frequency=self.sampling_rate							)
       return features.numpy()




   @staticmethod
   def       UpperCamelCase__  (    __magic_name__,		__magic_name__,		__magic_name__ = True,		__magic_name__ = True,		__magic_name__ = 0.0,		) ->      np.ndarray:






       """simple docstring"""
       # make sure we normalize float32 arrays
       if normalize_means:
           UpperCamelCase__							:				Tuple          =      x[:input_length].mean(axis=0							)
           UpperCamelCase__							:				str          =      np.subtract(__magic_name__,		__magic_name__							)
       if normalize_vars:
           UpperCamelCase__							:				List[Any]          =      x[:input_length].std(axis=0							)
           UpperCamelCase__							:				Union[str, Any]          =      np.divide(__magic_name__,		__magic_name__							)

       if input_length < x.shape[0]:
           UpperCamelCase__							:				Tuple          =      padding_value

       # make sure array is in float32
       UpperCamelCase__							:				Any          =      x.astype(np.floataa							)

       return x




   def       UpperCamelCase__  (    self,		__magic_name__,		__magic_name__ = None							) ->      List[np.ndarray]:






       """simple docstring"""
       UpperCamelCase__							:				Any          =      attention_mask.sum(-1							) if attention_mask is not None else [x.shape[0] for x in input_features]
       return [
           self.utterance_cmvn(__magic_name__,		__magic_name__,		self.normalize_means,		self.normalize_vars,		self.padding_value							)
           for x, n in zip(__magic_name__,		__magic_name__							)
       ]




   def __call__(    self,		__magic_name__,		__magic_name__ = False,		__magic_name__ = None,		__magic_name__ = False,		__magic_name__ = None,		__magic_name__ = None,		__magic_name__ = None,		__magic_name__ = None,		**__magic_name__,		) ->      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} was trained using a sampling rate of"
                   f" {self.sampling_rate}. Please make sure that the provided `raw_speech` 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.'''							)

       UpperCamelCase__							:				Optional[Any]          =      isinstance(__magic_name__,		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}"							)
       UpperCamelCase__							:				str          =      is_batched_numpy or (
           isinstance(__magic_name__,		(list, tuple)							) and (isinstance(raw_speech[0],		(np.ndarray, tuple, list)							))
       )

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

       # always return batch
       if not is_batched:
           UpperCamelCase__							:				List[Any]          =      [raw_speech]

       # extract fbank features
       UpperCamelCase__							:				List[str]          =      [self._extract_fbank_features(__magic_name__							) for waveform in raw_speech]

       # convert into correct format for padding
       UpperCamelCase__							:				Union[str, Any]          =      BatchFeature({'''input_features''': features}							)

       UpperCamelCase__							:				Optional[int]          =      self.pad(
           __magic_name__,		padding=__magic_name__,		max_length=__magic_name__,		truncation=__magic_name__,		pad_to_multiple_of=__magic_name__,		return_attention_mask=__magic_name__,		**__magic_name__,		)

       # make sure list is in array format
       UpperCamelCase__							:				Union[str, Any]          =      padded_inputs.get('''input_features'''							)
       if isinstance(input_features[0],		__magic_name__							):
           UpperCamelCase__							:				List[str]          =      [np.asarray(__magic_name__,		dtype=np.floataa							) for feature in input_features]

       UpperCamelCase__							:				Any          =      padded_inputs.get('''attention_mask'''							)
       if attention_mask is not None:
           UpperCamelCase__							:				Dict          =      [np.asarray(__magic_name__,		dtype=np.intaa							) for array in attention_mask]

       # Utterance-level cepstral mean and variance normalization
       if self.do_ceptral_normalize:
           UpperCamelCase__							:				List[Any]          =      (
               np.array(__magic_name__,		dtype=np.intaa							)
               if self._get_padding_strategies(__magic_name__,		max_length=__magic_name__							) is not PaddingStrategy.DO_NOT_PAD
               else None
           )
           UpperCamelCase__							:				List[Any]          =      self.normalize(
               padded_inputs['''input_features'''],		attention_mask=__magic_name__							)

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

       return padded_inputs








from typing import List, Optional, Union

import numpy as np
import PIL.Image

from ...image_processing_utils import BaseImageProcessor, BatchFeature
from ...image_transforms import rescale, resize, to_channel_dimension_format
from ...image_utils import (
    ChannelDimension,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


UpperCAmelCase_     							= logging.get_logger(__name__)






class     lowercase__       (	__lowerCamelCase				):

   '''simple docstring'''


   a						:							str   		=		["pixel_values"]




   def __init__(    self,		__magic_name__ = True,		__magic_name__ = 32,		__magic_name__=PILImageResampling.BILINEAR,		__magic_name__ = True,		**__magic_name__,		) ->      None:






       """simple docstring"""
       UpperCamelCase__							:				int          =      do_resize
       UpperCamelCase__							:				Tuple          =      do_rescale
       UpperCamelCase__							:				Any          =      size_divisor
       UpperCamelCase__							:				List[Any]          =      resample
       super().__init__(**__magic_name__							)




   def       UpperCamelCase__  (    self,		__magic_name__,		__magic_name__,		__magic_name__,		__magic_name__ = None,		**__magic_name__							) ->      np.ndarray:






       """simple docstring"""
       UpperCamelCase__   ,UpperCamelCase__							:				List[Any]          =      get_image_size(__magic_name__							)
       # Rounds the height and width down to the closest multiple of size_divisor
       UpperCamelCase__							:				Any          =      height // size_divisor * size_divisor
       UpperCamelCase__							:				Optional[int]          =      width // size_divisor * size_divisor
       UpperCamelCase__							:				str          =      resize(__magic_name__,		(new_h, new_w),		resample=__magic_name__,		data_format=__magic_name__,		**__magic_name__							)
       return image




   def       UpperCamelCase__  (    self,		__magic_name__,		__magic_name__,		__magic_name__ = None,		**__magic_name__							) ->      np.ndarray:






       """simple docstring"""
       return rescale(image=__magic_name__,		scale=__magic_name__,		data_format=__magic_name__,		**__magic_name__							)




   def       UpperCamelCase__  (    self,		__magic_name__,		__magic_name__ = None,		__magic_name__ = None,		__magic_name__=None,		__magic_name__ = None,		__magic_name__ = None,		__magic_name__ = ChannelDimension.FIRST,		**__magic_name__,		) ->      BatchFeature:






       """simple docstring"""
       UpperCamelCase__							:				str          =      do_resize if do_resize is not None else self.do_resize
       UpperCamelCase__							:				Union[str, Any]          =      do_rescale if do_rescale is not None else self.do_rescale
       UpperCamelCase__							:				Any          =      size_divisor if size_divisor is not None else self.size_divisor
       UpperCamelCase__							:				str          =      resample if resample is not None else self.resample

       if do_resize and size_divisor is None:
           raise ValueError('''size_divisor is required for resizing'''							)

       UpperCamelCase__							:				Union[str, Any]          =      make_list_of_images(__magic_name__							)

       if not valid_images(__magic_name__							):
           raise ValueError('''Invalid image(s)'''							)

       # All transformations expect numpy arrays.
       UpperCamelCase__							:				Optional[Any]          =      [to_numpy_array(__magic_name__							) for img in images]

       if do_resize:
           UpperCamelCase__							:				str          =      [self.resize(__magic_name__,		size_divisor=__magic_name__,		resample=__magic_name__							) for image in images]

       if do_rescale:
           UpperCamelCase__							:				List[Any]          =      [self.rescale(__magic_name__,		scale=1 / 255							) for image in images]

       UpperCamelCase__							:				Optional[Any]          =      [to_channel_dimension_format(__magic_name__,		__magic_name__							) for image in images]

       UpperCamelCase__							:				Tuple          =      {'''pixel_values''': images}
       return BatchFeature(data=__magic_name__,		tensor_type=__magic_name__							)

