Add shiny.bookmark.input_bookmark_button(); Use globals to set bookmark save and restore methods

Author: schloerke

shiny/_app.py

@@ -7,7 +7,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
@@ -31,6 +31,7 @@
 from ._error import ErrorMiddleware
 from ._shinyenv import is_pyodide
 from ._utils import guess_mime_type, is_async_callable, sort_keys_length
+from .bookmark import _globals as bookmark_globals
 from .bookmark._restore_state import (
     RestoreContext,
     get_current_restore_context,
@@ -120,6 +121,7 @@ def __init__(
         ),
         *,
         static_assets: Optional[str | Path | Mapping[str, str | Path]] = None,
+        bookmarking: Optional[Literal["url", "query", "disable"]] = None,
         debug: bool = False,
     ) -> None:
         # Used to store callbacks to be called when the app is shutting down (according
@@ -139,6 +141,8 @@ def __init__(
                 "`server` must have 1 (Inputs) or 3 parameters (Inputs, Outputs, Session)"
             )
 
+        if bookmarking is not None:
+            bookmark_globals.bookmark_store = bookmarking
         self._debug: bool = debug
 
         # Settings that the user can change after creating the App object.
@@ -359,35 +363,29 @@ async def _on_root_request_cb(self, request: Request) -> Response:
         request for / occurs.
         """
         ui: RenderedHTML
-        # Create a restore context using query string
-        # TODO: Barret implement how to get bookmark_store value
-        # bookmarkStore <- getShinyOption("bookmarkStore", default = "disable")
-        print("TODO: Figure this out")
-        bookmark_store: str = str("disable")
-        bookmark_store: str = str("query")
-
-        if bookmark_store == "disable":
+        if bookmark_globals.bookmark_store == "disable":
             restore_ctx = RestoreContext()
         else:
             restore_ctx = await RestoreContext.from_query_string(request.url.query)
 
         print(
+            "Restored state",
             {
                 "values": restore_ctx.as_state().values,
                 "input": restore_ctx.as_state().input,
-            }
+            },
         )
 
         with restore_context(restore_ctx):
             if callable(self.ui):
                 ui = self._render_page(self.ui(request), self.lib_prefix)
             else:
-                # TODO: Why is this here as there's a with restore_context above?
-                # TODO: Why not `if restore_ctx.active:`?
+                # TODO: Barret - Q: Why is this here as there's a with restore_context above?
+                # TODO: Barret - Q: Why not `if restore_ctx.active:`?
                 cur_restore_ctx = get_current_restore_context()
                 print("cur_restore_ctx", cur_restore_ctx)
                 if cur_restore_ctx is not None and cur_restore_ctx.active:
-                    # TODO: See ?enableBookmarking
+                    # TODO: Barret - Docs: See ?enableBookmarking
                     warnings.warn(
                         "Trying to restore saved app state, but UI code must be a function for this to work!",
                         stacklevel=1,

shiny/bookmark/__init__.py

@@ -6,7 +6,7 @@
     BookmarkProxy,
     ShinySaveState,
 )
-from ._bookmark_state import BookmarkState
+from ._button import input_bookmark_button
 from ._restore_state import RestoreContext, RestoreContextState
 
 __all__ = (
@@ -18,8 +18,8 @@
     "BookmarkApp",
     "BookmarkProxy",
     "BookmarkExpressStub",
-    # _bookmark_state
-    "BookmarkState",
+    # _button
+    "input_bookmark_button",
     # _restore_state
     "RestoreContext",
     "RestoreContextState",

shiny/bookmark/_bookmark.py

@@ -1,3 +1,16 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import TYPE_CHECKING, Awaitable, Callable, Literal, NoReturn
+
+from .._utils import AsyncCallbacks, CancelCallback, wrap_async
+from ..types import MISSING, MISSING_TYPE
+from . import _globals as bookmark_globals
+from ._globals import BookmarkStore
+from ._restore_state import RestoreContextState
+from ._save_state import ShinySaveState
+
 # TODO: bookmark button
 
 # TODO:
@@ -46,13 +59,6 @@
 # * May need to escape (all?) the parameters to avoid collisions with `h=` or `code=`.
 # Set query string to parent frame / tab
 
-from abc import ABC, abstractmethod
-from pathlib import Path
-from typing import TYPE_CHECKING, Awaitable, Callable, Literal, NoReturn
-
-from .._utils import AsyncCallbacks, CancelCallback, wrap_async
-from ._restore_state import RestoreContextState
-from ._save_state import ShinySaveState
 
 if TYPE_CHECKING:
     from .._namespaces import ResolvedId
@@ -70,9 +76,6 @@
     ExpressStubSession = Any
 
 
-BookmarkStore = Literal["url", "server", "disable"]
-
-
 # TODO: future - Local storage Bookmark class!
 # * Needs a consistent id for storage.
 # * Needs ways to clean up other storage
@@ -84,7 +87,20 @@ class Bookmark(ABC):
     # TODO: Barret - This feels like it needs to be a weakref
     _session_root: Session
 
-    store: BookmarkStore
+    _store: BookmarkStore | MISSING_TYPE
+
+    @property
+    def store(self) -> BookmarkStore:
+        # Should we allow for this?
+        # Allows a per-session override of the global bookmark store
+        if isinstance(self._session_root.bookmark._store, MISSING_TYPE):
+            return bookmark_globals.bookmark_store
+        return self._session_root.bookmark._store
+
+    @store.setter
+    def store(self, value: BookmarkStore) -> None:
+        self._session_root.bookmark._store = value
+        self._store = value
 
     _proxy_exclude_fns: list[Callable[[], list[str]]]
     exclude: list[str]
@@ -107,8 +123,18 @@ def __init__(self, session_root: Session):
         # from ._restore_state import RestoreContext
 
         super().__init__()
+        # TODO: Barret - Q: Should this be a weakref; Session -> Bookmark -> Session
         self._session_root = session_root
         self._restore_context = None
+        self._store = MISSING
+
+        self._proxy_exclude_fns = []
+        self.exclude = []
+
+        self._on_bookmark_callbacks = AsyncCallbacks()
+        self._on_bookmarked_callbacks = AsyncCallbacks()
+        self._on_restore_callbacks = AsyncCallbacks()
+        self._on_restored_callbacks = AsyncCallbacks()
 
     # # TODO: Barret - Implement this?!?
     # @abstractmethod
@@ -247,25 +273,14 @@ def on_restored(
 
 class BookmarkApp(Bookmark):
     def __init__(self, session_root: Session):
-
         super().__init__(session_root)
 
-        self.store = "disable"
-        self.store = "url"
-        self.exclude = []
-        self._proxy_exclude_fns = []
-        self._on_bookmark_callbacks = AsyncCallbacks()
-        self._on_bookmarked_callbacks = AsyncCallbacks()
-        self._on_restore_callbacks = AsyncCallbacks()
-        self._on_restored_callbacks = AsyncCallbacks()
-
     def _create_effects(self) -> None:
         # Get bookmarking config
         if self.store == "disable":
             return
 
         print("Creating effects")
-
         session = self._session_root
 
         from .. import reactive
@@ -481,17 +496,9 @@ def __init__(self, session_proxy: SessionProxy):
         super().__init__(session_proxy.root_scope())
 
         self._ns = session_proxy.ns
-        # TODO: Barret - This feels like it needs to be a weakref
+        # TODO: Barret - Q: Should this be a weakref
         self._session_proxy = session_proxy
 
-        self.exclude = []
-        self._proxy_exclude_fns = []
-        self._on_bookmark_callbacks = AsyncCallbacks()
-        self._on_bookmarked_callbacks = AsyncCallbacks()
-        self._on_restore_callbacks = AsyncCallbacks()
-        self._on_restored_callbacks = AsyncCallbacks()
-
-        # TODO: Barret - Double check that this works with nested modules!
         self._session_root.bookmark._proxy_exclude_fns.append(
             lambda: [str(self._ns(name)) for name in self.exclude]
         )
@@ -508,6 +515,14 @@ async def scoped_on_bookmark(root_state: ShinySaveState) -> None:
 
         from ..session import session_context
 
+        @self._root_bookmark.on_bookmarked
+        async def scoped_on_bookmarked(url: str) -> None:
+            if self._on_bookmarked_callbacks.count() == 0:
+                return
+
+            with session_context(self._session_proxy):
+                await self._on_bookmarked_callbacks.invoke(url)
+
         ns_prefix = str(self._ns + self._ns._sep)
 
         @self._root_bookmark.on_restore

shiny/bookmark/_bookmark_state.py

@@ -1,93 +1,21 @@
+from __future__ import annotations
+
 import os
-from abc import ABC, abstractmethod
 from pathlib import Path
 
 
-class BookmarkState(ABC):
-    """
-    Class for saving and restoring state to/from disk.
-    """
-
-    @abstractmethod
-    async def save_dir(
-        self,
-        id: str,
-        # write_files: Callable[[Path], Awaitable[None]],
-    ) -> Path:
-        """
-        Construct directory for saving state.
-
-        Parameters
-        ----------
-        id
-            The unique identifier for the state.
-
-        Returns
-        -------
-        Path
-            Directory location for saving state. This directory must exist.
-        """
-        # write_files
-        #     A async function that writes the state to a serializable location. The method receives a path object and
-        ...
-
-    @abstractmethod
-    async def load_dir(
-        self,
-        id: str,
-        # read_files: Callable[[Path], Awaitable[None]],
-    ) -> Path:
-        """
-        Construct directory for loading state.
-
-        Parameters
-        ----------
-        id
-            The unique identifier for the state.
-
-        Returns
-        -------
-        Path | None
-            Directory location for loading state. If `None`, state loading will be ignored. If a `Path`, the directory must exist.
-        """
-        ...
-
-
-class BookmarkStateLocal(BookmarkState):
-    """
-    Function wrappers for saving and restoring state to/from disk when running Shiny
-    locally.
-    """
-
-    def _local_dir(self, id: str) -> Path:
-        # Try to save/load from current working directory as we do not know where the
-        # app file is located
-        return Path(os.getcwd()) / "shiny_bookmarks" / id
-
-    async def save_dir(self, id: str) -> Path:
-        state_dir = self._local_dir(id)
-        if not state_dir.exists():
-            state_dir.mkdir(parents=True)
-        return state_dir
+def _local_dir(id: str) -> Path:
+    # Try to save/load from current working directory as we do not know where the
+    # app file is located
+    return Path(os.getcwd()) / "shiny_bookmarks" / id
 
-    async def load_dir(self, id: str) -> Path:
-        return self._local_dir(id)
 
-    # async def save(
-    #     self,
-    #     id: str,
-    #     write_files: Callable[[Path], Awaitable[None]],
-    # ) -> None:
-    #     state_dir = self._local_dir(id)
-    #     if not state_dir.exists():
-    #         state_dir.mkdir(parents=True)
+async def local_save_dir(id: str) -> Path:
+    state_dir = _local_dir(id)
+    if not state_dir.exists():
+        state_dir.mkdir(parents=True)
+    return state_dir
 
-    #     await write_files(state_dir)
 
-    # async def load(
-    #     self,
-    #     id: str,
-    #     read_files: Callable[[Path], Awaitable[None]],
-    # ) -> None:
-    #     await read_files(self._local_dir(id))
-    #     await read_files(self._local_dir(id))
+async def local_load_dir(id: str) -> Path:
+    return _local_dir(id)