




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







 '''simple docstring'''





 @parameterized.expand([(None,), ("""foo.json""",)]		)
 def  UpperCamelCase_   (				self:		Optional[Any],      a_:		Optional[int]		):




   '''simple docstring'''



   _snake_case							:		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		)
     _snake_case							:		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  UpperCamelCase_   (				self:		Any		):




   '''simple docstring'''



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




   '''simple docstring'''



   _snake_case							:		Any								=  GenerationConfig()
   _snake_case							:		str								=  {
       """max_new_tokens""": 1_024,
       """foo""": """bar""",
   }
   _snake_case							:		Any								=  copy.deepcopy(__a		)
   _snake_case							:		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,      1_024		)

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


 def  UpperCamelCase_   (				self:		Optional[Any]		):




   '''simple docstring'''



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

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

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

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


 def  UpperCamelCase_   (				self:		Tuple		):




   '''simple docstring'''



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

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







 '''simple docstring'''





 @classmethod
 def  UpperCamelCase_   (				cls:		Union[str, Any]		):




   '''simple docstring'''



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


 @classmethod
 def  UpperCamelCase_   (				cls:		List[str]		):




   '''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  UpperCamelCase_   (				self:		Any		):




   '''simple docstring'''



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

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

   _snake_case							:		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  UpperCamelCase_   (				self:		str		):




   '''simple docstring'''



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

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

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










from itertools import permutations
def 					snake_case_						(   lowerCAmelCase_				:  tuple					):
							if num[3] % 2 != 0:
														return False

							if (num[2] + num[3] + num[4]) % 3 != 0:
														return False

							if num[5] % 5 != 0:
														return False

							__lowercase					:							Dict			=   [7, 11, 13, 17]
							for i, test in enumerate(lowerCAmelCase_					):
														if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
																					return False
							return True
def 					snake_case_						(   lowerCAmelCase_				:  int = 10					):
							return sum(
							    int("""""".join(map(lowerCAmelCase_				,				lowerCAmelCase_					)					)					)
							    for num in permutations(range(lowerCAmelCase_					)					)
							    if is_substring_divisible(lowerCAmelCase_					)					)


if __name__ == "__main__":
	print(f'''{solution() = }''')