




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 						SCREAMING_SNAKE_CASE__		(_a ):
     lowercase_   :			int   =   "config.json"
     @register_to_config
     def __init__(	self  :		int					,	__lowerCamelCase  :		str=2					,	__lowerCamelCase  :		List[str]=5					,	__lowerCamelCase  :		List[str]=(2, 5)					,	__lowerCamelCase  :		List[str]="for diffusion"					,	__lowerCamelCase  :		Optional[int]=[1, 3]					,	):



       """simple docstring"""
       pass





class 						SCREAMING_SNAKE_CASE__		(_a ):
     lowercase_   :			Optional[Any]   =   "config.json"
     @register_to_config
     def __init__(	self  :		Dict					,	__lowerCamelCase  :		List[str]=2					,	__lowerCamelCase  :		List[Any]=5					,	__lowerCamelCase  :		List[Any]=(2, 5)					,	__lowerCamelCase  :		Any="for diffusion"					,	__lowerCamelCase  :		List[str]=[1, 3]					,	):



       """simple docstring"""
       pass





class 						SCREAMING_SNAKE_CASE__		(_a ):
     lowercase_   :			Union[str, Any]   =   "config.json"
     @register_to_config
     def __init__(	self  :		Dict					,	__lowerCamelCase  :		Optional[Any]=2					,	__lowerCamelCase  :		Tuple=5					,	__lowerCamelCase  :		Tuple=(2, 5)					,	__lowerCamelCase  :		str="for diffusion"					,	__lowerCamelCase  :		str=[1, 3]					,	__lowerCamelCase  :		int=[1, 3]					,	):



       """simple docstring"""
       pass





class 						SCREAMING_SNAKE_CASE__		(_a ):
     lowercase_   :			Dict   =   "config.json"
     @register_to_config
     def __init__(	self  :		Optional[int]					,	__lowerCamelCase  :		Optional[int]=2					,	__lowerCamelCase  :		int=5					,	__lowerCamelCase  :		Any=(2, 5)					,	__lowerCamelCase  :		Dict="for diffusion"					,	__lowerCamelCase  :		str=[1, 5]					,	__lowerCamelCase  :		int=[5, 4]					,	):



       """simple docstring"""
       pass





class 						SCREAMING_SNAKE_CASE__		(unittest.TestCase ):
     def 					A__			(	self  :		Optional[Any]	):



       """simple docstring"""
       with self.assertRaises(__lowerCamelCase	):
         ConfigMixin.load_config('''dummy_path'''	)
     def 					A__			(	self  :		List[Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			SampleObject()
       lowerCAmelCase__								=			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
       lowerCAmelCase__								=			SampleObject(_name_or_path='''lalala'''	)
       lowerCAmelCase__								=			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
       lowerCAmelCase__								=			SampleObject(c=6	)
       lowerCAmelCase__								=			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.
       lowerCAmelCase__								=			SampleObject(1					,	c=6	)
       lowerCAmelCase__								=			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  :		Tuple	):



       """simple docstring"""
       lowerCAmelCase__								=			SampleObject()
       lowerCAmelCase__								=			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(__lowerCamelCase	)
         lowerCAmelCase__								=			SampleObject.from_config(SampleObject.load_config(__lowerCamelCase	)	)
         lowerCAmelCase__								=			new_obj.config

       # unfreeze configs
       lowerCAmelCase__								=			dict(__lowerCamelCase	)
       lowerCAmelCase__								=			dict(__lowerCamelCase	)

       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  :		Any	):



       """simple docstring"""
       lowerCAmelCase__								=			logging.get_logger('''diffusers.configuration_utils'''	)
       # 30 for warning
       logger.setLevel(30	)

       with CaptureLogger(__lowerCamelCase	) as cap_logger:
         lowerCAmelCase__								=			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  :		Dict	):



       """simple docstring"""
       lowerCAmelCase__								=			logging.get_logger('''diffusers.configuration_utils'''	)
       # 30 for warning
       logger.setLevel(30	)

       with CaptureLogger(__lowerCamelCase	) as cap_logger:
         lowerCAmelCase__								=			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  :		List[Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			logging.get_logger('''diffusers.configuration_utils'''	)
       # 30 for warning
       logger.setLevel(30	)

       with CaptureLogger(__lowerCamelCase	) as cap_logger:
         lowerCAmelCase__								=			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  :		Union[str, Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			logging.get_logger('''diffusers.configuration_utils'''	)
       # 30 for warning
       logger.setLevel(30	)

       with CaptureLogger(__lowerCamelCase	) as cap_logger:
         lowerCAmelCase__								=			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  :		List[Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			logging.get_logger('''diffusers.configuration_utils'''	)
       # 30 for warning
       logger.setLevel(30	)

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

       with CaptureLogger(__lowerCamelCase	) as cap_logger_a:
         lowerCAmelCase__								=			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  :		Union[str, Any]	):



       """simple docstring"""
       lowerCAmelCase__								=			logging.get_logger('''diffusers.configuration_utils'''	)
       # 30 for warning
       logger.setLevel(30	)

       with CaptureLogger(__lowerCamelCase	) as cap_logger:
         lowerCAmelCase__								=			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  :		List[Any]	):



       """simple docstring"""
       # 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],

       lowerCAmelCase__								=			SampleObject()

       lowerCAmelCase__								=			{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(__lowerCamelCase	)

         # now loading it with SampleObject2 should put f into `_use_default_values`
         lowerCAmelCase__								=			SampleObjecta.from_config(__lowerCamelCase	)

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

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







import json

import requests

from .fetch_github_info import AUTHENTICATED_USER_ENDPOINT, fetch_github_info
def 		a_       (   __lowerCAmelCase							):





  class 						SCREAMING_SNAKE_CASE__		:
       def __init__(	self  :		List[str]					,	__lowerCamelCase  :		Any	):



         """simple docstring"""
         assert isinstance(__lowerCamelCase					,	(bytes, str)	)
         lowerCAmelCase__								=			content



       def 					A__			(	self  :		int	):



         """simple docstring"""
         return json.loads(self.content	)

  def mock_response(*__lowerCAmelCase      ,   **__lowerCAmelCase							):
    assert args[0] == AUTHENTICATED_USER_ENDPOINT
    assert "Authorization" in kwargs["headers"]
    assert kwargs["headers"]["Authorization"].startswith('''token '''							)
    assert "Accept" in kwargs["headers"]
    return FakeResponse(B'''{"login":"test","id":1}'''							)

  monkeypatch.setattr(__lowerCAmelCase      ,   '''get'''      ,   __lowerCAmelCase							)
  lowerCAmelCase__								=			fetch_github_info('''token'''							)
  assert result["login"] == "test"
  assert result["id"] == 1

