






"""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

SCREAMING_SNAKE_CASE    :    Optional[int]        =							random.Random()



def 			__lowerCamelCase       (       lowerCAmelCase__							,lowerCAmelCase__=1.0							,lowerCAmelCase__=None							,lowerCAmelCase__=None					):






				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    snake_case_							(     unittest.TestCase							):



	"""simple docstring"""

	def __init__(   self	,       __a	,       __a=7	,       __a=400	,       __a=2000	,       __a=10	,       __a=160	,       __a=8	,       __a=0.0	,       __a=4000	,       __a=False	,       __a=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    _UpperCAmelCase    (   self    ):


					"""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    _UpperCAmelCase    (   self	,       __a=False	,       __a=False    ):


					"""simple docstring"""

					def _flatten(__a    ):
									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    snake_case_							(     _lowerCamelCase     ,				unittest.TestCase							):



	"""simple docstring"""

	SCREAMING_SNAKE_CASE_:				str       =       WhisperFeatureExtractor if is_speech_available() else None


	def    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					A__							=							WhisperFeatureExtractionTester(self    )


	def    _UpperCAmelCase    (   self    ):


					"""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    _UpperCAmelCase    (   self    ):


					"""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    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					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(800	,       1400	,       200    )]
					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 (800, 800, 800)]
					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(200	,       (feature_extractor.n_samples + 500)	,       200    )]
					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    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					import torch

					A__							=							self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
					A__							=							np.random.rand(100	,       32    ).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    _UpperCAmelCase    (   self	,       __a    ):


					"""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    _UpperCAmelCase    (   self    ):


					"""simple docstring"""

					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, 80, 3000)    )
					self.assertTrue(torch.allclose(input_features[0, 0, :30]	,       lowerCamelCase_	,       atol=1E-4    )    )






	def    _UpperCAmelCase    (   self    ):


					"""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_5535  # 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 random





class lowerCamelCase__   :



    '''simple docstring'''




    @staticmethod
    def UpperCamelCase__		( lowerCamelCase_    )    ->      tuple[list[int], list[int]]:
          A				  =		[ord(lowerCamelCase_    ) for i in text]
          A				  =		[]
          A				  =		[]
          for i in plain:
                A				  =		random.randint(1 ,3_0_0    )
                A				  =		(i + k) * k
                cipher.append(lowerCamelCase_    )
                key.append(lowerCamelCase_    )
          return cipher, key




    @staticmethod
    def UpperCamelCase__		( lowerCamelCase_ ,lowerCamelCase_    )    ->      str:
          A				  =		[]
          for i in range(len(lowerCamelCase_    )    ):
                A				  =		int((cipher[i] - (key[i]) ** 2) / key[i]    )
                plain.append(chr(lowerCamelCase_    )    )
          return "".join(lowerCamelCase_    )


if __name__ == "__main__":
  UpperCAmelCase							,			UpperCAmelCase													=Onepad().encrypt("Hello")
  print(c, k)
  print(Onepad().decrypt(c, k))




