



import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


UpperCAmelCase__       =	logging.get_logger(__name__)







class       __lowerCAmelCase   (      A						):
			UpperCamelCase        =					['''input_features''']



			def __init__(						self       :  str			,		A       :  Optional[int]=80			,		A       :  Any=1_60_00			,		A       :  int=1_60			,		A       :  List[str]=30			,		A       :  List[Any]=4_00			,		A       :  List[str]=0.0			,		A       :  Optional[int]=False			,		**A       :  Union[str, Any]			,		)       ->   List[Any]:



						"""simple docstring"""






						super().__init__(
						    feature_size=A			,		sampling_rate=A			,		padding_value=A			,		return_attention_mask=A			,		**A			,		)
						_UpperCAmelCase			=       n_fft
						_UpperCAmelCase			=       hop_length
						_UpperCAmelCase			=       chunk_length
						_UpperCAmelCase			=       chunk_length * sampling_rate
						_UpperCAmelCase			=       self.n_samples // hop_length
						_UpperCAmelCase			=       sampling_rate
						_UpperCAmelCase			=       mel_filter_bank(
						    num_frequency_bins=1 + n_fft // 2			,		num_mel_filters=A			,		min_frequency=0.0			,		max_frequency=8_0_0_0.0			,		sampling_rate=A			,		norm='slaney'			,		mel_scale='slaney'			,		)



			def    _lowerCamelCase	(						self       :  Optional[int]			,		A       :  np.array)       ->   np.ndarray:



						"""simple docstring"""






						_UpperCAmelCase			=       spectrogram(
						    A			,		window_function(self.n_fft			,		'hann')			,		frame_length=self.n_fft			,		hop_length=self.hop_length			,		power=2.0			,		mel_filters=self.mel_filters			,		log_mel='log10'			,		)
						_UpperCAmelCase			=       log_spec[:, :-1]
						_UpperCAmelCase			=       np.maximum(A			,		log_spec.max() - 8.0)
						_UpperCAmelCase			=       (log_spec + 4.0) / 4.0
						return log_spec



			@staticmethod
			# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
			def    _lowerCamelCase	(						A       :  List[np.ndarray]			,		A       :  List[np.ndarray]			,		A       :  float = 0.0)       ->   List[np.ndarray]:



						"""simple docstring"""






						if attention_mask is not None:
									_UpperCAmelCase			=       np.array(A			,		np.intaa)
									_UpperCAmelCase			=       []

									for vector, length in zip(A			,		attention_mask.sum(-1)):
												_UpperCAmelCase			=       (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7)
												if length < normed_slice.shape[0]:
															_UpperCAmelCase			=       padding_value

												normed_input_values.append(A)
						else:
									_UpperCAmelCase			=       [(x - x.mean()) / np.sqrt(x.var() + 1E-7) for x in input_values]

						return normed_input_values



			def __call__(						self       :  Optional[Any]			,		A       :  Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]			,		A       :  bool = True			,		A       :  Optional[int] = None			,		A       :  Optional[Union[str, TensorType]] = None			,		A       :  Optional[bool] = None			,		A       :  Optional[str] = "max_length"			,		A       :  Optional[int] = None			,		A       :  Optional[int] = None			,		A       :  Optional[bool] = None			,		**A       :  Dict			,		)       ->   BatchFeature:



						"""simple docstring"""






						if sampling_rate is not None:
									if sampling_rate != self.sampling_rate:
												raise ValueError(
												    F"The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a"
												    F" sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input"
												    F" was sampled with {self.sampling_rate} and not {sampling_rate}.")
						else:
									logger.warning(
									    'It is strongly recommended to pass the `sampling_rate` argument to this function. '
									    'Failing to do so can result in silent errors that might be hard to debug.')

						_UpperCAmelCase			=       isinstance(A			,		np.ndarray) and len(raw_speech.shape) > 1
						if is_batched_numpy and len(raw_speech.shape) > 2:
									raise ValueError(F"Only mono-channel audio is supported for input to {self}")
						_UpperCAmelCase			=       is_batched_numpy or (
						    isinstance(A			,		(list, tuple)) and (isinstance(raw_speech[0]			,		(np.ndarray, tuple, list)))
						)

						if is_batched:
									_UpperCAmelCase			=       [np.asarray([speech]			,		dtype=np.floataa).T for speech in raw_speech]
						elif not is_batched and not isinstance(A			,		np.ndarray):
									_UpperCAmelCase			=       np.asarray(A			,		dtype=np.floataa)
						elif isinstance(A			,		np.ndarray) and raw_speech.dtype is np.dtype(np.floataa):
									_UpperCAmelCase			=       raw_speech.astype(np.floataa)

						# always return batch
						if not is_batched:
									_UpperCAmelCase			=       [np.asarray([raw_speech]).T]

						_UpperCAmelCase			=       BatchFeature({'input_features': raw_speech})

						# convert into correct format for padding

						_UpperCAmelCase			=       self.pad(
						    A			,		padding=A			,		max_length=max_length if max_length else self.n_samples			,		truncation=A			,		pad_to_multiple_of=A			,		return_attention_mask=return_attention_mask or do_normalize			,		)

						# zero-mean and unit-variance normalization
						if do_normalize:
									_UpperCAmelCase			=       self.zero_mean_unit_var_norm(
									    padded_inputs['input_features']			,		attention_mask=padded_inputs['attention_mask']			,		padding_value=self.padding_value			,		)
									_UpperCAmelCase			=       np.stack(padded_inputs['input_features']			,		axis=0)

						# make sure list is in array format
						_UpperCAmelCase			=       padded_inputs.get('input_features').transpose(2			,		0			,		1)

						_UpperCAmelCase			=       [self._np_extract_fbank_features(A) for waveform in input_features[0]]

						if isinstance(input_features[0]			,		A):
									_UpperCAmelCase			=       [np.asarray(A			,		dtype=np.floataa) for feature in input_features]
						else:
									_UpperCAmelCase			=       input_features

						if return_attention_mask:
									# rescale from sample (48000) to feature (3000)
									_UpperCAmelCase			=       padded_inputs['attention_mask'][:, :: self.hop_length]

						if return_tensors is not None:
									_UpperCAmelCase			=       padded_inputs.convert_to_tensors(A)

						return padded_inputs



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



						"""simple docstring"""






						_UpperCAmelCase			=       copy.deepcopy(self.__dict__)
						_UpperCAmelCase			=       self.__class__.__name__
						if "mel_filters" in output:
									del output["mel_filters"]
						return output





import string

import numpy





def 							A     (					_UpperCAmelCase    :       int							,       _UpperCAmelCase    :       int   )    ->			int:







			'''simple docstring'''
			return b if a == 0 else greatest_common_divisor(b % a							,       _UpperCAmelCase   )







class       __lowerCAmelCase   :
			UpperCamelCase        =					string.ascii_uppercase + string.digits
			# This cipher takes alphanumerics into account
			# i.e. a total of 36 characters

			# take x and return x % len(key_string)
			UpperCamelCase        =					numpy.vectorize(lambda A						: x % 3_6						)

			UpperCamelCase        =					numpy.vectorize(A						)



			def __init__(						self       :  Tuple			,		A       :  numpy.ndarray)       ->   None:



						"""simple docstring"""






						_UpperCAmelCase			=       self.modulus(A)  # mod36 calc's on the encrypt key
						self.check_determinant()  # validate the determinant of the encryption key
						_UpperCAmelCase			=       encrypt_key.shape[0]



			def    _lowerCamelCase	(						self       :  str			,		A       :  str)       ->   int:



						"""simple docstring"""






						return self.key_string.index(A)



			def    _lowerCamelCase	(						self       :  Any			,		A       :  int)       ->   str:



						"""simple docstring"""






						return self.key_string[round(A)]



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



						"""simple docstring"""






						_UpperCAmelCase			=       round(numpy.linalg.det(self.encrypt_key))

						if det < 0:
									_UpperCAmelCase			=       det % len(self.key_string)

						_UpperCAmelCase			=       len(self.key_string)
						if greatest_common_divisor(A			,		len(self.key_string)) != 1:
									_UpperCAmelCase			=       (
									    F"determinant modular {req_l} of encryption key({det}) "
									    F"is not co prime w.r.t {req_l}.\nTry another key."
									)
									raise ValueError(A)



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



						"""simple docstring"""






						_UpperCAmelCase			=       [char for char in text.upper() if char in self.key_string]

						_UpperCAmelCase			=       chars[-1]
						while len(A) % self.break_key != 0:
									chars.append(A)

						return "".join(A)



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



						"""simple docstring"""






						_UpperCAmelCase			=       self.process_text(text.upper())
						_UpperCAmelCase			=       ''

						for i in range(0			,		len(A) - self.break_key + 1			,		self.break_key):
									_UpperCAmelCase			=       text[i : i + self.break_key]
									_UpperCAmelCase			=       [self.replace_letters(A) for char in batch]
									_UpperCAmelCase			=       numpy.array([vec]).T
									_UpperCAmelCase			=       self.modulus(self.encrypt_key.dot(A)).T.tolist()[
									    0
									]
									_UpperCAmelCase			=       ''.join(
									    self.replace_digits(A) for num in batch_encrypted)
									encrypted += encrypted_batch

						return encrypted



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



						"""simple docstring"""






						_UpperCAmelCase			=       round(numpy.linalg.det(self.encrypt_key))

						if det < 0:
									_UpperCAmelCase			=       det % len(self.key_string)
						_UpperCAmelCase			=       None
						for i in range(len(self.key_string)):
									if (det * i) % len(self.key_string) == 1:
												_UpperCAmelCase			=       i
												break

						_UpperCAmelCase			=       (
						    det_inv
						    * numpy.linalg.det(self.encrypt_key)
						    * numpy.linalg.inv(self.encrypt_key)
						)

						return self.to_int(self.modulus(A))



			def    _lowerCamelCase	(						self       :  Tuple			,		A       :  str)       ->   str:



						"""simple docstring"""






						_UpperCAmelCase			=       self.make_decrypt_key()
						_UpperCAmelCase			=       self.process_text(text.upper())
						_UpperCAmelCase			=       ''

						for i in range(0			,		len(A) - self.break_key + 1			,		self.break_key):
									_UpperCAmelCase			=       text[i : i + self.break_key]
									_UpperCAmelCase			=       [self.replace_letters(A) for char in batch]
									_UpperCAmelCase			=       numpy.array([vec]).T
									_UpperCAmelCase			=       self.modulus(decrypt_key.dot(A)).T.tolist()[0]
									_UpperCAmelCase			=       ''.join(
									    self.replace_digits(A) for num in batch_decrypted)
									decrypted += decrypted_batch

						return decrypted





def 							A     (					)    ->			None:







			'''simple docstring'''
			_UpperCAmelCase			=       int(input('Enter the order of the encryption key: '   )   )
			_UpperCAmelCase			=       []

			print('Enter each row of the encryption key with space separated integers'   )
			for _ in range(_UpperCAmelCase   ):
						_UpperCAmelCase			=       [int(_UpperCAmelCase   ) for x in input().split()]
						hill_matrix.append(_UpperCAmelCase   )

			_UpperCAmelCase			=       HillCipher(numpy.array(_UpperCAmelCase   )   )

			print('Would you like to encrypt or decrypt some text? (1 or 2)'   )
			_UpperCAmelCase			=       input('\n1. Encrypt\n2. Decrypt\n'   )
			if option == "1":
						_UpperCAmelCase			=       input('What text would you like to encrypt?: '   )
						print('Your encrypted text is:'   )
						print(hc.encrypt(_UpperCAmelCase   )   )
			elif option == "2":
						_UpperCAmelCase			=       input('What text would you like to decrypt?: '   )
						print('Your decrypted text is:'   )
						print(hc.decrypt(_UpperCAmelCase   )   )


if __name__ == "__main__":
							import doctest

							doctest.testmod()

							main()
