


'''simple docstring'''






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,
    convert_to_rgb,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    OPENAI_CLIP_MEAN,
    OPENAI_CLIP_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, is_vision_available, logging


a_   :      Any				    =      logging.get_logger(__name__)


if is_vision_available():
 import PIL




class 	a       (       _SCREAMING_SNAKE_CASE    ):
 _lowerCAmelCase	   =		["""pixel_values"""]
 def __init__(	self ,			__magic_name__ = True ,			__magic_name__ = None ,			__magic_name__ = PILImageResampling.BICUBIC ,			__magic_name__ = True ,			__magic_name__ = None ,			__magic_name__ = True ,			__magic_name__ = 1 / 2_55 ,			__magic_name__ = True ,			__magic_name__ = None ,			__magic_name__ = None ,			__magic_name__ = True ,			**__magic_name__ ,			)   ->							None:
      super().__init__(**__magic_name__  )
      _a      =							size if size is not None else {'shortest_edge': 2_24}
      _a      =							get_size_dict(__magic_name__ ,			default_to_square=__magic_name__  )
      _a      =							crop_size if crop_size is not None else {'height': 2_24, 'width': 2_24}
      _a      =							get_size_dict(__magic_name__ ,			default_to_square=__magic_name__ ,			param_name='crop_size'  )

      _a      =							do_resize
      _a      =							size
      _a      =							resample
      _a      =							do_center_crop
      _a      =							crop_size
      _a      =							do_rescale
      _a      =							rescale_factor
      _a      =							do_normalize
      _a      =							image_mean if image_mean is not None else OPENAI_CLIP_MEAN
      _a      =							image_std if image_std is not None else OPENAI_CLIP_STD
      _a      =							do_convert_rgb
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ = PILImageResampling.BICUBIC ,			__magic_name__ = None ,			**__magic_name__ ,			)   ->							np.ndarray:
      _a      =							get_size_dict(__magic_name__ ,			default_to_square=__magic_name__  )
      if "shortest_edge" not in size:
           raise ValueError(f'The `size` parameter must contain the key `shortest_edge`. Got {size.keys()}'  )
      _a      =							get_resize_output_image_size(__magic_name__ ,			size=size['shortest_edge'] ,			default_to_square=__magic_name__  )
      return resize(__magic_name__ ,			size=__magic_name__ ,			resample=__magic_name__ ,			data_format=__magic_name__ ,			**__magic_name__  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ = None ,			**__magic_name__ ,			)   ->							np.ndarray:
      _a      =							get_size_dict(__magic_name__  )
      if "height" not in size or "width" not in size:
           raise ValueError(f'The `size` parameter must contain the keys (height, width). Got {size.keys()}'  )
      return center_crop(__magic_name__ ,			size=(size['height'], size['width']) ,			data_format=__magic_name__ ,			**__magic_name__  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ = None ,			**__magic_name__ ,			)   ->							List[Any]:
      return rescale(__magic_name__ ,			scale=__magic_name__ ,			data_format=__magic_name__ ,			**__magic_name__  )
 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ ,			__magic_name__ = None ,			**__magic_name__ ,			)   ->							np.ndarray:
      return normalize(__magic_name__ ,			mean=__magic_name__ ,			std=__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__ = None ,			__magic_name__ = None ,			__magic_name__ = None ,			__magic_name__ = None ,			__magic_name__ = None ,			__magic_name__ = None ,			__magic_name__ = None ,			__magic_name__ = ChannelDimension.FIRST ,			**__magic_name__ ,			)   ->							PIL.Image.Image:
      _a      =							do_resize if do_resize is not None else self.do_resize
      _a      =							size if size is not None else self.size
      _a      =							get_size_dict(__magic_name__ ,			param_name='size' ,			default_to_square=__magic_name__  )
      _a      =							resample if resample is not None else self.resample
      _a      =							do_center_crop if do_center_crop is not None else self.do_center_crop
      _a      =							crop_size if crop_size is not None else self.crop_size
      _a      =							get_size_dict(__magic_name__ ,			param_name='crop_size' ,			default_to_square=__magic_name__  )
      _a      =							do_rescale if do_rescale is not None else self.do_rescale
      _a      =							rescale_factor if rescale_factor is not None else self.rescale_factor
      _a      =							do_normalize if do_normalize is not None else self.do_normalize
      _a      =							image_mean if image_mean is not None else self.image_mean
      _a      =							image_std if image_std is not None else self.image_std
      _a      =							do_convert_rgb if do_convert_rgb is not None else self.do_convert_rgb

      _a      =							make_list_of_images(__magic_name__  )

      if not valid_images(__magic_name__  ):
           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:
           raise ValueError('Size 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.'  )

      # PIL RGBA images are converted to RGB
      if do_convert_rgb:
           _a      =							[convert_to_rgb(__magic_name__  ) for image in images]

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

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

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

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

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

      _a      =							[to_channel_dimension_format(__magic_name__ ,			__magic_name__  ) for image in images]

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





'''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


a_   :      Tuple				    =      logging.get_logger(__name__)




class 	a       (       _SCREAMING_SNAKE_CASE    ):
 _lowerCAmelCase	   =		["""input_features"""]
 def __init__(	self ,			__magic_name__=80 ,			__magic_name__=1_60_00 ,			__magic_name__=1_60 ,			__magic_name__=30 ,			__magic_name__=4_00 ,			__magic_name__=0.0 ,			__magic_name__=False ,			**__magic_name__ ,			)   ->							Optional[int]:
      super().__init__(
          feature_size=__magic_name__ ,			sampling_rate=__magic_name__ ,			padding_value=__magic_name__ ,			return_attention_mask=__magic_name__ ,			**__magic_name__ ,			)
      _a      =							n_fft
      _a      =							hop_length
      _a      =							chunk_length
      _a      =							chunk_length * sampling_rate
      _a      =							self.n_samples // hop_length
      _a      =							sampling_rate
      _a      =							mel_filter_bank(
          num_frequency_bins=1 + n_fft // 2 ,			num_mel_filters=__magic_name__ ,			min_frequency=0.0 ,			max_frequency=8_0_0_0.0 ,			sampling_rate=__magic_name__ ,			norm='slaney' ,			mel_scale='slaney' ,			)
 def 							__UpperCAmelCase						(	self ,			__magic_name__  )   ->							np.ndarray:
      _a      =							spectrogram(
          __magic_name__ ,			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' ,			)
      _a      =							log_spec[:, :-1]
      _a      =							np.maximum(__magic_name__ ,			log_spec.max() - 8.0  )
      _a      =							(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 							__UpperCAmelCase						(	__magic_name__ ,			__magic_name__ ,			__magic_name__ = 0.0  )   ->							List[np.ndarray]:
      if attention_mask is not None:
           _a      =							np.array(__magic_name__ ,			np.intaa  )
           _a      =							[]

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

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

      return normed_input_values
 def __call__(	self ,			__magic_name__ ,			__magic_name__ = True ,			__magic_name__ = None ,			__magic_name__ = None ,			__magic_name__ = None ,			__magic_name__ = "max_length" ,			__magic_name__ = None ,			__magic_name__ = None ,			__magic_name__ = None ,			**__magic_name__ ,			)   ->							BatchFeature:

      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.'  )

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

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

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

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

      # convert into correct format for padding

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

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

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

      _a      =							[self._np_extract_fbank_features(__magic_name__  ) for waveform in input_features[0]]

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

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

      if return_tensors is not None:
           _a      =							padded_inputs.convert_to_tensors(__magic_name__  )

      return padded_inputs




 def 							__UpperCAmelCase						(	self  )   ->							Dict[str, Any]:
      _a      =							copy.deepcopy(self.__dict__  )
      _a      =							self.__class__.__name__
      if "mel_filters" in output:
           del output["mel_filters"]
      return output

