

from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import center_crop, normalize, rescale, resize, to_channel_dimension_format
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


if is_vision_available():
  import PIL


lowercase_									=   logging.get_logger(__name__)





class  __lowerCAmelCase     (					SCREAMING_SNAKE_CASE							):
  _a									=  ["""pixel_values"""]




  def __init__(				self							,   lowerCAmelCase = True							,   lowerCAmelCase = None							,   lowerCAmelCase = PIL.Image.BICUBIC							,   lowerCAmelCase = True							,   lowerCAmelCase = None							,   lowerCAmelCase = 1 / 255							,   lowerCAmelCase = True							,   lowerCAmelCase = True							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   **lowerCAmelCase							,   )  -> None:
        '''simple docstring'''






        super().__init__(**lowerCAmelCase					)
        _lowercase	       =size if size is not None else {'height': 256, 'width': 256}
        _lowercase	       =get_size_dict(lowerCAmelCase					)
        _lowercase	       =crop_size if crop_size is not None else {'height': 224, 'width': 224}
        _lowercase	       =get_size_dict(lowerCAmelCase							,   param_name='crop_size'					)

        _lowercase	       =do_resize
        _lowercase	       =size
        _lowercase	       =resample
        _lowercase	       =do_center_crop
        _lowercase	       =crop_size
        _lowercase	       =do_rescale
        _lowercase	       =rescale_factor
        _lowercase	       =do_normalize
        _lowercase	       =image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
        _lowercase	       =image_std if image_std is not None else IMAGENET_STANDARD_STD




  def   A__     (				self							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase = PIL.Image.BICUBIC							,   lowerCAmelCase = None							,   **lowerCAmelCase							,   )  -> np.ndarray:
        '''simple docstring'''






        _lowercase	       =get_size_dict(lowerCAmelCase					)
        if "height" not in size or "width" not in size:
              raise ValueError(F'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'''					)
        return resize(
            lowerCAmelCase							,   size=(size['height'], size['width'])							,   resample=lowerCAmelCase							,   data_format=lowerCAmelCase							,   **lowerCAmelCase					)




  def   A__     (				self							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase = None							,   **lowerCAmelCase							,   )  -> np.ndarray:
        '''simple docstring'''






        _lowercase	       =get_size_dict(lowerCAmelCase					)
        if "height" not in size or "width" not in size:
              raise ValueError(F'''The size dictionary must have keys \'height\' and \'width\'. Got {size.keys()}'''					)
        return center_crop(lowerCAmelCase							,   size=(size['height'], size['width'])							,   data_format=lowerCAmelCase							,   **lowerCAmelCase					)




  def   A__     (				self							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase = None							,   **lowerCAmelCase							,   )  -> str:
        '''simple docstring'''






        return rescale(lowerCAmelCase							,   scale=lowerCAmelCase							,   data_format=lowerCAmelCase							,   **lowerCAmelCase					)




  def   A__     (				self							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase = None							,   **lowerCAmelCase							,   )  -> np.ndarray:
        '''simple docstring'''






        return normalize(lowerCAmelCase							,   mean=lowerCAmelCase							,   std=lowerCAmelCase							,   data_format=lowerCAmelCase							,   **lowerCAmelCase					)




  def   A__     (				self							,   lowerCAmelCase							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase=None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = ChannelDimension.FIRST							,   **lowerCAmelCase							,   )  -> PIL.Image.Image:
        '''simple docstring'''






        _lowercase	       =do_resize if do_resize is not None else self.do_resize
        _lowercase	       =resample if resample is not None else self.resample
        _lowercase	       =do_center_crop if do_center_crop is not None else self.do_center_crop
        _lowercase	       =do_rescale if do_rescale is not None else self.do_rescale
        _lowercase	       =rescale_factor if rescale_factor is not None else self.rescale_factor
        _lowercase	       =do_normalize if do_normalize is not None else self.do_normalize
        _lowercase	       =image_mean if image_mean is not None else self.image_mean
        _lowercase	       =image_std if image_std is not None else self.image_std

        _lowercase	       =size if size is not None else self.size
        _lowercase	       =get_size_dict(lowerCAmelCase					)
        _lowercase	       =crop_size if crop_size is not None else self.crop_size
        _lowercase	       =get_size_dict(lowerCAmelCase							,   param_name='crop_size'					)

        _lowercase	       =make_list_of_images(lowerCAmelCase					)

        if not valid_images(lowerCAmelCase					):
              raise ValueError(
                  'Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, '
                  'torch.Tensor, tf.Tensor or jax.ndarray.'					)

        if do_resize and size is None or resample is None:
              raise ValueError('Size and resample must be specified if do_resize is True.'					)

        if do_center_crop and crop_size is None:
              raise ValueError('Crop size must be specified if do_center_crop is True.'					)

        if do_rescale and rescale_factor is None:
              raise ValueError('Rescale factor must be specified if do_rescale is True.'					)

        if do_normalize and (image_mean is None or image_std is None):
              raise ValueError('Image mean and std must be specified if do_normalize is True.'					)

        # All transformations expect numpy arrays.
        _lowercase	       =[to_numpy_array(lowerCAmelCase					) for image in images]

        if do_resize:
              _lowercase	       =[self.resize(image=lowerCAmelCase							,   size=lowerCAmelCase							,   resample=lowerCAmelCase					) for image in images]

        if do_center_crop:
              _lowercase	       =[self.center_crop(image=lowerCAmelCase							,   size=lowerCAmelCase					) for image in images]

        if do_rescale:
              _lowercase	       =[self.rescale(image=lowerCAmelCase							,   scale=lowerCAmelCase					) for image in images]

        if do_normalize:
              _lowercase	       =[self.normalize(image=lowerCAmelCase							,   mean=lowerCAmelCase							,   std=lowerCAmelCase					) for image in images]

        _lowercase	       =[to_channel_dimension_format(lowerCAmelCase							,   lowerCAmelCase					) for image in images]

        _lowercase	       ={'pixel_values': images}
        return BatchFeature(data=lowerCAmelCase							,   tensor_type=lowerCAmelCase					)





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


lowercase_									=   logging.get_logger(__name__)





class  __lowerCAmelCase     (					SCREAMING_SNAKE_CASE							):
  _a									=  ["""input_features"""]




  def __init__(				self							,   lowerCAmelCase=80							,   lowerCAmelCase=16_000							,   lowerCAmelCase=160							,   lowerCAmelCase=30							,   lowerCAmelCase=400							,   lowerCAmelCase=0.0							,   lowerCAmelCase=False							,   **lowerCAmelCase							,   )  -> Any:
        '''simple docstring'''






        super().__init__(
            feature_size=lowerCAmelCase							,   sampling_rate=lowerCAmelCase							,   padding_value=lowerCAmelCase							,   return_attention_mask=lowerCAmelCase							,   **lowerCAmelCase							,   )
        _lowercase	       =n_fft
        _lowercase	       =hop_length
        _lowercase	       =chunk_length
        _lowercase	       =chunk_length * sampling_rate
        _lowercase	       =self.n_samples // hop_length
        _lowercase	       =sampling_rate
        _lowercase	       =mel_filter_bank(
            num_frequency_bins=1 + n_fft // 2							,   num_mel_filters=lowerCAmelCase							,   min_frequency=0.0							,   max_frequency=8000.0							,   sampling_rate=lowerCAmelCase							,   norm='slaney'							,   mel_scale='slaney'							,   )




  def   A__     (				self							,   lowerCAmelCase					)  -> np.ndarray:
        '''simple docstring'''






        _lowercase	       =spectrogram(
            lowerCAmelCase							,   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'							,   )
        _lowercase	       =log_spec[:, :-1]
        _lowercase	       =np.maximum(lowerCAmelCase							,   log_spec.max() - 8.0					)
        _lowercase	       =(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   A__     (				lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase = 0.0					)  -> List[np.ndarray]:
        '''simple docstring'''






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

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

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

        return normed_input_values




  def __call__(				self							,   lowerCAmelCase							,   lowerCAmelCase = True							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = "max_length"							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   **lowerCAmelCase							,   )  -> 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.'					)

        _lowercase	       =isinstance(lowerCAmelCase							,   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}'''					)
        _lowercase	       =is_batched_numpy or (
            isinstance(lowerCAmelCase							,   (list, tuple)					) and (isinstance(raw_speech[0]							,   (np.ndarray, tuple, list)					))
        )

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

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

        _lowercase	       =BatchFeature({'input_features': raw_speech}					)

        # convert into correct format for padding

        _lowercase	       =self.pad(
            lowerCAmelCase							,   padding=lowerCAmelCase							,   max_length=max_length if max_length else self.n_samples							,   truncation=lowerCAmelCase							,   pad_to_multiple_of=lowerCAmelCase							,   return_attention_mask=return_attention_mask or do_normalize							,   )

        # zero-mean and unit-variance normalization
        if do_normalize:
              _lowercase	       =self.zero_mean_unit_var_norm(
                  padded_inputs['input_features']							,   attention_mask=padded_inputs['attention_mask']							,   padding_value=self.padding_value							,   )
              _lowercase	       =np.stack(padded_inputs['input_features']							,   axis=0					)

        # make sure list is in array format
        _lowercase	       =padded_inputs.get('input_features'					).transpose(2							,   0							,   1					)

        _lowercase	       =[self._np_extract_fbank_features(lowerCAmelCase					) for waveform in input_features[0]]

        if isinstance(input_features[0]							,   lowerCAmelCase					):
              _lowercase	       =[np.asarray(lowerCAmelCase							,   dtype=np.floataa					) for feature in input_features]
        else:
              _lowercase	       =input_features

        if return_attention_mask:
              # rescale from sample (48000) to feature (3000)
              _lowercase	       =padded_inputs['attention_mask'][:, :: self.hop_length]

        if return_tensors is not None:
              _lowercase	       =padded_inputs.convert_to_tensors(lowerCAmelCase					)

        return padded_inputs




  def   A__     (				self					)  -> Dict[str, Any]:
        '''simple docstring'''






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


