
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 						__lowercase(     _lowerCamelCase   ):


       """simple docstring"""







       UpperCamelCase_				 =							'''config.json'''



       @register_to_config
       def __init__(     self					:			Tuple  ,      _lowerCAmelCase					:			Dict=2  ,      _lowerCAmelCase					:			Union[str, Any]=5  ,      _lowerCAmelCase					:			List[Any]=(2, 5)  ,      _lowerCAmelCase					:			List[Any]="for diffusion"  ,      _lowerCAmelCase					:			Dict=[1, 3]  ,      )					->   List[str]:
         pass





class 						__lowercase(     _lowerCamelCase   ):


       """simple docstring"""







       UpperCamelCase_				 =							'''config.json'''



       @register_to_config
       def __init__(     self					:			Optional[Any]  ,      _lowerCAmelCase					:			Optional[Any]=2  ,      _lowerCAmelCase					:			List[Any]=5  ,      _lowerCAmelCase					:			Any=(2, 5)  ,      _lowerCAmelCase					:			List[str]="for diffusion"  ,      _lowerCAmelCase					:			Tuple=[1, 3]  ,      )					->   Tuple:
         pass





class 						__lowercase(     _lowerCamelCase   ):


       """simple docstring"""







       UpperCamelCase_				 =							'''config.json'''



       @register_to_config
       def __init__(     self					:			List[Any]  ,      _lowerCAmelCase					:			Dict=2  ,      _lowerCAmelCase					:			Tuple=5  ,      _lowerCAmelCase					:			Union[str, Any]=(2, 5)  ,      _lowerCAmelCase					:			List[Any]="for diffusion"  ,      _lowerCAmelCase					:			int=[1, 3]  ,      _lowerCAmelCase					:			Optional[Any]=[1, 3]  ,      )					->   Tuple:
         pass





class 						__lowercase(     _lowerCamelCase   ):


       """simple docstring"""







       UpperCamelCase_				 =							'''config.json'''



       @register_to_config
       def __init__(     self					:			int  ,      _lowerCAmelCase					:			Optional[int]=2  ,      _lowerCAmelCase					:			int=5  ,      _lowerCAmelCase					:			Any=(2, 5)  ,      _lowerCAmelCase					:			List[str]="for diffusion"  ,      _lowerCAmelCase					:			Union[str, Any]=[1, 5]  ,      _lowerCAmelCase					:			Optional[Any]=[5, 4]  ,      )					->   Any:
         pass





class 						__lowercase(     unittest.TestCase   ):


       """simple docstring"""







       def SCREAMING_SNAKE_CASE_				(     self					:			Tuple       )					->   List[str]:
         with self.assertRaises(_UpperCamelCase       ):
           ConfigMixin.load_config('dummy_path'       )



       def SCREAMING_SNAKE_CASE_				(     self					:			Tuple       )					->   Dict:
         _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 SCREAMING_SNAKE_CASE_				(     self					:			Optional[Any]       )					->   Union[str, Any]:
         _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(_UpperCamelCase       )
           _lowerCAmelCase						=		SampleObject.from_config(SampleObject.load_config(_UpperCamelCase       )       )
           _lowerCAmelCase						=		new_obj.config

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

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

         with CaptureLogger(_UpperCamelCase       ) 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 SCREAMING_SNAKE_CASE_				(     self					:			Dict       )					->   Tuple:
         _lowerCAmelCase						=		logging.get_logger('diffusers.configuration_utils'       )
         # 30 for warning
         logger.setLevel(30       )

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

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

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

         with CaptureLogger(_UpperCamelCase       ) 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 SCREAMING_SNAKE_CASE_				(     self					:			Dict       )					->   Tuple:
         # 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(_UpperCamelCase       )

           # now loading it with SampleObject2 should put f into `_use_default_values`
           _lowerCAmelCase						=		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`
         _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]







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


snake_case__   :				Tuple						=	{
    'configuration_realm': ['REALM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'RealmConfig'],
    'tokenization_realm': ['RealmTokenizer'],
}

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       snake_case__   :				Tuple						=	['RealmTokenizerFast']

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       snake_case__   :				str						=	[
           'REALM_PRETRAINED_MODEL_ARCHIVE_LIST',
           'RealmEmbedder',
           'RealmForOpenQA',
           'RealmKnowledgeAugEncoder',
           'RealmPreTrainedModel',
           'RealmReader',
           'RealmScorer',
           'load_tf_weights_in_realm',
       ]
       snake_case__   :				Any						=	['RealmRetriever']


if TYPE_CHECKING:
       from .configuration_realm import REALM_PRETRAINED_CONFIG_ARCHIVE_MAP, RealmConfig
       from .tokenization_realm import RealmTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_realm import RealmTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_realm import (
                  REALM_PRETRAINED_MODEL_ARCHIVE_LIST,
                  RealmEmbedder,
                  RealmForOpenQA,
                  RealmKnowledgeAugEncoder,
                  RealmPreTrainedModel,
                  RealmReader,
                  RealmScorer,
                  load_tf_weights_in_realm,
              )
              from .retrieval_realm import RealmRetriever


else:
       import sys

       snake_case__   :				Any						=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





