





import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
		from transformers import WhisperFeatureExtractor

if is_torch_available():
		import torch

lowercase_		:				Union[str, Any]				=						random.Random()

def       A__(		__lowerCAmelCase	,			__lowerCAmelCase=1.0	,			__lowerCAmelCase=None	,			__lowerCAmelCase=None ):
				if rng is None:
								_snake_case :			str  						=   global_rng

				_snake_case :			Tuple  						=   []
				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     ):



						"""simple docstring"""

						def __init__(    self			:		Optional[Any] ,				lowerCamelCase_			:		Optional[int] ,				lowerCamelCase_			:		Any=7 ,				lowerCamelCase_			:		List[Any]=4_00 ,				lowerCamelCase_			:		List[str]=20_00 ,				lowerCamelCase_			:		Union[str, Any]=10 ,				lowerCamelCase_			:		Dict=1_60 ,				lowerCamelCase_			:		int=8 ,				lowerCamelCase_			:		Dict=0.0 ,				lowerCamelCase_			:		List[str]=40_00 ,				lowerCamelCase_			:		Optional[Any]=False ,				lowerCamelCase_			:		Any=True ,				):





										'''simple docstring'''







										_snake_case :			Dict  						=   parent
										_snake_case :			Optional[Any]  						=   batch_size
										_snake_case :			int  						=   min_seq_length
										_snake_case :			Tuple  						=   max_seq_length
										_snake_case :			Dict  						=   (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
										_snake_case :			List[str]  						=   padding_value
										_snake_case :			Optional[Any]  						=   sampling_rate
										_snake_case :			Optional[int]  						=   return_attention_mask
										_snake_case :			Optional[int]  						=   do_normalize
										_snake_case :			List[Any]  						=   feature_size
										_snake_case :			int  						=   chunk_length
										_snake_case :			Union[str, Any]  						=   hop_length







						def 		__UpperCAmelCase       (    self			:		List[Any]					):





										'''simple docstring'''







										return {
										    "feature_size": self.feature_size,
										    "hop_length": self.hop_length,
										    "chunk_length": self.chunk_length,
										    "padding_value": self.padding_value,
										    "sampling_rate": self.sampling_rate,
										    "return_attention_mask": self.return_attention_mask,
										    "do_normalize": self.do_normalize,
										}







						def 		__UpperCAmelCase       (    self			:		Dict ,				lowerCamelCase_			:		Optional[Any]=False ,				lowerCamelCase_			:		str=False					):





										'''simple docstring'''







										def _flatten(lowerCamelCase_			:		Dict					):
														return list(itertools.chain(*lowerCamelCase_					)					)

										if equal_length:
														_snake_case :			str  						=   [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 :			List[str]  						=   [
														    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 :			Optional[Any]  						=   [np.asarray(lowerCamelCase_					) for x in speech_inputs]
										return speech_inputs



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



						"""simple docstring"""

						_UpperCamelCase  :	Any								=	WhisperFeatureExtractor if is_speech_available() else None







						def 		__UpperCAmelCase       (    self			:		Dict					):





										'''simple docstring'''







										_snake_case :			Optional[Any]  						=   WhisperFeatureExtractionTester(self					)







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





										'''simple docstring'''







										_snake_case :			Union[str, Any]  						=   self.feature_extraction_class(**self.feat_extract_dict					)

										with tempfile.TemporaryDirectory() as tmpdirname:
														_snake_case :			Any  						=   feat_extract_first.save_pretrained(lowerCamelCase_					)[0]
														check_json_file_has_correct_format(lowerCamelCase_					)
														_snake_case :			Tuple  						=   self.feature_extraction_class.from_pretrained(lowerCamelCase_					)

										_snake_case :			Optional[Any]  						=   feat_extract_first.to_dict()
										_snake_case :			List[Any]  						=   feat_extract_second.to_dict()
										_snake_case :			List[Any]  						=   feat_extract_first.mel_filters
										_snake_case :			List[str]  						=   feat_extract_second.mel_filters
										self.assertTrue(np.allclose(lowerCamelCase_ ,				lowerCamelCase_					)					)
										self.assertEqual(lowerCamelCase_ ,				lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										_snake_case :			int  						=   self.feature_extraction_class(**self.feat_extract_dict					)

										with tempfile.TemporaryDirectory() as tmpdirname:
														_snake_case :			Any  						=   os.path.join(lowerCamelCase_ ,				'feat_extract.json'					)
														feat_extract_first.to_json_file(lowerCamelCase_					)
														_snake_case :			List[str]  						=   self.feature_extraction_class.from_json_file(lowerCamelCase_					)

										_snake_case :			str  						=   feat_extract_first.to_dict()
										_snake_case :			Union[str, Any]  						=   feat_extract_second.to_dict()
										_snake_case :			str  						=   feat_extract_first.mel_filters
										_snake_case :			str  						=   feat_extract_second.mel_filters
										self.assertTrue(np.allclose(lowerCamelCase_ ,				lowerCamelCase_					)					)
										self.assertEqual(lowerCamelCase_ ,				lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		List[Any]					):





										'''simple docstring'''







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

										# Test feature size
										_snake_case :			Dict  						=   feature_extractor(lowerCamelCase_ ,				padding='max_length' ,				return_tensors='np'					).input_features
										self.assertTrue(input_features.ndim == 3					)
										self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames					)
										self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size					)

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

										# Test batched
										_snake_case :			Any  						=   feature_extractor(lowerCamelCase_ ,				return_tensors='np'					).input_features
										_snake_case :			List[Any]  						=   feature_extractor(lowerCamelCase_ ,				return_tensors='np'					).input_features
										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.
										_snake_case :			Union[str, Any]  						=   [floats_list((1, x)					)[0] for x in (8_00, 8_00, 8_00)]
										_snake_case :			Optional[int]  						=   np.asarray(lowerCamelCase_					)
										_snake_case :			Union[str, Any]  						=   feature_extractor(lowerCamelCase_ ,				return_tensors='np'					).input_features
										_snake_case :			str  						=   feature_extractor(lowerCamelCase_ ,				return_tensors='np'					).input_features
										for enc_seq_a, enc_seq_a in zip(lowerCamelCase_ ,				lowerCamelCase_					):
														self.assertTrue(np.allclose(lowerCamelCase_ ,				lowerCamelCase_ ,				atol=1e-3					)					)

										# Test truncation required
										_snake_case :			Optional[Any]  						=   [floats_list((1, x)					)[0] for x in range(2_00 ,				(feature_extractor.n_samples + 5_00) ,				2_00					)]
										_snake_case :			str  						=   [np.asarray(lowerCamelCase_					) for speech_input in speech_inputs]

										_snake_case :			int  						=   [x[: feature_extractor.n_samples] for x in speech_inputs]
										_snake_case :			Dict  						=   [np.asarray(lowerCamelCase_					) for speech_input in speech_inputs_truncated]

										_snake_case :			str  						=   feature_extractor(lowerCamelCase_ ,				return_tensors='np'					).input_features
										_snake_case :			Optional[Any]  						=   feature_extractor(lowerCamelCase_ ,				return_tensors='np'					).input_features
										for enc_seq_a, enc_seq_a in zip(lowerCamelCase_ ,				lowerCamelCase_					):
														self.assertTrue(np.allclose(lowerCamelCase_ ,				lowerCamelCase_ ,				atol=1e-3					)					)







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										import torch

										_snake_case :			Tuple  						=   self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										_snake_case :			Any  						=   np.random.rand(1_00 ,				32					).astype(np.floataa					)
										_snake_case :			int  						=   np_speech_inputs.tolist()

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







						def 		__UpperCAmelCase       (    self			:		Any ,				lowerCamelCase_			:		Any					):





										'''simple docstring'''







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

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







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										_snake_case :			Tuple  						=   torch.tensor(
										    [
										        0.1193, -0.0946, -0.1098, -0.0196, 0.0225, -0.0690, -0.1736, 0.0951,
										        0.0971, -0.0817, -0.0702, 0.0162, 0.0260, 0.0017, -0.0192, -0.1678,
										        0.0709, -0.1867, -0.0655, -0.0274, -0.0234, -0.1884, -0.0516, -0.0554,
										        -0.0274, -0.1425, -0.1423, 0.0837, 0.0377, -0.0854
										    ]					)
										# fmt: on

										_snake_case :			str  						=   self._load_datasamples(1					)
										_snake_case :			Any  						=   WhisperFeatureExtractor()
										_snake_case :			int  						=   feature_extractor(lowerCamelCase_ ,				return_tensors='pt'					).input_features
										self.assertEqual(input_features.shape ,				(1, 80, 30_00)					)
										self.assertTrue(torch.allclose(input_features[0, 0, :30] ,				lowerCamelCase_ ,				atol=1e-4					)					)







						def 		__UpperCAmelCase       (    self			:		str					):





										'''simple docstring'''







										_snake_case :			Tuple  						=   self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
										_snake_case :			Any  						=   self._load_datasamples(1					)[0]
										_snake_case :			Dict  						=   ((audio - audio.min()) / (audio.max() - audio.min())) * 6_55_35  # Rescale to [0, 65535] to show issue
										_snake_case :			Dict  						=   feat_extract.zero_mean_unit_var_norm([audio] ,				attention_mask=lowerCamelCase_					)[0]

										self.assertTrue(np.all(np.mean(lowerCamelCase_					) < 1e-3					)					)
										self.assertTrue(np.all(np.abs(np.var(lowerCamelCase_					) - 1					) < 1e-3					)					)













def       A__(		__lowerCAmelCase ):

				if not isinstance(__lowerCAmelCase	,			__lowerCAmelCase ):
								raise TypeError('only integers accepted as input' )
				else:
								_snake_case :			Any  						=   str(abs(__lowerCAmelCase ) )
								_snake_case :			List[str]  						=   [list(__lowerCAmelCase ) for char in range(len(__lowerCAmelCase ) )]
								for index in range(len(__lowerCAmelCase ) ):
												num_transpositions[index].pop(__lowerCAmelCase )
								return max(
								    int(''.join(list(__lowerCAmelCase ) ) ) for transposition in num_transpositions )


if __name__ == "__main__":
		__import__('''doctest''').testmod()






