
"""simple docstring"""





import unittest

import numpy as np
import timeout_decorator  # noqa

from transformers import BlenderbotConfig, is_flax_available
from transformers.testing_utils import jax_device, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor


if is_flax_available():
							import os

							# The slow tests are often failing with OOM error on GPU
							# This makes JAX allocate exactly what is needed on demand, and deallocate memory that is no longer needed
							# but will be slower as stated here https://jax.readthedocs.io/en/latest/gpu_memory_allocation.html
							_a														=		"platform"

							import jax
							import jax.numpy as jnp

							from transformers import BlenderbotTokenizer
							from transformers.models.blenderbot.modeling_flax_blenderbot import (
							    FlaxBlenderbotForConditionalGeneration,
							    FlaxBlenderbotModel,
							    shift_tokens_right,
							)



def 				lowerCamelCase__		(      __snake_case,					__snake_case,					__snake_case=None,					__snake_case=None,					__snake_case=None,					__snake_case=None,					__snake_case=None,					__snake_case=None,					)							->		Optional[Any]:


					"""simple docstring"""





					if attention_mask is None:
										_UpperCamelCase										=  np.where(input_ids != config.pad_token_id,					1,					0     )
					if decoder_attention_mask is None:
										_UpperCamelCase										=  np.where(decoder_input_ids != config.pad_token_id,					1,					0     )
					if head_mask is None:
										_UpperCamelCase										=  np.ones((config.encoder_layers, config.encoder_attention_heads)     )
					if decoder_head_mask is None:
										_UpperCamelCase										=  np.ones((config.decoder_layers, config.decoder_attention_heads)     )
					if cross_attn_head_mask is None:
										_UpperCamelCase										=  np.ones((config.decoder_layers, config.decoder_attention_heads)     )
					return {
					    "input_ids": input_ids,
					    "decoder_input_ids": decoder_input_ids,
					    "attention_mask": attention_mask,
					    "decoder_attention_mask": attention_mask,
					}






class    _UpperCAmelCase:



		def __init__( self    ,		__a    ,		__a=13    ,		__a=7    ,		__a=True    ,		__a=False    ,		__a=99    ,		__a=16    ,		__a=2    ,		__a=4    ,		__a=4    ,		__a="gelu"    ,		__a=0.1    ,		__a=0.1    ,		__a=32    ,		__a=2    ,		__a=1    ,		__a=0    ,		__a=0.02    ,		)	->	List[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  parent
							_UpperCamelCase										=  batch_size
							_UpperCamelCase										=  seq_length
							_UpperCamelCase										=  is_training
							_UpperCamelCase										=  use_labels
							_UpperCamelCase										=  vocab_size
							_UpperCamelCase										=  hidden_size
							_UpperCamelCase										=  num_hidden_layers
							_UpperCamelCase										=  num_attention_heads
							_UpperCamelCase										=  intermediate_size
							_UpperCamelCase										=  hidden_act
							_UpperCamelCase										=  hidden_dropout_prob
							_UpperCamelCase										=  attention_probs_dropout_prob
							_UpperCamelCase										=  max_position_embeddings
							_UpperCamelCase										=  eos_token_id
							_UpperCamelCase										=  pad_token_id
							_UpperCamelCase										=  bos_token_id
							_UpperCamelCase										=  initializer_range



		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  np.clip(ids_tensor([self.batch_size, self.seq_length - 1]    ,		self.vocab_size)    ,		3    ,		self.vocab_size)
							_UpperCamelCase										=  np.concatenate((input_ids, 2 * np.ones((self.batch_size, 1)    ,		dtype=np.intaa))    ,		-1)

							_UpperCamelCase										=  shift_tokens_right(lowercase_    ,		1    ,		2)

							_UpperCamelCase										=  BlenderbotConfig(
							    vocab_size=self.vocab_size    ,		d_model=self.hidden_size    ,		encoder_layers=self.num_hidden_layers    ,		decoder_layers=self.num_hidden_layers    ,		encoder_attention_heads=self.num_attention_heads    ,		decoder_attention_heads=self.num_attention_heads    ,		encoder_ffn_dim=self.intermediate_size    ,		decoder_ffn_dim=self.intermediate_size    ,		dropout=self.hidden_dropout_prob    ,		attention_dropout=self.attention_probs_dropout_prob    ,		max_position_embeddings=self.max_position_embeddings    ,		eos_token_id=self.eos_token_id    ,		bos_token_id=self.bos_token_id    ,		pad_token_id=self.pad_token_id    ,		initializer_range=self.initializer_range    ,		use_cache=lowercase_    ,		)
							_UpperCamelCase										=  prepare_blenderbot_inputs_dict(lowercase_    ,		lowercase_    ,		lowercase_)
							return config, inputs_dict



		def 						UpperCAmelCase							( self)	->	Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase										=  self.prepare_config_and_inputs()
							return config, inputs_dict



		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a)	->	Optional[int]:






							'''simple docstring'''
							_UpperCamelCase										=  20
							_UpperCamelCase										=  model_class_name(lowercase_)

							_UpperCamelCase										=  model.encode(inputs_dict['''input_ids'''])

							_UpperCamelCase										=  (
							    inputs_dict["""decoder_input_ids"""],
							    inputs_dict["""decoder_attention_mask"""],
							)

							_UpperCamelCase										=  model.init_cache(decoder_input_ids.shape[0]    ,		lowercase_    ,		lowercase_)
							_UpperCamelCase										=  jnp.ones((decoder_input_ids.shape[0], max_decoder_length)    ,		dtype='''i4''')

							_UpperCamelCase										=  jnp.broadcast_to(
							    jnp.arange(decoder_input_ids.shape[-1] - 1)[None, :]    ,		(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)    ,		)
							_UpperCamelCase										=  model.decode(
							    decoder_input_ids[:, :-1]    ,		lowercase_    ,		decoder_attention_mask=lowercase_    ,		past_key_values=lowercase_    ,		decoder_position_ids=lowercase_    ,		)

							_UpperCamelCase										=  jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]    ,		dtype='''i4''')
							_UpperCamelCase										=  model.decode(
							    decoder_input_ids[:, -1:]    ,		lowercase_    ,		decoder_attention_mask=lowercase_    ,		past_key_values=outputs_cache.past_key_values    ,		decoder_position_ids=lowercase_    ,		)

							_UpperCamelCase										=  model.decode(lowercase_    ,		lowercase_)

							_UpperCamelCase										=  np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])))
							self.parent.assertTrue(diff < 1e-3    ,		msg=F'''Max diff is {diff}''')




		def 						UpperCAmelCase							( self    ,		__a    ,		__a    ,		__a)	->	Dict:






							'''simple docstring'''
							_UpperCamelCase										=  20
							_UpperCamelCase										=  model_class_name(lowercase_)

							_UpperCamelCase										=  model.encode(inputs_dict['''input_ids'''])

							_UpperCamelCase										=  (
							    inputs_dict["""decoder_input_ids"""],
							    inputs_dict["""decoder_attention_mask"""],
							)

							_UpperCamelCase										=  jnp.concatenate(
							    [
							        decoder_attention_mask,
							        jnp.zeros((decoder_attention_mask.shape[0], max_decoder_length - decoder_attention_mask.shape[1])),
							    ]    ,		axis=-1    ,		)

							_UpperCamelCase										=  model.init_cache(decoder_input_ids.shape[0]    ,		lowercase_    ,		lowercase_)
							_UpperCamelCase										=  jnp.broadcast_to(
							    jnp.arange(decoder_input_ids.shape[-1] - 1)[None, :]    ,		(decoder_input_ids.shape[0], decoder_input_ids.shape[-1] - 1)    ,		)

							_UpperCamelCase										=  model.decode(
							    decoder_input_ids[:, :-1]    ,		lowercase_    ,		decoder_attention_mask=lowercase_    ,		past_key_values=lowercase_    ,		decoder_position_ids=lowercase_    ,		)
							_UpperCamelCase										=  jnp.array(decoder_input_ids.shape[0] * [[decoder_input_ids.shape[-1] - 1]]    ,		dtype='''i4''')
							_UpperCamelCase										=  model.decode(
							    decoder_input_ids[:, -1:]    ,		lowercase_    ,		past_key_values=outputs_cache.past_key_values    ,		decoder_attention_mask=lowercase_    ,		decoder_position_ids=lowercase_    ,		)

							_UpperCamelCase										=  model.decode(lowercase_    ,		lowercase_    ,		decoder_attention_mask=lowercase_)

							_UpperCamelCase										=  np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])))
							self.parent.assertTrue(diff < 1e-3    ,		msg=F'''Max diff is {diff}''')






@require_flax
class    _UpperCAmelCase(   unittest.TestCase     ):
		lowercase__      =				99



		def 						UpperCAmelCase							( self)	->	Optional[int]:






							'''simple docstring'''
							_UpperCamelCase										=  np.array(
							    [
							        [71, 82, 18, 33, 46, 91, 2],
							        [68, 34, 26, 58, 30, 82, 2],
							        [5, 97, 17, 39, 94, 40, 2],
							        [76, 83, 94, 25, 70, 78, 2],
							        [87, 59, 41, 35, 48, 66, 2],
							        [55, 13, 16, 58, 5, 2, 1],  # note padding
							        [64, 27, 31, 51, 12, 75, 2],
							        [52, 64, 86, 17, 83, 39, 2],
							        [48, 61, 9, 24, 71, 82, 2],
							        [26, 1, 60, 48, 22, 13, 2],
							        [21, 5, 62, 28, 14, 76, 2],
							        [45, 98, 37, 86, 59, 48, 2],
							        [70, 70, 50, 9, 28, 0, 2],
							    ]    ,		dtype=np.intaa    ,		)

							_UpperCamelCase										=  input_ids.shape[0]
							_UpperCamelCase										=  BlenderbotConfig(
							    vocab_size=self.vocab_size    ,		d_model=24    ,		encoder_layers=2    ,		decoder_layers=2    ,		encoder_attention_heads=2    ,		decoder_attention_heads=2    ,		encoder_ffn_dim=32    ,		decoder_ffn_dim=32    ,		max_position_embeddings=48    ,		eos_token_id=2    ,		pad_token_id=1    ,		bos_token_id=0    ,		)
							return config, input_ids, batch_size



		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  self._get_config_and_data()
							_UpperCamelCase										=  FlaxBlenderbotForConditionalGeneration(lowercase_)
							_UpperCamelCase										=  lm_model(input_ids=lowercase_)
							_UpperCamelCase										=  (batch_size, input_ids.shape[1], config.vocab_size)
							self.assertEqual(outputs['''logits'''].shape    ,		lowercase_)



		def 						UpperCAmelCase							( self)	->	List[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  BlenderbotConfig(
							    vocab_size=self.vocab_size    ,		d_model=14    ,		encoder_layers=2    ,		decoder_layers=2    ,		encoder_attention_heads=2    ,		decoder_attention_heads=2    ,		encoder_ffn_dim=8    ,		decoder_ffn_dim=8    ,		max_position_embeddings=48    ,		)
							_UpperCamelCase										=  FlaxBlenderbotForConditionalGeneration(lowercase_)
							_UpperCamelCase										=  np.array([[71, 82, 18, 33, 46, 91, 2], [68, 34, 26, 58, 30, 2, 1]]    ,		dtype=np.intaa)
							_UpperCamelCase										=  np.array([[82, 71, 82, 18, 2], [58, 68, 2, 1, 1]]    ,		dtype=np.intaa)
							_UpperCamelCase										=  lm_model(input_ids=lowercase_    ,		decoder_input_ids=lowercase_)
							_UpperCamelCase										=  (*summary.shape, config.vocab_size)
							self.assertEqual(outputs['''logits'''].shape    ,		lowercase_)




		def 						UpperCAmelCase							( self)	->	str:






							'''simple docstring'''
							_UpperCamelCase										=  np.array([[71, 82, 18, 33, 2, 1, 1], [68, 34, 26, 58, 30, 82, 2]]    ,		dtype=np.intaa)
							_UpperCamelCase										=  shift_tokens_right(lowercase_    ,		1    ,		2)
							_UpperCamelCase										=  np.equal(lowercase_    ,		1).astype(np.floataa).sum()
							_UpperCamelCase										=  np.equal(lowercase_    ,		1).astype(np.floataa).sum()
							self.assertEqual(shifted.shape    ,		input_ids.shape)
							self.assertEqual(lowercase_    ,		n_pad_before - 1)
							self.assertTrue(np.equal(shifted[:, 0]    ,		2).all())






@require_flax
class    _UpperCAmelCase(   _UpperCAmelCase				,					unittest.TestCase				,					_UpperCAmelCase     ):
		lowercase__      =				True
		lowercase__      =				(
		    (
		        FlaxBlenderbotModel,
		        FlaxBlenderbotForConditionalGeneration,
		    )
		    if is_flax_available()
		    else ()
		)
		lowercase__      =				(FlaxBlenderbotForConditionalGeneration,) if is_flax_available() else ()



		def 						UpperCAmelCase							( self)	->	List[str]:






							'''simple docstring'''
							_UpperCamelCase										=  FlaxBlenderbotModelTester(self)



		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							for model_class in self.all_model_classes:
												self.model_tester.check_use_cache_forward(lowercase_    ,		lowercase_    ,		lowercase_)



		def 						UpperCAmelCase							( self)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							for model_class in self.all_model_classes:
												self.model_tester.check_use_cache_forward_with_attn_mask(lowercase_    ,		lowercase_    ,		lowercase_)



		def 						UpperCAmelCase							( self)	->	str:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												with self.subTest(model_class.__name__):
																	_UpperCamelCase										=  self._prepare_for_class(lowercase_    ,		lowercase_)
																	_UpperCamelCase										=  model_class(lowercase_)

																	@jax.jit
																	def encode_jitted(__a    ,		__a=None    ,		**__a):
																						return model.encode(input_ids=lowercase_    ,		attention_mask=lowercase_)

																	with self.subTest('''JIT Enabled'''):
																						_UpperCamelCase										=  encode_jitted(**lowercase_).to_tuple()

																	with self.subTest('''JIT Disabled'''):
																						with jax.disable_jit():
																											_UpperCamelCase										=  encode_jitted(**lowercase_).to_tuple()

																	self.assertEqual(len(lowercase_)    ,		len(lowercase_))
																	for jitted_output, output in zip(lowercase_    ,		lowercase_):
																						self.assertEqual(jitted_output.shape    ,		output.shape)



		def 						UpperCAmelCase							( self)	->	Any:






							'''simple docstring'''
							_UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												with self.subTest(model_class.__name__):
																	_UpperCamelCase										=  model_class(lowercase_)
																	_UpperCamelCase										=  model.encode(inputs_dict['''input_ids''']    ,		inputs_dict['''attention_mask'''])

																	_UpperCamelCase										=  {
																	    """decoder_input_ids""": inputs_dict["""decoder_input_ids"""],
																	    """decoder_attention_mask""": inputs_dict["""decoder_attention_mask"""],
																	    """encoder_outputs""": encoder_outputs,
																	}

																	@jax.jit
																	def decode_jitted(__a    ,		__a    ,		__a):
																						return model.decode(
																						    decoder_input_ids=lowercase_    ,		decoder_attention_mask=lowercase_    ,		encoder_outputs=lowercase_    ,		)

																	with self.subTest('''JIT Enabled'''):
																						_UpperCamelCase										=  decode_jitted(**lowercase_).to_tuple()

																	with self.subTest('''JIT Disabled'''):
																						with jax.disable_jit():
																											_UpperCamelCase										=  decode_jitted(**lowercase_).to_tuple()

																	self.assertEqual(len(lowercase_)    ,		len(lowercase_))
																	for jitted_output, output in zip(lowercase_    ,		lowercase_):
																						self.assertEqual(jitted_output.shape    ,		output.shape)



		@slow
		def 						UpperCAmelCase							( self)	->	str:






							'''simple docstring'''
							for model_class_name in self.all_model_classes:
												_UpperCamelCase										=  model_class_name.from_pretrained('''facebook/blenderbot-400M-distill''')
												# FlaxBlenderbotForSequenceClassification expects eos token in input_ids
												_UpperCamelCase										=  np.ones((1, 1)) * model.config.eos_token_id
												_UpperCamelCase										=  model(lowercase_)
												self.assertIsNotNone(lowercase_)




		@unittest.skipUnless(jax_device != '''cpu'''    ,		'''3B test too slow on CPU.''')
		@slow
		def 						UpperCAmelCase							( self)	->	List[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  {"""num_beams""": 1, """early_stopping""": True, """min_length""": 15, """max_length""": 25}
							_UpperCamelCase										=  {"""skip_special_tokens""": True, """clean_up_tokenization_spaces""": True}

							_UpperCamelCase										=  FlaxBlenderbotForConditionalGeneration.from_pretrained('''facebook/blenderbot-3B'''    ,		from_pt=lowercase_)
							_UpperCamelCase										=  BlenderbotTokenizer.from_pretrained('''facebook/blenderbot-3B''')

							_UpperCamelCase										=  ["""Sam"""]
							_UpperCamelCase										=  tokenizer(lowercase_    ,		return_tensors='''jax''')

							_UpperCamelCase										=  model.generate(**lowercase_    ,		**lowercase_)
							_UpperCamelCase										=  """Sam is a great name. It means \"sun\" in Gaelic."""

							_UpperCamelCase										=  tokenizer.batch_decode(lowercase_    ,		**lowercase_)
							assert generated_txt[0].strip() == tgt_text








"""simple docstring"""





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

import transformers
import transformers.models.auto
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.bert.configuration_bert import BertConfig
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import DUMMY_UNKNOWN_IDENTIFIER, get_tests_dir


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

from test_module.custom_configuration import CustomConfig  # noqa E402


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






class    _UpperCAmelCase(   unittest.TestCase     ):



		def 						UpperCAmelCase							( self)	->	str:






							'''simple docstring'''
							_UpperCamelCase										=  0



		def 						UpperCAmelCase							( self)	->	List[str]:






							'''simple docstring'''
							self.assertIsNotNone(transformers.models.auto.__spec__)
							self.assertIsNotNone(importlib.util.find_spec('''transformers.models.auto'''))



		def 						UpperCAmelCase							( self)	->	str:






							'''simple docstring'''
							_UpperCamelCase										=  AutoConfig.from_pretrained('''bert-base-uncased''')
							self.assertIsInstance(__a    ,		__a)



		def 						UpperCAmelCase							( self)	->	Tuple:






							'''simple docstring'''
							_UpperCamelCase										=  AutoConfig.from_pretrained(__a)
							self.assertIsInstance(__a    ,		__a)



		def 						UpperCAmelCase							( self)	->	Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase										=  AutoConfig.from_pretrained(__a)
							self.assertIsInstance(__a    ,		__a)



		def 						UpperCAmelCase							( self)	->	Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase										=  AutoConfig.for_model('''roberta''')
							self.assertIsInstance(__a    ,		__a)



		def 						UpperCAmelCase							( self)	->	Dict:






							'''simple docstring'''
							with tempfile.TemporaryDirectory() as tmp_dir:
												# This model name contains bert and roberta, but roberta ends up being picked.
												_UpperCamelCase										=  os.path.join(__a    ,		'''fake-roberta''')
												os.makedirs(__a    ,		exist_ok=__a)
												with open(os.path.join(__a    ,		'''config.json''')    ,		'''w''') as f:
																	f.write(json.dumps({}))
												_UpperCamelCase										=  AutoConfig.from_pretrained(__a)
												self.assertEqual(type(__a)    ,		__a)



		def 						UpperCAmelCase							( self)	->	Tuple:






							'''simple docstring'''
							try:
												AutoConfig.register('''custom'''    ,		__a)
												# Wrong model type will raise an error
												with self.assertRaises(__a):
																	AutoConfig.register('''model'''    ,		__a)
												# Trying to register something existing in the Transformers library will raise an error
												with self.assertRaises(__a):
																	AutoConfig.register('''bert'''    ,		__a)

												# Now that the config is registered, it can be used as any other config with the auto-API
												_UpperCamelCase										=  CustomConfig()
												with tempfile.TemporaryDirectory() as tmp_dir:
																	config.save_pretrained(__a)
																	_UpperCamelCase										=  AutoConfig.from_pretrained(__a)
																	self.assertIsInstance(__a    ,		__a)

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



		def 						UpperCAmelCase							( self)	->	List[Any]:






							'''simple docstring'''
							with self.assertRaisesRegex(
							    __a    ,		'''bert-base is not a local folder and is not a valid model identifier'''):
												_UpperCamelCase										=  AutoConfig.from_pretrained('''bert-base''')



		def 						UpperCAmelCase							( self)	->	List[Any]:






							'''simple docstring'''
							with self.assertRaisesRegex(
							    __a    ,		R'''aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'''):
												_UpperCamelCase										=  AutoConfig.from_pretrained(__a    ,		revision='''aaaaaa''')



		def 						UpperCAmelCase							( self)	->	Optional[Any]:






							'''simple docstring'''
							with self.assertRaisesRegex(
							    __a    ,		'''hf-internal-testing/no-config-test-repo does not appear to have a file named config.json.'''    ,		):
												_UpperCamelCase										=  AutoConfig.from_pretrained('''hf-internal-testing/no-config-test-repo''')



		def 						UpperCAmelCase							( self)	->	int:






							'''simple docstring'''
							# If remote code is not set, we will time out when asking whether to load the model.
							with self.assertRaises(__a):
												_UpperCamelCase										=  AutoConfig.from_pretrained('''hf-internal-testing/test_dynamic_model''')
							# If remote code is disabled, we can't load this config.
							with self.assertRaises(__a):
												_UpperCamelCase										=  AutoConfig.from_pretrained('''hf-internal-testing/test_dynamic_model'''    ,		trust_remote_code=__a)

							_UpperCamelCase										=  AutoConfig.from_pretrained('''hf-internal-testing/test_dynamic_model'''    ,		trust_remote_code=__a)
							self.assertEqual(config.__class__.__name__    ,		'''NewModelConfig''')

							# Test config can be reloaded.
							with tempfile.TemporaryDirectory() as tmp_dir:
												config.save_pretrained(__a)
												_UpperCamelCase										=  AutoConfig.from_pretrained(__a    ,		trust_remote_code=__a)
							self.assertEqual(reloaded_config.__class__.__name__    ,		'''NewModelConfig''')




		def 						UpperCAmelCase							( self)	->	Any:






							'''simple docstring'''






							class    _UpperCAmelCase(   lowerCamelCase     ):
									lowercase__      =				'new-model'

							try:
												AutoConfig.register('''new-model'''    ,		__a)
												# If remote code is not set, the default is to use local
												_UpperCamelCase										=  AutoConfig.from_pretrained('''hf-internal-testing/test_dynamic_model''')
												self.assertEqual(config.__class__.__name__    ,		'''NewModelConfigLocal''')

												# If remote code is disabled, we load the local one.
												_UpperCamelCase										=  AutoConfig.from_pretrained('''hf-internal-testing/test_dynamic_model'''    ,		trust_remote_code=__a)
												self.assertEqual(config.__class__.__name__    ,		'''NewModelConfigLocal''')

												# If remote is enabled, we load from the Hub
												_UpperCamelCase										=  AutoConfig.from_pretrained('''hf-internal-testing/test_dynamic_model'''    ,		trust_remote_code=__a)
												self.assertEqual(config.__class__.__name__    ,		'''NewModelConfig''')

							finally:
												if "new-model" in CONFIG_MAPPING._extra_content:
																	del CONFIG_MAPPING._extra_content["new-model"]






