Merge branch 'main' into add-bookmarking-input-components

Author: karangattu

shiny/bookmark/_bookmark.py

@@ -43,8 +43,6 @@ def __init__(
         self.dir = None  # This will be set by external functions.
         self.values = {}
 
-        self._always_exclude: list[str] = []
-
     async def _call_on_save(self):
         # Allow user-supplied save function to do things like add state$values, or
         # save data to state dir.

shiny/bookmark/_save_state.py

@@ -66,7 +66,7 @@ def on_ended(
 
     def make_scope(self, id: Id) -> Session:
         ns = self.ns(id)
-        return SessionProxy(parent=self, ns=ns)
+        return SessionProxy(root_session=self, ns=ns)
 
     def root_scope(self) -> ExpressStubSession:
         return self

shiny/express/_stub_session.py

@@ -1165,7 +1165,7 @@ def _process_ui(self, ui: TagChild) -> RenderedDeps:
 
     def make_scope(self, id: Id) -> Session:
         ns = self.ns(id)
-        return SessionProxy(parent=self, ns=ns)
+        return SessionProxy(root_session=self, ns=ns)
 
     def root_scope(self) -> AppSession:
         return self
@@ -1200,73 +1200,70 @@ class UpdateProgressMessage(TypedDict):
 
 
 class SessionProxy(Session):
-    def __init__(self, parent: Session, ns: ResolvedId) -> None:
+    def __init__(self, root_session: Session, ns: ResolvedId) -> None:
         super().__init__()
 
-        self._parent = parent
-        self.app = parent.app
-        self.id = parent.id
+        self._root_session = root_session
+        self.app = root_session.app
+        self.id = root_session.id
         self.ns = ns
-        self.input = Inputs(values=parent.input._map, ns=ns)
+        self.input = Inputs(values=root_session.input._map, ns=ns)
         self.output = Outputs(
             self,
             ns=ns,
-            outputs=parent.output._outputs,
+            outputs=root_session.output._outputs,
         )
-        self._outbound_message_queues = parent._outbound_message_queues
-        self._downloads = parent._downloads
+        self._outbound_message_queues = root_session._outbound_message_queues
+        self._downloads = root_session._downloads
 
         self.bookmark = BookmarkProxy(self)
 
     def _is_hidden(self, name: str) -> bool:
-        return self._parent._is_hidden(name)
+        return self._root_session._is_hidden(name)
 
     def on_ended(
         self,
         fn: Callable[[], None] | Callable[[], Awaitable[None]],
     ) -> Callable[[], None]:
-        return self._parent.on_ended(fn)
+        return self._root_session.on_ended(fn)
 
     def is_stub_session(self) -> bool:
-        return self._parent.is_stub_session()
+        return self._root_session.is_stub_session()
 
     async def close(self, code: int = 1001) -> None:
-        await self._parent.close(code)
+        await self._root_session.close(code)
 
     def make_scope(self, id: str) -> Session:
-        return self._parent.make_scope(self.ns(id))
+        return self._root_session.make_scope(self.ns(id))
 
     def root_scope(self) -> Session:
-        res = self
-        while isinstance(res, SessionProxy):
-            res = res._parent
-        return res
+        return self._root_session
 
     def _process_ui(self, ui: TagChild) -> RenderedDeps:
-        return self._parent._process_ui(ui)
+        return self._root_session._process_ui(ui)
 
     def send_input_message(self, id: str, message: dict[str, object]) -> None:
-        self._parent.send_input_message(self.ns(id), message)
+        self._root_session.send_input_message(self.ns(id), message)
 
     def _send_insert_ui(
         self, selector: str, multiple: bool, where: str, content: RenderedDeps
     ) -> None:
-        self._parent._send_insert_ui(selector, multiple, where, content)
+        self._root_session._send_insert_ui(selector, multiple, where, content)
 
     def _send_remove_ui(self, selector: str, multiple: bool) -> None:
-        self._parent._send_remove_ui(selector, multiple)
+        self._root_session._send_remove_ui(selector, multiple)
 
     def _send_progress(self, type: str, message: object) -> None:
-        self._parent._send_progress(type, message)  # pyright: ignore
+        self._root_session._send_progress(type, message)  # pyright: ignore
 
     async def send_custom_message(self, type: str, message: dict[str, object]) -> None:
-        await self._parent.send_custom_message(type, message)
+        await self._root_session.send_custom_message(type, message)
 
     def _increment_busy_count(self) -> None:
-        self._parent._increment_busy_count()
+        self._root_session._increment_busy_count()
 
     def _decrement_busy_count(self) -> None:
-        self._parent._decrement_busy_count()
+        self._root_session._decrement_busy_count()
 
     def set_message_handler(
         self,
@@ -1283,7 +1280,7 @@ def set_message_handler(
         if _handler_session is None:
             _handler_session = self
 
-        return self._parent.set_message_handler(
+        return self._root_session.set_message_handler(
             self.ns(name),
             handler,
             _handler_session=_handler_session,
@@ -1294,26 +1291,26 @@ def on_flush(
         fn: Callable[[], None] | Callable[[], Awaitable[None]],
         once: bool = True,
     ) -> Callable[[], None]:
-        return self._parent.on_flush(fn, once)
+        return self._root_session.on_flush(fn, once)
 
     async def _send_message(self, message: dict[str, object]) -> None:
-        await self._parent._send_message(message)
+        await self._root_session._send_message(message)
 
     def _send_message_sync(self, message: dict[str, object]) -> None:
-        self._parent._send_message_sync(message)
+        self._root_session._send_message_sync(message)
 
     def on_flushed(
         self,
         fn: Callable[[], None] | Callable[[], Awaitable[None]],
         once: bool = True,
     ) -> Callable[[], None]:
-        return self._parent.on_flushed(fn, once)
+        return self._root_session.on_flushed(fn, once)
 
     def dynamic_route(self, name: str, handler: DynamicRouteHandler) -> str:
-        return self._parent.dynamic_route(self.ns(name), handler)
+        return self._root_session.dynamic_route(self.ns(name), handler)
 
     async def _unhandled_error(self, e: Exception) -> None:
-        await self._parent._unhandled_error(e)
+        await self._root_session._unhandled_error(e)
 
     def download(
         self,
@@ -1324,7 +1321,7 @@ def download(
     ) -> Callable[[DownloadHandler], None]:
         def wrapper(fn: DownloadHandler):
             id_ = self.ns(id or fn.__name__)
-            return self._parent.download(
+            return self._root_session.download(
                 id=id_,
                 filename=filename,
                 media_type=media_type,

shiny/session/_session.py

@@ -0,0 +1,20 @@
+from starlette.requests import Request
+
+from shiny import App, Inputs, Outputs, Session, reactive, ui
+
+
+def app_ui(request: Request):
+    return ui.page_fluid(
+        ui.input_radio_buttons("letter", "Choose a letter", choices=["A", "B", "C"]),
+    )
+
+
+def server(input: Inputs, ouput: Outputs, session: Session):
+
+    @reactive.effect
+    @reactive.event(input.letter, ignore_init=True)
+    async def _():
+        await session.bookmark()
+
+
+app = App(app_ui, server, bookmark_store="url")

tests/playwright/shiny/bookmark/modal/app.py

@@ -0,0 +1,21 @@
+import re
+
+from playwright.sync_api import Page, expect
+
+from shiny.playwright.controller import InputRadioButtons
+from shiny.run import ShinyAppProc
+
+
+def test_bookmark_modules(page: Page, local_app: ShinyAppProc):
+
+    page.goto(local_app.url)
+
+    letter = InputRadioButtons(page, "letter")
+    letter.expect_selected("A")
+    letter.set("C")
+
+    expect(page.locator("div.modal-body > textarea")).to_have_value(
+        re.compile(r"letter=%22C%22")
+    )
+
+    assert "?" not in page.url

tests/playwright/shiny/bookmark/modal/test_bookmark_modal.py

@@ -29,7 +29,7 @@ def mod_btn(idx: int = 1):
             width="200px",
         ),
         ui.hr(),
-        mod_btn(f"sub{idx}", idx - 1) if idx > 0 else None,
+        mod_btn(f"sub{idx - 1}", idx - 1) if idx > 0 else None,
     )
 
 
@@ -55,7 +55,6 @@ def value():
     @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")
@@ -68,7 +67,6 @@ def _(state: BookmarkState) -> None:
 
     @session.bookmark.on_restore
     def _(restore_state: RestoreState) -> None:
-        # print("app-Restore state:", restore_state.values)
 
         if "btn2" in restore_state.values:
 
@@ -79,14 +77,16 @@ def _(restore_state: RestoreState) -> None:
             ui.update_radio_buttons("dyn2", selected=restore_state.values["dyn2"])
 
     if idx > 0:
-        btn_server(f"sub{idx}", idx - 1)
+        btn_server(f"sub{idx - 1}", idx - 1)
+    else:
+        # Attempt to call on_bookmarked at the very end of the proxy chain
+        session.bookmark.on_bookmarked(session.bookmark.update_query_string)
 
 
-k = 2
+k = 4
 
 
 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",
@@ -103,23 +103,6 @@ def server(input: Inputs, output: Outputs, session: Session):
     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"

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

@@ -30,9 +30,6 @@ def mod_btn(idx: int):
             ui.output_ui("ui_html"),
             ui.output_code("value"),
             width="200px",
-            # fill=True,
-            # fillable=True,
-            # height="75px",
         ),
         ui.hr(),
     )
@@ -60,7 +57,6 @@ def value():
     @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")
@@ -73,7 +69,6 @@ def _(state: BookmarkState) -> None:
 
     @session.bookmark.on_restore
     def _(restore_state: RestoreState) -> None:
-        # print("app-Restore state:", restore_state.values)
 
         if "btn2" in restore_state.values:
 
@@ -84,53 +79,29 @@ def _(restore_state: RestoreState) -> None:
             ui.update_radio_buttons("dyn2", selected=restore_state.values["dyn2"])
 
 
-k = 2
+k = 4
 
 
 def app_ui(request: Request) -> ui.Tag:
-    # print("app-Making UI")
     return ui.page_fixed(
         ui.output_code("bookmark_store"),
         "Click Button to update bookmark",
-        # ui.input_action_button("btn", "Button"),
         *[mod_btn(f"mod{i}", i) for i in reversed(range(k))],
-        # ui.input_radio_buttons("btn", "Button", choices=["a", "b", "c"], selected="a"),
-        # ui.output_code("code"),
-        # ui.input_bookmark_button(),
     )
 
 
 # Needs access to the restore context to the dynamic UI
 def server(input: Inputs, output: Outputs, session: Session):
 
+    session.bookmark.on_bookmarked(session.bookmark.update_query_string)
+
     @render.code
     def bookmark_store():
         return f"{session.bookmark.store}"
 
     for i in reversed(range(k)):
         btn_server(f"mod{i}", i)
 
-    @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)
-
-    # @render.code
-    # def code():
-    #     return f"{input.btn()}"
-
 
 SHINY_BOOKMARK_STORE: Literal["url", "server"] = os.getenv(
     "SHINY_BOOKMARK_STORE", "url"