

import argparse
import struct
import unittest






class _UpperCamelCase							:
			'''simple docstring'''







			def __init__(	self							:       List[Any]					,					a							:       bytes		)							->				Optional[Any]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					Tuple    =				data

				# Initialize hash values
				SCREAMING_SNAKE_CASE      :					Union[str, 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
				SCREAMING_SNAKE_CASE      :					Optional[int]    =				[
				    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,
				]

				SCREAMING_SNAKE_CASE      :					Tuple    =				self.preprocessing(self.data		)
				self.final_hash()
			@staticmethod
			def 							__UpperCamelCase       (	a							:       bytes		)							->				List[str]:

				"""simple docstring"""

				SCREAMING_SNAKE_CASE      :					List[str]    =				B"\x80" + (B"\x00" * (63 - (len(__UpperCAmelCase		) + 8) % 64))
				SCREAMING_SNAKE_CASE      :					Dict    =				struct.pack(">Q"					,					(len(__UpperCAmelCase		) * 8)		)
				return data + padding + big_endian_integer
			def 							__UpperCamelCase       (	self							:       Any		)							->				Dict:

				"""simple docstring"""

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

					SCREAMING_SNAKE_CASE      :					Dict    =				self.hashes

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

							SCREAMING_SNAKE_CASE      :					Tuple    =				(
							    words[index - 16] + sa + words[index - 7] + sa
							) % 0x100_000_000

						# Compression
						SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				self.ror(__UpperCAmelCase					,					6		) ^ self.ror(__UpperCAmelCase					,					11		) ^ self.ror(__UpperCAmelCase					,					25		)
						SCREAMING_SNAKE_CASE      :					str    =				(e & f) ^ ((~e & 0xFF_FFF_FFF) & g)
						SCREAMING_SNAKE_CASE      :					Tuple    =				(
						    h + sa + ch + self.round_constants[index] + words[index]
						) % 0x100_000_000
						SCREAMING_SNAKE_CASE      :					List[Any]    =				self.ror(__UpperCAmelCase					,					2		) ^ self.ror(__UpperCAmelCase					,					13		) ^ self.ror(__UpperCAmelCase					,					22		)
						SCREAMING_SNAKE_CASE      :					Union[str, Any]    =				(a & b) ^ (a & c) ^ (b & c)
						SCREAMING_SNAKE_CASE      :					List[Any]    =				(sa + maj) % 0x100_000_000

						SCREAMING_SNAKE_CASE      :					Optional[Any]    =				(
						    g,
						    f,
						    e,
						    ((d + tempa) % 0x100_000_000),
						    c,
						    b,
						    a,
						    ((tempa + tempa) % 0x100_000_000),
						)

					SCREAMING_SNAKE_CASE      :					Dict    =				[a, b, c, d, e, f, g, h]

					# Modify final values
					SCREAMING_SNAKE_CASE      :					str    =				[
					    ((element + mutated_hash_values[index]) % 0x100_000_000)
					    for index, element in enumerate(self.hashes		)
					]

				SCREAMING_SNAKE_CASE      :					Dict    =				"".join([hex(__UpperCAmelCase		)[2:].zfill(8		) for value in self.hashes]		)






			def 							__UpperCamelCase       (	self							:       Optional[Any]					,					a							:       int					,					a							:       int		)							->				Tuple:

				"""simple docstring"""

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






class _UpperCamelCase							(							unittest.TestCase      ):
			'''simple docstring'''







			def 							__UpperCamelCase       (	self							:       Optional[int]		)							->				Optional[int]:

				"""simple docstring"""

				import hashlib

				SCREAMING_SNAKE_CASE      :					int    =				bytes("Test String"					,					"utf-8"		)
				self.assertEqual(SHAaaa(__UpperCAmelCase		).hash					,					hashlib.shaaaa(__UpperCAmelCase		).hexdigest()		)

def        lowerCamelCase__       (    ):
	import doctest

	doctest.testmod()

	SCREAMING_SNAKE_CASE      :					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")

	SCREAMING_SNAKE_CASE      :					int    =				parser.parse_args()

	SCREAMING_SNAKE_CASE      :					List[Any]    =				args.input_string

	# hash input should be a bytestring
	if args.input_file:
		with open(args.input_file							,	"rb") as f:
			SCREAMING_SNAKE_CASE      :					Tuple    =				f.read()
	else:
		SCREAMING_SNAKE_CASE      :					Optional[int]    =				bytes(A_							,	"utf-8")

	print(SHAaaa(A_).hash)


if __name__ == "__main__":
			main()



"""simple docstring"""







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tensorflow_text_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__lowercase    					=      {
    """configuration_bert""": ["""BERT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """BertConfig""", """BertOnnxConfig"""],
    """tokenization_bert""": ["""BasicTokenizer""", """BertTokenizer""", """WordpieceTokenizer"""],
}

try:
 if not is_tokenizers_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowercase    					=      ["""BertTokenizerFast"""]

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowercase    					=      [
     """BERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """BertForMaskedLM""",
     """BertForMultipleChoice""",
     """BertForNextSentencePrediction""",
     """BertForPreTraining""",
     """BertForQuestionAnswering""",
     """BertForSequenceClassification""",
     """BertForTokenClassification""",
     """BertLayer""",
     """BertLMHeadModel""",
     """BertModel""",
     """BertPreTrainedModel""",
     """load_tf_weights_in_bert""",
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowercase    					=      [
     """TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
     """TFBertEmbeddings""",
     """TFBertForMaskedLM""",
     """TFBertForMultipleChoice""",
     """TFBertForNextSentencePrediction""",
     """TFBertForPreTraining""",
     """TFBertForQuestionAnswering""",
     """TFBertForSequenceClassification""",
     """TFBertForTokenClassification""",
     """TFBertLMHeadModel""",
     """TFBertMainLayer""",
     """TFBertModel""",
     """TFBertPreTrainedModel""",
 ]
try:
 if not is_tensorflow_text_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowercase    					=      ["""TFBertTokenizer"""]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 __lowercase    					=      [
     """FlaxBertForCausalLM""",
     """FlaxBertForMaskedLM""",
     """FlaxBertForMultipleChoice""",
     """FlaxBertForNextSentencePrediction""",
     """FlaxBertForPreTraining""",
     """FlaxBertForQuestionAnswering""",
     """FlaxBertForSequenceClassification""",
     """FlaxBertForTokenClassification""",
     """FlaxBertModel""",
     """FlaxBertPreTrainedModel""",
 ]

if TYPE_CHECKING:
 from .configuration_bert import BERT_PRETRAINED_CONFIG_ARCHIVE_MAP, BertConfig, BertOnnxConfig
 from .tokenization_bert import BasicTokenizer, BertTokenizer, WordpieceTokenizer

 try:
  if not is_tokenizers_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_bert_fast import BertTokenizerFast

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_bert import (
      BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      BertForMaskedLM,
      BertForMultipleChoice,
      BertForNextSentencePrediction,
      BertForPreTraining,
      BertForQuestionAnswering,
      BertForSequenceClassification,
      BertForTokenClassification,
      BertLayer,
      BertLMHeadModel,
      BertModel,
      BertPreTrainedModel,
      load_tf_weights_in_bert,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_bert import (
      TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFBertEmbeddings,
      TFBertForMaskedLM,
      TFBertForMultipleChoice,
      TFBertForNextSentencePrediction,
      TFBertForPreTraining,
      TFBertForQuestionAnswering,
      TFBertForSequenceClassification,
      TFBertForTokenClassification,
      TFBertLMHeadModel,
      TFBertMainLayer,
      TFBertModel,
      TFBertPreTrainedModel,
  )

 try:
  if not is_tensorflow_text_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .tokenization_bert_tf import TFBertTokenizer

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_bert import (
      FlaxBertForCausalLM,
      FlaxBertForMaskedLM,
      FlaxBertForMultipleChoice,
      FlaxBertForNextSentencePrediction,
      FlaxBertForPreTraining,
      FlaxBertForQuestionAnswering,
      FlaxBertForSequenceClassification,
      FlaxBertForTokenClassification,
      FlaxBertModel,
      FlaxBertPreTrainedModel,
  )

else:
 import sys

 __lowercase    					=      _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






