


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 timm.data import resolve_data_config
from timm.data.transforms_factory import create_transform

from transformers import (
    BitConfig,
    ViTHybridConfig,
    ViTHybridForImageClassification,
    ViTHybridImageProcessor,
    ViTHybridModel,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
__lowerCamelCase        =     logging.get_logger(__name__)



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase=False ):
     a_    :     str										=    []

     # fmt: off
     # stem:
     rename_keys.append(("""cls_token""", """vit.embeddings.cls_token""") )
     rename_keys.append(("""pos_embed""", """vit.embeddings.position_embeddings""") )

     rename_keys.append(("""patch_embed.proj.weight""", """vit.embeddings.patch_embeddings.projection.weight""") )
     rename_keys.append(("""patch_embed.proj.bias""", """vit.embeddings.patch_embeddings.projection.bias""") )

     # backbone
     rename_keys.append(("""patch_embed.backbone.stem.conv.weight""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.convolution.weight""") )
     rename_keys.append(("""patch_embed.backbone.stem.norm.weight""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.weight""") )
     rename_keys.append(("""patch_embed.backbone.stem.norm.bias""", """vit.embeddings.patch_embeddings.backbone.bit.embedder.norm.bias""") )

     for stage_idx in range(len(config.backbone_config.depths ) ):
          for layer_idx in range(config.backbone_config.depths[stage_idx] ):
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv1.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv1.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm1.bias''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm1.bias''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv2.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv2.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm2.bias''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm2.bias''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.conv3.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.conv3.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.weight''') )
               rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.{layer_idx}.norm3.bias''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.{layer_idx}.norm3.bias''') )

          rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.conv.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.conv.weight''') )
          rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.weight''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.weight''') )
          rename_keys.append((F'''patch_embed.backbone.stages.{stage_idx}.blocks.0.downsample.norm.bias''', F'''vit.embeddings.patch_embeddings.backbone.bit.encoder.stages.{stage_idx}.layers.0.downsample.norm.bias''') )

     # transformer encoder
     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''') )

     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"
          a_    :     int										=    [(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"""),
              ] )
     # fmt: on

     return rename_keys



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase=False ):
     for i in range(config.num_hidden_layers ):
          if base_model:
               a_    :     int										=    """"""
          else:
               a_    :     int										=    """vit."""
          # read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
          a_    :     List[Any]										=    state_dict.pop(F'''blocks.{i}.attn.qkv.weight''' )
          a_    :     List[Any]										=    state_dict.pop(F'''blocks.{i}.attn.qkv.bias''' )
          # next, add query, keys and values (in that order) to the state dict
          a_    :     Dict										=    in_proj_weight[
              : config.hidden_size, :
          ]
          a_    :     Dict										=    in_proj_bias[: config.hidden_size]
          a_    :     Tuple										=    in_proj_weight[
              config.hidden_size : config.hidden_size * 2, :
          ]
          a_    :     List[Any]										=    in_proj_bias[
              config.hidden_size : config.hidden_size * 2
          ]
          a_    :     List[Any]										=    in_proj_weight[
              -config.hidden_size :, :
          ]
          a_    :     Dict										=    in_proj_bias[-config.hidden_size :]



def  _a			(						__UpperCamelCase ):
     a_    :     Optional[Any]										=    ["""head.weight""", """head.bias"""]
     for k in ignore_keys:
          state_dict.pop(__UpperCamelCase  ,  __UpperCamelCase )



def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase ):
     a_    :     Optional[Any]										=    dct.pop(__UpperCamelCase )
     a_    :     List[Any]										=    val



def  _a			(						):
     a_    :     int										=    """http://images.cocodataset.org/val2017/000000039769.jpg"""
     a_    :     Optional[int]										=    Image.open(requests.get(__UpperCamelCase  ,  stream=__UpperCamelCase ).raw )
     return im



@torch.no_grad()
def  _a			(						__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase=False ):
     a_    :     str										=    BitConfig(
         global_padding="""same"""  ,  layer_type="""bottleneck"""  ,  depths=(3, 4, 9)  ,  out_features=["""stage3"""]  ,  embedding_dynamic_padding=__UpperCamelCase  ,  )
     a_    :     int										=    ViTHybridConfig(backbone_config=__UpperCamelCase  ,  image_size=3_8_4  ,  num_labels=1_0_0_0 )
     a_    :     Tuple										=    False

     # load original model from timm
     a_    :     Dict										=    timm.create_model(__UpperCamelCase  ,  pretrained=__UpperCamelCase )
     timm_model.eval()

     # load state_dict of original model, remove and rename some keys
     a_    :     Optional[Any]										=    timm_model.state_dict()
     if base_model:
          remove_classification_head_(__UpperCamelCase )
     a_    :     List[Any]										=    create_rename_keys(__UpperCamelCase  ,  __UpperCamelCase )
     for src, dest in rename_keys:
          rename_key(__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase )
     read_in_q_k_v(__UpperCamelCase  ,  __UpperCamelCase  ,  __UpperCamelCase )

     a_    :     Dict										=    """huggingface/label-files"""
     a_    :     List[Any]										=    """imagenet-1k-id2label.json"""
     a_    :     List[Any]										=    json.load(open(hf_hub_download(__UpperCamelCase  ,  __UpperCamelCase  ,  repo_type="""dataset""" )  ,  """r""" ) )
     a_    :     int										=    {int(__UpperCamelCase ): v for k, v in idalabel.items()}
     a_    :     Dict										=    idalabel
     a_    :     int										=    {v: k for k, v in idalabel.items()}

     # load HuggingFace model
     if vit_name[-5:] == "in21k":
          a_    :     List[str]										=    ViTHybridModel(__UpperCamelCase ).eval()
     else:
          a_    :     List[str]										=    ViTHybridForImageClassification(__UpperCamelCase ).eval()
     model.load_state_dict(__UpperCamelCase )

     # create image processor
     a_    :     List[str]										=    create_transform(**resolve_data_config({}  ,  model=__UpperCamelCase ) )
     a_    :     Tuple										=    transform.transforms

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

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

     a_    :     List[Any]										=    prepare_img()
     a_    :     List[Any]										=    transform(__UpperCamelCase ).unsqueeze(0 )
     a_    :     Union[str, Any]										=    processor(__UpperCamelCase  ,  return_tensors="""pt""" ).pixel_values

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

     # verify logits
     with torch.no_grad():
          a_    :     Union[str, Any]										=    model(__UpperCamelCase )
          a_    :     Optional[int]										=    outputs.logits

     print("""Predicted class:"""  ,  logits.argmax(-1 ).item() )
     if base_model:
          a_    :     Optional[int]										=    timm_model.forward_features(__UpperCamelCase )
          assert timm_pooled_output.shape == outputs.pooler_output.shape
          assert torch.allclose(__UpperCamelCase  ,  outputs.pooler_output  ,  atol=1E-3 )
     else:
          a_    :     List[str]										=    timm_model(__UpperCamelCase )
          assert timm_logits.shape == outputs.logits.shape
          assert torch.allclose(__UpperCamelCase  ,  outputs.logits  ,  atol=1E-3 )
     print("""Looks ok!""" )

     if pytorch_dump_folder_path is not None:
          Path(__UpperCamelCase ).mkdir(exist_ok=__UpperCamelCase )
          print(F'''Saving model {vit_name} to {pytorch_dump_folder_path}''' )
          model.save_pretrained(__UpperCamelCase )
          print(F'''Saving processor to {pytorch_dump_folder_path}''' )
          processor.save_pretrained(__UpperCamelCase )

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


if __name__ == "__main__":
       __lowerCamelCase        =     argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           '''--vit_name''',
           default='''vit_base_r50_s16_384''',
           type=str,
           help='''Name of the hybrid 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.'''
       )
       parser.add_argument(
           '''--push_to_hub''', action='''store_true''', help='''Whether to upload the model to the HuggingFace hub.'''
       )

       __lowerCamelCase        =     parser.parse_args()
       convert_vit_checkpoint(args.vit_name, args.pytorch_dump_folder_path, args.push_to_hub)







import json
import sys
import tempfile
import unittest
from pathlib import Path

import transformers
from transformers import (
    CONFIG_MAPPING,
    IMAGE_PROCESSOR_MAPPING,
    AutoConfig,
    AutoImageProcessor,
    CLIPConfig,
    CLIPImageProcessor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER


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

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_image_processing import CustomImageProcessor  # noqa E402


class   a__	(						unittest.TestCase    ):

       def 						UpperCAmelCase(   self      :     int    ):
            a_    :     Any										=    0

       def 						UpperCAmelCase(   self      :     Dict    ):
            a_    :     List[str]										=    AutoImageProcessor.from_pretrained("""openai/clip-vit-base-patch32"""    )
            self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     int    ):
            with tempfile.TemporaryDirectory() as tmpdirname:
                 a_    :     Any										=    Path(lowerCamelCase_    ) / """preprocessor_config.json"""
                 a_    :     Tuple										=    Path(lowerCamelCase_    ) / """config.json"""
                 json.dump(
                     {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}      ,							open(lowerCamelCase_      ,							"""w"""    )      ,							)
                 json.dump({"""model_type""": """clip"""}      ,							open(lowerCamelCase_      ,							"""w"""    )    )

                 a_    :     Union[str, Any]										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    )
                 self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     List[Any]    ):
            # Ensure we can load the image processor from the feature extractor config
            with tempfile.TemporaryDirectory() as tmpdirname:
                 a_    :     Dict										=    Path(lowerCamelCase_    ) / """preprocessor_config.json"""
                 a_    :     List[str]										=    Path(lowerCamelCase_    ) / """config.json"""
                 json.dump(
                     {"""feature_extractor_type""": """CLIPFeatureExtractor""", """processor_class""": """CLIPProcessor"""}      ,							open(lowerCamelCase_      ,							"""w"""    )      ,							)
                 json.dump({"""model_type""": """clip"""}      ,							open(lowerCamelCase_      ,							"""w"""    )    )

                 a_    :     int										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    )
                 self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     Optional[Any]    ):
            with tempfile.TemporaryDirectory() as tmpdirname:
                 a_    :     int										=    CLIPConfig()

                 # Create a dummy config file with image_proceesor_type
                 a_    :     Tuple										=    Path(lowerCamelCase_    ) / """preprocessor_config.json"""
                 a_    :     Tuple										=    Path(lowerCamelCase_    ) / """config.json"""
                 json.dump(
                     {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}      ,							open(lowerCamelCase_      ,							"""w"""    )      ,							)
                 json.dump({"""model_type""": """clip"""}      ,							open(lowerCamelCase_      ,							"""w"""    )    )

                 # remove image_processor_type to make sure config.json alone is enough to load image processor locally
                 a_    :     Optional[int]										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    ).to_dict()

                 config_dict.pop("""image_processor_type"""    )
                 a_    :     Tuple										=    CLIPImageProcessor(**lowerCamelCase_    )

                 # save in new folder
                 model_config.save_pretrained(lowerCamelCase_    )
                 config.save_pretrained(lowerCamelCase_    )

                 a_    :     Optional[int]										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    )

                 # make sure private variable is not incorrectly saved
                 a_    :     str										=    json.loads(config.to_json_string()    )
                 self.assertTrue("""_processor_class""" not in dict_as_saved    )

            self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     Dict    ):
            with tempfile.TemporaryDirectory() as tmpdirname:
                 a_    :     Union[str, Any]										=    Path(lowerCamelCase_    ) / """preprocessor_config.json"""
                 json.dump(
                     {"""image_processor_type""": """CLIPImageProcessor""", """processor_class""": """CLIPProcessor"""}      ,							open(lowerCamelCase_      ,							"""w"""    )      ,							)

                 a_    :     Optional[int]										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    )
                 self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

       def 						UpperCAmelCase(   self      :     int    ):
            with self.assertRaisesRegex(
                lowerCamelCase_      ,							"""clip-base is not a local folder and is not a valid model identifier"""    ):
                 a_    :     Any										=    AutoImageProcessor.from_pretrained("""clip-base"""    )

       def 						UpperCAmelCase(   self      :     Optional[Any]    ):
            with self.assertRaisesRegex(
                lowerCamelCase_      ,							R"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""    ):
                 a_    :     Dict										=    AutoImageProcessor.from_pretrained(lowerCamelCase_      ,							revision="""aaaaaa"""    )

       def 						UpperCAmelCase(   self      :     Dict    ):
            with self.assertRaisesRegex(
                lowerCamelCase_      ,							"""hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json."""      ,							):
                 a_    :     Any										=    AutoImageProcessor.from_pretrained("""hf-internal-testing/config-no-model"""    )

       def 						UpperCAmelCase(   self      :     str    ):
            # If remote code is not set, we will time out when asking whether to load the model.
            with self.assertRaises(lowerCamelCase_    ):
                 a_    :     int										=    AutoImageProcessor.from_pretrained("""hf-internal-testing/test_dynamic_image_processor"""    )
            # If remote code is disabled, we can't load this config.
            with self.assertRaises(lowerCamelCase_    ):
                 a_    :     Tuple										=    AutoImageProcessor.from_pretrained(
                     """hf-internal-testing/test_dynamic_image_processor"""      ,							trust_remote_code=lowerCamelCase_    )

            a_    :     int										=    AutoImageProcessor.from_pretrained(
                """hf-internal-testing/test_dynamic_image_processor"""      ,							trust_remote_code=lowerCamelCase_    )
            self.assertEqual(image_processor.__class__.__name__      ,							"""NewImageProcessor"""    )

            # Test image processor can be reloaded.
            with tempfile.TemporaryDirectory() as tmp_dir:
                 image_processor.save_pretrained(lowerCamelCase_    )
                 a_    :     int										=    AutoImageProcessor.from_pretrained(lowerCamelCase_      ,							trust_remote_code=lowerCamelCase_    )
            self.assertEqual(reloaded_image_processor.__class__.__name__      ,							"""NewImageProcessor"""    )

       def 						UpperCAmelCase(   self      :     List[str]    ):
            try:
                 AutoConfig.register("""custom"""      ,							lowerCamelCase_    )
                 AutoImageProcessor.register(lowerCamelCase_      ,							lowerCamelCase_    )
                 # Trying to register something existing in the Transformers library will raise an error
                 with self.assertRaises(lowerCamelCase_    ):
                      AutoImageProcessor.register(lowerCamelCase_      ,							lowerCamelCase_    )

                 with tempfile.TemporaryDirectory() as tmpdirname:
                      a_    :     Dict										=    Path(lowerCamelCase_    ) / """preprocessor_config.json"""
                      a_    :     Union[str, Any]										=    Path(lowerCamelCase_    ) / """config.json"""
                      json.dump(
                          {"""feature_extractor_type""": """CLIPFeatureExtractor""", """processor_class""": """CLIPProcessor"""}      ,							open(lowerCamelCase_      ,							"""w"""    )      ,							)
                      json.dump({"""model_type""": """clip"""}      ,							open(lowerCamelCase_      ,							"""w"""    )    )

                      a_    :     str										=    CustomImageProcessor.from_pretrained(lowerCamelCase_    )

                 # Now that the config is registered, it can be used as any other config with the auto-API
                 with tempfile.TemporaryDirectory() as tmp_dir:
                      image_processor.save_pretrained(lowerCamelCase_    )
                      a_    :     Any										=    AutoImageProcessor.from_pretrained(lowerCamelCase_    )
                      self.assertIsInstance(lowerCamelCase_      ,							lowerCamelCase_    )

            finally:
                 if "custom" in CONFIG_MAPPING._extra_content:
                      del CONFIG_MAPPING._extra_content["custom"]
                 if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
                      del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]

       def 						UpperCAmelCase(   self      :     Union[str, Any]    ):


            class   a__	(						lowerCAmelCase_    ):
                   lowerCamelCase__:     List[Any]							    =     True

            try:
                 AutoConfig.register("""custom"""      ,							lowerCamelCase_    )
                 AutoImageProcessor.register(lowerCamelCase_      ,							lowerCamelCase_    )
                 # If remote code is not set, the default is to use local
                 a_    :     Dict										=    AutoImageProcessor.from_pretrained("""hf-internal-testing/test_dynamic_image_processor"""    )
                 self.assertEqual(image_processor.__class__.__name__      ,							"""NewImageProcessor"""    )
                 self.assertTrue(image_processor.is_local    )

                 # If remote code is disabled, we load the local one.
                 a_    :     Optional[Any]										=    AutoImageProcessor.from_pretrained(
                     """hf-internal-testing/test_dynamic_image_processor"""      ,							trust_remote_code=lowerCamelCase_    )
                 self.assertEqual(image_processor.__class__.__name__      ,							"""NewImageProcessor"""    )
                 self.assertTrue(image_processor.is_local    )

                 # If remote is enabled, we load from the Hub
                 a_    :     Dict										=    AutoImageProcessor.from_pretrained(
                     """hf-internal-testing/test_dynamic_image_processor"""      ,							trust_remote_code=lowerCamelCase_    )
                 self.assertEqual(image_processor.__class__.__name__      ,							"""NewImageProcessor"""    )
                 self.assertTrue(not hasattr(lowerCamelCase_      ,							"""is_local"""    )    )

            finally:
                 if "custom" in CONFIG_MAPPING._extra_content:
                      del CONFIG_MAPPING._extra_content["custom"]
                 if CustomConfig in IMAGE_PROCESSOR_MAPPING._extra_content:
                      del IMAGE_PROCESSOR_MAPPING._extra_content[CustomConfig]



