


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







    """simple docstring"""




    @parameterized.expand([(None,), ("foo.json",)])
    def 	__snake_case							(					self				:    List[Any]				, __UpperCAmelCase				:    List[Any]):
      a						:		str      							=			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)
        a						:		Tuple      							=			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				, 50)
      self.assertEqual(loaded_config.max_length				, 20)
      self.assertEqual(loaded_config.max_time				, __UpperCAmelCase)






    def 	__snake_case							(					self				:    int):
      a						:		Dict      							=			AutoConfig.from_pretrained("gpt2")
      a						:		Optional[Any]      							=			GenerationConfig.from_model_config(__UpperCAmelCase)
      a						:		List[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				:    Optional[int]):
      a						:		List[Any]      							=			GenerationConfig()
      a						:		str      							=			{
          "max_new_tokens": 1024,
          "foo": "bar",
      }
      a						:		Dict      							=			copy.deepcopy(__UpperCAmelCase)
      a						:		Tuple      							=			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				, 1024)

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






    def 	__snake_case							(					self				:    Optional[int]):
      a						:		List[Any]      							=			GenerationConfig()
      a						:		Optional[int]      							=			"bar"

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

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

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






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

      a						:		Optional[int]      							=			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)
        a						:		Optional[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 						_A  (  unittest.TestCase  ):







    """simple docstring"""




    @classmethod
    def 	__snake_case							(					cls				:    Tuple):
      a						:		Optional[Any]      							=			TOKEN
      HfFolder.save_token(__UpperCAmelCase)






    @classmethod
    def 	__snake_case							(					cls				:    Dict):
      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				:    str):
      a						:		Dict      							=			GenerationConfig(
          do_sample=__UpperCAmelCase				, temperature=0.7				, length_penalty=1.0				, )
      config.push_to_hub("test-generation-config"				, use_auth_token=self._token)

      a						:		Union[str, 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))

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

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

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

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

      a						:		List[Any]      							=			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"""







def      lowercase			(				A_  ,   A_       )->      float:
  '''simple docstring'''







  if mass < 0:
    raise ValueError("The mass of a body cannot be negative"       )
  return 0.5 * mass * abs(A_       ) * abs(A_       )


if __name__ == "__main__":
 import doctest

 doctest.testmod(verbose=True)






