Move context manager from AsyncValueFn's call to Outputs's call

Author: schloerke

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, self)
+        async_fn = AsyncValueFn(fn)
         if async_fn.is_async():
             raise TypeError(
                 "@render.express does not support async functions. Use @render.ui instead."

shiny/render/renderer/_renderer.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from contextlib import contextmanager
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -163,7 +162,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)
+        self.fn = AsyncValueFn(_fn)
 
         # Copy over function name as it is consistent with how Session and Output
         # retrieve function names
@@ -348,7 +347,6 @@ class AsyncValueFn(Generic[IT]):
     def __init__(
         self,
         fn: Callable[[], IT | None] | Callable[[], Awaitable[IT | None]],
-        renderer: Renderer[Any],
     ):
         if isinstance(fn, AsyncValueFn):
             raise TypeError(
@@ -357,14 +355,12 @@ 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.
         """
-        with self._current_renderer():
-            return await self._fn()
+        return await self._fn()
 
     def is_async(self) -> bool:
         """
@@ -405,19 +401,3 @@ def get_sync_fn(self) -> Callable[[], IT | None]:
             )
         sync_fn = cast(Callable[[], IT], self._orig_fn)
         return sync_fn
-
-    @contextmanager
-    def _current_renderer(self):
-        from ...session import get_current_session
-
-        session = get_current_session()
-        if session is None:
-            yield
-            return
-
-        old_renderer = session._current_renderer
-        try:
-            session._current_renderer = self._renderer
-            yield
-        finally:
-            session._current_renderer = old_renderer

shiny/session/_session.py

@@ -22,6 +22,7 @@
     AsyncIterable,
     Awaitable,
     Callable,
+    Generator,
     Iterable,
     Literal,
     Optional,
@@ -550,6 +551,9 @@ def __init__(
 
         self.user: str | None = None
         self.groups: list[str] | None = None
+
+        self._current_renderer = None
+
         credentials_json: str = ""
         if "shiny-server-credentials" in self.http_conn.headers:
             credentials_json = self.http_conn.headers["shiny-server-credentials"]
@@ -1817,8 +1821,13 @@ async def output_obs():
                 )
 
                 try:
-                    value = await renderer.render()
+                    # Temporarily set the renderer so `clientdata.output_*()` can access it without an `id`
+                    with self._session_renderer(session, renderer):
+                        # Call the app's renderer function
+                        value = await renderer.render()
+
                     session._outbound_message_queues.set_value(output_name, value)
+
                 except SilentOperationInProgressException:
                     session._send_progress(
                         "binding", {"id": output_name, "persistent": True}
@@ -1894,3 +1903,14 @@ def _should_suspend(self, name: str) -> bool:
         return self._outputs[name].suspend_when_hidden and self._session._is_hidden(
             name
         )
+
+    @contextlib.contextmanager
+    def _session_renderer(
+        self, session: Session, renderer: Renderer[Any]
+    ) -> Generator[None, None, None]:
+        old_renderer = session._current_renderer
+        try:
+            session._current_renderer = renderer
+            yield
+        finally:
+            session._current_renderer = old_renderer