




import argparse
import json

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

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling

def 			a   (_lowerCAmelCase     ):
							SCREAMING_SNAKE_CASE_   	=    [2, 2, 6, 2] if '''tiny''' in model_name else [2, 2, 1_8, 2]
							SCREAMING_SNAKE_CASE_   	=    True if '''large''' in model_name or '''huge''' in model_name else False
							SCREAMING_SNAKE_CASE_   	=    True if '''large''' in model_name or '''huge''' in model_name else False
							SCREAMING_SNAKE_CASE_   	=    True if '''large''' in model_name or '''huge''' in model_name else False

							if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
														if "fl3" in model_name:
																					SCREAMING_SNAKE_CASE_   	=    [3, 3, 3, 3]
																					SCREAMING_SNAKE_CASE_   	=    [5, 5, 5, 5]
														elif "fl4" in model_name:
																					SCREAMING_SNAKE_CASE_   	=    [4, 4, 4, 4]
																					SCREAMING_SNAKE_CASE_   	=    [3, 3, 3, 3]

							if "tiny" in model_name or "small" in model_name or "base" in model_name:
														SCREAMING_SNAKE_CASE_   	=    [3, 3, 3, 3]
														if "lrf" in model_name:
																					SCREAMING_SNAKE_CASE_   	=    [3, 3, 3, 3]
														else:
																					SCREAMING_SNAKE_CASE_   	=    [2, 2, 2, 2]

							if "tiny" in model_name:
														SCREAMING_SNAKE_CASE_   	=    9_6
							elif "small" in model_name:
														SCREAMING_SNAKE_CASE_   	=    9_6
							elif "base" in model_name:
														SCREAMING_SNAKE_CASE_   	=    1_2_8
							elif "large" in model_name:
														SCREAMING_SNAKE_CASE_   	=    1_9_2
							elif "xlarge" in model_name:
														SCREAMING_SNAKE_CASE_   	=    2_5_6
							elif "huge" in model_name:
														SCREAMING_SNAKE_CASE_   	=    3_5_2

							# set label information
							SCREAMING_SNAKE_CASE_   	=    '''huggingface/label-files'''
							if "large" in model_name or "huge" in model_name:
														SCREAMING_SNAKE_CASE_   	=    '''imagenet-22k-id2label.json'''
							else:
														SCREAMING_SNAKE_CASE_   	=    '''imagenet-1k-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_   	=    FocalNetConfig(
							    embed_dim=_lowerCAmelCase  ,    depths=_lowerCAmelCase  ,    focal_levels=_lowerCAmelCase  ,    focal_windows=_lowerCAmelCase  ,    use_conv_embed=_lowerCAmelCase  ,    idalabel=_lowerCAmelCase  ,    labelaid=_lowerCAmelCase  ,    use_post_layernorm=_lowerCAmelCase  ,    use_layerscale=_lowerCAmelCase  ,    )

							return config

def 			a   (_lowerCAmelCase     ):
							if "patch_embed.proj" in name:
														SCREAMING_SNAKE_CASE_   	=    name.replace('''patch_embed.proj'''  ,    '''embeddings.patch_embeddings.projection'''     )
							if "patch_embed.norm" in name:
														SCREAMING_SNAKE_CASE_   	=    name.replace('''patch_embed.norm'''  ,    '''embeddings.norm'''     )
							if "layers" in name:
														SCREAMING_SNAKE_CASE_   	=    '''encoder.''' + name
							if "encoder.layers" in name:
														SCREAMING_SNAKE_CASE_   	=    name.replace('''encoder.layers'''  ,    '''encoder.stages'''     )
							if "downsample.proj" in name:
														SCREAMING_SNAKE_CASE_   	=    name.replace('''downsample.proj'''  ,    '''downsample.projection'''     )
							if "blocks" in name:
														SCREAMING_SNAKE_CASE_   	=    name.replace('''blocks'''  ,    '''layers'''     )
							if "modulation.f.weight" in name or "modulation.f.bias" in name:
														SCREAMING_SNAKE_CASE_   	=    name.replace('''modulation.f'''  ,    '''modulation.projection_in'''     )
							if "modulation.h.weight" in name or "modulation.h.bias" in name:
														SCREAMING_SNAKE_CASE_   	=    name.replace('''modulation.h'''  ,    '''modulation.projection_context'''     )
							if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
														SCREAMING_SNAKE_CASE_   	=    name.replace('''modulation.proj'''  ,    '''modulation.projection_out'''     )

							if name == "norm.weight":
														SCREAMING_SNAKE_CASE_   	=    '''layernorm.weight'''
							if name == "norm.bias":
														SCREAMING_SNAKE_CASE_   	=    '''layernorm.bias'''

							if "head" in name:
														SCREAMING_SNAKE_CASE_   	=    name.replace('''head'''  ,    '''classifier'''     )
							else:
														SCREAMING_SNAKE_CASE_   	=    '''focalnet.''' + name

							return name

def 			a   (_lowerCAmelCase  ,    _lowerCAmelCase  ,    _lowerCAmelCase=False     ):
							# fmt: off
							SCREAMING_SNAKE_CASE_   	=    {
							    '''focalnet-tiny''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth''',
							    '''focalnet-tiny-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth''',
							    '''focalnet-small''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth''',
							    '''focalnet-small-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth''',
							    '''focalnet-base''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth''',
							    '''focalnet-base-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth''',
							    '''focalnet-large-lrf-fl3''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth''',
							    '''focalnet-large-lrf-fl4''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth''',
							    '''focalnet-xlarge-lrf-fl3''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth''',
							    '''focalnet-xlarge-lrf-fl4''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth''',
							}
							# fmt: on

							SCREAMING_SNAKE_CASE_   	=    model_name_to_url[model_name]
							print('''Checkpoint URL: '''  ,    _lowerCAmelCase     )
							SCREAMING_SNAKE_CASE_   	=    torch.hub.load_state_dict_from_url(_lowerCAmelCase  ,    map_location='''cpu'''     )['''model''']

							# rename keys
							for key in state_dict.copy().keys():
														SCREAMING_SNAKE_CASE_   	=    state_dict.pop(_lowerCAmelCase     )
														SCREAMING_SNAKE_CASE_   	=    val

							SCREAMING_SNAKE_CASE_   	=    get_focalnet_config(_lowerCAmelCase     )
							SCREAMING_SNAKE_CASE_   	=    FocalNetForImageClassification(_lowerCAmelCase     )
							model.eval()

							# load state dict
							model.load_state_dict(_lowerCAmelCase     )

							# verify conversion
							SCREAMING_SNAKE_CASE_   	=    '''http://images.cocodataset.org/val2017/000000039769.jpg'''

							SCREAMING_SNAKE_CASE_   	=    BitImageProcessor(
							    do_resize=_lowerCAmelCase  ,    size={'''shortest_edge''': 2_5_6}  ,    resample=PILImageResampling.BILINEAR  ,    do_center_crop=_lowerCAmelCase  ,    crop_size=2_2_4  ,    do_normalize=_lowerCAmelCase  ,    image_mean=_lowerCAmelCase  ,    image_std=_lowerCAmelCase  ,    )
							SCREAMING_SNAKE_CASE_   	=    Image.open(requests.get(_lowerCAmelCase  ,    stream=_lowerCAmelCase     ).raw     )
							SCREAMING_SNAKE_CASE_   	=    processor(images=_lowerCAmelCase  ,    return_tensors='''pt'''     )

							SCREAMING_SNAKE_CASE_   	=    transforms.Compose(
							    [
							        transforms.Resize(2_5_6     ),
							        transforms.CenterCrop(2_2_4     ),
							        transforms.ToTensor(),
							        transforms.Normalize(mean=[0.485, 0.456, 0.406]  ,    std=[0.229, 0.224, 0.225]     ),
							    ]     )

							SCREAMING_SNAKE_CASE_   	=    image_transforms(_lowerCAmelCase     ).unsqueeze(0     )

							# verify pixel_values
							assert torch.allclose(inputs.pixel_values  ,    _lowerCAmelCase  ,    atol=1e-4     )

							SCREAMING_SNAKE_CASE_   	=    model(**_lowerCAmelCase     )

							SCREAMING_SNAKE_CASE_   	=    outputs.logits.argmax(-1     ).item()
							print('''Predicted class:'''  ,    model.config.idalabel[predicted_class_idx]     )

							print('''First values of logits:'''  ,    outputs.logits[0, :3]     )

							if model_name == "focalnet-tiny":
														SCREAMING_SNAKE_CASE_   	=    torch.tensor([0.2166, -0.4368, 0.2191]     )
							elif model_name == "focalnet-tiny-lrf":
														SCREAMING_SNAKE_CASE_   	=    torch.tensor([1.1669, 0.0125, -0.1695]     )
							elif model_name == "focalnet-small":
														SCREAMING_SNAKE_CASE_   	=    torch.tensor([0.4917, -0.0430, 0.1341]     )
							elif model_name == "focalnet-small-lrf":
														SCREAMING_SNAKE_CASE_   	=    torch.tensor([-0.2588, -0.5342, -0.2331]     )
							elif model_name == "focalnet-base":
														SCREAMING_SNAKE_CASE_   	=    torch.tensor([-0.1655, -0.4090, -0.1730]     )
							elif model_name == "focalnet-base-lrf":
														SCREAMING_SNAKE_CASE_   	=    torch.tensor([0.5306, -0.0483, -0.3928]     )
							assert torch.allclose(outputs.logits[0, :3]  ,    _lowerCAmelCase  ,    atol=1e-4     )
							print('''Looks ok!'''     )

							if pytorch_dump_folder_path is not None:
														print(F"Saving model and processor of {model_name} to {pytorch_dump_folder_path}"     )
														model.save_pretrained(_lowerCAmelCase     )
														processor.save_pretrained(_lowerCAmelCase     )

							if push_to_hub:
														print(F"Pushing model and processor of {model_name} to the hub..."     )
														model.push_to_hub(F"{model_name}"     )
														processor.push_to_hub(F"{model_name}"     )


if __name__ == "__main__":
			__SCREAMING_SNAKE_CASE 						=argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    """--model_name""",
			    default="""focalnet-tiny""",
			    type=str,
			    help="""Name of the FocalNet 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 to push the model and processor to the hub.""",
			)

			__SCREAMING_SNAKE_CASE 						=parser.parse_args()
			convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)








import webbrowser
from sys import argv
from urllib.parse import parse_qs, quote

import requests
from bsa import BeautifulSoup
from fake_useragent import UserAgent

if __name__ == "__main__":
			__SCREAMING_SNAKE_CASE 						="""%20""".join(argv[1:]) if len(argv) > 1 else quote(str(input("""Search: """)))

			print("""Googling.....""")

			__SCREAMING_SNAKE_CASE 						=f"""https://www.google.com/search?q={query}&num=100"""

			__SCREAMING_SNAKE_CASE 						=requests.get(
			    url,
			    headers={"""User-Agent""": str(UserAgent().random)},
			)

			try:
						__SCREAMING_SNAKE_CASE 						=(
						    BeautifulSoup(res.text, """html.parser""")
						    .find("""div""", attrs={"""class""": """yuRUbf"""})
						    .find("""a""")
						    .get("""href""")
						)

			except AttributeError:
						__SCREAMING_SNAKE_CASE 						=parse_qs(
						    BeautifulSoup(res.text, """html.parser""")
						    .find("""div""", attrs={"""class""": """kCrYT"""})
						    .find("""a""")
						    .get("""href""")
						)["""url"""][0]

			webbrowser.open(link)


