Filter Event Handler Expression (#197)

* lib/filtereventhandler: Add support for general expression

* lib/filtereventhandler: Add test cases

* lib/filtereventhandler: Handle eval exceptions

Author: ccrisan

qtoggleserver/lib/filtereventhandler.py

@@ -6,6 +6,7 @@
 from qtoggleserver.core import expressions as core_expressions
 from qtoggleserver.core import ports as core_ports
 from qtoggleserver.core.expressions import exceptions as expression_exceptions
+from qtoggleserver.core.expressions.exceptions import ExpressionEvalException
 from qtoggleserver.core.typing import Attribute, Attributes, NullablePortValue
 from qtoggleserver.slaves import devices as slaves_devices
 from qtoggleserver.slaves import events as slaves_events
@@ -41,6 +42,8 @@ def __init__(self, *, filter: dict | None = None, name: str | None = None) -> No
         self._filter_slave_attr_transitions: dict[str, tuple[Attribute, Attribute]] = {}
         self._filter_slave_attr_names: set[str] = set()
 
+        self._filter_expression: core_expressions.Expression | None = None
+
         # Maintain an internal "last" state for all objects, so we can detect changes in attributes and values
         self._device_attrs: Attributes | dict[str, list[Attribute]] = {}
         self._port_values: dict[str, NullablePortValue] = {}
@@ -113,6 +116,18 @@ def _prepare_filter(self) -> None:
         self._filter_slave_attr_names.update(self._filter_slave_attrs.keys())
         self._filter_slave_attr_names.update(self._filter_slave_attr_transitions.keys())
 
+        filter_sexpression = self._filter.get("expression")
+        if isinstance(filter_sexpression, str):
+            try:
+                self.debug('using filter expression "%s"', filter_sexpression)
+                self._filter_expression = core_expressions.parse(
+                    self_port_id=None, sexpression=filter_sexpression, role=core_expressions.Role.FILTER
+                )
+            except expression_exceptions.ExpressionParseError as e:
+                self.error('failed to parse filter expression "%s": %s', filter_sexpression, e)
+
+                raise
+
         self._filter_prepared = True
         self.debug("filter prepared")
 
@@ -261,7 +276,11 @@ async def accepts_port_value(
             elif isinstance(self._filter_port_value, core_expressions.Expression):  # an expression
                 port_values = {p.get_id(): p.get_last_read_value() for p in core_ports.get_all() if p.is_enabled()}
                 eval_context = core_expressions.EvalContext(port_values=port_values, now_ms=int(time.time() * 1000))
-                if new_value != await self._filter_port_value.eval(context=eval_context):
+                try:
+                    if new_value != await self._filter_port_value.eval(context=eval_context):
+                        return False
+                except ExpressionEvalException as e:
+                    self.warning('Expression evaluation failed for "%s": %s', self._filter_port_value, e)
                     return False
             elif new_value != self._filter_port_value:
                 return False
@@ -322,6 +341,16 @@ async def accepts(
         ):
             return False
 
+        if self._filter_expression:
+            port_values = {p.get_id(): p.get_last_read_value() for p in core_ports.get_all() if p.is_enabled()}
+            eval_context = core_expressions.EvalContext(port_values=port_values, now_ms=int(time.time() * 1000))
+            try:
+                if not await self._filter_expression.eval(context=eval_context):
+                    return False
+            except ExpressionEvalException as e:
+                self.warning('Expression evaluation failed for "%s": %s', self._filter_expression, e)
+                return False
+
         return True
 
     def get_device_attrs(self) -> Attributes: