




"""simple docstring"""
import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


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

a_				:    Any										=     {
    '''b0''': efficientnet.EfficientNetBa,
    '''b1''': efficientnet.EfficientNetBa,
    '''b2''': efficientnet.EfficientNetBa,
    '''b3''': efficientnet.EfficientNetBa,
    '''b4''': efficientnet.EfficientNetBa,
    '''b5''': efficientnet.EfficientNetBa,
    '''b6''': efficientnet.EfficientNetBa,
    '''b7''': efficientnet.EfficientNetBa,
}

a_				:    List[str]										=     {
    '''b0''': {
        '''hidden_dim''': 12_80,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.0,
        '''image_size''': 2_24,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [],
    },
    '''b1''': {
        '''hidden_dim''': 12_80,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.1,
        '''image_size''': 2_40,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [16],
    },
    '''b2''': {
        '''hidden_dim''': 14_08,
        '''width_coef''': 1.1,
        '''depth_coef''': 1.2,
        '''image_size''': 2_60,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 8, 16],
    },
    '''b3''': {
        '''hidden_dim''': 15_36,
        '''width_coef''': 1.2,
        '''depth_coef''': 1.4,
        '''image_size''': 3_00,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 18],
    },
    '''b4''': {
        '''hidden_dim''': 17_92,
        '''width_coef''': 1.4,
        '''depth_coef''': 1.8,
        '''image_size''': 3_80,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [6],
    },
    '''b5''': {
        '''hidden_dim''': 20_48,
        '''width_coef''': 1.6,
        '''depth_coef''': 2.2,
        '''image_size''': 4_56,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [13, 27],
    },
    '''b6''': {
        '''hidden_dim''': 23_04,
        '''width_coef''': 1.8,
        '''depth_coef''': 2.6,
        '''image_size''': 5_28,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [31],
    },
    '''b7''': {
        '''hidden_dim''': 25_60,
        '''width_coef''': 2.0,
        '''depth_coef''': 3.1,
        '''image_size''': 6_00,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [18],
    },
}





def 						UpperCAmelCase				(			A__:    Dict     )  ->     Optional[Any]:
			__lowerCamelCase					:	List[Any]	       =				EfficientNetConfig()
			__lowerCamelCase					:	str	       =				CONFIG_MAP[model_name]['hidden_dim']
			__lowerCamelCase					:	int	       =				CONFIG_MAP[model_name]['width_coef']
			__lowerCamelCase					:	List[Any]	       =				CONFIG_MAP[model_name]['depth_coef']
			__lowerCamelCase					:	Optional[int]	       =				CONFIG_MAP[model_name]['image_size']
			__lowerCamelCase					:	Tuple	       =				CONFIG_MAP[model_name]['dropout_rate']
			__lowerCamelCase					:	int	       =				CONFIG_MAP[model_name]['dw_padding']

			__lowerCamelCase					:	Tuple	       =				'huggingface/label-files'
			__lowerCamelCase					:	Dict	       =				'imagenet-1k-id2label.json'
			__lowerCamelCase					:	int	       =				1000
			__lowerCamelCase					:	Any	       =				json.load(open(hf_hub_download(A__							,				A__							,				repo_type='dataset'     )							,				'r'     )     )
			__lowerCamelCase					:	List[str]	       =				{int(A__     ): v for k, v in idalabel.items()}

			__lowerCamelCase					:	Optional[int]	       =				idalabel
			__lowerCamelCase					:	List[str]	       =				{v: k for k, v in idalabel.items()}
			return config





def 						UpperCAmelCase				(			)  ->     Optional[Any]:
			__lowerCamelCase					:	Any	       =				'http://images.cocodataset.org/val2017/000000039769.jpg'
			__lowerCamelCase					:	List[str]	       =				Image.open(requests.get(A__							,				stream=A__     ).raw     )
			return im





def 						UpperCAmelCase				(			A__:    List[Any]     )  ->     str:
			__lowerCamelCase					:	Any	       =				CONFIG_MAP[model_name]['image_size']
			__lowerCamelCase					:	List[str]	       =				EfficientNetImageProcessor(
			    size={'height': size, 'width': size}							,				image_mean=[0.485, 0.456, 0.406]							,				image_std=[0.47_853_944, 0.4_732_864, 0.47_434_163]							,				do_center_crop=A__							,				)
			return preprocessor





def 						UpperCAmelCase				(			A__:    Tuple     )  ->     Tuple:
			__lowerCamelCase					:	Any	       =				[v.split('_'     )[0].split('block'     )[1] for v in original_param_names if v.startswith('block'     )]
			__lowerCamelCase					:	Dict	       =				sorted(set(A__     )     )
			__lowerCamelCase					:	Dict	       =				len(A__     )
			__lowerCamelCase					:	Optional[Any]	       =				{b: str(A__     ) for b, i in zip(A__							,				range(A__     )     )}

			__lowerCamelCase					:	Any	       =				[]
			rename_keys.append(('stem_conv/kernel:0', 'embeddings.convolution.weight')     )
			rename_keys.append(('stem_bn/gamma:0', 'embeddings.batchnorm.weight')     )
			rename_keys.append(('stem_bn/beta:0', 'embeddings.batchnorm.bias')     )
			rename_keys.append(('stem_bn/moving_mean:0', 'embeddings.batchnorm.running_mean')     )
			rename_keys.append(('stem_bn/moving_variance:0', 'embeddings.batchnorm.running_var')     )

			for b in block_names:
						__lowerCamelCase					:	Dict	       =				block_name_mapping[b]
						rename_keys.append((f'''block{b}_expand_conv/kernel:0''', f'''encoder.blocks.{hf_b}.expansion.expand_conv.weight''')     )
						rename_keys.append((f'''block{b}_expand_bn/gamma:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.weight''')     )
						rename_keys.append((f'''block{b}_expand_bn/beta:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.bias''')     )
						rename_keys.append(
						    (f'''block{b}_expand_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_mean''')     )
						rename_keys.append(
						    (f'''block{b}_expand_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.expansion.expand_bn.running_var''')     )
						rename_keys.append(
						    (f'''block{b}_dwconv/depthwise_kernel:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight''')     )
						rename_keys.append((f'''block{b}_bn/gamma:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight''')     )
						rename_keys.append((f'''block{b}_bn/beta:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias''')     )
						rename_keys.append(
						    (f'''block{b}_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean''')     )
						rename_keys.append(
						    (f'''block{b}_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var''')     )

						rename_keys.append((f'''block{b}_se_reduce/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.weight''')     )
						rename_keys.append((f'''block{b}_se_reduce/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.reduce.bias''')     )
						rename_keys.append((f'''block{b}_se_expand/kernel:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.weight''')     )
						rename_keys.append((f'''block{b}_se_expand/bias:0''', f'''encoder.blocks.{hf_b}.squeeze_excite.expand.bias''')     )
						rename_keys.append(
						    (f'''block{b}_project_conv/kernel:0''', f'''encoder.blocks.{hf_b}.projection.project_conv.weight''')     )
						rename_keys.append((f'''block{b}_project_bn/gamma:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.weight''')     )
						rename_keys.append((f'''block{b}_project_bn/beta:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.bias''')     )
						rename_keys.append(
						    (f'''block{b}_project_bn/moving_mean:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_mean''')     )
						rename_keys.append(
						    (f'''block{b}_project_bn/moving_variance:0''', f'''encoder.blocks.{hf_b}.projection.project_bn.running_var''')     )

			rename_keys.append(('top_conv/kernel:0', 'encoder.top_conv.weight')     )
			rename_keys.append(('top_bn/gamma:0', 'encoder.top_bn.weight')     )
			rename_keys.append(('top_bn/beta:0', 'encoder.top_bn.bias')     )
			rename_keys.append(('top_bn/moving_mean:0', 'encoder.top_bn.running_mean')     )
			rename_keys.append(('top_bn/moving_variance:0', 'encoder.top_bn.running_var')     )

			__lowerCamelCase					:	Optional[int]	       =				{}
			for item in rename_keys:
						if item[0] in original_param_names:
									__lowerCamelCase					:	int	       =				'efficientnet.' + item[1]

			__lowerCamelCase					:	str	       =				'classifier.weight'
			__lowerCamelCase					:	Any	       =				'classifier.bias'
			return key_mapping





def 						UpperCAmelCase				(			A__:    Optional[int]							,				A__:    Any							,				A__:    Optional[int]     )  ->     List[Any]:
			for key, value in tf_params.items():
						if "normalization" in key:
									continue

						__lowerCamelCase					:	Tuple	       =				key_mapping[key]
						if "_conv" in key and "kernel" in key:
									__lowerCamelCase					:	Optional[int]	       =				torch.from_numpy(A__     ).permute(3							,				2							,				0							,				1     )
						elif "depthwise_kernel" in key:
									__lowerCamelCase					:	List[Any]	       =				torch.from_numpy(A__     ).permute(2							,				3							,				0							,				1     )
						elif "kernel" in key:
									__lowerCamelCase					:	List[str]	       =				torch.from_numpy(np.transpose(A__     )     )
						else:
									__lowerCamelCase					:	int	       =				torch.from_numpy(A__     )

						# Replace HF parameters with original TF model parameters
						assert hf_params[hf_key].shape == new_hf_value.shape
						hf_params[hf_key].copy_(A__     )





@torch.no_grad()
def 						UpperCAmelCase				(			A__:    List[str]							,				A__:    List[Any]							,				A__:    Dict							,				A__:    Dict     )  ->     List[str]:
			__lowerCamelCase					:	List[str]	       =				model_classes[model_name](
			    include_top=A__							,				weights='imagenet'							,				input_tensor=A__							,				input_shape=A__							,				pooling=A__							,				classes=1000							,				classifier_activation='softmax'							,				)

			__lowerCamelCase					:	Optional[Any]	       =				original_model.trainable_variables
			__lowerCamelCase					:	Union[str, Any]	       =				original_model.non_trainable_variables
			__lowerCamelCase					:	int	       =				{param.name: param.numpy() for param in tf_params}
			for param in tf_non_train_params:
						__lowerCamelCase					:	str	       =				param.numpy()
			__lowerCamelCase					:	int	       =				list(tf_params.keys()     )

			# Load HuggingFace model
			__lowerCamelCase					:	Optional[Any]	       =				get_efficientnet_config(A__     )
			__lowerCamelCase					:	Optional[Any]	       =				EfficientNetForImageClassification(A__     ).eval()
			__lowerCamelCase					:	List[str]	       =				hf_model.state_dict()

			# Create src-to-dst parameter name mapping dictionary
			print('Converting parameters...'     )
			__lowerCamelCase					:	int	       =				rename_keys(A__     )
			replace_params(A__							,				A__							,				A__     )

			# Initialize preprocessor and preprocess input image
			__lowerCamelCase					:	List[Any]	       =				convert_image_processor(A__     )
			__lowerCamelCase					:	Optional[Any]	       =				preprocessor(images=prepare_img()							,				return_tensors='pt'     )

			# HF model inference
			hf_model.eval()
			with torch.no_grad():
						__lowerCamelCase					:	Dict	       =				hf_model(**A__     )
			__lowerCamelCase					:	Optional[int]	       =				outputs.logits.detach().numpy()

			# Original model inference
			__lowerCamelCase					:	str	       =				False
			__lowerCamelCase					:	Tuple	       =				CONFIG_MAP[model_name]['image_size']
			__lowerCamelCase					:	str	       =				prepare_img().resize((image_size, image_size)							,				resample=PIL.Image.NEAREST     )
			__lowerCamelCase					:	Optional[int]	       =				image.img_to_array(A__     )
			__lowerCamelCase					:	Dict	       =				np.expand_dims(A__							,				axis=0     )
			__lowerCamelCase					:	Dict	       =				original_model.predict(A__     )

			# Check whether original and HF model outputs match  -> np.allclose
			assert np.allclose(A__							,				A__							,				atol=1E-3     ), "The predicted logits are not the same."
			print('Model outputs match!'     )

			if save_model:
						# Create folder to save model
						if not os.path.isdir(A__     ):
									os.mkdir(A__     )
						# Save converted model and image processor
						hf_model.save_pretrained(A__     )
						preprocessor.save_pretrained(A__     )

			if push_to_hub:
						# Push model and image processor to hub
						print(f'''Pushing converted {model_name} to the hub...'''     )
						__lowerCamelCase					:	List[str]	       =				f'''efficientnet-{model_name}'''
						preprocessor.push_to_hub(A__     )
						hf_model.push_to_hub(A__     )


if __name__ == "__main__":
						a_				:    Any										=     argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '''--model_name''',
						    default='''b0''',
						    type=str,
						    help='''Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].''',
						)
						parser.add_argument(
						    '''--pytorch_dump_folder_path''',
						    default='''hf_model''',
						    type=str,
						    help='''Path to the output PyTorch model directory.''',
						)
						parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
						parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''')

						a_				:    List[str]										=     parser.parse_args()
						convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)









"""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     )



