




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


lowercase_	       =			random.Random()






def 					__lowerCAmelCase		(  __lowerCamelCase	:    str				,   __lowerCamelCase	:    Optional[int]=1.0				,   __lowerCamelCase	:    Any=None				,   __lowerCamelCase	:    Optional[int]=None	)  ->						Union[str, Any]:

					if rng is None:
										__lowerCAmelCase	   =global_rng

					__lowerCAmelCase	   =[]
					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 						__a (     unittest.TestCase				):



	def __init__(						self							:    Dict				,	snake_case_							:    str				,	snake_case_							:    List[str]=7				,	snake_case_							:    str=4_00				,	snake_case_							:    int=20_00				,	snake_case_							:    Any=1				,	snake_case_							:    Tuple=0.0				,	snake_case_							:    Dict=1_60_00				,	snake_case_							:    List[Any]=True				,	snake_case_							:    Optional[Any]=80				,	snake_case_							:    int=16				,	snake_case_							:    Any=64				,	snake_case_							:    int="hann_window"				,	snake_case_							:    int=80				,	snake_case_							:    List[Any]=76_00				,	snake_case_							:    Optional[Any]=1e-10				,	snake_case_							:    Dict=True				,	)->							Optional[Any]:
						__lowerCAmelCase	   =parent
						__lowerCAmelCase	   =batch_size
						__lowerCAmelCase	   =min_seq_length
						__lowerCAmelCase	   =max_seq_length
						__lowerCAmelCase	   =(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
						__lowerCAmelCase	   =feature_size
						__lowerCAmelCase	   =padding_value
						__lowerCAmelCase	   =sampling_rate
						__lowerCAmelCase	   =do_normalize
						__lowerCAmelCase	   =num_mel_bins
						__lowerCAmelCase	   =hop_length
						__lowerCAmelCase	   =win_length
						__lowerCAmelCase	   =win_function
						__lowerCAmelCase	   =fmin
						__lowerCAmelCase	   =fmax
						__lowerCAmelCase	   =mel_floor
						__lowerCAmelCase	   =return_attention_mask



	def 		UpperCamelCase							(						self							:    Dict)->							Optional[int]:
						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 		UpperCamelCase							(						self							:    List[str]				,	snake_case_							:    int=False				,	snake_case_							:    Any=False)->							int:



						def _flatten(snake_case_							:    int):
											return list(itertools.chain(*a_))

						if equal_length:
											__lowerCAmelCase	   =floats_list((self.batch_size, self.max_seq_length))
						else:
											# make sure that inputs increase in size
											__lowerCAmelCase	   =[
											    _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	   =[np.asarray(a_) for x in speech_inputs]

						return speech_inputs



	def 		UpperCamelCase							(						self							:    Optional[Any]				,	snake_case_							:    Optional[Any]=False				,	snake_case_							:    List[str]=False)->							Any:



						if equal_length:
											__lowerCAmelCase	   =[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	   =[
											    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	   =[np.asarray(a_) for x in speech_inputs]

						return speech_inputs






@require_torch
class 						__a (     __a	,    unittest.TestCase				):
	SCREAMING_SNAKE_CASE       =       SpeechTaFeatureExtractor



	def 		UpperCamelCase							(						self							:    Tuple)->							int:
						__lowerCAmelCase	   =SpeechTaFeatureExtractionTester(self)



	def 		UpperCamelCase							(						self							:    List[str]				,	snake_case_							:    List[str])->							Any:
						self.assertTrue(np.all(np.mean(a_				,	axis=0) < 1e-3))
						self.assertTrue(np.all(np.abs(np.var(a_				,	axis=0) - 1) < 1e-3))



	def 		UpperCamelCase							(						self							:    Dict)->							int:
						__lowerCAmelCase	   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						# create three inputs of length 800, 1000, and 1200
						__lowerCAmelCase	   =[floats_list((1, x))[0] for x in range(8_00				,	14_00				,	2_00)]
						__lowerCAmelCase	   =[np.asarray(a_) for speech_input in speech_inputs]

						# Test not batched input
						__lowerCAmelCase	   =feat_extract(speech_inputs[0]				,	return_tensors="""np""").input_values
						__lowerCAmelCase	   =feat_extract(np_speech_inputs[0]				,	return_tensors="""np""").input_values
						self.assertTrue(np.allclose(a_				,	a_				,	atol=1e-3))

						# Test batched
						__lowerCAmelCase	   =feat_extract(a_				,	return_tensors="""np""").input_values
						__lowerCAmelCase	   =feat_extract(a_				,	return_tensors="""np""").input_values
						for enc_seq_a, enc_seq_a in zip(a_				,	a_):
											self.assertTrue(np.allclose(a_				,	a_				,	atol=1e-3))



	def 		UpperCamelCase							(						self							:    Tuple)->							int:
						__lowerCAmelCase	   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						__lowerCAmelCase	   =[floats_list((1, x))[0] for x in range(8_00				,	14_00				,	2_00)]

						__lowerCAmelCase	   =["""longest""", """max_length""", """do_not_pad"""]
						__lowerCAmelCase	   =[None, 16_00, None]
						for max_length, padding in zip(a_				,	a_):
											__lowerCAmelCase	   =feat_extract(a_				,	padding=a_				,	max_length=a_				,	return_tensors="""np""")
											__lowerCAmelCase	   =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 		UpperCamelCase							(						self							:    int)->							List[Any]:
						__lowerCAmelCase	   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						__lowerCAmelCase	   =range(8_00				,	14_00				,	2_00)
						__lowerCAmelCase	   =[floats_list((1, x))[0] for x in lengths]

						__lowerCAmelCase	   =["""longest""", """max_length""", """do_not_pad"""]
						__lowerCAmelCase	   =[None, 16_00, None]

						for max_length, padding in zip(a_				,	a_):
											__lowerCAmelCase	   =feat_extract(a_				,	max_length=a_				,	padding=a_)
											__lowerCAmelCase	   =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 		UpperCamelCase							(						self							:    Dict)->							Any:
						__lowerCAmelCase	   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						__lowerCAmelCase	   =[floats_list((1, x))[0] for x in range(8_00				,	14_00				,	2_00)]
						__lowerCAmelCase	   =feat_extract(
						    a_				,	truncation=a_				,	max_length=10_00				,	padding="""max_length"""				,	return_tensors="""np""")
						__lowerCAmelCase	   =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 		UpperCamelCase							(						self							:    Tuple)->							str:
						__lowerCAmelCase	   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						__lowerCAmelCase	   =[floats_list((1, x))[0] for x in range(8_00				,	14_00				,	2_00)]
						__lowerCAmelCase	   =feat_extract(
						    a_				,	truncation=a_				,	max_length=10_00				,	padding="""longest"""				,	return_tensors="""np""")
						__lowerCAmelCase	   =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	   =[floats_list((1, x))[0] for x in range(8_00				,	14_00				,	2_00)]
						__lowerCAmelCase	   =feat_extract(
						    a_				,	truncation=a_				,	max_length=20_00				,	padding="""longest"""				,	return_tensors="""np""")
						__lowerCAmelCase	   =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 		UpperCamelCase							(						self							:    int)->							List[Any]:
						__lowerCAmelCase	   =self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						__lowerCAmelCase	   =np.random.rand(1_00).astype(np.floataa)
						__lowerCAmelCase	   =np_speech_inputs.tolist()

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



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

						# Test feature size
						__lowerCAmelCase	   =feature_extractor(audio_target=a_				,	padding=a_				,	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	   =feature_extractor(speech_inputs[0]				,	return_tensors="""np""").input_values
						__lowerCAmelCase	   =feature_extractor(np_speech_inputs[0]				,	return_tensors="""np""").input_values
						self.assertTrue(np.allclose(a_				,	a_				,	atol=1e-3))

						# Test batched
						__lowerCAmelCase	   =feature_extractor(a_				,	return_tensors="""np""").input_values
						__lowerCAmelCase	   =feature_extractor(a_				,	return_tensors="""np""").input_values
						for enc_seq_a, enc_seq_a in zip(a_				,	a_):
											self.assertTrue(np.allclose(a_				,	a_				,	atol=1e-3))

						# Test 2-D numpy arrays are batched.
						__lowerCAmelCase	   =[floats_list((1, x))[0] for x in (8_00, 8_00, 8_00)]
						__lowerCAmelCase	   =np.asarray(a_)
						__lowerCAmelCase	   =feature_extractor(a_				,	return_tensors="""np""").input_values
						__lowerCAmelCase	   =feature_extractor(a_				,	return_tensors="""np""").input_values
						for enc_seq_a, enc_seq_a in zip(a_				,	a_):
											self.assertTrue(np.allclose(a_				,	a_				,	atol=1e-3))



	def 		UpperCamelCase							(						self							:    Tuple)->							Optional[Any]:
						__lowerCAmelCase	   =self.feat_extract_tester.prepare_inputs_for_target()
						__lowerCAmelCase	   =self.feature_extraction_class(**self.feat_extract_dict)
						__lowerCAmelCase	   =feat_extract.model_input_names[0]

						__lowerCAmelCase	   =BatchFeature({input_name: speech_inputs})

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

						__lowerCAmelCase	   =self.feat_extract_tester.prepare_inputs_for_target(equal_length=a_)
						__lowerCAmelCase	   =BatchFeature({input_name: speech_inputs}				,	tensor_type="""np""")

						__lowerCAmelCase	   =processed_features[input_name]

						if len(batch_features_input.shape) < 3:
											__lowerCAmelCase	   =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 		UpperCamelCase							(						self							:    List[str])->							str:
						__lowerCAmelCase	   =self.feat_extract_tester.prepare_inputs_for_target(equal_length=a_)
						__lowerCAmelCase	   =self.feature_extraction_class(**self.feat_extract_dict)
						__lowerCAmelCase	   =feat_extract.model_input_names[0]

						__lowerCAmelCase	   =BatchFeature({input_name: speech_inputs}				,	tensor_type="""pt""")

						__lowerCAmelCase	   =processed_features[input_name]

						if len(batch_features_input.shape) < 3:
											__lowerCAmelCase	   =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 		UpperCamelCase							(						self							:    List[Any])->							Dict:
						__lowerCAmelCase	   =self.feature_extraction_class(**self.feat_extract_dict)
						__lowerCAmelCase	   =self.feat_extract_tester.prepare_inputs_for_target()
						__lowerCAmelCase	   =feat_extract.model_input_names[0]

						__lowerCAmelCase	   =BatchFeature({input_name: speech_inputs})

						__lowerCAmelCase	   =feat_extract.num_mel_bins  # hack!

						__lowerCAmelCase	   =feat_extract.pad(a_				,	padding="""longest"""				,	return_tensors="""np""")[input_name]
						__lowerCAmelCase	   =feat_extract.pad(a_				,	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 		UpperCamelCase							(						self							:    int)->							Dict:
						__lowerCAmelCase	   =self.feat_extract_dict
						__lowerCAmelCase	   =True
						__lowerCAmelCase	   =self.feature_extraction_class(**a_)
						__lowerCAmelCase	   =self.feat_extract_tester.prepare_inputs_for_target()
						__lowerCAmelCase	   =[len(a_) for x in speech_inputs]
						__lowerCAmelCase	   =feat_extract.model_input_names[0]

						__lowerCAmelCase	   =BatchFeature({input_name: speech_inputs})

						__lowerCAmelCase	   =feat_extract.num_mel_bins  # hack!

						__lowerCAmelCase	   =feat_extract.pad(a_				,	padding="""longest"""				,	return_tensors="""np""")
						self.assertIn("""attention_mask"""				,	a_)
						self.assertListEqual(list(processed.attention_mask.shape)				,	list(processed[input_name].shape[:2]))
						self.assertListEqual(processed.attention_mask.sum(-1).tolist()				,	a_)



	def 		UpperCamelCase							(						self							:    Dict)->							str:
						__lowerCAmelCase	   =self.feat_extract_dict
						__lowerCAmelCase	   =True
						__lowerCAmelCase	   =self.feature_extraction_class(**a_)
						__lowerCAmelCase	   =self.feat_extract_tester.prepare_inputs_for_target()
						__lowerCAmelCase	   =[len(a_) for x in speech_inputs]
						__lowerCAmelCase	   =feat_extract.model_input_names[0]

						__lowerCAmelCase	   =BatchFeature({input_name: speech_inputs})
						__lowerCAmelCase	   =min(a_)

						__lowerCAmelCase	   =feat_extract.num_mel_bins  # hack!

						__lowerCAmelCase	   =feat_extract.pad(
						    a_				,	padding="""max_length"""				,	max_length=a_				,	truncation=a_				,	return_tensors="""np""")
						self.assertIn("""attention_mask"""				,	a_)
						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 		UpperCamelCase							(						self							:    Dict				,	snake_case_							:    Any)->							Optional[int]:
						from datasets import load_dataset

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

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



	def 		UpperCamelCase							(						self							:    Dict)->							List[Any]:
						__lowerCAmelCase	   =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	   =self._load_datasamples(1)
						__lowerCAmelCase	   =SpeechTaFeatureExtractor()
						__lowerCAmelCase	   =feature_extractor(a_				,	return_tensors="""pt""").input_values
						self.assertEquals(input_values.shape				,	(1, 9_36_80))
						self.assertTrue(torch.allclose(input_values[0, :30]				,	a_				,	atol=1e-6))



	def 		UpperCamelCase							(						self							:    Union[str, Any])->							Optional[Any]:
						__lowerCAmelCase	   =torch.tensor(
						    [-2.6_8_7_0, -3.0_1_0_4, -3.1_3_5_6, -3.5_3_5_2, -3.0_0_4_4, -3.0_3_5_3, -3.4_7_1_9, -3.6_7_7_7,
						     -3.1_5_2_0, -2.9_4_3_5, -2.6_5_5_3, -2.8_7_9_5, -2.9_9_4_4, -2.5_9_2_1, -3.0_2_7_9, -3.0_3_8_6,
						     -3.0_8_6_4, -3.1_2_9_1, -3.2_3_5_3, -2.7_4_4_4, -2.6_8_3_1, -2.7_2_8_7, -3.1_7_6_1, -3.1_5_7_1,
						     -3.2_7_2_6, -3.0_5_8_2, -3.1_0_0_7, -3.4_5_3_3, -3.4_6_9_5, -3.0_9_9_8])
						# fmt: on

						__lowerCAmelCase	   =self._load_datasamples(1)
						__lowerCAmelCase	   =SpeechTaFeatureExtractor()
						__lowerCAmelCase	   =feature_extractor(audio_target=a_				,	return_tensors="""pt""").input_values
						self.assertEquals(input_values.shape				,	(1, 3_66, 80))
						self.assertTrue(torch.allclose(input_values[0, 0, :30]				,	a_				,	atol=1e-4))









def 					__lowerCAmelCase		(  __lowerCamelCase	:    list				,   __lowerCamelCase	:    int				,   __lowerCamelCase	:    int = 0				,   __lowerCamelCase	:    int = 0	)  ->						int:
					__lowerCAmelCase	   =right or len(__lowerCamelCase	) - 1
					if left > right:
										return -1
					elif list_data[left] == key:
										return left
					elif list_data[right] == key:
										return right
					else:
										return search(__lowerCamelCase				,   __lowerCamelCase				,   left + 1				,   right - 1	)


if __name__ == "__main__":
				import doctest

				doctest.testmod()




