






"""simple docstring"""







import argparse
import os.path as osp
import re

import torch
from safetensors.torch import load_file, save_file


# =================#
# UNet Conversion #
# =================#

__a       :	Optional[int]             = [
    # (stable-diffusion, HF Diffusers)
    ("time_embed.0.weight", "time_embedding.linear_1.weight"),
    ("time_embed.0.bias", "time_embedding.linear_1.bias"),
    ("time_embed.2.weight", "time_embedding.linear_2.weight"),
    ("time_embed.2.bias", "time_embedding.linear_2.bias"),
    ("input_blocks.0.0.weight", "conv_in.weight"),
    ("input_blocks.0.0.bias", "conv_in.bias"),
    ("out.0.weight", "conv_norm_out.weight"),
    ("out.0.bias", "conv_norm_out.bias"),
    ("out.2.weight", "conv_out.weight"),
    ("out.2.bias", "conv_out.bias"),
]

__a       :	Dict             = [
    # (stable-diffusion, HF Diffusers)
    ("in_layers.0", "norm1"),
    ("in_layers.2", "conv1"),
    ("out_layers.0", "norm2"),
    ("out_layers.3", "conv2"),
    ("emb_layers.1", "time_emb_proj"),
    ("skip_connection", "conv_shortcut"),
]

__a       :	Tuple             = []
# hardcoded number of downblocks and resnets/attentions...
# would need smarter logic for other networks.
for i in range(4):
	# loop over downblocks/upblocks

	for j in range(2):
		# loop over resnets/attentions for downblocks
		__a       :	Tuple             = F'''down_blocks.{i}.resnets.{j}.'''
		__a       :	List[Any]             = F'''input_blocks.{3*i + j + 1}.0.'''
		unet_conversion_map_layer.append((sd_down_res_prefix, hf_down_res_prefix))

		if i < 3:
			# no attention layers in down_blocks.3
			__a       :	Any             = F'''down_blocks.{i}.attentions.{j}.'''
			__a       :	Union[str, Any]             = F'''input_blocks.{3*i + j + 1}.1.'''
			unet_conversion_map_layer.append((sd_down_atn_prefix, hf_down_atn_prefix))

	for j in range(3):
		# loop over resnets/attentions for upblocks
		__a       :	Optional[int]             = F'''up_blocks.{i}.resnets.{j}.'''
		__a       :	List[Any]             = F'''output_blocks.{3*i + j}.0.'''
		unet_conversion_map_layer.append((sd_up_res_prefix, hf_up_res_prefix))

		if i > 0:
			# no attention layers in up_blocks.0
			__a       :	Tuple             = F'''up_blocks.{i}.attentions.{j}.'''
			__a       :	int             = F'''output_blocks.{3*i + j}.1.'''
			unet_conversion_map_layer.append((sd_up_atn_prefix, hf_up_atn_prefix))

	if i < 3:
		# no downsample in down_blocks.3
		__a       :	str             = F'''down_blocks.{i}.downsamplers.0.conv.'''
		__a       :	List[Any]             = F'''input_blocks.{3*(i+1)}.0.op.'''
		unet_conversion_map_layer.append((sd_downsample_prefix, hf_downsample_prefix))

		# no upsample in up_blocks.3
		__a       :	Optional[Any]             = F'''up_blocks.{i}.upsamplers.0.'''
		__a       :	List[Any]             = F'''output_blocks.{3*i + 2}.{1 if i == 0 else 2}.'''
		unet_conversion_map_layer.append((sd_upsample_prefix, hf_upsample_prefix))

__a       :	List[Any]             = "mid_block.attentions.0."
__a       :	Any             = "middle_block.1."
unet_conversion_map_layer.append((sd_mid_atn_prefix, hf_mid_atn_prefix))

for j in range(2):
	__a       :	Tuple             = F'''mid_block.resnets.{j}.'''
	__a       :	int             = F'''middle_block.{2*j}.'''
	unet_conversion_map_layer.append((sd_mid_res_prefix, hf_mid_res_prefix))





def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					a__          =  {k: k for k in unet_state_dict.keys()}
					for sd_name, hf_name in unet_conversion_map:
										a__          =  sd_name
					for k, v in mapping.items():
										if "resnets" in k:
															for sd_part, hf_part in unet_conversion_map_resnet:
																				a__          =  v.replace(_lowerCamelCase ,     _lowerCamelCase)
															a__          =  v
					for k, v in mapping.items():
										for sd_part, hf_part in unet_conversion_map_layer:
															a__          =  v.replace(_lowerCamelCase ,     _lowerCamelCase)
										a__          =  v
					a__          =  {v: unet_state_dict[k] for k, v in mapping.items()}
					return new_state_dict


# ================#
# VAE Conversion #
# ================#

__a       :	str             = [
    # (stable-diffusion, HF Diffusers)
    ("nin_shortcut", "conv_shortcut"),
    ("norm_out", "conv_norm_out"),
    ("mid.attn_1.", "mid_block.attentions.0."),
]

for i in range(4):
	# down_blocks have two resnets
	for j in range(2):
		__a       :	Union[str, Any]             = F'''encoder.down_blocks.{i}.resnets.{j}.'''
		__a       :	Optional[Any]             = F'''encoder.down.{i}.block.{j}.'''
		vae_conversion_map.append((sd_down_prefix, hf_down_prefix))

	if i < 3:
		__a       :	List[Any]             = F'''down_blocks.{i}.downsamplers.0.'''
		__a       :	Tuple             = F'''down.{i}.downsample.'''
		vae_conversion_map.append((sd_downsample_prefix, hf_downsample_prefix))

		__a       :	Any             = F'''up_blocks.{i}.upsamplers.0.'''
		__a       :	Any             = F'''up.{3-i}.upsample.'''
		vae_conversion_map.append((sd_upsample_prefix, hf_upsample_prefix))

	# up_blocks have three resnets
	# also, up blocks in hf are numbered in reverse from sd
	for j in range(3):
		__a       :	Dict             = F'''decoder.up_blocks.{i}.resnets.{j}.'''
		__a       :	Union[str, Any]             = F'''decoder.up.{3-i}.block.{j}.'''
		vae_conversion_map.append((sd_up_prefix, hf_up_prefix))

# this part accounts for mid blocks in both the encoder and the decoder
for i in range(2):
	__a       :	Optional[Any]             = F'''mid_block.resnets.{i}.'''
	__a       :	Tuple             = F'''mid.block_{i+1}.'''
	vae_conversion_map.append((sd_mid_res_prefix, hf_mid_res_prefix))


__a       :	int             = [
    # (stable-diffusion, HF Diffusers)
    ("norm.", "group_norm."),
    ("q.", "query."),
    ("k.", "key."),
    ("v.", "value."),
    ("proj_out.", "proj_attn."),
]





def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					return w.reshape(*w.shape ,     1 ,     1)





def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					a__          =  {k: k for k in vae_state_dict.keys()}
					for k, v in mapping.items():
										for sd_part, hf_part in vae_conversion_map:
															a__          =  v.replace(_lowerCamelCase ,     _lowerCamelCase)
										a__          =  v
					for k, v in mapping.items():
										if "attentions" in k:
															for sd_part, hf_part in vae_conversion_map_attn:
																				a__          =  v.replace(_lowerCamelCase ,     _lowerCamelCase)
															a__          =  v
					a__          =  {v: vae_state_dict[k] for k, v in mapping.items()}
					a__          =  ["q", "k", "v", "proj_out"]
					for k, v in new_state_dict.items():
										for weight_name in weights_to_convert:
															if f'mid.attn_1.{weight_name}.weight' in k:
																				print(f'Reshaping {k} for SD format')
																				a__          =  reshape_weight_for_sd(_lowerCamelCase)
					return new_state_dict


# =========================#
# Text Encoder Conversion #
# =========================#


__a       :	List[Any]             = [
    # (stable-diffusion, HF Diffusers)
    ("resblocks.", "text_model.encoder.layers."),
    ("ln_1", "layer_norm1"),
    ("ln_2", "layer_norm2"),
    (".c_fc.", ".fc1."),
    (".c_proj.", ".fc2."),
    (".attn", ".self_attn"),
    ("ln_final.", "transformer.text_model.final_layer_norm."),
    ("token_embedding.weight", "transformer.text_model.embeddings.token_embedding.weight"),
    ("positional_embedding", "transformer.text_model.embeddings.position_embedding.weight"),
]
__a       :	Dict             = {re.escape(x[1]): x[0] for x in textenc_conversion_lst}
__a       :	Tuple             = re.compile('|'.join(protected.keys()))

# Ordering is from https://github.com/pytorch/pytorch/blob/master/test/cpp/api/modules.cpp
__a       :	Any             = {"q": 0, "k": 1, "v": 2}





def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					a__          =  {}
					a__          =  {}
					a__          =  {}
					for k, v in text_enc_dict.items():
										if (
										    k.endswith('''.self_attn.q_proj.weight''')
										    or k.endswith('''.self_attn.k_proj.weight''')
										    or k.endswith('''.self_attn.v_proj.weight''')
										):
															a__          =  k[: -len('''.q_proj.weight''')]
															a__          =  k[-len('''q_proj.weight''')]
															if k_pre not in capture_qkv_weight:
																				a__          =  [None, None, None]
															a__          =  v
															continue

										if (
										    k.endswith('''.self_attn.q_proj.bias''')
										    or k.endswith('''.self_attn.k_proj.bias''')
										    or k.endswith('''.self_attn.v_proj.bias''')
										):
															a__          =  k[: -len('''.q_proj.bias''')]
															a__          =  k[-len('''q_proj.bias''')]
															if k_pre not in capture_qkv_bias:
																				a__          =  [None, None, None]
															a__          =  v
															continue

										a__          =  textenc_pattern.sub(lambda lowerCamelCase_: protected[re.escape(m.group(0))] ,     _lowerCamelCase)
										a__          =  v

					for k_pre, tensors in capture_qkv_weight.items():
										if None in tensors:
															raise Exception('''CORRUPTED MODEL: one of the q-k-v values for the text encoder was missing''')
										a__          =  textenc_pattern.sub(lambda lowerCamelCase_: protected[re.escape(m.group(0))] ,     _lowerCamelCase)
										a__          =  torch.cat(_lowerCamelCase)

					for k_pre, tensors in capture_qkv_bias.items():
										if None in tensors:
															raise Exception('''CORRUPTED MODEL: one of the q-k-v values for the text encoder was missing''')
										a__          =  textenc_pattern.sub(lambda lowerCamelCase_: protected[re.escape(m.group(0))] ,     _lowerCamelCase)
										a__          =  torch.cat(_lowerCamelCase)

					return new_state_dict





def        SCREAMING_SNAKE_CASE       (      lowerCamelCase_):
					return text_enc_dict


if __name__ == "__main__":
	__a       :	List[Any]             = argparse.ArgumentParser()

	parser.add_argument('--model_path', default=None, type=str, required=True, help='Path to the model to convert.')
	parser.add_argument('--checkpoint_path', default=None, type=str, required=True, help='Path to the output model.')
	parser.add_argument('--half', action='store_true', help='Save weights in half precision.')
	parser.add_argument(
	    '--use_safetensors', action='store_true', help='Save weights use safetensors, default is ckpt.'
	)

	__a       :	str             = parser.parse_args()

	assert args.model_path is not None, "Must provide a model path!"

	assert args.checkpoint_path is not None, "Must provide a checkpoint path!"

	# Path for safetensors
	__a       :	List[Any]             = osp.join(args.model_path, 'unet', 'diffusion_pytorch_model.safetensors')
	__a       :	int             = osp.join(args.model_path, 'vae', 'diffusion_pytorch_model.safetensors')
	__a       :	Dict             = osp.join(args.model_path, 'text_encoder', 'model.safetensors')

	# Load models from safetensors if it exists, if it doesn't pytorch
	if osp.exists(unet_path):
		__a       :	List[str]             = load_file(unet_path, device='cpu')
	else:
		__a       :	int             = osp.join(args.model_path, 'unet', 'diffusion_pytorch_model.bin')
		__a       :	Tuple             = torch.load(unet_path, map_location='cpu')

	if osp.exists(vae_path):
		__a       :	Union[str, Any]             = load_file(vae_path, device='cpu')
	else:
		__a       :	Union[str, Any]             = osp.join(args.model_path, 'vae', 'diffusion_pytorch_model.bin')
		__a       :	Union[str, Any]             = torch.load(vae_path, map_location='cpu')

	if osp.exists(text_enc_path):
		__a       :	Union[str, Any]             = load_file(text_enc_path, device='cpu')
	else:
		__a       :	Dict             = osp.join(args.model_path, 'text_encoder', 'pytorch_model.bin')
		__a       :	Tuple             = torch.load(text_enc_path, map_location='cpu')

	# Convert the UNet model
	__a       :	int             = convert_unet_state_dict(unet_state_dict)
	__a       :	List[str]             = {"model.diffusion_model." + k: v for k, v in unet_state_dict.items()}

	# Convert the VAE model
	__a       :	List[str]             = convert_vae_state_dict(vae_state_dict)
	__a       :	List[str]             = {"first_stage_model." + k: v for k, v in vae_state_dict.items()}

	# Easiest way to identify v2.0 model seems to be that the text encoder (OpenCLIP) is deeper
	__a       :	List[str]             = "text_model.encoder.layers.22.layer_norm2.bias" in text_enc_dict

	if is_vaa_model:
		# Need to add the tag 'transformer' in advance so we can knock it out from the final layer-norm
		__a       :	int             = {"transformer." + k: v for k, v in text_enc_dict.items()}
		__a       :	Optional[Any]             = convert_text_enc_state_dict_vaa(text_enc_dict)
		__a       :	List[Any]             = {"cond_stage_model.model." + k: v for k, v in text_enc_dict.items()}
	else:
		__a       :	Dict             = convert_text_enc_state_dict(text_enc_dict)
		__a       :	Tuple             = {"cond_stage_model.transformer." + k: v for k, v in text_enc_dict.items()}

	# Put together new checkpoint
	__a       :	Optional[int]             = {**unet_state_dict, **vae_state_dict, **text_enc_dict}
	if args.half:
		__a       :	Tuple             = {k: v.half() for k, v in state_dict.items()}

	if args.use_safetensors:
		save_file(state_dict, args.checkpoint_path)
	else:
		__a       :	Dict             = {"state_dict": state_dict}
		torch.save(state_dict, args.checkpoint_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       :	Dict             = {
    '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': 128,
    '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.01),
    'suppress_tokens': [0, 1],
    'begin_suppress_tokens': 2,
    'task_specific_params': {'translation': 'some_params'},
    'problem_type': 'regression',
}







@is_staging_test
class        _SCREAMING_SNAKE_CASE						(  unittest.TestCase							):





							"""simple docstring"""





							@classmethod
							def  lowercase		(   cls:     Union[str, Any]    ):

												'''simple docstring'''

												a__          =  TOKEN
												HfFolder.save_token(__A    )




							@classmethod
							def  lowercase		(   cls:     Any    ):

												'''simple docstring'''

												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  lowercase		(   self:     Union[str, Any]    ):

												'''simple docstring'''

												a__          =  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    )

												a__          =  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    )

												a__          =  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  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  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    )

												a__          =  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    )

												a__          =  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  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												CustomConfig.register_for_auto_class()
												a__          =  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'''}    )

												a__          =  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        _SCREAMING_SNAKE_CASE						(  unittest.TestCase							):





							"""simple docstring"""





							def  lowercase		(   self:     int    ):

												'''simple docstring'''

												a__          =  GPTaConfig()

												# attempt to modify each of int/float/bool/str config records and verify they were updated
												a__          =  c.n_embd + 1  # int
												a__          =  c.resid_pdrop + 1.0  # float
												a__          =  not c.scale_attn_weights  # bool
												a__          =  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  lowercase		(   self:     List[str]    ):

												'''simple docstring'''

												a__          =  PretrainedConfig()
												a__          =  [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''']    )
												a__          =  [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  lowercase		(   self:     str    ):

												'''simple docstring'''

												with self.assertRaises(__A    ):
																	# config is in subfolder, the following should not work without specifying the subfolder
																	a__          =  BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''    )

												a__          =  BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''				,		subfolder='''bert'''    )

												self.assertIsNotNone(__A    )




							def  lowercase		(   self:     Dict    ):

												'''simple docstring'''

												a__          =  mock.Mock()
												a__          =  500
												a__          =  {}
												a__          =  HTTPError
												a__          =  {}

												# Download this model to make sure it's in the cache.
												a__          =  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:
																	a__          =  BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''    )
																	# This check we did call the fake head request
																	mock_head.assert_called()




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

												'''simple docstring'''

												a__          =  BertConfig.from_pretrained(
												    '''https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'''    )




							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  AutoConfig.from_pretrained('''bert-base-cased'''    )
												a__          =  ['''config.4.0.0.json''']

												with tempfile.TemporaryDirectory() as tmp_dir:
																	configuration.save_pretrained(__A    )
																	a__          =  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
																	a__          =  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
																	a__          =  ['''config.42.0.0.json''']
																	a__          =  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'''    )    )
																	a__          =  AutoConfig.from_pretrained(__A    )
																	self.assertEqual(new_configuration.hidden_size				,		768    )





							def  lowercase		(   self:     Optional[Any]    ):

												'''simple docstring'''

												a__          =  '''hf-internal-testing/test-two-configs'''

												import transformers as new_transformers

												a__          =  '''v4.0.0'''
												a__       ,a__          =  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

												a__          =  '''v3.0.0'''
												a__          =  old_transformers.models.auto.AutoConfig.from_pretrained(__A    )
												self.assertEqual(old_configuration.hidden_size				,		768    )


