state_trigger now allows a simple variable name, and multiple arguments; see #44

Author: craigbarratt

custom_components/pyscript/eval.py

@@ -384,15 +384,26 @@ async def do_service_call(func, ast_ctx, data):
         # strings
         #
         arg_check = {
-            "event_trigger": {1, 2},
-            "state_active": {1},
-            "state_trigger": {1},
-            "task_unique": {1},
-            "time_active": {"*"},
-            "time_trigger": {"*"},
+            "event_trigger": {"arg_cnt": {1, 2}},
+            "state_active": {"arg_cnt": {1}},
+            "state_trigger": {"arg_cnt": {"*"}, "type": {list, set}},
+            "task_unique": {"arg_cnt": {1}},
+            "time_active": {"arg_cnt": {"*"}},
+            "time_trigger": {"arg_cnt": {0, "*"}},
         }
-        for dec_name, arg_cnt in arg_check.items():
-            if dec_name not in trig_args or trig_args[dec_name]["args"] is None:
+        for dec_name, arg_info in arg_check.items():
+            arg_cnt = arg_info["arg_cnt"]
+            if dec_name not in trig_args:
+                continue
+            if trig_args[dec_name]["args"] is None:
+                if 0 not in arg_cnt:
+                    self.logger.error(
+                        "%s defined in %s: decorator @%s needs at least one argument; ignoring decorator",
+                        self.name,
+                        self.global_ctx_name,
+                        dec_name,
+                    )
+                    del trig_args[dec_name]
                 continue
             if "*" not in arg_cnt and len(trig_args[dec_name]["args"]) not in arg_cnt:
                 self.logger.error(
@@ -405,18 +416,30 @@ async def do_service_call(func, ast_ctx, data):
                     " or ".join([str(cnt) for cnt in sorted(arg_cnt)]),
                 )
                 del trig_args[dec_name]
-                break
+                continue
             for arg_num, arg in enumerate(trig_args[dec_name]["args"]):
-                if not isinstance(arg, str):
-                    self.logger.error(
-                        "%s defined in %s: decorator @%s argument %d should be a string; ignoring decorator",
-                        self.name,
-                        self.global_ctx_name,
-                        dec_name,
-                        arg_num + 1,
-                    )
-                    del trig_args[dec_name]
-                    break
+                if isinstance(arg, str):
+                    continue
+                mesg = "string"
+                if "type" in arg_info:
+                    if type(arg) in arg_info["type"]:
+                        for val in arg:
+                            if not isinstance(val, str):
+                                break
+                        else:
+                            continue
+                        for ok_type in arg_info["type"]:
+                            mesg += f", or {ok_type.__name__}"
+                self.logger.error(
+                    "%s defined in %s: decorator @%s argument %d should be a %s; ignoring decorator",
+                    self.name,
+                    self.global_ctx_name,
+                    dec_name,
+                    arg_num + 1,
+                    mesg,
+                )
+                del trig_args[dec_name]
+                continue
             if arg_cnt == {1}:
                 trig_args[dec_name]["args"] = trig_args[dec_name]["args"][0]
 

custom_components/pyscript/state.py

@@ -95,9 +95,6 @@ def notify_var_get(cls, var_names, new_vars):
                 notify_vars[var_name] = new_vars[var_name]
             elif 1 <= var_name.count(".") <= 2 and not cls.exist(var_name):
                 notify_vars[var_name] = None
-        _LOGGER.debug(
-            "notify_var_get var_names=%s, new_vars=%s, notify_vars=%s", var_names, new_vars, notify_vars
-        )
         return notify_vars
 
     @classmethod
@@ -115,6 +112,7 @@ def set(cls, var_name, value, new_attributes=None, **kwargs):
             new_attributes = new_attributes.copy()
             new_attributes.update(kwargs)
         _LOGGER.debug("setting %s = %s, attr = %s", var_name, value, new_attributes)
+        cls.notify_var_last[var_name] = str(value)
         cls.hass.states.async_set(var_name, value, new_attributes)
 
     @classmethod

custom_components/pyscript/trigger.py

@@ -21,6 +21,9 @@
 _LOGGER = logging.getLogger(LOGGER_PATH + ".trigger")
 
 
+STATE_RE = re.compile(r"[a-zA-Z]\w*\.[a-zA-Z]\w*$")
+
+
 def dt_now():
     """Return current time."""
     return dt.datetime.now()
@@ -101,32 +104,57 @@ async def wait_until(
                 await asyncio.sleep(timeout)
                 return {"trigger_type": "timeout"}
             return {"trigger_type": "none"}
-        state_trig_ident = None
-        state_trig_expr = None
+        state_trig_ident = set()
+        state_trig_ident_any = set()
+        state_trig_eval = None
         event_trig_expr = None
         exc = None
         notify_q = asyncio.Queue(0)
         if state_trigger is not None:
-            state_trig_expr = AstEval(
-                f"{ast_ctx.name} state_trigger",
-                ast_ctx.get_global_ctx(),
-                logger_name=ast_ctx.get_logger_name(),
-            )
-            Function.install_ast_funcs(state_trig_expr)
-            state_trig_expr.parse(state_trigger)
-            exc = state_trig_expr.get_exception_obj()
-            if exc is not None:
-                raise exc
+            state_trig = []
+            if isinstance(state_trigger, str):
+                state_trigger = [state_trigger]
+            elif isinstance(state_trigger, set):
+                state_trigger = list(state_trigger)
             #
-            # check straight away to see if the condition is met (to avoid race conditions)
+            # separate out the entries that are just state var names, which mean trigger
+            # on any change (no expr)
             #
-            state_trig_ok = await state_trig_expr.eval()
-            exc = state_trig_expr.get_exception_obj()
-            if exc is not None:
-                raise exc
-            if state_trig_ok:
-                return {"trigger_type": "state"}
-            state_trig_ident = await state_trig_expr.get_names()
+            for trig in state_trigger:
+                if STATE_RE.match(trig):
+                    state_trig_ident_any.add(trig)
+                else:
+                    state_trig.append(trig)
+
+            if len(state_trig) > 0:
+                if len(state_trig) == 1:
+                    state_trig_expr = state_trig[0]
+                else:
+                    state_trig_expr = f"any([{', '.join(state_trig)}])"
+                state_trig_eval = AstEval(
+                    f"{ast_ctx.name} state_trigger",
+                    ast_ctx.get_global_ctx(),
+                    logger_name=ast_ctx.get_logger_name(),
+                )
+                Function.install_ast_funcs(state_trig_eval)
+                state_trig_eval.parse(state_trig_expr)
+                state_trig_ident = await state_trig_eval.get_names()
+                exc = state_trig_eval.get_exception_obj()
+                if exc is not None:
+                    raise exc
+
+            state_trig_ident.update(state_trig_ident_any)
+            if state_trig_eval:
+                #
+                # check straight away to see if the condition is met (to avoid race conditions)
+                #
+                state_trig_ok = await state_trig_eval.eval(State.notify_var_get(state_trig_ident, {}))
+                exc = state_trig_eval.get_exception_obj()
+                if exc is not None:
+                    raise exc
+                if state_trig_ok:
+                    return {"trigger_type": "state"}
+
             _LOGGER.debug(
                 "trigger %s wait_until: watching vars %s", ast_ctx.name, state_trig_ident,
             )
@@ -145,7 +173,7 @@ async def wait_until(
                 event_trig_expr.parse(event_trigger[1])
                 exc = event_trig_expr.get_exception_obj()
                 if exc is not None:
-                    if state_trig_ident:
+                    if len(state_trig_ident) > 0:
                         State.notify_del(state_trig_ident, notify_q)
                     raise exc
             Event.notify_add(event_trigger[0], notify_q)
@@ -191,11 +219,19 @@ async def wait_until(
                             ret["trigger_time"] = time_next
                     break
             if notify_type == "state":
-                new_vars = notify_info[0] if notify_info else None
-                state_trig_ok = await state_trig_expr.eval(new_vars)
-                exc = state_trig_expr.get_exception_obj()
-                if exc is not None:
-                    break
+                if notify_info:
+                    new_vars, func_args = notify_info
+                else:
+                    new_vars, func_args = None, {}
+
+                state_trig_ok = False
+                if func_args.get("var_name", "") in state_trig_ident_any:
+                    state_trig_ok = True
+                elif state_trig_eval:
+                    state_trig_ok = await state_trig_eval.eval(new_vars)
+                    exc = state_trig_eval.get_exception_obj()
+                    if exc is not None:
+                        break
                 if state_trig_ok:
                     ret = notify_info[1] if notify_info else None
                     break
@@ -215,7 +251,7 @@ async def wait_until(
                     "trigger %s wait_until got unexpected queue message %s", ast_ctx.name, notify_type,
                 )
 
-        if state_trig_ident:
+        if len(state_trig_ident) > 0:
             State.notify_del(state_trig_ident, notify_q)
         if event_trigger is not None:
             Event.notify_del(event_trigger[0], notify_q)
@@ -454,7 +490,9 @@ def __init__(
         self.active_expr = None
         self.state_active_ident = None
         self.state_trig_expr = None
+        self.state_trig_eval = None
         self.state_trig_ident = None
+        self.state_trig_ident_any = set()
         self.event_trig_expr = None
         self.have_trigger = False
         self.setup_ok = False
@@ -481,15 +519,36 @@ def __init__(
             self.run_on_startup = True
 
         if self.state_trigger is not None:
-            self.state_trig_expr = AstEval(
-                f"{self.name} @state_trigger()", self.global_ctx, logger_name=self.name
-            )
-            Function.install_ast_funcs(self.state_trig_expr)
-            self.state_trig_expr.parse(self.state_trigger)
-            exc = self.state_trig_expr.get_exception_long()
-            if exc is not None:
-                self.state_trig_expr.get_logger().error(exc)
-                return
+            state_trig = []
+            for triggers in self.state_trigger:
+                if isinstance(triggers, str):
+                    triggers = [triggers]
+                elif isinstance(triggers, set):
+                    triggers = list(triggers)
+                #
+                # separate out the entries that are just state var names, which mean trigger
+                # on any change (no expr)
+                #
+                for trig in triggers:
+                    if STATE_RE.match(trig):
+                        self.state_trig_ident_any.add(trig)
+                    else:
+                        state_trig.append(trig)
+
+            if len(state_trig) > 0:
+                if len(state_trig) == 1:
+                    self.state_trig_expr = state_trig[0]
+                else:
+                    self.state_trig_expr = f"any([{', '.join(state_trig)}])"
+                self.state_trig_eval = AstEval(
+                    f"{self.name} @state_trigger()", self.global_ctx, logger_name=self.name
+                )
+                Function.install_ast_funcs(self.state_trig_eval)
+                self.state_trig_eval.parse(self.state_trig_expr)
+                exc = self.state_trig_eval.get_exception_long()
+                if exc is not None:
+                    self.state_trig_eval.get_logger().error(exc)
+                    return
             self.have_trigger = True
 
         if self.event_trigger is not None:
@@ -530,7 +589,10 @@ async def trigger_watch(self):
         try:
 
             if self.state_trigger is not None:
-                self.state_trig_ident = await self.state_trig_expr.get_names()
+                self.state_trig_ident = set()
+                if self.state_trig_eval:
+                    self.state_trig_ident = await self.state_trig_eval.get_names()
+                self.state_trig_ident.update(self.state_trig_ident_any)
                 _LOGGER.debug("trigger %s: watching vars %s", self.name, self.state_trig_ident)
                 if len(self.state_trig_ident) > 0:
                     State.notify_add(self.state_trig_ident, self.notify_q)
@@ -587,11 +649,14 @@ async def trigger_watch(self):
                 if notify_type == "state":
                     new_vars, func_args = notify_info
 
-                    if self.state_trig_expr:
-                        trig_ok = await self.state_trig_expr.eval(new_vars)
-                        exc = self.state_trig_expr.get_exception_long()
-                        if exc is not None:
-                            self.state_trig_expr.get_logger().error(exc)
+                    if func_args["var_name"] not in self.state_trig_ident_any:
+                        if self.state_trig_eval:
+                            trig_ok = await self.state_trig_eval.eval(new_vars)
+                            exc = self.state_trig_eval.get_exception_long()
+                            if exc is not None:
+                                self.state_trig_eval.get_logger().error(exc)
+                                trig_ok = False
+                        else:
                             trig_ok = False
 
                 elif notify_type == "event":

docs/reference.rst

@@ -165,15 +165,19 @@ function.
 
 .. code:: python
 
-    @state_trigger(str_expr)
+    @state_trigger(str_expr, ...)
 
-``@state_trigger`` takes a single string ``str_expr`` that contains any expression based on one or
+``@state_trigger`` takes one or more string arguments that contain any expression based on one or
 more state variables, and evaluates to ``True`` or ``False`` (or non-zero or zero). Whenever the
 state variables mentioned in the expression change, the expression is evaluated and the trigger
 occurs if it evaluates to ``True`` (or non-zero). For each state variable, eg: ``domain.name``,
 the prior value is also available to the expression as ``domain.name.old`` in case you want to
 condition the trigger on the prior value too.
 
+Multiple arguments are logically "or"ed together, so the trigger occurs if any of the expressions
+evaluate to ``True``. Any argument can alternatively be be a list or set of strings, and they are
+treated the same as multiple arguments by "or"ing them together.
+
 All state variables in HASS have string values. So you’ll have to do comparisons against string
 values or cast the variable to an integer or float. These two examples are essentially equivalent
 (note the use of single quotes inside the outer double quotes):
@@ -194,20 +198,15 @@ You can also use state variable attributes in the trigger expression, with an id
 form ``DOMAIN.name.attr``. Attributes maintain their original type, so there is no need to cast
 then to another type.
 
-If you specify ``@state_trigger("True")`` the state trigger will never occur. While that might seem
-counter-intuitive, the reason is that the expression will never be evaluated - it takes underlying
-state variables in the expression to change before the expression is evaluated. Since this
-expression has no state variables, it will never be evaluated. You can achieve a state trigger
-on any value change with a decorator of the form:
+You can specify a state trigger on any change with a string that is just the state variable name:
 
 .. code:: python
 
-   @state_trigger("True or domain.light_level")
+   @state_trigger("domain.light_level")
 
-The reason this works is that the expression is evaluated every time ``domain.light_level`` changes.
-Because of operator short-circuiting, the expression evaluates to ``True`` without even checking the
-value of ``domain.light_level``. So the result is a trigger whenever the state variable changes to
-any value. This idea can extend to multiple variables just by stringing them together.
+The trigger can include arguments with any mixture of string expressions (that are evaluated
+when any of the underlying state variable change) and string state variable names (that trigger
+whenever that variable changes).
 
 Note that if a state variable is set to the same value, HASS doesn’t generate a state change event,
 so the ``@state_trigger`` condition will not be checked. It is only evaluated each time a state
@@ -649,7 +648,8 @@ Task waiting
 
 It takes the following keyword arguments (all are optional):
 
-- ``state_trigger=None`` can be set to a string just like ``@state_trigger``.
+- ``state_trigger=None`` can be set to a string just like ``@state_trigger``, or it can be
+  a list of strings that are logically "or"ed together.
 - ``time_trigger=None`` can be set to a string or list of strings with
   datetime specifications, just like ``@time_trigger``.
 - ``event_trigger=None`` can be set to a string or list of two strings, just like