




import argparse
import json
from pathlib import Path

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

from transformers import (
    SwiftFormerConfig,
    SwiftFormerForImageClassification,
    ViTImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
__magic_name__  :  List[Any]					=       logging.get_logger(__name__)

__magic_name__  :  int					=       torch.device("""cpu""")
def 		a_							( ):
  lowerCAmelCase__										=      '''http://images.cocodataset.org/val2017/000000039769.jpg'''
  lowerCAmelCase__										=      Image.open(requests.get(__lowerCAmelCase   , stream=__lowerCAmelCase				).raw				)
  return im
def 		a_							( __lowerCAmelCase				):
  if swiftformer_name == "swiftformer_xs":
    return torch.tensor([-2.1_703E00, 2.1_107E00, -2.0_811E00, 8.8_685E-01, 2.4_360E-01]				)

  elif swiftformer_name == "swiftformer_s":
    return torch.tensor([3.9_636E-01, 2.3_478E-01, -1.6_963E00, -1.7_381E00, -8.6_337E-01]				)

  elif swiftformer_name == "swiftformer_l1":
    return torch.tensor([-4.2_768E-01, -4.7_429E-01, -1.0_897E00, -1.0_248E00, 3.5_523E-02]				)

  elif swiftformer_name == "swiftformer_l3":
    return torch.tensor([-2.5_330E-01, 2.4_211E-01, -6.0_185E-01, -8.2_789E-01, -6.0_446E-02]				)
def 		a_							( __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase				):
  lowerCAmelCase__										=      dct.pop(__lowerCAmelCase				)
  lowerCAmelCase__										=      val
def 		a_							( __lowerCAmelCase				):
  lowerCAmelCase__										=      []
  for k in state_dict.keys():
    lowerCAmelCase__										=      k
    if ".pwconv" in k:
      lowerCAmelCase__										=      k_new.replace('''.pwconv'''   , '''.point_wise_conv'''				)
    if ".dwconv" in k:
      lowerCAmelCase__										=      k_new.replace('''.dwconv'''   , '''.depth_wise_conv'''				)
    if ".Proj." in k:
      lowerCAmelCase__										=      k_new.replace('''.Proj.'''   , '''.proj.'''				)
    if "patch_embed" in k_new:
      lowerCAmelCase__										=      k_new.replace('''patch_embed'''   , '''swiftformer.patch_embed.patch_embedding'''				)
    if "network" in k_new:
      lowerCAmelCase__										=      k_new.split('''.'''				)
      if ls[2].isdigit():
        lowerCAmelCase__										=      '''swiftformer.encoder.network.''' + ls[1] + '''.blocks.''' + ls[2] + '''.''' + '''.'''.join(ls[3:]				)
      else:
        lowerCAmelCase__										=      k_new.replace('''network'''   , '''swiftformer.encoder.network'''				)
    rename_keys.append((k, k_new)				)
  return rename_keys
@torch.no_grad()
def 		a_							( __lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase				):
  lowerCAmelCase__										=      SwiftFormerConfig()

  # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
  lowerCAmelCase__										=      10_00
  lowerCAmelCase__										=      '''huggingface/label-files'''
  lowerCAmelCase__										=      '''imagenet-1k-id2label.json'''
  lowerCAmelCase__										=      json.load(open(hf_hub_download(__lowerCAmelCase   , __lowerCAmelCase   , repo_type='''dataset'''				)   , '''r'''				)				)
  lowerCAmelCase__										=      {int(__lowerCAmelCase				): v for k, v in idalabel.items()}
  lowerCAmelCase__										=      idalabel
  lowerCAmelCase__										=      {v: k for k, v in idalabel.items()}

  # size of the architecture
  if swiftformer_name == "swiftformer_xs":
    lowerCAmelCase__										=      [3, 3, 6, 4]
    lowerCAmelCase__										=      [48, 56, 1_12, 2_20]

  elif swiftformer_name == "swiftformer_s":
    lowerCAmelCase__										=      [3, 3, 9, 6]
    lowerCAmelCase__										=      [48, 64, 1_68, 2_24]

  elif swiftformer_name == "swiftformer_l1":
    lowerCAmelCase__										=      [4, 3, 10, 5]
    lowerCAmelCase__										=      [48, 96, 1_92, 3_84]

  elif swiftformer_name == "swiftformer_l3":
    lowerCAmelCase__										=      [4, 4, 12, 6]
    lowerCAmelCase__										=      [64, 1_28, 3_20, 5_12]

  # load state_dict of original model, remove and rename some keys
  if original_ckpt:
    if original_ckpt.startswith('''https'''				):
      lowerCAmelCase__										=      torch.hub.load_state_dict_from_url(__lowerCAmelCase   , map_location='''cpu'''   , check_hash=__lowerCAmelCase				)
    else:
      lowerCAmelCase__										=      torch.load(__lowerCAmelCase   , map_location='''cpu'''				)
  lowerCAmelCase__										=      checkpoint

  lowerCAmelCase__										=      create_rename_keys(__lowerCAmelCase				)
  for rename_key_src, rename_key_dest in rename_keys:
    rename_key(__lowerCAmelCase   , __lowerCAmelCase   , __lowerCAmelCase				)

  # load HuggingFace model
  lowerCAmelCase__										=      SwiftFormerForImageClassification(__lowerCAmelCase				).eval()
  hf_model.load_state_dict(__lowerCAmelCase				)

  # prepare test inputs
  lowerCAmelCase__										=      prepare_img()
  lowerCAmelCase__										=      ViTImageProcessor.from_pretrained('''preprocessor_config'''				)
  lowerCAmelCase__										=      processor(images=__lowerCAmelCase   , return_tensors='''pt'''				)

  # compare outputs from both models
  lowerCAmelCase__										=      get_expected_output(__lowerCAmelCase				)
  lowerCAmelCase__										=      hf_model(inputs['''pixel_values''']				).logits

  assert hf_logits.shape == torch.Size([1, 10_00]				)
  assert torch.allclose(hf_logits[0, 0:5]   , __lowerCAmelCase   , atol=1E-3				)

  Path(__lowerCAmelCase				).mkdir(exist_ok=__lowerCAmelCase				)
  print(F"""Saving model {swiftformer_name} to {pytorch_dump_folder_path}"""				)
  hf_model.save_pretrained(__lowerCAmelCase				)


if __name__ == "__main__":
      __magic_name__  :  Optional[int]					=       argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          """--swiftformer_name""",
          default="""swiftformer_xs""",
          choices=["""swiftformer_xs""", """swiftformer_s""", """swiftformer_l1""", """swiftformer_l3"""],
          type=str,
          help="""Name of the SwiftFormer model you'd like to convert.""",
      )
      parser.add_argument(
          """--pytorch_dump_folder_path""",
          default="""./converted_outputs/""",
          type=str,
          help="""Path to the output PyTorch model directory.""",
      )
      parser.add_argument("""--original_ckpt""", default=None, type=str, help="""Path to the original model checkpoint.""")

      __magic_name__  :  List[str]					=       parser.parse_args()
      convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)







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__":
      __magic_name__  :  List[Any]					=       """%20""".join(argv[1:]) if len(argv) > 1 else quote(str(input("""Search: """)))

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

      __magic_name__  :  List[Any]					=       F"https://www.google.com/search?q={query}&num=100"

      __magic_name__  :  Union[str, Any]					=       requests.get(
          url,
          headers={"""User-Agent""": str(UserAgent().random)},
      )

      try:
            __magic_name__  :  Optional[Any]					=       (
                BeautifulSoup(res.text, """html.parser""")
                .find("""div""", attrs={"""class""": """yuRUbf"""})
                .find("""a""")
                .get("""href""")
            )

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

      webbrowser.open(link)

