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_  : str								=					{
    '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': 1_2_8,
    'add_cross_attention': True,
    'tie_encoder_decoder': True,
    'max_length': 5_0,
    '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': 1_0,
    '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': 1_0,
    '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     ):
    @classmethod
    def     UpperCamelCase_					(	cls )							->       Dict:
     SCREAMING_SNAKE_CASE__: Union[str, Any]=   TOKEN
     HfFolder.save_token(lowerCAmelCase )
    @classmethod
    def     UpperCamelCase_					(	cls )							->       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 )							->       Optional[Any]:
     SCREAMING_SNAKE_CASE__: Dict=   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 )

     SCREAMING_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 ) )

        # 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 )

     SCREAMING_SNAKE_CASE__: Union[str, Any]=   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[str]:
     SCREAMING_SNAKE_CASE__: Optional[int]=   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 )

     SCREAMING_SNAKE_CASE__: Optional[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 ) )

        # 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 )

     SCREAMING_SNAKE_CASE__: Tuple=   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 )							->       Tuple:
     CustomConfig.register_for_auto_class()
     SCREAMING_SNAKE_CASE__: Optional[int]=   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'''} )

     SCREAMING_SNAKE_CASE__: Tuple=   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     ):
    def     UpperCamelCase_					(	self )							->       Tuple:
     SCREAMING_SNAKE_CASE__: Tuple=   GPTaConfig()

     # attempt to modify each of int/float/bool/str config records and verify they were updated
     SCREAMING_SNAKE_CASE__: List[Any]=   c.n_embd + 1  # int
     SCREAMING_SNAKE_CASE__: List[Any]=   c.resid_pdrop + 1.0  # float
     SCREAMING_SNAKE_CASE__: List[Any]=   not c.scale_attn_weights  # bool
     SCREAMING_SNAKE_CASE__: List[str]=   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 )							->       List[Any]:
     SCREAMING_SNAKE_CASE__: Any=   PretrainedConfig()
     SCREAMING_SNAKE_CASE__: Union[str, Any]=   [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'''] )
     SCREAMING_SNAKE_CASE__: List[str]=   [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
      SCREAMING_SNAKE_CASE__: Dict=   BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder''' )

     SCREAMING_SNAKE_CASE__: Optional[int]=   BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''			,			subfolder='''bert''' )

     self.assertIsNotNone(lowerCAmelCase )
    def     UpperCamelCase_					(	self )							->       Tuple:
     # A mock response for an HTTP head request to emulate server down
     SCREAMING_SNAKE_CASE__: Dict=   mock.Mock()
     SCREAMING_SNAKE_CASE__: int=   500
     SCREAMING_SNAKE_CASE__: List[Any]=   {}
     SCREAMING_SNAKE_CASE__: Optional[Any]=   HTTPError
     SCREAMING_SNAKE_CASE__: Tuple=   {}

     # Download this model to make sure it's in the cache.
     SCREAMING_SNAKE_CASE__: List[str]=   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:
      SCREAMING_SNAKE_CASE__: Any=   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 )							->       str:
     # This test is for deprecated behavior and can be removed in v5
     SCREAMING_SNAKE_CASE__: Dict=   BertConfig.from_pretrained(
         '''https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json''' )
    def     UpperCamelCase_					(	self )							->       Optional[Any]:
     SCREAMING_SNAKE_CASE__: Optional[int]=   AutoConfig.from_pretrained('''bert-base-cased''' )
     SCREAMING_SNAKE_CASE__: Union[str, Any]=   ['''config.4.0.0.json''']

     with tempfile.TemporaryDirectory() as tmp_dir:
      configuration.save_pretrained(lowerCAmelCase )
      SCREAMING_SNAKE_CASE__: Tuple=   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
      SCREAMING_SNAKE_CASE__: Any=   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
      SCREAMING_SNAKE_CASE__: Dict=   ['''config.42.0.0.json''']
      SCREAMING_SNAKE_CASE__: str=   768
      configuration.save_pretrained(lowerCAmelCase )
      shutil.move(os.path.join(lowerCAmelCase			,			'''config.4.0.0.json''' )			,			os.path.join(lowerCAmelCase			,			'''config.42.0.0.json''' ) )
      SCREAMING_SNAKE_CASE__: Union[str, Any]=   AutoConfig.from_pretrained(lowerCAmelCase )
      self.assertEqual(new_configuration.hidden_size			,			768 )



    def     UpperCamelCase_					(	self )							->       List[str]:
     # This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
     SCREAMING_SNAKE_CASE__: int=   '''hf-internal-testing/test-two-configs'''

     import transformers as new_transformers

     SCREAMING_SNAKE_CASE__: int=   '''v4.0.0'''
     SCREAMING_SNAKE_CASE__,						SCREAMING_SNAKE_CASE__: Tuple=   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

     SCREAMING_SNAKE_CASE__: Any=   '''v3.0.0'''
     SCREAMING_SNAKE_CASE__: Tuple=   old_transformers.models.auto.AutoConfig.from_pretrained(lowerCAmelCase )
     self.assertEqual(old_configuration.hidden_size			,			768 )





def      UpperCAmelCase__		(UpperCamelCase_ = 10_00							):



     """simple docstring"""






     return sum(2 * a * ((a - 1) // 2) for a in range(3				,n + 1							)							)


if __name__ == "__main__":
 print(solution())




