





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

_a     :    int         =						random.Random()
def 							a_	(    __magic_name__		,     __magic_name__=1.0		,     __magic_name__=None		,     __magic_name__=None   )				->			Optional[int]:




				"""simple docstring"""






				if rng is None:
								snake_case   :					Optional[Any]    						=				global_rng

				snake_case   :					Optional[int]    						=				[]
				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   a_ (			unittest.TestCase      ):

			def __init__(   self   :  int     , UpperCAmelCase__   :  Tuple     , UpperCAmelCase__   :  Optional[int]=7     , UpperCAmelCase__   :  Any=400     , UpperCAmelCase__   :  List[Any]=2_000     , UpperCAmelCase__   :  Optional[int]=10     , UpperCAmelCase__   :  Optional[Any]=160     , UpperCAmelCase__   :  Tuple=8     , UpperCAmelCase__   :  Dict=0.0     , UpperCAmelCase__   :  Any=4_000     , UpperCAmelCase__   :  Any=False     , UpperCAmelCase__   :  Optional[Any]=True     , ):






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

			def      lowerCAmelCase(   self   :  Tuple						):






							"""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      lowerCAmelCase(   self   :  Optional[int]     , UpperCAmelCase__   :  List[Any]=False     , UpperCAmelCase__   :  Union[str, Any]=False						):






							"""simple docstring"""

							def _flatten(UpperCAmelCase__   :  Union[str, Any]						):
											return list(itertools.chain(*snake_case_						)						)

							if equal_length:
											snake_case   :					Any    						=				[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   :					Dict    						=				[
											    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   :					Union[str, Any]    						=				[np.asarray(snake_case_						) for x in speech_inputs]
							return speech_inputs
@require_torch
@require_torchaudio
class   a_ (			lowerCAmelCase__		,							unittest.TestCase      ):
			A__      :			Union[str, Any]       	=  WhisperFeatureExtractor if is_speech_available() else None

			def      lowerCAmelCase(   self   :  Dict						):






							"""simple docstring"""
							snake_case   :					Union[str, Any]    						=				WhisperFeatureExtractionTester(self						)

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






							"""simple docstring"""
							snake_case   :					List[str]    						=				self.feature_extraction_class(**self.feat_extract_dict						)

							with tempfile.TemporaryDirectory() as tmpdirname:
											snake_case   :					str    						=				feat_extract_first.save_pretrained(snake_case_						)[0]
											check_json_file_has_correct_format(snake_case_						)
											snake_case   :					List[Any]    						=				self.feature_extraction_class.from_pretrained(snake_case_						)

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

			def      lowerCAmelCase(   self   :  Tuple						):






							"""simple docstring"""
							snake_case   :					Dict    						=				self.feature_extraction_class(**self.feat_extract_dict						)

							with tempfile.TemporaryDirectory() as tmpdirname:
											snake_case   :					int    						=				os.path.join(snake_case_     , '''feat_extract.json'''						)
											feat_extract_first.to_json_file(snake_case_						)
											snake_case   :					Optional[int]    						=				self.feature_extraction_class.from_json_file(snake_case_						)

							snake_case   :					Tuple    						=				feat_extract_first.to_dict()
							snake_case   :					Optional[int]    						=				feat_extract_second.to_dict()
							snake_case   :					Dict    						=				feat_extract_first.mel_filters
							snake_case   :					Union[str, Any]    						=				feat_extract_second.mel_filters
							self.assertTrue(np.allclose(snake_case_     , snake_case_						)						)
							self.assertEqual(snake_case_     , snake_case_						)

			def      lowerCAmelCase(   self   :  Optional[int]						):






							"""simple docstring"""
							snake_case   :					str    						=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
							# create three inputs of length 800, 1000, and 1200
							snake_case   :					Any    						=				[floats_list((1, x)						)[0] for x in range(800     , 1_400     , 200						)]
							snake_case   :					Dict    						=				[np.asarray(snake_case_						) for speech_input in speech_inputs]

							# Test feature size
							snake_case   :					Tuple    						=				feature_extractor(snake_case_     , 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   :					Optional[int]    						=				feature_extractor(speech_inputs[0]     , return_tensors='''np'''						).input_features
							snake_case   :					List[Any]    						=				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   :					List[str]    						=				feature_extractor(snake_case_     , return_tensors='''np'''						).input_features
							snake_case   :					str    						=				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   :					int    						=				[floats_list((1, x)						)[0] for x in (800, 800, 800)]
							snake_case   :					Union[str, Any]    						=				np.asarray(snake_case_						)
							snake_case   :					Optional[int]    						=				feature_extractor(snake_case_     , return_tensors='''np'''						).input_features
							snake_case   :					Dict    						=				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 truncation required
							snake_case   :					List[str]    						=				[floats_list((1, x)						)[0] for x in range(200     , (feature_extractor.n_samples + 500)     , 200						)]
							snake_case   :					str    						=				[np.asarray(snake_case_						) for speech_input in speech_inputs]

							snake_case   :					Dict    						=				[x[: feature_extractor.n_samples] for x in speech_inputs]
							snake_case   :					List[Any]    						=				[np.asarray(snake_case_						) for speech_input in speech_inputs_truncated]

							snake_case   :					str    						=				feature_extractor(snake_case_     , return_tensors='''np'''						).input_features
							snake_case   :					List[str]    						=				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      lowerCAmelCase(   self   :  List[str]						):






							"""simple docstring"""
							import torch

							snake_case   :					List[str]    						=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
							snake_case   :					List[str]    						=				np.random.rand(100     , 32						).astype(np.floataa						)
							snake_case   :					Any    						=				np_speech_inputs.tolist()

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

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






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

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

			def      lowerCAmelCase(   self   :  Any						):






							"""simple docstring"""
							snake_case   :					Optional[int]    						=				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   :					Dict    						=				self._load_datasamples(1						)
							snake_case   :					Union[str, Any]    						=				WhisperFeatureExtractor()
							snake_case   :					List[str]    						=				feature_extractor(snake_case_     , return_tensors='''pt'''						).input_features
							self.assertEqual(input_features.shape     , (1, 80, 3_000)						)
							self.assertTrue(torch.allclose(input_features[0, 0, :30]     , snake_case_     , atol=1e-4						)						)



			def      lowerCAmelCase(   self   :  int						):






							"""simple docstring"""
							snake_case   :					Optional[Any]    						=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()						)
							snake_case   :					Optional[Any]    						=				self._load_datasamples(1						)[0]
							snake_case   :					str    						=				((audio - audio.min()) / (audio.max() - audio.min())) * 65_535  # Rescale to [0, 65535] to show issue
							snake_case   :					Tuple    						=				feat_extract.zero_mean_unit_var_norm([audio]     , attention_mask=snake_case_						)[0]

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




def 		lowercase_	(  _UpperCamelCase	):


			'''simple docstring'''







			__lowercase			       = hex_num.strip()
			if not hex_num:
						raise ValueError('''No value was passed to the function'''	)

			__lowercase			       = hex_num[0] == '''-'''
			if is_negative:
						__lowercase			       = hex_num[1:]

			try:
						__lowercase			       = int(_UpperCamelCase							,      16	)
			except ValueError:
						raise ValueError('''Invalid value was passed to the function'''	)

			__lowercase			       = ''''''
			while int_num > 0:
						__lowercase			       = str(int_num % 2	) + bin_str
						int_num >>= 1

			return int(('''-''' + bin_str) if is_negative else bin_str	)


if __name__ == "__main__":
	import doctest

	doctest.testmod()


