
'''simple docstring'''







import argparse
import struct
import unittest


class 		__UpperCAmelCase :


							def __init__(			self       ,  lowerCAmelCase_    ):





								"""simple docstring"""






								_snake_case  		=						data

								# Initialize hash values
								_snake_case  		=						[
								    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
								_snake_case  		=						[
								    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,
								]

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


							@staticmethod
							def 					lowerCamelCase							(			lowerCAmelCase_    ):





								"""simple docstring"""






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


							def 					lowerCamelCase							(			self    ):





								"""simple docstring"""






								_snake_case  		=						[
								    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
									_snake_case  		=						list(struct.unpack('>16L'       ,  lowerCAmelCase_    )    )
									# add 48 0-ed integers
									words += [0] * 48

									_snake_case		,					_snake_case		,					_snake_case		,					_snake_case		,					_snake_case		,					_snake_case		,					_snake_case		,					_snake_case  		=						self.hashes

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

											_snake_case  		=						(
											    words[index - 16] + sa + words[index - 7] + sa
											) % 0X1_0_0_0_0_0_0_0_0

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

										_snake_case		,					_snake_case		,					_snake_case		,					_snake_case		,					_snake_case		,					_snake_case		,					_snake_case		,					_snake_case  		=						(
										    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),
										)

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

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

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




							def 					lowerCamelCase							(			self       ,  lowerCAmelCase_       ,  lowerCAmelCase_    ):





								"""simple docstring"""






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


class 		__UpperCAmelCase (   unittest.TestCase		):


							def 					lowerCamelCase							(			self    ):





								"""simple docstring"""






								import hashlib

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







def 							SCREAMING_SNAKE_CASE__      (  )			->      int:
	import doctest

	doctest.testmod()

	_snake_case  		=						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'      )

	_snake_case  		=						parser.parse_args()

	_snake_case  		=						args.input_string

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

	print(SHAaaa(__A      ).hash      )


if __name__ == "__main__":
					main()








"""simple docstring"""





import logging
import os

from .state import PartialState

class 						lowercase   (   logging.LoggerAdapter   ):





      @staticmethod
      def        _snake_case     (			lowercase					)						->	Optional[Any]:
            lowerCAmelCase    		=			PartialState()
            return not main_process_only or (main_process_only and state.is_main_process)





      def        _snake_case     (			self ,		lowercase ,		lowercase ,		*lowercase ,		**lowercase					)						->	Dict:
            if PartialState._shared_state == {}:
                  raise RuntimeError(
                      """You must initialize the accelerate state by calling either `PartialState()` or `Accelerator()` before using the logging utility."""					)
            lowerCAmelCase    		=			kwargs.pop("""main_process_only""" ,		lowercase					)
            lowerCAmelCase    		=			kwargs.pop("""in_order""" ,		lowercase					)

            if self.isEnabledFor(lowercase					):
                  if self._should_log(lowercase					):
                        lowerCAmelCase		,						lowerCAmelCase    		=			self.process(lowercase ,		lowercase					)
                        self.logger.log(lowercase ,		lowercase ,		*lowercase ,		**lowercase					)

                  elif in_order:
                        lowerCAmelCase    		=			PartialState()
                        for i in range(state.num_processes					):
                              if i == state.process_index:
                                    lowerCAmelCase		,						lowerCAmelCase    		=			self.process(lowercase ,		lowercase					)
                                    self.logger.log(lowercase ,		lowercase ,		*lowercase ,		**lowercase					)
                              state.wait_for_everyone()







def      UpperCAmelCase__				(    SCREAMING_SNAKE_CASE	:		str				,		SCREAMING_SNAKE_CASE	:		str = None     ):







      '''simple docstring'''




      if log_level is None:
            lowerCAmelCase    		=			os.environ.get("""ACCELERATE_LOG_LEVEL"""				,		SCREAMING_SNAKE_CASE     )
      lowerCAmelCase    		=			logging.getLogger(SCREAMING_SNAKE_CASE     )
      if log_level is not None:
            logger.setLevel(log_level.upper()     )
            logger.root.setLevel(log_level.upper()     )
      return MultiProcessAdapter(SCREAMING_SNAKE_CASE				,		{}     )






