





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


   @parameterized.expand([(None,), ('''foo.json''',)]					)
   def 					snake_case				( self    ,   _UpperCAmelCase					):
       A       :       Union[str, Any]							=						GenerationConfig(
           do_sample=_UpperCAmelCase    ,   temperature=0.7    ,   length_penalty=1.0    ,   bad_words_ids=[[1, 2, 3], [4, 5]]    ,   )
       with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(_UpperCAmelCase    ,   config_name=_UpperCAmelCase					)
           A       :       Tuple							=						GenerationConfig.from_pretrained(_UpperCAmelCase    ,   config_name=_UpperCAmelCase					)

       # Checks parameters that were specified
       self.assertEqual(loaded_config.do_sample    ,   _UpperCAmelCase					)
       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    ,   _UpperCAmelCase					)


   def 					snake_case				( self					):
       A       :       Tuple							=						AutoConfig.from_pretrained('''gpt2'''					)
       A       :       List[Any]							=						GenerationConfig.from_model_config(_UpperCAmelCase					)
       A       :       Dict							=						GenerationConfig()

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

       # 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 					snake_case				( self					):
       A       :       int							=						GenerationConfig()
       A       :       List[str]							=						{
           '''max_new_tokens''': 1_024,
           '''foo''': '''bar''',
       }
       A       :       Any							=						copy.deepcopy(_UpperCAmelCase					)
       A       :       Optional[Any]							=						generation_config.update(**_UpperCAmelCase					)

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

       # 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(_UpperCAmelCase    ,   {'''foo''': '''bar'''}					)


   def 					snake_case				( self					):
       A       :       Union[str, Any]							=						GenerationConfig()
       A       :       Optional[Any]							=						'''bar'''

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

           A       :       List[Any]							=						GenerationConfig.from_pretrained(_UpperCAmelCase					)
       # update_kwargs was used to update the config on valid attributes
       self.assertEqual(new_config.foo    ,   '''bar'''					)

       A       :       Any							=						GenerationConfig.from_model_config(_UpperCAmelCase					)
       assert not hasattr(_UpperCAmelCase    ,   '''foo'''					)  # no new kwargs should be initialized if from config


   def 					snake_case				( self					):
       A       :       Tuple							=						GenerationConfig()
       self.assertEqual(default_config.temperature    ,   1.0					)
       self.assertEqual(default_config.do_sample    ,   _UpperCAmelCase					)
       self.assertEqual(default_config.num_beams    ,   1					)

       A       :       List[Any]							=						GenerationConfig(
           do_sample=_UpperCAmelCase    ,   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    ,   _UpperCAmelCase					)
       self.assertEqual(config.num_beams    ,   1					)

       with tempfile.TemporaryDirectory() as tmp_dir:
           config.save_pretrained(_UpperCAmelCase					)
           A       :       Union[str, Any]							=						GenerationConfig.from_pretrained(_UpperCAmelCase    ,   temperature=1.0					)

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







@is_staging_test
class   _lowercase						(							unittest.TestCase				):


   @classmethod
   def 					snake_case				( cls					):
       A       :       int							=						TOKEN
       HfFolder.save_token(_UpperCAmelCase					)


   @classmethod
   def 					snake_case				( 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 					snake_case				( self					):
       A       :       List[Any]							=						GenerationConfig(
           do_sample=_UpperCAmelCase    ,   temperature=0.7    ,   length_penalty=1.0    ,   )
       config.push_to_hub('''test-generation-config'''    ,   use_auth_token=self._token					)

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

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

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


   def 					snake_case				( self					):
       A       :       List[Any]							=						GenerationConfig(
           do_sample=_UpperCAmelCase    ,   temperature=0.7    ,   length_penalty=1.0    ,   )
       config.push_to_hub('''valid_org/test-generation-config-org'''    ,   use_auth_token=self._token					)

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

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

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







'''simple docstring'''






from typing import TYPE_CHECKING

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


snake_case_     =	{
    """configuration_biogpt""": ["""BIOGPT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """BioGptConfig"""],
    """tokenization_biogpt""": ["""BioGptTokenizer"""],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     snake_case_     =	[
         """BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """BioGptForCausalLM""",
         """BioGptForTokenClassification""",
         """BioGptForSequenceClassification""",
         """BioGptModel""",
         """BioGptPreTrainedModel""",
     ]


if TYPE_CHECKING:
     from .configuration_biogpt import BIOGPT_PRETRAINED_CONFIG_ARCHIVE_MAP, BioGptConfig
     from .tokenization_biogpt import BioGptTokenizer

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_biogpt import (
              BIOGPT_PRETRAINED_MODEL_ARCHIVE_LIST,
              BioGptForCausalLM,
              BioGptForSequenceClassification,
              BioGptForTokenClassification,
              BioGptModel,
              BioGptPreTrainedModel,
          )


else:
     import sys

     snake_case_     =	_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
