



"""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 			_a     (   SCREAMING_SNAKE_CASE__):
							__magic_name__    				=    """config.json"""



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



class 			_a     (   SCREAMING_SNAKE_CASE__):
							__magic_name__    				=    """config.json"""



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



class 			_a     (   SCREAMING_SNAKE_CASE__):
							__magic_name__    				=    """config.json"""



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



class 			_a     (   SCREAMING_SNAKE_CASE__):
							__magic_name__    				=    """config.json"""



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



class 			_a     (   unittest.TestCase):



							def 							__lowercase				( self       :							Optional[Any]		)       ->				Dict:
													with self.assertRaises(_lowercase		):
																			ConfigMixin.load_config("dummy_path"		)



							def 							__lowercase				( self       :							int		)       ->				List[str]:
													snake_case      : Union[str, Any]							=   SampleObject()
													snake_case      : 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
													snake_case      : List[Any]							=   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      : Any							=   SampleObject(c=6		)
													snake_case      : Optional[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      : Union[str, Any]							=   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 							__lowercase				( self       :							Optional[int]		)       ->				Union[str, Any]:
													snake_case      : Any							=   SampleObject()
													snake_case      : 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(_lowercase		)
																			snake_case      : int							=   SampleObject.from_config(SampleObject.load_config(_lowercase		)		)
																			snake_case      : Any							=   new_obj.config

													# unfreeze configs
													snake_case      : Any							=   dict(_lowercase		)
													snake_case      : Union[str, Any]							=   dict(_lowercase		)

													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 							__lowercase				( self       :							List[str]		)       ->				Optional[int]:
													snake_case      : List[str]							=   logging.get_logger("diffusers.configuration_utils"		)
													# 30 for warning
													logger.setLevel(30		)

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

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

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

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

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

													with CaptureLogger(_lowercase		) as cap_logger_a:
																			snake_case      : str							=   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 							__lowercase				( self       :							List[Any]		)       ->				int:
													snake_case      : Dict							=   logging.get_logger("diffusers.configuration_utils"		)
													# 30 for warning
													logger.setLevel(30		)

													with CaptureLogger(_lowercase		) as cap_logger:
																			snake_case      : 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 							__lowercase				( self       :							Any		)       ->				List[str]:
													# 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      : str							=   SampleObject()

													snake_case      : List[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(_lowercase		)

																			# now loading it with SampleObject2 should put f into `_use_default_values`
																			snake_case      : List[str]							=   SampleObjecta.from_config(_lowercase		)

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

													config.config._use_default_values.pop()
													snake_case      : str							=   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"""







import math
from collections import OrderedDict

import torch
from packaging import version
from torch import Tensor, nn

from .utils import logging


A    =	logging.get_logger(__name__)

class 			_a     (   nn.Module):



			def __init__( self       :							Union[str, Any]		)       ->				str:
									super().__init__()
									if version.parse(torch.__version__		) < version.parse("1.12.0"		):
															raise ImportError(
															    F'''You are using torch=={torch.__version__}, but torch>=1.12.0 is required to use '''
															    "PytorchGELUTanh. Please upgrade torch."		)



			def 							__lowercase				( self       :							str      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return nn.functional.gelu(_lowercase      ,  approximate="tanh"		)



class 			_a     (   nn.Module):



			def 							__lowercase				( self       :							Tuple      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi		) * (input + 0.044715 * torch.pow(_lowercase      ,  3.0		))		))



class 			_a     (   nn.Module):



			def __init__( self       :							Tuple      ,  _lowercase       :							bool = False		)       ->				Optional[Any]:
									super().__init__()
									if use_gelu_python:
															snake_case      : Tuple							=   self._gelu_python
									else:
															snake_case      : Any							=   nn.functional.gelu



			def 							__lowercase				( self       :							Any      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return input * 0.5 * (1.0 + torch.erf(input / math.sqrt(2.0		)		))



			def 							__lowercase				( self       :							Optional[int]      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return self.act(_lowercase		)



class 			_a     (   nn.Module):



			def 							__lowercase				( self       :							Union[str, Any]      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return 0.5 * input * (1.0 + torch.tanh(input * 0.7978845608 * (1.0 + 0.044715 * input * input)		))



class 			_a     (   nn.Module):



			def 							__lowercase				( self       :							Dict      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return input * torch.sigmoid(1.702 * input		)



class 			_a     (   nn.Module):



			def __init__( self       :							Union[str, Any]      ,  _lowercase       :							float      ,  _lowercase       :							float		)       ->				Union[str, Any]:
									if min > max:
															raise ValueError(F'''min should be < max (got min: {min}, max: {max})'''		)

									super().__init__()
									snake_case      : str							=   min
									snake_case      : Dict							=   max



			def 							__lowercase				( self       :							str      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return torch.clip(gelu(_lowercase		)      ,  self.min      ,  self.max		)



class 			_a     (   nn.Module):



			def __init__( self       :							str		)       ->				Tuple:
									super().__init__()
									snake_case      : int							=   math.sqrt(2 / math.pi		)



			def 							__lowercase				( self       :							Union[str, Any]      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return 0.5 * input * (1 + torch.tanh(self.precomputed_constant * (input + 0.044715 * torch.pow(_lowercase      ,  3		))		))



class 			_a     (   nn.Module):



			def 							__lowercase				( self       :							int      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return nn.functional.silu(_lowercase		)



class 			_a     (   nn.Module):



			def __init__( self       :							Union[str, Any]		)       ->				Optional[Any]:
									super().__init__()
									if version.parse(torch.__version__		) < version.parse("1.9.0"		):
															snake_case      : Union[str, Any]							=   self._mish_python
									else:
															snake_case      : Union[str, Any]							=   nn.functional.mish



			def 							__lowercase				( self       :							str      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return input * torch.tanh(nn.functional.softplus(_lowercase		)		)



			def 							__lowercase				( self       :							Tuple      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return self.act(_lowercase		)



class 			_a     (   nn.Module):



			def 							__lowercase				( self       :							List[Any]      ,  _lowercase       :							Tensor		)       ->				Tensor:
									return input



class 			_a     (   nn.Module):



			def 							__lowercase				( self       :							Optional[Any]      ,  _lowercase       :							Optional[Any]      ,  _lowercase       :							List[str]=0.707107      ,  _lowercase       :							Dict=0.282095		)       ->				int:
									snake_case      : Any							=   (input - mu).div(sigma * math.sqrt(2.0		)		)
									return 0.5 * (1.0 + torch.erf(_lowercase		))



class 			_a     (   nn.Module):



			def 							__lowercase				( self       :							str      ,  _lowercase       :							List[str]		)       ->				str:
									snake_case      : Optional[Any]							=   nn.functional.relu(_lowercase		)
									snake_case      : List[str]							=   torch.square(_lowercase		)
									return squared



class 			_a     (   SCREAMING_SNAKE_CASE__):



			def __getitem__( self       :							List[str]      ,  _lowercase       :							Any		)       ->				int:
									snake_case      : List[str]							=   super().__getitem__(_lowercase		)
									snake_case						, snake_case      : Optional[Any]							=   content if isinstance(_lowercase      ,  _lowercase		) else (content, {})
									return cls(**_lowercase		)



A    =	{
    'gelu': GELUActivation,
    'gelu_10': (ClippedGELUActivation, {'min': -1_0, 'max': 1_0}),
    'gelu_fast': FastGELUActivation,
    'gelu_new': NewGELUActivation,
    'gelu_python': (GELUActivation, {'use_gelu_python': True}),
    'gelu_pytorch_tanh': PytorchGELUTanh,
    'gelu_accurate': AccurateGELUActivation,
    'laplace': LaplaceActivation,
    'linear': LinearActivation,
    'mish': MishActivation,
    'quick_gelu': QuickGELUActivation,
    'relu': nn.ReLU,
    'relu2': ReLUSquaredActivation,
    'relu6': nn.ReLUa,
    'sigmoid': nn.Sigmoid,
    'silu': SiLUActivation,
    'swish': SiLUActivation,
    'tanh': nn.Tanh,
}
A    =	ClassInstantier(ACTaCLS)

def    __SCREAMING_SNAKE_CASE		( lowerCamelCase_:       Tuple   ):
						"""simple docstring"""






						if activation_string in ACTaFN:
												return ACTaFN[activation_string]
						else:
												raise KeyError(f'''function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()   )}'''   )


# For backwards compatibility with: from activations import gelu_python
A    =	get_activation('gelu_python')
A    =	get_activation('gelu_new')
A    =	get_activation('gelu')
A    =	get_activation('gelu_fast')
A    =	get_activation('quick_gelu')
A    =	get_activation('silu')
A    =	get_activation('mish')
A    =	get_activation('linear')



