feat(clientdata): id is now optional on clientdata.output_*() methods

CHANGELOG.md

@@ -7,13 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [UNRELEASED]
 
+### New features
+
+* The `.output_*()` methods of the `ClientData` class (e.g., `session.clientdata.output_height()`) can now be called without an `id` inside a output renderer. (#1978)
+* The `Session` class gains a `.current_output_id()` method. It returns the ID of the currently executing output renderer (if any). (#1978)
+
 ### Improvements
 
 * Improved the styling and readability of markdown tables rendered by `ui.Chat()` and `ui.MarkdownStream()`. (#1973)
 
 ## [1.4.0] - 2025-04-08
 
-## New features
+### New features
 
 * Added support for bookmarking Shiny applications. Bookmarking allows users to save the current state of an application and return to it later. This feature is available in both Shiny Core and Shiny Express. (#1870, #1915, #1919, #1920, #1922, #1934, #1938, #1945, #1955)
   * To enable bookmarking in Express mode, set `shiny.express.app_opts(bookmark_store=)` during the app's initial construction.

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,19 @@ 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 None:
+            yield
+            return
+
+        old_id = session._current_output_id
+        try:
+            session._current_output_id = self._renderer.output_id
+            yield
+        finally:
+            session._current_output_id = old_id

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
@@ -188,6 +187,9 @@ class Session(ABC):
     user: str | None
     groups: list[str] | None
 
+    # Internal state for current_output_id()
+    _current_output_id: str | None = None
+
     # TODO: not sure these should be directly exposed
     _outbound_message_queues: OutBoundMessageQueues
     _downloads: dict[str, DownloadInfo]
@@ -378,6 +380,10 @@ def on_flushed(
             A function that can be used to cancel the registration.
         """
 
+    def current_output_id(self) -> str | None:
+        "Returns the id of the currently executing output renderer (if any)."
+        return self._current_output_id
+
     @abstractmethod
     async def _unhandled_error(self, e: Exception) -> None: ...
 
@@ -1556,7 +1562,7 @@ def pixelratio(self) -> float:
         """
         return cast(int, self._read_input("pixelratio"))
 
-    def output_height(self, id: str) -> float | None:
+    def output_height(self, id: Optional[str] = None) -> float | None:
         """
         Reactively read the height of an output.
 
@@ -1573,7 +1579,7 @@ def output_height(self, id: str) -> float | None:
         """
         return cast(float, self._read_output(id, "height"))
 
-    def output_width(self, id: str) -> float | None:
+    def output_width(self, id: Optional[str] = None) -> float | None:
         """
         Reactively read the width of an output.
 
@@ -1590,7 +1596,7 @@ def output_width(self, id: str) -> float | None:
         """
         return cast(float, self._read_output(id, "width"))
 
-    def output_hidden(self, id: str) -> bool | None:
+    def output_hidden(self, id: Optional[str] = None) -> bool | None:
         """
         Reactively read whether an output is hidden.
 
@@ -1606,7 +1612,7 @@ def output_hidden(self, id: str) -> bool | None:
         """
         return cast(bool, self._read_output(id, "hidden"))
 
-    def output_bg_color(self, id: str) -> str | None:
+    def output_bg_color(self, id: Optional[str] = None) -> str | None:
         """
         Reactively read the background color of an output.
 
@@ -1623,7 +1629,7 @@ def output_bg_color(self, id: str) -> str | None:
         """
         return cast(str, self._read_output(id, "bg"))
 
-    def output_fg_color(self, id: str) -> str | None:
+    def output_fg_color(self, id: Optional[str] = None) -> str | None:
         """
         Reactively read the foreground color of an output.
 
@@ -1640,7 +1646,7 @@ def output_fg_color(self, id: str) -> str | None:
         """
         return cast(str, self._read_output(id, "fg"))
 
-    def output_accent_color(self, id: str) -> str | None:
+    def output_accent_color(self, id: Optional[str] = None) -> str | None:
         """
         Reactively read the accent color of an output.
 
@@ -1657,7 +1663,7 @@ def output_accent_color(self, id: str) -> str | None:
         """
         return cast(str, self._read_output(id, "accent"))
 
-    def output_font(self, id: str) -> str | None:
+    def output_font(self, id: Optional[str] = None) -> str | None:
         """
         Reactively read the font(s) of an output.
 
@@ -1685,9 +1691,18 @@ def _read_input(self, key: str) -> str:
 
         return self._session.input[id]()
 
-    def _read_output(self, id: str, key: str) -> str | None:
+    def _read_output(self, id: str | None, key: str) -> str | None:
         self._check_current_context(f"output_{key}")
 
+        if id is None:
+            id = self._session.current_output_id()
+
+        if id is None:
+            raise ValueError(
+                "session.clientdata.output_*() requires an id when not called within "
+                "an output renderer."
+            )
+
         input_id = ResolvedId(f".clientdata_output_{id}_{key}")
         if input_id in self._session.input:
             return self._session.input[input_id]()

tests/playwright/shiny/session/current_output_info/app.py

@@ -0,0 +1,30 @@
+from shiny import App, Inputs, Outputs, Session, render, ui
+
+app_ui = ui.page_fluid(
+    ui.input_dark_mode(mode="light", id="dark_mode"),
+    ui.output_text("text1"),
+    ui.output_text("text2"),
+    ui.output_text("info").add_class("shiny-report-theme"),
+)
+
+
+def server(input: Inputs, output: Outputs, session: Session):
+
+    @render.text
+    def text1():
+        id = session.current_output_id() or "None"
+        return f"Output ID: {id}"
+
+    @output(id="text2")
+    @render.text
+    def _():
+        id = session.current_output_id() or "None"
+        return f"Output ID: {id}"
+
+    @render.text
+    def info():
+        bg_color = session.clientdata.output_bg_color()
+        return f"BG color: {bg_color}"
+
+
+app = App(app_ui, server)

tests/playwright/shiny/session/current_output_info/test_current_output_info.py

@@ -0,0 +1,29 @@
+from playwright.sync_api import Page
+
+from shiny.playwright import controller
+from shiny.run import ShinyAppProc
+
+
+def test_current_output_info(page: Page, local_app: ShinyAppProc) -> None:
+
+    page.goto(local_app.url)
+
+    # Check that the output ID is displayed correctly in the UI
+    text1 = controller.OutputText(page, "text1")
+    text2 = controller.OutputText(page, "text2")
+
+    text1.expect_value("Output ID: text1")
+    text2.expect_value("Output ID: text2")
+
+    # Check that we can get background color from clientdata
+    info = controller.OutputText(page, "info")
+    info.expect_value("BG color: rgb(255, 255, 255)")
+
+    # Click the dark mode button to change the background color
+    dark_mode = controller.InputDarkMode(page, "dark_mode")
+    dark_mode.expect_mode("light")
+    dark_mode.click()
+    dark_mode.expect_mode("dark")
+
+    # Check that the background color has changed
+    info.expect_value("BG color: rgb(29, 31, 33)")