





import argparse
import struct
import unittest

class      lowerCAmelCase							:
 def __init__(   self						:   str    ,  UpperCAmelCase						:   bytes			)    ->			None:
     lowerCamelCase__					:   List[str]      				=	data

     # Initialize hash values
     lowerCamelCase__					:   str      				=	[
         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__					:   Optional[int]      				=	[
         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__					:   Union[str, Any]      				=	self.preprocessing(self.data			)
     self.final_hash()
 @staticmethod
 def   A_			(   UpperCAmelCase						:   bytes			)    ->			bytes:
     lowerCamelCase__					:   Union[str, Any]      				=	B'\x80' + (B'\x00' * (63 - (len(UpperCAmelCase			) + 8) % 64))
     lowerCamelCase__					:   Optional[Any]      				=	struct.pack('>Q'    ,  (len(UpperCAmelCase			) * 8)			)
     return data + padding + big_endian_integer
 def   A_			(   self						:   List[Any]			)    ->			None:
     # Convert into blocks of 64 bytes
     lowerCamelCase__					:   str      				=	[
         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__					:   str      				=	list(struct.unpack('>16L'    ,  UpperCAmelCase			)			)
         # add 48 0-ed integers
         words += [0] * 48

         lowerCamelCase__					:   List[str]      				=	self.hashes

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

                 lowerCamelCase__					:   Dict      				=	(
                     words[index - 16] + sa + words[index - 7] + sa
                 ) % 0X100_000_000

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

             lowerCamelCase__					:   Optional[int]      				=	(
                 g,
                 f,
                 e,
                 ((d + tempa) % 0X100_000_000),
                 c,
                 b,
                 a,
                 ((tempa + tempa) % 0X100_000_000),
             )

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

         # Modify final values
         lowerCamelCase__					:   List[str]      				=	[
             ((element + mutated_hash_values[index]) % 0X100_000_000)
             for index, element in enumerate(self.hashes			)
         ]

     lowerCamelCase__					:   str      				=	''.join([hex(UpperCAmelCase			)[2:].zfill(8			) for value in self.hashes]			)







 def   A_			(   self						:   Any    ,  UpperCAmelCase						:   int    ,  UpperCAmelCase						:   int			)    ->			int:
     return 0XFF_FFF_FFF & (value << (32 - rotations)) | (value >> rotations)


class      lowerCAmelCase							(      unittest.TestCase    ):
 def   A_			(   self						:   Any			)    ->			None:
     import hashlib

     lowerCamelCase__					:   Union[str, Any]      				=	bytes('Test String'    ,  'utf-8'			)
     self.assertEqual(SHAaaa(UpperCAmelCase			).hash    ,  hashlib.shaaaa(UpperCAmelCase			).hexdigest()			)


def  SCREAMING_SNAKE_CASE   ( )    ->  None:
    import doctest

    doctest.testmod()

    lowerCamelCase__					:   Union[str, Any]      				=	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__					:   Optional[int]      				=	parser.parse_args()

    lowerCamelCase__					:   Any      				=	args.input_string

    # hash input should be a bytestring
    if args.input_file:
        with open(args.input_file		,			'rb'				) as f:
            lowerCamelCase__					:   str      				=	f.read()
    else:
        lowerCamelCase__					:   Optional[Any]      				=	bytes(_UpperCAmelCase		,			'utf-8'				)

    print(SHAaaa(_UpperCAmelCase				).hash				)


if __name__ == "__main__":
 main()












from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


_UpperCAmelCase       : Optional[Any]			     =       {
    """configuration_clip""": [
        """CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """CLIPConfig""",
        """CLIPOnnxConfig""",
        """CLIPTextConfig""",
        """CLIPVisionConfig""",
    ],
    """processing_clip""": ["""CLIPProcessor"""],
    """tokenization_clip""": ["""CLIPTokenizer"""],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _UpperCAmelCase       : int			     =       ["""CLIPTokenizerFast"""]

try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _UpperCAmelCase       : Optional[int]			     =       ["""CLIPFeatureExtractor"""]
    _UpperCAmelCase       : Union[str, Any]			     =       ["""CLIPImageProcessor"""]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _UpperCAmelCase       : int			     =       [
        """CLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """CLIPModel""",
        """CLIPPreTrainedModel""",
        """CLIPTextModel""",
        """CLIPTextModelWithProjection""",
        """CLIPVisionModel""",
        """CLIPVisionModelWithProjection""",
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _UpperCAmelCase       : Tuple			     =       [
        """TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """TFCLIPModel""",
        """TFCLIPPreTrainedModel""",
        """TFCLIPTextModel""",
        """TFCLIPVisionModel""",
    ]

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _UpperCAmelCase       : Optional[int]			     =       [
        """FlaxCLIPModel""",
        """FlaxCLIPPreTrainedModel""",
        """FlaxCLIPTextModel""",
        """FlaxCLIPTextPreTrainedModel""",
        """FlaxCLIPVisionModel""",
        """FlaxCLIPVisionPreTrainedModel""",
    ]


if TYPE_CHECKING:
    from .configuration_clip import (
        CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
        CLIPConfig,
        CLIPOnnxConfig,
        CLIPTextConfig,
        CLIPVisionConfig,
    )
    from .processing_clip import CLIPProcessor
    from .tokenization_clip import CLIPTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_clip_fast import CLIPTokenizerFast

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_clip import CLIPFeatureExtractor
        from .image_processing_clip import CLIPImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_clip import (
            CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
            CLIPModel,
            CLIPPreTrainedModel,
            CLIPTextModel,
            CLIPTextModelWithProjection,
            CLIPVisionModel,
            CLIPVisionModelWithProjection,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_clip import (
            TF_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFCLIPModel,
            TFCLIPPreTrainedModel,
            TFCLIPTextModel,
            TFCLIPVisionModel,
        )

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_clip import (
            FlaxCLIPModel,
            FlaxCLIPPreTrainedModel,
            FlaxCLIPTextModel,
            FlaxCLIPTextPreTrainedModel,
            FlaxCLIPVisionModel,
            FlaxCLIPVisionPreTrainedModel,
        )


else:
    import sys

    _UpperCAmelCase       : Optional[Any]			     =       _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





