adds @time_trigger("shutdown") to run on shutdown or reload; see #103

tests and docs still need updating

Author: craigbarratt

custom_components/pyscript/__init__.py

@@ -255,6 +255,7 @@ async def unload_scripts(global_ctx_only=None, unload_all=False):
         ctx_delete[global_ctx_name] = global_ctx
     for global_ctx_name, global_ctx in ctx_delete.items():
         GlobalContextMgr.delete(global_ctx_name)
+    await Function.reaper_sync()
 
 
 @bind_hass
@@ -307,7 +308,6 @@ def glob_read_files(load_paths, apps_config):
                     continue
                 mod_name = rel_path[0:-3]
                 if mod_name.endswith("/__init__"):
-                    # mod_name = mod_name[0 : -len("/__init__")]
                     rel_import_path = mod_name
                 mod_name = mod_name.replace("/", ".")
                 if path == "":
@@ -497,6 +497,7 @@ def import_recurse(ctx_name, visited, ctx2imports):
             global_ctx.stop()
             _LOGGER.debug("reload: deleting global_ctx=%s", global_ctx_name)
             GlobalContextMgr.delete(global_ctx_name)
+    await Function.reaper_sync()
 
     #
     # now load the requested files, and files that depend on loaded files

custom_components/pyscript/function.py

@@ -48,9 +48,10 @@ class Function:
     ast_functions = {}
 
     #
-    # task id of the task that cancel and waits for other tasks
+    # task id of the task that cancels and waits for other tasks,
+    # and also awaits on coros
     #
-    task_cancel_repeaer = None
+    task_repeaer = None
 
     def __init__(self):
         """Warn on Function instantiation."""
@@ -84,35 +85,64 @@ def init(cls, hass):
         # start a task which is a reaper for canceled tasks, since some # functions
         # like TrigInfo.stop() can't be async (it's called from a __del__ method)
         #
-        async def task_cancel_reaper(reaper_q):
+        async def task_reaper(reaper_q):
             while True:
                 try:
-                    try:
-                        task = await reaper_q.get()
-                        if task is None:
-                            return
-                        task.cancel()
-                        await task
-                    except asyncio.CancelledError:
-                        pass
+                    cmd = await reaper_q.get()
+                    if cmd[0] == "exit":
+                        return
+                    if cmd[0] == "cancel":
+                        try:
+                            cmd[1].cancel()
+                            await cmd[1]
+                        except asyncio.CancelledError:
+                            pass
+                    elif cmd[0] == "await":
+                        await cmd[1]
+                    elif cmd[0] == "sync":
+                        await cmd[1].put(0)
+                    else:
+                        _LOGGER.error("task_reaper: unknown command %s", cmd[0])
                 except asyncio.CancelledError:
                     raise
                 except Exception:
-                    _LOGGER.error("task_cancel_reaper: got exception %s", traceback.format_exc(-1))
+                    _LOGGER.error("task_reaper: got exception %s", traceback.format_exc(-1))
 
-        if not cls.task_cancel_repeaer:
+        if not cls.task_repeaer:
             cls.task_reaper_q = asyncio.Queue(0)
-            cls.task_cancel_repeaer = Function.create_task(task_cancel_reaper(cls.task_reaper_q))
+            cls.task_repeaer = Function.create_task(task_reaper(cls.task_reaper_q))
 
     @classmethod
     async def reaper_stop(cls):
         """Tell the reaper task to exit by sending a special task None."""
-        if cls.task_cancel_repeaer:
-            cls.task_cancel(None)
-            await cls.task_cancel_repeaer
-            cls.task_cancel_repeaer = None
+        if cls.task_repeaer:
+            cls.task_reaper_q.put_nowait(["exit"])
+            await cls.task_repeaer
+            cls.task_repeaer = None
             cls.task_reaper_q = None
 
+    @classmethod
+    def reaper_cancel(cls, task):
+        """Send a task to be canceled by the reaper."""
+        cls.task_reaper_q.put_nowait(["cancel", task])
+
+    @classmethod
+    def reaper_await(cls, coro):
+        """Send a coro to be awaited by the reaper."""
+        cls.task_reaper_q.put_nowait(["await", coro])
+
+    @classmethod
+    async def reaper_sync(cls):
+        """Wait until the reaper queue is empty."""
+        sync_q = asyncio.Queue(0)
+        sync_q.put_nowait(["sync", sync_q])
+        await sync_q.get()
+
+    @classmethod
+    def reaper_exit(cls):
+        """Send an exit request to the reaper."""
+        cls.task_reaper_q.put_nowait(["exit"])
+
     @classmethod
     async def async_sleep(cls, duration):
         """Implement task.sleep()."""
@@ -152,7 +182,7 @@ async def task_unique(name, kill_me=False):
                         # it seems we can't cancel ourselves, so we
                         # tell the repeaer task to cancel us
                         #
-                        Function.task_cancel(curr_task)
+                        Function.reaper_cancel(curr_task)
                         # wait to be canceled
                         await asyncio.sleep(100000)
                 elif task != curr_task and task in cls.our_tasks:
@@ -313,8 +343,3 @@ async def run_coro(cls, coro):
     def create_task(cls, coro):
         """Create a new task that runs a coroutine."""
         return cls.hass.loop.create_task(cls.run_coro(coro))
-
-    @classmethod
-    def task_cancel(cls, task):
-        """Send a task to be canceled by the reaper."""
-        cls.task_reaper_q.put_nowait(task)

custom_components/pyscript/trigger.py

@@ -690,6 +690,7 @@ def __init__(
         self.have_trigger = False
         self.setup_ok = False
         self.run_on_startup = False
+        self.run_on_shutdown = False
 
         if self.state_active is not None:
             self.active_expr = AstEval(
@@ -702,14 +703,17 @@ def __init__(
                 self.active_expr.get_logger().error(exc)
                 return
 
+        if "time_trigger" in trig_cfg and self.time_trigger is None:
+            self.run_on_startup = True
         if self.time_trigger is not None:
             while "startup" in self.time_trigger:
                 self.run_on_startup = True
                 self.time_trigger.remove("startup")
+            while "shutdown" in self.time_trigger:
+                self.run_on_shutdown = True
+                self.time_trigger.remove("shutdown")
             if len(self.time_trigger) == 0:
                 self.time_trigger = None
-        if "time_trigger" in trig_cfg and self.time_trigger is None:
-            self.run_on_startup = True
 
         if self.state_trigger is not None:
             state_trig = []
@@ -783,7 +787,12 @@ def stop(self):
             if self.mqtt_trigger is not None:
                 Mqtt.notify_del(self.mqtt_trigger[0], self.notify_q)
             if self.task:
-                Function.task_cancel(self.task)
+                Function.reaper_cancel(self.task)
+        if self.run_on_shutdown:
+            notify_type = "shutdown"
+            notify_info = {"trigger_type": "shutdown", "trigger_time": None}
+            action_future = self.call_action(notify_type, notify_info, run_task=False)
+            Function.reaper_await(action_future)
 
     def start(self):
         """Start this trigger task."""
@@ -1000,30 +1009,6 @@ async def trigger_watch(self):
                     )
                     continue
 
-                action_ast_ctx = AstEval(
-                    f"{self.action.global_ctx_name}.{self.action.name}", self.action.global_ctx
-                )
-                Function.install_ast_funcs(action_ast_ctx)
-                task_unique_func = None
-                if self.task_unique is not None:
-                    task_unique_func = Function.task_unique_factory(action_ast_ctx)
-
-                #
-                # check for @task_unique with kill_me=True
-                #
-                if (
-                    self.task_unique is not None
-                    and self.task_unique_kwargs
-                    and self.task_unique_kwargs["kill_me"]
-                    and Function.unique_name_used(action_ast_ctx, self.task_unique)
-                ):
-                    _LOGGER.debug(
-                        "trigger %s got %s trigger, @task_unique kill_me=True prevented new action",
-                        notify_type,
-                        self.name,
-                    )
-                    continue
-
                 if (
                     self.time_active_hold_off is not None
                     and last_trig_time is not None
@@ -1037,49 +1022,8 @@ async def trigger_watch(self):
                     )
                     continue
 
-                # Create new HASS Context with incoming as parent
-                if "context" in func_args and isinstance(func_args["context"], Context):
-                    hass_context = Context(parent_id=func_args["context"].id)
-                else:
-                    hass_context = Context()
-
-                # Fire an event indicating that pyscript is running
-                # Note: the event must have an entity_id for logbook to work correctly.
-                ev_name = self.name.replace(".", "_")
-                ev_entity_id = f"pyscript.{ev_name}"
-
-                event_data = dict(name=ev_name, entity_id=ev_entity_id, func_args=func_args)
-                Function.hass.bus.async_fire("pyscript_running", event_data, context=hass_context)
-
-                _LOGGER.debug(
-                    "trigger %s got %s trigger, running action (kwargs = %s)",
-                    self.name,
-                    notify_type,
-                    func_args,
-                )
-
-                async def do_func_call(func, ast_ctx, task_unique, task_unique_func, hass_context, **kwargs):
-                    # Store HASS Context for this Task
-                    Function.store_hass_context(hass_context)
-
-                    if task_unique and task_unique_func:
-                        await task_unique_func(task_unique)
-                    await func.call(ast_ctx, **kwargs)
-                    if ast_ctx.get_exception_obj():
-                        ast_ctx.get_logger().error(ast_ctx.get_exception_long())
-
-                last_trig_time = time.monotonic()
-
-                Function.create_task(
-                    do_func_call(
-                        self.action,
-                        action_ast_ctx,
-                        self.task_unique,
-                        task_unique_func,
-                        hass_context,
-                        **func_args,
-                    )
-                )
+                if self.call_action(notify_type, func_args):
+                    last_trig_time = time.monotonic()
 
         except asyncio.CancelledError:
             raise
@@ -1094,3 +1038,63 @@ async def do_func_call(func, ast_ctx, task_unique, task_unique_func, hass_contex
             if self.mqtt_trigger is not None:
                 Mqtt.notify_del(self.mqtt_trigger[0], self.notify_q)
             return
+
+    def call_action(self, notify_type, func_args, run_task=True):
+        """Call the trigger action function."""
+        action_ast_ctx = AstEval(f"{self.action.global_ctx_name}.{self.action.name}", self.action.global_ctx)
+        Function.install_ast_funcs(action_ast_ctx)
+        task_unique_func = None
+        if self.task_unique is not None:
+            task_unique_func = Function.task_unique_factory(action_ast_ctx)
+
+        #
+        # check for @task_unique with kill_me=True
+        #
+        if (
+            self.task_unique is not None
+            and self.task_unique_kwargs
+            and self.task_unique_kwargs["kill_me"]
+            and Function.unique_name_used(action_ast_ctx, self.task_unique)
+        ):
+            _LOGGER.debug(
+                "trigger %s got %s trigger, @task_unique kill_me=True prevented new action",
+                notify_type,
+                self.name,
+            )
+            return False
+
+        # Create new HASS Context with incoming as parent
+        if "context" in func_args and isinstance(func_args["context"], Context):
+            hass_context = Context(parent_id=func_args["context"].id)
+        else:
+            hass_context = Context()
+
+        # Fire an event indicating that pyscript is running
+        # Note: the event must have an entity_id for logbook to work correctly.
+        ev_name = self.name.replace(".", "_")
+        ev_entity_id = f"pyscript.{ev_name}"
+
+        event_data = dict(name=ev_name, entity_id=ev_entity_id, func_args=func_args)
+        Function.hass.bus.async_fire("pyscript_running", event_data, context=hass_context)
+
+        _LOGGER.debug(
+            "trigger %s got %s trigger, running action (kwargs = %s)", self.name, notify_type, func_args,
+        )
+
+        async def do_func_call(func, ast_ctx, task_unique, task_unique_func, hass_context, **kwargs):
+            # Store HASS Context for this Task
+            Function.store_hass_context(hass_context)
+
+            if task_unique and task_unique_func:
+                await task_unique_func(task_unique)
+            await func.call(ast_ctx, **kwargs)
+            if ast_ctx.get_exception_obj():
+                ast_ctx.get_logger().error(ast_ctx.get_exception_long())
+
+        func = do_func_call(
+            self.action, action_ast_ctx, self.task_unique, task_unique_func, hass_context, **func_args,
+        )
+        if run_task:
+            Function.create_task(func)
+            return True
+        return func

docs/new_features.rst

@@ -32,7 +32,7 @@ The new features since 1.0.0 in master include:
 - ``pyscript.reload`` only reloads changed files (changed contents, mtime, or an app's yaml configuration).
   All files in an app or module are reloaded if any one has changed, and any script, app or module that
   imports a changed modules (directly or indirectly) is also reloaded. Setting the optional ``global_ctx``
-  service parameter to ``*`` forces reloading all files (which is the behavior in 1.0.0 and earlier).
+  service parameter to ``*`` forces reloading all files (which is the behavior in 1.0.0 and earlier).  See #106.
 - Adding new decorator ``@mqtt_trigger`` by @dlashua (#98, #105).
 - Added ``state_hold_false=None`` optional period in seconds to ``@state_trigger()`` and ``task.wait_until()``.
   This requires the trigger expression to be ``False`` for at least that period (including 0) before