"""simple docstring"""




# Lint as: python3
import dataclasses
import re
from dataclasses import dataclass
from functools import total_ordering
from typing import Optional, Union


__lowerCamelCase											=  re.compile(R"^(?P<major>\d+)" R"\.(?P<minor>\d+)" R"\.(?P<patch>\d+)$")
@total_ordering
@dataclass
class     UpperCamelCase__:
						lowerCAmelCase__  :						str
						lowerCAmelCase__  :						Optional[str]													=		None
						lowerCAmelCase__  :						Optional[Union[str, int]]													=		None
						lowerCAmelCase__  :						Optional[Union[str, int]]													=		None
						lowerCAmelCase__  :						Optional[Union[str, int]]													=		None





						def 				snake_case__	(       self     )					->				Any:
													A__     ,  A__     ,  A__	     =							_str_to_version_tuple(self.version_str     )





						def __repr__(       self     )					->				Optional[Any]:
													return f'''{self.tuple[0]}.{self.tuple[1]}.{self.tuple[2]}'''





						@property
						def 				snake_case__	(       self     )					->				Union[str, Any]:
													return self.major, self.minor, self.patch





						def 				snake_case__	(       self		,__UpperCAmelCase     )					->				Optional[Any]:
													if isinstance(__UpperCAmelCase		,__UpperCAmelCase     ):
																				return Version(__UpperCAmelCase     )
													elif isinstance(__UpperCAmelCase		,__UpperCAmelCase     ):
																				return other
													raise TypeError(f'''{other} (type {type(__UpperCAmelCase     )}) cannot be compared to version.'''     )





						def __eq__(       self		,__UpperCAmelCase     )					->				Optional[int]:
													try:
																				A__	     =							self._validate_operand(__UpperCAmelCase     )
													except (TypeError, ValueError):
																				return False
													else:
																				return self.tuple == other.tuple





						def __lt__(       self		,__UpperCAmelCase     )					->				Union[str, Any]:
													A__	     =							self._validate_operand(__UpperCAmelCase     )
													return self.tuple < other.tuple





						def __hash__(       self     )					->				Optional[Any]:
													return hash(_version_tuple_to_str(self.tuple     )     )





						@classmethod
						def 				snake_case__	(       cls		,__UpperCAmelCase     )					->				Dict:
													A__	     =							{f.name for f in dataclasses.fields(cls     )}
													return cls(**{k: v for k, v in dic.items() if k in field_names}     )





						def 				snake_case__	(       self     )					->				str:
													return self.version_str






def   UpperCAmelCase					(	UpperCamelCase__				):






							"""simple docstring"""





							A__	     =							_VERSION_REG.match(UpperCamelCase__				)
							if not res:
														raise ValueError(F'''Invalid version \'{version_str}\'. Format should be x.y.z with {{x,y,z}} being digits.'''				)
							return tuple(int(UpperCamelCase__				) for v in [res.group('major'				), res.group('minor'				), res.group('patch'				)]				)






def   UpperCAmelCase					(	UpperCamelCase__				):






							"""simple docstring"""





							return ".".join(str(UpperCamelCase__				) for v in version_tuple				)






"""simple docstring"""




import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation
class     UpperCamelCase__(			unittest.TestCase ):





						def 				snake_case__	(       self     )					->				str:
													A__	     =							get_activation('swish'     )

													self.assertIsInstance(__UpperCAmelCase		,nn.SiLU     )

													self.assertEqual(act(torch.tensor(-1_00		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertNotEqual(act(torch.tensor(-1		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(0		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(20		,dtype=torch.floataa     )     ).item()		,20     )





						def 				snake_case__	(       self     )					->				Optional[Any]:
													A__	     =							get_activation('silu'     )

													self.assertIsInstance(__UpperCAmelCase		,nn.SiLU     )

													self.assertEqual(act(torch.tensor(-1_00		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertNotEqual(act(torch.tensor(-1		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(0		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(20		,dtype=torch.floataa     )     ).item()		,20     )





						def 				snake_case__	(       self     )					->				List[str]:
													A__	     =							get_activation('mish'     )

													self.assertIsInstance(__UpperCAmelCase		,nn.Mish     )

													self.assertEqual(act(torch.tensor(-2_00		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertNotEqual(act(torch.tensor(-1		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(0		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(20		,dtype=torch.floataa     )     ).item()		,20     )





						def 				snake_case__	(       self     )					->				List[str]:
													A__	     =							get_activation('gelu'     )

													self.assertIsInstance(__UpperCAmelCase		,nn.GELU     )

													self.assertEqual(act(torch.tensor(-1_00		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertNotEqual(act(torch.tensor(-1		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(0		,dtype=torch.floataa     )     ).item()		,0     )
													self.assertEqual(act(torch.tensor(20		,dtype=torch.floataa     )     ).item()		,20     )





