





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


lowercase    : List[Any]    	=  logging.get_logger(__name__)

class  __A(						__UpperCAmelCase ):
					__A	  =       ["input_values", "attention_mask"]

					def __init__(      self,       A = 1,       A = 1_6000,       A = 0.0,       A = False,       A = 80,       A = 16,       A = 64,       A = "hann_window",       A = 1.0,       A = 80,       A = 7600,       A = 1E-1_0,       A = 2,       A = True,       **A,       ):





												"""simple docstring"""

												super().__init__(feature_size=_lowerCAmelCase,       sampling_rate=_lowerCAmelCase,       padding_value=_lowerCAmelCase,       **_lowerCAmelCase      )
												_UpperCamelCase              =						do_normalize
												_UpperCamelCase              =						return_attention_mask

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

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

												_UpperCamelCase              =						window_function(window_length=self.sample_size,       name=self.win_function,       periodic=_lowerCAmelCase      )

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

					@staticmethod
					# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
					def 	_UpperCamelCase     (      A,       A,       A = 0.0      ):





												"""simple docstring"""

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

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

																										normed_input_values.append(_lowerCAmelCase      )
												else:
																			_UpperCamelCase              =						[(x - x.mean()) / np.sqrt(x.var() + 1E-7      ) for x in input_values]

												return normed_input_values

					def 	_UpperCamelCase     (      self,       A,       ):





												"""simple docstring"""

												_UpperCamelCase              =						spectrogram(
												    _lowerCAmelCase,       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,       A = None,       A = None,       A = False,       A = None,       A = False,       A = None,       A = None,       A = None,       A = None,       **A,       ):





												"""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:
																			_UpperCamelCase              =						self._process_audio(
																			    _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       **_lowerCAmelCase,       )
												else:
																			_UpperCamelCase              =						None

												if audio_target is not None:
																			_UpperCamelCase              =						self._process_audio(
																			    _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       **_lowerCAmelCase,       )

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

												return inputs

					def 	_UpperCamelCase     (      self,       A,       A = False,       A = False,       A = None,       A = False,       A = None,       A = None,       A = None,       **A,       ):





												"""simple docstring"""

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

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

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

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

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

												_UpperCamelCase              =						self.pad(
												    _lowerCAmelCase,       padding=_lowerCAmelCase,       max_length=_lowerCAmelCase,       truncation=_lowerCAmelCase,       pad_to_multiple_of=_lowerCAmelCase,       return_attention_mask=_lowerCAmelCase,       **_lowerCAmelCase,       )

												_UpperCamelCase              =						feature_size_hack

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

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

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

												if return_tensors is not None:
																			_UpperCamelCase              =						padded_inputs.convert_to_tensors(_lowerCAmelCase      )

												return padded_inputs



					def 	_UpperCamelCase     (      self      ):





												"""simple docstring"""

												_UpperCamelCase              =						super().to_dict()

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

												return output













import os
import sys
import unittest


lowercase    : Any    	=  os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, """utils"""))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
lowercase    : int    	=  os.path.join(git_repo_path, """src""", """transformers""")

lowercase    : str    	=  """
{0} = None
"""

lowercase    : Union[str, Any]    	=  """
class {0}(metaclass=DummyObject):
    _backends = {1}

    def __init__(self, *args, **kwargs):
        requires_backends(self, {1})
"""


lowercase    : Optional[Any]    	=  """
def {0}(*args, **kwargs):
    requires_backends({0}, {1})
"""

class  __A(						unittest.TestCase ):

     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						find_backend('''    _import_structure["models.albert"].append("AlbertTokenizerFast")'''      )
            self.assertIsNone(A      )

            _UpperCamelCase              =						find_backend('''    if not is_tokenizers_available():'''      )
            self.assertEqual(A,       '''tokenizers'''      )

            _UpperCamelCase              =						find_backend('''    if not is_tensorflow_text_available():'''      )
            self.assertEqual(A,       '''tensorflow_text'''      )

            _UpperCamelCase              =						find_backend('''    if not (is_sentencepiece_available() and is_tokenizers_available()):'''      )
            self.assertEqual(A,       '''sentencepiece_and_tokenizers'''      )

            _UpperCamelCase              =						find_backend(
                '''    if not (is_sentencepiece_available() and is_tensorflow_text_available()):'''      )
            self.assertEqual(A,       '''sentencepiece_and_tensorflow_text'''      )

            _UpperCamelCase              =						find_backend(
                '''    if not (is_sentencepiece_available() and is_tokenizers_available() and is_vision_available()):'''      )
            self.assertEqual(A,       '''sentencepiece_and_tokenizers_and_vision'''      )

     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						read_init()
            # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
            self.assertIn('''torch''',       A      )
            self.assertIn('''tensorflow_text''',       A      )
            self.assertIn('''sentencepiece_and_tokenizers''',       A      )

            # Likewise, we can't assert on the exact content of a key
            self.assertIn('''BertModel''',       objects['''torch''']      )
            self.assertIn('''TFBertModel''',       objects['''tf''']      )
            self.assertIn('''FlaxBertModel''',       objects['''flax''']      )
            self.assertIn('''BertModel''',       objects['''torch''']      )
            self.assertIn('''TFBertTokenizer''',       objects['''tensorflow_text''']      )
            self.assertIn('''convert_slow_tokenizer''',       objects['''sentencepiece_and_tokenizers''']      )

     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						create_dummy_object('''CONSTANT''',       '''\'torch\''''      )
            self.assertEqual(A,       '''\nCONSTANT = None\n'''      )

            _UpperCamelCase              =						create_dummy_object('''function''',       '''\'torch\''''      )
            self.assertEqual(
                A,       '''\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n'''      )

            _UpperCamelCase              =						'''
class FakeClass(metaclass=DummyObject):
    _backends = \'torch\'

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')
'''
            _UpperCamelCase              =						create_dummy_object('''FakeClass''',       '''\'torch\''''      )
            self.assertEqual(A,       A      )



     def 	_UpperCamelCase     (      self      ):





            """simple docstring"""

            _UpperCamelCase              =						'''# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, ["torch"])


class FakeClass(metaclass=DummyObject):
    _backends = ["torch"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, ["torch"])
'''
            _UpperCamelCase              =						create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']}      )
            self.assertEqual(dummy_files['''torch'''],       A      )






