kilonova 0.1.0__py3-none-any.whl

kilonova/__init__.py

@@ -0,0 +1,12 @@
+"""kilonova — pure-Python OPC UA servers from quasar Design files.
+
+A quasar in miniature: loads a quasar Design.xml + config.xml and serves the
+identical address space the C++ quasar framework would, with no code generation.
+"""
+
+from kilonova.design import Design
+from kilonova.server import Server
+
+__version__ = "0.1.0"
+
+__all__ = ["Design", "Server", "__version__"]

kilonova/address_space.py

@@ -0,0 +1,413 @@
+"""Building the quasar address space inside an asyncua server.
+
+Address rules match C++ quasar exactly: instances live in namespace 2 with
+string NodeIds of dotted paths (``sca1.online``), object types get numeric ids
+from 1000 upward.
+"""
+
+from __future__ import annotations
+
+import logging
+
+import asyncua
+from asyncua import ua
+from asyncua.common.node import Node
+
+from kilonova import oracle
+from kilonova.config import Instance
+from kilonova.design import (
+    CacheVariable,
+    ConfigEntry,
+    Design,
+    Method,
+    MethodArgument,
+    QuasarClass,
+    SourceVariable,
+)
+from kilonova.errors import ConfigurationError, DesignError
+from kilonova.objects import QuasarObject
+
+_log = logging.getLogger(__name__)
+
+FIRST_TYPE_ID = 1000
+
+
+async def _not_implemented_method(parent, *args):
+    return ua.StatusCode(ua.StatusCodes.BadNotImplemented)
+
+
+def _check_cardinality(relations, child_class_names: list[str], where: str) -> None:
+    """Enforce hasobjects minOccurs/maxOccurs, as quasar's Configuration.xsd does."""
+    for rel in relations:
+        if rel.instantiate_using != "configuration":
+            continue
+        count = child_class_names.count(rel.class_name)
+        if count < rel.min_occurs:
+            raise ConfigurationError(
+                f"{where}: needs at least {rel.min_occurs} <{rel.class_name}> "
+                f"instance(s), got {count}"
+            )
+        if rel.max_occurs is not None and count > rel.max_occurs:
+            raise ConfigurationError(
+                f"{where}: allows at most {rel.max_occurs} <{rel.class_name}> "
+                f"instance(s), got {count}"
+            )
+
+
+class AddressSpaceBuilder:
+    """Creates types and instances for one Design inside one asyncua server."""
+
+    def __init__(
+        self,
+        ua_server: asyncua.Server,
+        design: Design,
+        namespace_index: int,
+        method_dispatcher_factory=None,
+        calculated_engine=None,
+    ):
+        self._server = ua_server
+        self._design = design
+        self._ns = namespace_index
+        self._make_dispatcher = method_dispatcher_factory
+        self._calculated = calculated_engine
+        self._type_nodes: dict[str, Node] = {}
+        #: All instantiated objects keyed by their dotted string address.
+        self.objects: dict[str, QuasarObject] = {}
+        #: Source variable specs keyed by full dotted address.
+        self.source_variables: dict[str, SourceVariable] = {}
+        #: Full addresses of cache variables with addressSpaceWrite="delegated".
+        self.delegated_cache_variables: set[str] = set()
+
+    # -- types ---------------------------------------------------------------
+
+    async def build_types(self) -> None:
+        """One bare ObjectType per Design class, numeric ids from 1000 up."""
+        base = self._server.get_node(ua.NodeId(ua.ObjectIds.BaseObjectType))
+        for offset, klass in enumerate(self._design.classes.values()):
+            type_node = await base.add_object_type(
+                ua.NodeId(FIRST_TYPE_ID + offset, self._ns),
+                ua.QualifiedName(klass.name, self._ns),
+            )
+            self._type_nodes[klass.name] = type_node
+
+    # -- instances -----------------------------------------------------------
+
+    async def instantiate_root_design_objects(self) -> None:
+        """Objects the Design itself mandates at the root (instantiateUsing="design")."""
+        objects_folder = self._server.nodes.objects
+        for rel in self._design.root_has_objects:
+            if rel.instantiate_using != "design":
+                continue
+            klass = self._design.classes[rel.class_name]
+            for instance_name in rel.design_instance_names:
+                await self._instantiate(
+                    Instance(class_name=klass.name, name=instance_name),
+                    objects_folder,
+                    parent_address=None,
+                )
+
+    async def instantiate_from_config(self, instances: list[Instance]) -> None:
+        objects_folder = self._server.nodes.objects
+        _check_cardinality(
+            self._design.root_has_objects,
+            [instance.class_name for instance in instances],
+            where="configuration root",
+        )
+        for instance in instances:
+            await self._instantiate(instance, objects_folder, parent_address=None)
+
+    async def _instantiate(
+        self, instance: Instance, parent_node: Node, parent_address: str | None
+    ) -> QuasarObject:
+        klass = self._design.classes[instance.class_name]
+        if klass.calculated_variables:
+            raise DesignError(
+                f"class {klass.name}: Design-level calculated variables are not supported"
+                " yet — declare them in the configuration instead"
+            )
+        address = instance.name if parent_address is None else f"{parent_address}.{instance.name}"
+        node_id = ua.NodeId(address, self._ns)
+        browse_name = ua.QualifiedName(instance.name, self._ns)
+        _log.debug("instantiating %s %r", klass.name, address)
+
+        if klass.single_variable_node and klass.source_variables:
+            sv = klass.source_variables[0]
+            node = await self._add_source_variable_node(
+                parent_node, node_id, browse_name, address, sv
+            )
+            quasar_object = QuasarObject(self._server, klass, node, address)
+            quasar_object.source_variables[sv.name] = node
+        elif klass.single_variable_node:
+            node = await self._add_single_variable_node(
+                parent_node, node_id, browse_name, klass, instance
+            )
+            quasar_object = QuasarObject(self._server, klass, node, address)
+            quasar_object.cache_variables[klass.the_single_variable.name] = node
+        else:
+            node = await parent_node.add_object(
+                node_id, browse_name, objecttype=self._type_nodes[klass.name].nodeid
+            )
+            quasar_object = QuasarObject(self._server, klass, node, address)
+            for cv in klass.cache_variables:
+                var_node = await self._add_cache_variable(node, address, cv, instance)
+                quasar_object.cache_variables[cv.name] = var_node
+                if cv.address_space_write == "delegated":
+                    self.delegated_cache_variables.add(f"{address}.{cv.name}")
+            for sv in klass.source_variables:
+                sv_node = await self._add_source_variable(node, address, sv)
+                quasar_object.source_variables[sv.name] = sv_node
+            for entry in klass.config_entries:
+                await self._add_config_entry(node, address, entry, instance)
+            for method in klass.methods:
+                await self._add_method(node, address, method)
+
+        self.objects[address] = quasar_object
+        _check_cardinality(
+            klass.has_objects,
+            [child.class_name for child in instance.children],
+            where=f"<{klass.name} name={instance.name!r}>",
+        )
+
+        if self._calculated is not None:
+            for fv in instance.free_variables:
+                await self._calculated.add_free_variable(
+                    node, address, fv.name, fv.data_type, fv.initial_value
+                )
+            for calc in instance.calculated_variables:
+                await self._calculated.add_calculated_variable(
+                    node, address, calc.name, calc.formula
+                )
+
+        # children from the configuration...
+        for child in instance.children:
+            await self._instantiate(child, node, address)
+        # ...and children the Design mandates on every instance of this class
+        for rel in klass.has_objects:
+            if rel.instantiate_using != "design":
+                continue
+            for child_name in rel.design_instance_names:
+                await self._instantiate(
+                    Instance(class_name=rel.class_name, name=child_name), node, address
+                )
+        return quasar_object
+
+    # -- variables -----------------------------------------------------------
+
+    async def _add_single_variable_node(
+        self, parent_node: Node, node_id: ua.NodeId, browse_name: ua.QualifiedName,
+        klass: QuasarClass, instance: Instance,
+    ) -> Node:
+        """singleVariableNode classes collapse to one variable named as the instance."""
+        cv = klass.the_single_variable
+        data_value = self._initial_data_value(cv, instance)
+        node = await parent_node.add_variable(
+            node_id, browse_name, data_value.Value, datatype=self._data_type_attribute(cv)
+        )
+        await self._finalize_variable(node, cv, data_value)
+        return node
+
+    async def _add_cache_variable(
+        self, object_node: Node, parent_address: str, cv: CacheVariable, instance: Instance
+    ) -> Node:
+        node_id = ua.NodeId(f"{parent_address}.{cv.name}", self._ns)
+        data_value = self._initial_data_value(cv, instance)
+        node = await object_node.add_variable(
+            node_id,
+            ua.QualifiedName(cv.name, self._ns),
+            data_value.Value,
+            datatype=self._data_type_attribute(cv),
+        )
+        await self._finalize_variable(node, cv, data_value)
+        return node
+
+    @staticmethod
+    def _data_type_attribute(cv: CacheVariable) -> ua.NodeId:
+        """C++ quasar sets the concrete DataType only for nullForbidden variables;
+        nullAllowed ones keep BaseDataType so null writes stay legal."""
+        if cv.null_policy == "nullForbidden":
+            return oracle.data_type_node_id(cv.data_type)
+        return oracle.BASE_DATA_TYPE
+
+    async def _add_source_variable(
+        self, object_node: Node, parent_address: str, sv: SourceVariable
+    ) -> Node:
+        address = f"{parent_address}.{sv.name}"
+        return await self._add_source_variable_node(
+            object_node, ua.NodeId(address, self._ns),
+            ua.QualifiedName(sv.name, self._ns), address, sv,
+        )
+
+    async def _add_source_variable_node(
+        self, parent_node: Node, node_id: ua.NodeId, browse_name: ua.QualifiedName,
+        address: str, sv: SourceVariable,
+    ) -> Node:
+        """Source variables delegate reads/writes to device logic; until the first
+        interaction they hold a null value with BadWaitingForInitialData."""
+        initial = ua.DataValue(
+            ua.Variant(None, ua.VariantType.Null),
+            ua.StatusCode(ua.StatusCodes.BadWaitingForInitialData),
+        )
+        node = await parent_node.add_variable(
+            node_id,
+            browse_name,
+            initial.Value,
+            # source variables always expose the concrete design type (per oracle)
+            datatype=oracle.data_type_node_id(sv.data_type),
+        )
+        await self._write_value_rank(node, self._value_rank(sv.is_array, sv.data_type))
+        access = (1 if sv.is_readable else 0) | (2 if sv.is_writable else 0)
+        for attribute in (ua.AttributeIds.AccessLevel, ua.AttributeIds.UserAccessLevel):
+            await self._server.write_attribute_value(
+                node.nodeid,
+                ua.DataValue(ua.Variant(access, ua.VariantType.Byte)),
+                attribute,
+            )
+        await self._server.write_attribute_value(node.nodeid, initial)
+        self.source_variables[address] = sv
+        return node
+
+    async def _add_config_entry(
+        self, object_node: Node, parent_address: str, entry: ConfigEntry, instance: Instance
+    ) -> None:
+        """Scalar config entries surface as read-only properties, like C++ quasar
+        exposes them; array entries stay config-only (C++ parity)."""
+        if entry.is_array:
+            return
+        raw = instance.attributes.get(entry.name)
+        try:
+            if raw is not None:
+                oracle.check_restrictions(raw, entry.restrictions)
+            value = oracle.parse_design_value(raw, entry.data_type) if raw is not None else None
+        except ValueError as exc:
+            raise ConfigurationError(f"{instance.name}.{entry.name}: {exc}") from exc
+        variant = oracle.make_variant(value, entry.data_type, is_array=False)
+        node = await object_node.add_property(
+            ua.NodeId(f"{parent_address}.{entry.name}", self._ns),
+            ua.QualifiedName(entry.name, self._ns),
+            variant,
+            datatype=oracle.data_type_node_id(entry.data_type),
+        )
+        await self._write_value_rank(node, self._value_rank(False, entry.data_type))
+
+    async def _add_method(self, object_node: Node, parent_address: str, method: Method) -> None:
+        address = f"{parent_address}.{method.name}"
+        callback = (
+            self._make_dispatcher(parent_address, method)
+            if self._make_dispatcher is not None
+            else _not_implemented_method
+        )
+        method_node = await object_node.add_method(
+            ua.NodeId(address, self._ns),
+            ua.QualifiedName(method.name, self._ns),
+            callback,
+        )
+        # quasar publishes argument properties at <method>.args / <method>.return_values
+        if method.arguments:
+            await self._add_argument_property(
+                method_node, f"{address}.args", "InputArguments", method.arguments
+            )
+        if method.return_values:
+            await self._add_argument_property(
+                method_node, f"{address}.return_values", "OutputArguments", method.return_values
+            )
+
+    async def _add_argument_property(
+        self, method_node: Node, address: str, browse_name: str,
+        arguments: tuple[MethodArgument, ...],
+    ) -> None:
+        value = [
+            ua.Argument(
+                Name=arg.name,
+                DataType=oracle.data_type_node_id(arg.data_type),
+                ValueRank=self._value_rank(arg.is_array, arg.data_type),
+                ArrayDimensions=[],
+                Description=ua.LocalizedText(""),
+            )
+            for arg in arguments
+        ]
+        node = await method_node.add_property(
+            ua.NodeId(address, self._ns),
+            ua.QualifiedName(browse_name, 0),
+            value,
+            datatype=ua.NodeId(ua.ObjectIds.Argument),
+        )
+        await self._write_value_rank(node, 1)
+
+    @staticmethod
+    def _value_rank(is_array: bool, data_type: str) -> int:
+        """quasar semantics: arrays are one-dimensional; UaVariant is ScalarOrOneDimension."""
+        if is_array:
+            return 1
+        if data_type == "UaVariant":
+            return -3
+        return -1
+
+    async def _write_value_rank(self, node: Node, rank: int) -> None:
+        await self._server.write_attribute_value(
+            node.nodeid,
+            ua.DataValue(ua.Variant(rank, ua.VariantType.Int32)),
+            ua.AttributeIds.ValueRank,
+        )
+
+    async def _finalize_variable(self, node: Node, cv: CacheVariable, dv: ua.DataValue) -> None:
+        rank = self._value_rank(cv.is_array, cv.data_type)
+        await self._server.write_attribute_value(
+            node.nodeid,
+            ua.DataValue(ua.Variant(rank, ua.VariantType.Int32)),
+            ua.AttributeIds.ValueRank,
+        )
+        if cv.is_writable:
+            await node.set_writable(True)
+        # write the full DataValue (value + status) after creation: add_variable
+        # alone would leave status Good even for BadWaitingForInitialData designs
+        await self._server.write_attribute_value(node.nodeid, dv)
+
+    def _initial_data_value(self, cv: CacheVariable, instance: Instance | None) -> ua.DataValue:
+        if cv.initialize_with == "valueAndStatus":
+            if cv.initial_value is not None:
+                value = oracle.parse_design_value(cv.initial_value, cv.data_type)
+                variant = oracle.make_variant(value, cv.data_type, cv.is_array)
+            else:
+                variant = ua.Variant(None, ua.VariantType.Null)
+            if cv.initial_status is None:
+                raise DesignError(f"cache variable {cv.name}: valueAndStatus needs initialStatus")
+            status = oracle.initial_status(cv.initial_status)
+            return ua.DataValue(variant, ua.StatusCode(status))
+
+        if cv.initialize_with == "configuration":
+            where = instance.name if instance is not None else "<design>"
+            try:
+                if cv.is_array:
+                    if instance is not None and cv.name in instance.array_values:
+                        raw_values = instance.array_values[cv.name]
+                        for raw_element in raw_values:
+                            oracle.check_restrictions(raw_element, cv.restrictions)
+                        values = oracle.parse_design_array(raw_values, cv.data_type)
+                        variant = oracle.make_variant(values, cv.data_type, is_array=True)
+                        return ua.DataValue(variant, ua.StatusCode(ua.StatusCodes.Good))
+                    raw = None
+                else:
+                    raw = instance.attributes.get(cv.name) if instance is not None else None
+                    if raw is None:
+                        raw = cv.default_config_initializer_value
+                    if raw is not None:
+                        oracle.check_restrictions(raw, cv.restrictions)
+
+                if raw is None:
+                    if cv.null_policy == "nullForbidden":
+                        raise ConfigurationError(
+                            f"{where}: cache variable {cv.name} is nullForbidden but the "
+                            "configuration provides no value"
+                        )
+                    return ua.DataValue(
+                        ua.Variant(None, ua.VariantType.Null),
+                        ua.StatusCode(ua.StatusCodes.Good),
+                    )
+                value = oracle.parse_design_value(raw, cv.data_type)
+                variant = oracle.make_variant(value, cv.data_type, cv.is_array)
+            except ValueError as exc:
+                raise ConfigurationError(f"{where}.{cv.name}: {exc}") from exc
+            return ua.DataValue(variant, ua.StatusCode(ua.StatusCodes.Good))
+
+        raise DesignError(f"cache variable {cv.name}: unsupported initializeWith "
+                          f"{cv.initialize_with!r}")

kilonova/calculated.py

@@ -0,0 +1,234 @@
+"""quasar CalculatedVariables, pure Python.
+
+Config-level ``<FreeVariable>`` and ``<CalculatedVariable>`` elements become
+address-space variables; formulas (C++ quasar uses muParser) are compiled here
+to a whitelisted Python AST — no ``eval`` — whose inputs are dotted quasar
+addresses (``tc.fv``). Recalculation is wired through asyncua's server-side
+datachange callbacks, so a dependent value is recomputed *inside* the write
+that changed its input: the very next read is already fresh.
+
+Supported formula syntax: numbers, dotted addresses, ``+ - * / % **`` and
+unary minus (muParser's ``^`` is accepted and treated as power),
+``$thisObjectAddress`` substitution and ``$applyGenericFormula(Name)``.
+"""
+
+from __future__ import annotations
+
+import ast
+import logging
+import re
+from dataclasses import dataclass, field
+
+from asyncua import ua
+
+from kilonova.errors import ConfigurationError
+
+_log = logging.getLogger(__name__)
+
+_BINOPS = {
+    ast.Add: lambda a, b: a + b,
+    ast.Sub: lambda a, b: a - b,
+    ast.Mult: lambda a, b: a * b,
+    ast.Div: lambda a, b: a / b,
+    ast.Mod: lambda a, b: a % b,
+    ast.Pow: lambda a, b: a**b,
+}
+
+_GENERIC_CALL = re.compile(r"\$applyGenericFormula\((\w+)\)")
+
+
+@dataclass
+class CompiledFormula:
+    text: str
+    tree: ast.Expression
+    inputs: tuple[str, ...] = field(default_factory=tuple)
+
+
+def _address_of(node: ast.expr) -> str | None:
+    """Reconstruct a dotted quasar address from a Name/Attribute chain."""
+    parts = []
+    while isinstance(node, ast.Attribute):
+        parts.append(node.attr)
+        node = node.value
+    if isinstance(node, ast.Name):
+        parts.append(node.id)
+        return ".".join(reversed(parts))
+    return None
+
+
+def compile_formula(text: str) -> CompiledFormula:
+    """Parse and validate a formula; muParser's ``^`` is mapped to python ``**``."""
+    normalized = text.strip().replace("^", "**")
+    try:
+        tree = ast.parse(normalized, mode="eval")
+    except SyntaxError as exc:
+        raise ConfigurationError(f"cannot parse formula {text!r}: {exc}") from exc
+
+    inputs: list[str] = []
+
+    def validate(node: ast.expr) -> None:
+        if isinstance(node, ast.BinOp) and type(node.op) in _BINOPS:
+            validate(node.left)
+            validate(node.right)
+        elif isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.UAdd, ast.USub)):
+            validate(node.operand)
+        elif isinstance(node, ast.Constant) and isinstance(node.value, (int, float)):
+            pass
+        elif (address := _address_of(node)) is not None:
+            if address not in inputs:
+                inputs.append(address)
+        else:
+            raise ConfigurationError(
+                f"formula {text!r}: unsupported construct {ast.dump(node)[:60]}"
+            )
+
+    validate(tree.body)
+    return CompiledFormula(text=text, tree=tree, inputs=tuple(inputs))
+
+
+def evaluate(compiled: CompiledFormula, env: dict[str, float]) -> float:
+    def walk(node: ast.expr) -> float:
+        if isinstance(node, ast.BinOp):
+            return _BINOPS[type(node.op)](walk(node.left), walk(node.right))
+        if isinstance(node, ast.UnaryOp):
+            operand = walk(node.operand)
+            return -operand if isinstance(node.op, ast.USub) else operand
+        if isinstance(node, ast.Constant):
+            return float(node.value)
+        return env[_address_of(node)]
+
+    return walk(compiled.tree.body)
+
+
+_FREE_VARIABLE_PARSERS = {
+    "Boolean": lambda text: text in ("true", "1", "OpcUa_True"),
+    "Float": float,
+    "Double": float,
+    "String": str,
+}
+
+
+class CalculatedVariablesEngine:
+    """Owns free variables, formulas, the dependency graph, and recomputation."""
+
+    def __init__(self, ua_server, namespace_index: int):
+        self._server = ua_server
+        self._ns = namespace_index
+        self._formulas: dict[str, CompiledFormula] = {}
+        self._dependents: dict[str, list[str]] = {}
+        self._generic_formulas: dict[str, str] = {}
+        self._last: dict[str, object] = {}
+
+    def register_generic_formula(self, name: str, formula: str) -> None:
+        self._generic_formulas[name] = formula
+
+    def resolve_formula_text(self, text: str, this_object_address: str) -> str:
+        def expand_generic(match: re.Match) -> str:
+            try:
+                return f"({self._generic_formulas[match.group(1)]})"
+            except KeyError:
+                raise ConfigurationError(
+                    f"unknown generic formula {match.group(1)!r}"
+                ) from None
+
+        text = _GENERIC_CALL.sub(expand_generic, text)
+        return text.replace("$thisObjectAddress.", f"{this_object_address}." if
+                            this_object_address else "")
+
+    async def add_free_variable(
+        self, parent_node, parent_address: str, name: str, data_type: str,
+        initial_value: str | None,
+    ) -> None:
+        address = f"{parent_address}.{name}" if parent_address else name
+        try:
+            variant_type = ua.VariantType[data_type]
+        except KeyError:
+            raise ConfigurationError(
+                f"free variable {address}: unknown type {data_type!r}"
+            ) from None
+        parser = _FREE_VARIABLE_PARSERS.get(data_type, int)
+        value = parser(initial_value) if initial_value is not None else None
+        node = await parent_node.add_variable(
+            ua.NodeId(address, self._ns),
+            ua.QualifiedName(name, self._ns),
+            ua.Variant(value, variant_type if value is not None else ua.VariantType.Null),
+            datatype=ua.NodeId(variant_type.value),
+        )
+        await node.set_writable(True)
+
+    async def add_calculated_variable(
+        self, parent_node, parent_address: str, name: str, formula_text: str
+    ) -> None:
+        address = f"{parent_address}.{name}" if parent_address else name
+        resolved = self.resolve_formula_text(formula_text, parent_address)
+        compiled = compile_formula(resolved)
+        # like the C++ oracle: calculated variables expose BaseDataType, read-only
+        await parent_node.add_variable(
+            ua.NodeId(address, self._ns),
+            ua.QualifiedName(name, self._ns),
+            ua.Variant(None, ua.VariantType.Null),
+            datatype=ua.NodeId(ua.ObjectIds.BaseDataType),
+        )
+        self._formulas[address] = compiled
+        for input_address in compiled.inputs:
+            self._dependents.setdefault(input_address, []).append(address)
+
+    async def wire_and_evaluate(self) -> None:
+        """Subscribe to every input and compute initial values (document order)."""
+        aspace = self._server.iserver.aspace
+        for input_address in self._dependents:
+            status, _handle = aspace.add_datachange_callback(
+                ua.NodeId(input_address, self._ns),
+                ua.AttributeIds.Value,
+                self._make_input_listener(input_address),
+            )
+            if not status.is_good():
+                raise ConfigurationError(
+                    f"calculated variables: input {input_address!r} does not exist"
+                )
+        for address in self._formulas:
+            await self._recompute(address)
+
+    def _make_input_listener(self, input_address: str):
+        async def on_change(_handle, _data_value) -> None:
+            for dependent in self._dependents.get(input_address, ()):
+                await self._recompute(dependent)
+
+        return on_change
+
+    async def _recompute(self, address: str) -> None:
+        aspace = self._server.iserver.aspace
+        compiled = self._formulas[address]
+        env: dict[str, float] = {}
+        good = True
+        for input_address in compiled.inputs:
+            data_value = aspace.read_attribute_value(
+                ua.NodeId(input_address, self._ns), ua.AttributeIds.Value
+            )
+            value = data_value.Value.Value if data_value.Value is not None else None
+            in_status = data_value.StatusCode
+            if value is None or (in_status is not None and not in_status.is_good()):
+                good = False
+                break
+            env[input_address] = float(value)
+
+        if good:
+            try:
+                result = evaluate(compiled, env)
+            except ArithmeticError:
+                good = False
+        if good:
+            new = (result, ua.StatusCodes.Good)
+        else:
+            new = (None, ua.StatusCodes.BadWaitingForInitialData)
+        if self._last.get(address) == new:
+            return  # unchanged: stop propagation (also breaks accidental cycles)
+        self._last[address] = new
+        data_value = (
+            ua.DataValue(ua.Variant(new[0], ua.VariantType.Double), ua.StatusCode(new[1]))
+            if good
+            else ua.DataValue(ua.Variant(None, ua.VariantType.Null), ua.StatusCode(new[1]))
+        )
+        await aspace.write_attribute_value(
+            ua.NodeId(address, self._ns), ua.AttributeIds.Value, data_value
+        )