



"""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    UpperCamelCase     (			snake_case    ):




	"""simple docstring"""
	SCREAMING_SNAKE_CASE_				:    List[str]		    =   "config.json"






	@register_to_config
	def __init__(			self							,UpperCAmelCase_=2							,UpperCAmelCase_=5							,UpperCAmelCase_=(2, 5)							,UpperCAmelCase_="for diffusion"							,UpperCAmelCase_=[1, 3]							,):
			pass







class    UpperCamelCase     (			snake_case    ):




	"""simple docstring"""
	SCREAMING_SNAKE_CASE_				:    Optional[int]		    =   "config.json"






	@register_to_config
	def __init__(			self							,UpperCAmelCase_=2							,UpperCAmelCase_=5							,UpperCAmelCase_=(2, 5)							,UpperCAmelCase_="for diffusion"							,UpperCAmelCase_=[1, 3]							,):
			pass







class    UpperCamelCase     (			snake_case    ):




	"""simple docstring"""
	SCREAMING_SNAKE_CASE_				:    Any		    =   "config.json"






	@register_to_config
	def __init__(			self							,UpperCAmelCase_=2							,UpperCAmelCase_=5							,UpperCAmelCase_=(2, 5)							,UpperCAmelCase_="for diffusion"							,UpperCAmelCase_=[1, 3]							,UpperCAmelCase_=[1, 3]							,):
			pass







class    UpperCamelCase     (			snake_case    ):




	"""simple docstring"""
	SCREAMING_SNAKE_CASE_				:    Tuple		    =   "config.json"






	@register_to_config
	def __init__(			self							,UpperCAmelCase_=2							,UpperCAmelCase_=5							,UpperCAmelCase_=(2, 5)							,UpperCAmelCase_="for diffusion"							,UpperCAmelCase_=[1, 5]							,UpperCAmelCase_=[5, 4]							,):
			pass







class    UpperCamelCase     (			unittest.TestCase    ):




	"""simple docstring"""






	def 					lowerCamelCase__ (			self					):
			with self.assertRaises(UpperCAmelCase_					):
					ConfigMixin.load_config("""dummy_path"""					)






	def 					lowerCamelCase__ (			self					):
			_lowercase							:      List[Any]			=					SampleObject()
			_lowercase							:      Union[str, 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
			_lowercase							:      str			=					SampleObject(_name_or_path="""lalala"""					)
			_lowercase							:      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
			_lowercase							:      Any			=					SampleObject(c=6					)
			_lowercase							:      str			=					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.
			_lowercase							:      Optional[int]			=					SampleObject(1							,c=6					)
			_lowercase							:      Tuple			=					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					):
			_lowercase							:      int			=					SampleObject()
			_lowercase							:      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(UpperCAmelCase_					)
					_lowercase							:      Optional[Any]			=					SampleObject.from_config(SampleObject.load_config(UpperCAmelCase_					)					)
					_lowercase							:      List[str]			=					new_obj.config

			# unfreeze configs
			_lowercase							:      Optional[Any]			=					dict(UpperCAmelCase_					)
			_lowercase							:      List[str]			=					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 					lowerCamelCase__ (			self					):
			_lowercase							:      Optional[int]			=					logging.get_logger("""diffusers.configuration_utils"""					)
			# 30 for warning
			logger.setLevel(30					)

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

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

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

			with CaptureLogger(UpperCAmelCase_					) as cap_logger:
					_lowercase							:      int			=					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					):
			_lowercase							:      Tuple			=					logging.get_logger("""diffusers.configuration_utils"""					)
			# 30 for warning
			logger.setLevel(30					)

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

			with CaptureLogger(UpperCAmelCase_					) as cap_logger:
					_lowercase							:      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					):
			# 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],

			_lowercase							:      Any			=					SampleObject()

			_lowercase							:      Union[str, Any]			=					{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`
					_lowercase							:      int			=					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`
			_lowercase							:      List[Any]			=					SampleObjecta.from_config(config.config					)
			assert new_config.f == [5, 4]

			config.config._use_default_values.pop()
			_lowercase							:      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]








"""simple docstring"""







from typing import TYPE_CHECKING

from ..utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available


UpperCAmelCase:   int       			=							{
    """configuration_utils""": ["""GenerationConfig"""],
    """streamers""": ["""TextIteratorStreamer""", """TextStreamer"""],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase:   List[Any]       			=							[
		    """Constraint""",
		    """ConstraintListState""",
		    """DisjunctiveConstraint""",
		    """PhrasalConstraint""",
		]
		UpperCAmelCase:   Optional[Any]       			=							[
		    """BeamHypotheses""",
		    """BeamScorer""",
		    """BeamSearchScorer""",
		    """ConstrainedBeamSearchScorer""",
		]
		UpperCAmelCase:   Any       			=							[
		    """EpsilonLogitsWarper""",
		    """EtaLogitsWarper""",
		    """ForcedBOSTokenLogitsProcessor""",
		    """ForcedEOSTokenLogitsProcessor""",
		    """HammingDiversityLogitsProcessor""",
		    """InfNanRemoveLogitsProcessor""",
		    """LogitsProcessor""",
		    """LogitsProcessorList""",
		    """LogitsWarper""",
		    """MinLengthLogitsProcessor""",
		    """MinNewTokensLengthLogitsProcessor""",
		    """NoBadWordsLogitsProcessor""",
		    """NoRepeatNGramLogitsProcessor""",
		    """PrefixConstrainedLogitsProcessor""",
		    """RepetitionPenaltyLogitsProcessor""",
		    """SequenceBiasLogitsProcessor""",
		    """EncoderRepetitionPenaltyLogitsProcessor""",
		    """TemperatureLogitsWarper""",
		    """TopKLogitsWarper""",
		    """TopPLogitsWarper""",
		    """TypicalLogitsWarper""",
		    """EncoderNoRepeatNGramLogitsProcessor""",
		    """ExponentialDecayLengthPenalty""",
		    """LogitNormalization""",
		]
		UpperCAmelCase:   str       			=							[
		    """MaxNewTokensCriteria""",
		    """MaxLengthCriteria""",
		    """MaxTimeCriteria""",
		    """StoppingCriteria""",
		    """StoppingCriteriaList""",
		    """validate_stopping_criteria""",
		]
		UpperCAmelCase:   Optional[Any]       			=							[
		    """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:
		UpperCAmelCase:   Any       			=							[
		    """TFForcedBOSTokenLogitsProcessor""",
		    """TFForcedEOSTokenLogitsProcessor""",
		    """TFLogitsProcessor""",
		    """TFLogitsProcessorList""",
		    """TFLogitsWarper""",
		    """TFMinLengthLogitsProcessor""",
		    """TFNoBadWordsLogitsProcessor""",
		    """TFNoRepeatNGramLogitsProcessor""",
		    """TFRepetitionPenaltyLogitsProcessor""",
		    """TFTemperatureLogitsWarper""",
		    """TFTopKLogitsWarper""",
		    """TFTopPLogitsWarper""",
		    """TFForceTokensLogitsProcessor""",
		    """TFSuppressTokensAtBeginLogitsProcessor""",
		    """TFSuppressTokensLogitsProcessor""",
		]
		UpperCAmelCase:   Tuple       			=							[
		    """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:
		UpperCAmelCase:   Tuple       			=							[
		    """FlaxForcedBOSTokenLogitsProcessor""",
		    """FlaxForcedEOSTokenLogitsProcessor""",
		    """FlaxLogitsProcessor""",
		    """FlaxLogitsProcessorList""",
		    """FlaxLogitsWarper""",
		    """FlaxMinLengthLogitsProcessor""",
		    """FlaxTemperatureLogitsWarper""",
		    """FlaxTopKLogitsWarper""",
		    """FlaxTopPLogitsWarper""",
		]
		UpperCAmelCase:   int       			=							[
		    """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

		UpperCAmelCase:   Optional[Any]       			=							_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



