





'''simple docstring'''

from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available


@dataclass
class 			SCREAMING_SNAKE_CASE__	(					_UpperCamelCase						):







					"""simple docstring"""






					SCREAMING_SNAKE_CASE				=     {
					    'sld_warmup_steps': 15,
					    'sld_guidance_scale': 20,
					    'sld_threshold': 0.0,
					    'sld_momentum_scale': 0.0,
					    'sld_mom_beta': 0.0,
					}
					SCREAMING_SNAKE_CASE				=     {
					    'sld_warmup_steps': 10,
					    'sld_guidance_scale': 1_000,
					    'sld_threshold': 0.01,
					    'sld_momentum_scale': 0.3,
					    'sld_mom_beta': 0.4,
					}
					SCREAMING_SNAKE_CASE				=     {
					    'sld_warmup_steps': 7,
					    'sld_guidance_scale': 2_000,
					    'sld_threshold': 0.0_25,
					    'sld_momentum_scale': 0.5,
					    'sld_mom_beta': 0.7,
					}
					SCREAMING_SNAKE_CASE				=     {
					    'sld_warmup_steps': 0,
					    'sld_guidance_scale': 5_000,
					    'sld_threshold': 1.0,
					    'sld_momentum_scale': 0.5,
					    'sld_mom_beta': 0.7,
					}






@dataclass
class 			SCREAMING_SNAKE_CASE__	(					_UpperCamelCase						):







					"""simple docstring"""






					SCREAMING_SNAKE_CASE				=     42
					SCREAMING_SNAKE_CASE				=     42
					SCREAMING_SNAKE_CASE				=     42
					SCREAMING_SNAKE_CASE				=     42


if is_transformers_available() and is_torch_available():
			from .pipeline_stable_diffusion_safe import StableDiffusionPipelineSafe
			from .safety_checker import SafeStableDiffusionSafetyChecker





'''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 	__UpperCAmelCase				(				_UpperCamelCase     ):





       '''simple docstring'''



       __lowercase					:					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]    ,     )		->     Union[str, Any]:
           pass




class 	__UpperCAmelCase				(				_UpperCamelCase     ):





       '''simple docstring'''



       __lowercase					:					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, 3]    ,     )		->     Union[str, Any]:
           pass




class 	__UpperCAmelCase				(				_UpperCamelCase     ):





       '''simple docstring'''



       __lowercase					:					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]    ,     )		->     Dict:
           pass




class 	__UpperCAmelCase				(				_UpperCamelCase     ):





       '''simple docstring'''



       __lowercase					:					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, 5]    ,     _SCREAMING_SNAKE_CASE=[5, 4]    ,     )		->     List[str]:
           pass




class 	__UpperCAmelCase				(				unittest.TestCase     ):





       '''simple docstring'''



       def 					__A       (      self )		->     Optional[int]:
           with self.assertRaises(_SCREAMING_SNAKE_CASE ):
               ConfigMixin.load_config('''dummy_path''' )

       def 					__A       (      self )		->     Union[str, Any]:
           A_     =   SampleObject()
           A_     =   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
           A_     =   SampleObject(_name_or_path='''lalala''' )
           A_     =   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
           A_     =   SampleObject(c=6 )
           A_     =   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.
           A_     =   SampleObject(1    ,     c=6 )
           A_     =   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 )		->     int:
           A_     =   SampleObject()
           A_     =   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 )
               A_     =   SampleObject.from_config(SampleObject.load_config(_SCREAMING_SNAKE_CASE ) )
               A_     =   new_obj.config

           # unfreeze configs
           A_     =   dict(_SCREAMING_SNAKE_CASE )
           A_     =   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 					__A       (      self )		->     List[Any]:
           A_     =   logging.get_logger('''diffusers.configuration_utils''' )
           # 30 for warning
           logger.setLevel(30 )

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger:
               A_     =   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]:
           A_     =   logging.get_logger('''diffusers.configuration_utils''' )
           # 30 for warning
           logger.setLevel(30 )

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

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

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger:
               A_     =   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 )		->     Tuple:
           A_     =   logging.get_logger('''diffusers.configuration_utils''' )
           # 30 for warning
           logger.setLevel(30 )

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger:
               A_     =   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:
               A_     =   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]:
           A_     =   logging.get_logger('''diffusers.configuration_utils''' )
           # 30 for warning
           logger.setLevel(30 )

           with CaptureLogger(_SCREAMING_SNAKE_CASE ) as cap_logger:
               A_     =   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[int]:
           # 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],

           A_     =   SampleObject()

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

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






