




'''simple docstring'''




import copy
import tempfile
import unittest

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

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test






class UpperCAmelCase							(		unittest.TestCase							):



    @parameterized.expand([(None,), ('foo.json',)]					)
    def 					__lowerCamelCase						(  self     ,			__A					):
     __UpperCAmelCase					=   GenerationConfig(
         do_sample=__A     ,			temperature=0.7     ,			length_penalty=1.0     ,			bad_words_ids=[[1, 2, 3], [4, 5]]     ,			)
     with tempfile.TemporaryDirectory() as tmp_dir:
      config.save_pretrained(__A     ,			config_name=__A					)
      __UpperCAmelCase					=   GenerationConfig.from_pretrained(__A     ,			config_name=__A					)

     # Checks parameters that were specified
     self.assertEqual(loaded_config.do_sample     ,			__A					)
     self.assertEqual(loaded_config.temperature     ,			0.7					)
     self.assertEqual(loaded_config.length_penalty     ,			1.0					)
     self.assertEqual(loaded_config.bad_words_ids     ,			[[1, 2, 3], [4, 5]]					)

     # Checks parameters that were not specified (defaults)
     self.assertEqual(loaded_config.top_k     ,			50					)
     self.assertEqual(loaded_config.max_length     ,			20					)
     self.assertEqual(loaded_config.max_time     ,			__A					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   AutoConfig.from_pretrained('gpt2'					)
     __UpperCAmelCase					=   GenerationConfig.from_model_config(__A					)
     __UpperCAmelCase					=   GenerationConfig()

     # The generation config has loaded a few non-default parameters from the model config
     self.assertNotEqual(__A     ,			__A					)

     # One of those parameters is eos_token_id -- check if it matches
     self.assertNotEqual(generation_config_from_model.eos_token_id     ,			default_generation_config.eos_token_id					)
     self.assertEqual(generation_config_from_model.eos_token_id     ,			model_config.eos_token_id					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   GenerationConfig()
     __UpperCAmelCase					=   {
         'max_new_tokens': 1_024,
         'foo': 'bar',
     }
     __UpperCAmelCase					=   copy.deepcopy(__A					)
     __UpperCAmelCase					=   generation_config.update(**__A					)

     # update_kwargs was not modified (no side effects)
     self.assertEqual(__A     ,			__A					)

     # update_kwargs was used to update the config on valid attributes
     self.assertEqual(generation_config.max_new_tokens     ,			1_024					)

     # `.update()` returns a dictionary of unused kwargs
     self.assertEqual(__A     ,			{'foo': 'bar'}					)



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   GenerationConfig()
     __UpperCAmelCase					=   'bar'

     with tempfile.TemporaryDirectory('test-generation-config'					) as tmp_dir:
      generation_config.save_pretrained(__A					)

      __UpperCAmelCase					=   GenerationConfig.from_pretrained(__A					)
     # update_kwargs was used to update the config on valid attributes
     self.assertEqual(new_config.foo     ,			'bar'					)

     __UpperCAmelCase					=   GenerationConfig.from_model_config(__A					)
     assert not hasattr(__A     ,			'foo'					)  # no new kwargs should be initialized if from config




    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   GenerationConfig()
     self.assertEqual(default_config.temperature     ,			1.0					)
     self.assertEqual(default_config.do_sample     ,			__A					)
     self.assertEqual(default_config.num_beams     ,			1					)

     __UpperCAmelCase					=   GenerationConfig(
         do_sample=__A     ,			temperature=0.7     ,			length_penalty=1.0     ,			bad_words_ids=[[1, 2, 3], [4, 5]]     ,			)
     self.assertEqual(config.temperature     ,			0.7					)
     self.assertEqual(config.do_sample     ,			__A					)
     self.assertEqual(config.num_beams     ,			1					)

     with tempfile.TemporaryDirectory() as tmp_dir:
      config.save_pretrained(__A					)
      __UpperCAmelCase					=   GenerationConfig.from_pretrained(__A     ,			temperature=1.0					)

     self.assertEqual(loaded_config.temperature     ,			1.0					)
     self.assertEqual(loaded_config.do_sample     ,			__A					)
     self.assertEqual(loaded_config.num_beams     ,			1					)  # default value






@is_staging_test
class UpperCAmelCase							(		unittest.TestCase							):



    @classmethod
    def 					__lowerCamelCase						(  cls					):
     __UpperCAmelCase					=   TOKEN
     HfFolder.save_token(__A					)



    @classmethod
    def 					__lowerCamelCase						(  cls					):
     try:
      delete_repo(token=cls._token     ,			repo_id='test-generation-config'					)
     except HTTPError:
      pass

     try:
      delete_repo(token=cls._token     ,			repo_id='valid_org/test-generation-config-org'					)
     except HTTPError:
      pass



    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   GenerationConfig(
         do_sample=__A     ,			temperature=0.7     ,			length_penalty=1.0     ,			)
     config.push_to_hub('test-generation-config'     ,			use_auth_token=self._token					)

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

        # Reset repo
     delete_repo(token=self._token     ,			repo_id='test-generation-config'					)

     # Push to hub via save_pretrained
     with tempfile.TemporaryDirectory() as tmp_dir:
      config.save_pretrained(
          __A     ,			repo_id='test-generation-config'     ,			push_to_hub=__A     ,			use_auth_token=self._token					)

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




    def 					__lowerCamelCase						(  self					):
     __UpperCAmelCase					=   GenerationConfig(
         do_sample=__A     ,			temperature=0.7     ,			length_penalty=1.0     ,			)
     config.push_to_hub('valid_org/test-generation-config-org'     ,			use_auth_token=self._token					)

     __UpperCAmelCase					=   GenerationConfig.from_pretrained('valid_org/test-generation-config-org'					)
     for k, v in config.to_dict().items():
      if k != "transformers_version":
       self.assertEqual(__A     ,			getattr(__A     ,			__A					)					)

        # Reset repo
     delete_repo(token=self._token     ,			repo_id='valid_org/test-generation-config-org'					)

     # Push to hub via save_pretrained
     with tempfile.TemporaryDirectory() as tmp_dir:
      config.save_pretrained(
          __A     ,			repo_id='valid_org/test-generation-config-org'     ,			push_to_hub=__A     ,			use_auth_token=self._token					)

     __UpperCAmelCase					=   GenerationConfig.from_pretrained('valid_org/test-generation-config-org'					)
     for k, v in config.to_dict().items():
      if k != "transformers_version":
       self.assertEqual(__A     ,			getattr(__A     ,			__A					)					)












'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A:					List[str]							=				{
    """configuration_luke""": ["""LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LukeConfig"""],
    """tokenization_luke""": ["""LukeTokenizer"""],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A:					Union[str, Any]							=				[
        """LUKE_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """LukeForEntityClassification""",
        """LukeForEntityPairClassification""",
        """LukeForEntitySpanClassification""",
        """LukeForMultipleChoice""",
        """LukeForQuestionAnswering""",
        """LukeForSequenceClassification""",
        """LukeForTokenClassification""",
        """LukeForMaskedLM""",
        """LukeModel""",
        """LukePreTrainedModel""",
    ]


if TYPE_CHECKING:
    from .configuration_luke import LUKE_PRETRAINED_CONFIG_ARCHIVE_MAP, LukeConfig
    from .tokenization_luke import LukeTokenizer

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_luke import (
            LUKE_PRETRAINED_MODEL_ARCHIVE_LIST,
            LukeForEntityClassification,
            LukeForEntityPairClassification,
            LukeForEntitySpanClassification,
            LukeForMaskedLM,
            LukeForMultipleChoice,
            LukeForQuestionAnswering,
            LukeForSequenceClassification,
            LukeForTokenClassification,
            LukeModel,
            LukePreTrainedModel,
        )

else:
    import sys

    _A:					str							=				_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)





