


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    A_   ( A__     ):







 """simple docstring"""





 _UpperCamelCase				: Optional[int]      =					'''config.json'''
 @register_to_config
 def __init__(			self					: Optional[int]       ,    _a					: str=2       ,    _a					: Any=5       ,    _a					: Any=(2, 5)       ,    _a					: int="for diffusion"       ,    _a					: str=[1, 3]       ,    )    ->			Optional[int]:
      pass




class    A_   ( A__     ):







 """simple docstring"""





 _UpperCamelCase				: List[Any]      =					'''config.json'''
 @register_to_config
 def __init__(			self					: str       ,    _a					: Optional[Any]=2       ,    _a					: Union[str, Any]=5       ,    _a					: Tuple=(2, 5)       ,    _a					: List[Any]="for diffusion"       ,    _a					: List[Any]=[1, 3]       ,    )    ->			Optional[Any]:
      pass




class    A_   ( A__     ):







 """simple docstring"""





 _UpperCamelCase				: int      =					'''config.json'''
 @register_to_config
 def __init__(			self					: str       ,    _a					: Union[str, Any]=2       ,    _a					: Optional[Any]=5       ,    _a					: str=(2, 5)       ,    _a					: Dict="for diffusion"       ,    _a					: Tuple=[1, 3]       ,    _a					: Any=[1, 3]       ,    )    ->			str:
      pass




class    A_   ( A__     ):







 """simple docstring"""





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




class    A_   ( unittest.TestCase     ):







 """simple docstring"""





 def   _UpperCamelCase    (			self					: str				)    ->			Dict:






      with self.assertRaises(_a				):
           ConfigMixin.load_config("dummy_path"				)
 def   _UpperCamelCase    (			self					: Tuple				)    ->			List[Any]:
      UpperCAmelCase						:				Optional[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						:				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]

      # can override default
      UpperCAmelCase						:				Dict		  =			SampleObject(c=6				)
      UpperCAmelCase						:				Dict		  =			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						:				int		  =			SampleObject(1       ,    c=6				)
      UpperCAmelCase						:				Dict		  =			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					: int				)    ->			List[str]:
      UpperCAmelCase						:				int		  =			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]

      with tempfile.TemporaryDirectory() as tmpdirname:
           obj.save_config(_a				)
           UpperCAmelCase						:				Union[str, Any]		  =			SampleObject.from_config(SampleObject.load_config(_a				)				)
           UpperCAmelCase						:				Optional[int]		  =			new_obj.config

      # unfreeze configs
      UpperCAmelCase						:				List[Any]		  =			dict(_a				)
      UpperCAmelCase						:				Any		  =			dict(_a				)

      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					: Union[str, Any]				)    ->			Optional[Any]:
      UpperCAmelCase						:				List[Any]		  =			logging.get_logger("diffusers.configuration_utils"				)
      # 30 for warning
      logger.setLevel(3_0				)

      with CaptureLogger(_a				) as cap_logger:
           UpperCAmelCase						:				Optional[int]		  =			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					: Tuple				)    ->			Union[str, Any]:
      UpperCAmelCase						:				Optional[Any]		  =			logging.get_logger("diffusers.configuration_utils"				)
      # 30 for warning
      logger.setLevel(3_0				)

      with CaptureLogger(_a				) as cap_logger:
           UpperCAmelCase						:				Tuple		  =			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					: Tuple				)    ->			Tuple:
      UpperCAmelCase						:				List[Any]		  =			logging.get_logger("diffusers.configuration_utils"				)
      # 30 for warning
      logger.setLevel(3_0				)

      with CaptureLogger(_a				) as cap_logger:
           UpperCAmelCase						:				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					: Optional[Any]				)    ->			List[str]:
      UpperCAmelCase						:				Any		  =			logging.get_logger("diffusers.configuration_utils"				)
      # 30 for warning
      logger.setLevel(3_0				)

      with CaptureLogger(_a				) as cap_logger:
           UpperCAmelCase						:				str		  =			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					: str				)    ->			str:
      UpperCAmelCase						:				Union[str, Any]		  =			logging.get_logger("diffusers.configuration_utils"				)
      # 30 for warning
      logger.setLevel(3_0				)

      with CaptureLogger(_a				) as cap_logger:
           UpperCAmelCase						:				Dict		  =			DDPMScheduler.from_pretrained(
               "hf-internal-testing/tiny-stable-diffusion-torch"       ,    subfolder="scheduler"       ,    prediction_type="sample"       ,    beta_end=8       ,    )

      with CaptureLogger(_a				) as cap_logger_a:
           UpperCAmelCase						:				str		  =			DDPMScheduler.from_pretrained("google/ddpm-celebahq-256"       ,    beta_start=8_8				)

      assert ddpm.__class__ == DDPMScheduler
      assert ddpm.config.prediction_type == "sample"
      assert ddpm.config.beta_end == 8
      assert ddpm_a.config.beta_start == 8_8

      # no warning should be thrown
      assert cap_logger.out == ""
      assert cap_logger_a.out == ""
 def   _UpperCamelCase    (			self					: Optional[Any]				)    ->			Tuple:
      UpperCAmelCase						:				List[str]		  =			logging.get_logger("diffusers.configuration_utils"				)
      # 30 for warning
      logger.setLevel(3_0				)

      with CaptureLogger(_a				) as cap_logger:
           UpperCAmelCase						:				int		  =			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					: List[str]				)    ->			Any:
      UpperCAmelCase						:				List[str]		  =			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(_a				)

           # now loading it with SampleObject2 should put f into `_use_default_values`
           UpperCAmelCase						:				Dict		  =			SampleObjecta.from_config(_a				)

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

      config.config._use_default_values.pop()
      UpperCAmelCase						:				Tuple		  =			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_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_snake_case   = {"configuration_t5": ["T5_PRETRAINED_CONFIG_ARCHIVE_MAP", "T5Config", "T5OnnxConfig"]}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _snake_case   = ["T5Tokenizer"]

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _snake_case   = ["T5TokenizerFast"]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _snake_case   = [
          "T5_PRETRAINED_MODEL_ARCHIVE_LIST",
          "T5EncoderModel",
          "T5ForConditionalGeneration",
          "T5Model",
          "T5PreTrainedModel",
          "load_tf_weights_in_t5",
          "T5ForQuestionAnswering",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _snake_case   = [
          "TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TFT5EncoderModel",
          "TFT5ForConditionalGeneration",
          "TFT5Model",
          "TFT5PreTrainedModel",
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _snake_case   = [
          "FlaxT5EncoderModel",
          "FlaxT5ForConditionalGeneration",
          "FlaxT5Model",
          "FlaxT5PreTrainedModel",
      ]


if TYPE_CHECKING:
      from .configuration_ta import T5_PRETRAINED_CONFIG_ARCHIVE_MAP, TaConfig, TaOnnxConfig

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_ta import TaTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_ta_fast import TaTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_ta import (
                T5_PRETRAINED_MODEL_ARCHIVE_LIST,
                TaEncoderModel,
                TaForConditionalGeneration,
                TaForQuestionAnswering,
                TaModel,
                TaPreTrainedModel,
                load_tf_weights_in_ta,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_ta import (
                TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFTaEncoderModel,
                TFTaForConditionalGeneration,
                TFTaModel,
                TFTaPreTrainedModel,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_flax_ta import (
                FlaxTaEncoderModel,
                FlaxTaForConditionalGeneration,
                FlaxTaModel,
                FlaxTaPreTrainedModel,
            )


else:
      import sys

      _snake_case   = _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



