






import argparse
import struct
import unittest



class 				_UpperCamelCase      :


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

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

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


      @staticmethod
      def 			__UpperCAmelCase		(						__UpperCamelCase						)->						bytes:
           __lowerCAmelCase             =       b"\x80" + (b"\x00" * (6_3 - (len(_UpperCamelCase						) + 8) % 6_4))
           __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 + 6_4]
               for x in range(0       ,    len(self.preprocessed_data						)       ,    6_4						)
           ]

           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] * 4_8

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

                for index in range(0       ,    6_4						):
                     if index > 1_5:
                          # modify the zero-ed indexes at the end of the array
                          __lowerCAmelCase             =       (
                              self.ror(words[index - 1_5]       ,    7						)
                              ^ self.ror(words[index - 1_5]       ,    1_8						)
                              ^ (words[index - 1_5] >> 3)
                          )
                          __lowerCAmelCase             =       (
                              self.ror(words[index - 2]       ,    1_7						)
                              ^ self.ror(words[index - 2]       ,    1_9						)
                              ^ (words[index - 2] >> 1_0)
                          )

                          __lowerCAmelCase             =       (
                              words[index - 1_6] + sa + words[index - 7] + sa
                          ) % 0x100_000_000

                     # Compression
                     __lowerCAmelCase             =       self.ror(_UpperCamelCase       ,    6						) ^ self.ror(_UpperCamelCase       ,    1_1						) ^ self.ror(_UpperCamelCase       ,    2_5						)
                     __lowerCAmelCase             =       (e & f) ^ ((~e & 0xFF_FFF_FFF) & g)
                     __lowerCAmelCase             =       (
                         h + sa + ch + self.round_constants[index] + words[index]
                     ) % 0x100_000_000
                     __lowerCAmelCase             =       self.ror(_UpperCamelCase       ,    2						) ^ self.ror(_UpperCamelCase       ,    1_3						) ^ self.ror(_UpperCamelCase       ,    2_2						)
                     __lowerCAmelCase             =       (a & b) ^ (a & c) ^ (b & c)
                     __lowerCAmelCase             =       (sa + maj) % 0x100_000_000

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

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

                # Modify final values
                __lowerCAmelCase             =       [
                    ((element + mutated_hash_values[index]) % 0x100_000_000)
                    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 0xFF_FFF_FFF & (value << (3_2 - 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   (    ):
     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()








from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available





@dataclass
class       _lowerCAmelCase   (      __a			):
				_lowercase     						=42
				_lowercase     						=42


if is_transformers_available() and is_torch_available():
			from .pipeline_semantic_stable_diffusion import SemanticStableDiffusionPipeline



