






import argparse
import struct
import unittest




class 							snake_case_       :

						"""simple docstring"""



						def __init__(self:					Optional[int] ,					__UpperCAmelCase:					bytes   )    ->     None:




											'''simple docstring'''



											__a					:						Optional[Any]      =					data

											# Initialize hash values
											__a					:						Optional[Any]      =					[
											    0X6A09_E667,
											    0XBB67_AE85,
											    0X3C6E_F372,
											    0XA54F_F53A,
											    0X510E_527F,
											    0X9B05_688C,
											    0X1F83_D9AB,
											    0X5BE0_CD19,
											]

											# Initialize round constants
											__a					:						Union[str, Any]      =					[
											    0X428A_2F98,
											    0X7137_4491,
											    0XB5C0_FBCF,
											    0XE9B5_DBA5,
											    0X3956_C25B,
											    0X59F1_11F1,
											    0X923F_82A4,
											    0XAB1C_5ED5,
											    0XD807_AA98,
											    0X1283_5B01,
											    0X2431_85BE,
											    0X550C_7DC3,
											    0X72BE_5D74,
											    0X80DE_B1FE,
											    0X9BDC_06A7,
											    0XC19B_F174,
											    0XE49B_69C1,
											    0XEFBE_4786,
											    0X0FC1_9DC6,
											    0X240C_A1CC,
											    0X2DE9_2C6F,
											    0X4A74_84AA,
											    0X5CB0_A9DC,
											    0X76F9_88DA,
											    0X983E_5152,
											    0XA831_C66D,
											    0XB003_27C8,
											    0XBF59_7FC7,
											    0XC6E0_0BF3,
											    0XD5A7_9147,
											    0X06CA_6351,
											    0X1429_2967,
											    0X27B7_0A85,
											    0X2E1B_2138,
											    0X4D2C_6DFC,
											    0X5338_0D13,
											    0X650A_7354,
											    0X766A_0ABB,
											    0X81C2_C92E,
											    0X9272_2C85,
											    0XA2BF_E8A1,
											    0XA81A_664B,
											    0XC24B_8B70,
											    0XC76C_51A3,
											    0XD192_E819,
											    0XD699_0624,
											    0XF40E_3585,
											    0X106A_A070,
											    0X19A4_C116,
											    0X1E37_6C08,
											    0X2748_774C,
											    0X34B0_BCB5,
											    0X391C_0CB3,
											    0X4ED8_AA4A,
											    0X5B9C_CA4F,
											    0X682E_6FF3,
											    0X748F_82EE,
											    0X78A5_636F,
											    0X84C8_7814,
											    0X8CC7_0208,
											    0X90BE_FFFA,
											    0XA450_6CEB,
											    0XBEF9_A3F7,
											    0XC671_78F2,
											]

											__a					:						Dict      =					self.preprocessing(self.data   )
											self.final_hash()



						@staticmethod
						def        UpperCAmelCase__					(__UpperCAmelCase:					bytes   )    ->     bytes:




											'''simple docstring'''



											__a					:						Optional[Any]      =					b"\x80" + (b"\x00" * (63 - (len(lowerCAmelCase__   ) + 8) % 64))
											__a					:						Union[str, Any]      =					struct.pack(">Q" ,					(len(lowerCAmelCase__   ) * 8)   )
											return data + padding + big_endian_integer



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




											'''simple docstring'''



											__a					:						Tuple      =					[
											    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[Any]      =					list(struct.unpack(">16L" ,					lowerCAmelCase__   )   )
																# add 48 0-ed integers
																words += [0] * 48

																__a      ,			__a      ,			__a      ,			__a      ,			__a      ,			__a      ,			__a      ,			__a					:						Optional[int]      =					self.hashes

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

																										__a					:						List[Any]      =					(
																										    words[index - 16] + sa + words[index - 7] + sa
																										) % 0X1_0000_0000

																					# Compression
																					__a					:						Optional[int]      =					self.ror(lowerCAmelCase__ ,					6   ) ^ self.ror(lowerCAmelCase__ ,					11   ) ^ self.ror(lowerCAmelCase__ ,					25   )
																					__a					:						Optional[int]      =					(e & f) ^ ((~e & 0XFFFF_FFFF) & g)
																					__a					:						Any      =					(
																					    h + sa + ch + self.round_constants[index] + words[index]
																					) % 0X1_0000_0000
																					__a					:						List[Any]      =					self.ror(lowerCAmelCase__ ,					2   ) ^ self.ror(lowerCAmelCase__ ,					13   ) ^ self.ror(lowerCAmelCase__ ,					22   )
																					__a					:						str      =					(a & b) ^ (a & c) ^ (b & c)
																					__a					:						int      =					(sa + maj) % 0X1_0000_0000

																					__a      ,			__a      ,			__a      ,			__a      ,			__a      ,			__a      ,			__a      ,			__a					:						List[Any]      =					(
																					    g,
																					    f,
																					    e,
																					    ((d + tempa) % 0X1_0000_0000),
																					    c,
																					    b,
																					    a,
																					    ((tempa + tempa) % 0X1_0000_0000),
																					)

																__a					:						Optional[int]      =					[a, b, c, d, e, f, g, h]

																# Modify final values
																__a					:						Optional[int]      =					[
																    ((element + mutated_hash_values[index]) % 0X1_0000_0000)
																    for index, element in enumerate(self.hashes   )
																]

											__a					:						str      =					"".join([hex(lowerCAmelCase__   )[2:].zfill(8   ) for value in self.hashes]   )



						def        UpperCAmelCase__					(self:					Any ,					__UpperCAmelCase:					int ,					__UpperCAmelCase:					int   )    ->     int:




											'''simple docstring'''



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




class 							snake_case_       (    unittest.TestCase      ):

						"""simple docstring"""



						def        UpperCAmelCase__					(self:					List[str]   )    ->     None:




											'''simple docstring'''



											import hashlib

											__a					:						Optional[Any]      =					bytes("Test String" ,					"utf-8"   )
											self.assertEqual(SHAaaa(lowerCAmelCase__   ).hash ,					hashlib.shaaaa(lowerCAmelCase__   ).hexdigest()   )







def     a_   ()				->						None:



					"""simple docstring"""
					import doctest

					doctest.testmod()

					__a					:						str      =					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					:						Any      =					parser.parse_args()

					__a					:						List[Any]      =					args.input_string

					# hash input should be a bytestring
					if args.input_file:
										with open(args.input_file				,       "rb"      ) as f:
															__a					:						List[Any]      =					f.read()
					else:
										__a					:						Tuple      =					bytes(__A				,       "utf-8"      )

					print(SHAaaa(__A      ).hash      )


if __name__ == "__main__":
			main()












'''simple docstring'''

from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig, OnnxSeqaSeqConfigWithPast
from ...utils import logging


if TYPE_CHECKING:
   from ...feature_extraction_utils import FeatureExtractionMixin
   from ...tokenization_utils_base import PreTrainedTokenizerBase
   from ...utils import TensorType

lowercase__		:     Optional[Any]			=							logging.get_logger(__name__)

lowercase__		:     Union[str, Any]			=							{
    'openai/whisper-base': 'https://huggingface.co/openai/whisper-base/resolve/main/config.json',
}

# fmt: off
lowercase__		:     Any			=							[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 3_57, 3_66, 4_38, 5_32, 6_85,
    7_05, 7_96, 9_30, 10_58, 12_20, 12_67, 12_79, 13_03, 13_43, 13_77,
    13_91, 16_35, 17_82, 18_75, 21_62, 23_61, 24_88, 34_67, 40_08, 42_11,
    46_00, 48_08, 52_99, 58_55, 63_29, 72_03, 96_09, 99_59, 1_05_63, 1_07_86,
    1_14_20, 1_17_09, 1_19_07, 1_31_63, 1_36_97, 1_37_00, 1_48_08, 1_53_06, 1_64_10, 1_67_91,
    1_79_92, 1_92_03, 1_95_10, 2_07_24, 2_23_05, 2_29_35, 2_70_07, 3_01_09, 3_04_20, 3_34_09,
    3_49_49, 4_02_83, 4_04_93, 4_05_49, 4_72_82, 4_91_46, 5_02_57, 5_03_59, 5_03_60, 5_03_61
]
lowercase__		:     str			=							[
    1, 2, 7, 8, 9, 10, 14, 25,
    26, 27, 28, 29, 31, 58, 59, 60, 61, 62,
    63, 90, 91, 92, 93, 3_59, 5_03, 5_22, 5_42, 8_73,
    8_93, 9_02, 9_18, 9_22, 9_31, 13_50, 18_53, 19_82, 24_60, 26_27,
    32_46, 32_53, 32_68, 35_36, 38_46, 39_61, 41_83, 46_67, 65_85, 66_47,
    72_73, 90_61, 93_83, 1_04_28, 1_09_29, 1_19_38, 1_20_33, 1_23_31, 1_25_62, 1_37_93,
    1_41_57, 1_46_35, 1_52_65, 1_56_18, 1_65_53, 1_66_04, 1_83_62, 1_89_56, 2_00_75, 2_16_75,
    2_25_20, 2_61_30, 2_61_61, 2_64_35, 2_82_79, 2_94_64, 3_16_50, 3_23_02, 3_24_70, 3_68_65,
    4_28_63, 4_74_25, 4_98_70, 5_02_54, 5_02_58, 5_03_60, 5_03_61, 5_03_62
]
class 							__lowerCAmelCase	(       __magic_name__					):






       """simple docstring"""
       _snake_case      :	Optional[int]									=       'whisper'
       _snake_case      :	Union[str, Any]									=       ['past_key_values']
       _snake_case      :	Union[str, Any]									=       {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}





       def __init__(				self  :						Tuple			,					lowerCAmelCase__  :						List[str]=51865			,					lowerCAmelCase__  :						Optional[Any]=80			,					lowerCAmelCase__  :						Optional[int]=6			,					lowerCAmelCase__  :						List[Any]=4			,					lowerCAmelCase__  :						Any=6			,					lowerCAmelCase__  :						List[Any]=4			,					lowerCAmelCase__  :						List[Any]=1536			,					lowerCAmelCase__  :						Dict=1536			,					lowerCAmelCase__  :						int=0.0			,					lowerCAmelCase__  :						Optional[Any]=0.0			,					lowerCAmelCase__  :						int=50257			,					lowerCAmelCase__  :						Tuple=True			,					lowerCAmelCase__  :						Optional[Any]=True			,					lowerCAmelCase__  :						Optional[int]="gelu"			,					lowerCAmelCase__  :						Optional[int]=256			,					lowerCAmelCase__  :						Any=0.0			,					lowerCAmelCase__  :						Tuple=0.0			,					lowerCAmelCase__  :						Optional[Any]=0.0			,					lowerCAmelCase__  :						str=0.02			,					lowerCAmelCase__  :						Dict=False			,					lowerCAmelCase__  :						int=1500			,					lowerCAmelCase__  :						int=448			,					lowerCAmelCase__  :						Union[str, Any]=50256			,					lowerCAmelCase__  :						str=50256			,					lowerCAmelCase__  :						Optional[int]=50256			,					lowerCAmelCase__  :						List[str]=None			,					lowerCAmelCase__  :						Optional[int]=[220, 50256]			,					lowerCAmelCase__  :						List[Any]=False			,					lowerCAmelCase__  :						str=256			,					lowerCAmelCase__  :						Optional[Any]=False			,					lowerCAmelCase__  :						Any=0.05			,					lowerCAmelCase__  :						Optional[int]=10			,					lowerCAmelCase__  :						Dict=2			,					lowerCAmelCase__  :						int=0.0			,					lowerCAmelCase__  :						Dict=10			,					lowerCAmelCase__  :						List[str]=0			,					lowerCAmelCase__  :						List[Any]=7			,					**lowerCAmelCase__  :						List[str]			,					)       ->	Any:

            '''simple docstring'''




            _UpperCamelCase							       =			vocab_size
            _UpperCamelCase							       =			num_mel_bins
            _UpperCamelCase							       =			d_model
            _UpperCamelCase							       =			encoder_layers
            _UpperCamelCase							       =			encoder_attention_heads
            _UpperCamelCase							       =			decoder_layers
            _UpperCamelCase							       =			decoder_attention_heads
            _UpperCamelCase							       =			decoder_ffn_dim
            _UpperCamelCase							       =			encoder_ffn_dim
            _UpperCamelCase							       =			dropout
            _UpperCamelCase							       =			attention_dropout
            _UpperCamelCase							       =			activation_dropout
            _UpperCamelCase							       =			activation_function
            _UpperCamelCase							       =			init_std
            _UpperCamelCase							       =			encoder_layerdrop
            _UpperCamelCase							       =			decoder_layerdrop
            _UpperCamelCase							       =			use_cache
            _UpperCamelCase							       =			encoder_layers
            _UpperCamelCase							       =			scale_embedding  # scale factor will be sqrt(d_model) if True
            _UpperCamelCase							       =			max_source_positions
            _UpperCamelCase							       =			max_target_positions

            # Audio Classification-specific parameters. Feel free to ignore for other classes.
            _UpperCamelCase							       =			classifier_proj_size
            _UpperCamelCase							       =			use_weighted_layer_sum

            # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
            _UpperCamelCase							       =			apply_spec_augment
            _UpperCamelCase							       =			mask_time_prob
            _UpperCamelCase							       =			mask_time_length
            _UpperCamelCase							       =			mask_time_min_masks
            _UpperCamelCase							       =			mask_feature_prob
            _UpperCamelCase							       =			mask_feature_length
            _UpperCamelCase							       =			mask_feature_min_masks

            _UpperCamelCase							       =			median_filter_width

            super().__init__(
                pad_token_id=lowerCAmelCase__			,					bos_token_id=lowerCAmelCase__			,					eos_token_id=lowerCAmelCase__			,					is_encoder_decoder=lowerCAmelCase__			,					decoder_start_token_id=lowerCAmelCase__			,					suppress_tokens=lowerCAmelCase__			,					begin_suppress_tokens=lowerCAmelCase__			,					**lowerCAmelCase__			,					)

class 							__lowerCAmelCase	(       __magic_name__					):






       """simple docstring"""





       @property
       def snake_case__		(				self  :						Optional[Any]	)       ->	Mapping[str, Mapping[int, str]]:

            '''simple docstring'''




            _UpperCamelCase							       =			OrderedDict(
                [
                    ('''input_features''', {0: '''batch''', 1: '''feature_size''', 2: '''encoder_sequence'''}),
                ]	)
            if self.use_past:
                 _UpperCamelCase							       =			{0: '''batch'''}
            else:
                 _UpperCamelCase							       =			{0: '''batch''', 1: '''decoder_sequence'''}

            if self.use_past:
                 self.fill_with_past_key_values_(lowerCAmelCase__			,					direction='''inputs'''	)

            return common_inputs





       def snake_case__		(				self  :						Dict			,					lowerCAmelCase__  :						Union["PreTrainedTokenizerBase", "FeatureExtractionMixin"]			,					lowerCAmelCase__  :						int = -1			,					lowerCAmelCase__  :						int = -1			,					lowerCAmelCase__  :						bool = False			,					lowerCAmelCase__  :						Optional["TensorType"] = None			,					lowerCAmelCase__  :						int = 22050			,					lowerCAmelCase__  :						float = 5.0			,					lowerCAmelCase__  :						int = 220			,					)       ->	Mapping[str, Any]:

            '''simple docstring'''




            _UpperCamelCase							       =			OrderedDict()
            _UpperCamelCase							       =			OnnxConfig.generate_dummy_inputs(
                self			,					preprocessor=preprocessor.feature_extractor			,					batch_size=lowerCAmelCase__			,					framework=lowerCAmelCase__			,					sampling_rate=lowerCAmelCase__			,					time_duration=lowerCAmelCase__			,					frequency=lowerCAmelCase__			,					)
            _UpperCamelCase							       =			encoder_inputs['''input_features'''].shape[2]
            _UpperCamelCase							       =			encoder_sequence_length // 2 if self.use_past else seq_length

            _UpperCamelCase							       =			super().generate_dummy_inputs(
                preprocessor.tokenizer			,					lowerCAmelCase__			,					lowerCAmelCase__			,					lowerCAmelCase__			,					lowerCAmelCase__	)

            _UpperCamelCase							       =			encoder_inputs.pop('''input_features'''	)
            _UpperCamelCase							       =			decoder_inputs.pop('''decoder_input_ids'''	)

            if "past_key_values" in decoder_inputs:
                 _UpperCamelCase							       =			decoder_inputs.pop('''past_key_values'''	)

            return dummy_inputs







       @property
       def snake_case__		(				self  :						List[Any]	)       ->	float:

            '''simple docstring'''




            return 1e-3



