
'''simple docstring'''





import argparse
import json

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

from transformers import SegformerImageProcessor, SwinConfig, UperNetConfig, UperNetForSemanticSegmentation







def snake_case_     (					lowercase__		):
  UpperCAmelCase__      :					Union[str, Any]				       =							3_8_4
  UpperCAmelCase__      :					Tuple				       =							7
  if "tiny" in model_name:
    UpperCAmelCase__      :					Optional[int]				       =							9_6
    UpperCAmelCase__      :					List[str]				       =							(2, 2, 6, 2)
    UpperCAmelCase__      :					int				       =							(3, 6, 1_2, 2_4)
  elif "small" in model_name:
    UpperCAmelCase__      :					Union[str, Any]				       =							9_6
    UpperCAmelCase__      :					Tuple				       =							(2, 2, 1_8, 2)
    UpperCAmelCase__      :					List[str]				       =							(3, 6, 1_2, 2_4)
  elif "base" in model_name:
    UpperCAmelCase__      :					str				       =							1_2_8
    UpperCAmelCase__      :					Optional[int]				       =							(2, 2, 1_8, 2)
    UpperCAmelCase__      :					Tuple				       =							(4, 8, 1_6, 3_2)
    UpperCAmelCase__      :					List[str]				       =							1_2
    UpperCAmelCase__      :					Tuple				       =							5_1_2
  elif "large" in model_name:
    UpperCAmelCase__      :					Optional[int]				       =							1_9_2
    UpperCAmelCase__      :					Any				       =							(2, 2, 1_8, 2)
    UpperCAmelCase__      :					List[str]				       =							(6, 1_2, 2_4, 4_8)
    UpperCAmelCase__      :					Union[str, Any]				       =							1_2
    UpperCAmelCase__      :					int				       =							7_6_8

  # set label information
  UpperCAmelCase__      :					Any				       =							1_5_0
  UpperCAmelCase__      :					Any				       =							"huggingface/label-files"
  UpperCAmelCase__      :					List[Any]				       =							"ade20k-id2label.json"
  UpperCAmelCase__      :					List[str]				       =							json.load(open(hf_hub_download(lowercase__   ,       lowercase__   ,       repo_type="dataset"		)   ,       "r"		)		)
  UpperCAmelCase__      :					Any				       =							{int(lowercase__		): v for k, v in idalabel.items()}
  UpperCAmelCase__      :					Tuple				       =							{v: k for k, v in idalabel.items()}

  UpperCAmelCase__      :					Optional[int]				       =							SwinConfig(
      embed_dim=lowercase__   ,       depths=lowercase__   ,       num_heads=lowercase__   ,       window_size=lowercase__   ,       out_features=["stage1", "stage2", "stage3", "stage4"]   ,       )
  UpperCAmelCase__      :					Any				       =							UperNetConfig(
      backbone_config=lowercase__   ,       auxiliary_in_channels=lowercase__   ,       num_labels=lowercase__   ,       idalabel=lowercase__   ,       labelaid=lowercase__   ,       )

  return config







def snake_case_     (					lowercase__		):
  UpperCAmelCase__      :					Optional[int]				       =							[]

  # fmt: off
  # stem
  rename_keys.append(("backbone.patch_embed.projection.weight", "backbone.embeddings.patch_embeddings.projection.weight")		)
  rename_keys.append(("backbone.patch_embed.projection.bias", "backbone.embeddings.patch_embeddings.projection.bias")		)
  rename_keys.append(("backbone.patch_embed.norm.weight", "backbone.embeddings.norm.weight")		)
  rename_keys.append(("backbone.patch_embed.norm.bias", "backbone.embeddings.norm.bias")		)
  # stages
  for i in range(len(config.backbone_config.depths		)		):
    for j in range(config.backbone_config.depths[i]		):
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm1.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.weight""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm1.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_before.bias""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_bias_table""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.relative_position_index""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.proj.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm2.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.weight""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.norm2.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.layernorm_after.bias""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.0.0.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.1.weight""", F"""backbone.encoder.layers.{i}.blocks.{j}.output.dense.weight""")		)
      rename_keys.append((F"""backbone.stages.{i}.blocks.{j}.ffn.layers.1.bias""", F"""backbone.encoder.layers.{i}.blocks.{j}.output.dense.bias""")		)

    if i < 3:
      rename_keys.append((F"""backbone.stages.{i}.downsample.reduction.weight""", F"""backbone.encoder.layers.{i}.downsample.reduction.weight""")		)
      rename_keys.append((F"""backbone.stages.{i}.downsample.norm.weight""", F"""backbone.encoder.layers.{i}.downsample.norm.weight""")		)
      rename_keys.append((F"""backbone.stages.{i}.downsample.norm.bias""", F"""backbone.encoder.layers.{i}.downsample.norm.bias""")		)
    rename_keys.append((F"""backbone.norm{i}.weight""", F"""backbone.hidden_states_norms.stage{i+1}.weight""")		)
    rename_keys.append((F"""backbone.norm{i}.bias""", F"""backbone.hidden_states_norms.stage{i+1}.bias""")		)

  # decode head
  rename_keys.extend(
      [
          ("decode_head.conv_seg.weight", "decode_head.classifier.weight"),
          ("decode_head.conv_seg.bias", "decode_head.classifier.bias"),
          ("auxiliary_head.conv_seg.weight", "auxiliary_head.classifier.weight"),
          ("auxiliary_head.conv_seg.bias", "auxiliary_head.classifier.bias"),
      ]		)
  # fmt: on

  return rename_keys







def snake_case_     (					lowercase__   ,       lowercase__   ,       lowercase__		):
  UpperCAmelCase__      :					int				       =							dct.pop(lowercase__		)
  UpperCAmelCase__      :					List[Any]				       =							val







def snake_case_     (					lowercase__   ,       lowercase__		):
  UpperCAmelCase__      :					int				       =							[int(backbone_config.embed_dim * 2**i		) for i in range(len(backbone_config.depths		)		)]
  for i in range(len(backbone_config.depths		)		):
    UpperCAmelCase__      :					Union[str, Any]				       =							num_features[i]
    for j in range(backbone_config.depths[i]		):
      # fmt: off
      # read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
      UpperCAmelCase__      :					List[str]				       =							state_dict.pop(F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.weight"""		)
      UpperCAmelCase__      :					Optional[int]				       =							state_dict.pop(F"""backbone.stages.{i}.blocks.{j}.attn.w_msa.qkv.bias"""		)
      # next, add query, keys and values (in that order) to the state dict
      UpperCAmelCase__      :					Tuple				       =							in_proj_weight[:dim, :]
      UpperCAmelCase__      :					Tuple				       =							in_proj_bias[: dim]
      UpperCAmelCase__      :					Union[str, Any]				       =							in_proj_weight[
          dim : dim * 2, :
      ]
      UpperCAmelCase__      :					str				       =							in_proj_bias[
          dim : dim * 2
      ]
      UpperCAmelCase__      :					Optional[Any]				       =							in_proj_weight[
          -dim :, :
      ]
      UpperCAmelCase__      :					Union[str, Any]				       =							in_proj_bias[-dim :]
      # fmt: on







def snake_case_     (					lowercase__		):
  UpperCAmelCase__       ,			UpperCAmelCase__      :					List[str]				       =							x.shape
  UpperCAmelCase__      :					int				       =							x.reshape(lowercase__   ,       4   ,       in_channel // 4		)
  UpperCAmelCase__      :					List[str]				       =							x[:, [0, 2, 1, 3], :].transpose(1   ,       2		).reshape(lowercase__   ,       lowercase__		)
  return x







def snake_case_     (					lowercase__		):
  UpperCAmelCase__       ,			UpperCAmelCase__      :					List[str]				       =							x.shape
  UpperCAmelCase__      :					Tuple				       =							x.reshape(lowercase__   ,       in_channel // 4   ,       4		)
  UpperCAmelCase__      :					Union[str, Any]				       =							x[:, :, [0, 2, 1, 3]].transpose(1   ,       2		).reshape(lowercase__   ,       lowercase__		)

  return x







def snake_case_     (					lowercase__		):
  UpperCAmelCase__      :					int				       =							x.shape[0]
  UpperCAmelCase__      :					List[Any]				       =							x.reshape(4   ,       in_channel // 4		)
  UpperCAmelCase__      :					Tuple				       =							x[[0, 2, 1, 3], :].transpose(0   ,       1		).reshape(lowercase__		)
  return x







def snake_case_     (					lowercase__		):
  UpperCAmelCase__      :					Tuple				       =							x.shape[0]
  UpperCAmelCase__      :					List[Any]				       =							x.reshape(in_channel // 4   ,       4		)
  UpperCAmelCase__      :					Union[str, Any]				       =							x[:, [0, 2, 1, 3]].transpose(0   ,       1		).reshape(lowercase__		)
  return x







def snake_case_     (					lowercase__   ,       lowercase__   ,       lowercase__		):
  UpperCAmelCase__      :					List[str]				       =							{
      "upernet-swin-tiny": "https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210531_112542-e380ad3e.pth",
      "upernet-swin-small": "https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K/upernet_swin_small_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K_20210526_192015-ee2fff1c.pth",
      "upernet-swin-base": "https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K/upernet_swin_base_patch4_window12_512x512_160k_ade20k_pretrain_384x384_22K_20210531_125459-429057bf.pth",
      "upernet-swin-large": "https://download.openmmlab.com/mmsegmentation/v0.5/swin/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k/upernet_swin_large_patch4_window12_512x512_pretrain_384x384_22K_160k_ade20k_20220318_091743-9ba68901.pth",
  }
  UpperCAmelCase__      :					Tuple				       =							model_name_to_url[model_name]
  UpperCAmelCase__      :					Optional[Any]				       =							torch.hub.load_state_dict_from_url(lowercase__   ,       map_location="cpu"   ,       file_name=lowercase__		)[
      "state_dict"
  ]

  for name, param in state_dict.items():
    print(lowercase__   ,       param.shape		)

  UpperCAmelCase__      :					Tuple				       =							get_upernet_config(lowercase__		)
  UpperCAmelCase__      :					str				       =							UperNetForSemanticSegmentation(lowercase__		)
  model.eval()

  # replace "bn" => "batch_norm"
  for key in state_dict.copy().keys():
    UpperCAmelCase__      :					Any				       =							state_dict.pop(lowercase__		)
    if "bn" in key:
      UpperCAmelCase__      :					str				       =							key.replace("bn"   ,       "batch_norm"		)
    UpperCAmelCase__      :					int				       =							val

  # rename keys
  UpperCAmelCase__      :					List[str]				       =							create_rename_keys(lowercase__		)
  for src, dest in rename_keys:
    rename_key(lowercase__   ,       lowercase__   ,       lowercase__		)
  read_in_q_k_v(lowercase__   ,       config.backbone_config		)

  # fix downsample parameters
  for key, value in state_dict.items():
    if "downsample" in key:
      if "reduction" in key:
        UpperCAmelCase__      :					Tuple				       =							reverse_correct_unfold_reduction_order(lowercase__		)
      if "norm" in key:
        UpperCAmelCase__      :					Union[str, Any]				       =							reverse_correct_unfold_norm_order(lowercase__		)

  model.load_state_dict(lowercase__		)

  # verify on image
  UpperCAmelCase__      :					Tuple				       =							"https://huggingface.co/datasets/hf-internal-testing/fixtures_ade20k/resolve/main/ADE_val_00000001.jpg"
  UpperCAmelCase__      :					Any				       =							Image.open(requests.get(lowercase__   ,       stream=lowercase__		).raw		).convert("RGB"		)

  UpperCAmelCase__      :					Any				       =							SegformerImageProcessor()
  UpperCAmelCase__      :					Union[str, Any]				       =							processor(lowercase__   ,       return_tensors="pt"		).pixel_values

  with torch.no_grad():
    UpperCAmelCase__      :					Any				       =							model(lowercase__		)
    UpperCAmelCase__      :					List[str]				       =							outputs.logits

  print(logits.shape		)
  print("First values of logits:"   ,       logits[0, 0, :3, :3]		)
  # assert values
  if model_name == "upernet-swin-tiny":
    UpperCAmelCase__      :					Union[str, Any]				       =							torch.tensor(
        [[-7.5958, -7.5958, -7.4302], [-7.5958, -7.5958, -7.4302], [-7.4797, -7.4797, -7.3068]]		)
  elif model_name == "upernet-swin-small":
    UpperCAmelCase__      :					int				       =							torch.tensor(
        [[-7.1921, -7.1921, -6.9532], [-7.1921, -7.1921, -6.9532], [-7.0908, -7.0908, -6.8534]]		)
  elif model_name == "upernet-swin-base":
    UpperCAmelCase__      :					Optional[Any]				       =							torch.tensor(
        [[-6.5851, -6.5851, -6.4330], [-6.5851, -6.5851, -6.4330], [-6.4763, -6.4763, -6.3254]]		)
  elif model_name == "upernet-swin-large":
    UpperCAmelCase__      :					Tuple				       =							torch.tensor(
        [[-7.5297, -7.5297, -7.3802], [-7.5297, -7.5297, -7.3802], [-7.4044, -7.4044, -7.2586]]		)
  print("Logits:"   ,       outputs.logits[0, 0, :3, :3]		)
  assert torch.allclose(outputs.logits[0, 0, :3, :3]   ,       lowercase__   ,       atol=1E-4		)
  print("Looks ok!"		)

  if pytorch_dump_folder_path is not None:
    print(F"""Saving model {model_name} to {pytorch_dump_folder_path}"""		)
    model.save_pretrained(lowercase__		)
    print(F"""Saving processor to {pytorch_dump_folder_path}"""		)
    processor.save_pretrained(lowercase__		)

  if push_to_hub:
    print(F"""Pushing model and processor for {model_name} to hub"""		)
    model.push_to_hub(F"""openmmlab/{model_name}"""		)
    processor.push_to_hub(F"""openmmlab/{model_name}"""		)


if __name__ == "__main__":
      SCREAMING_SNAKE_CASE     =       argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          """--model_name""",
          default="""upernet-swin-tiny""",
          type=str,
          choices=[F'upernet-swin-{size}' for size in ["""tiny""", """small""", """base""", """large"""]],
          help="""Name of the Swin + UperNet 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 or not to push the converted model to the 🤗 hub."""
      )

      SCREAMING_SNAKE_CASE     =       parser.parse_args()
      convert_upernet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)





'''simple docstring'''





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

import transformers
from transformers import (
    CONFIG_MAPPING,
    FEATURE_EXTRACTOR_MAPPING,
    AutoConfig,
    AutoFeatureExtractor,
    WavaVecaConfig,
    WavaVecaFeatureExtractor,
)
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


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

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


SCREAMING_SNAKE_CASE     =       get_tests_dir("""fixtures""")
SCREAMING_SNAKE_CASE     =       get_tests_dir("""fixtures/dummy_feature_extractor_config.json""")
SCREAMING_SNAKE_CASE     =       get_tests_dir("""fixtures/dummy-config.json""")






class 							UpperCAmelCase_							(    unittest.TestCase				):

 '''simple docstring'''







 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					Any				       =							0







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



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[int]				       =							AutoFeatureExtractor.from_pretrained("facebook/wav2vec2-base-960h" )
   self.assertIsInstance(snake_case__			,				snake_case__ )







 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					Optional[int]				       =							AutoFeatureExtractor.from_pretrained(snake_case__ )
   self.assertIsInstance(snake_case__			,				snake_case__ )







 def 							UpperCamelCase  (					self		:  List[Any] ):



   '''simple docstring'''




   with tempfile.TemporaryDirectory() as tmpdirname:
     UpperCAmelCase__      :					Optional[Any]				       =							WavaVecaConfig()

     # remove feature_extractor_type to make sure config.json alone is enough to load feature processor locally
     UpperCAmelCase__      :					Any				       =							AutoFeatureExtractor.from_pretrained(snake_case__ ).to_dict()

     config_dict.pop("feature_extractor_type" )
     UpperCAmelCase__      :					Union[str, Any]				       =							WavaVecaFeatureExtractor(**snake_case__ )

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

     UpperCAmelCase__      :					Tuple				       =							AutoFeatureExtractor.from_pretrained(snake_case__ )

     # make sure private variable is not incorrectly saved
     UpperCAmelCase__      :					List[Any]				       =							json.loads(config.to_json_string() )
     self.assertTrue("_processor_class" not in dict_as_saved )

   self.assertIsInstance(snake_case__			,				snake_case__ )







 def 							UpperCamelCase  (					self		:  int ):



   '''simple docstring'''




   UpperCAmelCase__      :					Any				       =							AutoFeatureExtractor.from_pretrained(snake_case__ )
   self.assertIsInstance(snake_case__			,				snake_case__ )







 def 							UpperCamelCase  (					self		:  Tuple ):



   '''simple docstring'''




   with self.assertRaisesRegex(
       snake_case__			,				"bert-base is not a local folder and is not a valid model identifier" ):
     UpperCAmelCase__      :					Optional[int]				       =							AutoFeatureExtractor.from_pretrained("bert-base" )







 def 							UpperCamelCase  (					self		:  Any ):



   '''simple docstring'''




   with self.assertRaisesRegex(
       snake_case__			,				R"aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)" ):
     UpperCAmelCase__      :					List[str]				       =							AutoFeatureExtractor.from_pretrained(snake_case__			,				revision="aaaaaa" )







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



   '''simple docstring'''




   with self.assertRaisesRegex(
       snake_case__			,				"hf-internal-testing/config-no-model does not appear to have a file named preprocessor_config.json."			,				):
     UpperCAmelCase__      :					Optional[Any]				       =							AutoFeatureExtractor.from_pretrained("hf-internal-testing/config-no-model" )







 def 							UpperCamelCase  (					self		:  Optional[Any] ):



   '''simple docstring'''




   with self.assertRaises(snake_case__ ):
     UpperCAmelCase__      :					List[str]				       =							AutoFeatureExtractor.from_pretrained(
         "hf-internal-testing/test_dynamic_feature_extractor" )
   # If remote code is disabled, we can't load this config.
   with self.assertRaises(snake_case__ ):
     UpperCAmelCase__      :					Any				       =							AutoFeatureExtractor.from_pretrained(
         "hf-internal-testing/test_dynamic_feature_extractor"			,				trust_remote_code=snake_case__ )

   UpperCAmelCase__      :					Optional[Any]				       =							AutoFeatureExtractor.from_pretrained(
       "hf-internal-testing/test_dynamic_feature_extractor"			,				trust_remote_code=snake_case__ )
   self.assertEqual(feature_extractor.__class__.__name__			,				"NewFeatureExtractor" )

   # Test feature extractor can be reloaded.
   with tempfile.TemporaryDirectory() as tmp_dir:
     feature_extractor.save_pretrained(snake_case__ )
     UpperCAmelCase__      :					Any				       =							AutoFeatureExtractor.from_pretrained(snake_case__			,				trust_remote_code=snake_case__ )
   self.assertEqual(reloaded_feature_extractor.__class__.__name__			,				"NewFeatureExtractor" )







 def 							UpperCamelCase  (					self		:  str ):



   '''simple docstring'''




   try:
     AutoConfig.register("custom"			,				snake_case__ )
     AutoFeatureExtractor.register(snake_case__			,				snake_case__ )
     # Trying to register something existing in the Transformers library will raise an error
     with self.assertRaises(snake_case__ ):
       AutoFeatureExtractor.register(snake_case__			,				snake_case__ )

     # Now that the config is registered, it can be used as any other config with the auto-API
     UpperCAmelCase__      :					str				       =							CustomFeatureExtractor.from_pretrained(snake_case__ )
     with tempfile.TemporaryDirectory() as tmp_dir:
       feature_extractor.save_pretrained(snake_case__ )
       UpperCAmelCase__      :					Optional[int]				       =							AutoFeatureExtractor.from_pretrained(snake_case__ )
       self.assertIsInstance(snake_case__			,				snake_case__ )

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







 def 							UpperCamelCase  (					self		:  str ):



   '''simple docstring'''




   class 							UpperCAmelCase_							(    A				):

    '''simple docstring'''
    lowercase_					:    Optional[Any]				=							True

   try:
     AutoConfig.register("custom"			,				snake_case__ )
     AutoFeatureExtractor.register(snake_case__			,				snake_case__ )
     # If remote code is not set, the default is to use local
     UpperCAmelCase__      :					Any				       =							AutoFeatureExtractor.from_pretrained(
         "hf-internal-testing/test_dynamic_feature_extractor" )
     self.assertEqual(feature_extractor.__class__.__name__			,				"NewFeatureExtractor" )
     self.assertTrue(feature_extractor.is_local )

     # If remote code is disabled, we load the local one.
     UpperCAmelCase__      :					Optional[int]				       =							AutoFeatureExtractor.from_pretrained(
         "hf-internal-testing/test_dynamic_feature_extractor"			,				trust_remote_code=snake_case__ )
     self.assertEqual(feature_extractor.__class__.__name__			,				"NewFeatureExtractor" )
     self.assertTrue(feature_extractor.is_local )

     # If remote is enabled, we load from the Hub
     UpperCAmelCase__      :					int				       =							AutoFeatureExtractor.from_pretrained(
         "hf-internal-testing/test_dynamic_feature_extractor"			,				trust_remote_code=snake_case__ )
     self.assertEqual(feature_extractor.__class__.__name__			,				"NewFeatureExtractor" )
     self.assertTrue(not hasattr(snake_case__			,				"is_local" ) )

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



