


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       	=  random.Random()


def       UpperCAmelCase_					(   UpperCAmelCase__    ,				UpperCAmelCase__=1.0    ,				UpperCAmelCase__=None    ,				UpperCAmelCase__=None	):
					if rng is None:
										lowercase_					=      global_rng

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

					def __init__(  self							: Dict				,       UpperCamelCase__							: Dict				,       UpperCamelCase__							: int=7				,       UpperCamelCase__							: Optional[int]=400				,       UpperCamelCase__							: Optional[Any]=2_000				,       UpperCamelCase__							: List[str]=1				,       UpperCamelCase__							: Dict=0.0				,       UpperCamelCase__							: List[Any]=16_000				,       UpperCamelCase__							: List[str]=True				,       UpperCamelCase__							: Tuple=80				,       UpperCamelCase__							: List[str]=16				,       UpperCamelCase__							: str=64				,       UpperCamelCase__							: Optional[int]="hann_window"				,       UpperCamelCase__							: List[Any]=80				,       UpperCamelCase__							: Union[str, Any]=7_600				,       UpperCamelCase__							: Tuple=1e-10				,       UpperCamelCase__							: Tuple=True				,       ):






										'''simple docstring'''






										lowercase_					=      parent
										lowercase_					=      batch_size
										lowercase_					=      min_seq_length
										lowercase_					=      max_seq_length
										lowercase_					=      (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
										lowercase_					=      feature_size
										lowercase_					=      padding_value
										lowercase_					=      sampling_rate
										lowercase_					=      do_normalize
										lowercase_					=      num_mel_bins
										lowercase_					=      hop_length
										lowercase_					=      win_length
										lowercase_					=      win_function
										lowercase_					=      fmin
										lowercase_					=      fmax
										lowercase_					=      mel_floor
										lowercase_					=      return_attention_mask

					def 	UpperCAmelCase__							(  self							: int							):






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






										'''simple docstring'''






										def _flatten(UpperCamelCase__							: Optional[int]							):
															return list(itertools.chain(*__UpperCAmelCase							)							)

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

										return speech_inputs







					def 	UpperCAmelCase__							(  self							: Tuple				,       UpperCamelCase__							: Union[str, Any]=False				,       UpperCamelCase__							: str=False							):






										'''simple docstring'''






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

										return speech_inputs







@require_torch
class 							UpperCamelCase__ (						__UpperCamelCase				,					unittest.TestCase ):
					__SCREAMING_SNAKE_CASE							:	Any            = SpeechTaFeatureExtractor

					def 	UpperCAmelCase__							(  self							: Optional[Any]							):






										'''simple docstring'''






										lowercase_					=      SpeechTaFeatureExtractionTester(self							)

					def 	UpperCAmelCase__							(  self							: Any				,       UpperCamelCase__							: List[Any]							):






										'''simple docstring'''






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

					def 	UpperCAmelCase__							(  self							: Tuple							):






										'''simple docstring'''






										lowercase_					=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
										# create three inputs of length 800, 1000, and 1200
										lowercase_					=      [floats_list((1, x)							)[0] for x in range(800				,       1_400				,       200							)]
										lowercase_					=      [np.asarray(__UpperCAmelCase							) for speech_input in speech_inputs]

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

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

					def 	UpperCAmelCase__							(  self							: List[str]							):






										'''simple docstring'''






										lowercase_					=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
										lowercase_					=      [floats_list((1, x)							)[0] for x in range(800				,       1_400				,       200							)]

										lowercase_					=      ["longest", "max_length", "do_not_pad"]
										lowercase_					=      [None, 1_600, None]
										for max_length, padding in zip(__UpperCAmelCase				,       __UpperCAmelCase							):
															lowercase_					=      feat_extract(__UpperCAmelCase				,       padding=__UpperCAmelCase				,       max_length=__UpperCAmelCase				,       return_tensors="""np"""							)
															lowercase_					=      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][:1_000]							)
															self.assertTrue(input_values[0][1_000:].sum() < 1e-6							)
															self._check_zero_mean_unit_variance(input_values[2][:1_200]							)

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






										'''simple docstring'''






										lowercase_					=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
										lowercase_					=      range(800				,       1_400				,       200							)
										lowercase_					=      [floats_list((1, x)							)[0] for x in lengths]

										lowercase_					=      ["longest", "max_length", "do_not_pad"]
										lowercase_					=      [None, 1_600, None]

										for max_length, padding in zip(__UpperCAmelCase				,       __UpperCAmelCase							):
															lowercase_					=      feat_extract(__UpperCAmelCase				,       max_length=__UpperCAmelCase				,       padding=__UpperCAmelCase							)
															lowercase_					=      processed.input_values

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

					def 	UpperCAmelCase__							(  self							: Any							):






										'''simple docstring'''






										lowercase_					=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
										lowercase_					=      [floats_list((1, x)							)[0] for x in range(800				,       1_400				,       200							)]
										lowercase_					=      feat_extract(
										    __UpperCAmelCase				,       truncation=__UpperCAmelCase				,       max_length=1_000				,       padding="""max_length"""				,       return_tensors="""np"""							)
										lowercase_					=      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 	UpperCAmelCase__							(  self							: List[Any]							):






										'''simple docstring'''






										lowercase_					=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
										lowercase_					=      [floats_list((1, x)							)[0] for x in range(800				,       1_400				,       200							)]
										lowercase_					=      feat_extract(
										    __UpperCAmelCase				,       truncation=__UpperCAmelCase				,       max_length=1_000				,       padding="""longest"""				,       return_tensors="""np"""							)
										lowercase_					=      processed.input_values

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

										lowercase_					=      [floats_list((1, x)							)[0] for x in range(800				,       1_400				,       200							)]
										lowercase_					=      feat_extract(
										    __UpperCAmelCase				,       truncation=__UpperCAmelCase				,       max_length=2_000				,       padding="""longest"""				,       return_tensors="""np"""							)
										lowercase_					=      processed.input_values

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

					def 	UpperCAmelCase__							(  self							: Tuple							):






										'''simple docstring'''






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

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

					def 	UpperCAmelCase__							(  self							: Dict							):






										'''simple docstring'''






										lowercase_					=      self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()							)
										# create three inputs of length 800, 1000, and 1200
										lowercase_					=      [floats_list((1, x)							)[0] for x in range(800				,       1_400				,       200							)]
										lowercase_					=      [np.asarray(__UpperCAmelCase							) for speech_input in speech_inputs]

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

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

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

					def 	UpperCAmelCase__							(  self							: Any							):






										'''simple docstring'''






										lowercase_					=      self.feat_extract_tester.prepare_inputs_for_target()
										lowercase_					=      self.feature_extraction_class(**self.feat_extract_dict							)
										lowercase_					=      feat_extract.model_input_names[0]

										lowercase_					=      BatchFeature({input_name: speech_inputs}							)

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

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

										lowercase_					=      processed_features[input_name]

										if len(batch_features_input.shape							) < 3:
															lowercase_					=      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							: Union[str, Any]							):






										'''simple docstring'''






										lowercase_					=      self.feat_extract_tester.prepare_inputs_for_target(equal_length=__UpperCAmelCase							)
										lowercase_					=      self.feature_extraction_class(**self.feat_extract_dict							)
										lowercase_					=      feat_extract.model_input_names[0]

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

										lowercase_					=      processed_features[input_name]

										if len(batch_features_input.shape							) < 3:
															lowercase_					=      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							: Optional[int]							):






										'''simple docstring'''






										lowercase_					=      self.feature_extraction_class(**self.feat_extract_dict							)
										lowercase_					=      self.feat_extract_tester.prepare_inputs_for_target()
										lowercase_					=      feat_extract.model_input_names[0]

										lowercase_					=      BatchFeature({input_name: speech_inputs}							)

										lowercase_					=      feat_extract.num_mel_bins  # hack!

										lowercase_					=      feat_extract.pad(__UpperCAmelCase				,       padding="""longest"""				,       return_tensors="""np"""							)[input_name]
										lowercase_					=      feat_extract.pad(__UpperCAmelCase				,       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							: Any							):






										'''simple docstring'''






										lowercase_					=      self.feat_extract_dict
										lowercase_					=      True
										lowercase_					=      self.feature_extraction_class(**__UpperCAmelCase							)
										lowercase_					=      self.feat_extract_tester.prepare_inputs_for_target()
										lowercase_					=      [len(__UpperCAmelCase							) for x in speech_inputs]
										lowercase_					=      feat_extract.model_input_names[0]

										lowercase_					=      BatchFeature({input_name: speech_inputs}							)

										lowercase_					=      feat_extract.num_mel_bins  # hack!

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

					def 	UpperCAmelCase__							(  self							: List[Any]							):






										'''simple docstring'''






										lowercase_					=      self.feat_extract_dict
										lowercase_					=      True
										lowercase_					=      self.feature_extraction_class(**__UpperCAmelCase							)
										lowercase_					=      self.feat_extract_tester.prepare_inputs_for_target()
										lowercase_					=      [len(__UpperCAmelCase							) for x in speech_inputs]
										lowercase_					=      feat_extract.model_input_names[0]

										lowercase_					=      BatchFeature({input_name: speech_inputs}							)
										lowercase_					=      min(__UpperCAmelCase							)

										lowercase_					=      feat_extract.num_mel_bins  # hack!

										lowercase_					=      feat_extract.pad(
										    __UpperCAmelCase				,       padding="""max_length"""				,       max_length=__UpperCAmelCase				,       truncation=__UpperCAmelCase				,       return_tensors="""np"""							)
										self.assertIn("""attention_mask"""				,       __UpperCAmelCase							)
										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							: List[Any]				,       UpperCamelCase__							: List[str]							):






										'''simple docstring'''






										from datasets import load_dataset

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

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

					def 	UpperCAmelCase__							(  self							: Optional[Any]							):






										'''simple docstring'''






										lowercase_					=      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

										lowercase_					=      self._load_datasamples(1							)
										lowercase_					=      SpeechTaFeatureExtractor()
										lowercase_					=      feature_extractor(__UpperCAmelCase				,       return_tensors="""pt"""							).input_values
										self.assertEquals(input_values.shape				,       (1, 93_680)							)
										self.assertTrue(torch.allclose(input_values[0, :30]				,       __UpperCAmelCase				,       atol=1e-6							)							)







					def 	UpperCAmelCase__							(  self							: int							):






										'''simple docstring'''






										lowercase_					=      torch.tensor(
										    [-2.6_870, -3.0_104, -3.1_356, -3.5_352, -3.0_044, -3.0_353, -3.4_719, -3.6_777,
										     -3.1_520, -2.9_435, -2.6_553, -2.8_795, -2.9_944, -2.5_921, -3.0_279, -3.0_386,
										     -3.0_864, -3.1_291, -3.2_353, -2.7_444, -2.6_831, -2.7_287, -3.1_761, -3.1_571,
										     -3.2_726, -3.0_582, -3.1_007, -3.4_533, -3.4_695, -3.0_998]							)
										# fmt: on

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










UpperCAmelCase__      			=						'''Input must be a string of 8 numbers plus letter'''
UpperCAmelCase__      			=						'''TRWAGMYFPDXBNJZSQVHLCKE'''







def     a_   (__A      )				->						bool:



					"""simple docstring"""

					if not isinstance(__A				,       __A      ):
										__a					:						Any      =					f'Expected string as input, found {type(__A      ).__name__}'
										raise TypeError(__A      )

					__a					:						int      =					spanish_id.replace("-"				,       ""      ).upper()
					if len(__A      ) != 9:
										raise ValueError(__A      )

					try:
										__a					:						Tuple      =					int(spanish_id_clean[0:8]      )
										__a					:						Optional[int]      =					spanish_id_clean[8]
					except ValueError as ex:
										raise ValueError(__A      ) from ex

					if letter.isdigit():
										raise ValueError(__A      )

					return letter == LOOKUP_LETTERS[number % 23]


if __name__ == "__main__":
			import doctest

			doctest.testmod()





