



import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import ConvNextConfig, SegformerImageProcessor, UperNetConfig, UperNetForSemanticSegmentation






def       __lowercase  (					a__  )							->					int:
							__SCREAMING_SNAKE_CASE										=   3_84
							if "tiny" in model_name:
														__SCREAMING_SNAKE_CASE										=   [3, 3, 9, 3]
														__SCREAMING_SNAKE_CASE										=   [96, 1_92, 3_84, 7_68]
							if "small" in model_name:
														__SCREAMING_SNAKE_CASE										=   [3, 3, 27, 3]
														__SCREAMING_SNAKE_CASE										=   [96, 1_92, 3_84, 7_68]
							if "base" in model_name:
														__SCREAMING_SNAKE_CASE										=   [3, 3, 27, 3]
														__SCREAMING_SNAKE_CASE										=   [1_28, 2_56, 5_12, 10_24]
														__SCREAMING_SNAKE_CASE										=   5_12
							if "large" in model_name:
														__SCREAMING_SNAKE_CASE										=   [3, 3, 27, 3]
														__SCREAMING_SNAKE_CASE										=   [1_92, 3_84, 7_68, 15_36]
														__SCREAMING_SNAKE_CASE										=   7_68
							if "xlarge" in model_name:
														__SCREAMING_SNAKE_CASE										=   [3, 3, 27, 3]
														__SCREAMING_SNAKE_CASE										=   [2_56, 5_12, 10_24, 20_48]
														__SCREAMING_SNAKE_CASE										=   10_24

							# set label information
							__SCREAMING_SNAKE_CASE										=   1_50
							__SCREAMING_SNAKE_CASE										=   'huggingface/label-files'
							__SCREAMING_SNAKE_CASE										=   'ade20k-id2label.json'
							__SCREAMING_SNAKE_CASE										=   json.load(open(hf_hub_download(__lowerCAmelCase				,  __lowerCAmelCase				,  repo_type='dataset'  )				,  'r'  )  )
							__SCREAMING_SNAKE_CASE										=   {int(__lowerCAmelCase  ): v for k, v in idalabel.items()}
							__SCREAMING_SNAKE_CASE										=   {v: k for k, v in idalabel.items()}

							__SCREAMING_SNAKE_CASE										=   ConvNextConfig(
							    depths=__lowerCAmelCase				,  hidden_sizes=__lowerCAmelCase				,  out_features=['stage1', 'stage2', 'stage3', 'stage4']  )
							__SCREAMING_SNAKE_CASE										=   UperNetConfig(
							    backbone_config=__lowerCAmelCase				,  auxiliary_in_channels=__lowerCAmelCase				,  num_labels=__lowerCAmelCase				,  idalabel=__lowerCAmelCase				,  labelaid=__lowerCAmelCase				,  )

							return config






def       __lowercase  (					a__  )							->					List[str]:
							__SCREAMING_SNAKE_CASE										=   []

							# fmt: off
							# stem
							rename_keys.append(('backbone.downsample_layers.0.0.weight', 'backbone.embeddings.patch_embeddings.weight')  )
							rename_keys.append(('backbone.downsample_layers.0.0.bias', 'backbone.embeddings.patch_embeddings.bias')  )
							rename_keys.append(('backbone.downsample_layers.0.1.weight', 'backbone.embeddings.layernorm.weight')  )
							rename_keys.append(('backbone.downsample_layers.0.1.bias', 'backbone.embeddings.layernorm.bias')  )
							# stages
							for i in range(len(config.backbone_config.depths  )  ):
														for j in range(config.backbone_config.depths[i]  ):
																					rename_keys.append((f"""backbone.stages.{i}.{j}.gamma""", f"""backbone.encoder.stages.{i}.layers.{j}.layer_scale_parameter""")  )
																					rename_keys.append((f"""backbone.stages.{i}.{j}.depthwise_conv.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.dwconv.weight""")  )
																					rename_keys.append((f"""backbone.stages.{i}.{j}.depthwise_conv.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.dwconv.bias""")  )
																					rename_keys.append((f"""backbone.stages.{i}.{j}.norm.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.layernorm.weight""")  )
																					rename_keys.append((f"""backbone.stages.{i}.{j}.norm.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.layernorm.bias""")  )
																					rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv1.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv1.weight""")  )
																					rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv1.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv1.bias""")  )
																					rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv2.weight""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv2.weight""")  )
																					rename_keys.append((f"""backbone.stages.{i}.{j}.pointwise_conv2.bias""", f"""backbone.encoder.stages.{i}.layers.{j}.pwconv2.bias""")  )
														if i > 0:
																					rename_keys.append((f"""backbone.downsample_layers.{i}.0.weight""", f"""backbone.encoder.stages.{i}.downsampling_layer.0.weight""")  )
																					rename_keys.append((f"""backbone.downsample_layers.{i}.0.bias""", f"""backbone.encoder.stages.{i}.downsampling_layer.0.bias""")  )
																					rename_keys.append((f"""backbone.downsample_layers.{i}.1.weight""", f"""backbone.encoder.stages.{i}.downsampling_layer.1.weight""")  )
																					rename_keys.append((f"""backbone.downsample_layers.{i}.1.bias""", f"""backbone.encoder.stages.{i}.downsampling_layer.1.bias""")  )

														rename_keys.append((f"""backbone.norm{i}.weight""", f"""backbone.hidden_states_norms.stage{i+1}.weight""")  )
														rename_keys.append((f"""backbone.norm{i}.bias""", f"""backbone.hidden_states_norms.stage{i+1}.bias""")  )

							# decode head
							rename_keys.extend(
							    [
							        ('decode_head.conv_seg.weight', 'decode_head.classifier.weight'),
							        ('decode_head.conv_seg.bias', 'decode_head.classifier.bias'),
							        ('auxiliary_head.conv_seg.weight', 'auxiliary_head.classifier.weight'),
							        ('auxiliary_head.conv_seg.bias', 'auxiliary_head.classifier.bias'),
							    ]  )
							# fmt: on

							return rename_keys






def       __lowercase  (					a__				,  a__				,  a__  )							->					Tuple:
							__SCREAMING_SNAKE_CASE										=   dct.pop(__lowerCAmelCase  )
							__SCREAMING_SNAKE_CASE										=   val






def       __lowercase  (					a__				,  a__				,  a__  )							->					int:
							__SCREAMING_SNAKE_CASE										=   {
							    'upernet-convnext-tiny': 'https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k/upernet_convnext_tiny_fp16_512x512_160k_ade20k_20220227_124553-cad485de.pth',
							    'upernet-convnext-small': 'https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k/upernet_convnext_small_fp16_512x512_160k_ade20k_20220227_131208-1b1e394f.pth',
							    'upernet-convnext-base': 'https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k/upernet_convnext_base_fp16_512x512_160k_ade20k_20220227_181227-02a24fc6.pth',
							    'upernet-convnext-large': 'https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k/upernet_convnext_large_fp16_640x640_160k_ade20k_20220226_040532-e57aa54d.pth',
							    'upernet-convnext-xlarge': 'https://download.openmmlab.com/mmsegmentation/v0.5/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k/upernet_convnext_xlarge_fp16_640x640_160k_ade20k_20220226_080344-95fc38c2.pth',
							}
							__SCREAMING_SNAKE_CASE										=   model_name_to_url[model_name]
							__SCREAMING_SNAKE_CASE										=   torch.hub.load_state_dict_from_url(__lowerCAmelCase				,  map_location='cpu'  )['state_dict']

							__SCREAMING_SNAKE_CASE										=   get_upernet_config(__lowerCAmelCase  )
							__SCREAMING_SNAKE_CASE										=   UperNetForSemanticSegmentation(__lowerCAmelCase  )
							model.eval()

							# replace "bn" => "batch_norm"
							for key in state_dict.copy().keys():
														__SCREAMING_SNAKE_CASE										=   state_dict.pop(__lowerCAmelCase  )
														if "bn" in key:
																					__SCREAMING_SNAKE_CASE										=   key.replace('bn'				,  'batch_norm'  )
														__SCREAMING_SNAKE_CASE										=   val

							# rename keys
							__SCREAMING_SNAKE_CASE										=   create_rename_keys(__lowerCAmelCase  )
							for src, dest in rename_keys:
														rename_key(__lowerCAmelCase				,  __lowerCAmelCase				,  __lowerCAmelCase  )

							model.load_state_dict(__lowerCAmelCase  )

							# verify on image
							__SCREAMING_SNAKE_CASE										=   'https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg'
							__SCREAMING_SNAKE_CASE										=   Image.open(requests.get(__lowerCAmelCase				,  stream=__lowerCAmelCase  ).raw  ).convert('RGB'  )

							__SCREAMING_SNAKE_CASE										=   SegformerImageProcessor()
							__SCREAMING_SNAKE_CASE										=   processor(__lowerCAmelCase				,  return_tensors='pt'  ).pixel_values

							with torch.no_grad():
														__SCREAMING_SNAKE_CASE										=   model(__lowerCAmelCase  )

							if model_name == "upernet-convnext-tiny":
														__SCREAMING_SNAKE_CASE										=   torch.tensor(
														    [[-8.8110, -8.8110, -8.6521], [-8.8110, -8.8110, -8.6521], [-8.7746, -8.7746, -8.6130]]  )
							elif model_name == "upernet-convnext-small":
														__SCREAMING_SNAKE_CASE										=   torch.tensor(
														    [[-8.8236, -8.8236, -8.6771], [-8.8236, -8.8236, -8.6771], [-8.7638, -8.7638, -8.6240]]  )
							elif model_name == "upernet-convnext-base":
														__SCREAMING_SNAKE_CASE										=   torch.tensor(
														    [[-8.8558, -8.8558, -8.6905], [-8.8558, -8.8558, -8.6905], [-8.7669, -8.7669, -8.6021]]  )
							elif model_name == "upernet-convnext-large":
														__SCREAMING_SNAKE_CASE										=   torch.tensor(
														    [[-8.6660, -8.6660, -8.6210], [-8.6660, -8.6660, -8.6210], [-8.6310, -8.6310, -8.5964]]  )
							elif model_name == "upernet-convnext-xlarge":
														__SCREAMING_SNAKE_CASE										=   torch.tensor(
														    [[-8.4980, -8.4980, -8.3977], [-8.4980, -8.4980, -8.3977], [-8.4379, -8.4379, -8.3412]]  )
							print('Logits:'				,  outputs.logits[0, 0, :3, :3]  )
							assert torch.allclose(outputs.logits[0, 0, :3, :3]				,  __lowerCAmelCase				,  atol=1E-4  )
							print('Looks ok!'  )

							if pytorch_dump_folder_path is not None:
														print(f"""Saving model {model_name} to {pytorch_dump_folder_path}"""  )
														model.save_pretrained(__lowerCAmelCase  )
														print(f"""Saving processor to {pytorch_dump_folder_path}"""  )
														processor.save_pretrained(__lowerCAmelCase  )

							if push_to_hub:
														print(f"""Pushing model and processor for {model_name} to hub"""  )
														model.push_to_hub(f"""openmmlab/{model_name}"""  )
														processor.push_to_hub(f"""openmmlab/{model_name}"""  )


if __name__ == "__main__":
			lowerCAmelCase__						:	int					=argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    '''--model_name''',
			    default='''upernet-convnext-tiny''',
			    type=str,
			    choices=[F'''upernet-convnext-{size}''' for size in ['''tiny''', '''small''', '''base''', '''large''', '''xlarge''']],
			    help='''Name of the ConvNext UperNet model you\'d like to convert.''',
			)
			parser.add_argument(
			    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
			)
			parser.add_argument(
			    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
			)

			lowerCAmelCase__						:	Any					=parser.parse_args()
			convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








import argparse
import struct
import unittest





class       _lowerCAmelCase   :




				def __init__(   self							,							_UpperCamelCase	)							-> None:
							lowerCAmelCase_         =      data

							# Initialize hash values
							lowerCAmelCase_         =      [
							    0x6_A_0_9_E_6_6_7,
							    0xB_B_6_7_A_E_8_5,
							    0x3_C_6_E_F_3_7_2,
							    0xA_5_4_F_F_5_3_A,
							    0x5_1_0_E_5_2_7_F,
							    0x9_B_0_5_6_8_8_C,
							    0x1_F_8_3_D_9_A_B,
							    0x5_B_E_0_C_D_1_9,
							]

							# Initialize round constants
							lowerCAmelCase_         =      [
							    0x4_2_8_A_2_F_9_8,
							    0x7_1_3_7_4_4_9_1,
							    0xB_5_C_0_F_B_C_F,
							    0xE_9_B_5_D_B_A_5,
							    0x3_9_5_6_C_2_5_B,
							    0x5_9_F_1_1_1_F_1,
							    0x9_2_3_F_8_2_A_4,
							    0xA_B_1_C_5_E_D_5,
							    0xD_8_0_7_A_A_9_8,
							    0x1_2_8_3_5_B_0_1,
							    0x2_4_3_1_8_5_B_E,
							    0x5_5_0_C_7_D_C_3,
							    0x7_2_B_E_5_D_7_4,
							    0x8_0_D_E_B_1_F_E,
							    0x9_B_D_C_0_6_A_7,
							    0xC_1_9_B_F_1_7_4,
							    0xE_4_9_B_6_9_C_1,
							    0xE_F_B_E_4_7_8_6,
							    0x0_F_C_1_9_D_C_6,
							    0x2_4_0_C_A_1_C_C,
							    0x2_D_E_9_2_C_6_F,
							    0x4_A_7_4_8_4_A_A,
							    0x5_C_B_0_A_9_D_C,
							    0x7_6_F_9_8_8_D_A,
							    0x9_8_3_E_5_1_5_2,
							    0xA_8_3_1_C_6_6_D,
							    0xB_0_0_3_2_7_C_8,
							    0xB_F_5_9_7_F_C_7,
							    0xC_6_E_0_0_B_F_3,
							    0xD_5_A_7_9_1_4_7,
							    0x0_6_C_A_6_3_5_1,
							    0x1_4_2_9_2_9_6_7,
							    0x2_7_B_7_0_A_8_5,
							    0x2_E_1_B_2_1_3_8,
							    0x4_D_2_C_6_D_F_C,
							    0x5_3_3_8_0_D_1_3,
							    0x6_5_0_A_7_3_5_4,
							    0x7_6_6_A_0_A_B_B,
							    0x8_1_C_2_C_9_2_E,
							    0x9_2_7_2_2_C_8_5,
							    0xA_2_B_F_E_8_A_1,
							    0xA_8_1_A_6_6_4_B,
							    0xC_2_4_B_8_B_7_0,
							    0xC_7_6_C_5_1_A_3,
							    0xD_1_9_2_E_8_1_9,
							    0xD_6_9_9_0_6_2_4,
							    0xF_4_0_E_3_5_8_5,
							    0x1_0_6_A_A_0_7_0,
							    0x1_9_A_4_C_1_1_6,
							    0x1_E_3_7_6_C_0_8,
							    0x2_7_4_8_7_7_4_C,
							    0x3_4_B_0_B_C_B_5,
							    0x3_9_1_C_0_C_B_3,
							    0x4_E_D_8_A_A_4_A,
							    0x5_B_9_C_C_A_4_F,
							    0x6_8_2_E_6_F_F_3,
							    0x7_4_8_F_8_2_E_E,
							    0x7_8_A_5_6_3_6_F,
							    0x8_4_C_8_7_8_1_4,
							    0x8_C_C_7_0_2_0_8,
							    0x9_0_B_E_F_F_F_A,
							    0xA_4_5_0_6_C_E_B,
							    0xB_E_F_9_A_3_F_7,
							    0xC_6_7_1_7_8_F_2,
							]

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




				@staticmethod
				def 	__a		(   _UpperCamelCase	)							-> bytes:
							lowerCAmelCase_         =      B"\x80" + (B"\x00" * (63 - (len(_UpperCamelCase	) + 8) % 64))
							lowerCAmelCase_         =      struct.pack(">Q"							,							(len(_UpperCamelCase	) * 8)	)
							return data + padding + big_endian_integer




				def 	__a		(   self	)							-> None:
							# 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
																) % 0x1_0_0_0_0_0_0_0_0

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

													lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_      ,    lowerCAmelCase_         =      (
													    g,
													    f,
													    e,
													    ((d + tempa) % 0x1_0_0_0_0_0_0_0_0),
													    c,
													    b,
													    a,
													    ((tempa + tempa) % 0x1_0_0_0_0_0_0_0_0),
													)

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

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

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




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase	)							-> int:
							return 0xF_F_F_F_F_F_F_F & (value << (32 - rotations)) | (value >> rotations)





class       _lowerCAmelCase   (      unittest.TestCase			):




				def 	__a		(   self	)							-> None:
							import hashlib

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






def   lowerCamelCase__							(							):




			"""simple docstring"""


			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(__lowerCAmelCase       ,				"utf-8"							)

			print(SHAaaa(__lowerCAmelCase							).hash							)


if __name__ == "__main__":
			main()



