






import string





def 		__UpperCAmelCase     (	a_):
							for key in range(len(string.ascii_uppercase)):
														snake_case_           =				''
														for symbol in message:
																					if symbol in string.ascii_uppercase:
																												snake_case_           =				string.ascii_uppercase.find(a_)
																												snake_case_           =				num - key
																												if num < 0:
																																			snake_case_           =				num + len(string.ascii_uppercase)
																												snake_case_           =				translated + string.ascii_uppercase[num]
																					else:
																												snake_case_           =				translated + symbol
														print(f'''Decryption using Key #{key}: {translated}''')





def 		__UpperCAmelCase     (	):
							snake_case_           =				input('Encrypted message: ')
							snake_case_           =				message.upper()
							decrypt(a_)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	main()













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

import numpy as np
import torch

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


lowercase    				=   logging.get_logger(__name__)




class 					UpperCamelCase_ (     snake_case_							):



	'''simple docstring'''




	lowerCAmelCase						=					['''input_features''', '''is_longer''']




	def __init__(			self			,     a=64			,     a=4_80_00			,     a=4_80			,     a=10			,     a=10_24			,     a=0.0			,     a=False			,     a = 0			,     a = 1_40_00			,     a = None			,     a = "fusion"			,     a = "repeatpad"			,     **a			,     )			->       List[str]:
								super().__init__(
								    feature_size=a			,     sampling_rate=a			,     padding_value=a			,     return_attention_mask=a			,     **a			,     )
								snake_case_           =				top_db
								snake_case_           =				truncation
								snake_case_           =				padding
								snake_case_           =				fft_window_size
								snake_case_           =				(fft_window_size >> 1) + 1
								snake_case_           =				hop_length
								snake_case_           =				max_length_s
								snake_case_           =				max_length_s * sampling_rate
								snake_case_           =				sampling_rate
								snake_case_           =				frequency_min
								snake_case_           =				frequency_max
								snake_case_           =				mel_filter_bank(
								    num_frequency_bins=self.nb_frequency_bins			,     num_mel_filters=a			,     min_frequency=a			,     max_frequency=a			,     sampling_rate=a			,     norm=a			,     mel_scale='htk'			,     )
								snake_case_           =				mel_filter_bank(
								    num_frequency_bins=self.nb_frequency_bins			,     num_mel_filters=a			,     min_frequency=a			,     max_frequency=a			,     sampling_rate=a			,     norm='slaney'			,     mel_scale='slaney'			,     )




	def 				_UpperCamelCase     (			self   )			->       Dict[str, Any]:
								snake_case_           =				copy.deepcopy(self.__dict__   )
								snake_case_           =				self.__class__.__name__
								if "mel_filters" in output:
															del output["mel_filters"]
								if "mel_filters_slaney" in output:
															del output["mel_filters_slaney"]
								return output




	def 				_UpperCamelCase     (			self			,     a			,     a = None   )			->       np.ndarray:
								snake_case_           =				spectrogram(
								    a			,     window_function(self.fft_window_size			,     'hann'   )			,     frame_length=self.fft_window_size			,     hop_length=self.hop_length			,     power=2.0			,     mel_filters=a			,     log_mel='dB'			,     )
								return log_mel_spectrogram.T




	def 				_UpperCamelCase     (			self			,     a			,     a			,     a   )			->       Tuple:
								snake_case_           =				np.array_split(list(range(0			,     total_frames - chunk_frames + 1   )   )			,     3   )
								if len(ranges[1]   ) == 0:
															# if the audio is too short, we just use the first chunk
															snake_case_           =				[0]
								if len(ranges[2]   ) == 0:
															# if the audio is too short, we just use the first chunk
															snake_case_           =				[0]
								# randomly choose index for each part
								snake_case_           =				np.random.choice(ranges[0]   )
								snake_case_           =				np.random.choice(ranges[1]   )
								snake_case_           =				np.random.choice(ranges[2]   )

								snake_case_           =				mel[idx_front : idx_front + chunk_frames, :]
								snake_case_           =				mel[idx_middle : idx_middle + chunk_frames, :]
								snake_case_           =				mel[idx_back : idx_back + chunk_frames, :]

								snake_case_           =				torch.tensor(mel[None, None, :]   )
								snake_case_           =				torch.nn.functional.interpolate(
								    a			,     size=[chunk_frames, 64]			,     mode='bilinear'			,     align_corners=a   )
								snake_case_           =				mel_shrink[0][0].numpy()
								snake_case_           =				np.stack([mel_shrink, mel_chunk_front, mel_chunk_middle, mel_chunk_back]			,     axis=0   )
								return mel_fusion




	def 				_UpperCamelCase     (			self			,     a			,     a			,     a			,     a   )			->       np.array:
								if waveform.shape[0] > max_length:
															if truncation == "rand_trunc":
																						snake_case_           =				True
																						# random crop to max_length (for compatibility) -> this should be handled by self.pad
																						snake_case_           =				len(a   ) - max_length
																						snake_case_           =				np.random.randint(0			,     overflow + 1   )
																						snake_case_           =				waveform[idx : idx + max_length]
																						snake_case_           =				self._np_extract_fbank_features(a			,     self.mel_filters_slaney   )[None, :]
															elif truncation == "fusion":
																						snake_case_           =				self._np_extract_fbank_features(a			,     self.mel_filters   )
																						snake_case_           =				max_length // self.hop_length + 1  # the +1 related to how the spectrogram is computed
																						snake_case_           =				mel.shape[0]
																						if chunk_frames == total_frames:
																													# there is a corner case where the audio length is larger than max_length but smaller than max_length+hop_length.
																													# In this case, we just use the whole audio.
																													snake_case_           =				np.stack([mel, mel, mel, mel]			,     axis=0   )
																													snake_case_           =				False
																						else:
																													snake_case_           =				self._random_mel_fusion(a			,     a			,     a   )
																													snake_case_           =				True
															else:
																						raise NotImplementedError(F'''data_truncating {truncation} not implemented'''   )

								else:
															snake_case_           =				False
															# only use repeat as a new possible value for padding. you repeat the audio before applying the usual max_length padding
															if waveform.shape[0] < max_length:
																						if padding == "repeat":
																													snake_case_           =				int(max_length / len(a   )   )
																													snake_case_           =				np.stack(np.tile(a			,     n_repeat + 1   )   )[:max_length]
																						if padding == "repeatpad":
																													snake_case_           =				int(max_length / len(a   )   )
																													snake_case_           =				np.stack(np.tile(a			,     a   )   )
																						snake_case_           =				np.pad(a			,     (0, max_length - waveform.shape[0])			,     mode='constant'			,     constant_values=0   )

															if truncation == "fusion":
																						snake_case_           =				self._np_extract_fbank_features(a			,     self.mel_filters   )
																						snake_case_           =				np.stack([input_mel, input_mel, input_mel, input_mel]			,     axis=0   )
															else:
																						snake_case_           =				self._np_extract_fbank_features(a			,     self.mel_filters_slaney   )[None, :]

								return input_mel, longer






	def __call__(			self			,     a			,     a = None			,     a = None			,     a = None			,     a = None			,     a = None			,     **a			,     )			->       BatchFeature:
								snake_case_           =				truncation if truncation is not None else self.truncation
								snake_case_           =				padding if padding else self.padding

								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.'   )

								snake_case_           =				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}'''   )
								snake_case_           =				is_batched_numpy or (
								    isinstance(a			,     (list, tuple)   ) and (isinstance(raw_speech[0]			,     (np.ndarray, tuple, list)   ))
								)

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

								# always return batch
								if not is_batched:
															snake_case_           =				[np.asarray(a   )]

								# convert to mel spectrogram, truncate and pad if needed.
								snake_case_           =				[
								    self._get_input_mel(a			,     max_length if max_length else self.nb_max_samples			,     a			,     a   )
								    for waveform in raw_speech
								]

								snake_case_           =				[]
								snake_case_           =				[]
								for mel, longer in padded_inputs:
															input_mel.append(a   )
															is_longer.append(a   )

								if truncation == "fusion" and sum(a   ) == 0:
															# if no audio is longer than 10s, then randomly select one audio to be longer
															snake_case_           =				np.random.randint(0			,     len(a   )   )
															snake_case_           =				True

								if isinstance(input_mel[0]			,     a   ):
															snake_case_           =				[np.asarray(a			,     dtype=np.floataa   ) for feature in input_mel]

								# is_longer is a list of bool
								snake_case_           =				[[longer] for longer in is_longer]

								snake_case_           =				{'input_features': input_mel, 'is_longer': is_longer}
								snake_case_           =				BatchFeature(a   )

								if return_tensors is not None:
															snake_case_           =				input_features.convert_to_tensors(a   )

								return input_features





