






'''simple docstring'''




import argparse
import struct
import unittest







class       __lowercase					:

	def __init__(      self   :						Tuple  ,					UpperCAmelCase_   :						bytes):
			UpperCamelCase__				:					Dict					=					data

			# Initialize hash values
			UpperCamelCase__				:					Any					=					[
			    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
			UpperCamelCase__				:					List[Any]					=					[
			    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,
			]

			UpperCamelCase__				:					Tuple					=					self.preprocessing(self.data)
			self.final_hash()

	@staticmethod
	def      __UpperCamelCase							(      UpperCAmelCase_   :						bytes):
			UpperCamelCase__				:					List[Any]					=					B'\x80' + (B'\x00' * (63 - (len(UpperCAmelCase_) + 8) % 64))
			UpperCamelCase__				:					List[Any]					=					struct.pack('>Q'  ,					(len(UpperCAmelCase_) * 8))
			return data + padding + big_endian_integer

	def      __UpperCamelCase							(      self   :						Union[str, Any]):
			# Convert into blocks of 64 bytes
			UpperCamelCase__				:					int					=					[
			    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__				:					Tuple					=					list(struct.unpack('>16L'  ,					UpperCAmelCase_))
					# add 48 0-ed integers
					words += [0] * 48

					UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__				:					str					=					self.hashes

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

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

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

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

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

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

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





	def      __UpperCamelCase							(      self   :						int  ,					UpperCAmelCase_   :						int  ,					UpperCAmelCase_   :						int):
			return 0XFF_FFF_FFF & (value << (32 - rotations)) | (value >> rotations)







class       __lowercase					(unittest.TestCase    ):

	def      __UpperCamelCase							(      self   :						int):
			import hashlib

			UpperCamelCase__				:					str					=					bytes('Test String'  ,					'utf-8')
			self.assertEqual(SHAaaa(UpperCAmelCase_).hash  ,					hashlib.shaaaa(UpperCAmelCase_).hexdigest())







def       __UpperCAmelCase						(  )							->     None:
		import doctest

		doctest.testmod()

		UpperCamelCase__				:					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')

		UpperCamelCase__				:					List[str]					=					parser.parse_args()

		UpperCamelCase__				:					str					=					args.input_string

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

		print(SHAaaa(lowerCamelCase_).hash)


if __name__ == "__main__":
		main()












'''simple docstring'''




import inspect
import math
import tempfile
import unittest

import numpy as np

from transformers import ViTMAEConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import ViTMAEForPreTraining, ViTMAEModel
		from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import ViTImageProcessor







class       __lowercase					:

	def __init__(      self   :						Union[str, Any]  ,					UpperCAmelCase_   :						Dict  ,					UpperCAmelCase_   :						Optional[int]=13  ,					UpperCAmelCase_   :						Tuple=30  ,					UpperCAmelCase_   :						Dict=2  ,					UpperCAmelCase_   :						Dict=3  ,					UpperCAmelCase_   :						Tuple=True  ,					UpperCAmelCase_   :						str=True  ,					UpperCAmelCase_   :						Tuple=32  ,					UpperCAmelCase_   :						List[str]=5  ,					UpperCAmelCase_   :						str=4  ,					UpperCAmelCase_   :						Optional[int]=37  ,					UpperCAmelCase_   :						str="gelu"  ,					UpperCAmelCase_   :						List[str]=0.1  ,					UpperCAmelCase_   :						Dict=0.1  ,					UpperCAmelCase_   :						Dict=10  ,					UpperCAmelCase_   :						Optional[int]=0.02  ,					UpperCAmelCase_   :						Union[str, Any]=3  ,					UpperCAmelCase_   :						Any=0.6  ,					UpperCAmelCase_   :						Dict=None  ,					):
			UpperCamelCase__				:					Tuple					=					parent
			UpperCamelCase__				:					List[str]					=					batch_size
			UpperCamelCase__				:					Optional[Any]					=					image_size
			UpperCamelCase__				:					Optional[Any]					=					patch_size
			UpperCamelCase__				:					List[str]					=					num_channels
			UpperCamelCase__				:					Union[str, Any]					=					is_training
			UpperCamelCase__				:					int					=					use_labels
			UpperCamelCase__				:					Optional[int]					=					hidden_size
			UpperCamelCase__				:					Any					=					num_hidden_layers
			UpperCamelCase__				:					str					=					num_attention_heads
			UpperCamelCase__				:					str					=					intermediate_size
			UpperCamelCase__				:					Union[str, Any]					=					hidden_act
			UpperCamelCase__				:					Optional[int]					=					hidden_dropout_prob
			UpperCamelCase__				:					Tuple					=					attention_probs_dropout_prob
			UpperCamelCase__				:					Any					=					type_sequence_label_size
			UpperCamelCase__				:					int					=					initializer_range
			UpperCamelCase__				:					Optional[int]					=					mask_ratio
			UpperCamelCase__				:					int					=					scope

			# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
			# (we add 1 for the [CLS] token)
			UpperCamelCase__				:					str					=					(image_size // patch_size) ** 2
			UpperCamelCase__				:					Dict					=					int(math.ceil((1 - mask_ratio) * (num_patches + 1)))

	def      __UpperCamelCase							(      self   :						Dict):
			UpperCamelCase__				:					str					=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

			UpperCamelCase__				:					List[str]					=					None
			if self.use_labels:
					UpperCamelCase__				:					Dict					=					ids_tensor([self.batch_size]  ,					self.type_sequence_label_size)

			UpperCamelCase__				:					Any					=					self.get_config()

			return config, pixel_values, labels

	def      __UpperCamelCase							(      self   :						List[Any]):
			return ViTMAEConfig(
			    image_size=self.image_size  ,					patch_size=self.patch_size  ,					num_channels=self.num_channels  ,					hidden_size=self.hidden_size  ,					num_hidden_layers=self.num_hidden_layers  ,					num_attention_heads=self.num_attention_heads  ,					intermediate_size=self.intermediate_size  ,					hidden_act=self.hidden_act  ,					hidden_dropout_prob=self.hidden_dropout_prob  ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,					is_decoder=UpperCAmelCase_  ,					initializer_range=self.initializer_range  ,					mask_ratio=self.mask_ratio  ,					)

	def      __UpperCamelCase							(      self   :						Tuple  ,					UpperCAmelCase_   :						int  ,					UpperCAmelCase_   :						str  ,					UpperCAmelCase_   :						Optional[int]):
			UpperCamelCase__				:					Dict					=					ViTMAEModel(config=UpperCAmelCase_)
			model.to(UpperCAmelCase_)
			model.eval()
			UpperCamelCase__				:					Optional[int]					=					model(UpperCAmelCase_)
			self.parent.assertEqual(result.last_hidden_state.shape  ,					(self.batch_size, self.seq_length, self.hidden_size))

	def      __UpperCamelCase							(      self   :						Union[str, Any]  ,					UpperCAmelCase_   :						Union[str, Any]  ,					UpperCAmelCase_   :						Union[str, Any]  ,					UpperCAmelCase_   :						Tuple):
			UpperCamelCase__				:					List[Any]					=					ViTMAEForPreTraining(UpperCAmelCase_)
			model.to(UpperCAmelCase_)
			model.eval()
			UpperCamelCase__				:					Dict					=					model(UpperCAmelCase_)
			UpperCamelCase__				:					List[str]					=					(self.image_size // self.patch_size) ** 2
			UpperCamelCase__				:					Optional[int]					=					self.patch_size**2 * self.num_channels
			self.parent.assertEqual(result.logits.shape  ,					(self.batch_size, num_patches, expected_num_channels))

			# test greyscale images
			UpperCamelCase__				:					List[Any]					=					1
			UpperCamelCase__				:					Union[str, Any]					=					ViTMAEForPreTraining(UpperCAmelCase_)
			model.to(UpperCAmelCase_)
			model.eval()
			UpperCamelCase__				:					List[str]					=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
			UpperCamelCase__				:					Union[str, Any]					=					model(UpperCAmelCase_)
			UpperCamelCase__				:					Tuple					=					self.patch_size**2
			self.parent.assertEqual(result.logits.shape  ,					(self.batch_size, num_patches, expected_num_channels))





	def      __UpperCamelCase							(      self   :						Dict):
			UpperCamelCase__				:					List[str]					=					self.prepare_config_and_inputs()
			UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__				:					List[str]					=					config_and_inputs
			UpperCamelCase__				:					Any					=					{'pixel_values': pixel_values}
			return config, inputs_dict







@require_torch
class       __lowercase					(__lowerCamelCase   ,				__lowerCamelCase   ,				unittest.TestCase    ):
	_lowerCamelCase              =  (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
	_lowerCamelCase              =  {'''feature-extraction''': ViTMAEModel} if is_torch_available() else {}

	_lowerCamelCase              =  False
	_lowerCamelCase              =  False
	_lowerCamelCase              =  False
	_lowerCamelCase              =  False

	def      __UpperCamelCase							(      self   :						Optional[Any]):
			UpperCamelCase__				:					List[str]					=					ViTMAEModelTester(self)
			UpperCamelCase__				:					Any					=					ConfigTester(self  ,					config_class=UpperCAmelCase_  ,					has_text_modality=UpperCAmelCase_  ,					hidden_size=37)

	def      __UpperCamelCase							(      self   :						Any):
			self.config_tester.run_common_tests()

	@unittest.skip(reason='ViTMAE does not use inputs_embeds')
	def      __UpperCamelCase							(      self   :						Tuple):
			pass

	def      __UpperCamelCase							(      self   :						Optional[Any]):
			UpperCamelCase__,	UpperCamelCase__				:					Union[str, Any]					=					self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					UpperCamelCase__				:					List[str]					=					model_class(UpperCAmelCase_)
					self.assertIsInstance(model.get_input_embeddings()  ,					(nn.Module))
					UpperCamelCase__				:					Optional[Any]					=					model.get_output_embeddings()
					self.assertTrue(x is None or isinstance(UpperCAmelCase_  ,					nn.Linear))

	def      __UpperCamelCase							(      self   :						List[str]):
			UpperCamelCase__,	UpperCamelCase__				:					Dict					=					self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					UpperCamelCase__				:					Tuple					=					model_class(UpperCAmelCase_)
					UpperCamelCase__				:					int					=					inspect.signature(model.forward)
					# signature.parameters is an OrderedDict => so arg_names order is deterministic
					UpperCamelCase__				:					Any					=					[*signature.parameters.keys()]

					UpperCamelCase__				:					Optional[int]					=					['pixel_values']
					self.assertListEqual(arg_names[:1]  ,					UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						int):
			UpperCamelCase__				:					Union[str, Any]					=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_model(*UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						str):
			UpperCamelCase__				:					List[Any]					=					self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_for_pretraining(*UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						Union[str, Any]  ,					UpperCAmelCase_   :						str  ,					UpperCAmelCase_   :						Any  ,					UpperCAmelCase_   :						Union[str, Any]):
			# make masks reproducible
			np.random.seed(2)

			UpperCamelCase__				:					str					=					int((pt_model.config.image_size // pt_model.config.patch_size) ** 2)
			UpperCamelCase__				:					Tuple					=					np.random.uniform(size=(self.model_tester.batch_size, num_patches))
			UpperCamelCase__				:					Optional[Any]					=					torch.from_numpy(UpperCAmelCase_)

			# Add `noise` argument.
			# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
			UpperCamelCase__				:					List[str]					=					pt_noise

			super().check_pt_tf_models(UpperCAmelCase_  ,					UpperCAmelCase_  ,					UpperCAmelCase_)

	def      __UpperCamelCase							(      self   :						int):
			UpperCamelCase__,	UpperCamelCase__				:					Tuple					=					self.model_tester.prepare_config_and_inputs_for_common()

			for model_class in self.all_model_classes:
					UpperCamelCase__				:					Optional[Any]					=					model_class(UpperCAmelCase_)
					model.to(UpperCAmelCase_)
					model.eval()
					# make random mask reproducible
					torch.manual_seed(2)
					with torch.no_grad():
							UpperCamelCase__				:					Tuple					=					model(**self._prepare_for_class(UpperCAmelCase_  ,					UpperCAmelCase_))

					UpperCamelCase__				:					Dict					=					outputs[0].cpu().numpy()
					UpperCamelCase__				:					Optional[int]					=					0

					with tempfile.TemporaryDirectory() as tmpdirname:
							model.save_pretrained(UpperCAmelCase_)
							UpperCamelCase__				:					str					=					model_class.from_pretrained(UpperCAmelCase_)
							model.to(UpperCAmelCase_)
							# make random mask reproducible
							torch.manual_seed(2)
							with torch.no_grad():
									UpperCamelCase__				:					List[str]					=					model(**self._prepare_for_class(UpperCAmelCase_  ,					UpperCAmelCase_))

							# Make sure we don't have nans
							UpperCamelCase__				:					Tuple					=					after_outputs[0].cpu().numpy()
							UpperCamelCase__				:					Any					=					0
							UpperCamelCase__				:					Union[str, Any]					=					np.amax(np.abs(out_a - out_a))
							self.assertLessEqual(UpperCAmelCase_  ,					1e-5)

	@unittest.skip(
	    reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results.')
	def      __UpperCamelCase							(      self   :						Tuple):
			pass

	@unittest.skip(
	    reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results.')
	def      __UpperCamelCase							(      self   :						Optional[int]):
			pass

	@unittest.skip(
	    reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load\n    to get deterministic results.')
	def      __UpperCamelCase							(      self   :						Tuple):
			pass

	@unittest.skip(reason='ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load')
	def      __UpperCamelCase							(      self   :						Tuple):
			pass

	@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
	def      __UpperCamelCase							(      self   :						Optional[int]):
			pass





	@slow
	def      __UpperCamelCase							(      self   :						Optional[Any]):
			for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					UpperCamelCase__				:					Tuple					=					ViTMAEModel.from_pretrained(UpperCAmelCase_)
					self.assertIsNotNone(UpperCAmelCase_)







def       __UpperCAmelCase						(  )							->     Optional[Any]:
		UpperCamelCase__				:					int					=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png')
		return image







@require_torch
@require_vision
class       __lowercase					(unittest.TestCase    ):

	@cached_property
	def      __UpperCamelCase							(      self   :						int):
			return ViTImageProcessor.from_pretrained('facebook/vit-mae-base') if is_vision_available() else None





	@slow
	def      __UpperCamelCase							(      self   :						str):
			# make random mask reproducible across the PT and TF model
			np.random.seed(2)

			UpperCamelCase__				:					Union[str, Any]					=					ViTMAEForPreTraining.from_pretrained('facebook/vit-mae-base').to(UpperCAmelCase_)

			UpperCamelCase__				:					Tuple					=					self.default_image_processor
			UpperCamelCase__				:					Dict					=					prepare_img()
			UpperCamelCase__				:					Optional[int]					=					image_processor(images=UpperCAmelCase_  ,					return_tensors='pt').to(UpperCAmelCase_)

			# prepare a noise vector that will be also used for testing the TF model
			# (this way we can ensure that the PT and TF models operate on the same inputs)
			UpperCamelCase__				:					Union[str, Any]					=					ViTMAEConfig()
			UpperCamelCase__				:					int					=					int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2)
			UpperCamelCase__				:					Any					=					np.random.uniform(size=(1, num_patches))

			# forward pass
			with torch.no_grad():
					UpperCamelCase__				:					Dict					=					model(**UpperCAmelCase_  ,					noise=torch.from_numpy(UpperCAmelCase_).to(device=UpperCAmelCase_))

			# verify the logits
			UpperCamelCase__				:					Tuple					=					torch.Size((1, 196, 768))
			self.assertEqual(outputs.logits.shape  ,					UpperCAmelCase_)

			UpperCamelCase__				:					Any					=					torch.tensor(
			    [[-0.05_48, -1.70_23, -0.93_25], [0.37_21, -0.56_70, -0.22_33], [0.82_35, -1.38_78, -0.35_24]])

			self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]  ,					expected_slice.to(UpperCAmelCase_)  ,					atol=1e-4))




