



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




				@parameterized.expand([(None,), ("foo.json",)]  )
				def 							A__ (  self   :  Optional[Any],   __lowercase   :  Optional[Any]  ):
							lowercase__   					=			GenerationConfig(
							    do_sample=_SCREAMING_SNAKE_CASE,   temperature=0.7,   length_penalty=1.0,   bad_words_ids=[[1, 2, 3], [4, 5]],   )
							with tempfile.TemporaryDirectory() as tmp_dir:
										config.save_pretrained(_SCREAMING_SNAKE_CASE,   config_name=_SCREAMING_SNAKE_CASE  )
										lowercase__   					=			GenerationConfig.from_pretrained(_SCREAMING_SNAKE_CASE,   config_name=_SCREAMING_SNAKE_CASE  )

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




				def 							A__ (  self   :  Optional[int]  ):
							lowercase__   					=			AutoConfig.from_pretrained("gpt2"  )
							lowercase__   					=			GenerationConfig.from_model_config(_SCREAMING_SNAKE_CASE  )
							lowercase__   					=			GenerationConfig()

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

							# 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   :  Optional[Any]  ):
							lowercase__   					=			GenerationConfig()
							lowercase__   					=			{
							    "max_new_tokens": 1024,
							    "foo": "bar",
							}
							lowercase__   					=			copy.deepcopy(_SCREAMING_SNAKE_CASE  )
							lowercase__   					=			generation_config.update(**_SCREAMING_SNAKE_CASE  )

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

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




				def 							A__ (  self   :  Tuple  ):
							lowercase__   					=			GenerationConfig()
							lowercase__   					=			"bar"

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

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

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




				def 							A__ (  self   :  Optional[Any]  ):
							lowercase__   					=			GenerationConfig()
							self.assertEqual(default_config.temperature,   1.0  )
							self.assertEqual(default_config.do_sample,   _SCREAMING_SNAKE_CASE  )
							self.assertEqual(default_config.num_beams,   1  )

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

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

							self.assertEqual(loaded_config.temperature,   1.0  )
							self.assertEqual(loaded_config.do_sample,   _SCREAMING_SNAKE_CASE  )
							self.assertEqual(loaded_config.num_beams,   1  )  # default value
@is_staging_test
class 			_snake_case     (   unittest.TestCase):




				@classmethod
				def 							A__ (  cls   :  Any  ):
							lowercase__   					=			TOKEN
							HfFolder.save_token(_SCREAMING_SNAKE_CASE  )




				@classmethod
				def 							A__ (  cls   :  str  ):

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

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

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

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




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

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

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

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









from ...utils import (
    OptionalDependencyNotAvailable,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)


try:
							if not (is_transformers_available() and is_torch_available() and is_transformers_version(""">=""", """4.25.0""")):
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							from ...utils.dummy_torch_and_transformers_objects import (
							    VersatileDiffusionDualGuidedPipeline,
							    VersatileDiffusionImageVariationPipeline,
							    VersatileDiffusionPipeline,
							    VersatileDiffusionTextToImagePipeline,
							)
else:
							from .modeling_text_unet import UNetFlatConditionModel
							from .pipeline_versatile_diffusion import VersatileDiffusionPipeline
							from .pipeline_versatile_diffusion_dual_guided import VersatileDiffusionDualGuidedPipeline
							from .pipeline_versatile_diffusion_image_variation import VersatileDiffusionImageVariationPipeline
							from .pipeline_versatile_diffusion_text_to_image import VersatileDiffusionTextToImagePipeline




