



"""simple docstring"""







import argparse
import struct
import unittest






class      UpperCAmelCase__		:



		def __init__( self  :    Union[str, Any]      ,							snake_case  :    bytes				)			->						None:






									'''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 					A_		( snake_case  :    bytes				)			->						bytes:






									'''simple docstring'''

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



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






									'''simple docstring'''

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

																A      ,  A      ,  A      ,  A      ,  A      ,  A      ,  A      ,  A         =					self.hashes

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

																														A         =					(
																														    words[index - 16] + sa + words[index - 7] + sa
																														) % 0x1_0000_0000

																							# Compression
																							A         =					self.ror(snake_case      ,							6				) ^ self.ror(snake_case      ,							11				) ^ self.ror(snake_case      ,							25				)
																							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      ,							13				) ^ self.ror(snake_case      ,							22				)
																							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 					A_		( self  :    Any      ,							snake_case  :    int      ,							snake_case  :    int				)			->						int:






									'''simple docstring'''

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






class      UpperCAmelCase__		(      unittest.TestCase     ):



		def 					A_		( self  :    Any				)			->						None:






									'''simple docstring'''

									import hashlib

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



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

							print(SHAaaa(lowerCamelCase__			).hash			)


if __name__ == "__main__":
							main()











"""simple docstring"""







import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers.testing_utils import require_vision
from transformers.utils import is_vision_available


if is_vision_available():
							from PIL import Image

							from transformers import (
							    AutoProcessor,
							    BertTokenizerFast,
							    BlipImageProcessor,
							    GPTaTokenizer,
							    InstructBlipProcessor,
							    PreTrainedTokenizerFast,
							)






@require_vision
class      UpperCAmelCase__		(      unittest.TestCase     ):



		def 					A_		( self  :    Dict				)			->						Dict:






									'''simple docstring'''

									A         =					tempfile.mkdtemp()

									A         =					BlipImageProcessor()
									A         =					GPTaTokenizer.from_pretrained('hf-internal-testing/tiny-random-GPT2Model'				)
									A         =					BertTokenizerFast.from_pretrained('hf-internal-testing/tiny-random-bert'				)

									A         =					InstructBlipProcessor(snake_case      ,							snake_case      ,							snake_case				)

									processor.save_pretrained(self.tmpdirname				)



		def 					A_		( self  :    List[str]      ,							**snake_case  :    str				)			->						Dict:






									'''simple docstring'''

									return AutoProcessor.from_pretrained(self.tmpdirname      ,							**snake_case				).tokenizer



		def 					A_		( self  :    int      ,							**snake_case  :    Optional[Any]				)			->						Any:






									'''simple docstring'''

									return AutoProcessor.from_pretrained(self.tmpdirname      ,							**snake_case				).image_processor



		def 					A_		( self  :    Any      ,							**snake_case  :    Union[str, Any]				)			->						Any:






									'''simple docstring'''

									return AutoProcessor.from_pretrained(self.tmpdirname      ,							**snake_case				).qformer_tokenizer



		def 					A_		( self  :    int				)			->						Union[str, Any]:






									'''simple docstring'''

									shutil.rmtree(self.tmpdirname				)



		def 					A_		( self  :    List[Any]				)			->						Tuple:






									'''simple docstring'''

									A         =					[np.random.randint(255      ,							size=(3, 30, 400)      ,							dtype=np.uinta				)]

									A         =					[Image.fromarray(np.moveaxis(snake_case      ,							0      ,							-1				)				) for x in image_inputs]

									return image_inputs



		def 					A_		( self  :    List[Any]				)			->						Optional[int]:






									'''simple docstring'''

									A         =					InstructBlipProcessor(
									    tokenizer=self.get_tokenizer()      ,							image_processor=self.get_image_processor()      ,							qformer_tokenizer=self.get_qformer_tokenizer()      ,							)
									processor.save_pretrained(self.tmpdirname				)

									A         =					self.get_tokenizer(bos_token='(BOS)'      ,							eos_token='(EOS)'				)
									A         =					self.get_image_processor(do_normalize=snake_case      ,							padding_value=1.0				)

									A         =					InstructBlipProcessor.from_pretrained(
									    self.tmpdirname      ,							bos_token='(BOS)'      ,							eos_token='(EOS)'      ,							do_normalize=snake_case      ,							padding_value=1.0				)

									self.assertEqual(processor.tokenizer.get_vocab()      ,							tokenizer_add_kwargs.get_vocab()				)
									self.assertIsInstance(processor.tokenizer      ,							snake_case				)

									self.assertEqual(processor.image_processor.to_json_string()      ,							image_processor_add_kwargs.to_json_string()				)
									self.assertIsInstance(processor.image_processor      ,							snake_case				)
									self.assertIsInstance(processor.qformer_tokenizer      ,							snake_case				)



		def 					A_		( self  :    Optional[Any]				)			->						Dict:






									'''simple docstring'''

									A         =					self.get_image_processor()
									A         =					self.get_tokenizer()
									A         =					self.get_qformer_tokenizer()

									A         =					InstructBlipProcessor(
									    tokenizer=snake_case      ,							image_processor=snake_case      ,							qformer_tokenizer=snake_case				)

									A         =					self.prepare_image_inputs()

									A         =					image_processor(snake_case      ,							return_tensors='np'				)
									A         =					processor(images=snake_case      ,							return_tensors='np'				)

									for key in input_feat_extract.keys():
																self.assertAlmostEqual(input_feat_extract[key].sum()      ,							input_processor[key].sum()      ,							delta=1E-2				)



		def 					A_		( self  :    Tuple				)			->						List[str]:






									'''simple docstring'''

									A         =					self.get_image_processor()
									A         =					self.get_tokenizer()
									A         =					self.get_qformer_tokenizer()

									A         =					InstructBlipProcessor(
									    tokenizer=snake_case      ,							image_processor=snake_case      ,							qformer_tokenizer=snake_case				)

									A         =					'lower newer'

									A         =					processor(text=snake_case				)

									A         =					tokenizer(snake_case      ,							return_token_type_ids=snake_case				)
									A         =					qformer_tokenizer(snake_case      ,							return_token_type_ids=snake_case				)

									for key in encoded_tokens.keys():
																self.assertListEqual(encoded_tokens[key]      ,							encoded_processor[key]				)

									for key in encoded_tokens_qformer.keys():
																self.assertListEqual(encoded_tokens_qformer[key]      ,							encoded_processor['qformer_' + key]				)



		def 					A_		( self  :    List[Any]				)			->						Optional[int]:






									'''simple docstring'''

									A         =					self.get_image_processor()
									A         =					self.get_tokenizer()
									A         =					self.get_qformer_tokenizer()

									A         =					InstructBlipProcessor(
									    tokenizer=snake_case      ,							image_processor=snake_case      ,							qformer_tokenizer=snake_case				)

									A         =					'lower newer'
									A         =					self.prepare_image_inputs()

									A         =					processor(text=snake_case      ,							images=snake_case				)

									self.assertListEqual(
									    list(inputs.keys()				)      ,							['input_ids', 'attention_mask', 'qformer_input_ids', 'qformer_attention_mask', 'pixel_values']      ,							)

									# test if it raises when no input is passed
									with pytest.raises(snake_case				):
																processor()



		def 					A_		( self  :    Optional[Any]				)			->						List[str]:






									'''simple docstring'''

									A         =					self.get_image_processor()
									A         =					self.get_tokenizer()
									A         =					self.get_qformer_tokenizer()

									A         =					InstructBlipProcessor(
									    tokenizer=snake_case      ,							image_processor=snake_case      ,							qformer_tokenizer=snake_case				)

									A         =					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

									A         =					processor.batch_decode(snake_case				)
									A         =					tokenizer.batch_decode(snake_case				)

									self.assertListEqual(snake_case      ,							snake_case				)



		def 					A_		( self  :    Tuple				)			->						List[Any]:






									'''simple docstring'''

									A         =					self.get_image_processor()
									A         =					self.get_tokenizer()
									A         =					self.get_qformer_tokenizer()

									A         =					InstructBlipProcessor(
									    tokenizer=snake_case      ,							image_processor=snake_case      ,							qformer_tokenizer=snake_case				)

									A         =					'lower newer'
									A         =					self.prepare_image_inputs()

									A         =					processor(text=snake_case      ,							images=snake_case				)

									self.assertListEqual(
									    list(inputs.keys()				)      ,							['input_ids', 'attention_mask', 'qformer_input_ids', 'qformer_attention_mask', 'pixel_values']      ,							)



