



'''simple docstring'''



import argparse
import struct
import unittest






class 					UpperCAmelCase__	:



					def __init__(    self			,				UpperCamelCase     )     ->			None:
						__lowerCAmelCase												=  data

						# Initialize hash values
						__lowerCAmelCase												=  [
						    0x6_A_0_9_E_6_6_7,
						    0xB_B_6_7_A_E_8_5,
						    0x3_C_6_E_F_3_7_2,
						    0xA_5_4_F_F_5_3_A,
						    0x5_1_0_E_5_2_7_F,
						    0x9_B_0_5_6_8_8_C,
						    0x1_F_8_3_D_9_A_B,
						    0x5_B_E_0_C_D_1_9,
						]

						# Initialize round constants
						__lowerCAmelCase												=  [
						    0x4_2_8_A_2_F_9_8,
						    0x7_1_3_7_4_4_9_1,
						    0xB_5_C_0_F_B_C_F,
						    0xE_9_B_5_D_B_A_5,
						    0x3_9_5_6_C_2_5_B,
						    0x5_9_F_1_1_1_F_1,
						    0x9_2_3_F_8_2_A_4,
						    0xA_B_1_C_5_E_D_5,
						    0xD_8_0_7_A_A_9_8,
						    0x1_2_8_3_5_B_0_1,
						    0x2_4_3_1_8_5_B_E,
						    0x5_5_0_C_7_D_C_3,
						    0x7_2_B_E_5_D_7_4,
						    0x8_0_D_E_B_1_F_E,
						    0x9_B_D_C_0_6_A_7,
						    0xC_1_9_B_F_1_7_4,
						    0xE_4_9_B_6_9_C_1,
						    0xE_F_B_E_4_7_8_6,
						    0x0_F_C_1_9_D_C_6,
						    0x2_4_0_C_A_1_C_C,
						    0x2_D_E_9_2_C_6_F,
						    0x4_A_7_4_8_4_A_A,
						    0x5_C_B_0_A_9_D_C,
						    0x7_6_F_9_8_8_D_A,
						    0x9_8_3_E_5_1_5_2,
						    0xA_8_3_1_C_6_6_D,
						    0xB_0_0_3_2_7_C_8,
						    0xB_F_5_9_7_F_C_7,
						    0xC_6_E_0_0_B_F_3,
						    0xD_5_A_7_9_1_4_7,
						    0x0_6_C_A_6_3_5_1,
						    0x1_4_2_9_2_9_6_7,
						    0x2_7_B_7_0_A_8_5,
						    0x2_E_1_B_2_1_3_8,
						    0x4_D_2_C_6_D_F_C,
						    0x5_3_3_8_0_D_1_3,
						    0x6_5_0_A_7_3_5_4,
						    0x7_6_6_A_0_A_B_B,
						    0x8_1_C_2_C_9_2_E,
						    0x9_2_7_2_2_C_8_5,
						    0xA_2_B_F_E_8_A_1,
						    0xA_8_1_A_6_6_4_B,
						    0xC_2_4_B_8_B_7_0,
						    0xC_7_6_C_5_1_A_3,
						    0xD_1_9_2_E_8_1_9,
						    0xD_6_9_9_0_6_2_4,
						    0xF_4_0_E_3_5_8_5,
						    0x1_0_6_A_A_0_7_0,
						    0x1_9_A_4_C_1_1_6,
						    0x1_E_3_7_6_C_0_8,
						    0x2_7_4_8_7_7_4_C,
						    0x3_4_B_0_B_C_B_5,
						    0x3_9_1_C_0_C_B_3,
						    0x4_E_D_8_A_A_4_A,
						    0x5_B_9_C_C_A_4_F,
						    0x6_8_2_E_6_F_F_3,
						    0x7_4_8_F_8_2_E_E,
						    0x7_8_A_5_6_3_6_F,
						    0x8_4_C_8_7_8_1_4,
						    0x8_C_C_7_0_2_0_8,
						    0x9_0_B_E_F_F_F_A,
						    0xA_4_5_0_6_C_E_B,
						    0xB_E_F_9_A_3_F_7,
						    0xC_6_7_1_7_8_F_2,
						]

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



					@staticmethod
					def        UpperCAmelCase_ (    UpperCamelCase     )     ->			bytes:
						__lowerCAmelCase												=  b"\x80" + (b"\x00" * (63 - (len(UpperCamelCase     ) + 8) % 64))
						__lowerCAmelCase												=  struct.pack(">Q"			,				(len(UpperCamelCase     ) * 8)     )
						return data + padding + big_endian_integer



					def        UpperCAmelCase_ (    self     )     ->			None:
						# Convert into blocks of 64 bytes
						__lowerCAmelCase												=  [
						    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
							__lowerCAmelCase												=  list(struct.unpack(">16L"			,				UpperCamelCase     )     )
							# add 48 0-ed integers
							words += [0] * 48

							__lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase												=  self.hashes

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

									__lowerCAmelCase												=  (
									    words[index - 16] + sa + words[index - 7] + sa
									) % 0x1_0_0_0_0_0_0_0_0

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

								__lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase							,       __lowerCAmelCase												=  (
								    g,
								    f,
								    e,
								    ((d + tempa) % 0x1_0_0_0_0_0_0_0_0),
								    c,
								    b,
								    a,
								    ((tempa + tempa) % 0x1_0_0_0_0_0_0_0_0),
								)

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

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

						__lowerCAmelCase												=  "".join([hex(UpperCamelCase     )[2:].zfill(8     ) for value in self.hashes]     )



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






class 					UpperCAmelCase__	(		unittest.TestCase ):



					def        UpperCAmelCase_ (    self     )     ->			None:
						import hashlib

						__lowerCAmelCase												=  bytes("Test String"			,				"utf-8"     )
						self.assertEqual(SHAaaa(UpperCamelCase     ).hash			,				hashlib.shaaaa(UpperCamelCase     ).hexdigest()     )



def   __lowerCAmelCase					(							):






	'''simple docstring'''




	import doctest

	doctest.testmod()

	__lowerCAmelCase												=  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"					)

	__lowerCAmelCase												=  parser.parse_args()

	__lowerCAmelCase												=  args.input_string

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

	print(SHAaaa(lowerCamelCase					).hash					)


if __name__ == "__main__":
	main()




'''simple docstring'''



from argparse import ArgumentParser

from . import BaseTransformersCLICommand



def   __lowerCAmelCase					(							lowerCamelCase   :						List[str]					):






	'''simple docstring'''




	return DownloadCommand(args.model				,		args.cache_dir				,		args.force				,		args.trust_remote_code					)






class 					UpperCAmelCase__	(		UpperCamelCase__ ):



					@staticmethod
					def        UpperCAmelCase_ (    UpperCamelCase     )     ->			Tuple:
						__lowerCAmelCase												=  parser.add_parser("download"     )
						download_parser.add_argument(
						    "--cache-dir"			,				type=UpperCamelCase			,				default=UpperCamelCase			,				help="Path to location to store the models"     )
						download_parser.add_argument(
						    "--force"			,				action="store_true"			,				help="Force the model to be download even if already in cache-dir"     )
						download_parser.add_argument(
						    "--trust-remote-code"			,				action="store_true"			,				help="Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you've reviewed the code as it will execute on your local machine"			,				)
						download_parser.add_argument("model"			,				type=UpperCamelCase			,				help="Name of the model to download"     )
						download_parser.set_defaults(func=UpperCamelCase     )



					def __init__(    self			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase     )     ->			List[str]:
						__lowerCAmelCase												=  model
						__lowerCAmelCase												=  cache
						__lowerCAmelCase												=  force
						__lowerCAmelCase												=  trust_remote_code



					def        UpperCAmelCase_ (    self     )     ->			Any:
						from ..models.auto import AutoModel, AutoTokenizer

						AutoModel.from_pretrained(
						    self._model			,				cache_dir=self._cache			,				force_download=self._force			,				trust_remote_code=self._trust_remote_code     )
						AutoTokenizer.from_pretrained(
						    self._model			,				cache_dir=self._cache			,				force_download=self._force			,				trust_remote_code=self._trust_remote_code     )