


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







    """simple docstring"""



    @parameterized.expand([(None,), ("""foo.json""",)]		)
    def __lowercase   (   self    :  Optional[int]    ,						lowerCamelCase    :  List[str]		)   ->  Dict:
      lowerCAmelCase_			:      List[Any]			=   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		)
        lowerCAmelCase_			:      Optional[Any]			=   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		)   ->  str:
      lowerCAmelCase_			:      str			=   AutoConfig.from_pretrained("""gpt2"""		)
      lowerCAmelCase_			:      Dict			=   GenerationConfig.from_model_config(lowerCamelCase		)
      lowerCAmelCase_			:      int			=   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    :  Union[str, Any]		)   ->  Any:
      lowerCAmelCase_			:      Dict			=   GenerationConfig()
      lowerCAmelCase_			:      List[Any]			=   {
          """max_new_tokens""": 10_24,
          """foo""": """bar""",
      }
      lowerCAmelCase_			:      Optional[Any]			=   copy.deepcopy(lowerCamelCase		)
      lowerCAmelCase_			:      Tuple			=   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    ,						10_24		)

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

    def __lowercase   (   self    :  List[Any]		)   ->  List[Any]:
      lowerCAmelCase_			:      Union[str, Any]			=   GenerationConfig()
      lowerCAmelCase_			:      Optional[Any]			=   """bar"""

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

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

      lowerCAmelCase_			:      Optional[Any]			=   GenerationConfig.from_model_config(lowerCamelCase		)
      assert not hasattr(lowerCamelCase    ,						"""foo"""		)  # no new kwargs should be initialized if from config





    def __lowercase   (   self    :  Tuple		)   ->  str:
      lowerCAmelCase_			:      Tuple			=   GenerationConfig()
      self.assertEqual(default_config.temperature    ,						1.0		)
      self.assertEqual(default_config.do_sample    ,						lowerCamelCase		)
      self.assertEqual(default_config.num_beams    ,						1		)

      lowerCAmelCase_			:      List[Any]			=   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		)
        lowerCAmelCase_			:      Optional[Any]			=   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    __snake_case       (   unittest.TestCase):







    """simple docstring"""



    @classmethod
    def __lowercase   (   cls    :  Optional[int]		)   ->  Optional[Any]:
      lowerCAmelCase_			:      Tuple			=   TOKEN
      HfFolder.save_token(lowerCamelCase		)

    @classmethod
    def __lowercase   (   cls    :  Optional[Any]		)   ->  Optional[int]:
      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    :  Optional[int]		)   ->  int:
      lowerCAmelCase_			:      Tuple			=   GenerationConfig(
          do_sample=lowerCamelCase    ,						temperature=0.7    ,						length_penalty=1.0    ,						)
      config.push_to_hub("""test-generation-config"""    ,						use_auth_token=self._token		)

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

      lowerCAmelCase_			:      str			=   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[Any]		)   ->  Optional[Any]:
      lowerCAmelCase_			:      Dict			=   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		)

      lowerCAmelCase_			:      Dict			=   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		)

      lowerCAmelCase_			:      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(lowerCamelCase    ,						getattr(lowerCamelCase    ,						lowerCamelCase		)		)







'''simple docstring'''






from statistics import mean, stdev







def 				UpperCamelCase_			(    A__					:   list							,    A__					:   int = 3					):
  '''simple docstring'''





  lowerCAmelCase_			:      List[str]			=   min(A__					)
  lowerCAmelCase_			:      Optional[int]			=   max(A__					)
  # normalize data
  return [round((x - x_min) / (x_max - x_min)							,    A__					) for x in data]







def 				UpperCamelCase_			(    A__					:   list							,    A__					:   int = 3					):
  '''simple docstring'''





  lowerCAmelCase_			:      str			=   mean(A__					)
  lowerCAmelCase_			:      List[Any]			=   stdev(A__					)
  # standardize data
  return [round((x - mu) / (sigma)							,    A__					) for x in data]



