





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			:		Dict ,  lowerCAmelCase_			:		Optional[Any]					)							->						Union[str, Any]:
     __lowerCAmelCase							     =     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							     =     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 ,  5_0					)
     self.assertEqual(loaded_config.max_length ,  2_0					)
     self.assertEqual(loaded_config.max_time ,  lowerCAmelCase_					)






  def     lowercase		(    self			:		Dict					)							->						Optional[int]:
     __lowerCAmelCase							     =     AutoConfig.from_pretrained('gpt2'					)
     __lowerCAmelCase							     =     GenerationConfig.from_model_config(lowerCAmelCase_					)
     __lowerCAmelCase							     =     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			:		str					)							->						Optional[Any]:
     __lowerCAmelCase							     =     GenerationConfig()
     __lowerCAmelCase							     =     {
         'max_new_tokens': 1_0_2_4,
         'foo': 'bar',
     }
     __lowerCAmelCase							     =     copy.deepcopy(lowerCAmelCase_					)
     __lowerCAmelCase							     =     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_0_2_4					)

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






  def     lowercase		(    self			:		Optional[Any]					)							->						Optional[Any]:
     __lowerCAmelCase							     =     GenerationConfig()
     __lowerCAmelCase							     =     'bar'

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

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

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






  def     lowercase		(    self			:		Any					)							->						Optional[Any]:
     __lowerCAmelCase							     =     GenerationConfig()
     self.assertEqual(default_config.temperature ,  1.0					)
     self.assertEqual(default_config.do_sample ,  lowerCAmelCase_					)
     self.assertEqual(default_config.num_beams ,  1					)

     __lowerCAmelCase							     =     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							     =     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			:		Optional[int]					)							->						Tuple:
     __lowerCAmelCase							     =     TOKEN
     HfFolder.save_token(lowerCAmelCase_					)






  @classmethod
  def     lowercase		(    cls			:		List[Any]					)							->						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     lowercase		(    self			:		Union[str, Any]					)							->						List[Any]:
     __lowerCAmelCase							     =     GenerationConfig(
         do_sample=lowerCAmelCase_ ,  temperature=0.7 ,  length_penalty=1.0 ,  )
     config.push_to_hub('test-generation-config' ,  use_auth_token=self._token					)

     __lowerCAmelCase							     =     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							     =     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			:		str					)							->						Any:
     __lowerCAmelCase							     =     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							     =     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							     =     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_					)					)








import builtins
import sys

from ...utils.imports import _is_package_available
from . import cursor, input
from .helpers import Direction, clear_line, forceWrite, linebreak, move_cursor, reset_cursor, writeColor
from .keymap import KEYMAP


_snake_case  :   Union[str, Any]						   =  False
try:
     _snake_case  :   Tuple						   =  _is_package_available('google.colab')
except ModuleNotFoundError:
     pass



@input.register
class     _UpperCAmelCase   :

  """simple docstring"""


  def __init__(    self			:		Union[str, Any] ,  lowerCAmelCase_			:		str = None ,  lowerCAmelCase_			:		list = []					)							->						Optional[int]:
     __lowerCAmelCase							     =     0
     __lowerCAmelCase							     =     choices
     __lowerCAmelCase							     =     prompt
     if sys.platform == "win32":
        __lowerCAmelCase							     =     '*'
     else:
        __lowerCAmelCase							     =     '➔ '






  def     lowercase		(    self			:		Dict ,  lowerCAmelCase_			:		Dict ,  lowerCAmelCase_			:		str = ""					)							->						Any:
     if sys.platform != "win32":
        writeColor(self.choices[index] ,  3_2 ,  lowerCAmelCase_					)
     else:
        forceWrite(self.choices[index] ,  lowerCAmelCase_					)






  def     lowercase		(    self			:		List[Any] ,  lowerCAmelCase_			:		int					)							->						List[Any]:
     if index == self.position:
        forceWrite(f""" {self.arrow_char} """					)
        self.write_choice(lowerCAmelCase_					)
     else:
        forceWrite(f"""    {self.choices[index]}"""					)
     reset_cursor()






  def     lowercase		(    self			:		Dict ,  lowerCAmelCase_			:		Direction ,  lowerCAmelCase_			:		int = 1					)							->						Union[str, Any]:
     __lowerCAmelCase							     =     self.position
     if direction == Direction.DOWN:
        if self.position + 1 >= len(self.choices					):
           return
        self.position += num_spaces
     else:
        if self.position - 1 < 0:
           return
        self.position -= num_spaces
     clear_line()
     self.print_choice(lowerCAmelCase_					)
     move_cursor(lowerCAmelCase_ ,  direction.name					)
     self.print_choice(self.position					)






  @input.mark(KEYMAP['up']					)
  def     lowercase		(    self			:		Optional[int]					)							->						Tuple:
     self.move_direction(Direction.UP					)






  @input.mark(KEYMAP['down']					)
  def     lowercase		(    self			:		str					)							->						Optional[Any]:
     self.move_direction(Direction.DOWN					)






  @input.mark(KEYMAP['newline']					)
  def     lowercase		(    self			:		str					)							->						Any:
     move_cursor(len(self.choices					) - self.position ,  'DOWN'					)
     return self.position






  @input.mark(KEYMAP['interrupt']					)
  def     lowercase		(    self			:		Dict					)							->						Optional[Any]:
     move_cursor(len(self.choices					) - self.position ,  'DOWN'					)
     raise KeyboardInterrupt






  @input.mark_multiple(*[KEYMAP[str(lowerCAmelCase_					)] for number in range(1_0					)]					)
  def     lowercase		(    self			:		List[Any]					)							->						Optional[int]:
     __lowerCAmelCase							     =     int(chr(self.current_selection					)					)
     __lowerCAmelCase							     =     index - self.position
     if index == self.position:
        return
     if index < len(self.choices					):
        if self.position > index:
           self.move_direction(Direction.UP ,  -movement					)
        elif self.position < index:
           self.move_direction(Direction.DOWN ,  lowerCAmelCase_					)
        else:
           return
     else:
        return






  def     lowercase		(    self			:		Any ,  lowerCAmelCase_			:		int = 0					)							->						int:
     if self.prompt:
        linebreak()
        forceWrite(self.prompt ,  '\n'					)
        if in_colab:
           forceWrite('Please input a choice index (starting from 0), and press enter' ,  '\n'					)
        else:
           forceWrite('Please select a choice using the arrow or number keys, and selecting with enter' ,  '\n'					)
     __lowerCAmelCase							     =     default_choice
     for i in range(len(self.choices					)					):
        self.print_choice(lowerCAmelCase_					)
        forceWrite('\n'					)
     move_cursor(len(self.choices					) - self.position ,  'UP'					)
     with cursor.hide():
        while True:
           if in_colab:
              try:
                 __lowerCAmelCase							     =     int(builtins.input()					)
              except ValueError:
                 __lowerCAmelCase							     =     default_choice
           else:
              __lowerCAmelCase							     =     self.handle_input()
           if choice is not None:
              reset_cursor()
              for _ in range(len(self.choices					) + 1					):
                 move_cursor(1 ,  'UP'					)
                 clear_line()
              self.write_choice(lowerCAmelCase_ ,  '\n'					)
              return choice

