






import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


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

from test_module.custom_configuration import CustomConfig  # noqa E402


lowerCAmelCase_           = {
    'return_dict': False,
    'output_hidden_states': True,
    'output_attentions': True,
    'torchscript': True,
    'torch_dtype': 'float16',
    'use_bfloat16': True,
    'tf_legacy_loss': True,
    'pruned_heads': {'a': 1},
    'tie_word_embeddings': False,
    'is_decoder': True,
    'cross_attention_hidden_size': 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      UpperCamelCase (				unittest.TestCase ):







		"""simple docstring"""



		@classmethod
		def       A(  cls		:       List[Any]		)    ->   Tuple:


						'''simple docstring'''
						A	 =      TOKEN
						HfFolder.save_token(_SCREAMING_SNAKE_CASE		)
		@classmethod
		def       A(  cls		:       List[str]		)    ->   Dict:


						'''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       A(  self		:       Dict		)    ->   Optional[Any]:


						'''simple docstring'''
						A	 =      BertConfig(
						    vocab_size=9_9						,hidden_size=3_2						,num_hidden_layers=5						,num_attention_heads=4						,intermediate_size=3_7		)
						config.push_to_hub('test-config'						,use_auth_token=self._token		)

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

        # 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(_SCREAMING_SNAKE_CASE						,repo_id='test-config'						,push_to_hub=_SCREAMING_SNAKE_CASE						,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(_SCREAMING_SNAKE_CASE						,getattr(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)		)
		def       A(  self		:       Union[str, Any]		)    ->   List[str]:


						'''simple docstring'''
						A	 =      BertConfig(
						    vocab_size=9_9						,hidden_size=3_2						,num_hidden_layers=5						,num_attention_heads=4						,intermediate_size=3_7		)
						config.push_to_hub('valid_org/test-config-org'						,use_auth_token=self._token		)

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

        # 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(
										    _SCREAMING_SNAKE_CASE						,repo_id='valid_org/test-config-org'						,push_to_hub=_SCREAMING_SNAKE_CASE						,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(_SCREAMING_SNAKE_CASE						,getattr(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)		)







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


						'''simple docstring'''
						CustomConfig.register_for_auto_class()
						A	 =      CustomConfig(attribute=4_2		)

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

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

						A	 =      AutoConfig.from_pretrained(f'{USER}/test-dynamic-config'						,trust_remote_code=_SCREAMING_SNAKE_CASE		)
						# Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
						self.assertEqual(new_config.__class__.__name__						,'CustomConfig'		)
						self.assertEqual(new_config.attribute						,4_2		)


class      UpperCamelCase (				unittest.TestCase ):







		"""simple docstring"""



		def       A(  self		:       str		)    ->   Tuple:


						'''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(_SCREAMING_SNAKE_CASE						,c.n_embd						,'mismatch for key: n_embd'		)
						self.assertEqual(_SCREAMING_SNAKE_CASE						,c.resid_pdrop						,'mismatch for key: resid_pdrop'		)
						self.assertEqual(_SCREAMING_SNAKE_CASE						,c.scale_attn_weights						,'mismatch for key: scale_attn_weights'		)
						self.assertEqual(_SCREAMING_SNAKE_CASE						,c.summary_type						,'mismatch for key: summary_type'		)
		def       A(  self		:       List[Any]		)    ->   int:


						'''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(
						    _SCREAMING_SNAKE_CASE						,['is_encoder_decoder', '_name_or_path', '_commit_hash', 'transformers_version']		)
						A	 =      [key for key, value in config_common_kwargs.items() if value == getattr(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)]
						if len(_SCREAMING_SNAKE_CASE		) > 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(_SCREAMING_SNAKE_CASE		)}.'		)
		def       A(  self		:       Any		)    ->   Dict:


						'''simple docstring'''
						with self.assertRaises(_SCREAMING_SNAKE_CASE		):
										# 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(_SCREAMING_SNAKE_CASE		)
		def       A(  self		:       int		)    ->   Optional[Any]:


						'''simple docstring'''
						# A mock response for an HTTP head request to emulate server down
						A	 =      mock.Mock()
						A	 =      5_0_0
						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=_SCREAMING_SNAKE_CASE		) 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       A(  self		:       int		)    ->   Union[str, Any]:


						'''simple docstring'''
						# This test is for deprecated behavior and can be removed in v5
						A	 =      BertConfig.from_pretrained(
						    'https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'		)
		def       A(  self		:       List[Any]		)    ->   List[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(_SCREAMING_SNAKE_CASE		)
										A	 =      2
										json.dump(configuration.to_dict()						,open(os.path.join(_SCREAMING_SNAKE_CASE						,'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(_SCREAMING_SNAKE_CASE		)
										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	 =      7_6_8
										configuration.save_pretrained(_SCREAMING_SNAKE_CASE		)
										shutil.move(os.path.join(_SCREAMING_SNAKE_CASE						,'config.4.0.0.json'		)						,os.path.join(_SCREAMING_SNAKE_CASE						,'config.42.0.0.json'		)		)
										A	 =      AutoConfig.from_pretrained(_SCREAMING_SNAKE_CASE		)
										self.assertEqual(new_configuration.hidden_size						,7_6_8		)







		def       A(  self		:       int		)    ->   List[Any]:


						'''simple docstring'''
						# This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
						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(
						    _SCREAMING_SNAKE_CASE						,return_unused_kwargs=_SCREAMING_SNAKE_CASE		)
						self.assertEqual(new_configuration.hidden_size						,2		)
						# This checks `_configuration_file` ia not kept in the kwargs by mistake.
						self.assertDictEqual(_SCREAMING_SNAKE_CASE						,{}		)

						# 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(_SCREAMING_SNAKE_CASE		)
						self.assertEqual(old_configuration.hidden_size						,7_6_8		)













import copy
import re
class      UpperCamelCase :







		"""simple docstring"""



		snake_case    =   "hp"
		snake_case    =   {}
		snake_case    =   None
		@classmethod
		def       A(  cls		:       Union[str, Any]						,_SCREAMING_SNAKE_CASE		:       int						,_SCREAMING_SNAKE_CASE		:       List[Any]		)    ->   int:


						'''simple docstring'''
						A	 =      prefix
						A	 =      defaults
						cls.build_naming_info()
		@staticmethod
		def       A(  _SCREAMING_SNAKE_CASE		:       List[str]						,_SCREAMING_SNAKE_CASE		:       List[Any]		)    ->   Optional[Any]:


						'''simple docstring'''
						if len(_SCREAMING_SNAKE_CASE		) == 0:
										return ""
						A	 =      None
						if any(char.isdigit() for char in word		):
										raise Exception(f'Parameters should not contain numbers: \'{word}\' contains a number'		)
						if word in info["short_word"]:
										return info["short_word"][word]
						for prefix_len in range(1						,len(_SCREAMING_SNAKE_CASE		) + 1		):
										A	 =      word[:prefix_len]
										if prefix in info["reverse_short_word"]:
														continue
										else:
														A	 =      prefix
														break

						if short_word is None:
										# Paranoid fallback
										def int_to_alphabetic(_SCREAMING_SNAKE_CASE		:       Optional[int]		):
														A	 =      ''
														while integer != 0:
																		A	 =      chr(ord('A'		) + integer % 1_0		) + s
																		integer //= 1_0
														return s

										A	 =      0
										while True:
														A	 =      word + '#' + int_to_alphabetic(_SCREAMING_SNAKE_CASE		)
														if sword in info["reverse_short_word"]:
																		continue
														else:
																		A	 =      sword
																		break

						A	 =      short_word
						A	 =      word
						return short_word
		@staticmethod
		def       A(  _SCREAMING_SNAKE_CASE		:       Optional[int]						,_SCREAMING_SNAKE_CASE		:       Optional[int]		)    ->   int:


						'''simple docstring'''
						A	 =      param_name.split('_'		)

						A	 =      [TrialShortNamer.shortname_for_word(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		) for word in words]

						# We try to create a separatorless short name, but if there is a collision we have to fallback
						# to a separated short name
						A	 =      ['', '_']

						for separator in separators:
										A	 =      separator.join(_SCREAMING_SNAKE_CASE		)
										if shortname not in info["reverse_short_param"]:
														A	 =      shortname
														A	 =      param_name
														return shortname

						return param_name
		@staticmethod
		def       A(  _SCREAMING_SNAKE_CASE		:       Optional[Any]						,_SCREAMING_SNAKE_CASE		:       Optional[int]		)    ->   List[str]:


						'''simple docstring'''
						A	 =      TrialShortNamer.shortname_for_key(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)
						A	 =      short_name
						A	 =      param_name
		@classmethod
		def       A(  cls		:       Optional[int]		)    ->   str:


						'''simple docstring'''
						if cls.NAMING_INFO is not None:
										return

						A	 =      {
						    'short_word': {},
						    'reverse_short_word': {},
						    'short_param': {},
						    'reverse_short_param': {},
						}

						A	 =      list(cls.DEFAULTS.keys()		)

						for k in field_keys:
										cls.add_new_param_name(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		)

						A	 =      info
		@classmethod
		def       A(  cls		:       List[str]						,_SCREAMING_SNAKE_CASE		:       str		)    ->   List[Any]:


						'''simple docstring'''
						cls.build_naming_info()
						assert cls.PREFIX is not None
						A	 =      [copy.copy(cls.PREFIX		)]

						for k, v in params.items():
										if k not in cls.DEFAULTS:
														raise Exception(f'You should provide a default value for the param name {k} with value {v}'		)
										if v == cls.DEFAULTS[k]:
														# The default value is not added to the name
														continue

										A	 =      cls.NAMING_INFO['short_param'][k]

										if isinstance(_SCREAMING_SNAKE_CASE						,_SCREAMING_SNAKE_CASE		):
														A	 =      1 if v else 0

										A	 =      '' if isinstance(_SCREAMING_SNAKE_CASE						,(int, float)		) else '-'
										A	 =      f'{key}{sep}{v}'
										name.append(_SCREAMING_SNAKE_CASE		)

						return "_".join(_SCREAMING_SNAKE_CASE		)







		@classmethod
		def       A(  cls		:       int						,_SCREAMING_SNAKE_CASE		:       Optional[int]		)    ->   str:


						'''simple docstring'''
						A	 =      repr[len(cls.PREFIX		) + 1 :]
						if repr == "":
										A	 =      []
						else:
										A	 =      repr.split('_'		)

						A	 =      {}

						for value in values:
										if "-" in value:
														A ,		A	 =      value.split('-'		)
										else:
														A	 =      re.sub('[0-9.]'						,''						,_SCREAMING_SNAKE_CASE		)
														A	 =      float(re.sub('[^0-9.]'						,''						,_SCREAMING_SNAKE_CASE		)		)

										A	 =      cls.NAMING_INFO['reverse_short_param'][p_k]

										A	 =      p_v

						for k in cls.DEFAULTS:
										if k not in parameters:
														A	 =      cls.DEFAULTS[k]

						return parameters





