



import argparse
import struct
import unittest


class  SCREAMING_SNAKE_CASE			:
     '''simple docstring'''


     def __init__(				self       :	List[str]					, UpperCAmelCase_       :	bytes      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    data

       # Initialize hash values
       SCREAMING_SNAKE_CASE       :      int							=    [
           0X6A_09_E6_67,
           0XBB_67_AE_85,
           0X3C_6E_F3_72,
           0XA5_4F_F5_3A,
           0X51_0E_52_7F,
           0X9B_05_68_8C,
           0X1F_83_D9_AB,
           0X5B_E0_CD_19,
       ]

       # Initialize round constants
       SCREAMING_SNAKE_CASE       :      List[str]							=    [
           0X42_8A_2F_98,
           0X71_37_44_91,
           0XB5_C0_FB_CF,
           0XE9_B5_DB_A5,
           0X39_56_C2_5B,
           0X59_F1_11_F1,
           0X92_3F_82_A4,
           0XAB_1C_5E_D5,
           0XD8_07_AA_98,
           0X12_83_5B_01,
           0X24_31_85_BE,
           0X55_0C_7D_C3,
           0X72_BE_5D_74,
           0X80_DE_B1_FE,
           0X9B_DC_06_A7,
           0XC1_9B_F1_74,
           0XE4_9B_69_C1,
           0XEF_BE_47_86,
           0X0F_C1_9D_C6,
           0X24_0C_A1_CC,
           0X2D_E9_2C_6F,
           0X4A_74_84_AA,
           0X5C_B0_A9_DC,
           0X76_F9_88_DA,
           0X98_3E_51_52,
           0XA8_31_C6_6D,
           0XB0_03_27_C8,
           0XBF_59_7F_C7,
           0XC6_E0_0B_F3,
           0XD5_A7_91_47,
           0X06_CA_63_51,
           0X14_29_29_67,
           0X27_B7_0A_85,
           0X2E_1B_21_38,
           0X4D_2C_6D_FC,
           0X53_38_0D_13,
           0X65_0A_73_54,
           0X76_6A_0A_BB,
           0X81_C2_C9_2E,
           0X92_72_2C_85,
           0XA2_BF_E8_A1,
           0XA8_1A_66_4B,
           0XC2_4B_8B_70,
           0XC7_6C_51_A3,
           0XD1_92_E8_19,
           0XD6_99_06_24,
           0XF4_0E_35_85,
           0X10_6A_A0_70,
           0X19_A4_C1_16,
           0X1E_37_6C_08,
           0X27_48_77_4C,
           0X34_B0_BC_B5,
           0X39_1C_0C_B3,
           0X4E_D8_AA_4A,
           0X5B_9C_CA_4F,
           0X68_2E_6F_F3,
           0X74_8F_82_EE,
           0X78_A5_63_6F,
           0X84_C8_78_14,
           0X8C_C7_02_08,
           0X90_BE_FF_FA,
           0XA4_50_6C_EB,
           0XBE_F9_A3_F7,
           0XC6_71_78_F2,
       ]

       SCREAMING_SNAKE_CASE       :      Optional[int]							=    self.preprocessing(self.data      )
       self.final_hash()


     @staticmethod
     def 				_A       (				UpperCAmelCase_       :	bytes      ):
       SCREAMING_SNAKE_CASE       :      Tuple							=    B'''\x80''' + (B'''\x00''' * (63 - (len(UpperCamelCase__      ) + 8) % 64))
       SCREAMING_SNAKE_CASE       :      int							=    struct.pack(">Q"					, (len(UpperCamelCase__      ) * 8)      )
       return data + padding + big_endian_integer


     def 				_A       (				self       :	Union[str, Any]      ):
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    [
           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
         SCREAMING_SNAKE_CASE       :      Optional[Any]							=    list(struct.unpack(">16L"					, UpperCamelCase__      )      )
         # add 48 0-ed integers
         words += [0] * 48

         SCREAMING_SNAKE_CASE       :      Dict							=    self.hashes

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

             SCREAMING_SNAKE_CASE       :      Any							=    (
                 words[index - 16] + sa + words[index - 7] + sa
             ) % 0X1_00_00_00_00

           # Compression
           SCREAMING_SNAKE_CASE       :      Any							=    self.ror(UpperCamelCase__					, 6      ) ^ self.ror(UpperCamelCase__					, 11      ) ^ self.ror(UpperCamelCase__					, 25      )
           SCREAMING_SNAKE_CASE       :      List[str]							=    (e & f) ^ ((~e & 0XFF_FF_FF_FF) & g)
           SCREAMING_SNAKE_CASE       :      Optional[int]							=    (
               h + sa + ch + self.round_constants[index] + words[index]
           ) % 0X1_00_00_00_00
           SCREAMING_SNAKE_CASE       :      List[Any]							=    self.ror(UpperCamelCase__					, 2      ) ^ self.ror(UpperCamelCase__					, 13      ) ^ self.ror(UpperCamelCase__					, 22      )
           SCREAMING_SNAKE_CASE       :      str							=    (a & b) ^ (a & c) ^ (b & c)
           SCREAMING_SNAKE_CASE       :      Tuple							=    (sa + maj) % 0X1_00_00_00_00

           SCREAMING_SNAKE_CASE       :      Tuple							=    (
               g,
               f,
               e,
               ((d + tempa) % 0X1_00_00_00_00),
               c,
               b,
               a,
               ((tempa + tempa) % 0X1_00_00_00_00),
           )

         SCREAMING_SNAKE_CASE       :      Any							=    [a, b, c, d, e, f, g, h]

         # Modify final values
         SCREAMING_SNAKE_CASE       :      Tuple							=    [
             ((element + mutated_hash_values[index]) % 0X1_00_00_00_00)
             for index, element in enumerate(self.hashes      )
         ]

       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    ''''''.join([hex(UpperCamelCase__      )[2:].zfill(8      ) for value in self.hashes]      )






     def 				_A       (				self       :	Union[str, Any]					, UpperCAmelCase_       :	int					, UpperCAmelCase_       :	int      ):
       return 0XFF_FF_FF_FF & (value << (32 - rotations)) | (value >> rotations)





class  SCREAMING_SNAKE_CASE			(			unittest.TestCase					):
     '''simple docstring'''


     def 				_A       (				self       :	Optional[Any]      ):
       import hashlib

       SCREAMING_SNAKE_CASE       :      Dict							=    bytes("Test String"					, "utf-8"      )
       self.assertEqual(SHAaaa(UpperCamelCase__      ).hash					, hashlib.shaaaa(UpperCamelCase__      ).hexdigest()      )





def   lowerCamelCase__			(     ):

  """simple docstring"""






  import doctest

  doctest.testmod()

  SCREAMING_SNAKE_CASE       :      Optional[int]							=    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"				)

  SCREAMING_SNAKE_CASE       :      Optional[int]							=    parser.parse_args()

  SCREAMING_SNAKE_CASE       :      Dict							=    args.input_string

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

  print(SHAaaa(_lowercase				).hash				)


if __name__ == "__main__":
   main()














import numpy as np
import torch
import torch.nn as nn
from transformers import CLIPConfig, CLIPVisionModelWithProjection, PreTrainedModel

from ...utils import logging


snake_case    				=		logging.get_logger(__name__)


class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Union[str, Any]			=	CLIPConfig

     UpperCamelCase_							:		Optional[int]			=	['''CLIPEncoderLayer''']


     def __init__(				self       :	List[Any]					, UpperCAmelCase_       :	CLIPConfig      ):
       super().__init__(UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE       :      Any							=    CLIPVisionModelWithProjection(config.vision_config      )

       SCREAMING_SNAKE_CASE       :      List[Any]							=    nn.Linear(config.vision_config.projection_dim					, 1      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    nn.Linear(config.vision_config.projection_dim					, 1      )






     @torch.no_grad()
     def 				_A       (				self       :	Union[str, Any]					, UpperCAmelCase_       :	int					, UpperCAmelCase_       :	Dict					, UpperCAmelCase_       :	List[Any]=0.5					, UpperCAmelCase_       :	Optional[Any]=0.5      ):
       SCREAMING_SNAKE_CASE       :      str							=    self.vision_model(UpperCAmelCase_      )[0]

       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    self.p_head(UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    nsfw_detected.flatten()
       SCREAMING_SNAKE_CASE       :      List[str]							=    nsfw_detected > p_threshold
       SCREAMING_SNAKE_CASE       :      List[Any]							=    nsfw_detected.tolist()

       if any(UpperCAmelCase_      ):
         logger.warning(
             "Potential NSFW content was detected in one or more images. A black image will be returned instead."
             " Try again with a different prompt and/or seed."      )

       for idx, nsfw_detected_ in enumerate(UpperCAmelCase_      ):
         if nsfw_detected_:
           SCREAMING_SNAKE_CASE       :      Dict							=    np.zeros(images[idx].shape      )

       SCREAMING_SNAKE_CASE       :      Any							=    self.w_head(UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      List[Any]							=    watermark_detected.flatten()
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    watermark_detected > w_threshold
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    watermark_detected.tolist()

       if any(UpperCAmelCase_      ):
         logger.warning(
             "Potential watermarked content was detected in one or more images. A black image will be returned instead."
             " Try again with a different prompt and/or seed."      )

       for idx, watermark_detected_ in enumerate(UpperCAmelCase_      ):
         if watermark_detected_:
           SCREAMING_SNAKE_CASE       :      Optional[int]							=    np.zeros(images[idx].shape      )

       return images, nsfw_detected, watermark_detected






