




import argparse
import json
from pathlib import Path

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

from transformers import DeiTImageProcessor, ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel
from transformers.utils import logging


logging.set_verbosity_info()
snake_case_ : Dict    		=       logging.get_logger(__name__)


def    A						(__A   :    Any   ,				__A   :    Optional[Any]=False       )   ->      Union[str, Any]:







     """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"""blocks.{i}.norm1.weight""", F"""vit.encoder.layer.{i}.layernorm_before.weight""")       )
          rename_keys.append((F"""blocks.{i}.norm1.bias""", F"""vit.encoder.layer.{i}.layernorm_before.bias""")       )
          rename_keys.append((F"""blocks.{i}.attn.proj.weight""", F"""vit.encoder.layer.{i}.attention.output.dense.weight""")       )
          rename_keys.append((F"""blocks.{i}.attn.proj.bias""", F"""vit.encoder.layer.{i}.attention.output.dense.bias""")       )
          rename_keys.append((F"""blocks.{i}.norm2.weight""", F"""vit.encoder.layer.{i}.layernorm_after.weight""")       )
          rename_keys.append((F"""blocks.{i}.norm2.bias""", F"""vit.encoder.layer.{i}.layernorm_after.bias""")       )
          rename_keys.append((F"""blocks.{i}.mlp.fc1.weight""", F"""vit.encoder.layer.{i}.intermediate.dense.weight""")       )
          rename_keys.append((F"""blocks.{i}.mlp.fc1.bias""", F"""vit.encoder.layer.{i}.intermediate.dense.bias""")       )
          rename_keys.append((F"""blocks.{i}.mlp.fc2.weight""", F"""vit.encoder.layer.{i}.output.dense.weight""")       )
          rename_keys.append((F"""blocks.{i}.mlp.fc2.bias""", F"""vit.encoder.layer.{i}.output.dense.bias""")       )

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

     if base_model:
          # layernorm + pooler
          rename_keys.extend(
              [
                  ('''norm.weight''', '''layernorm.weight'''),
                  ('''norm.bias''', '''layernorm.bias'''),
                  ('''pre_logits.fc.weight''', '''pooler.dense.weight'''),
                  ('''pre_logits.fc.bias''', '''pooler.dense.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    A						(__A   :    Tuple   ,				__A   :    Any   ,				__A   :    Tuple=False       )   ->      Tuple:







     """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"""blocks.{i}.attn.qkv.weight"""       )
          UpperCAmelCase_          =							state_dict.pop(F"""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    A						(__A   :    Optional[Any]       )   ->      Union[str, Any]:







     """simple docstring"""


     UpperCAmelCase_          =							['''head.weight''', '''head.bias''']
     for k in ignore_keys:
          state_dict.pop(__A   ,				__A       )


def    A						(__A   :    Union[str, Any]   ,				__A   :    Optional[int]   ,				__A   :    Optional[Any]       )   ->      int:







     """simple docstring"""


     UpperCAmelCase_          =							dct.pop(__A       )
     UpperCAmelCase_          =							val


def    A						()   ->      List[Any]:







     """simple docstring"""


     UpperCAmelCase_          =							'''http://images.cocodataset.org/val2017/000000039769.jpg'''
     UpperCAmelCase_          =							Image.open(requests.get(__A   ,				stream=__A       ).raw       )
     return im


@torch.no_grad()
def    A						(__A   :    Optional[Any]   ,				__A   :    Optional[int]       )   ->      List[str]:







     """simple docstring"""


     UpperCAmelCase_          =							ViTConfig()
     UpperCAmelCase_          =							False
     # dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
     if vit_name[-5:] == "in21k":
          UpperCAmelCase_          =							True
          UpperCAmelCase_          =							int(vit_name[-12:-10]       )
          UpperCAmelCase_          =							int(vit_name[-9:-6]       )
     else:
          UpperCAmelCase_          =							1000
          UpperCAmelCase_          =							'''huggingface/label-files'''
          UpperCAmelCase_          =							'''imagenet-1k-id2label.json'''
          UpperCAmelCase_          =							json.load(open(hf_hub_download(__A   ,				__A   ,				repo_type='''dataset'''       )   ,				'''r'''       )       )
          UpperCAmelCase_          =							{int(__A       ): v for k, v in idalabel.items()}
          UpperCAmelCase_          =							idalabel
          UpperCAmelCase_          =							{v: k for k, v in idalabel.items()}
          UpperCAmelCase_          =							int(vit_name[-6:-4]       )
          UpperCAmelCase_          =							int(vit_name[-3:]       )
     # size of the architecture
     if "deit" in vit_name:
          if vit_name[9:].startswith('''tiny'''       ):
               UpperCAmelCase_          =							192
               UpperCAmelCase_          =							768
               UpperCAmelCase_          =							12
               UpperCAmelCase_          =							3
          elif vit_name[9:].startswith('''small'''       ):
               UpperCAmelCase_          =							384
               UpperCAmelCase_          =							1536
               UpperCAmelCase_          =							12
               UpperCAmelCase_          =							6
          else:
               pass
     else:
          if vit_name[4:].startswith('''small'''       ):
               UpperCAmelCase_          =							768
               UpperCAmelCase_          =							2304
               UpperCAmelCase_          =							8
               UpperCAmelCase_          =							8
          elif vit_name[4:].startswith('''base'''       ):
               pass
          elif vit_name[4:].startswith('''large'''       ):
               UpperCAmelCase_          =							1024
               UpperCAmelCase_          =							4096
               UpperCAmelCase_          =							24
               UpperCAmelCase_          =							16
          elif vit_name[4:].startswith('''huge'''       ):
               UpperCAmelCase_          =							1280
               UpperCAmelCase_          =							5120
               UpperCAmelCase_          =							32
               UpperCAmelCase_          =							16

    # load original model from timm
     UpperCAmelCase_          =							timm.create_model(__A   ,				pretrained=__A       )
     timm_model.eval()

     # load state_dict of original model, remove and rename some keys
     UpperCAmelCase_          =							timm_model.state_dict()
     if base_model:
          remove_classification_head_(__A       )
     UpperCAmelCase_          =							create_rename_keys(__A   ,				__A       )
     for src, dest in rename_keys:
          rename_key(__A   ,				__A   ,				__A       )
     read_in_q_k_v(__A   ,				__A   ,				__A       )

     # load HuggingFace model
     if vit_name[-5:] == "in21k":
          UpperCAmelCase_          =							ViTModel(__A       ).eval()
     else:
          UpperCAmelCase_          =							ViTForImageClassification(__A       ).eval()
     model.load_state_dict(__A       )

     # Check outputs on an image, prepared by ViTImageProcessor/DeiTImageProcessor
     if "deit" in vit_name:
          UpperCAmelCase_          =							DeiTImageProcessor(size=config.image_size       )
     else:
          UpperCAmelCase_          =							ViTImageProcessor(size=config.image_size       )
     UpperCAmelCase_          =							image_processor(images=prepare_img()   ,				return_tensors='''pt'''       )
     UpperCAmelCase_          =							encoding['''pixel_values''']
     UpperCAmelCase_          =							model(__A       )

     if base_model:
          UpperCAmelCase_          =							timm_model.forward_features(__A       )
          assert timm_pooled_output.shape == outputs.pooler_output.shape
          assert torch.allclose(__A   ,				outputs.pooler_output   ,				atol=1E-3       )
     else:
          UpperCAmelCase_          =							timm_model(__A       )
          assert timm_logits.shape == outputs.logits.shape
          assert torch.allclose(__A   ,				outputs.logits   ,				atol=1E-3       )

     Path(__A       ).mkdir(exist_ok=__A       )
     print(F"""Saving model {vit_name} to {pytorch_dump_folder_path}"""       )
     model.save_pretrained(__A       )
     print(F"""Saving image processor to {pytorch_dump_folder_path}"""       )
     image_processor.save_pretrained(__A       )


if __name__ == "__main__":
    snake_case_ : Tuple    		=       argparse.ArgumentParser()
    # Required parameters
    parser.add_argument(
        "--vit_name",
        default="vit_base_patch16_224",
        type=str,
        help="Name of the ViT 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."
    )

    snake_case_ : List[str]    		=       parser.parse_args()
    convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path)












from datetime import datetime

import requests


def    A						(__A   :    str       )   ->      bytes:







     """simple docstring"""


     UpperCAmelCase_          =							'''https://downloadgram.net/wp-json/wppress/video-downloader/video?url='''
     UpperCAmelCase_          =							requests.get(base_url + url       ).json()[0]['''urls'''][0]['''src''']
     return requests.get(__A       ).content


if __name__ == "__main__":
    snake_case_ : Optional[Any]    		=       input("Enter Video/IGTV url: ").strip()
    snake_case_ : Any    		=       f"{datetime.now():%Y-%m-%d_%H:%M:%S}.mp4"
    with open(file_name, "wb") as fp:
        fp.write(download_video(url))
    print(f"Done. Video saved to disk as {file_name}.")






