'''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 							a_       (   self       ,    __lowerCAmelCase):




					"""simple docstring"""


					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       ,    50)
					self.assertEqual(loaded_config.max_length       ,    20)
					self.assertEqual(loaded_config.max_time       ,    __lowerCAmelCase)



			def 							a_       (   self):




					"""simple docstring"""


					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 							a_       (   self):




					"""simple docstring"""


					lowerCAmelCase   					=  GenerationConfig()
					lowerCAmelCase   					=  {
					    """max_new_tokens""": 1024,
					    """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       ,    1024)

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



			def 							a_       (   self):




					"""simple docstring"""


					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 							a_       (   self):




					"""simple docstring"""


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


			'''simple docstring'''






			@classmethod
			def 							a_       (   cls):




					"""simple docstring"""


					lowerCAmelCase   					=  TOKEN
					HfFolder.save_token(__lowerCAmelCase)



			@classmethod
			def 							a_       (   cls):




					"""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 							a_       (   self):




					"""simple docstring"""


					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 							a_       (   self):




					"""simple docstring"""


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





'''simple docstring'''




from typing import TYPE_CHECKING

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


__lowercase          =  {
    '''configuration_nezha''': ['''NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''NezhaConfig'''],
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__lowercase          =  [
						    '''NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST''',
						    '''NezhaForNextSentencePrediction''',
						    '''NezhaForMaskedLM''',
						    '''NezhaForPreTraining''',
						    '''NezhaForMultipleChoice''',
						    '''NezhaForQuestionAnswering''',
						    '''NezhaForSequenceClassification''',
						    '''NezhaForTokenClassification''',
						    '''NezhaModel''',
						    '''NezhaPreTrainedModel''',
						]


if TYPE_CHECKING:
						from .configuration_nezha import NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP, NezhaConfig

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_nezha import (
												    NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST,
												    NezhaForMaskedLM,
												    NezhaForMultipleChoice,
												    NezhaForNextSentencePrediction,
												    NezhaForPreTraining,
												    NezhaForQuestionAnswering,
												    NezhaForSequenceClassification,
												    NezhaForTokenClassification,
												    NezhaModel,
												    NezhaPreTrainedModel,
												)


else:
						import sys

						__lowercase          =  _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




