



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


UpperCAmelCase__     = random.Random()





def 							A			(  _UpperCAmelCase       :     int							,     _UpperCAmelCase       :     int=1.0							,     _UpperCAmelCase       :     int=None							,     _UpperCAmelCase       :     Optional[int]=None					)       ->				Tuple:







			'''simple docstring'''
			if rng is None:
						_UpperCAmelCase	 =     global_rng

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



			def __init__(		self     :						int				,	A     :						Any				,	A     :						Optional[int]=7				,	A     :						str=4_00				,	A     :						int=20_00				,	A     :						str=1				,	A     :						Optional[int]=0.0				,	A     :						List[Any]=1_60_00				,	A     :						int=True				,	A     :						List[str]=80				,	A     :						List[Any]=16				,	A     :						Any=64				,	A     :						Optional[Any]="hann_window"				,	A     :						Tuple=80				,	A     :						Union[str, Any]=76_00				,	A     :						Any=1E-10				,	A     :						Optional[int]=True				,	)     ->					List[str]:



						"""simple docstring"""






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



			def 					_lowerCamelCase (		self     :						Dict)     ->					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 					_lowerCamelCase (		self     :						int				,	A     :						List[str]=False				,	A     :						Any=False)     ->					str:



						"""simple docstring"""






						def _flatten(A     :						List[str]):
									return list(itertools.chain(*A))

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

						return speech_inputs



			def 					_lowerCamelCase (		self     :						str				,	A     :						Tuple=False				,	A     :						Any=False)     ->					Dict:



						"""simple docstring"""






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

						return speech_inputs







@require_torch
class     __lowerCAmelCase					(    A       ,		unittest.TestCase		):
			UpperCamelCase           =  SpeechTaFeatureExtractor



			def 					_lowerCamelCase (		self     :						Optional[Any])     ->					List[Any]:



						"""simple docstring"""






						_UpperCAmelCase	 =     SpeechTaFeatureExtractionTester(self)



			def 					_lowerCamelCase (		self     :						str				,	A     :						Optional[int])     ->					Tuple:



						"""simple docstring"""






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



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



						"""simple docstring"""






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

						# Test not batched input
						_UpperCAmelCase	 =     feat_extract(speech_inputs[0]				,	return_tensors='np').input_values
						_UpperCAmelCase	 =     feat_extract(np_speech_inputs[0]				,	return_tensors='np').input_values
						self.assertTrue(np.allclose(A				,	A				,	atol=1E-3))

						# Test batched
						_UpperCAmelCase	 =     feat_extract(A				,	return_tensors='np').input_values
						_UpperCAmelCase	 =     feat_extract(A				,	return_tensors='np').input_values
						for enc_seq_a, enc_seq_a in zip(A				,	A):
									self.assertTrue(np.allclose(A				,	A				,	atol=1E-3))



			def 					_lowerCamelCase (		self     :						List[str])     ->					int:



						"""simple docstring"""






						_UpperCAmelCase	 =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						_UpperCAmelCase	 =     [floats_list((1, x))[0] for x in range(8_00				,	14_00				,	2_00)]

						_UpperCAmelCase	 =     ['longest', 'max_length', 'do_not_pad']
						_UpperCAmelCase	 =     [None, 16_00, None]
						for max_length, padding in zip(A				,	A):
									_UpperCAmelCase	 =     feat_extract(A				,	padding=A				,	max_length=A				,	return_tensors='np')
									_UpperCAmelCase	 =     processed.input_values

									self._check_zero_mean_unit_variance(input_values[0][:8_00])
									self.assertTrue(input_values[0][8_00:].sum() < 1E-6)
									self._check_zero_mean_unit_variance(input_values[1][:10_00])
									self.assertTrue(input_values[0][10_00:].sum() < 1E-6)
									self._check_zero_mean_unit_variance(input_values[2][:12_00])



			def 					_lowerCamelCase (		self     :						List[str])     ->					Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase	 =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						_UpperCAmelCase	 =     range(8_00				,	14_00				,	2_00)
						_UpperCAmelCase	 =     [floats_list((1, x))[0] for x in lengths]

						_UpperCAmelCase	 =     ['longest', 'max_length', 'do_not_pad']
						_UpperCAmelCase	 =     [None, 16_00, None]

						for max_length, padding in zip(A				,	A):
									_UpperCAmelCase	 =     feat_extract(A				,	max_length=A				,	padding=A)
									_UpperCAmelCase	 =     processed.input_values

									self._check_zero_mean_unit_variance(input_values[0][:8_00])
									self._check_zero_mean_unit_variance(input_values[1][:10_00])
									self._check_zero_mean_unit_variance(input_values[2][:12_00])



			def 					_lowerCamelCase (		self     :						Dict)     ->					Tuple:



						"""simple docstring"""






						_UpperCAmelCase	 =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						_UpperCAmelCase	 =     [floats_list((1, x))[0] for x in range(8_00				,	14_00				,	2_00)]
						_UpperCAmelCase	 =     feat_extract(
						    A				,	truncation=A				,	max_length=10_00				,	padding='max_length'				,	return_tensors='np')
						_UpperCAmelCase	 =     processed.input_values

						self._check_zero_mean_unit_variance(input_values[0, :8_00])
						self._check_zero_mean_unit_variance(input_values[1])
						self._check_zero_mean_unit_variance(input_values[2])



			def 					_lowerCamelCase (		self     :						Union[str, Any])     ->					Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase	 =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						_UpperCAmelCase	 =     [floats_list((1, x))[0] for x in range(8_00				,	14_00				,	2_00)]
						_UpperCAmelCase	 =     feat_extract(
						    A				,	truncation=A				,	max_length=10_00				,	padding='longest'				,	return_tensors='np')
						_UpperCAmelCase	 =     processed.input_values

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

						_UpperCAmelCase	 =     [floats_list((1, x))[0] for x in range(8_00				,	14_00				,	2_00)]
						_UpperCAmelCase	 =     feat_extract(
						    A				,	truncation=A				,	max_length=20_00				,	padding='longest'				,	return_tensors='np')
						_UpperCAmelCase	 =     processed.input_values

						self._check_zero_mean_unit_variance(input_values[0, :8_00])
						self._check_zero_mean_unit_variance(input_values[1, :10_00])
						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, 12_00))



			def 					_lowerCamelCase (		self     :						Tuple)     ->					Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase	 =     self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict())
						_UpperCAmelCase	 =     np.random.rand(1_00).astype(np.floataa)
						_UpperCAmelCase	 =     np_speech_inputs.tolist()

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



			def 					_lowerCamelCase (		self     :						str)     ->					Union[str, Any]:



						"""simple docstring"""






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

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

						# Test batched
						_UpperCAmelCase	 =     feature_extractor(A				,	return_tensors='np').input_values
						_UpperCAmelCase	 =     feature_extractor(A				,	return_tensors='np').input_values
						for enc_seq_a, enc_seq_a in zip(A				,	A):
									self.assertTrue(np.allclose(A				,	A				,	atol=1E-3))

						# Test 2-D numpy arrays are batched.
						_UpperCAmelCase	 =     [floats_list((1, x))[0] for x in (8_00, 8_00, 8_00)]
						_UpperCAmelCase	 =     np.asarray(A)
						_UpperCAmelCase	 =     feature_extractor(A				,	return_tensors='np').input_values
						_UpperCAmelCase	 =     feature_extractor(A				,	return_tensors='np').input_values
						for enc_seq_a, enc_seq_a in zip(A				,	A):
									self.assertTrue(np.allclose(A				,	A				,	atol=1E-3))



			def 					_lowerCamelCase (		self     :						Optional[Any])     ->					Optional[Any]:



						"""simple docstring"""






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

						_UpperCAmelCase	 =     BatchFeature({input_name: speech_inputs})

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

						_UpperCAmelCase	 =     self.feat_extract_tester.prepare_inputs_for_target(equal_length=A)
						_UpperCAmelCase	 =     BatchFeature({input_name: speech_inputs}				,	tensor_type='np')

						_UpperCAmelCase	 =     processed_features[input_name]

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



						"""simple docstring"""






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

						_UpperCAmelCase	 =     BatchFeature({input_name: speech_inputs}				,	tensor_type='pt')

						_UpperCAmelCase	 =     processed_features[input_name]

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



						"""simple docstring"""






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

						_UpperCAmelCase	 =     BatchFeature({input_name: speech_inputs})

						_UpperCAmelCase	 =     feat_extract.num_mel_bins  # hack!

						_UpperCAmelCase	 =     feat_extract.pad(A				,	padding='longest'				,	return_tensors='np')[input_name]
						_UpperCAmelCase	 =     feat_extract.pad(A				,	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 					_lowerCamelCase (		self     :						Dict)     ->					List[str]:



						"""simple docstring"""






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

						_UpperCAmelCase	 =     BatchFeature({input_name: speech_inputs})

						_UpperCAmelCase	 =     feat_extract.num_mel_bins  # hack!

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



			def 					_lowerCamelCase (		self     :						List[Any])     ->					Any:



						"""simple docstring"""






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

						_UpperCAmelCase	 =     BatchFeature({input_name: speech_inputs})
						_UpperCAmelCase	 =     min(A)

						_UpperCAmelCase	 =     feat_extract.num_mel_bins  # hack!

						_UpperCAmelCase	 =     feat_extract.pad(
						    A				,	padding='max_length'				,	max_length=A				,	truncation=A				,	return_tensors='np')
						self.assertIn('attention_mask'				,	A)
						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 					_lowerCamelCase (		self     :						List[Any]				,	A     :						Optional[Any])     ->					Union[str, Any]:



						"""simple docstring"""






						from datasets import load_dataset

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

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



			def 					_lowerCamelCase (		self     :						Union[str, Any])     ->					Union[str, Any]:



						"""simple docstring"""






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

						_UpperCAmelCase	 =     self._load_datasamples(1)
						_UpperCAmelCase	 =     SpeechTaFeatureExtractor()
						_UpperCAmelCase	 =     feature_extractor(A				,	return_tensors='pt').input_values
						self.assertEquals(input_values.shape				,	(1, 9_36_80))
						self.assertTrue(torch.allclose(input_values[0, :30]				,	A				,	atol=1E-6))



			def 					_lowerCamelCase (		self     :						Any)     ->					List[Any]:



						"""simple docstring"""






						_UpperCAmelCase	 =     torch.tensor(
						    [-2.6_8_7_0, -3.0_1_0_4, -3.1_3_5_6, -3.5_3_5_2, -3.0_0_4_4, -3.0_3_5_3, -3.4_7_1_9, -3.6_7_7_7,
						     -3.1_5_2_0, -2.9_4_3_5, -2.6_5_5_3, -2.8_7_9_5, -2.9_9_4_4, -2.5_9_2_1, -3.0_2_7_9, -3.0_3_8_6,
						     -3.0_8_6_4, -3.1_2_9_1, -3.2_3_5_3, -2.7_4_4_4, -2.6_8_3_1, -2.7_2_8_7, -3.1_7_6_1, -3.1_5_7_1,
						     -3.2_7_2_6, -3.0_5_8_2, -3.1_0_0_7, -3.4_5_3_3, -3.4_6_9_5, -3.0_9_9_8])
						# fmt: on

						_UpperCAmelCase	 =     self._load_datasamples(1)
						_UpperCAmelCase	 =     SpeechTaFeatureExtractor()
						_UpperCAmelCase	 =     feature_extractor(audio_target=A				,	return_tensors='pt').input_values
						self.assertEquals(input_values.shape				,	(1, 3_66, 80))
						self.assertTrue(torch.allclose(input_values[0, 0, :30]				,	A				,	atol=1E-4))





from sympy import diff, lambdify, symbols
from sympy.functions import *  # noqa: F403





def 							A			(  _UpperCAmelCase       :     str							,     _UpperCAmelCase       :     complex							,     _UpperCAmelCase       :     str = "x"							,     _UpperCAmelCase       :     float = 10**-10							,     _UpperCAmelCase       :     int = 1							,     )       ->				complex:







			'''simple docstring'''
			_UpperCAmelCase	 =     symbols(_UpperCAmelCase					)
			_UpperCAmelCase	 =     lambdify(_UpperCAmelCase							,     _UpperCAmelCase					)
			_UpperCAmelCase	 =     lambdify(_UpperCAmelCase							,     diff(_UpperCAmelCase							,     _UpperCAmelCase					)					)

			_UpperCAmelCase	 =     starting_point

			while True:
						if diff_function(_UpperCAmelCase					) != 0:
									_UpperCAmelCase	 =     prev_guess - multiplicity * func(_UpperCAmelCase					) / diff_function(
									    _UpperCAmelCase					)
						else:
									raise ZeroDivisionError('Could not find root'					) from None

						# Precision is checked by comparing the difference of consecutive guesses
						if abs(next_guess - prev_guess					) < precision:
									return next_guess

						_UpperCAmelCase	 =     next_guess


# Let's Execute
if __name__ == "__main__":
							# Find root of trigonometric function
							# Find value of pi
							print(f"""The root of sin(x) = 0 is {newton_raphson("sin(x)", 2)}""")

							# Find root of polynomial
							# Find fourth Root of 5
							print(f"""The root of x**4 - 5 = 0 is {newton_raphson("x**4 -5", 0.4 +5J)}""")

							# Find value of e
							print(
							    "The root of log(y) - 1 = 0 is ",
							    f"""{newton_raphson("log(y) - 1", 2, variable="y")}""",
							)

							# Exponential Roots
							print(
							    "The root of exp(x) - 1 = 0 is",
							    f"""{newton_raphson("exp(x) - 1", 10, precision=0.005)}""",
							)

							# Find root of cos(x)
							print(f"""The root of cos(x) = 0 is {newton_raphson("cos(x)", 0)}""")
