




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


_lowerCamelCase	:		int							       =   logging.get_logger(__name__)


class 				UpperCamelCase_    ( UpperCAmelCase__     ):

    '''simple docstring'''






    UpperCAmelCase__							  =      ['''input_values''', '''attention_mask''']


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





           '''simple docstring'''

           super().__init__(feature_size=UpperCAmelCase__					, sampling_rate=UpperCAmelCase__					, padding_value=UpperCAmelCase__					, **UpperCAmelCase__)
           A__       =    do_normalize
           A__       =    return_attention_mask

           A__       =    num_mel_bins
           A__       =    hop_length
           A__       =    win_length
           A__       =    win_function
           A__       =    frame_signal_scale
           A__       =    fmin
           A__       =    fmax
           A__       =    mel_floor
           A__       =    reduction_factor

           A__       =    win_length * sampling_rate // 1_000
           A__       =    hop_length * sampling_rate // 1_000
           A__       =    optimal_fft_length(self.sample_size)
           A__       =    (self.n_fft // 2) + 1

           A__       =    window_function(window_length=self.sample_size					, name=self.win_function					, periodic=UpperCAmelCase__)

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


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





           '''simple docstring'''

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

                  for vector, length in zip(UpperCAmelCase__					, 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(UpperCAmelCase__)
           else:
                  A__       =    [(x - x.mean()) / np.sqrt(x.var() + 1e-7) for x in input_values]

           return normed_input_values


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any]					, UpperCAmelCase__      :	np.ndarray					, )						->np.ndarray:





           '''simple docstring'''

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





           '''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:
                  A__       =    self._process_audio(
                      UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, **UpperCAmelCase__					, )
           else:
                  A__       =    None

           if audio_target is not None:
                  A__       =    self._process_audio(
                      UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, UpperCAmelCase__					, **UpperCAmelCase__					, )

                  if inputs is None:
                         return inputs_target
                  else:
                         A__       =    inputs_target['''input_values''']
                         A__       =    inputs_target.get('''attention_mask''')
                         if decoder_attention_mask is not None:
                                A__       =    decoder_attention_mask

           return inputs


    def        SCREAMING_SNAKE_CASE							(			self      :	List[str]					, UpperCAmelCase__      :	Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]					, UpperCAmelCase__      :	bool = False					, UpperCAmelCase__      :	Union[bool, str, PaddingStrategy] = False					, UpperCAmelCase__      :	Optional[int] = None					, UpperCAmelCase__      :	bool = False					, UpperCAmelCase__      :	Optional[int] = None					, UpperCAmelCase__      :	Optional[bool] = None					, UpperCAmelCase__      :	Optional[Union[str, TensorType]] = None					, **UpperCAmelCase__      :	int					, )						->BatchFeature:





           '''simple docstring'''

           A__       =    isinstance(UpperCAmelCase__					, 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}""")
           A__       =    is_batched_numpy or (
               isinstance(UpperCAmelCase__					, (list, tuple)) and (isinstance(speech[0]					, (np.ndarray, tuple, list)))
           )

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

           # always return batch
           if not is_batched:
                  A__       =    [speech]

           # needed to make pad() work on spectrogram inputs
           A__       =    self.feature_size

           # convert into correct format for padding
           if is_target:
                  A__       =    [self._extract_mel_features(UpperCAmelCase__) for waveform in speech]
                  A__       =    BatchFeature({'''input_values''': features})
                  A__       =    self.num_mel_bins
           else:
                  A__       =    BatchFeature({'''input_values''': speech})

           A__       =    self.pad(
               UpperCAmelCase__					, padding=UpperCAmelCase__					, max_length=UpperCAmelCase__					, truncation=UpperCAmelCase__					, pad_to_multiple_of=UpperCAmelCase__					, return_attention_mask=UpperCAmelCase__					, **UpperCAmelCase__					, )

           A__       =    feature_size_hack

           # convert input values to correct format
           A__       =    padded_inputs['''input_values''']
           if not isinstance(input_values[0]					, np.ndarray):
                  A__       =    [np.asarray(UpperCAmelCase__					, dtype=np.floataa) for array in input_values]
           elif (
               not isinstance(UpperCAmelCase__					, np.ndarray)
               and isinstance(input_values[0]					, np.ndarray)
               and input_values[0].dtype is np.dtype(np.floataa)
           ):
                  A__       =    [array.astype(np.floataa) for array in input_values]
           elif isinstance(UpperCAmelCase__					, np.ndarray) and input_values.dtype is np.dtype(np.floataa):
                  A__       =    input_values.astype(np.floataa)

           # convert attention_mask to correct format
           A__       =    padded_inputs.get('''attention_mask''')
           if attention_mask is not None:
                  A__       =    [np.asarray(UpperCAmelCase__					, dtype=np.intaa) for array in attention_mask]

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

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

           return padded_inputs





    def        SCREAMING_SNAKE_CASE							(			self      :	int)						->Dict[str, Any]:





           '''simple docstring'''

           A__       =    super().to_dict()

           # Don't serialize these as they are derived from the other properties.
           A__       =    ['''window''', '''mel_filters''', '''sample_size''', '''sample_stride''', '''n_fft''', '''n_freqs''']
           for name in names:
                  if name in output:
                         del output[name]

           return output








def SCREAMING_SNAKE_CASE				(       lowercase_ ,				lowercase_						)   ->       int:



       """simple docstring"""

       return int(input_a == input_a == 0						)







def SCREAMING_SNAKE_CASE				(       )   ->       None:



       """simple docstring"""

       print('''Truth Table of NOR Gate:'''						)
       print('''|   Input 1   |  Input 2  | Output |'''						)
       print(f"""|      0      |    0      |  {nor_gate(0 ,				0						)}     |"""						)
       print(f"""|      0      |    1      |  {nor_gate(0 ,				1						)}     |"""						)
       print(f"""|      1      |    0      |  {nor_gate(1 ,				0						)}     |"""						)
       print(f"""|      1      |    1      |  {nor_gate(1 ,				1						)}     |"""						)


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  main()


