





'''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 lowerCamelCase    (a__       ):
  _lowercase	:						Tuple							       =					"""config.json"""







  @register_to_config
  def __init__(		self  ,  lowercase__=2  ,  lowercase__=5  ,  lowercase__=(2, 5)  ,  lowercase__="for diffusion"  ,  lowercase__=[1, 3]  ,  )		->    Optional[int]:






        """simple docstring"""





        pass





class lowerCamelCase    (a__       ):
  _lowercase	:						List[str]							       =					"""config.json"""







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






        """simple docstring"""





        pass





class lowerCamelCase    (a__       ):
  _lowercase	:						Optional[int]							       =					"""config.json"""







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






        """simple docstring"""





        pass





class lowerCamelCase    (a__       ):
  _lowercase	:						Tuple							       =					"""config.json"""







  @register_to_config
  def __init__(		self  ,  lowercase__=2  ,  lowercase__=5  ,  lowercase__=(2, 5)  ,  lowercase__="for diffusion"  ,  lowercase__=[1, 5]  ,  lowercase__=[5, 4]  ,  )		->    Optional[Any]:






        """simple docstring"""





        pass





class lowerCamelCase    (unittest.TestCase       ):







  def 					UpperCAmelCase_					(		self		)		->    Any:






        """simple docstring"""





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







  def 					UpperCAmelCase_					(		self		)		->    Tuple:






        """simple docstring"""





        _snake_case		:						List[str]         =  SampleObject()
        _snake_case		:						List[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]

        # init ignore private arguments
        _snake_case		:						Optional[int]         =  SampleObject(_name_or_path='''lalala'''		)
        _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]

        # can override default
        _snake_case		:						Dict         =  SampleObject(c=6		)
        _snake_case		:						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.
        _snake_case		:						Any         =  SampleObject(1  ,  c=6		)
        _snake_case		:						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 					UpperCAmelCase_					(		self		)		->    Tuple:






        """simple docstring"""





        _snake_case		:						str         =  SampleObject()
        _snake_case		:						Optional[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(lowercase__		)
              _snake_case		:						int         =  SampleObject.from_config(SampleObject.load_config(lowercase__		)		)
              _snake_case		:						Tuple         =  new_obj.config

        # unfreeze configs
        _snake_case		:						Optional[Any]         =  dict(lowercase__		)
        _snake_case		:						List[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 					UpperCAmelCase_					(		self		)		->    List[str]:






        """simple docstring"""





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

        with CaptureLogger(lowercase__		) as cap_logger:
              _snake_case		:						Dict         =  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 					UpperCAmelCase_					(		self		)		->    Any:






        """simple docstring"""





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

        with CaptureLogger(lowercase__		) 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 					UpperCAmelCase_					(		self		)		->    str:






        """simple docstring"""





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

        with CaptureLogger(lowercase__		) as cap_logger:
              _snake_case		:						Union[str, 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 					UpperCAmelCase_					(		self		)		->    int:






        """simple docstring"""





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

        with CaptureLogger(lowercase__		) as cap_logger:
              _snake_case		:						Optional[int]         =  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 					UpperCAmelCase_					(		self		)		->    Union[str, Any]:






        """simple docstring"""





        _snake_case		:						Union[str, Any]         =  logging.get_logger('''diffusers.configuration_utils'''		)
        # 30 for warning
        logger.setLevel(30		)

        with CaptureLogger(lowercase__		) as cap_logger:
              _snake_case		:						Dict         =  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:
              _snake_case		:						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 					UpperCAmelCase_					(		self		)		->    Dict:






        """simple docstring"""





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

        with CaptureLogger(lowercase__		) as cap_logger:
              _snake_case		:						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 					UpperCAmelCase_					(		self		)		->    Tuple:






        """simple docstring"""





        _snake_case		:						List[str]         =  SampleObject()

        _snake_case		:						List[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(lowercase__		)

              # now loading it with SampleObject2 should put f into `_use_default_values`
              _snake_case		:						Dict         =  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`
        _snake_case		:						str         =  SampleObjecta.from_config(config.config		)
        assert new_config.f == [5, 4]

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









'''simple docstring'''

from __future__ import annotations




def  _a     (				lowerCAmelCase_						):





      """simple docstring"""



      _snake_case		:						List[str]         =  sorted(lowerCAmelCase_						)
      _snake_case		:						Any         =  len(lowerCAmelCase_						)
      _snake_case		:						List[str]         =  length >> 1
      return (
          (sorted_list[mid_index] + sorted_list[mid_index - 1]) / 2
          if length % 2 == 0
          else sorted_list[mid_index]
      )




def  _a     (				):





      """simple docstring"""



      import doctest

      doctest.testmod()


if __name__ == "__main__":
   main()


