






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

				"""simple docstring"""




				@parameterized.expand([(None,), ('''foo.json''',)]  )
				def 				lowercase__   (     self						:    List[str],  lowerCamelCase						:    Tuple  ):

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

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




				def 				lowercase__   (     self						:    Any  ):

								'''simple docstring'''
								lowercase__    =			AutoConfig.from_pretrained('''gpt2'''  )
								lowercase__    =			GenerationConfig.from_model_config(lowerCamelCase  )
								lowercase__    =			GenerationConfig()

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

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

								'''simple docstring'''
								lowercase__    =			GenerationConfig()
								lowercase__    =			{
								    '''max_new_tokens''': 1_024,
								    '''foo''': '''bar''',
								}
								lowercase__    =			copy.deepcopy(lowerCamelCase  )
								lowercase__    =			generation_config.update(**lowerCamelCase  )

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

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




				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			GenerationConfig()
								lowercase__    =			'''bar'''

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

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

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




				def 				lowercase__   (     self						:    Any  ):

								'''simple docstring'''
								lowercase__    =			GenerationConfig()
								self.assertEqual(default_config.temperature,  1.0  )
								self.assertEqual(default_config.do_sample,  lowerCamelCase  )
								self.assertEqual(default_config.num_beams,  1  )

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

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

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



@is_staging_test
class       _UpperCAmelCase					(       unittest.TestCase	):

				"""simple docstring"""




				@classmethod
				def 				lowercase__   (     cls						:    Any  ):

								'''simple docstring'''
								lowercase__    =			TOKEN
								HfFolder.save_token(lowerCamelCase  )




				@classmethod
				def 				lowercase__   (     cls						:    Union[str, 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 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								lowercase__    =			GenerationConfig(
								    do_sample=lowerCamelCase,  temperature=0.7,  length_penalty=1.0,  )
								config.push_to_hub('''test-generation-config''',  use_auth_token=self._token  )

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

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

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




				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								lowercase__    =			GenerationConfig(
								    do_sample=lowerCamelCase,  temperature=0.7,  length_penalty=1.0,  )
								config.push_to_hub('''valid_org/test-generation-config-org''',  use_auth_token=self._token  )

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

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

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












def   a			(						lowerCamelCase_				):






				'''simple docstring'''
				lowercase__    =			[1]

				lowercase__ ,						lowercase__ ,						lowercase__    =			0, 0, 0
				lowercase__    =			ugly_nums[ia] * 2
				lowercase__    =			ugly_nums[ia] * 3
				lowercase__    =			ugly_nums[ia] * 5

				for _ in range(1		,   lowerCamelCase_				):
								lowercase__    =			min(lowerCamelCase_		,   lowerCamelCase_		,   lowerCamelCase_				)
								ugly_nums.append(lowerCamelCase_				)
								if next_num == next_a:
												ia += 1
												lowercase__    =			ugly_nums[ia] * 2
								if next_num == next_a:
												ia += 1
												lowercase__    =			ugly_nums[ia] * 3
								if next_num == next_a:
												ia += 1
												lowercase__    =			ugly_nums[ia] * 5
				return ugly_nums[-1]


if __name__ == "__main__":
							from doctest import testmod

							testmod(verbose=True)
							print(F"{ugly_numbers(2_00) = }")




