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




   @parameterized.expand([(None,), ("""foo.json""",)]   )
   def 			__a		(					self    :       List[str] ,			_lowercase    :       Optional[int]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   GenerationConfig(
         do_sample=_lowercase ,			temperature=0.7 ,			length_penalty=1.0 ,			bad_words_ids=[[1, 2, 3], [4, 5]] ,			)
     with tempfile.TemporaryDirectory() as tmp_dir:
       config.save_pretrained(_lowercase ,			config_name=_lowercase   )
       SCREAMING_SNAKE_CASE__    							=   GenerationConfig.from_pretrained(_lowercase ,			config_name=_lowercase   )

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




   def 			__a		(					self    :       Optional[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   AutoConfig.from_pretrained("""gpt2"""   )
     SCREAMING_SNAKE_CASE__    							=   GenerationConfig.from_model_config(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   GenerationConfig()

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

     # 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 			__a		(					self    :       Optional[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   GenerationConfig()
     SCREAMING_SNAKE_CASE__    							=   {
         """max_new_tokens""": 10_24,
         """foo""": """bar""",
     }
     SCREAMING_SNAKE_CASE__    							=   copy.deepcopy(_lowercase   )
     SCREAMING_SNAKE_CASE__    							=   generation_config.update(**_lowercase   )

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

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

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




   def 			__a		(					self    :       Union[str, Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   GenerationConfig()
     SCREAMING_SNAKE_CASE__    							=   """bar"""

     with tempfile.TemporaryDirectory("""test-generation-config"""   ) as tmp_dir:
       generation_config.save_pretrained(_lowercase   )

       SCREAMING_SNAKE_CASE__    							=   GenerationConfig.from_pretrained(_lowercase   )
     # update_kwargs was used to update the config on valid attributes
     self.assertEqual(new_config.foo ,			"""bar"""   )

     SCREAMING_SNAKE_CASE__    							=   GenerationConfig.from_model_config(_lowercase   )
     assert not hasattr(_lowercase ,			"""foo"""   )  # no new kwargs should be initialized if from config




   def 			__a		(					self    :       str   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   GenerationConfig()
     self.assertEqual(default_config.temperature ,			1.0   )
     self.assertEqual(default_config.do_sample ,			_lowercase   )
     self.assertEqual(default_config.num_beams ,			1   )

     SCREAMING_SNAKE_CASE__    							=   GenerationConfig(
         do_sample=_lowercase ,			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 ,			_lowercase   )
     self.assertEqual(config.num_beams ,			1   )

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

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







@is_staging_test
class __snake_case       (		unittest.TestCase	):




   @classmethod
   def 			__a		(					cls    :       List[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   TOKEN
     HfFolder.save_token(_lowercase   )




   @classmethod
   def 			__a		(					cls    :       Optional[Any]   ):



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



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   GenerationConfig(
         do_sample=_lowercase ,			temperature=0.7 ,			length_penalty=1.0 ,			)
     config.push_to_hub("""test-generation-config""" ,			use_auth_token=self._token   )

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

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

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




   def 			__a		(					self    :       Any   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   GenerationConfig(
         do_sample=_lowercase ,			temperature=0.7 ,			length_penalty=1.0 ,			)
     config.push_to_hub("""valid_org/test-generation-config-org""" ,			use_auth_token=self._token   )

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

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

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

import enum
import shutil
import sys


__lowerCamelCase     ,		__lowerCamelCase    :				Optional[Any]							     =	shutil.get_terminal_size()

__lowerCamelCase    :				Any							     =	{'''UP''': '''A''', '''DOWN''': '''B''', '''RIGHT''': '''C''', '''LEFT''': '''D'''}







class __snake_case       (		enum.Enum	):
   lowerCAmelCase_														=							0
   lowerCAmelCase_														=							1





def 			__SCREAMING_SNAKE_CASE						(      __UpperCamelCase					: Optional[int]				,  __UpperCamelCase					: List[str]=""			)							->      int:







  """simple docstring"""





  sys.stdout.write(str(__UpperCamelCase			) + end			)
  sys.stdout.flush()



def 			__SCREAMING_SNAKE_CASE						(      __UpperCamelCase					: Optional[int]				,  __UpperCamelCase					: List[str]				,  __UpperCamelCase					: Optional[Any]=""			)							->      Dict:







  """simple docstring"""





  forceWrite(f"""\u001b[{color}m{content}\u001b[0m"""				,  __UpperCamelCase			)



def 			__SCREAMING_SNAKE_CASE						(      )							->      Optional[Any]:







  """simple docstring"""





  forceWrite("""\r"""			)



def 			__SCREAMING_SNAKE_CASE						(      __UpperCamelCase					: int				,  __UpperCamelCase					: str			)							->      str:







  """simple docstring"""





  forceWrite(f"""\033[{num_lines}{CURSOR_TO_CHAR[direction.upper()]}"""			)



def 			__SCREAMING_SNAKE_CASE						(      )							->      Dict:







  """simple docstring"""





  forceWrite(""" """ * TERMINAL_WIDTH			)
  reset_cursor()






def 			__SCREAMING_SNAKE_CASE						(      )							->      int:







  """simple docstring"""





  reset_cursor()
  forceWrite("""-""" * TERMINAL_WIDTH			)
