Move files around. Add shiny.bookmark. set_save_dir() and set_restore_dir()

Author: schloerke

shiny/_app.py

@@ -31,12 +31,12 @@
 from ._error import ErrorMiddleware
 from ._shinyenv import is_pyodide
 from ._utils import guess_mime_type, is_async_callable, sort_keys_length
-from .bookmark._globals import BookmarkStore
 from .bookmark._restore_state import (
     RestoreContext,
     get_current_restore_context,
     restore_context,
 )
+from .bookmark._types import 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

shiny/bookmark/__init__.py

@@ -1,4 +1,3 @@
-from . import _globals as globals
 from ._bookmark import (
     Bookmark,
     BookmarkApp,
@@ -7,11 +6,10 @@
     ShinySaveState,
 )
 from ._button import input_bookmark_button
+from ._external import set_load_dir, set_save_dir
 from ._restore_state import RestoreContext, RestoreContextState, restore_input
 
 __all__ = (
-    # _globals
-    "globals",
     # _bookmark
     "ShinySaveState",
     "Bookmark",
@@ -20,6 +18,9 @@
     "BookmarkExpressStub",
     # _button
     "input_bookmark_button",
+    # _external
+    "set_save_dir",
+    "set_load_dir",
     # _restore_state
     "RestoreContext",
     "RestoreContextState",

shiny/bookmark/_bookmark.py

@@ -7,11 +7,10 @@
 
 from .._utils import AsyncCallbacks, CancelCallback, wrap_async
 from ..types import MISSING, MISSING_TYPE
-from . import _globals as bookmark_globals
 from ._button import BOOKMARK_ID
-from ._globals import BookmarkStore
 from ._restore_state import RestoreContextState
 from ._save_state import ShinySaveState
+from ._types import BookmarkStore
 
 # TODO: Barret - Bookmark state
 # bookmark -> save/load interface
@@ -590,9 +589,12 @@ async def _scoped_on_bookmark(self, root_state: ShinySaveState) -> None:
         )
 
         # Make subdir for scope
+        # TODO-barret; Is this for uploaded files?!?
         if root_state.dir is not None:
             scope_subpath = self._ns
             scoped_state.dir = Path(root_state.dir) / scope_subpath
+            scoped_state.dir.mkdir(parents=True, exist_ok=True)
+
             if not scoped_state.dir.exists():
                 raise FileNotFoundError(
                     f"Scope directory could not be created for {scope_subpath}"
@@ -653,13 +655,6 @@ async def do_bookmark(self) -> None:
     def store(self) -> BookmarkStore:
         return self._root_bookmark.store
 
-    @store.setter
-    def store(  # pyright: ignore[reportIncompatibleVariableOverride]
-        self,
-        value: BookmarkStore,
-    ) -> None:
-        self._root_bookmark.store = value
-
     def on_restore(
         self,
         callback: (

shiny/bookmark/_bookmark_state.py

@@ -16,5 +16,5 @@ async def local_save_dir(id: str) -> Path:
     return state_dir
 
 
-async def local_load_dir(id: str) -> Path:
+async def local_restore_dir(id: str) -> Path:
     return _local_dir(id)

shiny/bookmark/_button.py

@@ -9,59 +9,59 @@
 BOOKMARK_ID = "._bookmark_"
 
 
-#' Create a button for bookmarking/sharing
-#'
-#' A `bookmarkButton` is a [actionButton()] with a default label
-#' that consists of a link icon and the text "Bookmark...". It is meant to be
-#' used for bookmarking state.
-#'
-#' @inheritParams actionButton
-#' @param title A tooltip that is shown when the mouse cursor hovers over the
-#'   button.
-#' @param id An ID for the bookmark button. The only time it is necessary to set
-#'   the ID unless you have more than one bookmark button in your application.
-#'   If you specify an input ID, it should be excluded from bookmarking with
-#'   [setBookmarkExclude()], and you must create an observer that
-#'   does the bookmarking when the button is pressed. See the examples below.
-#'
-#' @seealso [enableBookmarking()] for more examples.
-#'
-#' @examples
-#' ## Only run these examples in interactive sessions
-#' if (interactive()) {
-#'
-#' # This example shows how to use multiple bookmark buttons. If you only need
-#' # a single bookmark button, see examples in ?enableBookmarking.
-#' ui <- function(request) {
-#'   fluidPage(
-#'     tabsetPanel(id = "tabs",
-#'       tabPanel("One",
-#'         checkboxInput("chk1", "Checkbox 1"),
-#'         bookmarkButton(id = "bookmark1")
-#'       ),
-#'       tabPanel("Two",
-#'         checkboxInput("chk2", "Checkbox 2"),
-#'         bookmarkButton(id = "bookmark2")
-#'       )
-#'     )
-#'   )
-#' }
-#' server <- function(input, output, session) {
-#'   # Need to exclude the buttons from themselves being bookmarked
-#'   setBookmarkExclude(c("bookmark1", "bookmark2"))
-#'
-#'   # Trigger bookmarking with either button
-#'   observeEvent(input$bookmark1, {
-#'     session$doBookmark()
-#'   })
-#'   observeEvent(input$bookmark2, {
-#'     session$doBookmark()
-#'   })
-#' }
-#' enableBookmarking(store = "url")
-#' shinyApp(ui, server)
-#' }
-#' @export
+# ' Create a button for bookmarking/sharing
+# '
+# ' A `bookmarkButton` is a [actionButton()] with a default label
+# ' that consists of a link icon and the text "Bookmark...". It is meant to be
+# ' used for bookmarking state.
+# '
+# ' @inheritParams actionButton
+# ' @param title A tooltip that is shown when the mouse cursor hovers over the
+# '   button.
+# ' @param id An ID for the bookmark button. The only time it is necessary to set
+# '   the ID unless you have more than one bookmark button in your application.
+# '   If you specify an input ID, it should be excluded from bookmarking with
+# '   [setBookmarkExclude()], and you must create an observer that
+# '   does the bookmarking when the button is pressed. See the examples below.
+# '
+# ' @seealso [enableBookmarking()] for more examples.
+# '
+# ' @examples
+# ' ## Only run these examples in interactive sessions
+# ' if (interactive()) {
+# '
+# ' # This example shows how to use multiple bookmark buttons. If you only need
+# ' # a single bookmark button, see examples in ?enableBookmarking.
+# ' ui <- function(request) {
+# '   fluidPage(
+# '     tabsetPanel(id = "tabs",
+# '       tabPanel("One",
+# '         checkboxInput("chk1", "Checkbox 1"),
+# '         bookmarkButton(id = "bookmark1")
+# '       ),
+# '       tabPanel("Two",
+# '         checkboxInput("chk2", "Checkbox 2"),
+# '         bookmarkButton(id = "bookmark2")
+# '       )
+# '     )
+# '   )
+# ' }
+# ' server <- function(input, output, session) {
+# '   # Need to exclude the buttons from themselves being bookmarked
+# '   setBookmarkExclude(c("bookmark1", "bookmark2"))
+# '
+# '   # Trigger bookmarking with either button
+# '   observeEvent(input$bookmark1, {
+# '     session$doBookmark()
+# '   })
+# '   observeEvent(input$bookmark2, {
+# '     session$doBookmark()
+# '   })
+# ' }
+# ' enableBookmarking(store = "url")
+# ' shinyApp(ui, server)
+# ' }
+# ' @export
 def input_bookmark_button(
     label: TagChild = "Bookmark...",
     *,

shiny/bookmark/_external.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Awaitable, Callable, Literal, TypeVar
+
+from .._utils import wrap_async
+from ..types import MISSING, MISSING_TYPE
+from ._types import GetBookmarkRestoreDir, GetBookmarkSaveDir
+
+BookmarkStore = Literal["url", "server", "disable"]
+
+
+# WARNING! This file contains global state!
+# During App initialization, the save_dir and restore_dir functions are conventionally set
+# to read-only on the App.
+
+# The set methods below are used to set the save_dir and restore_dir locations for locations like Connect or SSP.
+# Ex:
+# ```python
+# @shiny.bookmark.set_save_dir
+# def connect_save_shiny_bookmark(id: str) -> Path:
+#     path = Path("connect") / id
+#     path.mkdir(parents=True, exist_ok=True)
+#     return path
+# @shiny.bookmark.set_restore_dir
+# def connect_restore_shiny_bookmark(id: str) -> Path:
+#     return Path("connect") / id
+# ```
+
+
+_bookmark_save_dir: GetBookmarkSaveDir | MISSING_TYPE = MISSING
+_bookmark_restore_dir: GetBookmarkRestoreDir | MISSING_TYPE = MISSING
+
+
+GetBookmarkDirT = TypeVar(
+    "GetBookmarkDirT",
+    bound=Callable[[str], Awaitable[Path]] | Callable[[str], Awaitable[Path]],
+)
+
+
+def set_save_dir(fn: GetBookmarkDirT) -> GetBookmarkDirT:
+    """TODO: Barret document"""
+    global _bookmark_save_dir
+
+    _bookmark_save_dir = wrap_async(fn)
+    return fn
+
+
+def set_restore_dir(fn: GetBookmarkDirT) -> GetBookmarkDirT:
+    """TODO: Barret document"""
+    global _bookmark_restore_dir
+
+    _bookmark_restore_dir = wrap_async(fn)
+    return fn

shiny/bookmark/_globals.py

@@ -10,9 +10,9 @@
 
 from shiny.types import MISSING_TYPE
 
-from . import _globals as bookmark_globals
-from ._bookmark_state import local_load_dir
-from ._globals import BookmarkLoadDir
+from . import _external as bookmark_external
+from ._bookmark_state import local_restore_dir
+from ._types import GetBookmarkRestoreDir
 from ._utils import from_json_str, is_hosted
 
 
@@ -59,6 +59,7 @@ def _state_within_namespace(self, prefix: str) -> "RestoreContextState":
             if self._name_has_namespace(name, prefix)
         }
 
+        # TODO-barret; Is this for bookmarking?!?
         dir = self.dir
         if dir is not None:
             dir = dir / prefix
@@ -187,9 +188,9 @@ async def _load_state_qs(self, query_string: str) -> None:
 
         id = id[0]
 
-        load_bookmark_fn: BookmarkLoadDir | None = None
-        if not isinstance(bookmark_globals.bookmark_load_dir, MISSING_TYPE):
-            load_bookmark_fn = bookmark_globals.bookmark_load_dir
+        load_bookmark_fn: GetBookmarkRestoreDir | None = None
+        if not isinstance(bookmark_external._bookmark_restore_dir, MISSING_TYPE):
+            load_bookmark_fn = bookmark_external._bookmark_restore_dir
 
         if load_bookmark_fn is None:
             if is_hosted():
@@ -199,7 +200,7 @@ async def _load_state_qs(self, query_string: str) -> None:
                 )
             else:
                 # We're running Shiny locally.
-                load_bookmark_fn = local_load_dir
+                load_bookmark_fn = local_restore_dir
 
         # Load the state from disk.
         self.dir = Path(await load_bookmark_fn(id))
@@ -401,7 +402,6 @@ def restore_input(id: str, default: Any) -> Any:
     default
         A default value to use, if there's no value to restore.
     """
-    # print("\n", "restore_input-1", id, default, "\n")
     # Will run even if the domain is missing
     if not has_current_restore_context():
         return default

shiny/bookmark/_restore_state.py

@@ -8,9 +8,9 @@
 from .._utils import private_random_id
 from ..reactive import isolate
 from ..types import MISSING_TYPE
-from . import _globals as bookmark_globals
+from . import _external as bookmark_external
 from ._bookmark_state import local_save_dir
-from ._globals import BookmarkSaveDir
+from ._types import GetBookmarkSaveDir
 from ._utils import is_hosted, to_json_str
 
 # TODO: Barret - Set / Load SaveState for Connect. Ex: Connect https://github.com/posit-dev/connect/blob/8de330aec6a61cf21e160b5081d08a1d3d7e8129/R/connect.R#L915
@@ -76,9 +76,9 @@ async def _save_state(self) -> str:
         # to `self.dir`.
 
         # This will be defined by the hosting environment if it supports bookmarking.
-        save_bookmark_fn: BookmarkSaveDir | None = None
-        if not isinstance(bookmark_globals.bookmark_save_dir, MISSING_TYPE):
-            save_bookmark_fn = bookmark_globals.bookmark_save_dir
+        save_bookmark_fn: GetBookmarkSaveDir | None = None
+        if not isinstance(bookmark_external._bookmark_save_dir, MISSING_TYPE):
+            save_bookmark_fn = bookmark_external._bookmark_save_dir
 
         if save_bookmark_fn is None:
             if is_hosted():
@@ -99,6 +99,7 @@ async def _save_state(self) -> str:
             state_dir=self.dir,
         )
         assert self.dir is not None
+
         with open(self.dir / "input.pickle", "wb") as f:
             pickle.dump(input_values_json, f)