





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


lowercase_		:				Optional[Any]				=						{
    '''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 			lowercase				(							unittest.TestCase     ):



						"""simple docstring"""

						@classmethod
						def 		__UpperCAmelCase       (    cls			:		int					):





										'''simple docstring'''







										_snake_case :			Optional[Any]  						=   TOKEN
										HfFolder.save_token(lowerCamelCase_					)







						@classmethod
						def 		__UpperCAmelCase       (    cls			:		Optional[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 		__UpperCAmelCase       (    self			:		Optional[Any]					):





										'''simple docstring'''







										_snake_case :			Any  						=   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					)

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

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

										_snake_case :			List[str]  						=   BertConfig.from_pretrained(f'''{USER}/test-config'''					)
										for k, v in config.to_dict().items():
														if k != "transformers_version":
																		self.assertEqual(lowerCamelCase_ ,				getattr(lowerCamelCase_ ,				lowerCamelCase_					)					)







						def 		__UpperCAmelCase       (    self			:		List[Any]					):





										'''simple docstring'''







										_snake_case :			List[Any]  						=   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					)

										_snake_case :			Optional[Any]  						=   BertConfig.from_pretrained('valid_org/test-config-org'					)
										for k, v in config.to_dict().items():
														if k != "transformers_version":
																		self.assertEqual(lowerCamelCase_ ,				getattr(lowerCamelCase_ ,				lowerCamelCase_					)					)

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

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







						def 		__UpperCAmelCase       (    self			:		str					):





										'''simple docstring'''







										CustomConfig.register_for_auto_class()
										_snake_case :			Union[str, 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'}					)

										_snake_case :			int  						=   AutoConfig.from_pretrained(f'''{USER}/test-dynamic-config''' ,				trust_remote_code=lowerCamelCase_					)
										# 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 		__UpperCAmelCase       (    self			:		List[Any]					):





										'''simple docstring'''







										_snake_case :			Union[str, Any]  						=   GPTaConfig()

										# attempt to modify each of int/float/bool/str config records and verify they were updated
										_snake_case :			Dict  						=   c.n_embd + 1  # int
										_snake_case :			Union[str, Any]  						=   c.resid_pdrop + 1.0  # float
										_snake_case :			int  						=   not c.scale_attn_weights  # bool
										_snake_case :			Dict  						=   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(lowerCamelCase_ ,				c.n_embd ,				'mismatch for key: n_embd'					)
										self.assertEqual(lowerCamelCase_ ,				c.resid_pdrop ,				'mismatch for key: resid_pdrop'					)
										self.assertEqual(lowerCamelCase_ ,				c.scale_attn_weights ,				'mismatch for key: scale_attn_weights'					)
										self.assertEqual(lowerCamelCase_ ,				c.summary_type ,				'mismatch for key: summary_type'					)







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





										'''simple docstring'''







										_snake_case :			List[Any]  						=   PretrainedConfig()
										_snake_case :			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(
										    lowerCamelCase_ ,				['is_encoder_decoder', '_name_or_path', '_commit_hash', 'transformers_version']					)
										_snake_case :			int  						=   [key for key, value in config_common_kwargs.items() if value == getattr(lowerCamelCase_ ,				lowerCamelCase_					)]
										if len(lowerCamelCase_					) > 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(lowerCamelCase_					)}.'''					)







						def 		__UpperCAmelCase       (    self			:		Optional[Any]					):





										'''simple docstring'''







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

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

										self.assertIsNotNone(lowerCamelCase_					)







						def 		__UpperCAmelCase       (    self			:		int					):





										'''simple docstring'''







										_snake_case :			str  						=   mock.Mock()
										_snake_case :			Optional[int]  						=   5_00
										_snake_case :			Any  						=   {}
										_snake_case :			List[str]  						=   HTTPError
										_snake_case :			Any  						=   {}

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







						def 		__UpperCAmelCase       (    self			:		Any					):





										'''simple docstring'''







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







						def 		__UpperCAmelCase       (    self			:		Any					):





										'''simple docstring'''







										_snake_case :			Union[str, Any]  						=   AutoConfig.from_pretrained('bert-base-cased'					)
										_snake_case :			Union[str, Any]  						=   ['config.4.0.0.json']

										with tempfile.TemporaryDirectory() as tmp_dir:
														configuration.save_pretrained(lowerCamelCase_					)
														_snake_case :			str  						=   2
														json.dump(configuration.to_dict() ,				open(os.path.join(lowerCamelCase_ ,				'config.4.0.0.json'					) ,				'w'					)					)

														# This should pick the new configuration file as the version of Transformers is > 4.0.0
														_snake_case :			int  						=   AutoConfig.from_pretrained(lowerCamelCase_					)
														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
														_snake_case :			List[str]  						=   ['config.42.0.0.json']
														_snake_case :			Dict  						=   7_68
														configuration.save_pretrained(lowerCamelCase_					)
														shutil.move(os.path.join(lowerCamelCase_ ,				'config.4.0.0.json'					) ,				os.path.join(lowerCamelCase_ ,				'config.42.0.0.json'					)					)
														_snake_case :			Optional[int]  						=   AutoConfig.from_pretrained(lowerCamelCase_					)
														self.assertEqual(new_configuration.hidden_size ,				7_68					)







						def 		__UpperCAmelCase       (    self			:		Optional[Any]					):





										'''simple docstring'''







										_snake_case :			List[Any]  						=   'hf-internal-testing/test-two-configs'

										import transformers as new_transformers

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

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

										_snake_case :			Tuple  						=   'v3.0.0'
										_snake_case :			Any  						=   old_transformers.models.auto.AutoConfig.from_pretrained(lowerCamelCase_					)
										self.assertEqual(old_configuration.hidden_size ,				7_68					)













def       A__(		__lowerCAmelCase ):
				assert column_title.isupper()
				_snake_case :			List[Any]  						=   0
				_snake_case :			List[str]  						=   len(__lowerCAmelCase ) - 1
				_snake_case :			Dict  						=   0

				while index >= 0:
								_snake_case :			List[str]  						=   (ord(column_title[index] ) - 64) * pow(26	,			__lowerCAmelCase )
								answer += value
								power += 1
								index -= 1

				return answer


if __name__ == "__main__":
		from doctest import testmod

		testmod()






