task.unique() names are now specific to each global context

Author: craigbarratt

custom_components/pyscript/function.py

@@ -54,7 +54,6 @@ def init(cls, hass):
                 "task.executor": cls.task_executor,
                 "event.fire": cls.event_fire,
                 "task.sleep": cls.async_sleep,
-                "task.unique": cls.task_unique,
                 "service.call": cls.service_call,
                 "service.has_service": cls.service_has_service,
             }
@@ -66,6 +65,7 @@ def init(cls, hass):
                 "log.info": lambda ast_ctx: ast_ctx.get_logger().info,
                 "log.warning": lambda ast_ctx: ast_ctx.get_logger().warning,
                 "print": lambda ast_ctx: ast_ctx.get_logger().debug,
+                "task.unique": lambda ast_ctx: cls.task_unique_factory(ast_ctx),
             }
         )
 
@@ -101,30 +101,36 @@ async def event_fire(cls, event_type, **kwargs):
         cls.hass.bus.async_fire(event_type, kwargs)
 
     @classmethod
-    async def task_unique(cls, name, kill_me=False):
-        """Implement task.unique()."""
-        if name in cls.unique_name2task:
-            if kill_me:
-                #
-                # it seems we can't cancel ourselves, so we
-                # tell the repeaer task to cancel us
-                #
-                Function.task_cancel(asyncio.current_task())
-                # wait to be canceled
-                await asyncio.sleep(100000)
-            else:
-                task = cls.unique_name2task[name]
-                if task in cls.our_tasks:
-                    # only cancel tasks if they are ones we started
-                    try:
-                        task.cancel()
-                        await task
-                    except asyncio.CancelledError:
-                        pass
-        task = asyncio.current_task()
-        if task in cls.our_tasks:
-            cls.unique_name2task[name] = task
-            cls.unique_task2name[task] = name
+    def task_unique_factory(cls, ctx):
+        """Define and return task.unique() for this context."""
+
+        async def task_unique(name, kill_me=False):
+            """Implement task.unique()."""
+            name = f"{ctx.get_global_ctx_name()}.{name}"
+            if name in cls.unique_name2task:
+                if kill_me:
+                    #
+                    # it seems we can't cancel ourselves, so we
+                    # tell the repeaer task to cancel us
+                    #
+                    Function.task_cancel(asyncio.current_task())
+                    # wait to be canceled
+                    await asyncio.sleep(100000)
+                else:
+                    task = cls.unique_name2task[name]
+                    if task in cls.our_tasks:
+                        # only cancel tasks if they are ones we started
+                        try:
+                            task.cancel()
+                            await task
+                        except asyncio.CancelledError:
+                            pass
+            task = asyncio.current_task()
+            if task in cls.our_tasks:
+                cls.unique_name2task[name] = task
+                cls.unique_task2name[task] = name
+
+        return task_unique
 
     @classmethod
     async def task_executor(cls, func, *args, **kwargs):
@@ -134,8 +140,9 @@ async def task_executor(cls, func, *args, **kwargs):
         return await cls.hass.async_add_executor_job(functools.partial(func, **kwargs), *args)
 
     @classmethod
-    def unique_name_used(cls, name):
+    def unique_name_used(cls, ctx, name):
         """Return whether the current unique name is in use."""
+        name = f"{ctx.get_global_ctx_name()}.{name}"
         return name in cls.unique_name2task
 
     @classmethod

custom_components/pyscript/trigger.py

@@ -448,6 +448,7 @@ def __init__(
         self.time_active = trig_cfg.get("time_active", {}).get("args", None)
         self.task_unique = trig_cfg.get("task_unique", {}).get("args", None)
         self.task_unique_kwargs = trig_cfg.get("task_unique", {}).get("kwargs", None)
+        self.task_unique_func = None
         self.action = trig_cfg.get("action")
         self.action_ast_ctx = trig_cfg.get("action_ast_ctx")
         self.global_sym_table = trig_cfg.get("global_sym_table", {})
@@ -505,6 +506,9 @@ def __init__(
                     return
             self.have_trigger = True
 
+        if self.task_unique:
+            self.task_unique_func = Function.task_unique_factory(self.action_ast_ctx)
+
         self.setup_ok = True
 
     def stop(self):
@@ -530,8 +534,8 @@ async def trigger_watch(self):
         try:
 
             async def do_func_call(func, ast_ctx, task_unique, kwargs=None):
-                if task_unique:
-                    await Function.task_unique(task_unique)
+                if task_unique and self.task_unique_func:
+                    await self.task_unique_func(task_unique)
                 await func.call(ast_ctx, kwargs=kwargs)
                 if ast_ctx.get_exception_obj():
                     ast_ctx.get_logger().error(ast_ctx.get_exception_long())
@@ -630,7 +634,7 @@ async def do_func_call(func, ast_ctx, task_unique, kwargs=None):
                     self.task_unique is not None
                     and self.task_unique_kwargs
                     and self.task_unique_kwargs["kill_me"]
-                    and Function.unique_name_used(self.task_unique)
+                    and Function.unique_name_used(self.action_ast_ctx, self.task_unique)
                 ):
                     _LOGGER.debug(
                         "trigger %s got %s trigger, @task_unique kill_me=True prevented new action",

docs/reference.rst

@@ -569,10 +569,8 @@ Task unique
   killed if another task that is running previously called ``task.unique`` with the same
   ``task_name``.
 
-Note that ``task.unique`` applies across all global contexts. It’s up to you to use a convention for
-``task_name`` that avoids accidental collisions. For example, you could use a prefix of the script
-file name, so that all ``task_unique`` calls in ``FILENAME.py`` use a ``task_name`` that starts with
-``"FILENAME."``.
+Note that ``task.unique`` is specific to the current global context, so names used in one
+global context will not affect another.
 
 ``task.unique`` can also be called outside a function, for example in the preamble of a script file
 or interactively using Jupyter. That causes any currently running functions (ie, functions that have
@@ -582,6 +580,10 @@ is the mechanism you can use should you wish to terminate specific functions on
 outside a function or interactively with Jupyter, calling ``task.unique`` with ``kill_me=True``
 causes ``task.unique`` to do nothing.
 
+The ``task.unique`` functionality is also provided via a decorator ``@task_unique``. If your
+function immediately and always calls ``task.unique``, you could choose instead to use the
+function decorator form.
+
 Task waiting
 ^^^^^^^^^^^^