



import unittest

from diffusers.models.unet_ad_blocks import *  # noqa F403
from diffusers.utils import torch_device

from .test_unet_blocks_common import UNetBlockTesterMixin






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Optional[int]    =DownBlockaD  # noqa F405
							__lowerCamelCase	:	Any    ='down'





							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											__a       =		[-0.0232, -0.9869, 0.8054, -0.0637, -0.1688, -1.4264, 0.4470, -1.3394, 0.0904]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Union[str, Any]    =ResnetDownsampleBlockaD  # noqa F405
							__lowerCamelCase	:	Union[str, Any]    ='down'





							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											__a       =		[0.0710, 0.2410, -0.7320, -1.0757, -1.1343, 0.3540, -0.0133, -0.2576, 0.0948]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Dict    =AttnDownBlockaD  # noqa F405
							__lowerCamelCase	:	Optional[Any]    ='down'





							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											__a       =		[0.0636, 0.8964, -0.6234, -1.0131, 0.0844, 0.4935, 0.3437, 0.0911, -0.2957]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Optional[Any]    =CrossAttnDownBlockaD  # noqa F405
							__lowerCamelCase	:	Dict    ='down'





							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											__a     ,					__a       =		super().prepare_init_args_and_inputs_for_common()
											__a       =		32
											return init_dict, inputs_dict







							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											__a       =		[0.2238, -0.7396, -0.2255, -0.3829, 0.1925, 1.1665, 0.0603, -0.7295, 0.1983]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	List[str]    =SimpleCrossAttnDownBlockaD  # noqa F405
							__lowerCamelCase	:	List[Any]    ='down'





							@property
							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											return super().get_dummy_input(include_encoder_hidden_states=__lowercase	)





							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											__a     ,					__a       =		super().prepare_init_args_and_inputs_for_common()
											__a       =		32
											return init_dict, inputs_dict







							@unittest.skipIf(torch_device == """mps"""      ,				"""MPS result is not consistent"""	)
							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											__a       =		[0.7921, -0.0992, -0.1962, -0.7695, -0.4242, 0.7804, 0.4737, 0.2765, 0.3338]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	List[Any]    =SkipDownBlockaD  # noqa F405
							__lowerCamelCase	:	Optional[int]    ='down'





							@property
							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											return super().get_dummy_input(include_skip_sample=__lowercase	)







							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											__a       =		[-0.0845, -0.2087, -0.2465, 0.0971, 0.1900, -0.0484, 0.2664, 0.4179, 0.5069]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Optional[int]    =AttnSkipDownBlockaD  # noqa F405
							__lowerCamelCase	:	List[str]    ='down'





							@property
							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											return super().get_dummy_input(include_skip_sample=__lowercase	)







							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											__a       =		[0.5539, 0.1609, 0.4924, 0.0537, -0.1995, 0.4050, 0.0979, -0.2721, -0.0642]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Optional[Any]    =DownEncoderBlockaD  # noqa F405
							__lowerCamelCase	:	List[Any]    ='down'





							@property
							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											return super().get_dummy_input(include_temb=__lowercase	)





							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											__a       =		{
											    """in_channels""": 32,
											    """out_channels""": 32,
											}
											__a       =		self.dummy_input
											return init_dict, inputs_dict







							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											__a       =		[1.1102, 0.5302, 0.4872, -0.0023, -0.8042, 0.0483, -0.3489, -0.5632, 0.7626]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	str    =AttnDownEncoderBlockaD  # noqa F405
							__lowerCamelCase	:	List[Any]    ='down'





							@property
							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											return super().get_dummy_input(include_temb=__lowercase	)





							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											__a       =		{
											    """in_channels""": 32,
											    """out_channels""": 32,
											}
											__a       =		self.dummy_input
											return init_dict, inputs_dict







							def 						UpperCamelCase_					(   self		:		Any	):

											'''simple docstring'''
											__a       =		[0.8966, -0.1486, 0.8568, 0.8141, -0.9046, -0.1342, -0.0972, -0.7417, 0.1538]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Dict    =UNetMidBlockaD  # noqa F405
							__lowerCamelCase	:	Optional[int]    ='mid'





							def 						UpperCamelCase_					(   self		:		Any	):

											'''simple docstring'''
											__a       =		{
											    """in_channels""": 32,
											    """temb_channels""": 128,
											}
											__a       =		self.dummy_input
											return init_dict, inputs_dict







							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											__a       =		[-0.1062, 1.7248, 0.3494, 1.4569, -0.0910, -1.2421, -0.9984, 0.6736, 1.0028]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Union[str, Any]    =UNetMidBlockaDCrossAttn  # noqa F405
							__lowerCamelCase	:	List[Any]    ='mid'





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

											'''simple docstring'''
											__a     ,					__a       =		super().prepare_init_args_and_inputs_for_common()
											__a       =		32
											return init_dict, inputs_dict







							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											__a       =		[0.0187, 2.4220, 0.4484, 1.1203, -0.6121, -1.5122, -0.8270, 0.7851, 1.8335]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Tuple    =UNetMidBlockaDSimpleCrossAttn  # noqa F405
							__lowerCamelCase	:	Tuple    ='mid'





							@property
							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											return super().get_dummy_input(include_encoder_hidden_states=__lowercase	)





							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											__a     ,					__a       =		super().prepare_init_args_and_inputs_for_common()
											__a       =		32
											return init_dict, inputs_dict







							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											__a       =		[0.7143, 1.9974, 0.5448, 1.3977, 0.1282, -1.1237, -1.4238, 0.5530, 0.8880]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	str    =UpBlockaD  # noqa F405
							__lowerCamelCase	:	Optional[Any]    ='up'





							@property
							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											return super().get_dummy_input(include_res_hidden_states_tuple=__lowercase	)







							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											__a       =		[-0.2041, -0.4165, -0.3022, 0.0041, -0.6628, -0.7053, 0.1928, -0.0325, 0.0523]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	str    =ResnetUpsampleBlockaD  # noqa F405
							__lowerCamelCase	:	List[str]    ='up'





							@property
							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											return super().get_dummy_input(include_res_hidden_states_tuple=__lowercase	)







							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											__a       =		[0.2287, 0.3549, -0.1346, 0.4797, -0.1715, -0.9649, 0.7305, -0.5864, -0.6244]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Tuple    =CrossAttnUpBlockaD  # noqa F405
							__lowerCamelCase	:	Optional[Any]    ='up'





							@property
							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											return super().get_dummy_input(include_res_hidden_states_tuple=__lowercase	)





							def 						UpperCamelCase_					(   self		:		Any	):

											'''simple docstring'''
											__a     ,					__a       =		super().prepare_init_args_and_inputs_for_common()
											__a       =		32
											return init_dict, inputs_dict







							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											__a       =		[-0.1403, -0.3515, -0.0420, -0.1425, 0.3167, 0.5094, -0.2181, 0.5931, 0.5582]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Union[str, Any]    =SimpleCrossAttnUpBlockaD  # noqa F405
							__lowerCamelCase	:	List[str]    ='up'





							@property
							def 						UpperCamelCase_					(   self		:		Optional[Any]	):

											'''simple docstring'''
											return super().get_dummy_input(include_res_hidden_states_tuple=__lowercase      ,				include_encoder_hidden_states=__lowercase	)





							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											__a     ,					__a       =		super().prepare_init_args_and_inputs_for_common()
											__a       =		32
											return init_dict, inputs_dict







							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											__a       =		[0.2645, 0.1480, 0.0909, 0.8044, -0.9758, -0.9083, 0.0994, -1.1453, -0.7402]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	int    =AttnUpBlockaD  # noqa F405
							__lowerCamelCase	:	Optional[Any]    ='up'





							@property
							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											return super().get_dummy_input(include_res_hidden_states_tuple=__lowercase	)







							@unittest.skipIf(torch_device == """mps"""      ,				"""MPS result is not consistent"""	)
							def 						UpperCamelCase_					(   self		:		Optional[Any]	):

											'''simple docstring'''
											__a       =		[0.0979, 0.1326, 0.0021, 0.0659, 0.2249, 0.0059, 0.1132, 0.5952, 0.1033]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Any    =SkipUpBlockaD  # noqa F405
							__lowerCamelCase	:	List[str]    ='up'





							@property
							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											return super().get_dummy_input(include_res_hidden_states_tuple=__lowercase	)







							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											__a       =		[-0.0893, -0.1234, -0.1506, -0.0332, 0.0123, -0.0211, 0.0566, 0.0143, 0.0362]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Optional[Any]    =AttnSkipUpBlockaD  # noqa F405
							__lowerCamelCase	:	List[str]    ='up'





							@property
							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											return super().get_dummy_input(include_res_hidden_states_tuple=__lowercase	)







							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											__a       =		[0.0361, 0.0617, 0.2787, -0.0350, 0.0342, 0.3421, -0.0843, 0.0913, 0.3015]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Optional[int]    =UpDecoderBlockaD  # noqa F405
							__lowerCamelCase	:	Tuple    ='up'





							@property
							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											return super().get_dummy_input(include_temb=__lowercase	)





							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											__a       =		{"""in_channels""": 32, """out_channels""": 32}

											__a       =		self.dummy_input
											return init_dict, inputs_dict







							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											__a       =		[0.4404, 0.1998, -0.9886, -0.3320, -0.3128, -0.7034, -0.6955, -0.2338, -0.3137]
											super().test_output(__lowercase	)






class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	str    =AttnUpDecoderBlockaD  # noqa F405
							__lowerCamelCase	:	Optional[int]    ='up'





							@property
							def 						UpperCamelCase_					(   self		:		List[Any]	):

											'''simple docstring'''
											return super().get_dummy_input(include_temb=__lowercase	)





							def 						UpperCamelCase_					(   self		:		Tuple	):

											'''simple docstring'''
											__a       =		{"""in_channels""": 32, """out_channels""": 32}

											__a       =		self.dummy_input
											return init_dict, inputs_dict







							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											__a       =		[0.6738, 0.4491, 0.1055, 1.0710, 0.7316, 0.3339, 0.3352, 0.1023, 0.3568]
											super().test_output(__lowercase	)





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

lowerCamelCase__			= random.Random()

def   lowerCAmelCase__						(							_SCREAMING_SNAKE_CASE       :			List[str]				,     _SCREAMING_SNAKE_CASE       :			int=1.0				,     _SCREAMING_SNAKE_CASE       :			Any=None				,     _SCREAMING_SNAKE_CASE       :			Any=None    ):
				"""simple docstring"""







				if rng is None:
								__a       =		global_rng

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

				return values






class    SCREAMING_SNAKE_CASE			(							unittest.TestCase					):





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

											'''simple docstring'''
											__a       =		parent
											__a       =		batch_size
											__a       =		min_seq_length
											__a       =		max_seq_length
											__a       =		(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
											__a       =		spectrogram_length
											__a       =		feature_size
											__a       =		num_audio_channels
											__a       =		hop_length
											__a       =		chunk_length
											__a       =		sampling_rate





							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''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 						UpperCamelCase_					(   self		:		Optional[int]      ,				__lowercase		:		Optional[int]=False      ,				__lowercase		:		Any=False	):

											'''simple docstring'''
											def _flatten(__lowercase		:		Tuple	):
															return list(itertools.chain(*__lowercase	)	)

											if equal_length:
															__a       =		[floats_list((self.max_seq_length, self.feature_size)	) for _ in range(self.batch_size	)]
											else:
															# make sure that inputs increase in size
															__a       =		[
															    floats_list((x, self.feature_size)	)
															    for x in range(self.min_seq_length      ,				self.max_seq_length      ,				self.seq_length_diff	)
															]
											if numpify:
															__a       =		[np.asarray(__lowercase	) for x in speech_inputs]
											return speech_inputs






@require_torch
@require_torchaudio
class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__			,      unittest.TestCase					):
							__lowerCamelCase	:	Dict    =TvltFeatureExtractor





							def 						UpperCamelCase_					(   self		:		Any	):

											'''simple docstring'''
											__a       =		TvltFeatureExtractionTester(self	)





							def 						UpperCamelCase_					(   self		:		int	):

											'''simple docstring'''
											__a       =		self.feature_extraction_class(**self.feat_extract_dict	)
											self.assertTrue(hasattr(__lowercase      ,				"""spectrogram_length"""	)	)
											self.assertTrue(hasattr(__lowercase      ,				"""feature_size"""	)	)
											self.assertTrue(hasattr(__lowercase      ,				"""num_audio_channels"""	)	)
											self.assertTrue(hasattr(__lowercase      ,				"""hop_length"""	)	)
											self.assertTrue(hasattr(__lowercase      ,				"""chunk_length"""	)	)
											self.assertTrue(hasattr(__lowercase      ,				"""sampling_rate"""	)	)





							def 						UpperCamelCase_					(   self		:		List[str]	):

											'''simple docstring'''
											__a       =		self.feature_extraction_class(**self.feat_extract_dict	)

											with tempfile.TemporaryDirectory() as tmpdirname:
															__a       =		feat_extract_first.save_pretrained(__lowercase	)[0]
															check_json_file_has_correct_format(__lowercase	)
															__a       =		self.feature_extraction_class.from_pretrained(__lowercase	)

											__a       =		feat_extract_first.to_dict()
											__a       =		feat_extract_second.to_dict()
											__a       =		dict_first.pop("""mel_filters"""	)
											__a       =		dict_second.pop("""mel_filters"""	)
											self.assertTrue(np.allclose(__lowercase      ,				__lowercase	)	)
											self.assertEqual(__lowercase      ,				__lowercase	)





							def 						UpperCamelCase_					(   self		:		Optional[int]	):

											'''simple docstring'''
											__a       =		self.feature_extraction_class(**self.feat_extract_dict	)

											with tempfile.TemporaryDirectory() as tmpdirname:
															__a       =		os.path.join(__lowercase      ,				"""feat_extract.json"""	)
															feat_extract_first.to_json_file(__lowercase	)
															__a       =		self.feature_extraction_class.from_json_file(__lowercase	)

											__a       =		feat_extract_first.to_dict()
											__a       =		feat_extract_second.to_dict()
											__a       =		dict_first.pop("""mel_filters"""	)
											__a       =		dict_second.pop("""mel_filters"""	)
											self.assertTrue(np.allclose(__lowercase      ,				__lowercase	)	)
											self.assertEqual(__lowercase      ,				__lowercase	)





							def 						UpperCamelCase_					(   self		:		Dict	):

											'''simple docstring'''
											# Initialize feature_extractor
											__a       =		self.feature_extraction_class(**self.feat_extract_dict	)

											# create three inputs of length 800, 1000, and 1200
											__a       =		[floats_list((1, x)	)[0] for x in range(800      ,				1400      ,				200	)]
											__a       =		[np.asarray(__lowercase	) for speech_input in speech_inputs]

											# Test not batched input
											__a       =		feature_extractor(np_speech_inputs[0]      ,				return_tensors="""np"""      ,				sampling_rate=44100	).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
											__a       =		feature_extractor(__lowercase      ,				return_tensors="""np"""      ,				sampling_rate=44100	).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
											__a       =		feature_extractor(
											    __lowercase      ,				return_tensors="""np"""      ,				sampling_rate=44100      ,				mask_audio=__lowercase	).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.
											__a       =		[floats_list((1, x)	)[0] for x in (800, 800, 800)]
											__a       =		np.asarray(__lowercase	)
											__a       =		feature_extractor(__lowercase      ,				return_tensors="""np"""      ,				sampling_rate=44100	).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 						UpperCamelCase_					(   self		:		Optional[int]      ,				__lowercase		:		str	):

											'''simple docstring'''
											__a       =		load_dataset("""hf-internal-testing/librispeech_asr_dummy"""      ,				"""clean"""      ,				split="""validation"""	)
											# automatic decoding with librispeech
											__a       =		ds.sort("""id"""	).select(range(__lowercase	)	)[:num_samples]["""audio"""]

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







							def 						UpperCamelCase_					(   self		:		str	):

											'''simple docstring'''
											__a       =		self._load_datasamples(1	)
											__a       =		TvltFeatureExtractor()
											__a       =		feature_extractor(__lowercase      ,				return_tensors="""pt"""	).audio_values

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

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