




"""simple docstring"""
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 (
    BertTokenizer,
    ViltConfig,
    ViltForImageAndTextRetrieval,
    ViltForImagesAndTextClassification,
    ViltForMaskedLM,
    ViltForQuestionAnswering,
    ViltImageProcessor,
    ViltProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
a_				:    Optional[Any]										=     logging.get_logger(__name__)





def 						UpperCAmelCase				(			A__:    Optional[int]							,				A__:    Tuple=False							,				A__:    Tuple=False							,				A__:    str=False     )  ->     str:
			__lowerCamelCase					:	Optional[Any]	       =				[]
			for i in range(config.num_hidden_layers     ):
						# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
						rename_keys.append((f'''transformer.blocks.{i}.norm1.weight''', f'''vilt.encoder.layer.{i}.layernorm_before.weight''')     )
						rename_keys.append((f'''transformer.blocks.{i}.norm1.bias''', f'''vilt.encoder.layer.{i}.layernorm_before.bias''')     )
						rename_keys.append(
						    (f'''transformer.blocks.{i}.attn.proj.weight''', f'''vilt.encoder.layer.{i}.attention.output.dense.weight''')     )
						rename_keys.append(
						    (f'''transformer.blocks.{i}.attn.proj.bias''', f'''vilt.encoder.layer.{i}.attention.output.dense.bias''')     )
						rename_keys.append((f'''transformer.blocks.{i}.norm2.weight''', f'''vilt.encoder.layer.{i}.layernorm_after.weight''')     )
						rename_keys.append((f'''transformer.blocks.{i}.norm2.bias''', f'''vilt.encoder.layer.{i}.layernorm_after.bias''')     )
						rename_keys.append(
						    (f'''transformer.blocks.{i}.mlp.fc1.weight''', f'''vilt.encoder.layer.{i}.intermediate.dense.weight''')     )
						rename_keys.append((f'''transformer.blocks.{i}.mlp.fc1.bias''', f'''vilt.encoder.layer.{i}.intermediate.dense.bias''')     )
						rename_keys.append((f'''transformer.blocks.{i}.mlp.fc2.weight''', f'''vilt.encoder.layer.{i}.output.dense.weight''')     )
						rename_keys.append((f'''transformer.blocks.{i}.mlp.fc2.bias''', f'''vilt.encoder.layer.{i}.output.dense.bias''')     )

			# embeddings
			rename_keys.extend(
			    [
			        # text embeddings
			        ('text_embeddings.word_embeddings.weight', 'vilt.embeddings.text_embeddings.word_embeddings.weight'),
			        (
			            'text_embeddings.position_embeddings.weight',
			            'vilt.embeddings.text_embeddings.position_embeddings.weight',
			        ),
			        ('text_embeddings.position_ids', 'vilt.embeddings.text_embeddings.position_ids'),
			        (
			            'text_embeddings.token_type_embeddings.weight',
			            'vilt.embeddings.text_embeddings.token_type_embeddings.weight',
			        ),
			        ('text_embeddings.LayerNorm.weight', 'vilt.embeddings.text_embeddings.LayerNorm.weight'),
			        ('text_embeddings.LayerNorm.bias', 'vilt.embeddings.text_embeddings.LayerNorm.bias'),
			        # patch embeddings
			        ('transformer.cls_token', 'vilt.embeddings.cls_token'),
			        ('transformer.patch_embed.proj.weight', 'vilt.embeddings.patch_embeddings.projection.weight'),
			        ('transformer.patch_embed.proj.bias', 'vilt.embeddings.patch_embeddings.projection.bias'),
			        ('transformer.pos_embed', 'vilt.embeddings.position_embeddings'),
			        # token type embeddings
			        ('token_type_embeddings.weight', 'vilt.embeddings.token_type_embeddings.weight'),
			    ]     )

			# final layernorm + pooler
			rename_keys.extend(
			    [
			        ('transformer.norm.weight', 'vilt.layernorm.weight'),
			        ('transformer.norm.bias', 'vilt.layernorm.bias'),
			        ('pooler.dense.weight', 'vilt.pooler.dense.weight'),
			        ('pooler.dense.bias', 'vilt.pooler.dense.bias'),
			    ]     )

			# classifier head(s)
			if vqa_model:
						# classification head
						rename_keys.extend(
						    [
						        ('vqa_classifier.0.weight', 'classifier.0.weight'),
						        ('vqa_classifier.0.bias', 'classifier.0.bias'),
						        ('vqa_classifier.1.weight', 'classifier.1.weight'),
						        ('vqa_classifier.1.bias', 'classifier.1.bias'),
						        ('vqa_classifier.3.weight', 'classifier.3.weight'),
						        ('vqa_classifier.3.bias', 'classifier.3.bias'),
						    ]     )
			elif nlvr_model:
						# classification head
						rename_keys.extend(
						    [
						        ('nlvr2_classifier.0.weight', 'classifier.0.weight'),
						        ('nlvr2_classifier.0.bias', 'classifier.0.bias'),
						        ('nlvr2_classifier.1.weight', 'classifier.1.weight'),
						        ('nlvr2_classifier.1.bias', 'classifier.1.bias'),
						        ('nlvr2_classifier.3.weight', 'classifier.3.weight'),
						        ('nlvr2_classifier.3.bias', 'classifier.3.bias'),
						    ]     )
			else:
						pass

			return rename_keys





def 						UpperCAmelCase				(			A__:    List[str]							,				A__:    Union[str, Any]     )  ->     List[str]:
			for i in range(config.num_hidden_layers     ):
						__lowerCamelCase					:	List[Any]	       =				'vilt.'
						# read in weights + bias of input projection layer (in timm, this is a single matrix + bias)
						__lowerCamelCase					:	List[Any]	       =				state_dict.pop(f'''transformer.blocks.{i}.attn.qkv.weight'''     )
						__lowerCamelCase					:	Optional[Any]	       =				state_dict.pop(f'''transformer.blocks.{i}.attn.qkv.bias'''     )
						# next, add query, keys and values (in that order) to the state dict
						__lowerCamelCase					:	Optional[Any]	       =				in_proj_weight[
						    : config.hidden_size, :
						]
						__lowerCamelCase					:	Optional[int]	       =				in_proj_bias[: config.hidden_size]
						__lowerCamelCase					:	Optional[Any]	       =				in_proj_weight[
						    config.hidden_size : config.hidden_size * 2, :
						]
						__lowerCamelCase					:	List[Any]	       =				in_proj_bias[
						    config.hidden_size : config.hidden_size * 2
						]
						__lowerCamelCase					:	int	       =				in_proj_weight[
						    -config.hidden_size :, :
						]
						__lowerCamelCase					:	Tuple	       =				in_proj_bias[-config.hidden_size :]





def 						UpperCAmelCase				(			A__:    str     )  ->     Any:
			__lowerCamelCase					:	List[str]	       =				['head.weight', 'head.bias']
			for k in ignore_keys:
						state_dict.pop(A__							,				A__     )





def 						UpperCAmelCase				(			A__:    Dict							,				A__:    Union[str, Any]							,				A__:    Tuple     )  ->     Tuple:
			__lowerCamelCase					:	Optional[Any]	       =				dct.pop(A__     )
			__lowerCamelCase					:	Optional[int]	       =				val





@torch.no_grad()
def 						UpperCAmelCase				(			A__:    Optional[int]							,				A__:    int     )  ->     Tuple:
			__lowerCamelCase					:	Optional[int]	       =				ViltConfig(image_size=384							,				patch_size=32							,				tie_word_embeddings=A__     )
			__lowerCamelCase					:	List[str]	       =				False
			__lowerCamelCase					:	Dict	       =				False
			__lowerCamelCase					:	Union[str, Any]	       =				False
			__lowerCamelCase					:	Any	       =				False
			if "vqa" in checkpoint_url:
						__lowerCamelCase					:	str	       =				True
						__lowerCamelCase					:	Union[str, Any]	       =				3129
						__lowerCamelCase					:	str	       =				'huggingface/label-files'
						__lowerCamelCase					:	int	       =				'vqa2-id2label.json'
						__lowerCamelCase					:	Any	       =				json.load(open(hf_hub_download(A__							,				A__							,				repo_type='dataset'     )							,				'r'     )     )
						__lowerCamelCase					:	List[Any]	       =				{int(A__     ): v for k, v in idalabel.items()}
						__lowerCamelCase					:	Dict	       =				idalabel
						__lowerCamelCase					:	Tuple	       =				{v: k for k, v in idalabel.items()}
						__lowerCamelCase					:	int	       =				ViltForQuestionAnswering(A__     )
			elif "nlvr" in checkpoint_url:
						__lowerCamelCase					:	Optional[Any]	       =				True
						__lowerCamelCase					:	Union[str, Any]	       =				2
						__lowerCamelCase					:	Tuple	       =				{0: 'False', 1: 'True'}
						__lowerCamelCase					:	Optional[Any]	       =				{v: k for k, v in config.idalabel.items()}
						__lowerCamelCase					:	Any	       =				3
						__lowerCamelCase					:	Optional[int]	       =				ViltForImagesAndTextClassification(A__     )
			elif "irtr" in checkpoint_url:
						__lowerCamelCase					:	Optional[int]	       =				True
						__lowerCamelCase					:	Any	       =				ViltForImageAndTextRetrieval(A__     )
			elif "mlm_itm" in checkpoint_url:
						__lowerCamelCase					:	List[Any]	       =				True
						__lowerCamelCase					:	str	       =				ViltForMaskedLM(A__     )
			else:
						raise ValueError('Unknown model type'     )

			# load state_dict of original model, remove and rename some keys
			__lowerCamelCase					:	str	       =				torch.hub.load_state_dict_from_url(A__							,				map_location='cpu'     )['state_dict']
			__lowerCamelCase					:	Tuple	       =				create_rename_keys(A__							,				A__							,				A__							,				A__     )
			for src, dest in rename_keys:
						rename_key(A__							,				A__							,				A__     )
			read_in_q_k_v(A__							,				A__     )
			if mlm_model or irtr_model:
						__lowerCamelCase					:	List[Any]	       =				['itm_score.fc.weight', 'itm_score.fc.bias']
						for k in ignore_keys:
									state_dict.pop(A__							,				A__     )

    # load state dict into HuggingFace model
			model.eval()
			if mlm_model:
						__lowerCamelCase       ,      __lowerCamelCase					:	List[Any]	       =				model.load_state_dict(A__							,				strict=A__     )
						assert missing_keys == ["mlm_score.decoder.bias"]
			else:
						model.load_state_dict(A__     )

			# Define processor
			__lowerCamelCase					:	str	       =				ViltImageProcessor(size=384     )
			__lowerCamelCase					:	Union[str, Any]	       =				BertTokenizer.from_pretrained('bert-base-uncased'     )
			__lowerCamelCase					:	str	       =				ViltProcessor(A__							,				A__     )

			# Forward pass on example inputs (image + text)
			if nlvr_model:
						__lowerCamelCase					:	Any	       =				Image.open(requests.get('https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg'							,				stream=A__     ).raw     )
						__lowerCamelCase					:	List[Any]	       =				Image.open(requests.get('https://lil.nlp.cornell.edu/nlvr/exs/ex0_0.jpg'							,				stream=A__     ).raw     )
						__lowerCamelCase					:	List[Any]	       =				(
						    'The left image contains twice the number of dogs as the right image, and at least two dogs in total are'
						    ' standing.'
						)
						__lowerCamelCase					:	Dict	       =				processor(A__							,				A__							,				return_tensors='pt'     )
						__lowerCamelCase					:	int	       =				processor(A__							,				A__							,				return_tensors='pt'     )
						__lowerCamelCase					:	str	       =				model(
						    input_ids=encoding_a.input_ids							,				pixel_values=encoding_a.pixel_values							,				pixel_values_a=encoding_a.pixel_values							,				)
			else:
						__lowerCamelCase					:	Optional[int]	       =				Image.open(requests.get('http://images.cocodataset.org/val2017/000000039769.jpg'							,				stream=A__     ).raw     )
						if mlm_model:
									__lowerCamelCase					:	Tuple	       =				'a bunch of [MASK] laying on a [MASK].'
						else:
									__lowerCamelCase					:	str	       =				'How many cats are there?'
						__lowerCamelCase					:	Union[str, Any]	       =				processor(A__							,				A__							,				return_tensors='pt'     )
						__lowerCamelCase					:	Any	       =				model(**A__     )

			# Verify outputs
			if mlm_model:
						__lowerCamelCase					:	int	       =				torch.Size([1, 11, 30522]     )
						__lowerCamelCase					:	int	       =				torch.tensor([-12.5_061, -12.5_123, -12.5_174]     )
						assert outputs.logits.shape == expected_shape
						assert torch.allclose(outputs.logits[0, 0, :3]							,				A__							,				atol=1E-4     )

						# verify masked token prediction equals "cats"
						__lowerCamelCase					:	Tuple	       =				outputs.logits[0, 4, :].argmax(-1     ).item()
						assert tokenizer.decode([predicted_id]     ) == "cats"
			elif vqa_model:
						__lowerCamelCase					:	List[Any]	       =				torch.Size([1, 3129]     )
						__lowerCamelCase					:	Union[str, Any]	       =				torch.tensor([-15.9_495, -18.1_472, -10.3_041]     )
						assert torch.allclose(outputs.logits[0, :3]							,				A__							,				atol=1E-4     )
						assert outputs.logits.shape == expected_shape
						assert torch.allclose(outputs.logits[0, 0, :3]							,				A__							,				atol=1E-4     )

						# verify vqa prediction equals "2"
						__lowerCamelCase					:	Any	       =				outputs.logits.argmax(-1     ).item()
						assert model.config.idalabel[predicted_idx] == "2"
			elif nlvr_model:
						__lowerCamelCase					:	Union[str, Any]	       =				torch.Size([1, 2]     )
						__lowerCamelCase					:	Any	       =				torch.tensor([-2.8_721, 2.1_291]     )
						assert torch.allclose(outputs.logits[0, :3]							,				A__							,				atol=1E-4     )
						assert outputs.logits.shape == expected_shape

			Path(A__     ).mkdir(exist_ok=A__     )
			print(f'''Saving model and processor to {pytorch_dump_folder_path}'''     )
			model.save_pretrained(A__     )
			processor.save_pretrained(A__     )


if __name__ == "__main__":
					a_				:    Dict										=     argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    '''--checkpoint_url''',
					    default='''https://github.com/dandelin/ViLT/releases/download/200k/vilt_200k_mlm_itm.ckpt''',
					    type=str,
					    help='''URL of the checkpoint you\'d like to convert.''',
					)
					parser.add_argument(
					    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
					)

					a_				:    Union[str, Any]										=     parser.parse_args()
					convert_vilt_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)









"""simple docstring"""
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


a_				:    Optional[int]										=     {
    '''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_28,
    '''add_cross_attention''': True,
    '''tie_encoder_decoder''': True,
    '''max_length''': 50,
    '''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''': 10,
    '''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''': 10,
    '''exponential_decay_length_penalty''': (5, 1.0_1),
    '''suppress_tokens''': [0, 1],
    '''begin_suppress_tokens''': 2,
    '''task_specific_params''': {'''translation''': '''some_params'''},
    '''problem_type''': '''regression''',
}

@is_staging_test
class __lowercase(      unittest.TestCase				):




					'''simple docstring'''


					@classmethod
					def     snake_case_				(    cls     ):
								__lowerCamelCase					:	Tuple	       =				TOKEN
								HfFolder.save_token(__a     )
					@classmethod
					def     snake_case_				(    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     snake_case_				(    self     ):
								__lowerCamelCase					:	List[str]	       =				BertConfig(
								    vocab_size=99						,	hidden_size=32						,	num_hidden_layers=5						,	num_attention_heads=4						,	intermediate_size=37     )
								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(__a						,	getattr(__a						,	__a     )     )

        # 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(__a						,	repo_id='test-config'						,	push_to_hub=__a						,	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(__a						,	getattr(__a						,	__a     )     )
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	int	       =				BertConfig(
								    vocab_size=99						,	hidden_size=32						,	num_hidden_layers=5						,	num_attention_heads=4						,	intermediate_size=37     )
								config.push_to_hub('valid_org/test-config-org'						,	use_auth_token=self._token     )

								__lowerCamelCase					:	Tuple	       =				BertConfig.from_pretrained('valid_org/test-config-org'     )
								for k, v in config.to_dict().items():
											if k != "transformers_version":
														self.assertEqual(__a						,	getattr(__a						,	__a     )     )

        # 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(
											    __a						,	repo_id='valid_org/test-config-org'						,	push_to_hub=__a						,	use_auth_token=self._token     )

								__lowerCamelCase					:	Tuple	       =				BertConfig.from_pretrained('valid_org/test-config-org'     )
								for k, v in config.to_dict().items():
											if k != "transformers_version":
														self.assertEqual(__a						,	getattr(__a						,	__a     )     )





					def     snake_case_				(    self     ):
								CustomConfig.register_for_auto_class()
								__lowerCamelCase					:	Optional[Any]	       =				CustomConfig(attribute=42     )

								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					:	Tuple	       =				AutoConfig.from_pretrained(f'''{USER}/test-dynamic-config'''						,	trust_remote_code=__a     )
								# 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						,	42     )



class __lowercase(      unittest.TestCase				):




					'''simple docstring'''


					def     snake_case_				(    self     ):
								__lowerCamelCase					:	Tuple	       =				GPTaConfig()

								# attempt to modify each of int/float/bool/str config records and verify they were updated
								__lowerCamelCase					:	List[str]	       =				c.n_embd + 1  # int
								__lowerCamelCase					:	Dict	       =				c.resid_pdrop + 1.0  # float
								__lowerCamelCase					:	int	       =				not c.scale_attn_weights  # bool
								__lowerCamelCase					:	Optional[int]	       =				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(__a						,	c.n_embd						,	'mismatch for key: n_embd'     )
								self.assertEqual(__a						,	c.resid_pdrop						,	'mismatch for key: resid_pdrop'     )
								self.assertEqual(__a						,	c.scale_attn_weights						,	'mismatch for key: scale_attn_weights'     )
								self.assertEqual(__a						,	c.summary_type						,	'mismatch for key: summary_type'     )
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	Tuple	       =				PretrainedConfig()
								__lowerCamelCase					:	Dict	       =				[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(
								    __a						,	['is_encoder_decoder', '_name_or_path', '_commit_hash', 'transformers_version']     )
								__lowerCamelCase					:	int	       =				[key for key, value in config_common_kwargs.items() if value == getattr(__a						,	__a     )]
								if len(__a     ) > 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(__a     )}.'''     )
					def     snake_case_				(    self     ):
								with self.assertRaises(__a     ):
											# config is in subfolder, the following should not work without specifying the subfolder
											__lowerCamelCase					:	int	       =				BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert-subfolder'     )

								__lowerCamelCase					:	Optional[int]	       =				BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert-subfolder'						,	subfolder='bert'     )

								self.assertIsNotNone(__a     )
					def     snake_case_				(    self     ):
								# A mock response for an HTTP head request to emulate server down
								__lowerCamelCase					:	List[str]	       =				mock.Mock()
								__lowerCamelCase					:	Tuple	       =				500
								__lowerCamelCase					:	Tuple	       =				{}
								__lowerCamelCase					:	Optional[Any]	       =				HTTPError
								__lowerCamelCase					:	str	       =				{}

								# Download this model to make sure it's in the cache.
								__lowerCamelCase					:	Optional[int]	       =				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=__a     ) as mock_head:
											__lowerCamelCase					:	Union[str, Any]	       =				BertConfig.from_pretrained('hf-internal-testing/tiny-random-bert'     )
											# This check we did call the fake head request
											mock_head.assert_called()
					def     snake_case_				(    self     ):
								# This test is for deprecated behavior and can be removed in v5
								__lowerCamelCase					:	Optional[Any]	       =				BertConfig.from_pretrained(
								    'https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'     )
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	List[Any]	       =				AutoConfig.from_pretrained('bert-base-cased'     )
								__lowerCamelCase					:	str	       =				['config.4.0.0.json']

								with tempfile.TemporaryDirectory() as tmp_dir:
											configuration.save_pretrained(__a     )
											__lowerCamelCase					:	Optional[int]	       =				2
											json.dump(configuration.to_dict()						,	open(os.path.join(__a						,	'config.4.0.0.json'     )						,	'w'     )     )

											# This should pick the new configuration file as the version of Transformers is > 4.0.0
											__lowerCamelCase					:	Any	       =				AutoConfig.from_pretrained(__a     )
											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					:	Tuple	       =				768
											configuration.save_pretrained(__a     )
											shutil.move(os.path.join(__a						,	'config.4.0.0.json'     )						,	os.path.join(__a						,	'config.42.0.0.json'     )     )
											__lowerCamelCase					:	Dict	       =				AutoConfig.from_pretrained(__a     )
											self.assertEqual(new_configuration.hidden_size						,	768     )





					def     snake_case_				(    self     ):
								# This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
								__lowerCamelCase					:	List[str]	       =				'hf-internal-testing/test-two-configs'

								import transformers as new_transformers

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

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

								__lowerCamelCase					:	Union[str, Any]	       =				'v3.0.0'
								__lowerCamelCase					:	Optional[int]	       =				old_transformers.models.auto.AutoConfig.from_pretrained(__a     )
								self.assertEqual(old_configuration.hidden_size						,	768     )



