def test_int_type():
t = setting_type(int)
assert t.heksher_string() == 'int'
assert t.convert(1) == Conversion(1)
with raises(TypeError):
t.convert(1.5)
with raises(TypeError):
t.convert('1')
def test_sequence(type_func):
class Color(Enum):
red = 'red'
blue = 'blue'
green = 'green'
t = setting_type(type_func(Color))
assert t.heksher_string() == 'Sequence<Enum["blue","green","red"]>'
assert t.convert(["green", "red", "blue", "green"]) == Conversion(
(Color.green, Color.red, Color.blue, Color.green), [])
def test_flag_type(type_func):
class B(IntFlag):
a = auto()
b = auto()
t = setting_type(type_func(B))
assert t.heksher_string() == 'Flags["a","b"]'
assert t.convert(["a", "c"]) == Conversion(
B.a, ['server sent a flag value not found in the python type (c)'])
assert t.convert([]) == Conversion(B(0), [])
assert t.convert(["a", "b"]) == Conversion(B.a | B.b, [])
def test_sequence_coerce(type_func):
class Color(Enum):
red = 'red'
blue = 'blue'
green = 'green'
t = setting_type(type_func(Color))
assert t.heksher_string() == 'Sequence<Enum["blue","green","red"]>'
assert t.convert([
"green", "red", "blue", 'white', "green"
]) == Conversion((Color.green, Color.red, Color.blue, Color.green), [
"failed to convert element 3: TypeError('value is not a valid enum member')"
])
def test_enum_type(type_func):
class A(Enum):
a = 0
b = 1
c = 'c'
d = 3.5
t = setting_type(type_func(A))
assert t.heksher_string() == 'Enum["c",0,1,3.5]'
assert t.convert(0) == Conversion(A.a)
assert t.convert("c") == Conversion(A.c)
with raises(TypeError):
assert t.convert("b")
def test_mapping(type_func):
class Color(Enum):
red = 'red'
blue = 'blue'
green = 'green'
t = setting_type(type_func(Color))
assert t.heksher_string() == 'Mapping<Enum["blue","green","red"]>'
assert t.convert({
'fg': 'blue',
'bg': 'red'
}) == Conversion({
'fg': Color.blue,
'bg': Color.red
}, [])
def __init__(self,
name: str,
type: Any,
configurable_features: Sequence[str],
default_value: T,
metadata: Optional[Mapping[str, Any]] = None,
alias: Optional[str] = None,
version: str = '1.0',
on_coerce: Optional[Callable[
[T, Any, Sequence[str], Optional[QueriedRule], 'Setting'],
T]] = lambda x, *args: x):
"""
Args:
name: The name of the setting.
type: The type of the setting, either a primitive type (int, str, bool, float), an enum class, a FlagInt
class, or a generic alias of List or Dict.
configurable_features: The configurable features of the setting.
default_value: The default value of the setting, this value will be returned if no rules match the current
context.
metadata: Additional metadata of the setting.
alias: An alias for the setting.
version: The version of the setting.
on_coerce: A function to be called after a server value resulter in coercion. Should return a local value,
or raise a TypeError. Set to None to always raise a type error.
Notes:
Creating a setting automatically registers it to be declared at the main heksher client.
"""
self.name = name
self.type = setting_type(type)
self.configurable_features = OrderedSet(configurable_features)
self.default_value = default_value
self.metadata = metadata or {}
self.alias = alias
self.version_str = version
self.version = tuple(int(x) for x in version.split('.', 1))
if on_coerce is None:
on_coerce = _reject_on_coerce
self.on_coerce = on_coerce
self.last_ruleset: Optional[RuleSet] = None
self._validators: List[Validator[T]] = []
self.server_default_value: Optional[T] = None
heksher.main_client.Main.add_settings((self, ))
def test_mapping_coerce(type_func):
class Color(Enum):
red = 'red'
blue = 'blue'
green = 'green'
t = setting_type(type_func(Color))
assert t.heksher_string() == 'Mapping<Enum["blue","green","red"]>'
assert t.convert({
'fg': 'blue',
'bg': 'red',
'tx': 'white'
}) == Conversion({
'fg': Color.blue,
'bg': Color.red
}, [
"failed to convert value for key tx: TypeError('value is not a valid enum member')"
])
