





"""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 					_lowerCAmelCase   (     unittest.TestCase       ):
       """simple docstring"""




       @parameterized.expand([(None,), ('foo.json',)]      )
       def      snake_case						(    self    , __UpperCAmelCase      ):



         '''simple docstring'''

         lowerCAmelCase__			:int											=							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      )
           lowerCAmelCase__			:Dict											=							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    , 5_0      )
         self.assertEqual(loaded_config.max_length    , 2_0      )
         self.assertEqual(loaded_config.max_time    , __UpperCAmelCase      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[Any]											=							AutoConfig.from_pretrained('gpt2'      )
         lowerCAmelCase__			:Dict											=							GenerationConfig.from_model_config(__UpperCAmelCase      )
         lowerCAmelCase__			:Any											=							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      ):



         '''simple docstring'''

         lowerCAmelCase__			:Union[str, Any]											=							GenerationConfig()
         lowerCAmelCase__			:List[Any]											=							{
             'max_new_tokens': 1_0_2_4,
             'foo': 'bar',
         }
         lowerCAmelCase__			:Union[str, Any]											=							copy.deepcopy(__UpperCAmelCase      )
         lowerCAmelCase__			:Optional[int]											=							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_0_2_4      )

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






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[int]											=							GenerationConfig()
         lowerCAmelCase__			:Optional[Any]											=							'bar'

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

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

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






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:List[str]											=							GenerationConfig()
         self.assertEqual(default_config.temperature    , 1.0      )
         self.assertEqual(default_config.do_sample    , __UpperCAmelCase      )
         self.assertEqual(default_config.num_beams    , 1      )

         lowerCAmelCase__			:Optional[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      )
           lowerCAmelCase__			: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 					_lowerCAmelCase   (     unittest.TestCase       ):
       """simple docstring"""




       @classmethod
       def      snake_case						(    cls      ):



         '''simple docstring'''

         lowerCAmelCase__			:Union[str, Any]											=							TOKEN
         HfFolder.save_token(__UpperCAmelCase      )






       @classmethod
       def      snake_case						(    cls      ):



         '''simple docstring'''

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



         '''simple docstring'''

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

         lowerCAmelCase__			:Optional[int]											=							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      )

         lowerCAmelCase__			:List[Any]											=							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      ):



         '''simple docstring'''

         lowerCAmelCase__			: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      )

         lowerCAmelCase__			: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      )      )

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

         lowerCAmelCase__			:List[str]											=							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"""





import tempfile
import unittest

from transformers import AutoModelForSeqaSeqLM, AutoTokenizer
from transformers.testing_utils import (
    is_torch_available,
    require_optimum,
    require_torch,
    slow,
)


if is_torch_available():
  import torch






@require_torch
@require_optimum
@slow
class 					_lowerCAmelCase   (     unittest.TestCase       ):
       """simple docstring"""




       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[Any]											=							'hf-internal-testing/tiny-random-t5'
         lowerCAmelCase__			:List[Any]											=							AutoTokenizer.from_pretrained(__UpperCAmelCase      )
         lowerCAmelCase__			:str											=							AutoModelForSeqaSeqLM.from_pretrained(__UpperCAmelCase      )

         lowerCAmelCase__			:Any											=							tokenizer('This is me'    , return_tensors='pt'      )

         lowerCAmelCase__			:Dict											=							model.to_bettertransformer()

         self.assertTrue(any('BetterTransformer' in mod.__class__.__name__ for _, mod in model.named_modules()      )      )

         lowerCAmelCase__			:Optional[Any]											=							model.generate(**__UpperCAmelCase      )

         lowerCAmelCase__			:List[Any]											=							model.reverse_bettertransformer()

         self.assertFalse(any('BetterTransformer' in mod.__class__.__name__ for _, mod in model.named_modules()      )      )

         with tempfile.TemporaryDirectory() as tmpdirname:
           model.save_pretrained(__UpperCAmelCase      )

           lowerCAmelCase__			:Any											=							AutoModelForSeqaSeqLM.from_pretrained(__UpperCAmelCase      )

           self.assertFalse(
               any('BetterTransformer' in mod.__class__.__name__ for _, mod in model_reloaded.named_modules()      )      )

           lowerCAmelCase__			:Union[str, Any]											=							model_reloaded.generate(**__UpperCAmelCase      )
           self.assertTrue(torch.allclose(__UpperCAmelCase    , __UpperCAmelCase      )      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:int											=							'hf-internal-testing/tiny-random-t5'
         lowerCAmelCase__			:Union[str, Any]											=							AutoModelForSeqaSeqLM.from_pretrained(__UpperCAmelCase      )

         lowerCAmelCase__			:str											=							model.to_bettertransformer()

         with tempfile.TemporaryDirectory() as tmpdirname:
           with self.assertRaises(__UpperCAmelCase      ):
             model.save_pretrained(__UpperCAmelCase      )

           lowerCAmelCase__			:Optional[int]											=							model.reverse_bettertransformer()
           model.save_pretrained(__UpperCAmelCase      )
