


'''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


__SCREAMING_SNAKE_CASE					:				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 					__lowerCAmelCase   (   unittest.TestCase						):

						"""simple docstring"""






						@classmethod
						def 				_UpperCAmelCase       (  cls							:      Union[str, Any]	):
													A_			    =		TOKEN
													HfFolder.save_token(lowerCAmelCase	)






						@classmethod
						def 				_UpperCAmelCase       (  cls							:      List[Any]	):
													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							:      Dict	):
													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(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	)

													A_			    =		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							:      Tuple	):
													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(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	)

													A_			    =		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	):
													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=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 					__lowerCAmelCase   (   unittest.TestCase						):

						"""simple docstring"""






						def 				_UpperCAmelCase       (  self							:      List[Any]	):
													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(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							:      Optional[int]	):
													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(
													    lowerCAmelCase ,  ["is_encoder_decoder", "_name_or_path", "_commit_hash", "transformers_version"]	)
													A_			    =		[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							:      List[Any]	):
													with self.assertRaises(lowerCAmelCase	):
																				# 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(lowerCAmelCase	)






						def 				_UpperCAmelCase       (  self							:      Union[str, Any]	):
													# A mock response for an HTTP head request to emulate server down
													A_			    =		mock.Mock()
													A_			    =		5_00
													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=lowerCAmelCase	) 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 				_UpperCAmelCase       (  self							:      Tuple	):
													# 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 				_UpperCAmelCase       (  self							:      Any	):
													A_			    =		AutoConfig.from_pretrained("bert-base-cased"	)
													A_			    =		["config.4.0.0.json"]

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






						def 				_UpperCAmelCase       (  self							:      Optional[int]	):
													# 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(
													    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

													A_			    =		"v3.0.0"
													A_			    =		old_transformers.models.auto.AutoConfig.from_pretrained(lowerCAmelCase	)
													self.assertEqual(old_configuration.hidden_size ,  7_68	)









'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__SCREAMING_SNAKE_CASE					:				List[str]									=		{
    '''configuration_graphormer''': ['''GRAPHORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GraphormerConfig'''],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__SCREAMING_SNAKE_CASE					:				Optional[Any]									=		[
							    '''GRAPHORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''GraphormerForGraphClassification''',
							    '''GraphormerModel''',
							    '''GraphormerPreTrainedModel''',
							]


if TYPE_CHECKING:
							from .configuration_graphormer import GRAPHORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, GraphormerConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_graphormer import (
														    GRAPHORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
														    GraphormerForGraphClassification,
														    GraphormerModel,
														    GraphormerPreTrainedModel,
														)


else:
							import sys

							__SCREAMING_SNAKE_CASE					:				Optional[int]									=		_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





