





import argparse
import struct
import unittest





class UpperCAmelCase_				:


  def __init__(							self ,__snake_case ):



       """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 						__UpperCAmelCase     (							__snake_case ):



       """simple docstring"""





       A_          =       B'''\x80''' + (B'''\x00''' * (6_3 - (len(__snake_case ) + 8) % 6_4))
       A_          =       struct.pack('''>Q''' ,(len(__snake_case ) * 8) )
       return data + padding + big_endian_integer


  def 						__UpperCAmelCase     (							self ):



       """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''' ,__snake_case ) )
            # 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(__snake_case ,6 ) ^ self.ror(__snake_case ,1_1 ) ^ self.ror(__snake_case ,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(__snake_case ,2 ) ^ self.ror(__snake_case ,1_3 ) ^ self.ror(__snake_case ,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(__snake_case )[2:].zfill(8 ) for value in self.hashes] )




  def 						__UpperCAmelCase     (							self ,__snake_case ,__snake_case ):



       """simple docstring"""





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





class UpperCAmelCase_				( unittest.TestCase ):


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       import hashlib

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




def      UpperCAmelCase_    (    )	->				None:
     '''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(_UpperCAmelCase  ,						'''utf-8'''				)

     print(SHAaaa(_UpperCAmelCase				).hash				)


if __name__ == "__main__":
      main()










import unittest

import numpy as np
import torch

from diffusers import VersatileDiffusionImageVariationPipeline
from diffusers.utils.testing_utils import load_image, require_torch_gpu, slow, torch_device


a__      :     Optional[int]         =		False





class UpperCAmelCase_				( unittest.TestCase ):
  pass





@slow
@require_torch_gpu
class UpperCAmelCase_				( unittest.TestCase ):


  def 						__UpperCAmelCase     (							self ):



       """simple docstring"""





       A_          =       VersatileDiffusionImageVariationPipeline.from_pretrained('''shi-labs/versatile-diffusion''' )
       pipe.to(__snake_case )
       pipe.set_progress_bar_config(disable=__snake_case )

       A_          =       load_image(
           '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/versatile_diffusion/benz.jpg''' )
       A_          =       torch.manual_seed(0 )
       A_          =       pipe(
           image=__snake_case ,generator=__snake_case ,guidance_scale=7.5 ,num_inference_steps=5_0 ,output_type='''numpy''' ,).images

       A_          =       image[0, 2_5_3:2_5_6, 2_5_3:2_5_6, -1]

       assert image.shape == (1, 5_1_2, 5_1_2, 3)
       A_          =       np.array([0.0441, 0.0469, 0.0507, 0.0575, 0.0632, 0.0650, 0.0865, 0.0909, 0.0945] )

       assert np.abs(image_slice.flatten() - expected_slice ).max() < 1E-2



