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 ViTConfig, ViTForImageClassification, ViTImageProcessor, ViTModel
from transformers.utils import logging


logging.set_verbosity_info()
A   :     int       =				logging.get_logger(__name__)


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase=False ):
      SCREAMING_SNAKE_CASE_      =     []
      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"),
                ] )

            # if just the base model, we should remove "vit" from all keys that start with "vit"
            SCREAMING_SNAKE_CASE_      =     [(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__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase=False ):
      for i in range(config.num_hidden_layers ):
            if base_model:
                  SCREAMING_SNAKE_CASE_      =     ""
            else:
                  SCREAMING_SNAKE_CASE_      =     "vit."
            # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
            SCREAMING_SNAKE_CASE_      =     state_dict.pop(F'''blocks.{i}.attn.qkv.weight''' )
            SCREAMING_SNAKE_CASE_      =     state_dict.pop(F'''blocks.{i}.attn.qkv.bias''' )
            # next, add query, keys and values (in that order) to the state dict
            SCREAMING_SNAKE_CASE_      =     in_proj_weight[
                : config.hidden_size, :
            ]
            SCREAMING_SNAKE_CASE_      =     in_proj_bias[: config.hidden_size]
            SCREAMING_SNAKE_CASE_      =     in_proj_weight[
                config.hidden_size : config.hidden_size * 2, :
            ]
            SCREAMING_SNAKE_CASE_      =     in_proj_bias[
                config.hidden_size : config.hidden_size * 2
            ]
            SCREAMING_SNAKE_CASE_      =     in_proj_weight[
                -config.hidden_size :, :
            ]
            SCREAMING_SNAKE_CASE_      =     in_proj_bias[-config.hidden_size :]


def    a__       (						__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     ["head.weight", "head.bias"]
      for k in ignore_keys:
            state_dict.pop(__UpperCamelCase   ,					__UpperCamelCase )


def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase ):
      SCREAMING_SNAKE_CASE_      =     dct.pop(__UpperCamelCase )
      SCREAMING_SNAKE_CASE_      =     val


def    a__       (						):
      SCREAMING_SNAKE_CASE_      =     "http://images.cocodataset.org/val2017/000000039769.jpg"
      SCREAMING_SNAKE_CASE_      =     Image.open(requests.get(__UpperCamelCase   ,					stream=__UpperCamelCase ).raw )
      return im


@torch.no_grad()
def    a__       (						__UpperCamelCase   ,					__UpperCamelCase   ,					__UpperCamelCase=True ):
      SCREAMING_SNAKE_CASE_      =     ViTConfig()
      # patch_size
      if model_name[-1] == "8":
            SCREAMING_SNAKE_CASE_      =     8
      # set labels if required
      if not base_model:
            SCREAMING_SNAKE_CASE_      =     1_0_0_0
            SCREAMING_SNAKE_CASE_      =     "huggingface/label-files"
            SCREAMING_SNAKE_CASE_      =     "imagenet-1k-id2label.json"
            SCREAMING_SNAKE_CASE_      =     json.load(open(hf_hub_download(__UpperCamelCase   ,					__UpperCamelCase   ,					repo_type="dataset" )   ,					"r" ) )
            SCREAMING_SNAKE_CASE_      =     {int(__UpperCamelCase ): v for k, v in idalabel.items()}
            SCREAMING_SNAKE_CASE_      =     idalabel
            SCREAMING_SNAKE_CASE_      =     {v: k for k, v in idalabel.items()}
      # size of the architecture
      if model_name in ["dino_vits8", "dino_vits16"]:
            SCREAMING_SNAKE_CASE_      =     3_8_4
            SCREAMING_SNAKE_CASE_      =     1_5_3_6
            SCREAMING_SNAKE_CASE_      =     1_2
            SCREAMING_SNAKE_CASE_      =     6

      # load original model from torch hub
      SCREAMING_SNAKE_CASE_      =     torch.hub.load("facebookresearch/dino:main"   ,					__UpperCamelCase )
      original_model.eval()

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

      # load HuggingFace model
      if base_model:
            SCREAMING_SNAKE_CASE_      =     ViTModel(__UpperCamelCase   ,					add_pooling_layer=__UpperCamelCase ).eval()
      else:
            SCREAMING_SNAKE_CASE_      =     ViTForImageClassification(__UpperCamelCase ).eval()
      model.load_state_dict(__UpperCamelCase )

      # Check outputs on an image, prepared by ViTImageProcessor
      SCREAMING_SNAKE_CASE_      =     ViTImageProcessor()
      SCREAMING_SNAKE_CASE_      =     image_processor(images=prepare_img()   ,					return_tensors="pt" )
      SCREAMING_SNAKE_CASE_      =     encoding["pixel_values"]
      SCREAMING_SNAKE_CASE_      =     model(__UpperCamelCase )

      if base_model:
            SCREAMING_SNAKE_CASE_      =     original_model(__UpperCamelCase )
            assert torch.allclose(__UpperCamelCase   ,					outputs.last_hidden_state[:, 0, :]   ,					atol=1E-1 )
      else:
            SCREAMING_SNAKE_CASE_      =     original_model(__UpperCamelCase )
            assert logits.shape == outputs.logits.shape
            assert torch.allclose(__UpperCamelCase   ,					outputs.logits   ,					atol=1E-3 )

      Path(__UpperCamelCase ).mkdir(exist_ok=__UpperCamelCase )
      print(F'''Saving model {model_name} to {pytorch_dump_folder_path}''' )
      model.save_pretrained(__UpperCamelCase )
      print(F'''Saving image processor to {pytorch_dump_folder_path}''' )
      image_processor.save_pretrained(__UpperCamelCase )


if __name__ == "__main__":
      A   :     Tuple       =				argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          "--model_name",
          default="dino_vitb16",
          type=str,
          help="Name of the model trained with DINO 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(
          "--base_model",
          action="store_true",
          help="Whether to only convert the base model (no projection head weights).",
      )

      parser.set_defaults(base_model=True)
      A   :     Tuple       =				parser.parse_args()
      convert_vit_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.base_model)



import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoFeatureExtractor, WavaVecaFeatureExtractor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / "utils"))

from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


A   :     Tuple       =				get_tests_dir("fixtures")


class      lowerCamelCase    (unittest.TestCase    ):
  """simple docstring"""







  def       __A   (							self       :				Union[str, Any]      )     ->		Union[str, Any]:
        # A mock response for an HTTP head request to emulate server down
        SCREAMING_SNAKE_CASE_      =     mock.Mock()
        SCREAMING_SNAKE_CASE_      =     500
        SCREAMING_SNAKE_CASE_      =     {}
        SCREAMING_SNAKE_CASE_      =     HTTPError
        SCREAMING_SNAKE_CASE_      =     {}

        # Download this model to make sure it's in the cache.
        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained("hf-internal-testing/tiny-random-wav2vec2"      )
        # Under the mock environment we get a 500 error when trying to reach the model.
        with mock.patch("requests.Session.request"     ,   return_value=__magic_name__      ) as mock_head:
              SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained("hf-internal-testing/tiny-random-wav2vec2"      )
              # This check we did call the fake head request
              mock_head.assert_called()







  def       __A   (							self       :				Optional[int]      )     ->		Tuple:
        # This test is for deprecated behavior and can be removed in v5
        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained(
            "https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"      )



@is_staging_test
class      lowerCamelCase    (unittest.TestCase    ):
  """simple docstring"""







  @classmethod
  def       __A   (							cls       :				Any      )     ->		Union[str, Any]:
        SCREAMING_SNAKE_CASE_      =     TOKEN
        HfFolder.save_token(__magic_name__      )







  @classmethod
  def       __A   (							cls       :				int      )     ->		Optional[Any]:
        try:
              delete_repo(token=cls._token     ,   repo_id="test-feature-extractor"      )
        except HTTPError:
              pass

        try:
              delete_repo(token=cls._token     ,   repo_id="valid_org/test-feature-extractor-org"      )
        except HTTPError:
              pass

        try:
              delete_repo(token=cls._token     ,   repo_id="test-dynamic-feature-extractor"      )
        except HTTPError:
              pass







  def       __A   (							self       :				str      )     ->		List[Any]:
        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained(__magic_name__      )
        feature_extractor.push_to_hub("test-feature-extractor"     ,   use_auth_token=self._token      )

        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor'''      )
        for k, v in feature_extractor.__dict__.items():
              self.assertEqual(__magic_name__     ,   getattr(__magic_name__     ,   __magic_name__      )      )

        # Reset repo
        delete_repo(token=self._token     ,   repo_id="test-feature-extractor"      )

        # Push to hub via save_pretrained
        with tempfile.TemporaryDirectory() as tmp_dir:
              feature_extractor.save_pretrained(
                  __magic_name__     ,   repo_id="test-feature-extractor"     ,   push_to_hub=__magic_name__     ,   use_auth_token=self._token      )

        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor'''      )
        for k, v in feature_extractor.__dict__.items():
              self.assertEqual(__magic_name__     ,   getattr(__magic_name__     ,   __magic_name__      )      )







  def       __A   (							self       :				Dict      )     ->		str:
        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained(__magic_name__      )
        feature_extractor.push_to_hub("valid_org/test-feature-extractor"     ,   use_auth_token=self._token      )

        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained("valid_org/test-feature-extractor"      )
        for k, v in feature_extractor.__dict__.items():
              self.assertEqual(__magic_name__     ,   getattr(__magic_name__     ,   __magic_name__      )      )

        # Reset repo
        delete_repo(token=self._token     ,   repo_id="valid_org/test-feature-extractor"      )

        # Push to hub via save_pretrained
        with tempfile.TemporaryDirectory() as tmp_dir:
              feature_extractor.save_pretrained(
                  __magic_name__     ,   repo_id="valid_org/test-feature-extractor-org"     ,   push_to_hub=__magic_name__     ,   use_auth_token=self._token      )

        SCREAMING_SNAKE_CASE_      =     WavaVecaFeatureExtractor.from_pretrained("valid_org/test-feature-extractor-org"      )
        for k, v in feature_extractor.__dict__.items():
              self.assertEqual(__magic_name__     ,   getattr(__magic_name__     ,   __magic_name__      )      )







  def       __A   (							self       :				List[Any]      )     ->		Dict:
        CustomFeatureExtractor.register_for_auto_class()
        SCREAMING_SNAKE_CASE_      =     CustomFeatureExtractor.from_pretrained(__magic_name__      )

        feature_extractor.push_to_hub("test-dynamic-feature-extractor"     ,   use_auth_token=self._token      )

        # This has added the proper auto_map field to the config
        self.assertDictEqual(
            feature_extractor.auto_map     ,   {"AutoFeatureExtractor": "custom_feature_extraction.CustomFeatureExtractor"}     ,   )

        SCREAMING_SNAKE_CASE_      =     AutoFeatureExtractor.from_pretrained(
            F'''{USER}/test-dynamic-feature-extractor'''     ,   trust_remote_code=__magic_name__      )
        # Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module
        self.assertEqual(new_feature_extractor.__class__.__name__     ,   "CustomFeatureExtractor"      )


