"""simple docstring"""




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


_a				:		Optional[Any]	   =       random.Random()





def 							SCREAMING_SNAKE_CASE					(      _lowerCamelCase						:	int      ,_lowerCamelCase						:	Tuple=1.0      ,_lowerCamelCase						:	List[str]=None      ,_lowerCamelCase						:	Union[str, Any]=None     )	->				List[str]:
		if rng is None:
				_lowerCAmelCase						:	Dict        =					global_rng

		_lowerCAmelCase						:	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 						__A							(			unittest.TestCase		):






					def __init__(		self    ,					a__    ,					a__=7    ,					a__=400    ,					a__=2000    ,					a__=1    ,					a__=0.0    ,					a__=16000    ,					a__=True    ,					a__=80    ,					a__=16    ,					a__=64    ,					a__="hann_window"    ,					a__=80    ,					a__=7600    ,					a__=1e-10    ,					a__=True    ,					):
							_lowerCAmelCase						:	str        =					parent
							_lowerCAmelCase						:	Any        =					batch_size
							_lowerCAmelCase						:	Optional[int]        =					min_seq_length
							_lowerCAmelCase						:	Union[str, Any]        =					max_seq_length
							_lowerCAmelCase						:	int        =					(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
							_lowerCAmelCase						:	str        =					feature_size
							_lowerCAmelCase						:	Tuple        =					padding_value
							_lowerCAmelCase						:	Optional[Any]        =					sampling_rate
							_lowerCAmelCase						:	int        =					do_normalize
							_lowerCAmelCase						:	Optional[Any]        =					num_mel_bins
							_lowerCAmelCase						:	Any        =					hop_length
							_lowerCAmelCase						:	List[str]        =					win_length
							_lowerCAmelCase						:	int        =					win_function
							_lowerCAmelCase						:	Union[str, Any]        =					fmin
							_lowerCAmelCase						:	int        =					fmax
							_lowerCAmelCase						:	Optional[int]        =					mel_floor
							_lowerCAmelCase						:	Any        =					return_attention_mask






					def    __A  (		self  ):
							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    __A  (		self    ,					a__=False    ,					a__=False  ):
							def _flatten(a__  ):
									return list(itertools.chain(*a__  )  )

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

							return speech_inputs






					def    __A  (		self    ,					a__=False    ,					a__=False  ):
							if equal_length:
									_lowerCAmelCase						:	str        =					[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[int]        =					[
									    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(a__  ) for x in speech_inputs]

							return speech_inputs







@require_torch
class 						__A							(			SCREAMING_SNAKE_CASE_   ,     unittest.TestCase		):
					_UpperCamelCase							:      Optional[Any]		 =		SpeechTaFeatureExtractor






					def    __A  (		self  ):
							_lowerCAmelCase						:	Any        =					SpeechTaFeatureExtractionTester(self  )






					def    __A  (		self    ,					a__  ):
							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    __A  (		self  ):
							# Tests that all call wrap to encode_plus and batch_encode_plus
							_lowerCAmelCase						:	str        =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()  )
							# create three inputs of length 800, 1000, and 1200
							_lowerCAmelCase						:	str        =					[floats_list((1, x)  )[0] for x in range(800    ,					1400    ,					200  )]
							_lowerCAmelCase						:	Optional[Any]        =					[np.asarray(a__  ) for speech_input in speech_inputs]

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

							# Test batched
							_lowerCAmelCase						:	Union[str, Any]        =					feat_extract(a__    ,					return_tensors="""np"""  ).input_values
							_lowerCAmelCase						:	Optional[Any]        =					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    __A  (		self  ):
							_lowerCAmelCase						:	Tuple        =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()  )
							_lowerCAmelCase						:	Any        =					[floats_list((1, x)  )[0] for x in range(800    ,					1400    ,					200  )]

							_lowerCAmelCase						:	Optional[Any]        =					["""longest""", """max_length""", """do_not_pad"""]
							_lowerCAmelCase						:	Any        =					[None, 1600, None]
							for max_length, padding in zip(a__    ,					a__  ):
									_lowerCAmelCase						:	List[str]        =					feat_extract(a__    ,					padding=a__    ,					max_length=a__    ,					return_tensors="""np"""  )
									_lowerCAmelCase						:	Any        =					processed.input_values

									self._check_zero_mean_unit_variance(input_values[0][:800]  )
									self.assertTrue(input_values[0][800:].sum() < 1e-6  )
									self._check_zero_mean_unit_variance(input_values[1][:1000]  )
									self.assertTrue(input_values[0][1000:].sum() < 1e-6  )
									self._check_zero_mean_unit_variance(input_values[2][:1200]  )






					def    __A  (		self  ):
							_lowerCAmelCase						:	List[Any]        =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()  )
							_lowerCAmelCase						:	Optional[int]        =					range(800    ,					1400    ,					200  )
							_lowerCAmelCase						:	Any        =					[floats_list((1, x)  )[0] for x in lengths]

							_lowerCAmelCase						:	Dict        =					["""longest""", """max_length""", """do_not_pad"""]
							_lowerCAmelCase						:	List[str]        =					[None, 1600, None]

							for max_length, padding in zip(a__    ,					a__  ):
									_lowerCAmelCase						:	List[Any]        =					feat_extract(a__    ,					max_length=a__    ,					padding=a__  )
									_lowerCAmelCase						:	List[Any]        =					processed.input_values

									self._check_zero_mean_unit_variance(input_values[0][:800]  )
									self._check_zero_mean_unit_variance(input_values[1][:1000]  )
									self._check_zero_mean_unit_variance(input_values[2][:1200]  )






					def    __A  (		self  ):
							_lowerCAmelCase						:	List[Any]        =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()  )
							_lowerCAmelCase						:	Optional[Any]        =					[floats_list((1, x)  )[0] for x in range(800    ,					1400    ,					200  )]
							_lowerCAmelCase						:	Union[str, Any]        =					feat_extract(
							    a__    ,					truncation=a__    ,					max_length=1000    ,					padding="""max_length"""    ,					return_tensors="""np"""  )
							_lowerCAmelCase						:	Any        =					processed.input_values

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






					def    __A  (		self  ):
							_lowerCAmelCase						:	List[str]        =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()  )
							_lowerCAmelCase						:	Any        =					[floats_list((1, x)  )[0] for x in range(800    ,					1400    ,					200  )]
							_lowerCAmelCase						:	Tuple        =					feat_extract(
							    a__    ,					truncation=a__    ,					max_length=1000    ,					padding="""longest"""    ,					return_tensors="""np"""  )
							_lowerCAmelCase						:	Optional[Any]        =					processed.input_values

							self._check_zero_mean_unit_variance(input_values[0, :800]  )
							self._check_zero_mean_unit_variance(input_values[1, :1000]  )
							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, 1000)  )

							_lowerCAmelCase						:	List[str]        =					[floats_list((1, x)  )[0] for x in range(800    ,					1400    ,					200  )]
							_lowerCAmelCase						:	Optional[int]        =					feat_extract(
							    a__    ,					truncation=a__    ,					max_length=2000    ,					padding="""longest"""    ,					return_tensors="""np"""  )
							_lowerCAmelCase						:	List[Any]        =					processed.input_values

							self._check_zero_mean_unit_variance(input_values[0, :800]  )
							self._check_zero_mean_unit_variance(input_values[1, :1000]  )
							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, 1200)  )






					def    __A  (		self  ):
							_lowerCAmelCase						:	Any        =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()  )
							_lowerCAmelCase						:	int        =					np.random.rand(100  ).astype(np.floataa  )
							_lowerCAmelCase						:	List[Any]        =					np_speech_inputs.tolist()

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






					def    __A  (		self  ):
							# Tests that all call wrap to encode_plus and batch_encode_plus
							_lowerCAmelCase						:	Any        =					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(800    ,					1400    ,					200  )]
							_lowerCAmelCase						:	Optional[Any]        =					[np.asarray(a__  ) for speech_input in speech_inputs]

							# Test feature size
							_lowerCAmelCase						:	Optional[Any]        =					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						:	Tuple        =					feature_extractor(speech_inputs[0]    ,					return_tensors="""np"""  ).input_values
							_lowerCAmelCase						:	int        =					feature_extractor(np_speech_inputs[0]    ,					return_tensors="""np"""  ).input_values
							self.assertTrue(np.allclose(a__    ,					a__    ,					atol=1e-3  )  )

							# Test batched
							_lowerCAmelCase						:	Union[str, Any]        =					feature_extractor(a__    ,					return_tensors="""np"""  ).input_values
							_lowerCAmelCase						:	Any        =					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						:	Any        =					[floats_list((1, x)  )[0] for x in (800, 800, 800)]
							_lowerCAmelCase						:	List[str]        =					np.asarray(a__  )
							_lowerCAmelCase						:	Optional[Any]        =					feature_extractor(a__    ,					return_tensors="""np"""  ).input_values
							_lowerCAmelCase						:	Tuple        =					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    __A  (		self  ):
							_lowerCAmelCase						:	Optional[Any]        =					self.feat_extract_tester.prepare_inputs_for_target()
							_lowerCAmelCase						:	Tuple        =					self.feature_extraction_class(**self.feat_extract_dict  )
							_lowerCAmelCase						:	List[Any]        =					feat_extract.model_input_names[0]

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

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

							_lowerCAmelCase						:	str        =					self.feat_extract_tester.prepare_inputs_for_target(equal_length=a__  )
							_lowerCAmelCase						:	Tuple        =					BatchFeature({input_name: speech_inputs}    ,					tensor_type="""np"""  )

							_lowerCAmelCase						:	Union[str, Any]        =					processed_features[input_name]

							if len(batch_features_input.shape  ) < 3:
									_lowerCAmelCase						:	Optional[Any]        =					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    __A  (		self  ):
							_lowerCAmelCase						:	Tuple        =					self.feat_extract_tester.prepare_inputs_for_target(equal_length=a__  )
							_lowerCAmelCase						:	Any        =					self.feature_extraction_class(**self.feat_extract_dict  )
							_lowerCAmelCase						:	Union[str, Any]        =					feat_extract.model_input_names[0]

							_lowerCAmelCase						:	List[Any]        =					BatchFeature({input_name: speech_inputs}    ,					tensor_type="""pt"""  )

							_lowerCAmelCase						:	Optional[Any]        =					processed_features[input_name]

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

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

							_lowerCAmelCase						:	Tuple        =					feat_extract.num_mel_bins  # hack!

							_lowerCAmelCase						:	Dict        =					feat_extract.pad(a__    ,					padding="""longest"""    ,					return_tensors="""np"""  )[input_name]
							_lowerCAmelCase						:	List[str]        =					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    __A  (		self  ):
							_lowerCAmelCase						:	str        =					self.feat_extract_dict
							_lowerCAmelCase						:	Tuple        =					True
							_lowerCAmelCase						:	Dict        =					self.feature_extraction_class(**a__  )
							_lowerCAmelCase						:	Tuple        =					self.feat_extract_tester.prepare_inputs_for_target()
							_lowerCAmelCase						:	Any        =					[len(a__  ) for x in speech_inputs]
							_lowerCAmelCase						:	Optional[int]        =					feat_extract.model_input_names[0]

							_lowerCAmelCase						:	str        =					BatchFeature({input_name: speech_inputs}  )

							_lowerCAmelCase						:	int        =					feat_extract.num_mel_bins  # hack!

							_lowerCAmelCase						:	Any        =					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    __A  (		self  ):
							_lowerCAmelCase						:	List[str]        =					self.feat_extract_dict
							_lowerCAmelCase						:	Dict        =					True
							_lowerCAmelCase						:	Union[str, Any]        =					self.feature_extraction_class(**a__  )
							_lowerCAmelCase						:	Tuple        =					self.feat_extract_tester.prepare_inputs_for_target()
							_lowerCAmelCase						:	str        =					[len(a__  ) for x in speech_inputs]
							_lowerCAmelCase						:	Tuple        =					feat_extract.model_input_names[0]

							_lowerCAmelCase						:	Dict        =					BatchFeature({input_name: speech_inputs}  )
							_lowerCAmelCase						:	int        =					min(a__  )

							_lowerCAmelCase						:	Dict        =					feat_extract.num_mel_bins  # hack!

							_lowerCAmelCase						:	Optional[int]        =					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    __A  (		self    ,					a__  ):
							from datasets import load_dataset

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

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






					def    __A  (		self  ):
							# fmt: off
							_lowerCAmelCase						:	Dict        =					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						:	Any        =					self._load_datasamples(1  )
							_lowerCAmelCase						:	Optional[int]        =					SpeechTaFeatureExtractor()
							_lowerCAmelCase						:	Union[str, Any]        =					feature_extractor(a__    ,					return_tensors="""pt"""  ).input_values
							self.assertEquals(input_values.shape    ,					(1, 93680)  )
							self.assertTrue(torch.allclose(input_values[0, :30]    ,					a__    ,					atol=1e-6  )  )






					def    __A  (		self  ):
							# fmt: off
							_lowerCAmelCase						:	Optional[Any]        =					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						:	str        =					self._load_datasamples(1  )
							_lowerCAmelCase						:	Optional[int]        =					SpeechTaFeatureExtractor()
							_lowerCAmelCase						:	Union[str, Any]        =					feature_extractor(audio_target=a__    ,					return_tensors="""pt"""  ).input_values
							self.assertEquals(input_values.shape    ,					(1, 366, 80)  )
							self.assertTrue(torch.allclose(input_values[0, 0, :30]    ,					a__    ,					atol=1e-4  )  )





"""simple docstring"""




from __future__ import annotations





def 							SCREAMING_SNAKE_CASE					(      _lowerCamelCase						:	list     )	->				float:
  if not nums:
    raise ValueError("""List is empty"""     )
  return sum(_lowerCamelCase     ) / len(_lowerCamelCase     )


if __name__ == "__main__":
     import doctest

     doctest.testmod()




