feat(session): Add a current_output_id attribute for identifying currently executing output

Author: cpsievert

shiny/render/_express.py

@@ -67,7 +67,7 @@ def __call__(self, fn: ValueFn[None]) -> Self:
         if fn is None:  # pyright: ignore[reportUnnecessaryComparison]
             raise TypeError("@render.express requires a function when called")
 
-        async_fn = AsyncValueFn(fn)
+        async_fn = AsyncValueFn(fn, self)
         if async_fn.is_async():
             raise TypeError(
                 "@render.express does not support async functions. Use @render.ui instead."

shiny/render/renderer/_renderer.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from contextlib import contextmanager
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -162,7 +163,7 @@ def __call__(self, _fn: ValueFn[IT]) -> Self:
             raise TypeError("Value function must be callable")
 
         # Set value function with extra meta information
-        self.fn = AsyncValueFn(_fn)
+        self.fn = AsyncValueFn(_fn, self)
 
         # Copy over function name as it is consistent with how Session and Output
         # retrieve function names
@@ -350,6 +351,7 @@ class AsyncValueFn(Generic[IT]):
     def __init__(
         self,
         fn: Callable[[], IT | None] | Callable[[], Awaitable[IT | None]],
+        renderer: Renderer[Any],
     ):
         if isinstance(fn, AsyncValueFn):
             raise TypeError(
@@ -358,12 +360,14 @@ def __init__(
         self._is_async = is_async_callable(fn)
         self._fn = wrap_async(fn)
         self._orig_fn = fn
+        self._renderer = renderer
 
     async def __call__(self) -> IT | None:
         """
         Call the asynchronous function.
         """
-        return await self._fn()
+        with self._current_output_id():
+            return await self._fn()
 
     def is_async(self) -> bool:
         """
@@ -404,3 +408,13 @@ def get_sync_fn(self) -> Callable[[], IT | None]:
             )
         sync_fn = cast(Callable[[], IT], self._orig_fn)
         return sync_fn
+
+    @contextmanager
+    def _current_output_id(self):
+        from ...session import get_current_session
+
+        session = get_current_session()
+        if session is not None:
+            session.current_output_id = self._renderer.output_id
+            yield
+            session.current_output_id = None

shiny/session/_session.py

@@ -50,9 +50,8 @@
 from ..http_staticfiles import FileResponse
 from ..input_handler import input_handlers
 from ..module import ResolvedId
-from ..reactive import Effect_, Value, effect
+from ..reactive import Effect_, Value, effect, isolate
 from ..reactive import flush as reactive_flush
-from ..reactive import isolate
 from ..reactive._core import lock
 from ..reactive._core import on_flushed as reactive_on_flushed
 from ..render.renderer import Renderer, RendererT
@@ -180,6 +179,7 @@ class Session(ABC):
     input: Inputs
     output: Outputs
     clientdata: ClientData
+    current_output_id: str | None
 
     # Could be done with a weak ref dict from root to all children. Then we could just
     # iterate over all modules and check the `.bookmark_exclude` list of each proxy