





import tempfile
import unittest

from diffusers import (
    DDIMScheduler,
    DDPMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    PNDMScheduler,
    logging,
)
from diffusers.configuration_utils import ConfigMixin, register_to_config
from diffusers.utils.testing_utils import CaptureLogger




class      UpperCamelCase_				(   UpperCamelCase__			):
							lowerCamelCase_							=    "config.json"


							@register_to_config
							def __init__(							self			:Optional[int]							, __A			:int=2							, __A			:Union[str, Any]=5							, __A			:Tuple=(2, 5)							, __A			:Any="for diffusion"							, __A			:Dict=[1, 3]							, )      ->      Optional[int]:



									"""simple docstring"""



									pass




class      UpperCamelCase_				(   UpperCamelCase__			):
							lowerCamelCase_							=    "config.json"


							@register_to_config
							def __init__(							self			:Union[str, Any]							, __A			:List[str]=2							, __A			:Dict=5							, __A			:str=(2, 5)							, __A			:List[str]="for diffusion"							, __A			:Any=[1, 3]							, )      ->      List[Any]:



									"""simple docstring"""



									pass




class      UpperCamelCase_				(   UpperCamelCase__			):
							lowerCamelCase_							=    "config.json"


							@register_to_config
							def __init__(							self			:str							, __A			:List[str]=2							, __A			:str=5							, __A			:List[Any]=(2, 5)							, __A			:List[Any]="for diffusion"							, __A			:List[Any]=[1, 3]							, __A			:str=[1, 3]							, )      ->      List[Any]:



									"""simple docstring"""



									pass




class      UpperCamelCase_				(   UpperCamelCase__			):
							lowerCamelCase_							=    "config.json"


							@register_to_config
							def __init__(							self			:Optional[Any]							, __A			:Tuple=2							, __A			:str=5							, __A			:Optional[int]=(2, 5)							, __A			:str="for diffusion"							, __A			:List[str]=[1, 5]							, __A			:int=[5, 4]							, )      ->      int:



									"""simple docstring"""



									pass




class      UpperCamelCase_				(   unittest.TestCase			):


							def    _snake_case     (							self			:Optional[int]						)      ->      Tuple:



									"""simple docstring"""



									with self.assertRaises(__A						):
											ConfigMixin.load_config("""dummy_path"""						)


							def    _snake_case     (							self			:Tuple						)      ->      Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					SampleObject()
									SCREAMING_SNAKE_CASE__								=					obj.config
									assert config["a"] == 2
									assert config["b"] == 5
									assert config["c"] == (2, 5)
									assert config["d"] == "for diffusion"
									assert config["e"] == [1, 3]

									# init ignore private arguments
									SCREAMING_SNAKE_CASE__								=					SampleObject(_name_or_path="""lalala"""						)
									SCREAMING_SNAKE_CASE__								=					obj.config
									assert config["a"] == 2
									assert config["b"] == 5
									assert config["c"] == (2, 5)
									assert config["d"] == "for diffusion"
									assert config["e"] == [1, 3]

									# can override default
									SCREAMING_SNAKE_CASE__								=					SampleObject(c=6						)
									SCREAMING_SNAKE_CASE__								=					obj.config
									assert config["a"] == 2
									assert config["b"] == 5
									assert config["c"] == 6
									assert config["d"] == "for diffusion"
									assert config["e"] == [1, 3]

									# can use positional arguments.
									SCREAMING_SNAKE_CASE__								=					SampleObject(1							, c=6						)
									SCREAMING_SNAKE_CASE__								=					obj.config
									assert config["a"] == 1
									assert config["b"] == 5
									assert config["c"] == 6
									assert config["d"] == "for diffusion"
									assert config["e"] == [1, 3]


							def    _snake_case     (							self			:Optional[int]						)      ->      Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					SampleObject()
									SCREAMING_SNAKE_CASE__								=					obj.config

									assert config["a"] == 2
									assert config["b"] == 5
									assert config["c"] == (2, 5)
									assert config["d"] == "for diffusion"
									assert config["e"] == [1, 3]

									with tempfile.TemporaryDirectory() as tmpdirname:
											obj.save_config(__A						)
											SCREAMING_SNAKE_CASE__								=					SampleObject.from_config(SampleObject.load_config(__A						)						)
											SCREAMING_SNAKE_CASE__								=					new_obj.config

									# unfreeze configs
									SCREAMING_SNAKE_CASE__								=					dict(__A						)
									SCREAMING_SNAKE_CASE__								=					dict(__A						)

									assert config.pop("""c"""						) == (2, 5)  # instantiated as tuple
									assert new_config.pop("""c"""						) == [2, 5]  # saved & loaded as list because of json
									config.pop("""_use_default_values"""						)
									assert config == new_config


							def    _snake_case     (							self			:str						)      ->      Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					logging.get_logger("""diffusers.configuration_utils"""						)
									# 30 for warning
									logger.setLevel(30						)

									with CaptureLogger(__A						) as cap_logger:
											SCREAMING_SNAKE_CASE__								=					DDIMScheduler.from_pretrained(
											    """hf-internal-testing/tiny-stable-diffusion-torch"""							, subfolder="""scheduler"""						)

									assert ddim.__class__ == DDIMScheduler
									# no warning should be thrown
									assert cap_logger.out == ""


							def    _snake_case     (							self			:Optional[int]						)      ->      str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					logging.get_logger("""diffusers.configuration_utils"""						)
									# 30 for warning
									logger.setLevel(30						)

									with CaptureLogger(__A						) as cap_logger:
											SCREAMING_SNAKE_CASE__								=					EulerDiscreteScheduler.from_pretrained(
											    """hf-internal-testing/tiny-stable-diffusion-torch"""							, subfolder="""scheduler"""						)

									assert euler.__class__ == EulerDiscreteScheduler
									# no warning should be thrown
									assert cap_logger.out == ""


							def    _snake_case     (							self			:List[Any]						)      ->      int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					logging.get_logger("""diffusers.configuration_utils"""						)
									# 30 for warning
									logger.setLevel(30						)

									with CaptureLogger(__A						) as cap_logger:
											SCREAMING_SNAKE_CASE__								=					EulerAncestralDiscreteScheduler.from_pretrained(
											    """hf-internal-testing/tiny-stable-diffusion-torch"""							, subfolder="""scheduler"""						)

									assert euler.__class__ == EulerAncestralDiscreteScheduler
									# no warning should be thrown
									assert cap_logger.out == ""


							def    _snake_case     (							self			:str						)      ->      Union[str, Any]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					logging.get_logger("""diffusers.configuration_utils"""						)
									# 30 for warning
									logger.setLevel(30						)

									with CaptureLogger(__A						) as cap_logger:
											SCREAMING_SNAKE_CASE__								=					PNDMScheduler.from_pretrained(
											    """hf-internal-testing/tiny-stable-diffusion-torch"""							, subfolder="""scheduler"""						)

									assert pndm.__class__ == PNDMScheduler
									# no warning should be thrown
									assert cap_logger.out == ""


							def    _snake_case     (							self			:Union[str, Any]						)      ->      Optional[int]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					logging.get_logger("""diffusers.configuration_utils"""						)
									# 30 for warning
									logger.setLevel(30						)

									with CaptureLogger(__A						) as cap_logger:
											SCREAMING_SNAKE_CASE__								=					DDPMScheduler.from_pretrained(
											    """hf-internal-testing/tiny-stable-diffusion-torch"""							, subfolder="""scheduler"""							, prediction_type="""sample"""							, beta_end=8							, )

									with CaptureLogger(__A						) as cap_logger_a:
											SCREAMING_SNAKE_CASE__								=					DDPMScheduler.from_pretrained("""google/ddpm-celebahq-256"""							, beta_start=88						)

									assert ddpm.__class__ == DDPMScheduler
									assert ddpm.config.prediction_type == "sample"
									assert ddpm.config.beta_end == 8
									assert ddpm_a.config.beta_start == 88

									# no warning should be thrown
									assert cap_logger.out == ""
									assert cap_logger_a.out == ""


							def    _snake_case     (							self			:Optional[int]						)      ->      Tuple:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					logging.get_logger("""diffusers.configuration_utils"""						)
									# 30 for warning
									logger.setLevel(30						)

									with CaptureLogger(__A						) as cap_logger:
											SCREAMING_SNAKE_CASE__								=					DPMSolverMultistepScheduler.from_pretrained(
											    """hf-internal-testing/tiny-stable-diffusion-torch"""							, subfolder="""scheduler"""						)

									assert dpm.__class__ == DPMSolverMultistepScheduler
									# no warning should be thrown
									assert cap_logger.out == ""


							def    _snake_case     (							self			:Tuple						)      ->      List[str]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=					SampleObject()

									SCREAMING_SNAKE_CASE__								=					{k: v for k, v in config.config.items() if not k.startswith("""_"""						)}

									# make sure that default config has all keys in `_use_default_values`
									assert set(config_dict.keys()						) == set(config.config._use_default_values						)

									with tempfile.TemporaryDirectory() as tmpdirname:
											config.save_config(__A						)

											# now loading it with SampleObject2 should put f into `_use_default_values`
											SCREAMING_SNAKE_CASE__								=					SampleObjecta.from_config(__A						)

											assert "f" in config._use_default_values
											assert config.f == [1, 3]

									# now loading the config, should **NOT** use [1, 3] for `f`, but the default [1, 4] value
									# **BECAUSE** it is part of `config._use_default_values`
									SCREAMING_SNAKE_CASE__								=					SampleObjecta.from_config(config.config						)
									assert new_config.f == [5, 4]

									config.config._use_default_values.pop()
									SCREAMING_SNAKE_CASE__								=					SampleObjecta.from_config(config.config						)
									assert new_config_a.f == [1, 3]

									# Nevertheless "e" should still be correctly loaded to [1, 3] from SampleObject2 instead of defaulting to [1, 5]
									assert new_config_a.e == [1, 3]






from typing import TYPE_CHECKING

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


_lowerCamelCase       =	{
    'configuration_gptsan_japanese': ['GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP', 'GPTSanJapaneseConfig'],
    'tokenization_gptsan_japanese': ['GPTSanJapaneseTokenizer'],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	_lowerCamelCase       =	[
	    'GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST',
	    'GPTSanJapaneseForConditionalGeneration',
	    'GPTSanJapaneseModel',
	    'GPTSanJapanesePreTrainedModel',
	]
	_lowerCamelCase       =	[
	    'GPTSanJapaneseTokenizer',
	]


if TYPE_CHECKING:
	from .configuration_gptsan_japanese import GPTSAN_JAPANESE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTSanJapaneseConfig
	from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_gptsan_japanese import (
		    GPTSAN_JAPANESE_PRETRAINED_MODEL_ARCHIVE_LIST,
		    GPTSanJapaneseForConditionalGeneration,
		    GPTSanJapaneseModel,
		    GPTSanJapanesePreTrainedModel,
		)
		from .tokenization_gptsan_japanese import GPTSanJapaneseTokenizer


else:
	import sys

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