





import argparse
import struct
import unittest



class  __lowerCAmelCase     :




 def __init__(						self	,				__UpperCAmelCase				):



    '''simple docstring'''
    __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        lowerCamelCase      (						__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    b'''\x80''' + (b'''\x00''' * (63 - (len(__UpperCamelCase				) + 8) % 64))
    __lowerCamelCase													=    struct.pack('''>Q'''	,				(len(__UpperCamelCase				) * 8)				)
    return data + padding + big_endian_integer




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    # Convert into blocks of 64 bytes
    __lowerCamelCase													=    [
        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
       __lowerCamelCase													=    list(struct.unpack('''>16L'''	,				__UpperCamelCase				)				)
       # add 48 0-ed integers
       words += [0] * 48

       __lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase													=    self.hashes

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

             __lowerCamelCase													=    (
                 words[index - 16] + sa + words[index - 7] + sa
             ) % 0X100_000_000

          # Compression
          __lowerCamelCase													=    self.ror(__UpperCamelCase	,				6				) ^ self.ror(__UpperCamelCase	,				11				) ^ self.ror(__UpperCamelCase	,				25				)
          __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	,				13				) ^ self.ror(__UpperCamelCase	,				22				)
          __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        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase				):



    '''simple docstring'''
    return 0Xff_fff_fff & (value << (32 - rotations)) | (value >> rotations)



class  __lowerCAmelCase     (	unittest.TestCase   ):




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    import hashlib

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





def 		a__			(		):
   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(_SCREAMING_SNAKE_CASE ,'''utf-8'''							)

   print(SHAaaa(_SCREAMING_SNAKE_CASE							).hash							)


if __name__ == "__main__":
  main()











from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a_			=					{
    """configuration_clipseg""": [
        """CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """CLIPSegConfig""",
        """CLIPSegTextConfig""",
        """CLIPSegVisionConfig""",
    ],
    """processing_clipseg""": ["""CLIPSegProcessor"""],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a_			=					[
      """CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """CLIPSegModel""",
      """CLIPSegPreTrainedModel""",
      """CLIPSegTextModel""",
      """CLIPSegVisionModel""",
      """CLIPSegForImageSegmentation""",
  ]

if TYPE_CHECKING:
  from .configuration_clipseg import (
      CLIPSEG_PRETRAINED_CONFIG_ARCHIVE_MAP,
      CLIPSegConfig,
      CLIPSegTextConfig,
      CLIPSegVisionConfig,
  )
  from .processing_clipseg import CLIPSegProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_clipseg import (
        CLIPSEG_PRETRAINED_MODEL_ARCHIVE_LIST,
        CLIPSegForImageSegmentation,
        CLIPSegModel,
        CLIPSegPreTrainedModel,
        CLIPSegTextModel,
        CLIPSegVisionModel,
    )

else:
  import sys

  a_			=					_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






