






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							:					Optional[int]           =							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							:					Optional[int]           =							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							:					Optional[Any]           =							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							:					List[str]           =							tf_top_k_top_p_filtering(_snake_case					,	top_k=10					,	top_p=0.6					,	min_tokens_to_keep=4		)

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

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






@require_tf
class       lowercase__		(     unittest.TestCase			,							UpperCAmelCase_):






						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			:       str		):





												'''simple docstring'''





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





												class       lowercase__		(     tf.Module):


																		def __init__( self			:       Any					,	UpperCamelCase__			:       str		):





																								'''simple docstring'''





																								super(_snake_case					,	self		).__init__()
																								SCREAMING_SNAKE_CASE							:					Any           =							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=_snake_case					,	)
																		def  __A ( self			:       Optional[int]					,	UpperCamelCase__			:       Dict					,	UpperCamelCase__			:       List[str]		):





																								'''simple docstring'''





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






												SCREAMING_SNAKE_CASE							:					Dict           =							[[2, 0], [102, 103]]
												SCREAMING_SNAKE_CASE							:					Tuple           =							[[1, 0], [1, 1]]
												SCREAMING_SNAKE_CASE							:					List[str]           =							DummyModel(model=_snake_case		)
												with tempfile.TemporaryDirectory() as tmp_dir:
																		tf.saved_model.save(_snake_case					,	_snake_case					,	signatures={'''serving_default''': dummy_model.serving}		)
																		SCREAMING_SNAKE_CASE							:					List[str]           =							tf.saved_model.load(_snake_case		).signatures['''serving_default''']
																		for batch_size in range(1					,	len(_snake_case		) + 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							:					Optional[Any]           =							serving_func(**_snake_case		)['''sequences''']
																								SCREAMING_SNAKE_CASE							:					List[str]           =							test_model.generate(**_snake_case					,	max_new_tokens=_snake_case		)
																								tf.debugging.assert_equal(_snake_case					,	_snake_case		)


						@slow
						def  __A ( self			:       Tuple		):





												'''simple docstring'''





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





												class       lowercase__		(     tf.Module):


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





																								'''simple docstring'''





																								super(_snake_case					,	self		).__init__()
																								SCREAMING_SNAKE_CASE							:					int           =							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=_snake_case					,	)
																		def  __A ( self			:       Tuple					,	UpperCamelCase__			:       Any					,	UpperCamelCase__			:       List[Any]		):





																								'''simple docstring'''





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






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


						@slow
						@require_tensorflow_text
						def  __A ( self			:       Optional[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=_snake_case		)





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


																								def __init__( self			:       Dict		):





																														'''simple docstring'''





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



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





																														'''simple docstring'''





																														SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							self.tokenizer.tokenize(_snake_case		)
																														SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE							:					Tuple           =							text.pad_model_inputs(
																														    _snake_case					,	max_seq_length=64					,	pad_value=self.model.config.pad_token_id		)
																														SCREAMING_SNAKE_CASE							:					Dict           =							self.model.generate(input_ids=_snake_case					,	attention_mask=_snake_case		)
																														return self.tokenizer.detokenize(_snake_case		)






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


						def  __A ( self			:       List[str]		):





												'''simple docstring'''





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

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

												SCREAMING_SNAKE_CASE							:					Dict           =							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							:					List[str]           =							model.generate(**_snake_case					,	eos_token_id=_snake_case					,	**_snake_case		)
												self.assertTrue(expectation == len(generated_tokens[0]		)		)

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



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





												'''simple docstring'''





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





												class       lowercase__		(     UpperCAmelCase_):


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





																								'''simple docstring'''





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






												SCREAMING_SNAKE_CASE							:					Any           =							FakeBart.from_pretrained('''hf-internal-testing/tiny-random-bart'''		)
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							bart_model.generate(_snake_case					,	foo='''bar'''		).numpy()
												self.assertTrue(np.array_equal(_snake_case					,	_snake_case		)		)





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


																		def  __A ( self			:       str					,	UpperCamelCase__			:       Tuple					,	**UpperCamelCase__			:       str		):





																								'''simple docstring'''





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






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

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






import itertools
import os
import random
import tempfile
import unittest

import numpy as np

from transformers import TvltFeatureExtractor, is_datasets_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
					import torch

if is_datasets_available():
					from datasets import load_dataset

__UpperCamelCase	: Dict    		=  random.Random()
def    A			(					_lowercase	,						_lowercase=1.0	,						_lowercase=None	,						_lowercase=None		):
						if rng is None:
												SCREAMING_SNAKE_CASE							:					Any           =							global_rng

						SCREAMING_SNAKE_CASE							:					int           =							[]
						for batch_idx in range(shape[0]		):
												values.append([]		)
												for _ in range(shape[1]		):
																		values[-1].append(rng.random() * scale		)

						return values





class       lowercase__		(     unittest.TestCase):


						def __init__( self			:       List[Any]					,	UpperCamelCase__			:       Optional[int]					,	UpperCamelCase__			:       str=7					,	UpperCamelCase__			:       Any=400					,	UpperCamelCase__			:       List[str]=2000					,	UpperCamelCase__			:       List[Any]=2048					,	UpperCamelCase__			:       Any=128					,	UpperCamelCase__			:       Union[str, Any]=1					,	UpperCamelCase__			:       List[Any]=512					,	UpperCamelCase__			:       str=30					,	UpperCamelCase__			:       Tuple=4_4100					,	):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					str           =							parent
												SCREAMING_SNAKE_CASE							:					str           =							batch_size
												SCREAMING_SNAKE_CASE							:					str           =							min_seq_length
												SCREAMING_SNAKE_CASE							:					Dict           =							max_seq_length
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							spectrogram_length
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							feature_size
												SCREAMING_SNAKE_CASE							:					Tuple           =							num_audio_channels
												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							hop_length
												SCREAMING_SNAKE_CASE							:					List[Any]           =							chunk_length
												SCREAMING_SNAKE_CASE							:					str           =							sampling_rate


						def  __A ( self			:       Optional[Any]		):





												'''simple docstring'''





												return {
												    "spectrogram_length": self.spectrogram_length,
												    "feature_size": self.feature_size,
												    "num_audio_channels": self.num_audio_channels,
												    "hop_length": self.hop_length,
												    "chunk_length": self.chunk_length,
												    "sampling_rate": self.sampling_rate,
												}



						def  __A ( self			:       Tuple					,	UpperCamelCase__			:       List[str]=False					,	UpperCamelCase__			:       Optional[int]=False		):





												'''simple docstring'''





												def _flatten(UpperCamelCase__			:       str		):
																		return list(itertools.chain(*UpperCamelCase__		)		)

												if equal_length:
																		SCREAMING_SNAKE_CASE							:					List[str]           =							[floats_list((self.max_seq_length, self.feature_size)		) for _ in range(self.batch_size		)]
												else:
																		# make sure that inputs increase in size
																		SCREAMING_SNAKE_CASE							:					int           =							[
																		    floats_list((x, self.feature_size)		)
																		    for x in range(self.min_seq_length					,	self.max_seq_length					,	self.seq_length_diff		)
																		]
												if numpify:
																		SCREAMING_SNAKE_CASE							:					Optional[Any]           =							[np.asarray(UpperCamelCase__		) for x in speech_inputs]
												return speech_inputs






@require_torch
@require_torchaudio
class       lowercase__		(     UpperCamelCase_			,							unittest.TestCase):
						UpperCamelCase_  =	TvltFeatureExtractor


						def  __A ( self			:       List[str]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Dict           =							TvltFeatureExtractionTester(self		)


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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Any           =							self.feature_extraction_class(**self.feat_extract_dict		)
												self.assertTrue(hasattr(UpperCamelCase__					,	'''spectrogram_length'''		)		)
												self.assertTrue(hasattr(UpperCamelCase__					,	'''feature_size'''		)		)
												self.assertTrue(hasattr(UpperCamelCase__					,	'''num_audio_channels'''		)		)
												self.assertTrue(hasattr(UpperCamelCase__					,	'''hop_length'''		)		)
												self.assertTrue(hasattr(UpperCamelCase__					,	'''chunk_length'''		)		)
												self.assertTrue(hasattr(UpperCamelCase__					,	'''sampling_rate'''		)		)


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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Union[str, Any]           =							self.feature_extraction_class(**self.feat_extract_dict		)

												with tempfile.TemporaryDirectory() as tmpdirname:
																		SCREAMING_SNAKE_CASE							:					Optional[Any]           =							feat_extract_first.save_pretrained(UpperCamelCase__		)[0]
																		check_json_file_has_correct_format(UpperCamelCase__		)
																		SCREAMING_SNAKE_CASE							:					List[Any]           =							self.feature_extraction_class.from_pretrained(UpperCamelCase__		)

												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							feat_extract_first.to_dict()
												SCREAMING_SNAKE_CASE							:					str           =							feat_extract_second.to_dict()
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							dict_first.pop('''mel_filters'''		)
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							dict_second.pop('''mel_filters'''		)
												self.assertTrue(np.allclose(UpperCamelCase__					,	UpperCamelCase__		)		)
												self.assertEqual(UpperCamelCase__					,	UpperCamelCase__		)


						def  __A ( self			:       int		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Dict           =							self.feature_extraction_class(**self.feat_extract_dict		)

												with tempfile.TemporaryDirectory() as tmpdirname:
																		SCREAMING_SNAKE_CASE							:					Tuple           =							os.path.join(UpperCamelCase__					,	'''feat_extract.json'''		)
																		feat_extract_first.to_json_file(UpperCamelCase__		)
																		SCREAMING_SNAKE_CASE							:					List[str]           =							self.feature_extraction_class.from_json_file(UpperCamelCase__		)

												SCREAMING_SNAKE_CASE							:					Any           =							feat_extract_first.to_dict()
												SCREAMING_SNAKE_CASE							:					str           =							feat_extract_second.to_dict()
												SCREAMING_SNAKE_CASE							:					int           =							dict_first.pop('''mel_filters'''		)
												SCREAMING_SNAKE_CASE							:					Any           =							dict_second.pop('''mel_filters'''		)
												self.assertTrue(np.allclose(UpperCamelCase__					,	UpperCamelCase__		)		)
												self.assertEqual(UpperCamelCase__					,	UpperCamelCase__		)


						def  __A ( self			:       Any		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					int           =							self.feature_extraction_class(**self.feat_extract_dict		)

												# create three inputs of length 800, 1000, and 1200
												SCREAMING_SNAKE_CASE							:					List[Any]           =							[floats_list((1, x)		)[0] for x in range(800					,	1400					,	200		)]
												SCREAMING_SNAKE_CASE							:					Optional[int]           =							[np.asarray(UpperCamelCase__		) for speech_input in speech_inputs]

												# Test not batched input
												SCREAMING_SNAKE_CASE							:					List[Any]           =							feature_extractor(np_speech_inputs[0]					,	return_tensors='''np'''					,	sampling_rate=4_4100		).audio_values

												self.assertTrue(encoded_audios.ndim == 4		)
												self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size		)
												self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length		)
												self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels		)

												# Test batched
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							feature_extractor(UpperCamelCase__					,	return_tensors='''np'''					,	sampling_rate=4_4100		).audio_values

												self.assertTrue(encoded_audios.ndim == 4		)
												self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size		)
												self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length		)
												self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels		)

												# Test audio masking
												SCREAMING_SNAKE_CASE							:					List[str]           =							feature_extractor(
												    UpperCamelCase__					,	return_tensors='''np'''					,	sampling_rate=4_4100					,	mask_audio=UpperCamelCase__		).audio_values

												self.assertTrue(encoded_audios.ndim == 4		)
												self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size		)
												self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length		)
												self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels		)

												# Test 2-D numpy arrays are batched.
												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							[floats_list((1, x)		)[0] for x in (800, 800, 800)]
												SCREAMING_SNAKE_CASE							:					Dict           =							np.asarray(UpperCamelCase__		)
												SCREAMING_SNAKE_CASE							:					str           =							feature_extractor(UpperCamelCase__					,	return_tensors='''np'''					,	sampling_rate=4_4100		).audio_values
												self.assertTrue(encoded_audios.ndim == 4		)
												self.assertTrue(encoded_audios.shape[-1] == feature_extractor.feature_size		)
												self.assertTrue(encoded_audios.shape[-2] <= feature_extractor.spectrogram_length		)
												self.assertTrue(encoded_audios.shape[-3] == feature_extractor.num_channels		)


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





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					List[str]           =							load_dataset('''hf-internal-testing/librispeech_asr_dummy'''					,	'''clean'''					,	split='''validation'''		)
												# automatic decoding with librispeech
												SCREAMING_SNAKE_CASE							:					Dict           =							ds.sort('''id'''		).select(range(UpperCamelCase__		)		)[:num_samples]['''audio''']

												return [x["array"] for x in speech_samples]



						def  __A ( self			:       List[Any]		):





												'''simple docstring'''





												SCREAMING_SNAKE_CASE							:					Optional[Any]           =							self._load_datasamples(1		)
												SCREAMING_SNAKE_CASE							:					int           =							TvltFeatureExtractor()
												SCREAMING_SNAKE_CASE							:					List[Any]           =							feature_extractor(UpperCamelCase__					,	return_tensors='''pt'''		).audio_values

												self.assertEquals(audio_values.shape					,	(1, 1, 192, 128)		)

												SCREAMING_SNAKE_CASE							:					str           =							torch.tensor([[-0.3032, -0.2708], [-0.4434, -0.4007]]		)
												self.assertTrue(torch.allclose(audio_values[0, 0, :2, :2]					,	UpperCamelCase__					,	atol=1E-4		)		)





