






'''simple docstring'''




from __future__ import annotations

from collections.abc import Iterator
from typing import Generic, TypeVar

lowerCAmelCase__          =						TypeVar('T')







class       __lowercase					(Generic[T]    ):

	def __init__(      self   :						Union[str, Any]  ,					UpperCAmelCase_   :						T):
			UpperCamelCase__				:					Tuple					=					data
			UpperCamelCase__				:					Node[T] | None					=					None





	def __str__(      self   :						str):
			return F'{self.data}'







class       __lowercase					(Generic[T]    ):

	def __init__(      self   :						Tuple):
			UpperCamelCase__				:					Node[T] | None					=					None

	def __iter__(      self   :						Any):
			UpperCamelCase__				:					List[Any]					=					self.top
			while node:
					yield node.data
					UpperCamelCase__				:					Union[str, Any]					=					node.next

	def __str__(      self   :						int):
			return "->".join([str(UpperCAmelCase_) for item in self])

	def __len__(      self   :						Optional[Any]):
			return len(tuple(iter(self)))

	def      __UpperCamelCase							(      self   :						Optional[Any]):
			return self.top is None

	def      __UpperCamelCase							(      self   :						List[Any]  ,					UpperCAmelCase_   :						T):
			UpperCamelCase__				:					Tuple					=					Node(UpperCAmelCase_)
			if not self.is_empty():
					UpperCamelCase__				:					Optional[int]					=					self.top
			UpperCamelCase__				:					List[Any]					=					node

	def      __UpperCamelCase							(      self   :						int):
			if self.is_empty():
					raise IndexError('pop from empty stack')
			assert isinstance(self.top  ,					UpperCAmelCase_)
			UpperCamelCase__				:					str					=					self.top
			UpperCamelCase__				:					Dict					=					self.top.next
			return pop_node.data

	def      __UpperCamelCase							(      self   :						Optional[Any]):
			if self.is_empty():
					raise IndexError('peek from empty stack')

			assert self.top is not None
			return self.top.data





	def      __UpperCamelCase							(      self   :						Any):
			UpperCamelCase__				:					Union[str, Any]					=					None


if __name__ == "__main__":
		from doctest import testmod

		testmod()












'''simple docstring'''




import argparse
import struct
import unittest







class       __lowercase					:

	def __init__(      self   :						Tuple  ,					UpperCAmelCase_   :						bytes):
			UpperCamelCase__				:					Dict					=					data

			# Initialize hash values
			UpperCamelCase__				:					Any					=					[
			    0X6A_09E_667,
			    0XBB_67A_E85,
			    0X3C_6EF_372,
			    0XA5_4FF_53A,
			    0X51_0E5_27F,
			    0X9B_056_88C,
			    0X1F_83D_9AB,
			    0X5B_E0C_D19,
			]

			# Initialize round constants
			UpperCamelCase__				:					List[Any]					=					[
			    0X42_8A2_F98,
			    0X71_374_491,
			    0XB5_C0F_BCF,
			    0XE9_B5D_BA5,
			    0X39_56C_25B,
			    0X59_F11_1F1,
			    0X92_3F8_2A4,
			    0XAB_1C5_ED5,
			    0XD8_07A_A98,
			    0X12_835_B01,
			    0X24_318_5BE,
			    0X55_0C7_DC3,
			    0X72_BE5_D74,
			    0X80_DEB_1FE,
			    0X9B_DC0_6A7,
			    0XC1_9BF_174,
			    0XE4_9B6_9C1,
			    0XEF_BE4_786,
			    0X0F_C19_DC6,
			    0X24_0CA_1CC,
			    0X2D_E92_C6F,
			    0X4A_748_4AA,
			    0X5C_B0A_9DC,
			    0X76_F98_8DA,
			    0X98_3E5_152,
			    0XA8_31C_66D,
			    0XB0_032_7C8,
			    0XBF_597_FC7,
			    0XC6_E00_BF3,
			    0XD5_A79_147,
			    0X06_CA6_351,
			    0X14_292_967,
			    0X27_B70_A85,
			    0X2E_1B2_138,
			    0X4D_2C6_DFC,
			    0X53_380_D13,
			    0X65_0A7_354,
			    0X76_6A0_ABB,
			    0X81_C2C_92E,
			    0X92_722_C85,
			    0XA2_BFE_8A1,
			    0XA8_1A6_64B,
			    0XC2_4B8_B70,
			    0XC7_6C5_1A3,
			    0XD1_92E_819,
			    0XD6_990_624,
			    0XF4_0E3_585,
			    0X10_6AA_070,
			    0X19_A4C_116,
			    0X1E_376_C08,
			    0X27_487_74C,
			    0X34_B0B_CB5,
			    0X39_1C0_CB3,
			    0X4E_D8A_A4A,
			    0X5B_9CC_A4F,
			    0X68_2E6_FF3,
			    0X74_8F8_2EE,
			    0X78_A56_36F,
			    0X84_C87_814,
			    0X8C_C70_208,
			    0X90_BEF_FFA,
			    0XA4_506_CEB,
			    0XBE_F9A_3F7,
			    0XC6_717_8F2,
			]

			UpperCamelCase__				:					Tuple					=					self.preprocessing(self.data)
			self.final_hash()

	@staticmethod
	def      __UpperCamelCase							(      UpperCAmelCase_   :						bytes):
			UpperCamelCase__				:					List[Any]					=					B'\x80' + (B'\x00' * (63 - (len(UpperCAmelCase_) + 8) % 64))
			UpperCamelCase__				:					List[Any]					=					struct.pack('>Q'  ,					(len(UpperCAmelCase_) * 8))
			return data + padding + big_endian_integer

	def      __UpperCamelCase							(      self   :						Union[str, Any]):
			# Convert into blocks of 64 bytes
			UpperCamelCase__				:					int					=					[
			    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
					UpperCamelCase__				:					Tuple					=					list(struct.unpack('>16L'  ,					UpperCAmelCase_))
					# add 48 0-ed integers
					words += [0] * 48

					UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__				:					str					=					self.hashes

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

									UpperCamelCase__				:					int					=					(
									    words[index - 16] + sa + words[index - 7] + sa
									) % 0X100_000_000

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

							UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__				:					Tuple					=					(
							    g,
							    f,
							    e,
							    ((d + tempa) % 0X100_000_000),
							    c,
							    b,
							    a,
							    ((tempa + tempa) % 0X100_000_000),
							)

					UpperCamelCase__				:					List[Any]					=					[a, b, c, d, e, f, g, h]

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

			UpperCamelCase__				:					Any					=					''.join([hex(UpperCAmelCase_)[2:].zfill(8) for value in self.hashes])





	def      __UpperCamelCase							(      self   :						int  ,					UpperCAmelCase_   :						int  ,					UpperCAmelCase_   :						int):
			return 0XFF_FFF_FFF & (value << (32 - rotations)) | (value >> rotations)







class       __lowercase					(unittest.TestCase    ):

	def      __UpperCamelCase							(      self   :						int):
			import hashlib

			UpperCamelCase__				:					str					=					bytes('Test String'  ,					'utf-8')
			self.assertEqual(SHAaaa(UpperCAmelCase_).hash  ,					hashlib.shaaaa(UpperCAmelCase_).hexdigest())







def       __UpperCAmelCase						(  )							->     None:
		import doctest

		doctest.testmod()

		UpperCamelCase__				:					Union[str, Any]					=					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')

		UpperCamelCase__				:					List[str]					=					parser.parse_args()

		UpperCamelCase__				:					str					=					args.input_string

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

		print(SHAaaa(lowerCamelCase_).hash)


if __name__ == "__main__":
		main()




