


import itertools
import random
import unittest

import numpy as np

from transformers import WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST, WavaVecaConfig, WavaVecaFeatureExtractor
from transformers.testing_utils import require_torch, slow

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


A	:		Dict    =       random.Random()






def 			UpperCamelCase (     __magic_name__					:							Any   ,   __magic_name__					:							int=1.0   ,   __magic_name__					:							str=None   ,   __magic_name__					:							Union[str, Any]=None					)       ->  List[Any]:
		"""simple docstring"""




		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



class 							A   (	unittest.TestCase							):
					'''simple docstring'''






					def __init__(self   :						Any				, _UpperCAmelCase   :						Optional[Any]				, _UpperCAmelCase   :						Dict=7				, _UpperCAmelCase   :						str=400				, _UpperCAmelCase   :						Any=2000				, _UpperCAmelCase   :						Tuple=1				, _UpperCAmelCase   :						Dict=0.0				, _UpperCAmelCase   :						Optional[Any]=1_6000				, _UpperCAmelCase   :						Union[str, Any]=True				, _UpperCAmelCase   :						List[str]=True				, )						->       Optional[int]:




							"""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__					      =		return_attention_mask
							lowercase__					      =		do_normalize

					def   lowerCamelCase__					(self   :						Optional[Any]		)						->       Tuple:




							"""simple docstring"""


							return {
							    "feature_size": self.feature_size,
							    "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[Any]				, _UpperCAmelCase   :						str=False				, _UpperCAmelCase   :						str=False		)						->       Dict:




							"""simple docstring"""


							def _flatten(_UpperCAmelCase   :						Dict		):
									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






class 							A   (	UpperCAmelCase__			,  unittest.TestCase							):
					'''simple docstring'''






					A__      =			WavaVecaFeatureExtractor

					def   lowerCamelCase__					(self   :						Any		)						->       Any:




							"""simple docstring"""


							lowercase__					      =		WavaVecaFeatureExtractionTester(self		)

					def   lowerCamelCase__					(self   :						Any				, _UpperCAmelCase   :						Optional[Any]		)						->       int:




							"""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   lowerCamelCase__					(self   :						List[Any]		)						->       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				, 1400				, 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		)		)

							# Test 2-D numpy arrays are batched.
							lowercase__					      =		[floats_list((1, x)		)[0] for x in (800, 800, 800)]
							lowercase__					      =		np.asarray(_UpperCAmelCase		)
							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   lowerCamelCase__					(self   :						Optional[int]		)						->       Dict:




							"""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				, 1400				, 200		)]

							lowercase__					      =		["""longest""", """max_length""", """do_not_pad"""]
							lowercase__					      =		[None, 1600, 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][:1000]		)
									self.assertTrue(input_values[0][1000:].sum() < 1E-6		)
									self._check_zero_mean_unit_variance(input_values[2][:1200]		)

					def   lowerCamelCase__					(self   :						List[Any]		)						->       List[str]:




							"""simple docstring"""


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

							lowercase__					      =		["""longest""", """max_length""", """do_not_pad"""]
							lowercase__					      =		[None, 1600, 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][:1000]		)
									self._check_zero_mean_unit_variance(input_values[2][:1200]		)

					def   lowerCamelCase__					(self   :						int		)						->       Optional[int]:




							"""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				, 1400				, 200		)]
							lowercase__					      =		feat_extract(
							    _UpperCAmelCase				, truncation=_UpperCAmelCase				, max_length=1000				, 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   lowerCamelCase__					(self   :						Any		)						->       int:




							"""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				, 1400				, 200		)]
							lowercase__					      =		feat_extract(
							    _UpperCAmelCase				, truncation=_UpperCAmelCase				, max_length=1000				, 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, :1000]		)
							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, 1000)		)

							lowercase__					      =		[floats_list((1, x)		)[0] for x in range(800				, 1400				, 200		)]
							lowercase__					      =		feat_extract(
							    _UpperCAmelCase				, truncation=_UpperCAmelCase				, max_length=2000				, 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, :1000]		)
							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, 1200)		)

					@require_torch
					def   lowerCamelCase__					(self   :						str		)						->       Dict:




							"""simple docstring"""


							import torch

							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		)


					@slow
					@require_torch
					def   lowerCamelCase__					(self   :						Union[str, Any]		)						->       List[str]:




							"""simple docstring"""


							for model_id in WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST:
									lowercase__					      =		WavaVecaConfig.from_pretrained(_UpperCAmelCase		)
									lowercase__					      =		WavaVecaFeatureExtractor.from_pretrained(_UpperCAmelCase		)

									# only "layer" feature extraction norm should make use of
									# attention_mask
									self.assertEqual(feat_extract.return_attention_mask				, config.feat_extract_norm == """layer"""		)





from functools import lru_cache






def 			UpperCamelCase (     __magic_name__					:							int					)       ->  set:
		"""simple docstring"""




		lowercase__					      =		2
		lowercase__					      =		set()
		while i * i <= n:
				if n % i:
						i += 1
				else:
						n //= i
						factors.add(__magic_name__					)
		if n > 1:
				factors.add(__magic_name__					)
		return factors






@lru_cache
def 			UpperCamelCase (     __magic_name__					:							int					)       ->  int:
		"""simple docstring"""




		return len(unique_prime_factors(__magic_name__					)					)






def 			UpperCamelCase (     __magic_name__					:							list					)       ->  bool:
		"""simple docstring"""




		return len(set(__magic_name__					)					) in (0, 1)






def 			UpperCamelCase (     __magic_name__					:							int					)       ->  list:
		"""simple docstring"""




		lowercase__					      =		2

		while True:
				# Increment each value of a generated range
				lowercase__					      =		[base + i for i in range(__magic_name__					)]

				# Run elements through out unique_prime_factors function
				# Append our target number to the end.
				lowercase__					      =		[upf_len(__magic_name__					) for x in group]
				checker.append(__magic_name__					)

				# If all numbers in the list are equal, return the group variable.
				if equality(__magic_name__					):
						return group

				# Increment our base variable by 1
				base += 1






def 			UpperCamelCase (     __magic_name__					:							int = 4					)       ->  int:
		"""simple docstring"""




		lowercase__					      =		run(__magic_name__					)
		return results[0] if len(__magic_name__					) else None


if __name__ == "__main__":
	print(solution())

