
import argparse

import requests
import torch

# pip3 install salesforce-lavis
# I'm actually installing a slightly modified version: pip3 install git+https://github.com/nielsrogge/LAVIS.git@fix_lavis
from lavis.models import load_model_and_preprocess
from PIL import Image

from transformers import (
    AutoTokenizer,
    BlipaConfig,
    BlipaForConditionalGeneration,
    BlipaProcessor,
    BlipaVisionConfig,
    BlipImageProcessor,
    OPTConfig,
    TaConfig,
)
from transformers.utils.constants import OPENAI_CLIP_MEAN, OPENAI_CLIP_STD





def     _a					(						):
 lowerCamelCase		:	Tuple							=      """https://storage.googleapis.com/sfr-vision-language-research/LAVIS/assets/merlion.png"""
 lowerCamelCase		:	List[Any]							=      Image.open(requests.get(lowerCamelCase,	stream=lowerCamelCase							).raw							).convert("""RGB"""							)

 return image





def     _a					(						lowerCamelCase							):
 lowerCamelCase		:	Union[str, Any]							=      []
 # fmt: off

 # vision encoder
 rename_keys.append(("""visual_encoder.cls_token""", """vision_model.embeddings.class_embedding""")							)
 rename_keys.append(("""visual_encoder.pos_embed""", """vision_model.embeddings.position_embedding""")							)
 rename_keys.append(("""visual_encoder.patch_embed.proj.weight""", """vision_model.embeddings.patch_embedding.weight""")							)
 rename_keys.append(("""visual_encoder.patch_embed.proj.bias""", """vision_model.embeddings.patch_embedding.bias""")							)
 rename_keys.append(("""ln_vision.weight""", """vision_model.post_layernorm.weight""")							)
 rename_keys.append(("""ln_vision.bias""", """vision_model.post_layernorm.bias""")							)

 for i in range(config.vision_config.num_hidden_layers							):
  rename_keys.append((F'''visual_encoder.blocks.{i}.norm1.weight''', F'''vision_model.encoder.layers.{i}.layer_norm1.weight''')							)
  rename_keys.append((F'''visual_encoder.blocks.{i}.norm1.bias''', F'''vision_model.encoder.layers.{i}.layer_norm1.bias''')							)
  rename_keys.append((F'''visual_encoder.blocks.{i}.norm2.weight''', F'''vision_model.encoder.layers.{i}.layer_norm2.weight''')							)
  rename_keys.append((F'''visual_encoder.blocks.{i}.norm2.bias''', F'''vision_model.encoder.layers.{i}.layer_norm2.bias''')							)
  rename_keys.append((F'''visual_encoder.blocks.{i}.attn.qkv.weight''', F'''vision_model.encoder.layers.{i}.self_attn.qkv.weight''')							)
  rename_keys.append((F'''visual_encoder.blocks.{i}.attn.proj.weight''', F'''vision_model.encoder.layers.{i}.self_attn.projection.weight''',)							)
  rename_keys.append((F'''visual_encoder.blocks.{i}.attn.proj.bias''', F'''vision_model.encoder.layers.{i}.self_attn.projection.bias''')							)
  rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc1.weight''', F'''vision_model.encoder.layers.{i}.mlp.fc1.weight''')							)
  rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc1.bias''', F'''vision_model.encoder.layers.{i}.mlp.fc1.bias''')							)
  rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc2.weight''', F'''vision_model.encoder.layers.{i}.mlp.fc2.weight''')							)
  rename_keys.append((F'''visual_encoder.blocks.{i}.mlp.fc2.bias''', F'''vision_model.encoder.layers.{i}.mlp.fc2.bias''')							)

 # QFormer
 rename_keys.append(("""Qformer.bert.embeddings.LayerNorm.weight""", """qformer.layernorm.weight""")							)
 rename_keys.append(("""Qformer.bert.embeddings.LayerNorm.bias""", """qformer.layernorm.bias""")							)

 # fmt: on
 return rename_keys





def     _a					(						lowerCamelCase,	lowerCamelCase,	lowerCamelCase							):
 lowerCamelCase		:	List[str]							=      dct.pop(lowerCamelCase							)
 lowerCamelCase		:	Dict							=      val





def     _a					(						lowerCamelCase,	lowerCamelCase							):
 for i in range(config.vision_config.num_hidden_layers							):
  # read in original q and v biases
  lowerCamelCase		:	int							=      state_dict.pop(F'''visual_encoder.blocks.{i}.attn.q_bias'''							)
  lowerCamelCase		:	Tuple							=      state_dict.pop(F'''visual_encoder.blocks.{i}.attn.v_bias'''							)

  # next, set bias in the state dict
  lowerCamelCase		:	Any							=      torch.cat((q_bias, torch.zeros_like(lowerCamelCase,	requires_grad=lowerCamelCase							), v_bias)							)
  lowerCamelCase		:	Union[str, Any]							=      qkv_bias





def     _a					(						lowerCamelCase,	lowerCamelCase							):
 lowerCamelCase		:	Dict							=      364 if """coco""" in model_name else 224
 lowerCamelCase		:	int							=      BlipaVisionConfig(image_size=lowerCamelCase							).to_dict()

 # make sure the models have proper bos_token_id and eos_token_id set (important for generation)
 # seems like flan-T5 models don't have bos_token_id properly set?
 if "opt-2.7b" in model_name:
  lowerCamelCase		:	List[str]							=      OPTConfig.from_pretrained("""facebook/opt-2.7b""",	eos_token_id=lowerCamelCase							).to_dict()
 elif "opt-6.7b" in model_name:
  lowerCamelCase		:	Any							=      OPTConfig.from_pretrained("""facebook/opt-6.7b""",	eos_token_id=lowerCamelCase							).to_dict()
 elif "t5-xl" in model_name:
  lowerCamelCase		:	str							=      TaConfig.from_pretrained("""google/flan-t5-xl""",	dense_act_fn="""gelu""",	bos_token_id=1							).to_dict()
 elif "t5-xxl" in model_name:
  lowerCamelCase		:	List[str]							=      TaConfig.from_pretrained("""google/flan-t5-xxl""",	dense_act_fn="""gelu""",	bos_token_id=1							).to_dict()

 lowerCamelCase		:	Dict							=      BlipaConfig(vision_config=lowerCamelCase,	text_config=lowerCamelCase							)

 return config, image_size





@torch.no_grad()
def     _a					(						lowerCamelCase,	lowerCamelCase=None,	lowerCamelCase=False							):
 lowerCamelCase		:	Optional[int]							=      (
     AutoTokenizer.from_pretrained("""facebook/opt-2.7b"""							)
     if """opt""" in model_name
     else AutoTokenizer.from_pretrained("""google/flan-t5-xl"""							)
 )
 lowerCamelCase		:	Any							=      tokenizer("""\n""",	add_special_tokens=lowerCamelCase							).input_ids[0]
 lowerCamelCase			,    lowerCamelCase		:	List[Any]							=      get_blipa_config(lowerCamelCase,	eos_token_id=lowerCamelCase							)

 lowerCamelCase		:	List[Any]							=      BlipaForConditionalGeneration(lowerCamelCase							).eval()

 lowerCamelCase		:	List[str]							=      {
     """blip2-opt-2.7b""": ("""blip2_opt""", """pretrain_opt2.7b"""),
     """blip2-opt-6.7b""": ("""blip2_opt""", """pretrain_opt6.7b"""),
     """blip2-opt-2.7b-coco""": ("""blip2_opt""", """caption_coco_opt2.7b"""),
     """blip2-opt-6.7b-coco""": ("""blip2_opt""", """caption_coco_opt6.7b"""),
     """blip2-flan-t5-xl""": ("""blip2_t5""", """pretrain_flant5xl"""),
     """blip2-flan-t5-xl-coco""": ("""blip2_t5""", """caption_coco_flant5xl"""),
     """blip2-flan-t5-xxl""": ("""blip2_t5""", """pretrain_flant5xxl"""),
 }

 lowerCamelCase			,    lowerCamelCase		:	Dict							=      model_name_to_original[model_name]

 # load original model
 print("""Loading original model..."""							)
 lowerCamelCase		:	Tuple							=      """cuda""" if torch.cuda.is_available() else """cpu"""
 lowerCamelCase			,    lowerCamelCase			,    lowerCamelCase		:	Union[str, Any]							=      load_model_and_preprocess(
     name=lowerCamelCase,	model_type=lowerCamelCase,	is_eval=lowerCamelCase,	device=lowerCamelCase							)
 original_model.eval()
 print("""Done!"""							)

 # update state dict keys
 lowerCamelCase		:	Dict							=      original_model.state_dict()
 lowerCamelCase		:	Tuple							=      create_rename_keys(lowerCamelCase							)
 for src, dest in rename_keys:
  rename_key(lowerCamelCase,	lowerCamelCase,	lowerCamelCase							)

 # some keys can be renamed efficiently
 for key, val in state_dict.copy().items():
  lowerCamelCase		:	Dict							=      state_dict.pop(lowerCamelCase							)
  if key.startswith("""Qformer.bert"""							):
   lowerCamelCase		:	Tuple							=      key.replace("""Qformer.bert""",	"""qformer"""							)
  if "attention.self" in key:
   lowerCamelCase		:	Optional[Any]							=      key.replace("""self""",	"""attention"""							)
  if "opt_proj" in key:
   lowerCamelCase		:	Optional[Any]							=      key.replace("""opt_proj""",	"""language_projection"""							)
  if "t5_proj" in key:
   lowerCamelCase		:	int							=      key.replace("""t5_proj""",	"""language_projection"""							)
  if key.startswith("""opt"""							):
   lowerCamelCase		:	Any							=      key.replace("""opt""",	"""language"""							)
  if key.startswith("""t5"""							):
   lowerCamelCase		:	List[Any]							=      key.replace("""t5""",	"""language"""							)
  lowerCamelCase		:	Dict							=      val

 # read in qv biases
 read_in_q_v_bias(lowerCamelCase,	lowerCamelCase							)

 lowerCamelCase			,    lowerCamelCase		:	List[Any]							=      hf_model.load_state_dict(lowerCamelCase,	strict=lowerCamelCase							)
 assert len(lowerCamelCase							) == 0
 assert unexpected_keys == ["qformer.embeddings.position_ids"]

 lowerCamelCase		:	str							=      load_demo_image()
 lowerCamelCase		:	Optional[int]							=      vis_processors["""eval"""](lowerCamelCase							).unsqueeze(0							).to(lowerCamelCase							)
 lowerCamelCase		:	Tuple							=      tokenizer(["""\n"""],	return_tensors="""pt"""							).input_ids.to(lowerCamelCase							)

 # create processor
 lowerCamelCase		:	Optional[int]							=      BlipImageProcessor(
     size={"""height""": image_size, """width""": image_size},	image_mean=lowerCamelCase,	image_std=lowerCamelCase							)
 lowerCamelCase		:	str							=      BlipaProcessor(image_processor=lowerCamelCase,	tokenizer=lowerCamelCase							)
 lowerCamelCase		:	Dict							=      processor(images=lowerCamelCase,	return_tensors="""pt"""							).pixel_values.to(lowerCamelCase							)

 # make sure processor creates exact same pixel values
 assert torch.allclose(lowerCamelCase,	lowerCamelCase							)

 original_model.to(lowerCamelCase							)
 hf_model.to(lowerCamelCase							)
 with torch.no_grad():
  if "opt" in model_name:
   lowerCamelCase		:	List[Any]							=      original_model({"""image""": original_pixel_values, """text_input""": [""""""]}							).logits
   lowerCamelCase		:	List[str]							=      hf_model(lowerCamelCase,	lowerCamelCase							).logits
  else:
   lowerCamelCase		:	str							=      original_model(
       {"""image""": original_pixel_values, """text_input""": ["""\n"""], """text_output""": ["""\n"""]}							).logits
   lowerCamelCase		:	Optional[int]							=      input_ids.masked_fill(input_ids == tokenizer.pad_token_id,	-100							)
   lowerCamelCase		:	int							=      hf_model(lowerCamelCase,	lowerCamelCase,	labels=lowerCamelCase							).logits

 assert original_logits.shape == logits.shape
 print("""First values of original logits:""",	original_logits[0, :3, :3]							)
 print("""First values of HF logits:""",	logits[0, :3, :3]							)

 # assert values
 if model_name == "blip2-flan-t5-xl":
  lowerCamelCase		:	Dict							=      torch.tensor(
      [[-4_1.5_8_5_0, -4.4_4_4_0, -8.9_9_2_2], [-4_7.4_3_2_2, -5.9_1_4_3, -1.7_3_4_0]],	device=lowerCamelCase							)
  assert torch.allclose(logits[0, :3, :3],	lowerCamelCase,	atol=1e-4							)
 elif model_name == "blip2-flan-t5-xl-coco":
  lowerCamelCase		:	Dict							=      torch.tensor(
      [[-5_7.0_1_0_9, -9.8_9_6_7, -1_2.6_2_8_0], [-6_8.6_5_7_8, -1_2.7_1_9_1, -1_0.5_0_6_5]],	device=lowerCamelCase							)
 else:
  # cast to same type
  lowerCamelCase		:	List[str]							=      logits.dtype
  assert torch.allclose(original_logits.to(lowerCamelCase							),	lowerCamelCase,	atol=1e-2							)
 print("""Looks ok!"""							)

 print("""Generating a caption..."""							)
 lowerCamelCase		:	Optional[int]							=      """"""
 lowerCamelCase		:	Any							=      tokenizer(lowerCamelCase,	return_tensors="""pt"""							).input_ids.to(lowerCamelCase							)

 lowerCamelCase		:	Dict							=      original_model.generate({"""image""": original_pixel_values}							)
 lowerCamelCase		:	Union[str, Any]							=      hf_model.generate(
     lowerCamelCase,	lowerCamelCase,	do_sample=lowerCamelCase,	num_beams=5,	max_length=30,	min_length=1,	top_p=0.9,	repetition_penalty=1.0,	length_penalty=1.0,	temperature=1,	)
 print("""Original generation:""",	lowerCamelCase							)
 lowerCamelCase		:	Optional[Any]							=      input_ids.shape[1]
 lowerCamelCase		:	Any							=      processor.batch_decode(outputs[:, prompt_length:],	skip_special_tokens=lowerCamelCase							)
 lowerCamelCase		:	str							=      [text.strip() for text in output_text]
 print("""HF generation:""",	lowerCamelCase							)

 if pytorch_dump_folder_path is not None:
  processor.save_pretrained(lowerCamelCase							)
  hf_model.save_pretrained(lowerCamelCase							)

 if push_to_hub:
  processor.push_to_hub(F'''nielsr/{model_name}'''							)
  hf_model.push_to_hub(F'''nielsr/{model_name}'''							)


if __name__ == "__main__":
      _lowerCamelCase					   =argparse.ArgumentParser()
      _lowerCamelCase					   =[
          """blip2-opt-2.7b""",
          """blip2-opt-6.7b""",
          """blip2-opt-2.7b-coco""",
          """blip2-opt-6.7b-coco""",
          """blip2-flan-t5-xl""",
          """blip2-flan-t5-xl-coco""",
          """blip2-flan-t5-xxl""",
      ]
      parser.add_argument(
          """--model_name""",
          default="""blip2-opt-2.7b""",
          choices=choices,
          type=str,
          help="""Path to hf config.json of model to convert""",
      )
      parser.add_argument("""--pytorch_dump_folder_path""", default=None, type=str, help="""Path to the output PyTorch model.""")
      parser.add_argument(
          """--push_to_hub""",
          action="""store_true""",
          help="""Whether to push the model and processor to the hub after converting""",
      )

      _lowerCamelCase					   =parser.parse_args()

      convert_blipa_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)






import json
import os
import shutil
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 AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


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

from test_module.custom_configuration import CustomConfig  # noqa E402


_lowerCamelCase					   ={
    """return_dict""": False,
    """output_hidden_states""": True,
    """output_attentions""": True,
    """torchscript""": True,
    """torch_dtype""": """float16""",
    """use_bfloat16""": True,
    """tf_legacy_loss""": True,
    """pruned_heads""": {"""a""": 1},
    """tie_word_embeddings""": False,
    """is_decoder""": True,
    """cross_attention_hidden_size""": 1_2_8,
    """add_cross_attention""": True,
    """tie_encoder_decoder""": True,
    """max_length""": 5_0,
    """min_length""": 3,
    """do_sample""": True,
    """early_stopping""": True,
    """num_beams""": 3,
    """num_beam_groups""": 3,
    """diversity_penalty""": 0.5,
    """temperature""": 2.0,
    """top_k""": 1_0,
    """top_p""": 0.7,
    """typical_p""": 0.2,
    """repetition_penalty""": 0.8,
    """length_penalty""": 0.8,
    """no_repeat_ngram_size""": 5,
    """encoder_no_repeat_ngram_size""": 5,
    """bad_words_ids""": [1, 2, 3],
    """num_return_sequences""": 3,
    """chunk_size_feed_forward""": 5,
    """output_scores""": True,
    """return_dict_in_generate""": True,
    """forced_bos_token_id""": 2,
    """forced_eos_token_id""": 3,
    """remove_invalid_values""": True,
    """architectures""": ["""BertModel"""],
    """finetuning_task""": """translation""",
    """id2label""": {0: """label"""},
    """label2id""": {"""label""": """0"""},
    """tokenizer_class""": """BertTokenizerFast""",
    """prefix""": """prefix""",
    """bos_token_id""": 6,
    """pad_token_id""": 7,
    """eos_token_id""": 8,
    """sep_token_id""": 9,
    """decoder_start_token_id""": 1_0,
    """exponential_decay_length_penalty""": (5, 1.01),
    """suppress_tokens""": [0, 1],
    """begin_suppress_tokens""": 2,
    """task_specific_params""": {"""translation""": """some_params"""},
    """problem_type""": """regression""",
}





@is_staging_test
class 							A__		(	unittest.TestCase):
      @classmethod
      def 						UpperCamelCase__							(      cls      ):
       lowerCamelCase		:	int							=      TOKEN
       HfFolder.save_token(__magic_name__      )
      @classmethod
      def 						UpperCamelCase__							(      cls      ):
       try:
        delete_repo(token=cls._token    ,  repo_id="""test-config"""      )
       except HTTPError:
        pass

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

       try:
        delete_repo(token=cls._token    ,  repo_id="""test-dynamic-config"""      )
       except HTTPError:
        pass
      def 						UpperCamelCase__							(      self      ):
       lowerCamelCase		:	List[Any]							=      BertConfig(
           vocab_size=9_9    ,  hidden_size=3_2    ,  num_hidden_layers=5    ,  num_attention_heads=4    ,  intermediate_size=3_7      )
       config.push_to_hub("""test-config"""    ,  use_auth_token=self._token      )

       lowerCamelCase		:	Any							=      BertConfig.from_pretrained(F'''{USER}/test-config'''      )
       for k, v in config.to_dict().items():
        if k != "transformers_version":
         self.assertEqual(__magic_name__    ,  getattr(__magic_name__    ,  __magic_name__      )      )

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

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

       lowerCamelCase		:	Optional[Any]							=      BertConfig.from_pretrained(F'''{USER}/test-config'''      )
       for k, v in config.to_dict().items():
        if k != "transformers_version":
         self.assertEqual(__magic_name__    ,  getattr(__magic_name__    ,  __magic_name__      )      )
      def 						UpperCamelCase__							(      self      ):
       lowerCamelCase		:	Dict							=      BertConfig(
           vocab_size=9_9    ,  hidden_size=3_2    ,  num_hidden_layers=5    ,  num_attention_heads=4    ,  intermediate_size=3_7      )
       config.push_to_hub("""valid_org/test-config-org"""    ,  use_auth_token=self._token      )

       lowerCamelCase		:	Optional[int]							=      BertConfig.from_pretrained("""valid_org/test-config-org"""      )
       for k, v in config.to_dict().items():
        if k != "transformers_version":
         self.assertEqual(__magic_name__    ,  getattr(__magic_name__    ,  __magic_name__      )      )

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

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

       lowerCamelCase		:	List[str]							=      BertConfig.from_pretrained("""valid_org/test-config-org"""      )
       for k, v in config.to_dict().items():
        if k != "transformers_version":
         self.assertEqual(__magic_name__    ,  getattr(__magic_name__    ,  __magic_name__      )      )






      def 						UpperCamelCase__							(      self      ):
       CustomConfig.register_for_auto_class()
       lowerCamelCase		:	Optional[Any]							=      CustomConfig(attribute=4_2      )

       config.push_to_hub("""test-dynamic-config"""    ,  use_auth_token=self._token      )

       # This has added the proper auto_map field to the config
       self.assertDictEqual(config.auto_map    ,  {"""AutoConfig""": """custom_configuration.CustomConfig"""}      )

       lowerCamelCase		:	List[str]							=      AutoConfig.from_pretrained(F'''{USER}/test-dynamic-config'''    ,  trust_remote_code=__magic_name__      )
       # Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
       self.assertEqual(new_config.__class__.__name__    ,  """CustomConfig"""      )
       self.assertEqual(new_config.attribute    ,  4_2      )





class 							A__		(	unittest.TestCase):
      def 						UpperCamelCase__							(      self      ):
       lowerCamelCase		:	str							=      GPTaConfig()

       # attempt to modify each of int/float/bool/str config records and verify they were updated
       lowerCamelCase		:	Optional[int]							=      c.n_embd + 1  # int
       lowerCamelCase		:	Optional[int]							=      c.resid_pdrop + 1.0  # float
       lowerCamelCase		:	Tuple							=      not c.scale_attn_weights  # bool
       lowerCamelCase		:	Any							=      c.summary_type + """foo"""  # str
       c.update_from_string(
           F'''n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}'''      )
       self.assertEqual(__magic_name__    ,  c.n_embd    ,  """mismatch for key: n_embd"""      )
       self.assertEqual(__magic_name__    ,  c.resid_pdrop    ,  """mismatch for key: resid_pdrop"""      )
       self.assertEqual(__magic_name__    ,  c.scale_attn_weights    ,  """mismatch for key: scale_attn_weights"""      )
       self.assertEqual(__magic_name__    ,  c.summary_type    ,  """mismatch for key: summary_type"""      )
      def 						UpperCamelCase__							(      self      ):
       lowerCamelCase		:	str							=      PretrainedConfig()
       lowerCamelCase		:	int							=      [key for key in base_config.__dict__ if key not in config_common_kwargs]
       # If this part of the test fails, you have arguments to addin config_common_kwargs above.
       self.assertListEqual(
           __magic_name__    ,  ["""is_encoder_decoder""", """_name_or_path""", """_commit_hash""", """transformers_version"""]      )
       lowerCamelCase		:	List[str]							=      [key for key, value in config_common_kwargs.items() if value == getattr(__magic_name__    ,  __magic_name__      )]
       if len(__magic_name__      ) > 0:
        raise ValueError(
            """The following keys are set with the default values in"""
            """ `test_configuration_common.config_common_kwargs` pick another value for them:"""
            F''' {", ".join(__magic_name__      )}.'''      )
      def 						UpperCamelCase__							(      self      ):
       with self.assertRaises(__magic_name__      ):
        # config is in subfolder, the following should not work without specifying the subfolder
        lowerCamelCase		:	Dict							=      BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert-subfolder"""      )

       lowerCamelCase		:	str							=      BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert-subfolder"""    ,  subfolder="""bert"""      )

       self.assertIsNotNone(__magic_name__      )
      def 						UpperCamelCase__							(      self      ):
       # A mock response for an HTTP head request to emulate server down
       lowerCamelCase		:	Dict							=      mock.Mock()
       lowerCamelCase		:	Optional[int]							=      5_0_0
       lowerCamelCase		:	List[Any]							=      {}
       lowerCamelCase		:	Tuple							=      HTTPError
       lowerCamelCase		:	Union[str, Any]							=      {}

       # Download this model to make sure it's in the cache.
       lowerCamelCase		:	List[str]							=      BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert"""      )

       # 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:
        lowerCamelCase		:	Any							=      BertConfig.from_pretrained("""hf-internal-testing/tiny-random-bert"""      )
        # This check we did call the fake head request
        mock_head.assert_called()
      def 						UpperCamelCase__							(      self      ):
       # This test is for deprecated behavior and can be removed in v5
       lowerCamelCase		:	List[str]							=      BertConfig.from_pretrained(
           """https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json"""      )
      def 						UpperCamelCase__							(      self      ):
       lowerCamelCase		:	Optional[int]							=      AutoConfig.from_pretrained("""bert-base-cased"""      )
       lowerCamelCase		:	Optional[Any]							=      ["""config.4.0.0.json"""]

       with tempfile.TemporaryDirectory() as tmp_dir:
        configuration.save_pretrained(__magic_name__      )
        lowerCamelCase		:	str							=      2
        json.dump(configuration.to_dict()    ,  open(os.path.join(__magic_name__    ,  """config.4.0.0.json"""      )    ,  """w"""      )      )

        # This should pick the new configuration file as the version of Transformers is > 4.0.0
        lowerCamelCase		:	Union[str, Any]							=      AutoConfig.from_pretrained(__magic_name__      )
        self.assertEqual(new_configuration.hidden_size    ,  2      )

        # Will need to be adjusted if we reach v42 and this test is still here.
        # Should pick the old configuration file as the version of Transformers is < 4.42.0
        lowerCamelCase		:	Any							=      ["""config.42.0.0.json"""]
        lowerCamelCase		:	Optional[Any]							=      7_6_8
        configuration.save_pretrained(__magic_name__      )
        shutil.move(os.path.join(__magic_name__    ,  """config.4.0.0.json"""      )    ,  os.path.join(__magic_name__    ,  """config.42.0.0.json"""      )      )
        lowerCamelCase		:	int							=      AutoConfig.from_pretrained(__magic_name__      )
        self.assertEqual(new_configuration.hidden_size    ,  7_6_8      )






      def 						UpperCamelCase__							(      self      ):
       # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
       lowerCamelCase		:	str							=      """hf-internal-testing/test-two-configs"""

       import transformers as new_transformers

       lowerCamelCase		:	Tuple							=      """v4.0.0"""
       lowerCamelCase			,    lowerCamelCase		:	Optional[int]							=      new_transformers.models.auto.AutoConfig.from_pretrained(
           __magic_name__    ,  return_unused_kwargs=__magic_name__      )
       self.assertEqual(new_configuration.hidden_size    ,  2      )
       # This checks `_configuration_file` ia not kept in the kwargs by mistake.
       self.assertDictEqual(__magic_name__    ,  {}      )

       # Testing an older version by monkey-patching the version in the module it's used.
       import transformers as old_transformers

       lowerCamelCase		:	Tuple							=      """v3.0.0"""
       lowerCamelCase		:	Any							=      old_transformers.models.auto.AutoConfig.from_pretrained(__magic_name__      )
       self.assertEqual(old_configuration.hidden_size    ,  7_6_8      )




