code: 
  
  
  
  
  """simple docstring"""
  
  from typing import TYPE_CHECKING
  
  from ..utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available
  
  
  __A 		=			{
      "configuration_utils": ["GenerationConfig"],
      "streamers": ["TextIteratorStreamer", "TextStreamer"],
  }
  
  try:
  							if not is_torch_available():
  														raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  							pass
  else:
  							__A 		=			[
  							    "Constraint",
  							    "ConstraintListState",
  							    "DisjunctiveConstraint",
  							    "PhrasalConstraint",
  							]
  							__A 		=			[
  							    "BeamHypotheses",
  							    "BeamScorer",
  							    "BeamSearchScorer",
  							    "ConstrainedBeamSearchScorer",
  							]
  							__A 		=			[
  							    "EpsilonLogitsWarper",
  							    "EtaLogitsWarper",
  							    "ForcedBOSTokenLogitsProcessor",
  							    "ForcedEOSTokenLogitsProcessor",
  							    "HammingDiversityLogitsProcessor",
  							    "InfNanRemoveLogitsProcessor",
  							    "LogitsProcessor",
  							    "LogitsProcessorList",
  							    "LogitsWarper",
  							    "MinLengthLogitsProcessor",
  							    "MinNewTokensLengthLogitsProcessor",
  							    "NoBadWordsLogitsProcessor",
  							    "NoRepeatNGramLogitsProcessor",
  							    "PrefixConstrainedLogitsProcessor",
  							    "RepetitionPenaltyLogitsProcessor",
  							    "SequenceBiasLogitsProcessor",
  							    "EncoderRepetitionPenaltyLogitsProcessor",
  							    "TemperatureLogitsWarper",
  							    "TopKLogitsWarper",
  							    "TopPLogitsWarper",
  							    "TypicalLogitsWarper",
  							    "EncoderNoRepeatNGramLogitsProcessor",
  							    "ExponentialDecayLengthPenalty",
  							    "LogitNormalization",
  							]
  							__A 		=			[
  							    "MaxNewTokensCriteria",
  							    "MaxLengthCriteria",
  							    "MaxTimeCriteria",
  							    "StoppingCriteria",
  							    "StoppingCriteriaList",
  							    "validate_stopping_criteria",
  							]
  							__A 		=			[
  							    "GenerationMixin",
  							    "top_k_top_p_filtering",
  							    "GreedySearchEncoderDecoderOutput",
  							    "GreedySearchDecoderOnlyOutput",
  							    "SampleEncoderDecoderOutput",
  							    "SampleDecoderOnlyOutput",
  							    "BeamSearchEncoderDecoderOutput",
  							    "BeamSearchDecoderOnlyOutput",
  							    "BeamSampleEncoderDecoderOutput",
  							    "BeamSampleDecoderOnlyOutput",
  							    "ContrastiveSearchEncoderDecoderOutput",
  							    "ContrastiveSearchDecoderOnlyOutput",
  							]
  
  try:
  							if not is_tf_available():
  														raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  							pass
  else:
  							__A 		=			[
  							    "TFForcedBOSTokenLogitsProcessor",
  							    "TFForcedEOSTokenLogitsProcessor",
  							    "TFLogitsProcessor",
  							    "TFLogitsProcessorList",
  							    "TFLogitsWarper",
  							    "TFMinLengthLogitsProcessor",
  							    "TFNoBadWordsLogitsProcessor",
  							    "TFNoRepeatNGramLogitsProcessor",
  							    "TFRepetitionPenaltyLogitsProcessor",
  							    "TFTemperatureLogitsWarper",
  							    "TFTopKLogitsWarper",
  							    "TFTopPLogitsWarper",
  							    "TFForceTokensLogitsProcessor",
  							    "TFSuppressTokensAtBeginLogitsProcessor",
  							    "TFSuppressTokensLogitsProcessor",
  							]
  							__A 		=			[
  							    "TFGenerationMixin",
  							    "tf_top_k_top_p_filtering",
  							    "TFGreedySearchDecoderOnlyOutput",
  							    "TFGreedySearchEncoderDecoderOutput",
  							    "TFSampleEncoderDecoderOutput",
  							    "TFSampleDecoderOnlyOutput",
  							    "TFBeamSearchEncoderDecoderOutput",
  							    "TFBeamSearchDecoderOnlyOutput",
  							    "TFBeamSampleEncoderDecoderOutput",
  							    "TFBeamSampleDecoderOnlyOutput",
  							    "TFContrastiveSearchEncoderDecoderOutput",
  							    "TFContrastiveSearchDecoderOnlyOutput",
  							]
  
  try:
  							if not is_flax_available():
  														raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  							pass
  else:
  							__A 		=			[
  							    "FlaxForcedBOSTokenLogitsProcessor",
  							    "FlaxForcedEOSTokenLogitsProcessor",
  							    "FlaxLogitsProcessor",
  							    "FlaxLogitsProcessorList",
  							    "FlaxLogitsWarper",
  							    "FlaxMinLengthLogitsProcessor",
  							    "FlaxTemperatureLogitsWarper",
  							    "FlaxTopKLogitsWarper",
  							    "FlaxTopPLogitsWarper",
  							]
  							__A 		=			[
  							    "FlaxGenerationMixin",
  							    "FlaxGreedySearchOutput",
  							    "FlaxSampleOutput",
  							    "FlaxBeamSearchOutput",
  							]
  
  if TYPE_CHECKING:
  							from .configuration_utils import GenerationConfig
  							from .streamers import TextIteratorStreamer, TextStreamer
  
  							try:
  														if not is_torch_available():
  																					raise OptionalDependencyNotAvailable()
  							except OptionalDependencyNotAvailable:
  														pass
  							else:
  														from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
  														from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
  														from .logits_process import (
  														    EncoderNoRepeatNGramLogitsProcessor,
  														    EncoderRepetitionPenaltyLogitsProcessor,
  														    EpsilonLogitsWarper,
  														    EtaLogitsWarper,
  														    ExponentialDecayLengthPenalty,
  														    ForcedBOSTokenLogitsProcessor,
  														    ForcedEOSTokenLogitsProcessor,
  														    HammingDiversityLogitsProcessor,
  														    InfNanRemoveLogitsProcessor,
  														    LogitNormalization,
  														    LogitsProcessor,
  														    LogitsProcessorList,
  														    LogitsWarper,
  														    MinLengthLogitsProcessor,
  														    MinNewTokensLengthLogitsProcessor,
  														    NoBadWordsLogitsProcessor,
  														    NoRepeatNGramLogitsProcessor,
  														    PrefixConstrainedLogitsProcessor,
  														    RepetitionPenaltyLogitsProcessor,
  														    SequenceBiasLogitsProcessor,
  														    TemperatureLogitsWarper,
  														    TopKLogitsWarper,
  														    TopPLogitsWarper,
  														    TypicalLogitsWarper,
  														)
  														from .stopping_criteria import (
  														    MaxLengthCriteria,
  														    MaxNewTokensCriteria,
  														    MaxTimeCriteria,
  														    StoppingCriteria,
  														    StoppingCriteriaList,
  														    validate_stopping_criteria,
  														)
  														from .utils import (
  														    BeamSampleDecoderOnlyOutput,
  														    BeamSampleEncoderDecoderOutput,
  														    BeamSearchDecoderOnlyOutput,
  														    BeamSearchEncoderDecoderOutput,
  														    ContrastiveSearchDecoderOnlyOutput,
  														    ContrastiveSearchEncoderDecoderOutput,
  														    GenerationMixin,
  														    GreedySearchDecoderOnlyOutput,
  														    GreedySearchEncoderDecoderOutput,
  														    SampleDecoderOnlyOutput,
  														    SampleEncoderDecoderOutput,
  														    top_k_top_p_filtering,
  														)
  
  							try:
  														if not is_tf_available():
  																					raise OptionalDependencyNotAvailable()
  							except OptionalDependencyNotAvailable:
  														pass
  							else:
  														from .tf_logits_process import (
  														    TFForcedBOSTokenLogitsProcessor,
  														    TFForcedEOSTokenLogitsProcessor,
  														    TFForceTokensLogitsProcessor,
  														    TFLogitsProcessor,
  														    TFLogitsProcessorList,
  														    TFLogitsWarper,
  														    TFMinLengthLogitsProcessor,
  														    TFNoBadWordsLogitsProcessor,
  														    TFNoRepeatNGramLogitsProcessor,
  														    TFRepetitionPenaltyLogitsProcessor,
  														    TFSuppressTokensAtBeginLogitsProcessor,
  														    TFSuppressTokensLogitsProcessor,
  														    TFTemperatureLogitsWarper,
  														    TFTopKLogitsWarper,
  														    TFTopPLogitsWarper,
  														)
  														from .tf_utils import (
  														    TFBeamSampleDecoderOnlyOutput,
  														    TFBeamSampleEncoderDecoderOutput,
  														    TFBeamSearchDecoderOnlyOutput,
  														    TFBeamSearchEncoderDecoderOutput,
  														    TFContrastiveSearchDecoderOnlyOutput,
  														    TFContrastiveSearchEncoderDecoderOutput,
  														    TFGenerationMixin,
  														    TFGreedySearchDecoderOnlyOutput,
  														    TFGreedySearchEncoderDecoderOutput,
  														    TFSampleDecoderOnlyOutput,
  														    TFSampleEncoderDecoderOutput,
  														    tf_top_k_top_p_filtering,
  														)
  
  							try:
  														if not is_flax_available():
  																					raise OptionalDependencyNotAvailable()
  							except OptionalDependencyNotAvailable:
  														pass
  							else:
  														from .flax_logits_process import (
  														    FlaxForcedBOSTokenLogitsProcessor,
  														    FlaxForcedEOSTokenLogitsProcessor,
  														    FlaxLogitsProcessor,
  														    FlaxLogitsProcessorList,
  														    FlaxLogitsWarper,
  														    FlaxMinLengthLogitsProcessor,
  														    FlaxTemperatureLogitsWarper,
  														    FlaxTopKLogitsWarper,
  														    FlaxTopPLogitsWarper,
  														)
  														from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
  else:
  							import sys
  
  							__A 		=			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
  
  
style_context: 
  
  
  
  
  """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__    (  lowerCamelCase_			):
  			a__ :      int								=     """config.json"""
  
  
  			@register_to_config
  			def __init__(     self				, SCREAMING_SNAKE_CASE=2				, SCREAMING_SNAKE_CASE=5				, SCREAMING_SNAKE_CASE=(2, 5)				, SCREAMING_SNAKE_CASE="for diffusion"				, SCREAMING_SNAKE_CASE=[1, 3]				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  class 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      Dict								=     """config.json"""
  
  
  			@register_to_config
  			def __init__(     self				, SCREAMING_SNAKE_CASE=2				, SCREAMING_SNAKE_CASE=5				, SCREAMING_SNAKE_CASE=(2, 5)				, SCREAMING_SNAKE_CASE="for diffusion"				, SCREAMING_SNAKE_CASE=[1, 3]				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  class 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      Union[str, Any]								=     """config.json"""
  
  
  			@register_to_config
  			def __init__(     self				, SCREAMING_SNAKE_CASE=2				, SCREAMING_SNAKE_CASE=5				, SCREAMING_SNAKE_CASE=(2, 5)				, SCREAMING_SNAKE_CASE="for diffusion"				, SCREAMING_SNAKE_CASE=[1, 3]				, SCREAMING_SNAKE_CASE=[1, 3]				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  class 			lowerCamelCase__    (  lowerCamelCase_			):
  			a__ :      Tuple								=     """config.json"""
  
  
  			@register_to_config
  			def __init__(     self				, SCREAMING_SNAKE_CASE=2				, SCREAMING_SNAKE_CASE=5				, SCREAMING_SNAKE_CASE=(2, 5)				, SCREAMING_SNAKE_CASE="for diffusion"				, SCREAMING_SNAKE_CASE=[1, 5]				, SCREAMING_SNAKE_CASE=[5, 4]				, ):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  class 			lowerCamelCase__    (  unittest.TestCase			):
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					with self.assertRaises(SCREAMING_SNAKE_CASE							):
  							ConfigMixin.load_config("dummy_path"							)
  
  
  			def 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Dict								=				SampleObject()
  					snake_case		:						Dict								=				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		:						Dict								=				SampleObject(_name_or_path="lalala"							)
  					snake_case		:						List[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]
  
  					# can override default
  					snake_case		:						str								=				SampleObject(c=6							)
  					snake_case		:						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		:						int								=				SampleObject(1				, c=6							)
  					snake_case		:						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 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						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]
  
  					with tempfile.TemporaryDirectory() as tmpdirname:
  							obj.save_config(SCREAMING_SNAKE_CASE							)
  							snake_case		:						Union[str, Any]								=				SampleObject.from_config(SampleObject.load_config(SCREAMING_SNAKE_CASE							)							)
  							snake_case		:						Union[str, Any]								=				new_obj.config
  
  					# unfreeze configs
  					snake_case		:						List[str]								=				dict(SCREAMING_SNAKE_CASE							)
  					snake_case		:						Union[str, Any]								=				dict(SCREAMING_SNAKE_CASE							)
  
  					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							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						List[Any]								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						Any								=				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							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						int								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						Optional[int]								=				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							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Any								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) 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 							lowerCamelCase_				(     self							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Union[str, Any]								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						List[Any]								=				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							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						str								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						List[Any]								=				DDPMScheduler.from_pretrained(
  							    "hf-internal-testing/tiny-stable-diffusion-torch"				, subfolder="scheduler"				, prediction_type="sample"				, beta_end=8				, )
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger_a:
  							snake_case		:						Optional[int]								=				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							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Dict								=				logging.get_logger("diffusers.configuration_utils"							)
  					# 30 for warning
  					logger.setLevel(30							)
  
  					with CaptureLogger(SCREAMING_SNAKE_CASE							) as cap_logger:
  							snake_case		:						Union[str, Any]								=				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							):
  
  
  
  					"""simple docstring"""
  
  
  
  
  
  
  
  					snake_case		:						Optional[Any]								=				SampleObject()
  
  					snake_case		:						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(SCREAMING_SNAKE_CASE							)
  
  							# now loading it with SampleObject2 should put f into `_use_default_values`
  							snake_case		:						Optional[int]								=				SampleObjecta.from_config(SCREAMING_SNAKE_CASE							)
  
  							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		:						Tuple								=				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]
  
  