



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 							lowerCAmelCase_		(		UpperCAmelCase__     ):
		SCREAMING_SNAKE_CASE_       :			Union[str, Any]					       =	"""config.json"""







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


						'''simple docstring'''







						pass





class 							lowerCAmelCase_		(		UpperCAmelCase__     ):
		SCREAMING_SNAKE_CASE_       :			int					       =	"""config.json"""







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


						'''simple docstring'''







						pass





class 							lowerCAmelCase_		(		UpperCAmelCase__     ):
		SCREAMING_SNAKE_CASE_       :			int					       =	"""config.json"""







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


						'''simple docstring'''







						pass





class 							lowerCAmelCase_		(		UpperCAmelCase__     ):
		SCREAMING_SNAKE_CASE_       :			Optional[Any]					       =	"""config.json"""







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


						'''simple docstring'''







						pass





class 							lowerCAmelCase_		(		unittest.TestCase     ):







		def 					a_  (    self  :   Tuple					)       ->		str:


						'''simple docstring'''







						with self.assertRaises(__lowercase					):
										ConfigMixin.load_config('''dummy_path'''					)







		def 					a_  (    self  :   Optional[int]					)       ->		Optional[int]:


						'''simple docstring'''







						_UpperCAmelCase						:  List[str]     					=	SampleObject()
						_UpperCAmelCase						:  Dict     					=	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
						_UpperCAmelCase						:  List[str]     					=	SampleObject(_name_or_path='''lalala'''					)
						_UpperCAmelCase						:  Dict     					=	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
						_UpperCAmelCase						:  List[Any]     					=	SampleObject(c=6					)
						_UpperCAmelCase						:  Optional[int]     					=	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.
						_UpperCAmelCase						:  Optional[Any]     					=	SampleObject(1       ,		c=6					)
						_UpperCAmelCase						:  Dict     					=	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 					a_  (    self  :   Optional[int]					)       ->		int:


						'''simple docstring'''







						_UpperCAmelCase						:  List[Any]     					=	SampleObject()
						_UpperCAmelCase						:  str     					=	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(__lowercase					)
										_UpperCAmelCase						:  int     					=	SampleObject.from_config(SampleObject.load_config(__lowercase					)					)
										_UpperCAmelCase						:  Optional[Any]     					=	new_obj.config

						# unfreeze configs
						_UpperCAmelCase						:  str     					=	dict(__lowercase					)
						_UpperCAmelCase						:  Any     					=	dict(__lowercase					)

						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 					a_  (    self  :   Tuple					)       ->		List[str]:


						'''simple docstring'''







						_UpperCAmelCase						:  Optional[Any]     					=	logging.get_logger('''diffusers.configuration_utils'''					)
						# 30 for warning
						logger.setLevel(30					)

						with CaptureLogger(__lowercase					) as cap_logger:
										_UpperCAmelCase						:  int     					=	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 					a_  (    self  :   List[str]					)       ->		Optional[Any]:


						'''simple docstring'''







						_UpperCAmelCase						:  List[Any]     					=	logging.get_logger('''diffusers.configuration_utils'''					)
						# 30 for warning
						logger.setLevel(30					)

						with CaptureLogger(__lowercase					) as cap_logger:
										_UpperCAmelCase						:  Any     					=	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 					a_  (    self  :   Optional[int]					)       ->		Any:


						'''simple docstring'''







						_UpperCAmelCase						:  Tuple     					=	logging.get_logger('''diffusers.configuration_utils'''					)
						# 30 for warning
						logger.setLevel(30					)

						with CaptureLogger(__lowercase					) as cap_logger:
										_UpperCAmelCase						:  Optional[int]     					=	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 					a_  (    self  :   Tuple					)       ->		List[Any]:


						'''simple docstring'''







						_UpperCAmelCase						:  Any     					=	logging.get_logger('''diffusers.configuration_utils'''					)
						# 30 for warning
						logger.setLevel(30					)

						with CaptureLogger(__lowercase					) as cap_logger:
										_UpperCAmelCase						:  Dict     					=	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 					a_  (    self  :   int					)       ->		Tuple:


						'''simple docstring'''







						_UpperCAmelCase						:  Optional[int]     					=	logging.get_logger('''diffusers.configuration_utils'''					)
						# 30 for warning
						logger.setLevel(30					)

						with CaptureLogger(__lowercase					) as cap_logger:
										_UpperCAmelCase						:  int     					=	DDPMScheduler.from_pretrained(
										    '''hf-internal-testing/tiny-stable-diffusion-torch'''       ,		subfolder='''scheduler'''       ,		prediction_type='''sample'''       ,		beta_end=8       ,		)

						with CaptureLogger(__lowercase					) as cap_logger_a:
										_UpperCAmelCase						:  Tuple     					=	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 					a_  (    self  :   List[Any]					)       ->		int:


						'''simple docstring'''







						_UpperCAmelCase						:  Tuple     					=	logging.get_logger('''diffusers.configuration_utils'''					)
						# 30 for warning
						logger.setLevel(30					)

						with CaptureLogger(__lowercase					) as cap_logger:
										_UpperCAmelCase						:  List[str]     					=	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 					a_  (    self  :   Optional[Any]					)       ->		Optional[Any]:


						'''simple docstring'''







						_UpperCAmelCase						:  Dict     					=	SampleObject()

						_UpperCAmelCase						:  Optional[int]     					=	{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(__lowercase					)

										# now loading it with SampleObject2 should put f into `_use_default_values`
										_UpperCAmelCase						:  List[Any]     					=	SampleObjecta.from_config(__lowercase					)

										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`
						_UpperCAmelCase						:  List[Any]     					=	SampleObjecta.from_config(config.config					)
						assert new_config.f == [5, 4]

						config.config._use_default_values.pop()
						_UpperCAmelCase						:  int     					=	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]




def       lowerCAmelCase			(		lowerCAmelCase_			, lowerCAmelCase_			)->			set:
				assert isinstance(lowerCAmelCase_			, lowerCAmelCase_			), f"""The input value of [set_a={set_a}] is not a set"""
				assert isinstance(lowerCAmelCase_			, lowerCAmelCase_			), f"""The input value of [set_b={set_b}] is not a set"""

				return {a + b for a in set_a for b in set_b}


if __name__ == "__main__":
						from doctest import testmod

						testmod()