Test for recursive module bookmarking

Author: schloerke

shiny/bookmark/_bookmark.py

@@ -75,7 +75,7 @@
 
 class Bookmark(ABC):
 
-    _proxy_exclude_fns: list[Callable[[], list[str]]]
+    _on_get_exclude: list[Callable[[], list[str]]]
     """Callbacks that BookmarkProxy classes utilize to help determine the list of inputs to exclude from bookmarking."""
     exclude: list[str]
     """A list of scoped Input names to exclude from bookmarking."""
@@ -85,6 +85,21 @@ class Bookmark(ABC):
     _on_restore_callbacks: AsyncCallbacks
     _on_restored_callbacks: AsyncCallbacks
 
+    async def __call__(self) -> None:
+        await self.do_bookmark()
+
+    def __init__(self):
+
+        super().__init__()
+
+        self._on_get_exclude = []
+        self.exclude = []
+
+        self._on_bookmark_callbacks = AsyncCallbacks()
+        self._on_bookmarked_callbacks = AsyncCallbacks()
+        self._on_restore_callbacks = AsyncCallbacks()
+        self._on_restored_callbacks = AsyncCallbacks()
+
     # Making this a read only property as app authors will not be able to change how the session is restored as the server function will run after the session has been restored.
     @property
     @abstractmethod
@@ -116,20 +131,16 @@ def _set_restore_context(self, restore_context: RestoreContext):
         """
         ...
 
-    async def __call__(self) -> None:
-        await self.do_bookmark()
-
-    def __init__(self):
-
-        super().__init__()
-
-        self._proxy_exclude_fns = []
-        self.exclude = []
+    def _get_bookmark_exclude(self) -> list[str]:
+        """
+        Get the list of inputs excluded from being bookmarked.
+        """
 
-        self._on_bookmark_callbacks = AsyncCallbacks()
-        self._on_bookmarked_callbacks = AsyncCallbacks()
-        self._on_restore_callbacks = AsyncCallbacks()
-        self._on_restored_callbacks = AsyncCallbacks()
+        scoped_excludes: list[str] = []
+        for proxy_exclude_fn in self._on_get_exclude:
+            scoped_excludes.extend(proxy_exclude_fn())
+        # Remove duplicates
+        return list(set([*self.exclude, *scoped_excludes]))
 
     # # TODO: Barret - Implement this?!?
     # @abstractmethod
@@ -154,13 +165,6 @@ def _create_effects(self) -> None:
         """
         ...
 
-    @abstractmethod
-    def _get_bookmark_exclude(self) -> list[str]:
-        """
-        Retrieve the list of inputs excluded from being bookmarked.
-        """
-        ...
-
     @abstractmethod
     def on_bookmark(
         self,
@@ -396,17 +400,6 @@ async def invoke_on_restored_callbacks():
 
         return
 
-    def _get_bookmark_exclude(self) -> list[str]:
-        """
-        Get the list of inputs excluded from being bookmarked.
-        """
-
-        scoped_excludes: list[str] = []
-        for proxy_exclude_fn in self._proxy_exclude_fns:
-            scoped_excludes.extend(proxy_exclude_fn())
-        # Remove duplicates
-        return list(set([*self.exclude, *scoped_excludes]))
-
     def on_bookmark(
         self,
         callback: (
@@ -548,9 +541,8 @@ def __init__(self, session_proxy: SessionProxy):
         self._ns = session_proxy.ns
         self._session = session_proxy
 
-        # TODO: Barret - This isn't getting to the root
         # Maybe `._get_bookmark_exclude()` should be used instead of`proxy_exclude_fns`?
-        self._session._parent.bookmark._proxy_exclude_fns.append(
+        self._session._parent.bookmark._on_get_exclude.append(
             lambda: [str(self._ns(name)) for name in self.exclude]
         )
 
@@ -667,12 +659,6 @@ def on_bookmarked(
     ) -> CancelCallback:
         return self._on_bookmarked_callbacks.register(wrap_async(callback))
 
-    def _get_bookmark_exclude(self) -> NoReturn:
-
-        raise NotImplementedError(
-            "Please call `._get_bookmark_exclude()` from the root session only."
-        )
-
     async def update_query_string(
         self, query_string: str, mode: Literal["replace", "push"] = "replace"
     ) -> None:
@@ -706,7 +692,7 @@ def __init__(self, session: ExpressStubSession) -> None:
         from ..express._stub_session import ExpressStubSession
 
         assert isinstance(session, ExpressStubSession)
-        self._session = session
+        # self._session = session
 
     @property
     def store(self) -> BookmarkStore:
@@ -724,11 +710,6 @@ def _create_effects(self) -> NoReturn:
             "Please call `._create_effects()` only from a real session object"
         )
 
-    def _get_bookmark_exclude(self) -> NoReturn:
-        raise NotImplementedError(
-            "Please call `._get_bookmark_exclude()` only from a real session object"
-        )
-
     def on_bookmark(
         self,
         callback: (

tests/playwright/shiny/bookmark/modules/app-core-recursive.py

@@ -0,0 +1,129 @@
+import os
+from typing import Literal
+
+from starlette.requests import Request
+
+from shiny import App, Inputs, Outputs, Session, module, reactive, render, ui
+from shiny.bookmark import BookmarkState
+from shiny.bookmark._restore_state import RestoreState
+
+
+@module.ui
+def mod_btn(idx: int = 1):
+    return ui.TagList(
+        ui.h3(f"Module {idx}"),
+        ui.layout_column_wrap(
+            ui.TagList(
+                ui.input_radio_buttons(
+                    "btn1", "Button Input", choices=["a", "b", "c"], selected="a"
+                ),
+                ui.input_radio_buttons(
+                    "btn2",
+                    "Button Value",
+                    choices=["a", "b", "c"],
+                    selected="a",
+                ),
+            ),
+            ui.output_ui("ui_html"),
+            ui.output_code("value"),
+            width="200px",
+        ),
+        ui.hr(),
+        mod_btn(f"sub{idx}", idx - 1) if idx > 0 else None,
+    )
+
+
+@module.server
+def btn_server(input: Inputs, output: Outputs, session: Session, idx: int = 1):
+
+    @render.ui
+    def ui_html():
+        return ui.TagList(
+            ui.input_radio_buttons(
+                "dyn1", "Dynamic Input", choices=["a", "b", "c"], selected="a"
+            ),
+            ui.input_radio_buttons(
+                "dyn2", "Dynamic Value", choices=["a", "b", "c"], selected="a"
+            ),
+        )
+
+    @render.code
+    def value():
+        value_arr = [input.btn1(), input.btn2(), input.dyn1(), input.dyn2()]
+        return f"{value_arr}"
+
+    @reactive.effect
+    @reactive.event(input.btn1, input.btn2, input.dyn1, input.dyn2, ignore_init=True)
+    async def _():
+        # print("app-Bookmarking!")
+        await session.bookmark()
+
+    session.bookmark.exclude.append("btn2")
+    session.bookmark.exclude.append("dyn2")
+
+    @session.bookmark.on_bookmark
+    def _(state: BookmarkState) -> None:
+        state.values["btn2"] = input.btn2()
+        state.values["dyn2"] = input.dyn2()
+
+    @session.bookmark.on_restore
+    def _(restore_state: RestoreState) -> None:
+        # print("app-Restore state:", restore_state.values)
+
+        if "btn2" in restore_state.values:
+
+            ui.update_radio_buttons("btn2", selected=restore_state.values["btn2"])
+
+        if "dyn2" in restore_state.values:
+
+            ui.update_radio_buttons("dyn2", selected=restore_state.values["dyn2"])
+
+    if idx > 0:
+        btn_server(f"sub{idx}", idx - 1)
+
+
+k = 2
+
+
+def app_ui(request: Request) -> ui.Tag:
+    # print("app-Making UI")
+    return ui.page_fixed(
+        ui.output_code("bookmark_store"),
+        "Click Buttons to update bookmark",
+        mod_btn(f"mod{k-1}", k - 1),
+    )
+
+
+# Needs access to the restore context to the dynamic UI
+def server(input: Inputs, output: Outputs, session: Session):
+
+    btn_server(f"mod{k-1}", k - 1)
+
+    @render.code
+    def bookmark_store():
+        return f"{session.bookmark.store}"
+
+    @session.bookmark.on_bookmark
+    async def on_bookmark(state: BookmarkState) -> None:
+        print(
+            "app-On Bookmark",
+            "\nInputs: ",
+            await state.input._serialize(exclude=state.exclude, state_dir=None),
+            "\nValues: ",
+            state.values,
+            "\n\n",
+        )
+        # session.bookmark.update_query_string()
+
+        pass
+
+    session.bookmark.on_bookmarked(session.bookmark.update_query_string)
+    # session.bookmark.on_bookmarked(session.bookmark.show_modal)
+
+
+SHINY_BOOKMARK_STORE: Literal["url", "server"] = os.getenv(
+    "SHINY_BOOKMARK_STORE", "url"
+)  # pyright: ignore[reportAssignmentType]
+if SHINY_BOOKMARK_STORE not in ["url", "server"]:
+    raise ValueError("SHINY_BOOKMARK_STORE must be either 'url' or 'server'")
+app = App(app_ui, server, bookmark_store=SHINY_BOOKMARK_STORE, debug=False)

tests/playwright/shiny/bookmark/modules/app.py renamed to tests/playwright/shiny/bookmark/modules/app-core.py

@@ -8,9 +8,25 @@
 from shiny.run import ShinyAppProc, run_shiny_app
 
 
-@pytest.mark.parametrize("app_name", ["app-express.py", "app.py"])
+@pytest.mark.parametrize(
+    "app_name,mod0_key,mod1_key",
+    [
+        # Express mode
+        ("app-express.py", "mod0", "mod1"),
+        # Core mode
+        ("app-core.py", "mod0", "mod1"),
+        # Recursive modules within core mode
+        ("app-core-recursive.py", "mod1-sub1", "mod1"),
+    ],
+)
 @pytest.mark.parametrize("bookmark_store", ["url", "server"])
-def test_bookmark_modules(page: Page, bookmark_store: str, app_name: str):
+def test_bookmark_modules(
+    page: Page,
+    bookmark_store: str,
+    app_name: str,
+    mod0_key: str,
+    mod1_key: str,
+) -> None:
 
     # Set environment variable before the app starts
     os.environ["SHINY_BOOKMARK_STORE"] = bookmark_store
@@ -41,18 +57,18 @@ def set_mod(mod_key: str, values: list[str]):
             InputRadioButtons(page, f"{mod_key}-dyn1").set(values[2])
             InputRadioButtons(page, f"{mod_key}-dyn2").set(values[3])
 
-        expect_mod("mod0", ["a", "a", "a", "a"])
-        expect_mod("mod1", ["a", "a", "a", "a"])
+        expect_mod(mod0_key, ["a", "a", "a", "a"])
+        expect_mod(mod1_key, ["a", "a", "a", "a"])
 
-        set_mod("mod0", ["b", "b", "c", "c"])
+        set_mod(mod0_key, ["b", "b", "c", "c"])
 
-        expect_mod("mod0", ["b", "b", "c", "c"])
-        expect_mod("mod1", ["a", "a", "a", "a"])
+        expect_mod(mod0_key, ["b", "b", "c", "c"])
+        expect_mod(mod1_key, ["a", "a", "a", "a"])
 
         page.reload()
 
-        expect_mod("mod0", ["b", "b", "c", "c"])
-        expect_mod("mod1", ["a", "a", "a", "a"])
+        expect_mod(mod0_key, ["b", "b", "c", "c"])
+        expect_mod(mod1_key, ["a", "a", "a", "a"])
 
         if bookmark_store == "url":
             assert "_inputs_" in page.url