

"""simple docstring"""




import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_url
from PIL import Image

from transformers import DPTConfig, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
_lowercase   :	int												=						logging.get_logger(__name__)





def       lowercase__						(       snake_case_   :List[Any]    ):
	__UpperCAmelCase      		= DPTConfig()

	if "large" in checkpoint_url:
		__UpperCAmelCase      		= 1_024
		__UpperCAmelCase      		= 4_096
		__UpperCAmelCase      		= 24
		__UpperCAmelCase      		= 16
		__UpperCAmelCase      		= [5, 11, 17, 23]
		__UpperCAmelCase      		= [256, 512, 1_024, 1_024]
		__UpperCAmelCase      		= (1, 384, 384)

	if "ade" in checkpoint_url:
		__UpperCAmelCase      		= True

		__UpperCAmelCase      		= 150
		__UpperCAmelCase      		= 'huggingface/label-files'
		__UpperCAmelCase      		= 'ade20k-id2label.json'
		__UpperCAmelCase      		= json.load(open(cached_download(hf_hub_url(_snake_case			,		_snake_case			,		repo_type='''dataset'''    )    )			,		'''r'''    )    )
		__UpperCAmelCase      		= {int(_snake_case    ): v for k, v in idalabel.items()}
		__UpperCAmelCase      		= idalabel
		__UpperCAmelCase      		= {v: k for k, v in idalabel.items()}
		__UpperCAmelCase      		= [1, 150, 480, 480]

	return config, expected_shape





def       lowercase__						(       snake_case_   :List[Any]    ):
	__UpperCAmelCase      		= ['pretrained.model.head.weight', 'pretrained.model.head.bias']
	for k in ignore_keys:
		state_dict.pop(_snake_case			,		_snake_case    )





def       lowercase__						(       snake_case_   :Union[str, Any]    ):
	if (
	    "pretrained.model" in name
	    and "cls_token" not in name
	    and "pos_embed" not in name
	    and "patch_embed" not in name
	):
		__UpperCAmelCase      		= name.replace('''pretrained.model'''			,		'''dpt.encoder'''    )
	if "pretrained.model" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.model'''			,		'''dpt.embeddings'''    )
	if "patch_embed" in name:
		__UpperCAmelCase      		= name.replace('''patch_embed'''			,		'''patch_embeddings'''    )
	if "pos_embed" in name:
		__UpperCAmelCase      		= name.replace('''pos_embed'''			,		'''position_embeddings'''    )
	if "attn.proj" in name:
		__UpperCAmelCase      		= name.replace('''attn.proj'''			,		'''attention.output.dense'''    )
	if "proj" in name and "project" not in name:
		__UpperCAmelCase      		= name.replace('''proj'''			,		'''projection'''    )
	if "blocks" in name:
		__UpperCAmelCase      		= name.replace('''blocks'''			,		'''layer'''    )
	if "mlp.fc1" in name:
		__UpperCAmelCase      		= name.replace('''mlp.fc1'''			,		'''intermediate.dense'''    )
	if "mlp.fc2" in name:
		__UpperCAmelCase      		= name.replace('''mlp.fc2'''			,		'''output.dense'''    )
	if "norm1" in name:
		__UpperCAmelCase      		= name.replace('''norm1'''			,		'''layernorm_before'''    )
	if "norm2" in name:
		__UpperCAmelCase      		= name.replace('''norm2'''			,		'''layernorm_after'''    )
	if "scratch.output_conv" in name:
		__UpperCAmelCase      		= name.replace('''scratch.output_conv'''			,		'''head'''    )
	if "scratch" in name:
		__UpperCAmelCase      		= name.replace('''scratch'''			,		'''neck'''    )
	if "layer1_rn" in name:
		__UpperCAmelCase      		= name.replace('''layer1_rn'''			,		'''convs.0'''    )
	if "layer2_rn" in name:
		__UpperCAmelCase      		= name.replace('''layer2_rn'''			,		'''convs.1'''    )
	if "layer3_rn" in name:
		__UpperCAmelCase      		= name.replace('''layer3_rn'''			,		'''convs.2'''    )
	if "layer4_rn" in name:
		__UpperCAmelCase      		= name.replace('''layer4_rn'''			,		'''convs.3'''    )
	if "refinenet" in name:
		__UpperCAmelCase      		= int(name[len('''neck.refinenet'''    ) : len('''neck.refinenet'''    ) + 1]    )
		# tricky here: we need to map 4 to 0, 3 to 1, 2 to 2 and 1 to 3
		__UpperCAmelCase      		= name.replace(F'''refinenet{layer_idx}'''			,		F'''fusion_stage.layers.{abs(layer_idx-4    )}'''    )
	if "out_conv" in name:
		__UpperCAmelCase      		= name.replace('''out_conv'''			,		'''projection'''    )
	if "resConfUnit1" in name:
		__UpperCAmelCase      		= name.replace('''resConfUnit1'''			,		'''residual_layer1'''    )
	if "resConfUnit2" in name:
		__UpperCAmelCase      		= name.replace('''resConfUnit2'''			,		'''residual_layer2'''    )
	if "conv1" in name:
		__UpperCAmelCase      		= name.replace('''conv1'''			,		'''convolution1'''    )
	if "conv2" in name:
		__UpperCAmelCase      		= name.replace('''conv2'''			,		'''convolution2'''    )
	# readout blocks
	if "pretrained.act_postprocess1.0.project.0" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess1.0.project.0'''			,		'''neck.reassemble_stage.readout_projects.0.0'''    )
	if "pretrained.act_postprocess2.0.project.0" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess2.0.project.0'''			,		'''neck.reassemble_stage.readout_projects.1.0'''    )
	if "pretrained.act_postprocess3.0.project.0" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess3.0.project.0'''			,		'''neck.reassemble_stage.readout_projects.2.0'''    )
	if "pretrained.act_postprocess4.0.project.0" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess4.0.project.0'''			,		'''neck.reassemble_stage.readout_projects.3.0'''    )
	# resize blocks
	if "pretrained.act_postprocess1.3" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess1.3'''			,		'''neck.reassemble_stage.layers.0.projection'''    )
	if "pretrained.act_postprocess1.4" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess1.4'''			,		'''neck.reassemble_stage.layers.0.resize'''    )
	if "pretrained.act_postprocess2.3" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess2.3'''			,		'''neck.reassemble_stage.layers.1.projection'''    )
	if "pretrained.act_postprocess2.4" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess2.4'''			,		'''neck.reassemble_stage.layers.1.resize'''    )
	if "pretrained.act_postprocess3.3" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess3.3'''			,		'''neck.reassemble_stage.layers.2.projection'''    )
	if "pretrained.act_postprocess4.3" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess4.3'''			,		'''neck.reassemble_stage.layers.3.projection'''    )
	if "pretrained.act_postprocess4.4" in name:
		__UpperCAmelCase      		= name.replace('''pretrained.act_postprocess4.4'''			,		'''neck.reassemble_stage.layers.3.resize'''    )
	if "pretrained" in name:
		__UpperCAmelCase      		= name.replace('''pretrained'''			,		'''dpt'''    )
	if "bn" in name:
		__UpperCAmelCase      		= name.replace('''bn'''			,		'''batch_norm'''    )
	if "head" in name:
		__UpperCAmelCase      		= name.replace('''head'''			,		'''head.head'''    )
	if "encoder.norm" in name:
		__UpperCAmelCase      		= name.replace('''encoder.norm'''			,		'''layernorm'''    )
	if "auxlayer" in name:
		__UpperCAmelCase      		= name.replace('''auxlayer'''			,		'''auxiliary_head.head'''    )

	return name





def       lowercase__						(       snake_case_   :List[str]			,		snake_case_   :str    ):
	for i in range(config.num_hidden_layers    ):
		# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
		__UpperCAmelCase      		= state_dict.pop(F'''dpt.encoder.layer.{i}.attn.qkv.weight'''    )
		__UpperCAmelCase      		= state_dict.pop(F'''dpt.encoder.layer.{i}.attn.qkv.bias'''    )
		# next, add query, keys and values (in that order) to the state dict
		__UpperCAmelCase      		= in_proj_weight[: config.hidden_size, :]
		__UpperCAmelCase      		= in_proj_bias[: config.hidden_size]
		__UpperCAmelCase      		= in_proj_weight[
		    config.hidden_size : config.hidden_size * 2, :
		]
		__UpperCAmelCase      		= in_proj_bias[
		    config.hidden_size : config.hidden_size * 2
		]
		__UpperCAmelCase      		= in_proj_weight[
		    -config.hidden_size :, :
		]
		__UpperCAmelCase      		= in_proj_bias[-config.hidden_size :]





def       lowercase__						(       ):
	__UpperCAmelCase      		= 'http://images.cocodataset.org/val2017/000000039769.jpg'
	__UpperCAmelCase      		= Image.open(requests.get(_snake_case			,		stream=_snake_case    ).raw    )
	return im





@torch.no_grad()
def       lowercase__						(       snake_case_   :Dict			,		snake_case_   :Any			,		snake_case_   :List[Any]			,		snake_case_   :List[Any]    ):
	__UpperCAmelCase      		= get_dpt_config(_snake_case    )
	# load original state_dict from URL
	__UpperCAmelCase      		= torch.hub.load_state_dict_from_url(_snake_case			,		map_location='''cpu'''    )
	# remove certain keys
	remove_ignore_keys_(_snake_case    )
	# rename keys
	for key in state_dict.copy().keys():
		__UpperCAmelCase      		= state_dict.pop(_snake_case    )
		__UpperCAmelCase      		= val
	# read in qkv matrices
	read_in_q_k_v(_snake_case			,		_snake_case    )

	# load HuggingFace model
	__UpperCAmelCase      		= DPTForSemanticSegmentation(_snake_case    ) if 'ade' in checkpoint_url else DPTForDepthEstimation(_snake_case    )
	model.load_state_dict(_snake_case    )
	model.eval()

	# Check outputs on an image
	__UpperCAmelCase      		= 480 if 'ade' in checkpoint_url else 384
	__UpperCAmelCase      		= DPTImageProcessor(size=_snake_case    )

	__UpperCAmelCase      		= prepare_img()
	__UpperCAmelCase      		= image_processor(_snake_case			,		return_tensors='''pt'''    )

	# forward pass
	__UpperCAmelCase      		= model(**_snake_case    ).logits if 'ade' in checkpoint_url else model(**_snake_case    ).predicted_depth

	# Assert logits
	__UpperCAmelCase      		= torch.tensor([[6.3199, 6.3629, 6.4148], [6.3850, 6.3615, 6.4166], [6.3519, 6.3176, 6.3575]]    )
	if "ade" in checkpoint_url:
		__UpperCAmelCase      		= torch.tensor([[4.0480, 4.2420, 4.4360], [4.3124, 4.5693, 4.8261], [4.5768, 4.8965, 5.2163]]    )
	assert outputs.shape == torch.Size(_snake_case    )
	assert (
	    torch.allclose(outputs[0, 0, :3, :3]			,		_snake_case			,		atol=1E-4    )
	    if "ade" in checkpoint_url
	    else torch.allclose(outputs[0, :3, :3]			,		_snake_case    )
	)

	Path(_snake_case    ).mkdir(exist_ok=_snake_case    )
	print(F'''Saving model to {pytorch_dump_folder_path}'''    )
	model.save_pretrained(_snake_case    )
	print(F'''Saving image processor to {pytorch_dump_folder_path}'''    )
	image_processor.save_pretrained(_snake_case    )

	if push_to_hub:
		print('''Pushing model to hub...'''    )
		model.push_to_hub(
		    repo_path_or_name=Path(_snake_case			,		_snake_case    )			,		organization='''nielsr'''			,		commit_message='''Add model'''			,		use_temp_dir=_snake_case			,		)
		image_processor.push_to_hub(
		    repo_path_or_name=Path(_snake_case			,		_snake_case    )			,		organization='''nielsr'''			,		commit_message='''Add image processor'''			,		use_temp_dir=_snake_case			,		)


if __name__ == "__main__":
				_lowercase   :	Optional[int]												=						argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '--checkpoint_url',
				    default='https://github.com/intel-isl/DPT/releases/download/1_0/dpt_large-midas-2f21e586.pt',
				    type=str,
				    help='URL of the original DPT checkpoint you\'d like to convert.',
				)
				parser.add_argument(
				    '--pytorch_dump_folder_path',
				    default=None,
				    type=str,
				    required=True,
				    help='Path to the output PyTorch model directory.',
				)
				parser.add_argument(
				    '--push_to_hub',
				    action='store_true',
				)
				parser.add_argument(
				    '--model_name',
				    default='dpt-large',
				    type=str,
				    help='Name of the model, in case you\'re pushing to the hub.',
				)

				_lowercase   :	List[str]												=						parser.parse_args()
				convert_dpt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub, args.model_name)


"""simple docstring"""



from itertools import permutations
def 					lowerCamelCase   (     _snake_case ):
    if num[3] % 2 != 0:
        return False

    if (num[2] + num[3] + num[4]) % 3 != 0:
        return False

    if num[5] % 5 != 0:
        return False

    UpperCAmelCase__	:      List[str]     							=					[7, 11, 13, 17]
    for i, test in enumerate(_snake_case ):
        if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
            return False
    return True
def 					lowerCamelCase   (     _snake_case = 10 ):
    return sum(
        int(''.join(map(_snake_case    ,_snake_case ) ) )
        for num in permutations(range(_snake_case ) )
        if is_substring_divisible(_snake_case ) )


if __name__ == "__main__":
    print(f'{solution() = }')

