from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import (
					    AutoTokenizer,
					    TFAutoModelForCausalLM,
					    TFAutoModelForSeqaSeqLM,
					    TFAutoModelForSpeechSeqaSeq,
					    TFAutoModelForVisionaSeq,
					    TFBartForConditionalGeneration,
					    TFLogitsProcessorList,
					    TFMinLengthLogitsProcessor,
					    tf_top_k_top_p_filtering,
					)

if is_tensorflow_text_available():
					import tensorflow_text as text





@require_tf
class 					lowercase__						(   unittest.TestCase):


						def        __A       (       self	:				Union[str, Any]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[Any]							=							tf.convert_to_tensor(
												    [
												        [
												            8.222_0991,  # 3rd highest value; idx. 0
												            -0.562_0044,
												            5.2322_9752,
												            4.038_6393,
												            -6.879_8378,
												            -0.5478_5802,
												            -3.201_2153,
												            2.9277_7176,
												            1.8817_1953,
												            7.3534_1276,  # 5th highest value; idx. 9
												            8.4320_7833,  # 2nd highest value; idx. 10
												            -9.8571_1836,
												            -5.9620_9236,
												            -1.1303_9161,
												            -7.111_5294,
												            -0.836_9633,
												            -5.318_6408,
												            7.0642_7407,
												            0.8136_9344,
												            -0.8202_3817,
												            -5.917_9796,
												            0.5881_3443,
												            -6.9977_8438,
												            4.7155_1189,
												            -0.1877_1637,
												            7.4402_0759,  # 4th highest value; idx. 25
												            9.3845_0987,  # 1st highest value; idx. 26
												            2.1266_2941,
												            -9.3256_2038,
												            2.3565_2522,
												        ],  # cummulative prob of 5 highest values <= 0.6
												        [
												            0.5842_5518,
												            4.5313_9238,
												            -5.5751_0464,
												            -6.2803_0699,
												            -7.1952_9503,
												            -4.0212_2551,
												            1.3933_7037,
												            -6.0670_7057,
												            1.5948_0517,
												            -9.64_3119,
												            0.0390_7799,
												            0.6723_1762,
												            -8.8820_6726,
												            6.2711_5922,  # 4th highest value; idx. 13
												            2.2852_0723,
												            4.8276_7506,
												            4.3042_1368,
												            8.827_5313,  # 2nd highest value; idx. 17
												            5.4402_9958,  # 5th highest value; idx. 18
												            -4.473_5794,
												            7.3857_9536,  # 3rd highest value; idx. 20
												            -2.9105_1663,
												            2.6194_6077,
												            -2.567_4762,
												            -9.4895_9302,
												            -4.0292_2645,
												            -1.3541_6918,
												            9.6770_2323,  # 1st highest value; idx. 27
												            -5.8947_8553,
												            1.8537_0467,
												        ],  # cummulative prob of 5 highest values <= 0.6
												    ]    ,		dtype=tf.floataa    ,		)

												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							tf.convert_to_tensor(
												    [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]    ,		dtype=tf.intaa    ,		)  # expected non filtered idx as noted above

												SCREAMING_SNAKE_CASE							:    str							=							tf.convert_to_tensor(
												    [8.22_2099, 7.353_4126, 8.43_2078, 7.440_2075, 9.3_8451, 6.27_1159, 8.82_7531, 5.440_2995, 7.385_7956, 9.67_7023]    ,		dtype=tf.floataa    ,		)  # expected non filtered values as noted above

												SCREAMING_SNAKE_CASE							:    str							=							tf_top_k_top_p_filtering(UpperCamelCase__    ,		top_k=10    ,		top_p=0.6    ,		min_tokens_to_keep=4						)

												SCREAMING_SNAKE_CASE							:    Optional[int]							=							output[output != -float('''inf'''						)]
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							tf.cast(
												    tf.where(tf.not_equal(UpperCamelCase__    ,		tf.constant(-float('''inf'''						)    ,		dtype=tf.floataa						)						)						)    ,		dtype=tf.intaa    ,		)

												tf.debugging.assert_near(UpperCamelCase__    ,		UpperCamelCase__    ,		rtol=1E-12						)
												tf.debugging.assert_equal(UpperCamelCase__    ,		UpperCamelCase__						)






@require_tf
class 					lowercase__						(   unittest.TestCase	,							__snake_case):
						# setting framework_dependent_parameters needs to be gated, just like its contents' imports
						if is_tf_available():
												UpperCamelCase_     =		{
												    """AutoModelForCausalLM""": TFAutoModelForCausalLM,
												    """AutoModelForSpeechSeq2Seq""": TFAutoModelForSpeechSeqaSeq,
												    """AutoModelForSeq2SeqLM""": TFAutoModelForSeqaSeqLM,
												    """AutoModelForVision2Seq""": TFAutoModelForVisionaSeq,
												    """LogitsProcessorList""": TFLogitsProcessorList,
												    """MinLengthLogitsProcessor""": TFMinLengthLogitsProcessor,
												    """create_tensor_fn""": tf.convert_to_tensor,
												    """floats_tensor""": floats_tensor,
												    """return_tensors""": """tf""",
												}


						@slow
						def        __A       (       self	:				Any						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    Any							=							TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''						)
												SCREAMING_SNAKE_CASE							:    str							=							2
												SCREAMING_SNAKE_CASE							:    List[str]							=							2





												class 					lowercase__						(   tf.Module):


																		def __init__(       self	:				List[Any]    ,		UpperCamelCase__	:				Optional[int]						):





																								'''simple docstring'''





																								super(UpperCamelCase__    ,		self						).__init__()
																								SCREAMING_SNAKE_CASE							:    str							=							model



																		@tf.function(
																		    input_signature=(
																		        tf.TensorSpec((None, input_length)    ,		tf.intaa    ,		name='''input_ids'''						),
																		        tf.TensorSpec((None, input_length)    ,		tf.intaa    ,		name='''attention_mask'''						),
																		    )    ,		jit_compile=UpperCamelCase__    ,		)
																		def        __A       (       self	:				Optional[int]    ,		UpperCamelCase__	:				int    ,		UpperCamelCase__	:				List[str]						):





																								'''simple docstring'''





																								SCREAMING_SNAKE_CASE							:    Dict							=							self.model.generate(
																								    input_ids=UpperCamelCase__    ,		attention_mask=UpperCamelCase__    ,		max_new_tokens=UpperCamelCase__    ,		return_dict_in_generate=UpperCamelCase__    ,		)
																								return {"sequences": outputs["sequences"]}






												SCREAMING_SNAKE_CASE							:    Tuple							=							[[2, 0], [102, 103]]
												SCREAMING_SNAKE_CASE							:    List[Any]							=							[[1, 0], [1, 1]]
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							DummyModel(model=UpperCamelCase__						)
												with tempfile.TemporaryDirectory() as tmp_dir:
																		tf.saved_model.save(UpperCamelCase__    ,		UpperCamelCase__    ,		signatures={'''serving_default''': dummy_model.serving}						)
																		SCREAMING_SNAKE_CASE							:    Tuple							=							tf.saved_model.load(UpperCamelCase__						).signatures['''serving_default''']
																		for batch_size in range(1    ,		len(UpperCamelCase__						) + 1						):
																								SCREAMING_SNAKE_CASE							:    List[Any]							=							{
																								    '''input_ids''': tf.constant(dummy_input_ids[:batch_size]						),
																								    '''attention_mask''': tf.constant(dummy_attention_masks[:batch_size]						),
																								}
																								SCREAMING_SNAKE_CASE							:    List[Any]							=							serving_func(**UpperCamelCase__						)['''sequences''']
																								SCREAMING_SNAKE_CASE							:    Optional[Any]							=							test_model.generate(**UpperCamelCase__    ,		max_new_tokens=UpperCamelCase__						)
																								tf.debugging.assert_equal(UpperCamelCase__    ,		UpperCamelCase__						)


						@slow
						def        __A       (       self	:				Any						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    str							=							TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''						)
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							1
												SCREAMING_SNAKE_CASE							:    List[Any]							=							2





												class 					lowercase__						(   tf.Module):


																		def __init__(       self	:				Union[str, Any]    ,		UpperCamelCase__	:				List[str]						):





																								'''simple docstring'''





																								super(UpperCamelCase__    ,		self						).__init__()
																								SCREAMING_SNAKE_CASE							:    Optional[Any]							=							model



																		@tf.function(
																		    input_signature=(
																		        tf.TensorSpec((batch_size, None)    ,		tf.intaa    ,		name='''input_ids'''						),
																		        tf.TensorSpec((batch_size, None)    ,		tf.intaa    ,		name='''attention_mask'''						),
																		    )    ,		jit_compile=UpperCamelCase__    ,		)
																		def        __A       (       self	:				str    ,		UpperCamelCase__	:				List[str]    ,		UpperCamelCase__	:				str						):





																								'''simple docstring'''





																								SCREAMING_SNAKE_CASE							:    Any							=							self.model.generate(
																								    input_ids=UpperCamelCase__    ,		attention_mask=UpperCamelCase__    ,		max_new_tokens=UpperCamelCase__    ,		return_dict_in_generate=UpperCamelCase__    ,		)
																								return {"sequences": outputs["sequences"]}






												SCREAMING_SNAKE_CASE							:    Optional[int]							=							[[2], [102, 103]]
												SCREAMING_SNAKE_CASE							:    List[str]							=							[[1], [1, 1]]
												SCREAMING_SNAKE_CASE							:    Optional[int]							=							DummyModel(model=UpperCamelCase__						)
												with tempfile.TemporaryDirectory() as tmp_dir:
																		tf.saved_model.save(UpperCamelCase__    ,		UpperCamelCase__    ,		signatures={'''serving_default''': dummy_model.serving}						)
																		SCREAMING_SNAKE_CASE							:    Tuple							=							tf.saved_model.load(UpperCamelCase__						).signatures['''serving_default''']
																		for input_row in range(len(UpperCamelCase__						)						):
																								SCREAMING_SNAKE_CASE							:    List[str]							=							{
																								    '''input_ids''': tf.constant([dummy_input_ids[input_row]]						),
																								    '''attention_mask''': tf.constant([dummy_attention_masks[input_row]]						),
																								}
																								SCREAMING_SNAKE_CASE							:    Tuple							=							serving_func(**UpperCamelCase__						)['''sequences''']
																								SCREAMING_SNAKE_CASE							:    List[str]							=							test_model.generate(**UpperCamelCase__    ,		max_new_tokens=UpperCamelCase__						)
																								tf.debugging.assert_equal(UpperCamelCase__    ,		UpperCamelCase__						)


						@slow
						@require_tensorflow_text
						def        __A       (       self	:				Union[str, Any]						):





												'''simple docstring'''





												with tempfile.TemporaryDirectory() as tmp_dir:
																		# file needed to load the TF tokenizer
																		hf_hub_download(repo_id='''google/flan-t5-small'''    ,		filename='''spiece.model'''    ,		local_dir=UpperCamelCase__						)





																		class 					lowercase__						(   tf.keras.layers.Layer):


																								def __init__(       self	:				List[Any]						):





																														'''simple docstring'''





																														super().__init__()
																														SCREAMING_SNAKE_CASE							:    List[str]							=							text.SentencepieceTokenizer(
																														    model=tf.io.gfile.GFile(os.path.join(UpperCamelCase__    ,		'''spiece.model'''						)    ,		'''rb'''						).read()						)
																														SCREAMING_SNAKE_CASE							:    List[Any]							=							TFAutoModelForSeqaSeqLM.from_pretrained('''hf-internal-testing/tiny-random-t5'''						)



																								def        __A       (       self	:				Optional[Any]    ,		UpperCamelCase__	:				str    ,		*UpperCamelCase__	:				Union[str, Any]    ,		**UpperCamelCase__	:				str						):





																														'''simple docstring'''





																														SCREAMING_SNAKE_CASE							:    Any							=							self.tokenizer.tokenize(UpperCamelCase__						)
																														SCREAMING_SNAKE_CASE							:    List[Any]							=							text.pad_model_inputs(
																														    UpperCamelCase__    ,		max_seq_length=64    ,		pad_value=self.model.config.pad_token_id						)
																														SCREAMING_SNAKE_CASE							:    List[Any]							=							self.model.generate(input_ids=UpperCamelCase__    ,		attention_mask=UpperCamelCase__						)
																														return self.tokenizer.detokenize(UpperCamelCase__						)






																		SCREAMING_SNAKE_CASE							:    Tuple							=							CompleteSentenceTransformer()
																		SCREAMING_SNAKE_CASE							:    int							=							tf.keras.layers.Input(shape=(1,)    ,		dtype=tf.string    ,		name='''inputs'''						)
																		SCREAMING_SNAKE_CASE							:    Optional[int]							=							complete_model(UpperCamelCase__						)
																		SCREAMING_SNAKE_CASE							:    Tuple							=							tf.keras.Model(UpperCamelCase__    ,		UpperCamelCase__						)
																		keras_model.save(UpperCamelCase__						)


						def        __A       (       self	:				Tuple						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    List[str]							=							{
												    '''do_sample''': True,
												    '''num_beams''': 1,
												    '''top_p''': 0.7,
												    '''top_k''': 10,
												    '''temperature''': 0.7,
												}
												SCREAMING_SNAKE_CASE							:    List[Any]							=							14

												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''						)
												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							'''Hello, my dog is cute and'''
												SCREAMING_SNAKE_CASE							:    List[str]							=							tokenizer(UpperCamelCase__    ,		return_tensors='''tf'''						)
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							TFAutoModelForCausalLM.from_pretrained('''hf-internal-testing/tiny-random-gpt2'''						)

												SCREAMING_SNAKE_CASE							:    Optional[Any]							=							638
												# forces the generation to happen on CPU, to avoid GPU-related quirks
												with tf.device(''':/CPU:0'''						):
																		tf.random.set_seed(0						)
																		SCREAMING_SNAKE_CASE							:    int							=							model.generate(**UpperCamelCase__    ,		eos_token_id=UpperCamelCase__    ,		**UpperCamelCase__						)
												self.assertTrue(expectation == len(generated_tokens[0]						)						)

												SCREAMING_SNAKE_CASE							:    str							=							[638, 198]
												with tf.device(''':/CPU:0'''						):
																		tf.random.set_seed(0						)
																		SCREAMING_SNAKE_CASE							:    Any							=							model.generate(**UpperCamelCase__    ,		eos_token_id=UpperCamelCase__    ,		**UpperCamelCase__						)
												self.assertTrue(expectation == len(generated_tokens[0]						)						)



						def        __A       (       self	:				Optional[int]						):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:    str							=							AutoTokenizer.from_pretrained('''hf-internal-testing/tiny-random-bart'''						)
												SCREAMING_SNAKE_CASE							:    Tuple							=							'''Hugging Face is a technology company based in New York and Paris.'''
												SCREAMING_SNAKE_CASE							:    Any							=							bart_tokenizer(UpperCamelCase__    ,		return_tensors='''tf'''						).input_ids
												SCREAMING_SNAKE_CASE							:    Tuple							=							TFBartForConditionalGeneration.from_pretrained('''hf-internal-testing/tiny-random-bart'''						)
												SCREAMING_SNAKE_CASE							:    Union[str, Any]							=							bart_model.generate(UpperCamelCase__						).numpy()





												class 					lowercase__						(   __snake_case):


																		def        __A       (       self	:				List[str]    ,		UpperCamelCase__	:				Optional[int]    ,		UpperCamelCase__	:				int=None    ,		**UpperCamelCase__	:				Dict						):





																								'''simple docstring'''





																								return super().call(UpperCamelCase__    ,		**UpperCamelCase__						)






												SCREAMING_SNAKE_CASE							:    Tuple							=							FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart'''						)
												SCREAMING_SNAKE_CASE							:    int							=							bart_model.generate(UpperCamelCase__    ,		foo='''bar'''						).numpy()
												self.assertTrue(np.array_equal(UpperCamelCase__    ,		UpperCamelCase__						)						)





												class 					lowercase__						(   bart_model.model.encoder.__class__):


																		def        __A       (       self	:				Optional[int]    ,		UpperCamelCase__	:				Dict    ,		**UpperCamelCase__	:				Optional[Any]						):





																								'''simple docstring'''





																								return super().call(UpperCamelCase__    ,		**UpperCamelCase__						)






												SCREAMING_SNAKE_CASE							:    Optional[int]							=							FakeEncoder(bart_model.config    ,		bart_model.model.shared						)
												SCREAMING_SNAKE_CASE							:    Tuple							=							fake_encoder

												# Normal generation still works (the output will be different because the encoder weights are different)
												SCREAMING_SNAKE_CASE							:    Any							=							bart_model.generate(UpperCamelCase__						).numpy()
												with self.assertRaises(UpperCamelCase__						):
																		# FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
																		bart_model.generate(UpperCamelCase__    ,		foo='''bar'''						)







'''simple docstring'''




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


lowercase			:				Optional[int]    		=			logging.get_logger(__name__)





class  A				(							__snake_case						):
     __magic_name__						=		['''input_features''', '''attention_mask''']





     def __init__(							self						,			SCREAMING_SNAKE_CASE=80						,			SCREAMING_SNAKE_CASE=16000						,			SCREAMING_SNAKE_CASE=80						,			SCREAMING_SNAKE_CASE=0.0						,			SCREAMING_SNAKE_CASE=True						,			SCREAMING_SNAKE_CASE=True						,			SCREAMING_SNAKE_CASE=True						,			**SCREAMING_SNAKE_CASE						,			) ->				int:






         """simple docstring"""






         super().__init__(feature_size=SCREAMING_SNAKE_CASE						,			sampling_rate=SCREAMING_SNAKE_CASE						,			padding_value=SCREAMING_SNAKE_CASE						,			**SCREAMING_SNAKE_CASE	)
         A       :   Optional[int]					=						num_mel_bins
         A       :   Tuple					=						do_ceptral_normalize
         A       :   Dict					=						normalize_means
         A       :   List[Any]					=						normalize_vars
         A       :   List[str]					=						True





     def 				__lowerCAmelCase							(							self						,			SCREAMING_SNAKE_CASE						,			) ->				np.ndarray:






         """simple docstring"""






         A       :   List[Any]					=						waveform * (2**15)  # Kaldi compliance: 16-bit signed integers
         A       :   Any					=						torch.from_numpy(SCREAMING_SNAKE_CASE	).unsqueeze(0	)
         A       :   Any					=						ta_kaldi.fbank(SCREAMING_SNAKE_CASE						,			num_mel_bins=self.num_mel_bins						,			sample_frequency=self.sampling_rate	)
         return features.numpy()





     @staticmethod
     def 				__lowerCAmelCase							(							SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE = True						,			SCREAMING_SNAKE_CASE = True						,			SCREAMING_SNAKE_CASE = 0.0						,			) ->				np.ndarray:






         """simple docstring"""






         if normalize_means:
             A       :   Dict					=						x[:input_length].mean(axis=0	)
             A       :   Optional[Any]					=						np.subtract(SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE	)
         if normalize_vars:
             A       :   str					=						x[:input_length].std(axis=0	)
             A       :   int					=						np.divide(SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE	)

         if input_length < x.shape[0]:
             A       :   List[str]					=						padding_value

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

         return x





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






         """simple docstring"""






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





     def __call__(							self						,			SCREAMING_SNAKE_CASE						,			SCREAMING_SNAKE_CASE = False						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = False						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			SCREAMING_SNAKE_CASE = None						,			**SCREAMING_SNAKE_CASE						,			) ->				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.'''	)

         A       :   List[Any]					=						isinstance(SCREAMING_SNAKE_CASE						,			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       :   Tuple					=						is_batched_numpy or (
             isinstance(SCREAMING_SNAKE_CASE						,			(list, tuple)	) and (isinstance(raw_speech[0]						,			(np.ndarray, tuple, list)	))
         )

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

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

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

         # convert into correct format for padding
         A       :   str					=						BatchFeature({'''input_features''': features}	)

         A       :   Union[str, Any]					=						self.pad(
             SCREAMING_SNAKE_CASE						,			padding=SCREAMING_SNAKE_CASE						,			max_length=SCREAMING_SNAKE_CASE						,			truncation=SCREAMING_SNAKE_CASE						,			pad_to_multiple_of=SCREAMING_SNAKE_CASE						,			return_attention_mask=SCREAMING_SNAKE_CASE						,			**SCREAMING_SNAKE_CASE						,			)

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

         A       :   Union[str, Any]					=						padded_inputs.get('''attention_mask'''	)
         if attention_mask is not None:
             A       :   Union[str, Any]					=						[np.asarray(SCREAMING_SNAKE_CASE						,			dtype=np.intaa	) for array in attention_mask]

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

         if return_tensors is not None:
             A       :   int					=						padded_inputs.convert_to_tensors(SCREAMING_SNAKE_CASE	)

         return padded_inputs




