




import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from timm import create_model
from timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import BitConfig, BitForImageClassification, BitImageProcessor
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
__UpperCamelCase					:       Tuple    					=      logging.get_logger(__name__)





def 		__A		(	__lowerCamelCase    )      ->       List[str]:
	a										=							"""huggingface/label-files"""
	a										=							"""imagenet-1k-id2label.json"""
	a										=							json.load(open(hf_hub_download(__lowerCamelCase							,			__lowerCamelCase							,			repo_type="""dataset"""    )							,			"""r"""    )    )
	a										=							{int(__lowerCamelCase    ): v for k, v in idalabel.items()}
	a										=							{v: k for k, v in idalabel.items()}

	a										=							"""std_conv""" if """bit""" in model_name else False

	# note that when using BiT as backbone for ViT-hybrid checkpoints,
	# one needs to additionally set config.layer_type = "bottleneck", config.stem_type = "same",
	# config.conv_layer = "std_conv_same"
	a										=							BitConfig(
	    conv_layer=__lowerCamelCase							,			num_labels=1000							,			idalabel=__lowerCamelCase							,			labelaid=__lowerCamelCase							,			)

	return config





def 		__A		(	__lowerCamelCase    )      ->       Any:
	if "stem.conv" in name:
		a										=							name.replace("""stem.conv"""							,			"""bit.embedder.convolution"""    )
	if "blocks" in name:
		a										=							name.replace("""blocks"""							,			"""layers"""    )
	if "head.fc" in name:
		a										=							name.replace("""head.fc"""							,			"""classifier.1"""    )
	if name.startswith("""norm"""    ):
		a										=							"""bit.""" + name
	if "bit" not in name and "classifier" not in name:
		a										=							"""bit.encoder.""" + name

	return name





def 		__A		(	)      ->       str:
	a										=							"""http://images.cocodataset.org/val2017/000000039769.jpg"""
	a										=							Image.open(requests.get(__lowerCamelCase							,			stream=__lowerCamelCase    ).raw    )
	return im





@torch.no_grad()
def 		__A		(	__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase=False    )      ->       List[Any]:
	a										=							get_config(__lowerCamelCase    )

	# load original model from timm
	a										=							create_model(__lowerCamelCase							,			pretrained=__lowerCamelCase    )
	timm_model.eval()

	# load state_dict of original model
	a										=							timm_model.state_dict()
	for key in state_dict.copy().keys():
		a										=							state_dict.pop(__lowerCamelCase    )
		a										=							val.squeeze() if """head""" in key else val

	# load HuggingFace model
	a										=							BitForImageClassification(__lowerCamelCase    )
	model.eval()
	model.load_state_dict(__lowerCamelCase    )

	# create image processor
	a										=							create_transform(**resolve_data_config({}							,			model=__lowerCamelCase    )    )
	a										=							transform.transforms

	a										=							{
	    """bilinear""": PILImageResampling.BILINEAR,
	    """bicubic""": PILImageResampling.BICUBIC,
	    """nearest""": PILImageResampling.NEAREST,
	}

	a										=							BitImageProcessor(
	    do_resize=__lowerCamelCase							,			size={"""shortest_edge""": timm_transforms[0].size}							,			resample=pillow_resamplings[timm_transforms[0].interpolation.value]							,			do_center_crop=__lowerCamelCase							,			crop_size={"""height""": timm_transforms[1].size[0], """width""": timm_transforms[1].size[1]}							,			do_normalize=__lowerCamelCase							,			image_mean=timm_transforms[-1].mean.tolist()							,			image_std=timm_transforms[-1].std.tolist()							,			)

	a										=							prepare_img()
	a										=							transform(__lowerCamelCase    ).unsqueeze(0    )
	a										=							processor(__lowerCamelCase							,			return_tensors="""pt"""    ).pixel_values

	# verify pixel values
	assert torch.allclose(__lowerCamelCase							,			__lowerCamelCase    )

	# verify logits
	with torch.no_grad():
		a										=							model(__lowerCamelCase    )
		a										=							outputs.logits

	print("""Logits:"""							,			logits[0, :3]    )
	print("""Predicted class:"""							,			model.config.idalabel[logits.argmax(-1    ).item()]    )
	a										=							timm_model(__lowerCamelCase    )
	assert timm_logits.shape == outputs.logits.shape
	assert torch.allclose(__lowerCamelCase							,			outputs.logits							,			atol=1E-3    )
	print("""Looks ok!"""    )

	if pytorch_dump_folder_path is not None:
		Path(__lowerCamelCase    ).mkdir(exist_ok=__lowerCamelCase    )
		print(f'Saving model {model_name} and processor to {pytorch_dump_folder_path}'    )
		model.save_pretrained(__lowerCamelCase    )
		processor.save_pretrained(__lowerCamelCase    )

	if push_to_hub:
		print(f'Pushing model {model_name} and processor to the hub'    )
		model.push_to_hub(f'ybelkada/{model_name}'    )
		processor.push_to_hub(f'ybelkada/{model_name}'    )


if __name__ == "__main__":
		__UpperCamelCase					:       str    					=      argparse.ArgumentParser()
		# Required parameters
		parser.add_argument(
		    "--model_name",
		    default="resnetv2_50x1_bitm",
		    type=str,
		    help="Name of the BiT timm 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 to the hub.",
		)

		__UpperCamelCase					:       Tuple    					=      parser.parse_args()
		convert_bit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







import math
from datetime import datetime, timedelta





def 		__A		(	__lowerCamelCase    )      ->       datetime:
	a										=							year % 19
	a										=							year % 4
	a										=							year % 7
	a										=							math.floor(year / 100    )
	a										=							math.floor((13 + 8 * leap_day_inhibits) / 25    )
	a										=							leap_day_inhibits / 4
	a										=							(
	    15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
	) % 30
	a										=							(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

	# days to be added to March 21
	a										=							(19 * metonic_cycle + secular_moon_shift) % 30

	# PHM -> Paschal Full Moon
	a										=							(
	    2 * julian_leap_year
	    + 4 * non_leap_year
	    + 6 * days_to_add
	    + century_starting_point
	) % 7

	if days_to_add == 29 and days_from_phm_to_sunday == 6:
		return datetime(__lowerCamelCase							,			4							,			19    )
	elif days_to_add == 28 and days_from_phm_to_sunday == 6:
		return datetime(__lowerCamelCase							,			4							,			18    )
	else:
		return datetime(__lowerCamelCase							,			3							,			22    ) + timedelta(
		    days=int(days_to_add + days_from_phm_to_sunday    )    )


if __name__ == "__main__":
		for year in (1_994, 2_000, 2_010, 2_021, 2_023):
				__UpperCamelCase					:       Tuple    					=      "will be" if year > datetime.now().year else "was"
				print(F'Easter in {year} {tense} {gauss_easter(year)}')

