



import argparse
import struct
import unittest


class   __lowerCAmelCase  :
					"""simple docstring"""






					def __init__(  self       :							List[Any]					,       _snake_case       :							bytes       ):






								"""simple docstring"""


								A__	  =     data

								# Initialize hash values
								A__	  =     [
								    0x6A09E667,
								    0xBB67AE85,
								    0x3C6EF372,
								    0xA54FF53A,
								    0x510E527F,
								    0x9B05688C,
								    0x1F83D9AB,
								    0x5BE0CD19,
								]

								# Initialize round constants
								A__	  =     [
								    0x428A2F98,
								    0x71374491,
								    0xB5C0FBCF,
								    0xE9B5DBA5,
								    0x3956C25B,
								    0x59F111F1,
								    0x923F82A4,
								    0xAB1C5ED5,
								    0xD807AA98,
								    0x12835B01,
								    0x243185BE,
								    0x550C7DC3,
								    0x72BE5D74,
								    0x80DEB1FE,
								    0x9BDC06A7,
								    0xC19BF174,
								    0xE49B69C1,
								    0xEFBE4786,
								    0x0FC19DC6,
								    0x240CA1CC,
								    0x2DE92C6F,
								    0x4A7484AA,
								    0x5CB0A9DC,
								    0x76F988DA,
								    0x983E5152,
								    0xA831C66D,
								    0xB00327C8,
								    0xBF597FC7,
								    0xC6E00BF3,
								    0xD5A79147,
								    0x06CA6351,
								    0x14292967,
								    0x27B70A85,
								    0x2E1B2138,
								    0x4D2C6DFC,
								    0x53380D13,
								    0x650A7354,
								    0x766A0ABB,
								    0x81C2C92E,
								    0x92722C85,
								    0xA2BFE8A1,
								    0xA81A664B,
								    0xC24B8B70,
								    0xC76C51A3,
								    0xD192E819,
								    0xD6990624,
								    0xF40E3585,
								    0x106AA070,
								    0x19A4C116,
								    0x1E376C08,
								    0x2748774C,
								    0x34B0BCB5,
								    0x391C0CB3,
								    0x4ED8AA4A,
								    0x5B9CCA4F,
								    0x682E6FF3,
								    0x748F82EE,
								    0x78A5636F,
								    0x84C87814,
								    0x8CC70208,
								    0x90BEFFFA,
								    0xA4506CEB,
								    0xBEF9A3F7,
								    0xC67178F2,
								]

								A__	  =     self.preprocessing(self.data       )
								self.final_hash()



					@staticmethod
					def      _a				(  _snake_case       :							bytes       ):






								"""simple docstring"""


								A__	  =     B'\x80' + (B'\x00' * (63 - (len(_snake_case       ) + 8) % 64))
								A__	  =     struct.pack('>Q'					,       (len(_snake_case       ) * 8)       )
								return data + padding + big_endian_integer



					def      _a				(  self       :							Dict       ):






								"""simple docstring"""


								A__	  =     [
								    self.preprocessed_data[x : x + 64]
								    for x in range(0					,       len(self.preprocessed_data       )					,       64       )
								]

								for block in self.blocks:
											# Convert the given block into a list of 4 byte integers
											A__	  =     list(struct.unpack('>16L'					,       _snake_case       )       )
											# add 48 0-ed integers
											words += [0] * 48

											A__  ,			A__  ,			A__  ,			A__  ,			A__  ,			A__  ,			A__  ,			A__	  =     self.hashes

											for index in range(0					,       64       ):
														if index > 15:
																	# modify the zero-ed indexes at the end of the array
																	A__	  =     (
																	    self.ror(words[index - 15]					,       7       )
																	    ^ self.ror(words[index - 15]					,       18       )
																	    ^ (words[index - 15] >> 3)
																	)
																	A__	  =     (
																	    self.ror(words[index - 2]					,       17       )
																	    ^ self.ror(words[index - 2]					,       19       )
																	    ^ (words[index - 2] >> 10)
																	)

																	A__	  =     (
																	    words[index - 16] + sa + words[index - 7] + sa
																	) % 0x100000000

														# Compression
														A__	  =     self.ror(_snake_case					,       6       ) ^ self.ror(_snake_case					,       11       ) ^ self.ror(_snake_case					,       25       )
														A__	  =     (e & f) ^ ((~e & 0xFFFFFFFF) & g)
														A__	  =     (
														    h + sa + ch + self.round_constants[index] + words[index]
														) % 0x100000000
														A__	  =     self.ror(_snake_case					,       2       ) ^ self.ror(_snake_case					,       13       ) ^ self.ror(_snake_case					,       22       )
														A__	  =     (a & b) ^ (a & c) ^ (b & c)
														A__	  =     (sa + maj) % 0x100000000

														A__  ,			A__  ,			A__  ,			A__  ,			A__  ,			A__  ,			A__  ,			A__	  =     (
														    g,
														    f,
														    e,
														    ((d + tempa) % 0x100000000),
														    c,
														    b,
														    a,
														    ((tempa + tempa) % 0x100000000),
														)

											A__	  =     [a, b, c, d, e, f, g, h]

											# Modify final values
											A__	  =     [
											    ((element + mutated_hash_values[index]) % 0x100000000)
											    for index, element in enumerate(self.hashes       )
											]

								A__	  =     ''.join([hex(_snake_case       )[2:].zfill(8       ) for value in self.hashes]       )



					def      _a				(  self       :							Dict					,       _snake_case       :							int					,       _snake_case       :							int       ):






								"""simple docstring"""


								return 0xFFFFFFFF & (value << (32 - rotations)) | (value >> rotations)







class   __lowerCAmelCase  (		unittest.TestCase   ):
					"""simple docstring"""






					def      _a				(  self       :							str       ):






								"""simple docstring"""


								import hashlib

								A__	  =     bytes('Test String'					,       'utf-8'       )
								self.assertEqual(SHAaaa(_snake_case       ).hash					,       hashlib.shaaaa(_snake_case       ).hexdigest()       )







def A    (							)    ->   None:
			import doctest

			doctest.testmod()

			A__	  =     argparse.ArgumentParser()
			parser.add_argument(
			    '-s'			,						'--string'			,						dest='input_string'			,						default='Hello World!! Welcome to Cryptography'			,						help='Hash the string'			,						)
			parser.add_argument(
			    '-f'			,						'--file'			,						dest='input_file'			,						help='Hash contents of a file'       )

			A__	  =     parser.parse_args()

			A__	  =     args.input_string

			# hash input should be a bytestring
			if args.input_file:
						with open(args.input_file			,						'rb'       ) as f:
									A__	  =     f.read()
			else:
						A__	  =     bytes(__UpperCamelCase			,						'utf-8'       )

			print(SHAaaa(__UpperCamelCase       ).hash       )


if __name__ == "__main__":
							main()









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

import numpy as np

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


SCREAMING_SNAKE_CASE__   			=   logging.get_logger(__name__)


class   __lowerCAmelCase  (		UpperCAmelCase_   ):
					"""simple docstring"""






					A__					:		Optional[Any]      							=     ["input_values", "attention_mask"]



					def __init__(  self       :							str					,       _snake_case       :							int = 1					,       _snake_case       :							int = 1_60_00					,       _snake_case       :							float = 0.0					,       _snake_case       :							bool = False					,       _snake_case       :							int = 80					,       _snake_case       :							int = 16					,       _snake_case       :							int = 64					,       _snake_case       :							str = "hann_window"					,       _snake_case       :							float = 1.0					,       _snake_case       :							float = 80					,       _snake_case       :							float = 76_00					,       _snake_case       :							float = 1E-10					,       _snake_case       :							int = 2					,       _snake_case       :							bool = True					,       **_snake_case       :							Union[str, Any]					,       ):






								"""simple docstring"""


								super().__init__(feature_size=_snake_case					,       sampling_rate=_snake_case					,       padding_value=_snake_case					,       **_snake_case       )
								A__	  =     do_normalize
								A__	  =     return_attention_mask

								A__	  =     num_mel_bins
								A__	  =     hop_length
								A__	  =     win_length
								A__	  =     win_function
								A__	  =     frame_signal_scale
								A__	  =     fmin
								A__	  =     fmax
								A__	  =     mel_floor
								A__	  =     reduction_factor

								A__	  =     win_length * sampling_rate // 10_00
								A__	  =     hop_length * sampling_rate // 10_00
								A__	  =     optimal_fft_length(self.sample_size       )
								A__	  =     (self.n_fft // 2) + 1

								A__	  =     window_function(window_length=self.sample_size					,       name=self.win_function					,       periodic=_snake_case       )

								A__	  =     mel_filter_bank(
								    num_frequency_bins=self.n_freqs					,       num_mel_filters=self.num_mel_bins					,       min_frequency=self.fmin					,       max_frequency=self.fmax					,       sampling_rate=self.sampling_rate					,       norm='slaney'					,       mel_scale='slaney'					,       )

								if frame_signal_scale != 1.0:
											warnings.warn(
											    'The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers'					,       _snake_case					,       )
								if reduction_factor != 2.0:
											warnings.warn(
											    'The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers'					,       _snake_case					,       )



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






								"""simple docstring"""


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

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

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

								return normed_input_values



					def      _a				(  self       :							Tuple					,       _snake_case       :							np.ndarray					,       ):






								"""simple docstring"""


								A__	  =     spectrogram(
								    _snake_case					,       window=self.window					,       frame_length=self.sample_size					,       hop_length=self.sample_stride					,       fft_length=self.n_fft					,       mel_filters=self.mel_filters					,       mel_floor=self.mel_floor					,       log_mel='log10'					,       )
								return log_mel_spec.T



					def __call__(  self       :							List[str]					,       _snake_case       :							Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None					,       _snake_case       :							Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None					,       _snake_case       :							Union[bool, str, PaddingStrategy] = False					,       _snake_case       :							Optional[int] = None					,       _snake_case       :							bool = False					,       _snake_case       :							Optional[int] = None					,       _snake_case       :							Optional[bool] = None					,       _snake_case       :							Optional[Union[str, TensorType]] = None					,       _snake_case       :							Optional[int] = None					,       **_snake_case       :							Tuple					,       ):






								"""simple docstring"""


								if audio is None and audio_target is None:
											raise ValueError('You must provide either `audio` or `audio_target` values.'       )

								if sampling_rate is not None:
											if sampling_rate != self.sampling_rate:
														raise ValueError(
														    F'''The model corresponding to this feature extractor: {self} was trained using a sampling rate of'''
														    F''' {self.sampling_rate}. Please make sure that the provided audio input was sampled with'''
														    F''' {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.'       )

								if audio is not None:
											A__	  =     self._process_audio(
											    _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       **_snake_case					,       )
								else:
											A__	  =     None

								if audio_target is not None:
											A__	  =     self._process_audio(
											    _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       _snake_case					,       **_snake_case					,       )

											if inputs is None:
														return inputs_target
											else:
														A__	  =     inputs_target['input_values']
														A__	  =     inputs_target.get('attention_mask'       )
														if decoder_attention_mask is not None:
																	A__	  =     decoder_attention_mask

								return inputs



					def      _a				(  self       :							Tuple					,       _snake_case       :							Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]					,       _snake_case       :							bool = False					,       _snake_case       :							Union[bool, str, PaddingStrategy] = False					,       _snake_case       :							Optional[int] = None					,       _snake_case       :							bool = False					,       _snake_case       :							Optional[int] = None					,       _snake_case       :							Optional[bool] = None					,       _snake_case       :							Optional[Union[str, TensorType]] = None					,       **_snake_case       :							Tuple					,       ):






								"""simple docstring"""


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

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

								# always return batch
								if not is_batched:
											A__	  =     [speech]

								# needed to make pad() work on spectrogram inputs
								A__	  =     self.feature_size

								# convert into correct format for padding
								if is_target:
											A__	  =     [self._extract_mel_features(_snake_case       ) for waveform in speech]
											A__	  =     BatchFeature({'input_values': features}       )
											A__	  =     self.num_mel_bins
								else:
											A__	  =     BatchFeature({'input_values': speech}       )

								A__	  =     self.pad(
								    _snake_case					,       padding=_snake_case					,       max_length=_snake_case					,       truncation=_snake_case					,       pad_to_multiple_of=_snake_case					,       return_attention_mask=_snake_case					,       **_snake_case					,       )

								A__	  =     feature_size_hack

								# convert input values to correct format
								A__	  =     padded_inputs['input_values']
								if not isinstance(input_values[0]					,       np.ndarray       ):
											A__	  =     [np.asarray(_snake_case					,       dtype=np.floataa       ) for array in input_values]
								elif (
								    not isinstance(_snake_case					,       np.ndarray       )
								    and isinstance(input_values[0]					,       np.ndarray       )
								    and input_values[0].dtype is np.dtype(np.floataa       )
								):
											A__	  =     [array.astype(np.floataa       ) for array in input_values]
								elif isinstance(_snake_case					,       np.ndarray       ) and input_values.dtype is np.dtype(np.floataa       ):
											A__	  =     input_values.astype(np.floataa       )

								# convert attention_mask to correct format
								A__	  =     padded_inputs.get('attention_mask'       )
								if attention_mask is not None:
											A__	  =     [np.asarray(_snake_case					,       dtype=np.intaa       ) for array in attention_mask]

								# zero-mean and unit-variance normalization
								if not is_target and self.do_normalize:
											A__	  =     (
											    attention_mask
											    if self._get_padding_strategies(_snake_case					,       max_length=_snake_case       ) is not PaddingStrategy.DO_NOT_PAD
											    else None
											)
											A__	  =     self.zero_mean_unit_var_norm(
											    padded_inputs['input_values']					,       attention_mask=_snake_case					,       padding_value=self.padding_value       )

								if return_tensors is not None:
											A__	  =     padded_inputs.convert_to_tensors(_snake_case       )

								return padded_inputs



					def      _a				(  self       :							Optional[Any]       ):






								"""simple docstring"""


								A__	  =     super().to_dict()

								# Don't serialize these as they are derived from the other properties.
								A__	  =     ['window', 'mel_filters', 'sample_size', 'sample_stride', 'n_fft', 'n_freqs']
								for name in names:
											if name in output:
														del output[name]

								return output




