
'''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__ (							UpperCamelCase							):



  '''simple docstring'''






  _UpperCamelCase							=			'config.json'

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



class 			lowerCAmelCase__ (							UpperCamelCase							):



  '''simple docstring'''






  _UpperCamelCase							=			'config.json'

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



class 			lowerCAmelCase__ (							UpperCamelCase							):



  '''simple docstring'''






  _UpperCamelCase							=			'config.json'

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



class 			lowerCAmelCase__ (							UpperCamelCase							):



  '''simple docstring'''






  _UpperCamelCase							=			'config.json'

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



class 			lowerCAmelCase__ (							unittest.TestCase							):



  '''simple docstring'''






  def 		_lowerCamelCase						(self	:			Tuple     ) ->							Dict:
        with self.assertRaises(lowerCAmelCase_     ):
              ConfigMixin.load_config("dummy_path"     )

  def 		_lowerCamelCase						(self	:			Optional[Any]     ) ->							Tuple:
        snake_case_    							=				SampleObject()
        snake_case_    							=				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_    							=				SampleObject(_name_or_path="lalala"     )
        snake_case_    							=				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_    							=				SampleObject(c=6     )
        snake_case_    							=				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_    							=				SampleObject(1						,			c=6     )
        snake_case_    							=				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 		_lowerCamelCase						(self	:			Tuple     ) ->							Optional[int]:
        snake_case_    							=				SampleObject()
        snake_case_    							=				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_     )
              snake_case_    							=				SampleObject.from_config(SampleObject.load_config(lowerCAmelCase_     )     )
              snake_case_    							=				new_obj.config

        # unfreeze configs
        snake_case_    							=				dict(lowerCAmelCase_     )
        snake_case_    							=				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 		_lowerCamelCase						(self	:			Dict     ) ->							List[Any]:
        snake_case_    							=				logging.get_logger("diffusers.configuration_utils"     )
        # 30 for warning
        logger.setLevel(30     )

        with CaptureLogger(lowerCAmelCase_     ) as cap_logger:
              snake_case_    							=				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 		_lowerCamelCase						(self	:			Dict     ) ->							Dict:
        snake_case_    							=				logging.get_logger("diffusers.configuration_utils"     )
        # 30 for warning
        logger.setLevel(30     )

        with CaptureLogger(lowerCAmelCase_     ) as cap_logger:
              snake_case_    							=				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 		_lowerCamelCase						(self	:			str     ) ->							List[Any]:
        snake_case_    							=				logging.get_logger("diffusers.configuration_utils"     )
        # 30 for warning
        logger.setLevel(30     )

        with CaptureLogger(lowerCAmelCase_     ) as cap_logger:
              snake_case_    							=				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 		_lowerCamelCase						(self	:			List[str]     ) ->							Any:
        snake_case_    							=				logging.get_logger("diffusers.configuration_utils"     )
        # 30 for warning
        logger.setLevel(30     )

        with CaptureLogger(lowerCAmelCase_     ) as cap_logger:
              snake_case_    							=				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 		_lowerCamelCase						(self	:			Any     ) ->							Optional[Any]:
        snake_case_    							=				logging.get_logger("diffusers.configuration_utils"     )
        # 30 for warning
        logger.setLevel(30     )

        with CaptureLogger(lowerCAmelCase_     ) as cap_logger:
              snake_case_    							=				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:
              snake_case_    							=				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 		_lowerCamelCase						(self	:			Optional[int]     ) ->							str:
        snake_case_    							=				logging.get_logger("diffusers.configuration_utils"     )
        # 30 for warning
        logger.setLevel(30     )

        with CaptureLogger(lowerCAmelCase_     ) as cap_logger:
              snake_case_    							=				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 		_lowerCamelCase						(self	:			int     ) ->							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],

        snake_case_    							=				SampleObject()

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

        config.config._use_default_values.pop()
        snake_case_    							=				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 ctypes import c_float, sizeof
from enum import Enum
from typing import TYPE_CHECKING, Optional, Union


if TYPE_CHECKING:
  from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore




class 					__UpperCAmelCase (		UpperCamelCase__	):

      '''simple docstring'''





      SCREAMING_SNAKE_CASE				:    Dict				       =					c_float




      @property
      def 							lowerCamelCase     (					self						):
             return sizeof(self.value						)






def  lowerCAmelCase__		(					a_  :     int			,						a_  :     int			,						a_  :     int = 0			)   -> int:
       # < 0 is possible if using a dynamic axis
       if dimension <= 0:
              UpperCAmelCase__	:   List[Any]												=	fixed_dimension

       dimension -= num_token_to_add
       return dimension






def  lowerCAmelCase__		(					a_  :     int			,						a_  :     ParameterFormat			)   -> int:
       return num_parameters * dtype.size






def  lowerCAmelCase__		(					a_  :     str			)   -> Optional[Union["AutoTokenizer", "AutoFeatureExtractor", "AutoProcessor"]]:
       from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore

       try:
              return AutoProcessor.from_pretrained(a_			)
       except (ValueError, OSError, KeyError):
              UpperCAmelCase__							,							UpperCAmelCase__	:   Dict												=	None, None
              try:
                     UpperCAmelCase__	:   Union[str, Any]												=	AutoTokenizer.from_pretrained(a_			)
              except (OSError, KeyError):
                     pass
              try:
                     UpperCAmelCase__	:   List[str]												=	AutoFeatureExtractor.from_pretrained(a_			)
              except (OSError, KeyError):
                     pass

              if tokenizer is not None and feature_extractor is not None:
                     raise ValueError(
                         f"""Couldn't auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor."""			)
              elif tokenizer is None and feature_extractor is None:
                     return None
              elif tokenizer is not None:
                     return tokenizer
              else:
                     return feature_extractor