





'''simple docstring'''

import argparse
import struct
import unittest
class 							__lowerCAmelCase	:






       """simple docstring"""





       def __init__(				self  :						Optional[int]			,					lowerCAmelCase__  :						bytes	)       ->	None:

            '''simple docstring'''




            _UpperCamelCase							       =			data

            # Initialize hash values
            _UpperCamelCase							       =			[
                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
            _UpperCamelCase							       =			[
                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,
            ]

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





       @staticmethod
       def snake_case__		(				lowerCAmelCase__  :						bytes	)       ->	bytes:

            '''simple docstring'''




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





       def snake_case__		(				self  :						Union[str, Any]	)       ->	None:

            '''simple docstring'''




            _UpperCamelCase							       =			[
                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
                 _UpperCamelCase							       =			list(struct.unpack('''>16L'''			,					lowerCAmelCase__	)	)
                 # add 48 0-ed integers
                 words += [0] * 48

                 _UpperCamelCase       ,							_UpperCamelCase       ,							_UpperCamelCase       ,							_UpperCamelCase       ,							_UpperCamelCase       ,							_UpperCamelCase       ,							_UpperCamelCase       ,							_UpperCamelCase							       =			self.hashes

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

                           _UpperCamelCase							       =			(
                               words[index - 16] + sa + words[index - 7] + sa
                           ) % 0X1_00_00_00_00

                      # Compression
                      _UpperCamelCase							       =			self.ror(lowerCAmelCase__			,					6	) ^ self.ror(lowerCAmelCase__			,					11	) ^ self.ror(lowerCAmelCase__			,					25	)
                      _UpperCamelCase							       =			(e & f) ^ ((~e & 0Xff_ff_ff_ff) & g)
                      _UpperCamelCase							       =			(
                          h + sa + ch + self.round_constants[index] + words[index]
                      ) % 0X1_00_00_00_00
                      _UpperCamelCase							       =			self.ror(lowerCAmelCase__			,					2	) ^ self.ror(lowerCAmelCase__			,					13	) ^ self.ror(lowerCAmelCase__			,					22	)
                      _UpperCamelCase							       =			(a & b) ^ (a & c) ^ (b & c)
                      _UpperCamelCase							       =			(sa + maj) % 0X1_00_00_00_00

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

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

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

            _UpperCamelCase							       =			''''''.join([hex(lowerCAmelCase__	)[2:].zfill(8	) for value in self.hashes]	)







       def snake_case__		(				self  :						Any			,					lowerCAmelCase__  :						int			,					lowerCAmelCase__  :						int	)       ->	int:

            '''simple docstring'''




            return 0Xff_ff_ff_ff & (value << (32 - rotations)) | (value >> rotations)

class 							__lowerCAmelCase	(       unittest.TestCase					):






       """simple docstring"""





       def snake_case__		(				self  :						List[str]	)       ->	None:

            '''simple docstring'''




            import hashlib

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







def    a__							(							)						->						None:





     """simple docstring"""

     import doctest

     doctest.testmod()

     _UpperCamelCase							       =			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''' )

     _UpperCamelCase							       =			parser.parse_args()

     _UpperCamelCase							       =			args.input_string

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

     print(SHAaaa(lowercase ).hash )


if __name__ == "__main__":
   main()










'''simple docstring'''

# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ..models.auto import AutoModelForVisionaSeq
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
   from PIL import Image
class 							__lowerCAmelCase	(       __magic_name__					):






       """simple docstring"""
       _snake_case      :	str									=       'Salesforce/blip-image-captioning-base'
       _snake_case      :	Union[str, Any]									=       (
           'This is a tool that generates a description of an image. It takes an input named `image` which should be the '
           'image to caption, and returns a text that contains the description in English.'
       )
       _snake_case      :	List[Any]									=       'image_captioner'
       _snake_case      :	Union[str, Any]									=       AutoModelForVisionaSeq

       _snake_case      :	Dict									=       ['image']
       _snake_case      :	Optional[int]									=       ['text']





       def __init__(				self  :						Union[str, Any]			,					*lowerCAmelCase__  :						Optional[Any]			,					**lowerCAmelCase__  :						Optional[int]	)       ->	Tuple:

            '''simple docstring'''




            requires_backends(self			,					['''vision''']	)
            super().__init__(*lowerCAmelCase__			,					**lowerCAmelCase__	)





       def snake_case__		(				self  :						Tuple			,					lowerCAmelCase__  :						"Image"	)       ->	Optional[int]:

            '''simple docstring'''




            return self.pre_processor(images=lowerCAmelCase__			,					return_tensors='''pt'''	)





       def snake_case__		(				self  :						Any			,					lowerCAmelCase__  :						Union[str, Any]	)       ->	Union[str, Any]:

            '''simple docstring'''




            return self.model.generate(**lowerCAmelCase__	)







       def snake_case__		(				self  :						int			,					lowerCAmelCase__  :						List[str]	)       ->	List[str]:

            '''simple docstring'''




            return self.pre_processor.batch_decode(lowerCAmelCase__			,					skip_special_tokens=lowerCAmelCase__	)[0].strip()



