First pass at restore state. **many** debug statements. Modules are saving!

Author: schloerke

shiny/_app.py

@@ -3,6 +3,7 @@
 import copy
 import os
 import secrets
+import warnings
 from contextlib import AsyncExitStack, asynccontextmanager
 from inspect import signature
 from pathlib import Path
@@ -30,6 +31,11 @@
 from ._error import ErrorMiddleware
 from ._shinyenv import is_pyodide
 from ._utils import guess_mime_type, is_async_callable, sort_keys_length
+from .bookmark._restore_state import (
+    RestoreContext,
+    get_current_restore_context,
+    restore_context,
+)
 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
@@ -167,7 +173,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,11 +359,41 @@ async def _on_root_request_cb(self, request: Request) -> Response:
         request for / occurs.
         """
         ui: RenderedHTML
-        if callable(self.ui):
-            ui = self._render_page(self.ui(request), self.lib_prefix)
+        # 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 = "disable"
+        bookmark_store: str = "query"
+
+        if bookmark_store == "disable":
+            restore_ctx = RestoreContext()
         else:
-            ui = self.ui
-        return HTMLResponse(content=ui["html"])
+            restore_ctx = await RestoreContext.from_query_string(request.url.query)
+
+        print(
+            {
+                "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:`?
+                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
+                    warnings.warn(
+                        "Trying to restore saved app state, but UI code must be a function for this to work!"
+                    )
+
+                ui = self.ui
+            return HTMLResponse(content=ui["html"])
 
     async def _on_connect_cb(self, ws: starlette.websockets.WebSocket) -> None:
         """

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

@@ -550,23 +550,26 @@ 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._id: int = 0
 
     def register(
         self, fn: Callable[..., Awaitable[None]], once: bool = False
-    ) -> Callable[[], None]:
+    ) -> 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, *args: Any, **kwargs: Any) -> None:
         # The list() wrapper is necessary to force collection of all the items before

shiny/bookmark/__init__.py

@@ -5,13 +5,19 @@
     BookmarkProxy,
     ShinySaveState,
 )
-from ._save_state import SaveState
+from ._bookmark_state import BookmarkState
+from ._restore_state import RestoreContext, RestoreContextState
 
 __all__ = (
-    "SaveState",
+    # _bookmark
     "ShinySaveState",
     "Bookmark",
     "BookmarkApp",
     "BookmarkProxy",
     "BookmarkExpressStub",
+    # _bookmark_state
+    "BookmarkState",
+    # _restore_state
+    "RestoreContext",
+    "RestoreContextState",
 )