



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_	(						snake_case__							):
							UpperCAmelCase__       :      str       =						'config.json'
							@register_to_config
							def __init__(    self,    SCREAMING_SNAKE_CASE_=2,    SCREAMING_SNAKE_CASE_=5,    SCREAMING_SNAKE_CASE_=(2, 5),    SCREAMING_SNAKE_CASE_="for diffusion",    SCREAMING_SNAKE_CASE_=[1, 3],    )  ->	int:
										pass






class        lowerCAmelCase_	(						snake_case__							):
							UpperCAmelCase__       :      Union[str, Any]       =						'config.json'
							@register_to_config
							def __init__(    self,    SCREAMING_SNAKE_CASE_=2,    SCREAMING_SNAKE_CASE_=5,    SCREAMING_SNAKE_CASE_=(2, 5),    SCREAMING_SNAKE_CASE_="for diffusion",    SCREAMING_SNAKE_CASE_=[1, 3],    )  ->	List[str]:
										pass






class        lowerCAmelCase_	(						snake_case__							):
							UpperCAmelCase__       :      Optional[Any]       =						'config.json'
							@register_to_config
							def __init__(    self,    SCREAMING_SNAKE_CASE_=2,    SCREAMING_SNAKE_CASE_=5,    SCREAMING_SNAKE_CASE_=(2, 5),    SCREAMING_SNAKE_CASE_="for diffusion",    SCREAMING_SNAKE_CASE_=[1, 3],    SCREAMING_SNAKE_CASE_=[1, 3],    )  ->	Any:
										pass






class        lowerCAmelCase_	(						snake_case__							):
							UpperCAmelCase__       :      Tuple       =						'config.json'
							@register_to_config
							def __init__(    self,    SCREAMING_SNAKE_CASE_=2,    SCREAMING_SNAKE_CASE_=5,    SCREAMING_SNAKE_CASE_=(2, 5),    SCREAMING_SNAKE_CASE_="for diffusion",    SCREAMING_SNAKE_CASE_=[1, 5],    SCREAMING_SNAKE_CASE_=[5, 4],    )  ->	Any:
										pass






class        lowerCAmelCase_	(						unittest.TestCase							):
							def       snake_case_ (    self )  ->	List[Any]:
										with self.assertRaises(SCREAMING_SNAKE_CASE_ ):
													ConfigMixin.load_config('dummy_path' )
							def       snake_case_ (    self )  ->	List[Any]:
										UpperCamelCase					:						List[Any]					=			SampleObject()
										UpperCamelCase					:						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]

										# init ignore private arguments
										UpperCamelCase					:						Any					=			SampleObject(_name_or_path='lalala' )
										UpperCamelCase					:						int					=			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					:						Union[str, Any]					=			SampleObject(c=6 )
										UpperCamelCase					:						List[Any]					=			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					:						Tuple					=			SampleObject(1,    c=6 )
										UpperCamelCase					:						Union[str, 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       snake_case_ (    self )  ->	Any:
										UpperCamelCase					:						int					=			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(SCREAMING_SNAKE_CASE_ )
													UpperCamelCase					:						str					=			SampleObject.from_config(SampleObject.load_config(SCREAMING_SNAKE_CASE_ ) )
													UpperCamelCase					:						Optional[Any]					=			new_obj.config

										# unfreeze configs
										UpperCamelCase					:						int					=			dict(SCREAMING_SNAKE_CASE_ )
										UpperCamelCase					:						str					=			dict(SCREAMING_SNAKE_CASE_ )

										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 )  ->	Optional[int]:
										UpperCamelCase					:						List[str]					=			logging.get_logger('diffusers.configuration_utils' )
										# 30 for warning
										logger.setLevel(30 )

										with CaptureLogger(SCREAMING_SNAKE_CASE_ ) as cap_logger:
													UpperCamelCase					:						List[str]					=			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 )  ->	int:
										UpperCamelCase					:						Optional[Any]					=			logging.get_logger('diffusers.configuration_utils' )
										# 30 for warning
										logger.setLevel(30 )

										with CaptureLogger(SCREAMING_SNAKE_CASE_ ) as cap_logger:
													UpperCamelCase					:						List[str]					=			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 )  ->	Union[str, Any]:
										UpperCamelCase					:						str					=			logging.get_logger('diffusers.configuration_utils' )
										# 30 for warning
										logger.setLevel(30 )

										with CaptureLogger(SCREAMING_SNAKE_CASE_ ) as cap_logger:
													UpperCamelCase					:						List[Any]					=			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 )  ->	List[str]:
										UpperCamelCase					:						Optional[int]					=			logging.get_logger('diffusers.configuration_utils' )
										# 30 for warning
										logger.setLevel(30 )

										with CaptureLogger(SCREAMING_SNAKE_CASE_ ) as cap_logger:
													UpperCamelCase					:						List[Any]					=			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 )  ->	List[str]:
										UpperCamelCase					:						Tuple					=			logging.get_logger('diffusers.configuration_utils' )
										# 30 for warning
										logger.setLevel(30 )

										with CaptureLogger(SCREAMING_SNAKE_CASE_ ) as cap_logger:
													UpperCamelCase					:						Optional[Any]					=			DDPMScheduler.from_pretrained(
													    'hf-internal-testing/tiny-stable-diffusion-torch',    subfolder='scheduler',    prediction_type='sample',    beta_end=8,    )

										with CaptureLogger(SCREAMING_SNAKE_CASE_ ) 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       snake_case_ (    self )  ->	Tuple:
										UpperCamelCase					:						Optional[Any]					=			logging.get_logger('diffusers.configuration_utils' )
										# 30 for warning
										logger.setLevel(30 )

										with CaptureLogger(SCREAMING_SNAKE_CASE_ ) as cap_logger:
													UpperCamelCase					:						Optional[Any]					=			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 )  ->	Dict:
										# let's first save a config that should be in the form
										#    a=2,
										#    b=5,
										#    c=(2, 5),
										#    d="for diffusion",
										#    e=[1, 3],

										UpperCamelCase					:						Optional[Any]					=			SampleObject()

										UpperCamelCase					:						str					=			{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(SCREAMING_SNAKE_CASE_ )

													# now loading it with SampleObject2 should put f into `_use_default_values`
													UpperCamelCase					:						Optional[Any]					=			SampleObjecta.from_config(SCREAMING_SNAKE_CASE_ )

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

										config.config._use_default_values.pop()
										UpperCamelCase					:						Optional[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]








from __future__ import annotations

import sys
def 	UpperCamelCase			(     snake_case__ :					int ,  snake_case__ :					int			)			->  tuple[int, int]:
   # base cases
   if abs(snake_case__			) == 1:
      return a, 0
   elif abs(snake_case__			) == 1:
      return 0, b

   UpperCamelCase			,  UpperCamelCase					:						Dict					=			a, b
   UpperCamelCase			,  UpperCamelCase					:						int					=			1, 0
   UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			0, 1

   while remainder != 0:
      UpperCamelCase					:						str					=			old_remainder // remainder
      UpperCamelCase			,  UpperCamelCase					:						Union[str, Any]					=			remainder, old_remainder - quotient * remainder
      UpperCamelCase			,  UpperCamelCase					:						List[Any]					=			coeff_a, old_coeff_a - quotient * coeff_a
      UpperCamelCase			,  UpperCamelCase					:						Optional[Any]					=			coeff_b, old_coeff_b - quotient * coeff_b

   # sign correction for negative numbers
   if a < 0:
      UpperCamelCase					:						Dict					=			-old_coeff_a
   if b < 0:
      UpperCamelCase					:						Any					=			-old_coeff_b

   return old_coeff_a, old_coeff_b
def 	UpperCamelCase			(     )			->  Tuple:
   if len(sys.argv			) < 3:
      print('2 integer arguments required'			)
      return 1
   UpperCamelCase					:						Union[str, Any]					=			int(sys.argv[1]			)
   UpperCamelCase					:						Optional[int]					=			int(sys.argv[2]			)
   print(extended_euclidean_algorithm(snake_case__ ,  snake_case__			)			)
   return 0


if __name__ == "__main__":
    raise SystemExit(main())



