

import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
					from transformers import SpeechaTextFeatureExtractor

_UpperCAmelCase	:     List[str]		       = random.Random()





def       __lowerCamelCase			(				UpperCamelCase__     ,							UpperCamelCase__=1.0     ,							UpperCamelCase__=None     ,							UpperCamelCase__=None   ):







							'''simple docstring'''






							if rng is None:
														snake_case_           =					global_rng

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

							return values







@require_torch
@require_torchaudio
class 				lowercase       ( unittest.TestCase    ):




				def __init__(      self   ,     snake_case   ,     snake_case=7   ,     snake_case=400   ,     snake_case=2000   ,     snake_case=24   ,     snake_case=24   ,     snake_case=0.0   ,     snake_case=1_6000   ,     snake_case=True   ,     snake_case=True   ,     ):
											snake_case_           =					parent
											snake_case_           =					batch_size
											snake_case_           =					min_seq_length
											snake_case_           =					max_seq_length
											snake_case_           =					(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
											snake_case_           =					feature_size
											snake_case_           =					num_mel_bins
											snake_case_           =					padding_value
											snake_case_           =					sampling_rate
											snake_case_           =					return_attention_mask
											snake_case_           =					do_normalize




				def 					a							(      self ):
											return {
											    "feature_size": self.feature_size,
											    "num_mel_bins": self.num_mel_bins,
											    "padding_value": self.padding_value,
											    "sampling_rate": self.sampling_rate,
											    "return_attention_mask": self.return_attention_mask,
											    "do_normalize": self.do_normalize,
											}




				def 					a							(      self   ,     snake_case=False   ,     snake_case=False ):
											def _flatten(snake_case ):
																		return list(itertools.chain(*snake_case ) )

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







@require_torch
@require_torchaudio
class 				lowercase       ( lowercase_			,						unittest.TestCase    ):
				__SCREAMING_SNAKE_CASE      :				Optional[Any]     =    SpeechaTextFeatureExtractor if is_speech_available() else None




				def 					a							(      self ):
											snake_case_           =					SpeechaTextFeatureExtractionTester(self )




				def 					a							(      self   ,     snake_case ):
											self.assertTrue(np.all(np.mean(snake_case   ,     axis=0 ) < 1e-3 ) )
											self.assertTrue(np.all(np.abs(np.var(snake_case   ,     axis=0 ) - 1 ) < 1e-3 ) )




				def 					a							(      self ):
											# Tests that all call wrap to encode_plus and batch_encode_plus
											snake_case_           =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
											# create three inputs of length 800, 1000, and 1200
											snake_case_           =					[floats_list((1, x) )[0] for x in range(800   ,     1400   ,     200 )]
											snake_case_           =					[np.asarray(snake_case ) for speech_input in speech_inputs]

											# Test feature size
											snake_case_           =					feature_extractor(snake_case   ,     padding=snake_case   ,     return_tensors='np' ).input_features
											self.assertTrue(input_features.ndim == 3 )
											self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size )

											# Test not batched input
											snake_case_           =					feature_extractor(speech_inputs[0]   ,     return_tensors='np' ).input_features
											snake_case_           =					feature_extractor(np_speech_inputs[0]   ,     return_tensors='np' ).input_features
											self.assertTrue(np.allclose(snake_case   ,     snake_case   ,     atol=1e-3 ) )

											# Test batched
											snake_case_           =					feature_extractor(snake_case   ,     return_tensors='np' ).input_features
											snake_case_           =					feature_extractor(snake_case   ,     return_tensors='np' ).input_features
											for enc_seq_a, enc_seq_a in zip(snake_case   ,     snake_case ):
																		self.assertTrue(np.allclose(snake_case   ,     snake_case   ,     atol=1e-3 ) )

											# Test 2-D numpy arrays are batched.
											snake_case_           =					[floats_list((1, x) )[0] for x in (800, 800, 800)]
											snake_case_           =					np.asarray(snake_case )
											snake_case_           =					feature_extractor(snake_case   ,     return_tensors='np' ).input_features
											snake_case_           =					feature_extractor(snake_case   ,     return_tensors='np' ).input_features
											for enc_seq_a, enc_seq_a in zip(snake_case   ,     snake_case ):
																		self.assertTrue(np.allclose(snake_case   ,     snake_case   ,     atol=1e-3 ) )




				def 					a							(      self ):
											snake_case_           =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
											snake_case_           =					[floats_list((1, x) )[0] for x in range(800   ,     1400   ,     200 )]

											snake_case_           =					['longest', 'max_length', 'do_not_pad']
											snake_case_           =					[None, 16, None]
											for max_length, padding in zip(snake_case   ,     snake_case ):
																		snake_case_           =					feature_extractor(
																		    snake_case   ,     padding=snake_case   ,     max_length=snake_case   ,     return_attention_mask=snake_case )
																		snake_case_           =					inputs.input_features
																		snake_case_           =					inputs.attention_mask
																		snake_case_           =					[np.sum(snake_case ) for x in attention_mask]

																		self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]] )
																		self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]] )
																		self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]] )




				def 					a							(      self ):
											snake_case_           =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
											snake_case_           =					[floats_list((1, x) )[0] for x in range(800   ,     1400   ,     200 )]

											snake_case_           =					['longest', 'max_length', 'do_not_pad']
											snake_case_           =					[None, 16, None]
											for max_length, padding in zip(snake_case   ,     snake_case ):
																		snake_case_           =					feature_extractor(
																		    snake_case   ,     max_length=snake_case   ,     padding=snake_case   ,     return_tensors='np'   ,     return_attention_mask=snake_case )
																		snake_case_           =					inputs.input_features
																		snake_case_           =					inputs.attention_mask
																		snake_case_           =					[np.sum(snake_case ) for x in attention_mask]

																		self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]] )
																		self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6 )
																		self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]] )
																		self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6 )
																		self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]] )




				def 					a							(      self ):
											snake_case_           =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
											snake_case_           =					[floats_list((1, x) )[0] for x in range(800   ,     1400   ,     200 )]
											snake_case_           =					feature_extractor(
											    snake_case   ,     padding='max_length'   ,     max_length=4   ,     truncation=snake_case   ,     return_tensors='np'   ,     return_attention_mask=snake_case   ,     )
											snake_case_           =					inputs.input_features
											snake_case_           =					inputs.attention_mask
											snake_case_           =					np.sum(attention_mask == 1   ,     axis=1 )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] )
											self._check_zero_mean_unit_variance(input_features[1] )
											self._check_zero_mean_unit_variance(input_features[2] )




				def 					a							(      self ):
											snake_case_           =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
											snake_case_           =					[floats_list((1, x) )[0] for x in range(800   ,     1400   ,     200 )]
											snake_case_           =					feature_extractor(
											    snake_case   ,     padding='longest'   ,     max_length=4   ,     truncation=snake_case   ,     return_tensors='np'   ,     return_attention_mask=snake_case   ,     )
											snake_case_           =					inputs.input_features
											snake_case_           =					inputs.attention_mask
											snake_case_           =					np.sum(attention_mask == 1   ,     axis=1 )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] )
											self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]] )
											self._check_zero_mean_unit_variance(input_features[2] )

											# make sure that if max_length < longest -> then pad to max_length
											self.assertEqual(input_features.shape   ,     (3, 4, 24) )

											snake_case_           =					[floats_list((1, x) )[0] for x in range(800   ,     1400   ,     200 )]
											snake_case_           =					feature_extractor(
											    snake_case   ,     padding='longest'   ,     max_length=16   ,     truncation=snake_case   ,     return_tensors='np'   ,     return_attention_mask=snake_case   ,     )
											snake_case_           =					inputs.input_features
											snake_case_           =					inputs.attention_mask
											snake_case_           =					np.sum(attention_mask == 1   ,     axis=1 )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]] )
											self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]] )
											self._check_zero_mean_unit_variance(input_features[2] )

											# make sure that if max_length < longest -> then pad to max_length
											self.assertEqual(input_features.shape   ,     (3, 6, 24) )




				def 					a							(      self ):
											import torch

											snake_case_           =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
											snake_case_           =					np.random.rand(100   ,     32 ).astype(np.floataa )
											snake_case_           =					np_speech_inputs.tolist()

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




				def 					a							(      self   ,     snake_case ):
											from datasets import load_dataset

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

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




				def 					a							(      self ):
											# fmt: off
											snake_case_           =					np.array([
											    -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
											    -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
											    -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
											] )
											# fmt: on

											snake_case_           =					self._load_datasamples(1 )
											snake_case_           =					self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict() )
											snake_case_           =					feature_extractor(snake_case   ,     return_tensors='pt' ).input_features
											self.assertEquals(input_features.shape   ,     (1, 584, 24) )
											self.assertTrue(np.allclose(input_features[0, 0, :30]   ,     snake_case   ,     atol=1e-4 ) )







def       __lowerCamelCase			(				UpperCamelCase__   ):







							'''simple docstring'''






							if not nums:  # Makes sure that the list is not empty
														raise ValueError('List is empty'   )

							snake_case_           =					sum(UpperCamelCase__   ) / len(UpperCamelCase__   )  # Calculate the average
							return sum(abs(x - average   ) for x in nums   ) / len(UpperCamelCase__   )


if __name__ == "__main__":
					import doctest

					doctest.testmod()




