




'''simple docstring'''






def 			__lowerCAmelCase					(    snake_case__					,      snake_case__					,      snake_case__						):

			if exponent == 1:
						return base
			if exponent % 2 == 0:
						__UpperCamelCase      :			str									=   _modexpt(UpperCamelCase__					,      exponent // 2					,      UpperCamelCase__						) % modulo_value
						return (x * x) % modulo_value
			else:
						return (base * _modexpt(UpperCamelCase__					,      exponent - 1					,      UpperCamelCase__						)) % modulo_value

def 			__lowerCAmelCase					(    snake_case__ = 1_777					,      snake_case__ = 1_855					,      snake_case__ = 8						):
			__UpperCamelCase      :			int									=   base
			for _ in range(1					,      UpperCamelCase__						):
						__UpperCamelCase      :			Optional[Any]									=   _modexpt(UpperCamelCase__					,      UpperCamelCase__					,      10**digits						)

			return result


if __name__ == "__main__":
				print(f'{solution() = }')










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


__A				:    str       =   random.Random()





def 						__SCREAMING_SNAKE_CASE  (				UpperCamelCase__			,			UpperCamelCase__=1.0			,			UpperCamelCase__=None			,			UpperCamelCase__=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 	A_       (unittest.TestCase			):
	def __init__(    self							,					_A							,					_A=7							,					_A=4_0_0							,					_A=2_0_0_0							,					_A=1							,					_A=0.0							,					_A=1_6_0_0_0							,					_A=True							,					_A=8_0							,					_A=1_6							,					_A=6_4							,					_A="hann_window"							,					_A=8_0							,					_A=7_6_0_0							,					_A=1E-10							,					_A=True							,					):






				'''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      _lowercase				(    self		):






				'''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      _lowercase				(    self							,					_A=False							,					_A=False		):






				'''simple docstring'''







				def _flatten(_A		):
							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      _lowercase				(    self							,					_A=False							,					_A=False		):






				'''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 	A_       (a_     ,							unittest.TestCase			):
	UpperCAmelCase__					=			SpeechTaFeatureExtractor
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				SpeechTaFeatureExtractionTester(self		)
	def      _lowercase				(    self							,					_A		):






				'''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      _lowercase				(    self		):






				'''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_0_0							,					1_4_0_0							,					2_0_0		)]
				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      _lowercase				(    self		):






				'''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_0_0							,					1_4_0_0							,					2_0_0		)]

				UpperCAmelCase   		=				['''longest''', '''max_length''', '''do_not_pad''']
				UpperCAmelCase   		=				[None, 1_6_0_0, 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_0_0]		)
							self.assertTrue(input_values[0][8_0_0:].sum() < 1E-6		)
							self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0]		)
							self.assertTrue(input_values[0][1_0_0_0:].sum() < 1E-6		)
							self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0]		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				range(8_0_0							,					1_4_0_0							,					2_0_0		)
				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in lengths]

				UpperCAmelCase   		=				['''longest''', '''max_length''', '''do_not_pad''']
				UpperCAmelCase   		=				[None, 1_6_0_0, 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_0_0]		)
							self._check_zero_mean_unit_variance(input_values[1][:1_0_0_0]		)
							self._check_zero_mean_unit_variance(input_values[2][:1_2_0_0]		)
	def      _lowercase				(    self		):






				'''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_0_0							,					1_4_0_0							,					2_0_0		)]
				UpperCAmelCase   		=				feat_extract(
				    _A							,					truncation=_A							,					max_length=1_0_0_0							,					padding='''max_length'''							,					return_tensors='''np'''		)
				UpperCAmelCase   		=				processed.input_values

				self._check_zero_mean_unit_variance(input_values[0, :8_0_0]		)
				self._check_zero_mean_unit_variance(input_values[1]		)
				self._check_zero_mean_unit_variance(input_values[2]		)
	def      _lowercase				(    self		):






				'''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_0_0							,					1_4_0_0							,					2_0_0		)]
				UpperCAmelCase   		=				feat_extract(
				    _A							,					truncation=_A							,					max_length=1_0_0_0							,					padding='''longest'''							,					return_tensors='''np'''		)
				UpperCAmelCase   		=				processed.input_values

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

				UpperCAmelCase   		=				[floats_list((1, x)		)[0] for x in range(8_0_0							,					1_4_0_0							,					2_0_0		)]
				UpperCAmelCase   		=				feat_extract(
				    _A							,					truncation=_A							,					max_length=2_0_0_0							,					padding='''longest'''							,					return_tensors='''np'''		)
				UpperCAmelCase   		=				processed.input_values

				self._check_zero_mean_unit_variance(input_values[0, :8_0_0]		)
				self._check_zero_mean_unit_variance(input_values[1, :1_0_0_0]		)
				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, 1_2_0_0)		)
	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()		)
				UpperCAmelCase   		=				np.random.rand(1_0_0		).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      _lowercase				(    self		):






				'''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_0_0							,					1_4_0_0							,					2_0_0		)]
				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_0_0, 8_0_0, 8_0_0)]
				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      _lowercase				(    self		):






				'''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      _lowercase				(    self		):






				'''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      _lowercase				(    self		):






				'''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      _lowercase				(    self		):






				'''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      _lowercase				(    self		):






				'''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      _lowercase				(    self							,					_A		):






				'''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      _lowercase				(    self		):






				'''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_3_6_8_0)		)
				self.assertTrue(torch.allclose(input_values[0, :3_0]							,					_A							,					atol=1E-6		)		)







	def      _lowercase				(    self		):






				'''simple docstring'''







				UpperCAmelCase   		=				torch.tensor(
				    [-2.68_70, -3.01_04, -3.13_56, -3.53_52, -3.00_44, -3.03_53, -3.47_19, -3.67_77,
				     -3.15_20, -2.94_35, -2.65_53, -2.87_95, -2.99_44, -2.59_21, -3.02_79, -3.03_86,
				     -3.08_64, -3.12_91, -3.23_53, -2.74_44, -2.68_31, -2.72_87, -3.17_61, -3.15_71,
				     -3.27_26, -3.05_82, -3.10_07, -3.45_33, -3.46_95, -3.09_98]		)
				# 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_6_6, 8_0)		)
				self.assertTrue(torch.allclose(input_values[0, 0, :3_0]							,					_A							,					atol=1E-4		)		)



