


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      __snake_case				(   _UpperCAmelCase):
					SCREAMING_SNAKE_CASE_		:       Tuple								=			"config.json"
					@register_to_config
					def __init__(						self       :						str	,      _lowerCAmelCase       :						int=2	,      _lowerCAmelCase       :						str=5	,      _lowerCAmelCase       :						Tuple=(2, 5)	,      _lowerCAmelCase       :						int="for diffusion"	,      _lowerCAmelCase       :						List[Any]=[1, 3]	,      )							->					Optional[int]:



											'''simple docstring'''





											pass







class      __snake_case				(   _UpperCAmelCase):
					SCREAMING_SNAKE_CASE_		:       Union[str, Any]								=			"config.json"
					@register_to_config
					def __init__(						self       :						Optional[Any]	,      _lowerCAmelCase       :						Optional[Any]=2	,      _lowerCAmelCase       :						List[Any]=5	,      _lowerCAmelCase       :						Optional[int]=(2, 5)	,      _lowerCAmelCase       :						Optional[Any]="for diffusion"	,      _lowerCAmelCase       :						str=[1, 3]	,      )							->					Any:



											'''simple docstring'''





											pass







class      __snake_case				(   _UpperCAmelCase):
					SCREAMING_SNAKE_CASE_		:       str								=			"config.json"
					@register_to_config
					def __init__(						self       :						int	,      _lowerCAmelCase       :						str=2	,      _lowerCAmelCase       :						Tuple=5	,      _lowerCAmelCase       :						Dict=(2, 5)	,      _lowerCAmelCase       :						Optional[int]="for diffusion"	,      _lowerCAmelCase       :						Optional[int]=[1, 3]	,      _lowerCAmelCase       :						Optional[Any]=[1, 3]	,      )							->					List[Any]:



											'''simple docstring'''





											pass







class      __snake_case				(   _UpperCAmelCase):
					SCREAMING_SNAKE_CASE_		:       Tuple								=			"config.json"
					@register_to_config
					def __init__(						self       :						Tuple	,      _lowerCAmelCase       :						Dict=2	,      _lowerCAmelCase       :						Optional[Any]=5	,      _lowerCAmelCase       :						int=(2, 5)	,      _lowerCAmelCase       :						int="for diffusion"	,      _lowerCAmelCase       :						Union[str, Any]=[1, 5]	,      _lowerCAmelCase       :						Optional[Any]=[5, 4]	,      )							->					Optional[int]:



											'''simple docstring'''





											pass







class      __snake_case				(   unittest.TestCase):
					def 	a			(						self       :						Dict  )							->					int:



											'''simple docstring'''





											with self.assertRaises(_lowerCAmelCase  ):
																	ConfigMixin.load_config('dummy_path'  )
					def 	a			(						self       :						int  )							->					List[str]:



											'''simple docstring'''





											__magic_name__					=      SampleObject()
											__magic_name__					=      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
											__magic_name__					=      SampleObject(_name_or_path='lalala'  )
											__magic_name__					=      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
											__magic_name__					=      SampleObject(c=6  )
											__magic_name__					=      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.
											__magic_name__					=      SampleObject(1	,      c=6  )
											__magic_name__					=      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 	a			(						self       :						List[Any]  )							->					Optional[Any]:



											'''simple docstring'''





											__magic_name__					=      SampleObject()
											__magic_name__					=      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  )
																	__magic_name__					=      SampleObject.from_config(SampleObject.load_config(_lowerCAmelCase  )  )
																	__magic_name__					=      new_obj.config

											# unfreeze configs
											__magic_name__					=      dict(_lowerCAmelCase  )
											__magic_name__					=      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 	a			(						self       :						str  )							->					Optional[Any]:



											'''simple docstring'''





											__magic_name__					=      logging.get_logger('diffusers.configuration_utils'  )
											# 30 for warning
											logger.setLevel(3_0  )

											with CaptureLogger(_lowerCAmelCase  ) as cap_logger:
																	__magic_name__					=      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 	a			(						self       :						Optional[Any]  )							->					Tuple:



											'''simple docstring'''





											__magic_name__					=      logging.get_logger('diffusers.configuration_utils'  )
											# 30 for warning
											logger.setLevel(3_0  )

											with CaptureLogger(_lowerCAmelCase  ) as cap_logger:
																	__magic_name__					=      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 	a			(						self       :						int  )							->					List[str]:



											'''simple docstring'''





											__magic_name__					=      logging.get_logger('diffusers.configuration_utils'  )
											# 30 for warning
											logger.setLevel(3_0  )

											with CaptureLogger(_lowerCAmelCase  ) as cap_logger:
																	__magic_name__					=      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 	a			(						self       :						List[Any]  )							->					Any:



											'''simple docstring'''





											__magic_name__					=      logging.get_logger('diffusers.configuration_utils'  )
											# 30 for warning
											logger.setLevel(3_0  )

											with CaptureLogger(_lowerCAmelCase  ) as cap_logger:
																	__magic_name__					=      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 	a			(						self       :						List[str]  )							->					int:



											'''simple docstring'''





											__magic_name__					=      logging.get_logger('diffusers.configuration_utils'  )
											# 30 for warning
											logger.setLevel(3_0  )

											with CaptureLogger(_lowerCAmelCase  ) as cap_logger:
																	__magic_name__					=      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:
																	__magic_name__					=      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 	a			(						self       :						Union[str, Any]  )							->					Tuple:



											'''simple docstring'''





											__magic_name__					=      logging.get_logger('diffusers.configuration_utils'  )
											# 30 for warning
											logger.setLevel(3_0  )

											with CaptureLogger(_lowerCAmelCase  ) as cap_logger:
																	__magic_name__					=      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 	a			(						self       :						int  )							->					int:



											'''simple docstring'''





											__magic_name__					=      SampleObject()

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

											config.config._use_default_values.pop()
											__magic_name__					=      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_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCamelCase			:					Optional[int]         =							{
    '''configuration_dpr''': ['''DPR_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DPRConfig'''],
    '''tokenization_dpr''': [
        '''DPRContextEncoderTokenizer''',
        '''DPRQuestionEncoderTokenizer''',
        '''DPRReaderOutput''',
        '''DPRReaderTokenizer''',
    ],
}


try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase			:					List[str]         =							[
					    '''DPRContextEncoderTokenizerFast''',
					    '''DPRQuestionEncoderTokenizerFast''',
					    '''DPRReaderTokenizerFast''',
					]

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase			:					Optional[Any]         =							[
					    '''DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''DPRContextEncoder''',
					    '''DPRPretrainedContextEncoder''',
					    '''DPRPreTrainedModel''',
					    '''DPRPretrainedQuestionEncoder''',
					    '''DPRPretrainedReader''',
					    '''DPRQuestionEncoder''',
					    '''DPRReader''',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCamelCase			:					Optional[int]         =							[
					    '''TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TFDPRContextEncoder''',
					    '''TFDPRPretrainedContextEncoder''',
					    '''TFDPRPretrainedQuestionEncoder''',
					    '''TFDPRPretrainedReader''',
					    '''TFDPRQuestionEncoder''',
					    '''TFDPRReader''',
					]


if TYPE_CHECKING:
					from .configuration_dpr import DPR_PRETRAINED_CONFIG_ARCHIVE_MAP, DPRConfig
					from .tokenization_dpr import (
					    DPRContextEncoderTokenizer,
					    DPRQuestionEncoderTokenizer,
					    DPRReaderOutput,
					    DPRReaderTokenizer,
					)

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_dpr_fast import (
										    DPRContextEncoderTokenizerFast,
										    DPRQuestionEncoderTokenizerFast,
										    DPRReaderTokenizerFast,
										)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_dpr import (
										    DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DPRContextEncoder,
										    DPRPretrainedContextEncoder,
										    DPRPreTrainedModel,
										    DPRPretrainedQuestionEncoder,
										    DPRPretrainedReader,
										    DPRQuestionEncoder,
										    DPRReader,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_dpr import (
										    TF_DPR_CONTEXT_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TF_DPR_QUESTION_ENCODER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TF_DPR_READER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFDPRContextEncoder,
										    TFDPRPretrainedContextEncoder,
										    TFDPRPretrainedQuestionEncoder,
										    TFDPRPretrainedReader,
										    TFDPRQuestionEncoder,
										    TFDPRReader,
										)

else:
					import sys

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

