





'''simple docstring'''


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

lowerCAmelCase_   :   Tuple       =					random.Random()







def    _lowerCamelCase  (__lowerCamelCase  :     Tuple					,  __lowerCamelCase  :     Optional[int]=1.0					,  __lowerCamelCase  :     Any=None					,  __lowerCamelCase  :     Optional[Any]=None     )   ->    Union[str, Any]:
			if rng is None:
						a__     = global_rng

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







	def __init__(				self			:   Optional[int] , lowerCamelCase			:   Optional[int] , lowerCamelCase			:   str=7 , lowerCamelCase			:   str=4_0_0 , lowerCamelCase			:   List[Any]=2_0_0_0 , lowerCamelCase			:   Any=1_0 , lowerCamelCase			:   str=1_6_0 , lowerCamelCase			:   List[Any]=8 , lowerCamelCase			:   Optional[int]=0.0 , lowerCamelCase			:   Tuple=4_0_0_0 , lowerCamelCase			:   str=False , lowerCamelCase			:   List[Any]=True , ):




				'''simple docstring'''
				a__     = parent
				a__     = batch_size
				a__     = min_seq_length
				a__     = max_seq_length
				a__     = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
				a__     = padding_value
				a__     = sampling_rate
				a__     = return_attention_mask
				a__     = do_normalize
				a__     = feature_size
				a__     = chunk_length
				a__     = hop_length







	def 						__a   (				self			:   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 						__a   (				self			:   Tuple , lowerCamelCase			:   Optional[int]=False , lowerCamelCase			:   Any=False		):




				'''simple docstring'''
				def _flatten(lowerCamelCase			:   Union[str, Any]		):
							return list(itertools.chain(*lowerCamelCase		)		)

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






@require_torch
@require_torchaudio
class       UpperCamelCase__  (		__lowerCAmelCase	,unittest.TestCase     ):
	lowerCAmelCase__					:			Optional[int]								=						WhisperFeatureExtractor if is_speech_available() else None







	def 						__a   (				self			:   int		):




				'''simple docstring'''
				a__     = WhisperFeatureExtractionTester(self		)







	def 						__a   (				self			:   List[Any]		):




				'''simple docstring'''
				a__     = self.feature_extraction_class(**self.feat_extract_dict		)

				with tempfile.TemporaryDirectory() as tmpdirname:
							a__     = feat_extract_first.save_pretrained(lowerCamelCase		)[0]
							check_json_file_has_correct_format(lowerCamelCase		)
							a__     = self.feature_extraction_class.from_pretrained(lowerCamelCase		)

				a__     = feat_extract_first.to_dict()
				a__     = feat_extract_second.to_dict()
				a__     = feat_extract_first.mel_filters
				a__     = feat_extract_second.mel_filters
				self.assertTrue(np.allclose(lowerCamelCase , lowerCamelCase		)		)
				self.assertEqual(lowerCamelCase , lowerCamelCase		)







	def 						__a   (				self			:   List[str]		):




				'''simple docstring'''
				a__     = self.feature_extraction_class(**self.feat_extract_dict		)

				with tempfile.TemporaryDirectory() as tmpdirname:
							a__     = os.path.join(lowerCamelCase , "feat_extract.json"		)
							feat_extract_first.to_json_file(lowerCamelCase		)
							a__     = self.feature_extraction_class.from_json_file(lowerCamelCase		)

				a__     = feat_extract_first.to_dict()
				a__     = feat_extract_second.to_dict()
				a__     = feat_extract_first.mel_filters
				a__     = feat_extract_second.mel_filters
				self.assertTrue(np.allclose(lowerCamelCase , lowerCamelCase		)		)
				self.assertEqual(lowerCamelCase , lowerCamelCase		)







	def 						__a   (				self			:   int		):




				'''simple docstring'''
				# Tests that all call wrap to encode_plus and batch_encode_plus
				a__     = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				# create three inputs of length 800, 1000, and 1200
				a__     = [floats_list((1, x)		)[0] for x in range(8_0_0 , 1_4_0_0 , 2_0_0		)]
				a__     = [np.asarray(lowerCamelCase		) for speech_input in speech_inputs]

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

				# Test batched
				a__     = feature_extractor(lowerCamelCase , return_tensors="np"		).input_features
				a__     = 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.
				a__     = [floats_list((1, x)		)[0] for x in (8_0_0, 8_0_0, 8_0_0)]
				a__     = np.asarray(lowerCamelCase		)
				a__     = feature_extractor(lowerCamelCase , return_tensors="np"		).input_features
				a__     = 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
				a__     = [floats_list((1, x)		)[0] for x in range(2_0_0 , (feature_extractor.n_samples + 5_0_0) , 2_0_0		)]
				a__     = [np.asarray(lowerCamelCase		) for speech_input in speech_inputs]

				a__     = [x[: feature_extractor.n_samples] for x in speech_inputs]
				a__     = [np.asarray(lowerCamelCase		) for speech_input in speech_inputs_truncated]

				a__     = feature_extractor(lowerCamelCase , return_tensors="np"		).input_features
				a__     = 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 						__a   (				self			:   Tuple		):




				'''simple docstring'''
				import torch

				a__     = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				a__     = np.random.rand(1_0_0 , 3_2		).astype(np.floataa		)
				a__     = np_speech_inputs.tolist()

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







	def 						__a   (				self			:   Union[str, Any] , lowerCamelCase			:   Optional[int]		):




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

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







	def 						__a   (				self			:   int		):




				'''simple docstring'''
				# fmt: off
				a__     = 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

				a__     = self._load_datasamples(1		)
				a__     = WhisperFeatureExtractor()
				a__     = feature_extractor(lowerCamelCase , return_tensors="pt"		).input_features
				self.assertEqual(input_features.shape , (1, 8_0, 3_0_0_0)		)
				self.assertTrue(torch.allclose(input_features[0, 0, :3_0] , lowerCamelCase , atol=1e-4		)		)







	def 						__a   (				self			:   Any		):




				'''simple docstring'''
				a__     = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				a__     = self._load_datasamples(1		)[0]
				a__     = ((audio - audio.min()) / (audio.max() - audio.min())) * 6_5_5_3_5  # Rescale to [0, 65535] to show issue
				a__     = 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		)		)










'''simple docstring'''


import re







def    _lowerCamelCase  (__lowerCamelCase  :     str     )   ->    bool:
			a__     = re.compile(
			    r"^(?:0|94|\+94|0{2}94)" r"7(0|1|2|4|5|6|7|8)" r"(-| |)" r"\d{7}$"     )

			return bool(re.search(__lowerCamelCase					,  __lowerCamelCase     )     )


if __name__ == "__main__":
		lowerCAmelCase_   :   Any       =					"0094702343221"

		print(is_sri_lankan_phone_number(phone))



