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






						'''simple docstring'''






						@parameterized.expand([(None,), ("""foo.json""",)]				)
						def  _lowercase     ( self   ,       _lowercase				):

												"""simple docstring"""



												_lowerCAmelCase  						=			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				)
																		_lowerCAmelCase  						=			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  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			AutoConfig.from_pretrained("""gpt2"""				)
												_lowerCAmelCase  						=			GenerationConfig.from_model_config(_lowercase				)
												_lowerCAmelCase  						=			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  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			GenerationConfig()
												_lowerCAmelCase  						=			{
												    """max_new_tokens""": 1_024,
												    """foo""": """bar""",
												}
												_lowerCAmelCase  						=			copy.deepcopy(_lowercase				)
												_lowerCAmelCase  						=			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   ,       1_024				)

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




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			GenerationConfig()
												_lowerCAmelCase  						=			"""bar"""

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

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

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




						def  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			GenerationConfig()
												self.assertEqual(default_config.temperature   ,       1.0				)
												self.assertEqual(default_config.do_sample   ,       _lowercase				)
												self.assertEqual(default_config.num_beams   ,       1				)

												_lowerCAmelCase  						=			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				)
																		_lowerCAmelCase  						=			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  _lowercase     ( cls				):

												"""simple docstring"""



												_lowerCAmelCase  						=			TOKEN
												HfFolder.save_token(_lowercase				)




						@classmethod
						def  _lowercase     ( 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  _lowercase     ( self				):

												"""simple docstring"""



												_lowerCAmelCase  						=			GenerationConfig(
												    do_sample=_lowercase   ,       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(_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				)

												_lowerCAmelCase  						=			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  _lowercase     ( self				):

												"""simple docstring"""



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

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

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


'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


_lowercase    =		{"""configuration_deit""": ["""DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DeiTConfig""", """DeiTOnnxConfig"""]}

try:
						if not is_vision_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowercase    =		["""DeiTFeatureExtractor"""]
						_lowercase    =		["""DeiTImageProcessor"""]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowercase    =		[
						    """DEIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """DeiTForImageClassification""",
						    """DeiTForImageClassificationWithTeacher""",
						    """DeiTForMaskedImageModeling""",
						    """DeiTModel""",
						    """DeiTPreTrainedModel""",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						_lowercase    =		[
						    """TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST""",
						    """TFDeiTForImageClassification""",
						    """TFDeiTForImageClassificationWithTeacher""",
						    """TFDeiTForMaskedImageModeling""",
						    """TFDeiTModel""",
						    """TFDeiTPreTrainedModel""",
						]


if TYPE_CHECKING:
						from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig

						try:
												if not is_vision_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .feature_extraction_deit import DeiTFeatureExtractor
												from .image_processing_deit import DeiTImageProcessor

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_deit import (
												    DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    DeiTForImageClassification,
												    DeiTForImageClassificationWithTeacher,
												    DeiTForMaskedImageModeling,
												    DeiTModel,
												    DeiTPreTrainedModel,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_deit import (
												    TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFDeiTForImageClassification,
												    TFDeiTForImageClassificationWithTeacher,
												    TFDeiTForMaskedImageModeling,
												    TFDeiTModel,
												    TFDeiTPreTrainedModel,
												)


else:
						import sys

						_lowercase    =		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
