



import itertools
import random
import unittest

import numpy as np

from transformers import BatchFeature, SpeechTaFeatureExtractor
from transformers.testing_utils import require_torch
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_torch_available():
							import torch


__snake_case       :	List[Any]            =random.Random()






def 			lowerCAmelCase__	(					lowerCamelCase_	:	Optional[Any] ,lowerCamelCase_	:	Optional[Any]=1.0 ,lowerCamelCase_	:	List[Any]=None ,lowerCamelCase_	:	Union[str, Any]=None):





				'''simple docstring'''

				if rng is None:
								lowerCAmelCase__  :       Any				=  global_rng

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

				return values



@require_torch
class  lowerCamelCase__    (							unittest.TestCase):




		'''simple docstring'''



		def __init__(self	,__lowerCamelCase	,__lowerCamelCase=7	,__lowerCamelCase=4_00	,__lowerCamelCase=20_00	,__lowerCamelCase=1	,__lowerCamelCase=0.0	,__lowerCamelCase=1_60_00	,__lowerCamelCase=True	,__lowerCamelCase=80	,__lowerCamelCase=16	,__lowerCamelCase=64	,__lowerCamelCase="hann_window"	,__lowerCamelCase=80	,__lowerCamelCase=76_00	,__lowerCamelCase=1e-10	,__lowerCamelCase=True	,)  ->    List[str]:

						"""simple docstring"""






						lowerCAmelCase__  :       int				=  parent
						lowerCAmelCase__  :       Dict				=  batch_size
						lowerCAmelCase__  :       List[Any]				=  min_seq_length
						lowerCAmelCase__  :       List[Any]				=  max_seq_length
						lowerCAmelCase__  :       Optional[Any]				=  (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
						lowerCAmelCase__  :       Optional[Any]				=  feature_size
						lowerCAmelCase__  :       Optional[Any]				=  padding_value
						lowerCAmelCase__  :       Union[str, Any]				=  sampling_rate
						lowerCAmelCase__  :       Optional[Any]				=  do_normalize
						lowerCAmelCase__  :       Tuple				=  num_mel_bins
						lowerCAmelCase__  :       List[str]				=  hop_length
						lowerCAmelCase__  :       Any				=  win_length
						lowerCAmelCase__  :       Union[str, Any]				=  win_function
						lowerCAmelCase__  :       List[str]				=  fmin
						lowerCAmelCase__  :       Union[str, Any]				=  fmax
						lowerCAmelCase__  :       List[Any]				=  mel_floor
						lowerCAmelCase__  :       Optional[int]				=  return_attention_mask



		def 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






						return {
						    "feature_size": self.feature_size,
						    "padding_value": self.padding_value,
						    "sampling_rate": self.sampling_rate,
						    "do_normalize": self.do_normalize,
						    "num_mel_bins": self.num_mel_bins,
						    "hop_length": self.hop_length,
						    "win_length": self.win_length,
						    "win_function": self.win_function,
						    "fmin": self.fmin,
						    "fmax": self.fmax,
						    "mel_floor": self.mel_floor,
						    "return_attention_mask": self.return_attention_mask,
						}



		def 	lowerCAmelCase__   (self	,__lowerCamelCase=False	,__lowerCamelCase=False				)  ->    Any:

						"""simple docstring"""






						def _flatten(__lowerCamelCase				):
										return list(itertools.chain(*__lowerCamelCase				)				)

						if equal_length:
										lowerCAmelCase__  :       Union[str, Any]				=  floats_list((self.batch_size, self.max_seq_length)				)
						else:
										# make sure that inputs increase in size
										lowerCAmelCase__  :       Optional[Any]				=  [
										    _flatten(floats_list((x, self.feature_size)				)				)
										    for x in range(self.min_seq_length	,self.max_seq_length	,self.seq_length_diff				)
										]

						if numpify:
										lowerCAmelCase__  :       Dict				=  [np.asarray(__lowerCamelCase				) for x in speech_inputs]

						return speech_inputs



		def 	lowerCAmelCase__   (self	,__lowerCamelCase=False	,__lowerCamelCase=False				)  ->    Union[str, Any]:

						"""simple docstring"""






						if equal_length:
										lowerCAmelCase__  :       Union[str, Any]				=  [floats_list((self.max_seq_length, self.num_mel_bins)				) for _ in range(self.batch_size				)]
						else:
										# make sure that inputs increase in size
										lowerCAmelCase__  :       Optional[Any]				=  [
										    floats_list((x, self.num_mel_bins)				)
										    for x in range(self.min_seq_length	,self.max_seq_length	,self.seq_length_diff				)
										]

						if numpify:
										lowerCAmelCase__  :       Tuple				=  [np.asarray(__lowerCamelCase				) for x in speech_inputs]

						return speech_inputs



@require_torch
class  lowerCamelCase__    (							lowerCamelCase__   ,       unittest.TestCase):




		'''simple docstring'''



		snake_case_			=SpeechTaFeatureExtractor



		def 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Tuple				=  SpeechTaFeatureExtractionTester(self				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase				)  ->    Optional[int]:

						"""simple docstring"""






						self.assertTrue(np.all(np.mean(__lowerCamelCase	,axis=0				) < 1e-3				)				)
						self.assertTrue(np.all(np.abs(np.var(__lowerCamelCase	,axis=0				) - 1				) < 1e-3				)				)



		def 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Tuple				=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
						# create three inputs of length 800, 1000, and 1200
						lowerCAmelCase__  :       Union[str, Any]				=  [floats_list((1, x)				)[0] for x in range(8_00	,14_00	,2_00				)]
						lowerCAmelCase__  :       Optional[int]				=  [np.asarray(__lowerCamelCase				) for speech_input in speech_inputs]

						# Test not batched input
						lowerCAmelCase__  :       Dict				=  feat_extract(speech_inputs[0]	,return_tensors='''np'''				).input_values
						lowerCAmelCase__  :       Any				=  feat_extract(np_speech_inputs[0]	,return_tensors='''np'''				).input_values
						self.assertTrue(np.allclose(__lowerCamelCase	,__lowerCamelCase	,atol=1e-3				)				)

						# Test batched
						lowerCAmelCase__  :       int				=  feat_extract(__lowerCamelCase	,return_tensors='''np'''				).input_values
						lowerCAmelCase__  :       str				=  feat_extract(__lowerCamelCase	,return_tensors='''np'''				).input_values
						for enc_seq_a, enc_seq_a in zip(__lowerCamelCase	,__lowerCamelCase				):
										self.assertTrue(np.allclose(__lowerCamelCase	,__lowerCamelCase	,atol=1e-3				)				)



		def 	lowerCAmelCase__   (self				)  ->    Dict:

						"""simple docstring"""






						lowerCAmelCase__  :       str				=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
						lowerCAmelCase__  :       Optional[Any]				=  [floats_list((1, x)				)[0] for x in range(8_00	,14_00	,2_00				)]

						lowerCAmelCase__  :       List[str]				=  ['''longest''', '''max_length''', '''do_not_pad''']
						lowerCAmelCase__  :       Optional[Any]				=  [None, 16_00, None]
						for max_length, padding in zip(__lowerCamelCase	,__lowerCamelCase				):
										lowerCAmelCase__  :       Any				=  feat_extract(__lowerCamelCase	,padding=__lowerCamelCase	,max_length=__lowerCamelCase	,return_tensors='''np'''				)
										lowerCAmelCase__  :       Optional[int]				=  processed.input_values

										self._check_zero_mean_unit_variance(input_values[0][:8_00]				)
										self.assertTrue(input_values[0][8_00:].sum() < 1e-6				)
										self._check_zero_mean_unit_variance(input_values[1][:10_00]				)
										self.assertTrue(input_values[0][10_00:].sum() < 1e-6				)
										self._check_zero_mean_unit_variance(input_values[2][:12_00]				)



		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       List[str]				=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
						lowerCAmelCase__  :       List[str]				=  range(8_00	,14_00	,2_00				)
						lowerCAmelCase__  :       Optional[Any]				=  [floats_list((1, x)				)[0] for x in lengths]

						lowerCAmelCase__  :       Union[str, Any]				=  ['''longest''', '''max_length''', '''do_not_pad''']
						lowerCAmelCase__  :       int				=  [None, 16_00, None]

						for max_length, padding in zip(__lowerCamelCase	,__lowerCamelCase				):
										lowerCAmelCase__  :       str				=  feat_extract(__lowerCamelCase	,max_length=__lowerCamelCase	,padding=__lowerCamelCase				)
										lowerCAmelCase__  :       Tuple				=  processed.input_values

										self._check_zero_mean_unit_variance(input_values[0][:8_00]				)
										self._check_zero_mean_unit_variance(input_values[1][:10_00]				)
										self._check_zero_mean_unit_variance(input_values[2][:12_00]				)



		def 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
						lowerCAmelCase__  :       Optional[Any]				=  [floats_list((1, x)				)[0] for x in range(8_00	,14_00	,2_00				)]
						lowerCAmelCase__  :       Optional[int]				=  feat_extract(
						    __lowerCamelCase	,truncation=__lowerCamelCase	,max_length=10_00	,padding='''max_length'''	,return_tensors='''np'''				)
						lowerCAmelCase__  :       List[Any]				=  processed.input_values

						self._check_zero_mean_unit_variance(input_values[0, :8_00]				)
						self._check_zero_mean_unit_variance(input_values[1]				)
						self._check_zero_mean_unit_variance(input_values[2]				)



		def 	lowerCAmelCase__   (self				)  ->    List[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
						lowerCAmelCase__  :       List[str]				=  [floats_list((1, x)				)[0] for x in range(8_00	,14_00	,2_00				)]
						lowerCAmelCase__  :       Union[str, Any]				=  feat_extract(
						    __lowerCamelCase	,truncation=__lowerCamelCase	,max_length=10_00	,padding='''longest'''	,return_tensors='''np'''				)
						lowerCAmelCase__  :       Optional[int]				=  processed.input_values

						self._check_zero_mean_unit_variance(input_values[0, :8_00]				)
						self._check_zero_mean_unit_variance(input_values[1, :10_00]				)
						self._check_zero_mean_unit_variance(input_values[2]				)

						# make sure that if max_length < longest -> then pad to max_length
						self.assertTrue(input_values.shape == (3, 10_00)				)

						lowerCAmelCase__  :       Tuple				=  [floats_list((1, x)				)[0] for x in range(8_00	,14_00	,2_00				)]
						lowerCAmelCase__  :       Optional[int]				=  feat_extract(
						    __lowerCamelCase	,truncation=__lowerCamelCase	,max_length=20_00	,padding='''longest'''	,return_tensors='''np'''				)
						lowerCAmelCase__  :       Optional[Any]				=  processed.input_values

						self._check_zero_mean_unit_variance(input_values[0, :8_00]				)
						self._check_zero_mean_unit_variance(input_values[1, :10_00]				)
						self._check_zero_mean_unit_variance(input_values[2]				)

						# make sure that if max_length > longest -> then pad to longest
						self.assertTrue(input_values.shape == (3, 12_00)				)



		def 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
						lowerCAmelCase__  :       Union[str, Any]				=  np.random.rand(1_00				).astype(np.floataa				)
						lowerCAmelCase__  :       Any				=  np_speech_inputs.tolist()

						for inputs in [py_speech_inputs, np_speech_inputs]:
										lowerCAmelCase__  :       str				=  feature_extractor.pad([{'''input_values''': inputs}]	,return_tensors='''np'''				)
										self.assertTrue(np_processed.input_values.dtype == np.floataa				)
										lowerCAmelCase__  :       int				=  feature_extractor.pad([{'''input_values''': inputs}]	,return_tensors='''pt'''				)
										self.assertTrue(pt_processed.input_values.dtype == torch.floataa				)



		def 	lowerCAmelCase__   (self				)  ->    str:

						"""simple docstring"""






						lowerCAmelCase__  :       str				=  self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()				)
						# create three inputs of length 800, 1000, and 1200
						lowerCAmelCase__  :       Any				=  [floats_list((1, x)				)[0] for x in range(8_00	,14_00	,2_00				)]
						lowerCAmelCase__  :       Optional[Any]				=  [np.asarray(__lowerCamelCase				) for speech_input in speech_inputs]

						# Test feature size
						lowerCAmelCase__  :       List[str]				=  feature_extractor(audio_target=__lowerCamelCase	,padding=__lowerCamelCase	,return_tensors='''np'''				).input_values
						self.assertTrue(input_values.ndim == 3				)
						self.assertTrue(input_values.shape[-1] == feature_extractor.num_mel_bins				)

						# Test not batched input
						lowerCAmelCase__  :       List[str]				=  feature_extractor(speech_inputs[0]	,return_tensors='''np'''				).input_values
						lowerCAmelCase__  :       Optional[int]				=  feature_extractor(np_speech_inputs[0]	,return_tensors='''np'''				).input_values
						self.assertTrue(np.allclose(__lowerCamelCase	,__lowerCamelCase	,atol=1e-3				)				)

						# Test batched
						lowerCAmelCase__  :       Dict				=  feature_extractor(__lowerCamelCase	,return_tensors='''np'''				).input_values
						lowerCAmelCase__  :       List[Any]				=  feature_extractor(__lowerCamelCase	,return_tensors='''np'''				).input_values
						for enc_seq_a, enc_seq_a in zip(__lowerCamelCase	,__lowerCamelCase				):
										self.assertTrue(np.allclose(__lowerCamelCase	,__lowerCamelCase	,atol=1e-3				)				)

						# Test 2-D numpy arrays are batched.
						lowerCAmelCase__  :       Tuple				=  [floats_list((1, x)				)[0] for x in (8_00, 8_00, 8_00)]
						lowerCAmelCase__  :       Optional[int]				=  np.asarray(__lowerCamelCase				)
						lowerCAmelCase__  :       Dict				=  feature_extractor(__lowerCamelCase	,return_tensors='''np'''				).input_values
						lowerCAmelCase__  :       Dict				=  feature_extractor(__lowerCamelCase	,return_tensors='''np'''				).input_values
						for enc_seq_a, enc_seq_a in zip(__lowerCamelCase	,__lowerCamelCase				):
										self.assertTrue(np.allclose(__lowerCamelCase	,__lowerCamelCase	,atol=1e-3				)				)



		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       Tuple				=  self.feat_extract_tester.prepare_inputs_for_target()
						lowerCAmelCase__  :       Union[str, Any]				=  self.feature_extraction_class(**self.feat_extract_dict				)
						lowerCAmelCase__  :       Optional[int]				=  feat_extract.model_input_names[0]

						lowerCAmelCase__  :       Dict				=  BatchFeature({input_name: speech_inputs}				)

						self.assertTrue(all(len(__lowerCamelCase				) == len(__lowerCamelCase				) for x, y in zip(__lowerCamelCase	,processed_features[input_name]				)				)				)

						lowerCAmelCase__  :       str				=  self.feat_extract_tester.prepare_inputs_for_target(equal_length=__lowerCamelCase				)
						lowerCAmelCase__  :       List[Any]				=  BatchFeature({input_name: speech_inputs}	,tensor_type='''np'''				)

						lowerCAmelCase__  :       int				=  processed_features[input_name]

						if len(batch_features_input.shape				) < 3:
										lowerCAmelCase__  :       List[str]				=  batch_features_input[:, :, None]

						self.assertTrue(
						    batch_features_input.shape
						    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]				), self.feat_extract_tester.num_mel_bins)				)



		@require_torch
		def 	lowerCAmelCase__   (self				)  ->    List[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  self.feat_extract_tester.prepare_inputs_for_target(equal_length=__lowerCamelCase				)
						lowerCAmelCase__  :       List[Any]				=  self.feature_extraction_class(**self.feat_extract_dict				)
						lowerCAmelCase__  :       int				=  feat_extract.model_input_names[0]

						lowerCAmelCase__  :       Union[str, Any]				=  BatchFeature({input_name: speech_inputs}	,tensor_type='''pt'''				)

						lowerCAmelCase__  :       Optional[int]				=  processed_features[input_name]

						if len(batch_features_input.shape				) < 3:
										lowerCAmelCase__  :       Optional[int]				=  batch_features_input[:, :, None]

						self.assertTrue(
						    batch_features_input.shape
						    == (self.feat_extract_tester.batch_size, len(speech_inputs[0]				), self.feat_extract_tester.num_mel_bins)				)



		@require_torch
		def 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[Any]				=  self.feature_extraction_class(**self.feat_extract_dict				)
						lowerCAmelCase__  :       List[str]				=  self.feat_extract_tester.prepare_inputs_for_target()
						lowerCAmelCase__  :       Optional[int]				=  feat_extract.model_input_names[0]

						lowerCAmelCase__  :       Union[str, Any]				=  BatchFeature({input_name: speech_inputs}				)

						lowerCAmelCase__  :       Optional[int]				=  feat_extract.num_mel_bins  # hack!

						lowerCAmelCase__  :       List[str]				=  feat_extract.pad(__lowerCamelCase	,padding='''longest'''	,return_tensors='''np'''				)[input_name]
						lowerCAmelCase__  :       Any				=  feat_extract.pad(__lowerCamelCase	,padding='''longest'''	,return_tensors='''pt'''				)[input_name]

						self.assertTrue(abs(input_np.astype(np.floataa				).sum() - input_pt.numpy().astype(np.floataa				).sum()				) < 1e-2				)



		def 	lowerCAmelCase__   (self				)  ->    List[str]:

						"""simple docstring"""






						lowerCAmelCase__  :       List[str]				=  self.feat_extract_dict
						lowerCAmelCase__  :       Optional[Any]				=  True
						lowerCAmelCase__  :       Optional[Any]				=  self.feature_extraction_class(**__lowerCamelCase				)
						lowerCAmelCase__  :       int				=  self.feat_extract_tester.prepare_inputs_for_target()
						lowerCAmelCase__  :       Optional[int]				=  [len(__lowerCamelCase				) for x in speech_inputs]
						lowerCAmelCase__  :       Union[str, Any]				=  feat_extract.model_input_names[0]

						lowerCAmelCase__  :       Tuple				=  BatchFeature({input_name: speech_inputs}				)

						lowerCAmelCase__  :       str				=  feat_extract.num_mel_bins  # hack!

						lowerCAmelCase__  :       List[Any]				=  feat_extract.pad(__lowerCamelCase	,padding='''longest'''	,return_tensors='''np'''				)
						self.assertIn('''attention_mask'''	,__lowerCamelCase				)
						self.assertListEqual(list(processed.attention_mask.shape				)	,list(processed[input_name].shape[:2]				)				)
						self.assertListEqual(processed.attention_mask.sum(-1				).tolist()	,__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  self.feat_extract_dict
						lowerCAmelCase__  :       Any				=  True
						lowerCAmelCase__  :       List[str]				=  self.feature_extraction_class(**__lowerCamelCase				)
						lowerCAmelCase__  :       Any				=  self.feat_extract_tester.prepare_inputs_for_target()
						lowerCAmelCase__  :       Tuple				=  [len(__lowerCamelCase				) for x in speech_inputs]
						lowerCAmelCase__  :       str				=  feat_extract.model_input_names[0]

						lowerCAmelCase__  :       int				=  BatchFeature({input_name: speech_inputs}				)
						lowerCAmelCase__  :       Optional[int]				=  min(__lowerCamelCase				)

						lowerCAmelCase__  :       Dict				=  feat_extract.num_mel_bins  # hack!

						lowerCAmelCase__  :       Union[str, Any]				=  feat_extract.pad(
						    __lowerCamelCase	,padding='''max_length'''	,max_length=__lowerCamelCase	,truncation=__lowerCamelCase	,return_tensors='''np'''				)
						self.assertIn('''attention_mask'''	,__lowerCamelCase				)
						self.assertListEqual(
						    list(processed_pad.attention_mask.shape				)	,[processed_pad[input_name].shape[0], max_length]				)
						self.assertListEqual(
						    processed_pad.attention_mask[:, :max_length].sum(-1				).tolist()	,[max_length for x in speech_inputs]				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase				)  ->    List[str]:

						"""simple docstring"""






						from datasets import load_dataset

						lowerCAmelCase__  :       Tuple				=  load_dataset('''hf-internal-testing/librispeech_asr_dummy'''	,'''clean'''	,split='''validation'''				)
						# automatic decoding with librispeech
						lowerCAmelCase__  :       Tuple				=  ds.sort('''id'''				).select(range(__lowerCamelCase				)				)[:num_samples]['''audio''']

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



		def 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Tuple				=  torch.tensor(
						    [2.3804e-03, 2.0752e-03, 1.9836e-03, 2.1057e-03, 1.6174e-03,
						     3.0518e-04, 9.1553e-05, 3.3569e-04, 9.7656e-04, 1.8311e-03,
						     2.0142e-03, 2.1057e-03, 1.7395e-03, 4.5776e-04, -3.9673e-04,
						     4.5776e-04, 1.0071e-03, 9.1553e-05, 4.8828e-04, 1.1597e-03,
						     7.3242e-04, 9.4604e-04, 1.8005e-03, 1.8311e-03, 8.8501e-04,
						     4.2725e-04, 4.8828e-04, 7.3242e-04, 1.0986e-03, 2.1057e-03]				)
						# fmt: on

						lowerCAmelCase__  :       Dict				=  self._load_datasamples(1				)
						lowerCAmelCase__  :       Any				=  SpeechTaFeatureExtractor()
						lowerCAmelCase__  :       Dict				=  feature_extractor(__lowerCamelCase	,return_tensors='''pt'''				).input_values
						self.assertEquals(input_values.shape	,(1, 9_36_80)				)
						self.assertTrue(torch.allclose(input_values[0, :30]	,__lowerCamelCase	,atol=1e-6				)				)



		def 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__  :       Union[str, Any]				=  torch.tensor(
						    [-2.6870, -3.0104, -3.1356, -3.5352, -3.0044, -3.0353, -3.4719, -3.6777,
						     -3.1520, -2.9435, -2.6553, -2.8795, -2.9944, -2.5921, -3.0279, -3.0386,
						     -3.0864, -3.1291, -3.2353, -2.7444, -2.6831, -2.7287, -3.1761, -3.1571,
						     -3.2726, -3.0582, -3.1007, -3.4533, -3.4695, -3.0998]				)
						# fmt: on

						lowerCAmelCase__  :       Tuple				=  self._load_datasamples(1				)
						lowerCAmelCase__  :       Optional[Any]				=  SpeechTaFeatureExtractor()
						lowerCAmelCase__  :       Any				=  feature_extractor(audio_target=__lowerCamelCase	,return_tensors='''pt'''				).input_values
						self.assertEquals(input_values.shape	,(1, 3_66, 80)				)
						self.assertTrue(torch.allclose(input_values[0, 0, :30]	,__lowerCamelCase	,atol=1e-4				)				)






from __future__ import annotations






def 			lowerCAmelCase__	(					lowerCamelCase_	:	list[int]):





				'''simple docstring'''

				return len(set(lowerCamelCase_)) == len(lowerCamelCase_)


if __name__ == "__main__":
							import doctest

							doctest.testmod()

