



'''simple docstring'''


import argparse
import struct
import unittest







class 	UpperCAmelCase	:


 '''simple docstring'''




 def __init__(   self							,  lowerCAmelCase_) ->      None:



      """simple docstring"""







      a_       		=data

      # Initialize hash values
      a_       		=[
          0x6a09_e667,
          0xbb67_ae85,
          0x3c6e_f372,
          0xa54f_f53a,
          0x510e_527f,
          0x9b05_688c,
          0x1f83_d9ab,
          0x5be0_cd19,
      ]

      # Initialize round constants
      a_       		=[
          0x428a_2f98,
          0x7137_4491,
          0xb5c0_fbcf,
          0xe9b5_dba5,
          0x3956_c25b,
          0x59f1_11f1,
          0x923f_82a4,
          0xab1c_5ed5,
          0xd807_aa98,
          0x1283_5b01,
          0x2431_85be,
          0x550c_7dc3,
          0x72be_5d74,
          0x80de_b1fe,
          0x9bdc_06a7,
          0xc19b_f174,
          0xe49b_69c1,
          0xefbe_4786,
          0x0fc1_9dc6,
          0x240c_a1cc,
          0x2de9_2c6f,
          0x4a74_84aa,
          0x5cb0_a9dc,
          0x76f9_88da,
          0x983e_5152,
          0xa831_c66d,
          0xb003_27c8,
          0xbf59_7fc7,
          0xc6e0_0bf3,
          0xd5a7_9147,
          0x06ca_6351,
          0x1429_2967,
          0x27b7_0a85,
          0x2e1b_2138,
          0x4d2c_6dfc,
          0x5338_0d13,
          0x650a_7354,
          0x766a_0abb,
          0x81c2_c92e,
          0x9272_2c85,
          0xa2bf_e8a1,
          0xa81a_664b,
          0xc24b_8b70,
          0xc76c_51a3,
          0xd192_e819,
          0xd699_0624,
          0xf40e_3585,
          0x106a_a070,
          0x19a4_c116,
          0x1e37_6c08,
          0x2748_774c,
          0x34b0_bcb5,
          0x391c_0cb3,
          0x4ed8_aa4a,
          0x5b9c_ca4f,
          0x682e_6ff3,
          0x748f_82ee,
          0x78a5_636f,
          0x84c8_7814,
          0x8cc7_0208,
          0x90be_fffa,
          0xa450_6ceb,
          0xbef9_a3f7,
          0xc671_78f2,
      ]

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




 @staticmethod
 def       lowercase_  (   lowerCAmelCase_) ->      bytes:



      """simple docstring"""







      a_       		=b"\x80" + (b"\x00" * (6_3 - (len(lowerCAmelCase_) + 8) % 6_4))
      a_       		=struct.pack(">Q"							,  (len(lowerCAmelCase_) * 8))
      return data + padding + big_endian_integer




 def       lowercase_  (   self) ->      None:



      """simple docstring"""







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

           a_		,						a_		,						a_		,						a_		,						a_		,						a_		,						a_		,						a_       		=self.hashes

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

                     a_       		=(
                         words[index - 1_6] + sa + words[index - 7] + sa
                     ) % 0x1_0000_0000

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

                a_		,						a_		,						a_		,						a_		,						a_		,						a_		,						a_		,						a_       		=(
                    g,
                    f,
                    e,
                    ((d + tempa) % 0x1_0000_0000),
                    c,
                    b,
                    a,
                    ((tempa + tempa) % 0x1_0000_0000),
                )

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

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

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




 def       lowercase_  (   self							,  lowerCAmelCase_							,  lowerCAmelCase_) ->      int:



      """simple docstring"""







      return 0xffff_ffff & (value << (3_2 - rotations)) | (value >> rotations)







class 	UpperCAmelCase	(		unittest.TestCase):


 '''simple docstring'''




 def       lowercase_  (   self) ->      None:



      """simple docstring"""







      import hashlib

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






def  UpperCAmelCase_       (		):


     '''simple docstring'''







     import doctest

     doctest.testmod()

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

     a_       		=parser.parse_args()

     a_       		=args.input_string

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

     print(SHAaaa(lowercase__       ).hash       )


if __name__ == "__main__":
  main()







'''simple docstring'''


import torch

from diffusers import StableDiffusionPipeline


lowercase							       =			'''path-to-your-trained-model'''
lowercase							       =			StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.floataa).to('''cuda''')

lowercase							       =			'''A photo of sks dog in a bucket'''
lowercase							       =			pipe(prompt, num_inference_steps=50, guidance_scale=7.5).images[0]

image.save('''dog-bucket.png''')


