
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     UpperCamelCase_  (	self :			List[str]							,A :			Any			):
								__A             =			GenerationConfig(
								    do_sample=lowercase_							,temperature=0.7							,length_penalty=1.0							,bad_words_ids=[[1, 2, 3], [4, 5]]							,)
								with tempfile.TemporaryDirectory() as tmp_dir:
															config.save_pretrained(lowercase_							,config_name=lowercase_			)
															__A             =			GenerationConfig.from_pretrained(lowercase_							,config_name=lowercase_			)

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






	def     UpperCamelCase_  (	self :			Optional[Any]			):
								__A             =			AutoConfig.from_pretrained("gpt2"			)
								__A             =			GenerationConfig.from_model_config(lowercase_			)
								__A             =			GenerationConfig()

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

								# 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 :			Any			):
								__A             =			GenerationConfig()
								__A             =			{
								    "max_new_tokens": 10_24,
								    "foo": "bar",
								}
								__A             =			copy.deepcopy(lowercase_			)
								__A             =			generation_config.update(**lowercase_			)

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

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






	def     UpperCamelCase_  (	self :			List[str]			):
								__A             =			GenerationConfig()
								__A             =			"bar"

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

															__A             =			GenerationConfig.from_pretrained(lowercase_			)
								# update_kwargs was used to update the config on valid attributes
								self.assertEqual(new_config.foo							,"bar"			)

								__A             =			GenerationConfig.from_model_config(lowercase_			)
								assert not hasattr(lowercase_							,"foo"			)  # no new kwargs should be initialized if from config







	def     UpperCamelCase_  (	self :			str			):
								__A             =			GenerationConfig()
								self.assertEqual(default_config.temperature							,1.0			)
								self.assertEqual(default_config.do_sample							,lowercase_			)
								self.assertEqual(default_config.num_beams							,1			)

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

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

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





@is_staging_test
class 							UpperCAmelCase				(  unittest.TestCase  ):




	'''simple docstring'''





	@classmethod
	def     UpperCamelCase_  (	cls :			Optional[int]			):
								__A             =			TOKEN
								HfFolder.save_token(lowercase_			)






	@classmethod
	def     UpperCamelCase_  (	cls :			Any			):







								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 :			str			):
								__A             =			GenerationConfig(
								    do_sample=lowercase_							,temperature=0.7							,length_penalty=1.0							,)
								config.push_to_hub("test-generation-config"							,use_auth_token=self._token			)

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

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

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







	def     UpperCamelCase_  (	self :			Dict			):
								__A             =			GenerationConfig(
								    do_sample=lowercase_							,temperature=0.7							,length_penalty=1.0							,)
								config.push_to_hub("valid_org/test-generation-config-org"							,use_auth_token=self._token			)

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

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

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


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


SCREAMING_SNAKE_CASE							:Any										=    {
    'configuration_rag': ['RagConfig'],
    'retrieval_rag': ['RagRetriever'],
    'tokenization_rag': ['RagTokenizer'],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE							:List[Any]										=    [
					    'RagModel',
					    'RagPreTrainedModel',
					    'RagSequenceForGeneration',
					    'RagTokenForGeneration',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE							:Any										=    [
					    'TFRagModel',
					    'TFRagPreTrainedModel',
					    'TFRagSequenceForGeneration',
					    'TFRagTokenForGeneration',
					]


if TYPE_CHECKING:
					from .configuration_rag import RagConfig
					from .retrieval_rag import RagRetriever
					from .tokenization_rag import RagTokenizer

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_rag import RagModel, RagPreTrainedModel, RagSequenceForGeneration, RagTokenForGeneration

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_rag import (
										    TFRagModel,
										    TFRagPreTrainedModel,
										    TFRagSequenceForGeneration,
										    TFRagTokenForGeneration,
										)

else:
					import sys

					SCREAMING_SNAKE_CASE							:int										=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
