




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     :		Union[str, 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     UpperCamelCase_   (			unittest.TestCase					):

    '''simple docstring'''






    @classmethod
    def 	SCREAMING_SNAKE_CASE							(      cls				:     List[str])						->int:





           '''simple docstring'''

           A__							=   TOKEN
           HfFolder.save_token(lowerCamelCase_)


    @classmethod
    def 	SCREAMING_SNAKE_CASE							(      cls				:     List[str])						->str:





           '''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 	SCREAMING_SNAKE_CASE							(      self				:     List[str])						->str:





           '''simple docstring'''

           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 	SCREAMING_SNAKE_CASE							(      self				:     Tuple)						->Union[str, Any]:





           '''simple docstring'''

           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 	SCREAMING_SNAKE_CASE							(      self				:     Any)						->List[str]:





           '''simple docstring'''

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

    '''simple docstring'''






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





           '''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(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 	SCREAMING_SNAKE_CASE							(      self				:     Tuple)						->Any:





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





           '''simple docstring'''

           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 	SCREAMING_SNAKE_CASE							(      self				:     List[Any])						->List[Any]:





           '''simple docstring'''

           A__							=   mock.Mock()
           A__							=   500
           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 	SCREAMING_SNAKE_CASE							(      self				:     Dict)						->List[str]:





           '''simple docstring'''

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


    def 	SCREAMING_SNAKE_CASE							(      self				:     Tuple)						->Union[str, 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(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__							=   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'''))
                  A__							=   AutoConfig.from_pretrained(lowerCamelCase_)
                  self.assertEqual(new_configuration.hidden_size ,			768)





    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[int])						->Optional[Any]:





           '''simple docstring'''

           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 ,			768)











import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
  import torch

  from transformers.generation import DisjunctiveConstraint


@require_torch
class     UpperCamelCase_   (			unittest.TestCase					):

    '''simple docstring'''






    def 	SCREAMING_SNAKE_CASE							(      self				:     Dict)						->Tuple:





           '''simple docstring'''

           A__							=   [[1, 2, 4], [1, 2, 3, 4]]
           A__							=   DisjunctiveConstraint(UpperCAmelCase__)
           self.assertTrue(isinstance(dc.token_ids ,			UpperCAmelCase__))

           with self.assertRaises(UpperCAmelCase__):
                  DisjunctiveConstraint(torch.LongTensor([[1, 2, 4], [1, 2, 3]]))

           with self.assertRaises(UpperCAmelCase__):
                  DisjunctiveConstraint([torch.LongTensor([1, 2, 4]), torch.LongTensor([1, 2, 3, 4, 5])])


    def 	SCREAMING_SNAKE_CASE							(      self				:     int)						->str:





           '''simple docstring'''

           A__							=   [[1, 2], [1, 2, 3, 4]]

           with self.assertRaises(UpperCAmelCase__):
                  DisjunctiveConstraint(UpperCAmelCase__)  # fails here


    def 	SCREAMING_SNAKE_CASE							(      self				:     Any)						->str:





           '''simple docstring'''

           A__							=   [[1, 2, 3], [1, 2, 4]]

           A__							=   DisjunctiveConstraint(UpperCAmelCase__)

           A__			,							A__			,							A__							=   dc.update(1)
           A__							=   stepped is True and completed is False and reset is False
           self.assertTrue(UpperCAmelCase__)
           self.assertTrue(not dc.completed)
           self.assertTrue(dc.current_seq == [1])

           A__			,							A__			,							A__							=   dc.update(2)
           A__							=   stepped is True and completed is False and reset is False
           self.assertTrue(UpperCAmelCase__)
           self.assertTrue(not dc.completed)
           self.assertTrue(dc.current_seq == [1, 2])

           A__			,							A__			,							A__							=   dc.update(3)
           A__							=   stepped is True and completed is True and reset is False
           self.assertTrue(UpperCAmelCase__)
           self.assertTrue(dc.completed)  # Completed!
           self.assertTrue(dc.current_seq == [1, 2, 3])





    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[Any])						->Tuple:





           '''simple docstring'''

           A__							=   [[1, 2, 3], [1, 2, 4, 5], [1, 2, 5]]

           A__							=   DisjunctiveConstraint(UpperCAmelCase__)

           A__			,							A__			,							A__							=   dc.update(1)
           self.assertTrue(not dc.completed)
           self.assertTrue(dc.current_seq == [1])

           A__			,							A__			,							A__							=   dc.update(2)
           self.assertTrue(not dc.completed)
           self.assertTrue(dc.current_seq == [1, 2])

           A__			,							A__			,							A__							=   dc.update(4)
           self.assertTrue(not dc.completed)
           self.assertTrue(dc.current_seq == [1, 2, 4])

           A__			,							A__			,							A__							=   dc.update(5)
           self.assertTrue(dc.completed)  # Completed!
           self.assertTrue(dc.current_seq == [1, 2, 4, 5])

           dc.reset()

           A__			,							A__			,							A__							=   dc.update(1)
           self.assertTrue(not dc.completed)
           self.assertTrue(dc.remaining() == 3)
           self.assertTrue(dc.current_seq == [1])

           A__			,							A__			,							A__							=   dc.update(2)
           self.assertTrue(not dc.completed)
           self.assertTrue(dc.remaining() == 2)
           self.assertTrue(dc.current_seq == [1, 2])

           A__			,							A__			,							A__							=   dc.update(5)
           self.assertTrue(dc.completed)  # Completed!
           self.assertTrue(dc.remaining() == 0)
           self.assertTrue(dc.current_seq == [1, 2, 5])


