import argparse
import json
import os

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

from transformers import ConvNextImageProcessor, ConvNextVaConfig, ConvNextVaForImageClassification
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
UpperCamelCase      			=     logging.get_logger(__name__)



def    lowerCamelCase_   (  _lowercase    )							->	Tuple:
		__A							:   str	  =				ConvNextVaConfig()

		if "atto" in checkpoint_url:
				__A							:   Any	  =				[2, 2, 6, 2]
				__A							:   int	  =				[40, 80, 160, 320]
		if "femto" in checkpoint_url:
				__A							:   int	  =				[2, 2, 6, 2]
				__A							:   Optional[int]	  =				[48, 96, 192, 384]
		if "pico" in checkpoint_url:
				__A							:   Optional[int]	  =				[2, 2, 6, 2]
				__A							:   int	  =				[64, 128, 256, 512]
		if "nano" in checkpoint_url:
				__A							:   Union[str, Any]	  =				[2, 2, 8, 2]
				__A							:   int	  =				[80, 160, 320, 640]
		if "tiny" in checkpoint_url:
				__A							:   List[str]	  =				[3, 3, 9, 3]
				__A							:   List[str]	  =				[96, 192, 384, 768]
		if "base" in checkpoint_url:
				__A							:   List[Any]	  =				[3, 3, 27, 3]
				__A							:   str	  =				[128, 256, 512, 1_024]
		if "large" in checkpoint_url:
				__A							:   Optional[int]	  =				[3, 3, 27, 3]
				__A							:   Tuple	  =				[192, 384, 768, 1_536]
		if "huge" in checkpoint_url:
				__A							:   int	  =				[3, 3, 27, 3]
				__A							:   List[Any]	  =				[352, 704, 1_408, 2_816]

		__A							:   List[str]	  =				1_000
		__A							:   Union[str, Any]	  =				"imagenet-1k-id2label.json"
		__A							:   Any	  =				(1, 1_000)

		__A							:   Optional[Any]	  =				"huggingface/label-files"
		__A							:   Dict	  =				num_labels
		__A							:   List[Any]	  =				json.load(open(hf_hub_download(_lowercase ,     _lowercase ,     repo_type="dataset"    ) ,     "r"    )    )
		__A							:   Any	  =				{int(_lowercase    ): v for k, v in idalabel.items()}

		__A							:   Union[str, Any]	  =				idalabel
		__A							:   Tuple	  =				{v: k for k, v in idalabel.items()}
		__A							:   int	  =				hidden_sizes
		__A							:   List[Any]	  =				depths

		return config, expected_shape



def    lowerCamelCase_   (  _lowercase    )							->	int:
		if "downsample_layers.0.0" in name:
				__A							:   Any	  =				name.replace("downsample_layers.0.0" ,     "embeddings.patch_embeddings"    )
		if "downsample_layers.0.1" in name:
				__A							:   Tuple	  =				name.replace("downsample_layers.0.1" ,     "embeddings.norm"    )  # we rename to layernorm later on
		if "downsample_layers.1.0" in name:
				__A							:   int	  =				name.replace("downsample_layers.1.0" ,     "stages.1.downsampling_layer.0"    )
		if "downsample_layers.1.1" in name:
				__A							:   Union[str, Any]	  =				name.replace("downsample_layers.1.1" ,     "stages.1.downsampling_layer.1"    )
		if "downsample_layers.2.0" in name:
				__A							:   Optional[int]	  =				name.replace("downsample_layers.2.0" ,     "stages.2.downsampling_layer.0"    )
		if "downsample_layers.2.1" in name:
				__A							:   str	  =				name.replace("downsample_layers.2.1" ,     "stages.2.downsampling_layer.1"    )
		if "downsample_layers.3.0" in name:
				__A							:   Union[str, Any]	  =				name.replace("downsample_layers.3.0" ,     "stages.3.downsampling_layer.0"    )
		if "downsample_layers.3.1" in name:
				__A							:   Any	  =				name.replace("downsample_layers.3.1" ,     "stages.3.downsampling_layer.1"    )
		if "stages" in name and "downsampling_layer" not in name:
				# stages.0.0. for instance should be renamed to stages.0.layers.0.
				__A							:   Dict	  =				name[: len("stages.0"    )] + ".layers" + name[len("stages.0"    ) :]
		if "gamma" in name:
				__A							:   Tuple	  =				name.replace("gamma" ,     "weight"    )
		if "beta" in name:
				__A							:   Union[str, Any]	  =				name.replace("beta" ,     "bias"    )
		if "stages" in name:
				__A							:   Optional[Any]	  =				name.replace("stages" ,     "encoder.stages"    )
		if "norm" in name:
				__A							:   Optional[Any]	  =				name.replace("norm" ,     "layernorm"    )
		if "head" in name:
				__A							:   Optional[int]	  =				name.replace("head" ,     "classifier"    )

		return name



def    lowerCamelCase_   (  )							->	List[str]:
		__A							:   Any	  =				"http://images.cocodataset.org/val2017/000000039769.jpg"
		__A							:   Union[str, Any]	  =				Image.open(requests.get(_lowercase ,     stream=_lowercase    ).raw    )
		return im



def    lowerCamelCase_   (  _lowercase    )							->	Union[str, Any]:
		if "224" in checkpoint_url:
				__A							:   Union[str, Any]	  =				224
				__A							:   Optional[int]	  =				224 / 256
		elif "384" in checkpoint_url:
				__A							:   str	  =				384
				__A							:   Any	  =				None
		else:
				__A							:   str	  =				512
				__A							:   int	  =				None

		return ConvNextImageProcessor(
		    size=_lowercase ,     crop_pct=_lowercase ,     image_mean=[0.4_85, 0.4_56, 0.4_06] ,     image_std=[0.2_29, 0.2_24, 0.2_25] ,     resample=PILImageResampling.BICUBIC ,     )



@torch.no_grad()
def    lowerCamelCase_   (  _lowercase ,     _lowercase ,     _lowercase ,     _lowercase    )							->	List[Any]:
		print("Downloading original model from checkpoint..."    )
		# define ConvNeXTV2 configuration based on URL
		__A  ,       __A							:   List[Any]	  =				get_convnextva_config(_lowercase    )
		# load original state_dict from URL
		__A							:   Optional[Any]	  =				torch.hub.load_state_dict_from_url(_lowercase    )["model"]

		print("Converting model parameters..."    )
		# rename keys
		for key in state_dict.copy().keys():
				__A							:   Dict	  =				state_dict.pop(_lowercase    )
				__A							:   int	  =				val
		# add prefix to all keys expect classifier head
		for key in state_dict.copy().keys():
				__A							:   int	  =				state_dict.pop(_lowercase    )
				if not key.startswith("classifier"    ):
						__A							:   Tuple	  =				"convnextv2." + key
				__A							:   int	  =				val

		# load HuggingFace model
		__A							:   int	  =				ConvNextVaForImageClassification(_lowercase    )
		model.load_state_dict(_lowercase    )
		model.eval()

		# Check outputs on an image, prepared by ConvNextImageProcessor
		__A							:   int	  =				convert_preprocessor(_lowercase    )
		__A							:   str	  =				preprocessor(images=prepare_img() ,     return_tensors="pt"    )
		__A							:   str	  =				model(**_lowercase    ).logits

		# note: the logits below were obtained without center cropping
		if checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt":
				__A							:   str	  =				torch.tensor([-0.39_30, 0.17_47, -0.52_46, 0.41_77, 0.42_95]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_femto_1k_224_ema.pt":
				__A							:   Any	  =				torch.tensor([-0.17_27, -0.53_41, -0.78_18, -0.47_45, -0.65_66]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_pico_1k_224_ema.pt":
				__A							:   int	  =				torch.tensor([-0.03_33, 0.15_63, -0.91_37, 0.10_54, 0.03_81]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_nano_1k_224_ema.pt":
				__A							:   Optional[Any]	  =				torch.tensor([-0.17_44, -0.15_55, -0.07_13, 0.09_50, -0.14_31]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_tiny_1k_224_ema.pt":
				__A							:   Union[str, Any]	  =				torch.tensor([0.99_96, 0.19_66, -0.43_86, -0.34_72, 0.66_61]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_base_1k_224_ema.pt":
				__A							:   Optional[int]	  =				torch.tensor([-0.25_53, -0.67_08, -0.13_59, 0.25_18, -0.24_88]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_large_1k_224_ema.pt":
				__A							:   int	  =				torch.tensor([-0.06_73, -0.56_27, -0.37_53, -0.27_22, 0.01_78]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_huge_1k_224_ema.pt":
				__A							:   Tuple	  =				torch.tensor([-0.63_77, -0.74_58, -0.21_50, 0.11_84, -0.05_97]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_224_ema.pt":
				__A							:   Optional[Any]	  =				torch.tensor([1.07_99, 0.23_22, -0.88_60, 1.02_19, 0.62_31]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_nano_22k_384_ema.pt":
				__A							:   str	  =				torch.tensor([0.37_66, 0.49_17, -1.14_26, 0.99_42, 0.60_24]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_224_ema.pt":
				__A							:   Any	  =				torch.tensor([0.42_20, -0.69_19, -0.43_17, -0.28_81, -0.66_09]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_tiny_22k_384_ema.pt":
				__A							:   Tuple	  =				torch.tensor([0.10_82, -0.82_86, -0.50_95, 0.46_81, -0.80_85]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_224_ema.pt":
				__A							:   Tuple	  =				torch.tensor([-0.24_19, -0.62_21, 0.21_76, -0.09_80, -0.75_27]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_base_22k_384_ema.pt":
				__A							:   Any	  =				torch.tensor([0.03_91, -0.43_71, 0.37_86, 0.12_51, -0.27_84]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_224_ema.pt":
				__A							:   Optional[int]	  =				torch.tensor([-0.05_04, 0.56_36, -0.17_29, -0.65_07, -0.39_49]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_large_22k_384_ema.pt":
				__A							:   List[str]	  =				torch.tensor([0.35_60, 0.94_86, 0.31_49, -0.26_67, -0.51_38]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_384_ema.pt":
				__A							:   int	  =				torch.tensor([-0.24_69, -0.45_50, -0.58_53, -0.08_10, 0.03_09]    )
		elif checkpoint_url == "https://dl.fbaipublicfiles.com/convnext/convnextv2/im22k/convnextv2_huge_22k_512_ema.pt":
				__A							:   Optional[int]	  =				torch.tensor([-0.30_90, 0.08_02, -0.06_82, -0.19_79, -0.28_26]    )
		else:
				raise ValueError(F"Unknown URL: {checkpoint_url}"    )

		assert torch.allclose(logits[0, :5] ,     _lowercase ,     atol=1E-3    )
		assert logits.shape == expected_shape
		print("Model outputs match the original results!"    )

		if save_model:
				print("Saving model to local..."    )
				# Create folder to save model
				if not os.path.isdir(_lowercase    ):
						os.mkdir(_lowercase    )

				model.save_pretrained(_lowercase    )
				preprocessor.save_pretrained(_lowercase    )

		__A							:   Optional[Any]	  =				"convnextv2"
		if "atto" in checkpoint_url:
				model_name += "-atto"
		if "femto" in checkpoint_url:
				model_name += "-femto"
		if "pico" in checkpoint_url:
				model_name += "-pico"
		if "nano" in checkpoint_url:
				model_name += "-nano"
		elif "tiny" in checkpoint_url:
				model_name += "-tiny"
		elif "base" in checkpoint_url:
				model_name += "-base"
		elif "large" in checkpoint_url:
				model_name += "-large"
		elif "huge" in checkpoint_url:
				model_name += "-huge"
		if "22k" in checkpoint_url and "1k" not in checkpoint_url:
				model_name += "-22k"
		elif "22k" in checkpoint_url and "1k" in checkpoint_url:
				model_name += "-22k-1k"
		elif "1k" in checkpoint_url:
				model_name += "-1k"
		if "224" in checkpoint_url:
				model_name += "-224"
		elif "384" in checkpoint_url:
				model_name += "-384"
		elif "512" in checkpoint_url:
				model_name += "-512"

		if push_to_hub:
				print(F"Pushing {model_name} to the hub..."    )
				model.push_to_hub(_lowercase    )
				preprocessor.push_to_hub(_lowercase    )


if __name__ == "__main__":
					UpperCamelCase      			=     argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '--checkpoint_url',
					    default='https://dl.fbaipublicfiles.com/convnext/convnextv2/im1k/convnextv2_atto_1k_224_ema.pt',
					    type=str,
					    help='URL of the original ConvNeXTV2 checkpoint you\'d like to convert.',
					)
					parser.add_argument(
					    '--pytorch_dump_folder_path',
					    default='model',
					    type=str,
					    help='Path to the output PyTorch model directory.',
					)
					parser.add_argument('--save_model', action='store_true', help='Save model to local')
					parser.add_argument('--push_to_hub', action='store_true', help='Push model and image preprocessor to the hub')

					UpperCamelCase      			=     parser.parse_args()
					convert_convnextva_checkpoint(
					    args.checkpoint_url, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub
					)






import os
import sys

from . import rsa_key_generator as rkg

UpperCamelCase      			=     128
UpperCamelCase      			=     256



def    lowerCamelCase_   (  _lowercase ,     _lowercase = DEFAULT_BLOCK_SIZE    )							->	list[int]:
		__A							:   List[str]	  =				message.encode("ascii"    )

		__A							:   str	  =				[]
		for block_start in range(0 ,     len(_lowercase    ) ,     _lowercase    ):
				__A							:   str	  =				0
				for i in range(_lowercase ,     min(block_start + block_size ,     len(_lowercase    )    )    ):
						block_int += message_bytes[i] * (BYTE_SIZE ** (i % block_size))
				block_ints.append(_lowercase    )
		return block_ints



def    lowerCamelCase_   (  _lowercase ,     _lowercase ,     _lowercase = DEFAULT_BLOCK_SIZE    )							->	str:
		__A							:   list[str]	  =				[]
		for block_int in block_ints:
				__A							:   list[str]	  =				[]
				for i in range(block_size - 1 ,     -1 ,     -1    ):
						if len(_lowercase    ) + i < message_length:
								__A							:   Optional[Any]	  =				block_int // (BYTE_SIZE**i)
								__A							:   Union[str, Any]	  =				block_int % (BYTE_SIZE**i)
								block_message.insert(0 ,     chr(_lowercase    )    )
				message.extend(_lowercase    )
		return "".join(_lowercase    )



def    lowerCamelCase_   (  _lowercase ,     _lowercase ,     _lowercase = DEFAULT_BLOCK_SIZE    )							->	list[int]:
		__A							:   List[str]	  =				[]
		__A  ,       __A							:   List[Any]	  =				key

		for block in get_blocks_from_text(_lowercase ,     _lowercase    ):
				encrypted_blocks.append(pow(_lowercase ,     _lowercase ,     _lowercase    )    )
		return encrypted_blocks



def    lowerCamelCase_   (  _lowercase ,     _lowercase ,     _lowercase ,     _lowercase = DEFAULT_BLOCK_SIZE ,     )							->	str:
		__A							:   Optional[Any]	  =				[]
		__A  ,       __A							:   Dict	  =				key
		for block in encrypted_blocks:
				decrypted_blocks.append(pow(_lowercase ,     _lowercase ,     _lowercase    )    )
		return get_text_from_blocks(_lowercase ,     _lowercase ,     _lowercase    )



def    lowerCamelCase_   (  _lowercase    )							->	tuple[int, int, int]:
		with open(_lowercase    ) as fo:
				__A							:   Optional[int]	  =				fo.read()
		__A  ,       __A  ,       __A							:   Optional[int]	  =				content.split(","    )
		return (int(_lowercase    ), int(_lowercase    ), int(_lowercase    ))



def    lowerCamelCase_   (  _lowercase ,     _lowercase ,     _lowercase ,     _lowercase = DEFAULT_BLOCK_SIZE ,     )							->	str:
		__A  ,       __A  ,       __A							:   Optional[int]	  =				read_key_file(_lowercase    )
		if key_size < block_size * 8:
				sys.exit(
				    "ERROR: Block size is {} bits and key size is {} bits. The RSA cipher "
				    "requires the block size to be equal to or greater than the key size. "
				    "Either decrease the block size or use different keys.".format(
				        block_size * 8 ,     _lowercase    )    )

		__A							:   Optional[int]	  =				[str(_lowercase    ) for i in encrypt_message(_lowercase ,     (n, e) ,     _lowercase    )]

		__A							:   int	  =				",".join(_lowercase    )
		__A							:   List[Any]	  =				F"{len(_lowercase    )}_{block_size}_{encrypted_content}"
		with open(_lowercase ,     "w"    ) as fo:
				fo.write(_lowercase    )
		return encrypted_content



def    lowerCamelCase_   (  _lowercase ,     _lowercase    )							->	str:
		__A  ,       __A  ,       __A							:   List[str]	  =				read_key_file(_lowercase    )
		with open(_lowercase    ) as fo:
				__A							:   Optional[Any]	  =				fo.read()
		__A  ,       __A  ,       __A							:   int	  =				content.split("_"    )
		__A							:   Tuple	  =				int(_lowercase    )
		__A							:   Any	  =				int(_lowercase    )

		if key_size < block_size * 8:
				sys.exit(
				    "ERROR: Block size is {} bits and key size is {} bits. The RSA cipher "
				    "requires the block size to be equal to or greater than the key size. "
				    "Did you specify the correct key file and encrypted file?".format(
				        block_size * 8 ,     _lowercase    )    )

		__A							:   Dict	  =				[]
		for block in encrypted_message.split(","    ):
				encrypted_blocks.append(int(_lowercase    )    )

		return decrypt_message(_lowercase ,     _lowercase ,     (n, d) ,     _lowercase    )



def    lowerCamelCase_   (  )							->	None:
		__A							:   int	  =				"encrypted_file.txt"
		__A							:   int	  =				input(r"Encrypt\Decrypt [e\d]: "    )

		if response.lower().startswith("e"    ):
				__A							:   str	  =				"encrypt"
		elif response.lower().startswith("d"    ):
				__A							:   str	  =				"decrypt"

		if mode == "encrypt":
				if not os.path.exists("rsa_pubkey.txt"    ):
						rkg.make_key_files("rsa" ,     1_024    )

				__A							:   Any	  =				input("\nEnter message: "    )
				__A							:   Any	  =				"rsa_pubkey.txt"
				print(F"Encrypting and writing to {filename}..."    )
				__A							:   List[str]	  =				encrypt_and_write_to_file(_lowercase ,     _lowercase ,     _lowercase    )

				print("\nEncrypted text:"    )
				print(_lowercase    )

		elif mode == "decrypt":
				__A							:   Dict	  =				"rsa_privkey.txt"
				print(F"Reading from {filename} and decrypting..."    )
				__A							:   Dict	  =				read_from_file_and_decrypt(_lowercase ,     _lowercase    )
				print("writing decryption to rsa_decryption.txt..."    )
				with open("rsa_decryption.txt" ,     "w"    ) as dec:
						dec.write(_lowercase    )

				print("\nDecryption:"    )
				print(_lowercase    )


if __name__ == "__main__":
					main()





