"""simple docstring"""


import argparse
import json

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

from transformers import ViTImageProcessor, ViTMSNConfig, ViTMSNModel
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD


torch.set_grad_enabled(False)






def 			__UpperCAmelCase    (	lowercase      ,lowercase=False						):







  """simple docstring"""
  _UpperCAmelCase         =					[]
  for i in range(config.num_hidden_layers						):
    # encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
    rename_keys.append((f'''module.blocks.{i}.norm1.weight''', f'''vit.encoder.layer.{i}.layernorm_before.weight''')						)
    rename_keys.append((f'''module.blocks.{i}.norm1.bias''', f'''vit.encoder.layer.{i}.layernorm_before.bias''')						)
    rename_keys.append(
        (f'''module.blocks.{i}.attn.proj.weight''', f'''vit.encoder.layer.{i}.attention.output.dense.weight''')						)
    rename_keys.append((f'''module.blocks.{i}.attn.proj.bias''', f'''vit.encoder.layer.{i}.attention.output.dense.bias''')						)
    rename_keys.append((f'''module.blocks.{i}.norm2.weight''', f'''vit.encoder.layer.{i}.layernorm_after.weight''')						)
    rename_keys.append((f'''module.blocks.{i}.norm2.bias''', f'''vit.encoder.layer.{i}.layernorm_after.bias''')						)
    rename_keys.append((f'''module.blocks.{i}.mlp.fc1.weight''', f'''vit.encoder.layer.{i}.intermediate.dense.weight''')						)
    rename_keys.append((f'''module.blocks.{i}.mlp.fc1.bias''', f'''vit.encoder.layer.{i}.intermediate.dense.bias''')						)
    rename_keys.append((f'''module.blocks.{i}.mlp.fc2.weight''', f'''vit.encoder.layer.{i}.output.dense.weight''')						)
    rename_keys.append((f'''module.blocks.{i}.mlp.fc2.bias''', f'''vit.encoder.layer.{i}.output.dense.bias''')						)

  # projection layer + position embeddings
  rename_keys.extend(
      [
          ("""module.cls_token""", """vit.embeddings.cls_token"""),
          ("""module.patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight"""),
          ("""module.patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias"""),
          ("""module.pos_embed""", """vit.embeddings.position_embeddings"""),
      ]						)

  if base_model:
    # layernorm + pooler
    rename_keys.extend(
        [
            ("""module.norm.weight""", """layernorm.weight"""),
            ("""module.norm.bias""", """layernorm.bias"""),
        ]						)

    # if just the base model, we should remove "vit" from all keys that start with "vit"
    _UpperCAmelCase         =					[(pair[0], pair[1][4:]) if pair[1].startswith("""vit"""						) else pair for pair in rename_keys]
  else:
    # layernorm + classification head
    rename_keys.extend(
        [
            ("""norm.weight""", """vit.layernorm.weight"""),
            ("""norm.bias""", """vit.layernorm.bias"""),
            ("""head.weight""", """classifier.weight"""),
            ("""head.bias""", """classifier.bias"""),
        ]						)

  return rename_keys






def 			__UpperCAmelCase    (	lowercase      ,lowercase      ,lowercase=False						):







  """simple docstring"""
  for i in range(config.num_hidden_layers						):
    if base_model:
      _UpperCAmelCase         =					""""""
    else:
      _UpperCAmelCase         =					"""vit."""
    # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
    _UpperCAmelCase         =					state_dict.pop(f'''module.blocks.{i}.attn.qkv.weight'''						)
    _UpperCAmelCase         =					state_dict.pop(f'''module.blocks.{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 			__UpperCAmelCase    (	lowercase						):







  """simple docstring"""
  _UpperCAmelCase         =					["""head.weight""", """head.bias"""]
  for k in ignore_keys:
    state_dict.pop(lowercase      ,lowercase						)






def 			__UpperCAmelCase    (	lowercase						):







  """simple docstring"""
  # projection head is used in the self-supervised pre-training in MSN,
  # for downstream task it's not needed.
  _UpperCAmelCase         =					[
      """module.fc.fc1.weight""",
      """module.fc.fc1.bias""",
      """module.fc.bn1.weight""",
      """module.fc.bn1.bias""",
      """module.fc.bn1.running_mean""",
      """module.fc.bn1.running_var""",
      """module.fc.bn1.num_batches_tracked""",
      """module.fc.fc2.weight""",
      """module.fc.fc2.bias""",
      """module.fc.bn2.weight""",
      """module.fc.bn2.bias""",
      """module.fc.bn2.running_mean""",
      """module.fc.bn2.running_var""",
      """module.fc.bn2.num_batches_tracked""",
      """module.fc.fc3.weight""",
      """module.fc.fc3.bias""",
  ]
  for k in ignore_keys:
    state_dict.pop(lowercase      ,lowercase						)






def 			__UpperCAmelCase    (	lowercase      ,lowercase      ,lowercase						):







  """simple docstring"""
  _UpperCAmelCase         =					dct.pop(lowercase						)
  _UpperCAmelCase         =					val






def 			__UpperCAmelCase    (	lowercase      ,lowercase						):







  """simple docstring"""
  _UpperCAmelCase         =					ViTMSNConfig()
  _UpperCAmelCase         =					10_00

  _UpperCAmelCase         =					"""datasets/huggingface/label-files"""
  _UpperCAmelCase         =					"""imagenet-1k-id2label.json"""
  _UpperCAmelCase         =					json.load(open(hf_hub_download(lowercase      ,lowercase						)      ,"""r"""						)						)
  _UpperCAmelCase         =					{int(lowercase						): v for k, v in idalabel.items()}
  _UpperCAmelCase         =					idalabel
  _UpperCAmelCase         =					{v: k for k, v in idalabel.items()}

  if "s16" in checkpoint_url:
    _UpperCAmelCase         =					3_84
    _UpperCAmelCase         =					15_36
    _UpperCAmelCase         =					6
  elif "l16" in checkpoint_url:
    _UpperCAmelCase         =					10_24
    _UpperCAmelCase         =					40_96
    _UpperCAmelCase         =					24
    _UpperCAmelCase         =					16
    _UpperCAmelCase         =					0.1
  elif "b4" in checkpoint_url:
    _UpperCAmelCase         =					4
  elif "l7" in checkpoint_url:
    _UpperCAmelCase         =					7
    _UpperCAmelCase         =					10_24
    _UpperCAmelCase         =					40_96
    _UpperCAmelCase         =					24
    _UpperCAmelCase         =					16
    _UpperCAmelCase         =					0.1

  _UpperCAmelCase         =					ViTMSNModel(lowercase						)

  _UpperCAmelCase         =					torch.hub.load_state_dict_from_url(lowercase      ,map_location="""cpu"""						)["""target_encoder"""]

  _UpperCAmelCase         =					ViTImageProcessor(size=config.image_size						)

  remove_projection_head(lowercase						)
  _UpperCAmelCase         =					create_rename_keys(lowercase      ,base_model=lowercase						)

  for src, dest in rename_keys:
    rename_key(lowercase      ,lowercase      ,lowercase						)
  read_in_q_k_v(lowercase      ,lowercase      ,base_model=lowercase						)

  model.load_state_dict(lowercase						)
  model.eval()

  _UpperCAmelCase         =					"""http://images.cocodataset.org/val2017/000000039769.jpg"""

  _UpperCAmelCase         =					Image.open(requests.get(lowercase      ,stream=lowercase						).raw						)
  _UpperCAmelCase         =					ViTImageProcessor(
      size=config.image_size      ,image_mean=lowercase      ,image_std=lowercase						)
  _UpperCAmelCase         =					image_processor(images=lowercase      ,return_tensors="""pt"""						)

  # forward pass
  torch.manual_seed(2						)
  _UpperCAmelCase         =					model(**lowercase						)
  _UpperCAmelCase         =					outputs.last_hidden_state

  # The following Colab Notebook was used to generate these outputs:
  # https://colab.research.google.com/gist/sayakpaul/3672419a04f5997827503fd84079bdd1/scratchpad.ipynb
  if "s16" in checkpoint_url:
    _UpperCAmelCase         =					torch.tensor([[-1.09_15, -1.48_76, -1.18_09]]						)
  elif "b16" in checkpoint_url:
    _UpperCAmelCase         =					torch.tensor([[14.28_89, -18.90_45, 11.72_81]]						)
  elif "l16" in checkpoint_url:
    _UpperCAmelCase         =					torch.tensor([[41.50_28, -22.86_81, 45.64_75]]						)
  elif "b4" in checkpoint_url:
    _UpperCAmelCase         =					torch.tensor([[-4.38_68, 5.29_32, -0.41_37]]						)
  else:
    _UpperCAmelCase         =					torch.tensor([[-0.17_92, -0.64_65, 2.42_63]]						)

  # verify logits
  assert torch.allclose(last_hidden_state[:, 0, :3]      ,lowercase      ,atol=1E-4						)

  print(f'''Saving model to {pytorch_dump_folder_path}'''						)
  model.save_pretrained(lowercase						)

  print(f'''Saving image processor to {pytorch_dump_folder_path}'''						)
  image_processor.save_pretrained(lowercase						)


if __name__ == "__main__":
    UpperCAmelCase__     						=  argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        """--checkpoint_url""",
        default="""https://dl.fbaipublicfiles.com/msn/vits16_800ep.pth.tar""",
        type=str,
        help="""URL of the checkpoint you'd like to convert.""",
    )
    parser.add_argument(
        """--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model directory."""
    )

    UpperCAmelCase__     						=  parser.parse_args()
    convert_vit_msn_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)

"""simple docstring"""


import requests

UpperCAmelCase__     						=  """"""  # <-- Put your OpenWeatherMap appid here!
UpperCAmelCase__     						=  """https://api.openweathermap.org/data/2.5/"""






def 			__UpperCAmelCase    (	lowercase = "Chicago"      ,lowercase = APPID						):







  """simple docstring"""
  return requests.get(URL_BASE + """weather"""      ,params=locals()						).json()






def 			__UpperCAmelCase    (	lowercase = "Kolkata, India"      ,lowercase = APPID						):







  """simple docstring"""
  return requests.get(URL_BASE + """forecast"""      ,params=locals()						).json()






def 			__UpperCAmelCase    (	lowercase = 55.68      ,lowercase = 12.57      ,lowercase = APPID						):







  """simple docstring"""
  return requests.get(URL_BASE + """onecall"""      ,params=locals()						).json()


if __name__ == "__main__":
    from pprint import pprint

    while True:
        UpperCAmelCase__     						=  input("""Enter a location:""").strip()
        if location:
            pprint(current_weather(location))
        else:
            break
