Merge branch 'main' into chat-inject-stream

Author: cpsievert

.github/workflows/pytest.yaml

@@ -187,7 +187,6 @@ jobs:
       - name: Install node.js
         uses: actions/setup-node@v4
         with:
-          node-version: "18"
           cache: npm
           cache-dependency-path: examples/brownian/shinymediapipe/package-lock.json
       - name: Install node.js package
@@ -206,6 +205,49 @@ jobs:
           path: test-results/
           retention-days: 5
 
+  playwright-ai:
+    if: github.event_name != 'release'
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.11", "3.10", "3.9"]
+        browser: ["chromium", "firefox", "webkit"]
+        exclude:
+          - python-version: ${{ github.event.pull_request.draft && '3.11' }}
+          - python-version: ${{ github.event.pull_request.draft && '3.10' }}
+          - python-version: ${{ github.event.pull_request.draft && '3.9' }}
+          - browser: ${{ github.event.pull_request.draft && 'firefox' }}
+          - browser: ${{ github.event.pull_request.draft && 'webkit' }}
+      fail-fast: false
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Setup py-shiny
+        uses: ./.github/py-shiny/setup
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Determine browsers for testing
+        uses: ./.github/py-shiny/pytest-browsers
+        id: browsers
+        with:
+          browser: ${{ matrix.browser }}
+          # If anything other than `true`, it will heavily reduce webkit performance
+          # Related: https://github.com/microsoft/playwright/issues/18119
+          disable-playwright-diagnostics: ${{ matrix.browser == 'webkit' || matrix.browser == 'firefox' }}
+
+      - name: Run playwright tests for AI generated apps
+        timeout-minutes: 60
+        run: |
+          make playwright-ai SUB_FILE=". --numprocesses 3 ${{ steps.browsers.outputs.playwright-diagnostic-args }}" ${{ steps.browsers.outputs.browsers }}
+      - uses: actions/upload-artifact@v4
+        if: failure() && steps.browsers.outputs.has-playwright-diagnostics
+        with:
+          name: "playright-ai-${{ runner.os }}-${{ matrix.python-version }}-${{ matrix.browser }}-results"
+          path: test-results/
+          retention-days: 5
+
   playwright-deploys-precheck:
     if: github.event_name != 'release'
     runs-on: ubuntu-latest

.gitignore

@@ -115,6 +115,7 @@ docs/source/reference/
 _dev/
 tests/playwright/deploys/**/requirements.txt
 test-results/
+shiny_bookmarks/
 
 # setuptools_scm
 shiny/_version.py

CHANGELOG.md

@@ -23,6 +23,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 * Fixed an issue where the `.update_user_input()` method on `ui.Chat()` isn't working in shinylive.  (#1891)
 
+* Fixed an issue with the `.click()` method on InputActionButton controllers in `shiny.playwright.controllers` where the method would not work as expected. (#1886)
+
 ## [1.3.0] - 2025-03-03
 
 ### New features

Makefile

@@ -157,6 +157,7 @@ TEST_FILE:=tests/playwright/$(SUB_FILE)
 DEPLOYS_TEST_FILE:=tests/playwright/deploys$(SUB_FILE)
 SHINY_TEST_FILE:=tests/playwright/shiny/$(SUB_FILE)
 EXAMPLES_TEST_FILE:=tests/playwright/examples/$(SUB_FILE)
+AI_TEST_FILE:=tests/playwright/ai_generated_apps/$(SUB_FILE)
 
 install-playwright: FORCE
 	playwright install --with-deps
@@ -187,6 +188,10 @@ playwright-deploys: FORCE
 playwright-examples: FORCE
 	$(MAKE) playwright TEST_FILE="$(EXAMPLES_TEST_FILE)"
 
+# end-to-end tests for all AI generated apps
+playwright-ai: FORCE
+	$(MAKE) playwright TEST_FILE="$(AI_TEST_FILE)"
+
 coverage: FORCE ## check combined code coverage (must run e2e last)
 	pytest --cov-report term-missing --cov=shiny tests/pytest/ $(SHINY_TEST_FILE) $(PYTEST_BROWSERS)
 	coverage html

docs/_quartodoc-core.yml

@@ -98,6 +98,23 @@ quartodoc:
         - ui.input_file
         - ui.download_button
         - ui.download_link
+    - title: Bookmarking
+      desc: Saving and restoring app state
+      contents:
+        - ui.input_bookmark_button
+        - bookmark.restore_input
+        - bookmark.Bookmark
+        - bookmark.BookmarkState
+        - bookmark.RestoreState
+        - kind: page
+          path: bookmark_integration
+          summary:
+            name: "Integration"
+            desc: "Decorators to set save and restore directories."
+          flatten: true
+          contents:
+            - bookmark.set_global_save_dir_fn
+            - bookmark.set_global_restore_dir_fn
     - title: Chat interface
       desc: Build a chatbot interface
       contents:

pyrightconfig.json

@@ -10,7 +10,7 @@
     "docs",
     "tests/playwright/deploys/*/app.py",
     "shiny/templates",
-    "tests/playwright/shiny/tests_for_ai_generated_apps"
+    "tests/playwright/ai_generated_apps",
   ],
   "typeCheckingMode": "strict",
   "reportImportCycles": "none",

shiny/_app.py

@@ -6,7 +6,7 @@
 from contextlib import AsyncExitStack, asynccontextmanager
 from inspect import signature
 from pathlib import Path
-from typing import Any, Callable, Mapping, Optional, TypeVar, cast
+from typing import Any, Callable, Literal, Mapping, Optional, TypeVar, cast
 
 import starlette.applications
 import starlette.exceptions
@@ -30,6 +30,15 @@
 from ._error import ErrorMiddleware
 from ._shinyenv import is_pyodide
 from ._utils import guess_mime_type, is_async_callable, sort_keys_length
+from .bookmark import _global as bookmark_global_state
+from .bookmark._global import as_bookmark_dir_fn
+from .bookmark._restore_state import RestoreContext, restore_context
+from .bookmark._types import (
+    BookmarkDirFn,
+    BookmarkRestoreDirFn,
+    BookmarkSaveDirFn,
+    BookmarkStore,
+)
 from .html_dependencies import jquery_deps, require_deps, shiny_deps
 from .http_staticfiles import FileResponse, StaticFiles
 from .session._session import AppSession, Inputs, Outputs, Session, session_context
@@ -106,6 +115,10 @@ def server(input: Inputs, output: Outputs, session: Session):
     ui: RenderedHTML | Callable[[Request], Tag | TagList]
     server: Callable[[Inputs, Outputs, Session], None]
 
+    _bookmark_save_dir_fn: BookmarkSaveDirFn | None
+    _bookmark_restore_dir_fn: BookmarkRestoreDirFn | None
+    _bookmark_store: BookmarkStore
+
     def __init__(
         self,
         ui: Tag | TagList | Callable[[Request], Tag | TagList] | Path,
@@ -114,6 +127,8 @@ def __init__(
         ),
         *,
         static_assets: Optional[str | Path | Mapping[str, str | Path]] = None,
+        # Document type as Literal to have clearer type hints to App author
+        bookmark_store: Literal["url", "server", "disable"] = "disable",
         debug: bool = False,
     ) -> None:
         # Used to store callbacks to be called when the app is shutting down (according
@@ -133,6 +148,8 @@ def __init__(
                 "`server` must have 1 (Inputs) or 3 parameters (Inputs, Outputs, Session)"
             )
 
+        self._init_bookmarking(bookmark_store=bookmark_store, ui=ui)
+
         self._debug: bool = debug
 
         # Settings that the user can change after creating the App object.
@@ -167,7 +184,7 @@ def __init__(
 
         self._sessions: dict[str, AppSession] = {}
 
-        self._sessions_needing_flush: dict[int, AppSession] = {}
+        # self._sessions_needing_flush: dict[int, AppSession] = {}
 
         self._registered_dependencies: dict[str, HTMLDependency] = {}
         self._dependency_handler = starlette.routing.Router()
@@ -353,8 +370,18 @@ async def _on_root_request_cb(self, request: Request) -> Response:
         request for / occurs.
         """
         ui: RenderedHTML
+        if self.bookmark_store == "disable":
+            restore_ctx = RestoreContext()
+        else:
+            restore_ctx = await RestoreContext.from_query_string(
+                request.url.query, app=self
+            )
+
         if callable(self.ui):
-            ui = self._render_page(self.ui(request), self.lib_prefix)
+            # At this point, if `app.bookmark_store != "disable"`, then we've already
+            # checked that `ui` is a function (in `App._init_bookmarking()`). No need to throw warning if `ui` is _not_ a function.
+            with restore_context(restore_ctx):
+                ui = self._render_page(self.ui(request), self.lib_prefix)
         else:
             ui = self.ui
         return HTMLResponse(content=ui["html"])
@@ -466,6 +493,30 @@ def _render_page_from_file(self, file: Path, lib_prefix: str) -> RenderedHTML:
 
         return rendered
 
+    # ==========================================================================
+    # Bookmarking
+    # ==========================================================================
+
+    def _init_bookmarking(self, *, bookmark_store: BookmarkStore, ui: Any) -> None:
+        self._bookmark_save_dir_fn = bookmark_global_state.bookmark_save_dir
+        self._bookmark_restore_dir_fn = bookmark_global_state.bookmark_restore_dir
+        self._bookmark_store = bookmark_store
+
+        if bookmark_store != "disable" and not callable(ui):
+            raise TypeError(
+                "App(ui=) must be a function that accepts a request object to allow the UI to be properly reconstructed from a bookmarked state."
+            )
+
+    @property
+    def bookmark_store(self) -> BookmarkStore:
+        return self._bookmark_store
+
+    def set_bookmark_save_dir_fn(self, bookmark_save_dir_fn: BookmarkDirFn):
+        self._bookmark_save_dir_fn = as_bookmark_dir_fn(bookmark_save_dir_fn)
+
+    def set_bookmark_restore_dir_fn(self, bookmark_restore_dir_fn: BookmarkDirFn):
+        self._bookmark_restore_dir_fn = as_bookmark_dir_fn(bookmark_restore_dir_fn)
+
 
 def is_uifunc(x: Path | Tag | TagList | Callable[[Request], Tag | TagList]) -> bool:
     if (

shiny/_main_create.py

@@ -775,8 +775,7 @@ def copy_template_files(
         )
         sys.exit(1)
 
-    if not dest_dir.exists():
-        dest_dir.mkdir()
+    dest_dir.mkdir(parents=True, exist_ok=True)
 
     for item in template.path.iterdir():
         if item.is_file():

shiny/_namespaces.py

@@ -7,6 +7,8 @@
 
 
 class ResolvedId(str):
+    _sep: str = "-"  # Shared object for all instances
+
     def __call__(self, id: Id) -> ResolvedId:
         if isinstance(id, ResolvedId):
             return id
@@ -16,7 +18,7 @@ def __call__(self, id: Id) -> ResolvedId:
         if self == "":
             return ResolvedId(id)
         else:
-            return ResolvedId(self + "-" + id)
+            return ResolvedId(str(self) + self._sep + id)
 
 
 Root: ResolvedId = ResolvedId("")

shiny/_utils.py

@@ -281,7 +281,7 @@ async def fn_async(*args: P.args, **kwargs: P.kwargs) -> R:
     return fn_async
 
 
-# # TODO-barret-future; Q: Keep code?
+# # TODO: Barret - Future: Q: Keep code?
 # class WrapAsync(Generic[P, R]):
 #     """
 #     Make a function asynchronous.
@@ -517,11 +517,11 @@ async def __anext__(self):
 # ==============================================================================
 class Callbacks:
     def __init__(self) -> None:
-        self._callbacks: dict[int, tuple[Callable[[], None], bool]] = {}
+        self._callbacks: dict[int, tuple[Callable[..., None], bool]] = {}
         self._id: int = 0
 
     def register(
-        self, fn: Callable[[], None], once: bool = False
+        self, fn: Callable[..., None], once: bool = False
     ) -> Callable[[], None]:
         self._id += 1
         id = self._id
@@ -533,14 +533,14 @@ def _():
 
         return _
 
-    def invoke(self) -> None:
+    def invoke(self, *args: Any, **kwargs: Any) -> None:
         # The list() wrapper is necessary to force collection of all the items before
         # iteration begins. This is necessary because self._callbacks may be mutated
         # by callbacks.
         for id, value in list(self._callbacks.items()):
             fn, once = value
             try:
-                fn()
+                fn(*args, **kwargs)
             finally:
                 if once:
                     if id in self._callbacks:
@@ -550,32 +550,35 @@ def count(self) -> int:
         return len(self._callbacks)
 
 
+CancelCallback = Callable[[], None]
+
+
 class AsyncCallbacks:
     def __init__(self) -> None:
-        self._callbacks: dict[int, tuple[Callable[[], Awaitable[None]], bool]] = {}
+        self._callbacks: dict[int, tuple[Callable[..., Awaitable[None]], bool]] = {}
         self._id: int = 0
 
     def register(
-        self, fn: Callable[[], Awaitable[None]], once: bool = False
-    ) -> Callable[[], None]:
+        self, fn: Callable[..., Awaitable[None]], once: bool = False
+    ) -> CancelCallback:
         self._id += 1
         id = self._id
         self._callbacks[id] = (fn, once)
 
-        def _():
+        def cancel_callback():
             if id in self._callbacks:
                 del self._callbacks[id]
 
-        return _
+        return cancel_callback
 
-    async def invoke(self) -> None:
+    async def invoke(self, *args: Any, **kwargs: Any) -> None:
         # The list() wrapper is necessary to force collection of all the items before
         # iteration begins. This is necessary because self._callbacks may be mutated
         # by callbacks.
         for id, value in list(self._callbacks.items()):
             fn, once = value
             try:
-                await fn()
+                await fn(*args, **kwargs)
             finally:
                 if once:
                     if id in self._callbacks: