code: 
  '''simple docstring'''
  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   snake_case__					(			__SCREAMING_SNAKE_CASE				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		lowerCamelCase           =	"""config.json"""
  
  
  
  		@register_to_config
  		def __init__(			self							: Union[str, Any]     ,  UpperCamelCase__							: Optional[int]=2     ,  UpperCamelCase__							: Union[str, Any]=5     ,  UpperCamelCase__							: Any=(2, 5)     ,  UpperCamelCase__							: Union[str, Any]="for diffusion"     ,  UpperCamelCase__							: List[str]=[1, 3]     ,  )	-> Tuple:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				pass
  
  
  
  
  
  
  
  class   snake_case__					(			__SCREAMING_SNAKE_CASE				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		lowerCamelCase           =	"""config.json"""
  
  
  
  		@register_to_config
  		def __init__(			self							: Dict     ,  UpperCamelCase__							: Optional[Any]=2     ,  UpperCamelCase__							: Any=5     ,  UpperCamelCase__							: List[Any]=(2, 5)     ,  UpperCamelCase__							: Any="for diffusion"     ,  UpperCamelCase__							: List[Any]=[1, 3]     ,  )	-> int:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				pass
  
  
  
  
  
  
  
  class   snake_case__					(			__SCREAMING_SNAKE_CASE				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		lowerCamelCase           =	"""config.json"""
  
  
  
  		@register_to_config
  		def __init__(			self							: Union[str, Any]     ,  UpperCamelCase__							: str=2     ,  UpperCamelCase__							: Tuple=5     ,  UpperCamelCase__							: int=(2, 5)     ,  UpperCamelCase__							: Optional[Any]="for diffusion"     ,  UpperCamelCase__							: Optional[Any]=[1, 3]     ,  UpperCamelCase__							: Dict=[1, 3]     ,  )	-> List[Any]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				pass
  
  
  
  
  
  
  
  class   snake_case__					(			__SCREAMING_SNAKE_CASE				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		lowerCamelCase           =	"""config.json"""
  
  
  
  		@register_to_config
  		def __init__(			self							: Union[str, Any]     ,  UpperCamelCase__							: str=2     ,  UpperCamelCase__							: List[Any]=5     ,  UpperCamelCase__							: List[Any]=(2, 5)     ,  UpperCamelCase__							: Any="for diffusion"     ,  UpperCamelCase__							: List[Any]=[1, 5]     ,  UpperCamelCase__							: str=[5, 4]     ,  )	-> str:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				pass
  
  
  
  
  
  
  
  class   snake_case__					(			unittest.TestCase				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		def 			lowerCAmelCase							(			self							: str			)	-> Optional[int]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				with self.assertRaises(UpperCamelCase__			):
  						ConfigMixin.load_config('''dummy_path'''			)
  
  
  
  		def 			lowerCAmelCase							(			self							: List[str]			)	-> Optional[Any]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Optional[Any]     =	SampleObject()
  				snake_case     :					Tuple     =	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
  				snake_case     :					List[Any]     =	SampleObject(_name_or_path='''lalala'''			)
  				snake_case     :					List[Any]     =	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
  				snake_case     :					str     =	SampleObject(c=6			)
  				snake_case     :					Dict     =	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.
  				snake_case     :					str     =	SampleObject(1     ,  c=6			)
  				snake_case     :					List[Any]     =	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 			lowerCAmelCase							(			self							: Union[str, Any]			)	-> Tuple:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Any     =	SampleObject()
  				snake_case     :					Union[str, Any]     =	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(UpperCamelCase__			)
  						snake_case     :					Optional[int]     =	SampleObject.from_config(SampleObject.load_config(UpperCamelCase__			)			)
  						snake_case     :					str     =	new_obj.config
  
  				# unfreeze configs
  				snake_case     :					str     =	dict(UpperCamelCase__			)
  				snake_case     :					str     =	dict(UpperCamelCase__			)
  
  				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 			lowerCAmelCase							(			self							: int			)	-> Any:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					List[Any]     =	logging.get_logger('''diffusers.configuration_utils'''			)
  				# 30 for warning
  				logger.setLevel(30			)
  
  				with CaptureLogger(UpperCamelCase__			) as cap_logger:
  						snake_case     :					Tuple     =	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 			lowerCAmelCase							(			self							: List[Any]			)	-> Optional[int]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Tuple     =	logging.get_logger('''diffusers.configuration_utils'''			)
  				# 30 for warning
  				logger.setLevel(30			)
  
  				with CaptureLogger(UpperCamelCase__			) as cap_logger:
  						snake_case     :					Optional[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 			lowerCAmelCase							(			self							: Optional[Any]			)	-> Optional[Any]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					List[str]     =	logging.get_logger('''diffusers.configuration_utils'''			)
  				# 30 for warning
  				logger.setLevel(30			)
  
  				with CaptureLogger(UpperCamelCase__			) as cap_logger:
  						snake_case     :					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 			lowerCAmelCase							(			self							: Tuple			)	-> int:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Optional[Any]     =	logging.get_logger('''diffusers.configuration_utils'''			)
  				# 30 for warning
  				logger.setLevel(30			)
  
  				with CaptureLogger(UpperCamelCase__			) as cap_logger:
  						snake_case     :					List[str]     =	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 			lowerCAmelCase							(			self							: Optional[Any]			)	-> Any:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					List[Any]     =	logging.get_logger('''diffusers.configuration_utils'''			)
  				# 30 for warning
  				logger.setLevel(30			)
  
  				with CaptureLogger(UpperCamelCase__			) as cap_logger:
  						snake_case     :					List[Any]     =	DDPMScheduler.from_pretrained(
  						    '''hf-internal-testing/tiny-stable-diffusion-torch'''     ,  subfolder='''scheduler'''     ,  prediction_type='''sample'''     ,  beta_end=8     ,  )
  
  				with CaptureLogger(UpperCamelCase__			) as cap_logger_a:
  						snake_case     :					List[str]     =	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 			lowerCAmelCase							(			self							: List[Any]			)	-> List[Any]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					str     =	logging.get_logger('''diffusers.configuration_utils'''			)
  				# 30 for warning
  				logger.setLevel(30			)
  
  				with CaptureLogger(UpperCamelCase__			) as cap_logger:
  						snake_case     :					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 			lowerCAmelCase							(			self							: Optional[Any]			)	-> str:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Union[str, Any]     =	SampleObject()
  
  				snake_case     :					Dict     =	{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(UpperCamelCase__			)
  
  						# now loading it with SampleObject2 should put f into `_use_default_values`
  						snake_case     :					Any     =	SampleObjecta.from_config(UpperCamelCase__			)
  
  						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`
  				snake_case     :					Dict     =	SampleObjecta.from_config(config.config			)
  				assert new_config.f == [5, 4]
  
  				config.config._use_default_values.pop()
  				snake_case     :					Any     =	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]
  
  
  
style_context: 
  '''simple docstring'''
  def       _UpperCamelCase	(					)     ->       int:
  
  
  		'''simple docstring'''
  
  
  		for a in range(300 ):
  				for b in range(a + 1   ,					400 ):
  						for c in range(b + 1   ,					500 ):
  								if (a + b + c) == 1000 and (a**2) + (b**2) == (c**2):
  										return a * b * c
  
  		return -1
  
  
  
  
  def       _UpperCamelCase	(					)     ->       int:
  
  
  		'''simple docstring'''
  
  
  		for a in range(300 ):
  				for b in range(400 ):
  						snake_case     :					Dict     =	1000 - a - b
  						if a < b < c and (a**2) + (b**2) == (c**2):
  								return a * b * c
  
  		return -1
  
  
  
  
  def       _UpperCamelCase	(					)     ->       None:
  
  
  		'''simple docstring'''
  
  
  		import timeit
  
  		print(
  		    timeit.timeit('''solution()'''   ,					setup='''from __main__ import solution'''   ,					number=1000 ) )
  		print(
  		    timeit.timeit(
  		        '''solution_fast()'''   ,					setup='''from __main__ import solution_fast'''   ,					number=1000 ) )
  
  
  if __name__ == "__main__":
  						print(f"{solution() = }")
  
  
  