






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


												"""simple docstring"""

												__lowercase					:							List[str]			=   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							)
																			__lowercase					:							List[str]			=   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 :		Any							)	->     Optional[int]:


												"""simple docstring"""

												__lowercase					:							Dict			=   AutoConfig.from_pretrained("""gpt2"""							)
												__lowercase					:							Any			=   GenerationConfig.from_model_config(__a							)
												__lowercase					:							Optional[int]			=   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 :		Union[str, Any]							)	->     Union[str, Any]:


												"""simple docstring"""

												__lowercase					:							Any			=   GenerationConfig()
												__lowercase					:							str			=   {
												    """max_new_tokens""": 1024,
												    """foo""": """bar""",
												}
												__lowercase					:							Any			=   copy.deepcopy(__a							)
												__lowercase					:							List[Any]			=   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						,   1024							)

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



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


												"""simple docstring"""

												__lowercase					:							int			=   GenerationConfig()
												__lowercase					:							Tuple			=   """bar"""

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

																			__lowercase					:							Optional[Any]			=   GenerationConfig.from_pretrained(__a							)
												# update_kwargs was used to update the config on valid attributes
												self.assertEqual(new_config.foo						,   """bar"""							)

												__lowercase					:							List[str]			=   GenerationConfig.from_model_config(__a							)
												assert not hasattr(__a						,   """foo"""							)  # no new kwargs should be initialized if from config



					def 					lowerCAmelCase (     self :		Tuple							)	->     int:


												"""simple docstring"""

												__lowercase					:							List[Any]			=   GenerationConfig()
												self.assertEqual(default_config.temperature						,   1.0							)
												self.assertEqual(default_config.do_sample						,   __a							)
												self.assertEqual(default_config.num_beams						,   1							)

												__lowercase					:							Any			=   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							)
																			__lowercase					:							Tuple			=   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 						lowerCAmelCase   (       unittest.TestCase	):

					'''simple docstring'''

					@classmethod
					def 					lowerCAmelCase (     cls :		Union[str, Any]							)	->     Optional[int]:


												"""simple docstring"""

												__lowercase					:							List[str]			=   TOKEN
												HfFolder.save_token(__a							)



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


												"""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 					lowerCAmelCase (     self :		Any							)	->     str:


												"""simple docstring"""

												__lowercase					:							Dict			=   GenerationConfig(
												    do_sample=__a						,   temperature=0.7						,   length_penalty=1.0						,   )
												config.push_to_hub("""test-generation-config"""						,   use_auth_token=self._token							)

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

												__lowercase					:							List[str]			=   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 :		str							)	->     Tuple:


												"""simple docstring"""

												__lowercase					:							Tuple			=   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							)

												__lowercase					:							Tuple			=   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							)

												__lowercase					:							Union[str, Any]			=   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							)							)







# flake8: noqa
# Lint as: python3
lowerCamelCase       :       Optional[Any]        =				[
    '''VerificationMode''',
    '''Version''',
    '''disable_progress_bar''',
    '''enable_progress_bar''',
    '''is_progress_bar_enabled''',
    '''experimental''',
]

from .info_utils import VerificationMode
from .logging import disable_progress_bar, enable_progress_bar, is_progress_bar_enabled
from .version import Version
from .experimental import experimental