First pass of using ._session._parent.bookmark instead of ._root_bookmark; "Exclude" todo remaining

Author: schloerke

shiny/bookmark/_bookmark.py

@@ -6,7 +6,6 @@
 from typing import TYPE_CHECKING, Awaitable, Callable, Literal, NoReturn
 
 from .._utils import AsyncCallbacks, CancelCallback, wrap_async
-from ..types import MISSING, MISSING_TYPE
 from ._button import BOOKMARK_ID
 from ._restore_state import RestoreState
 from ._save_state import BookmarkState
@@ -62,41 +61,33 @@
 if TYPE_CHECKING:
     from ..express._stub_session import ExpressStubSession
     from ..module import ResolvedId
-    from ..session import Session
-    from ..session._session import SessionProxy
+    from ..session._session import AppSession, SessionProxy
     from . import RestoreContext
 else:
     from typing import Any
 
     RestoreContext = Any
-    Session = Any
     SessionProxy = Any
+    AppSession = Any
     ResolvedId = Any
     ExpressStubSession = Any
 
 
-# TODO: future - Local storage Bookmark class!
-# * Needs a consistent id for storage.
-# * Needs ways to clean up other storage
-# * Needs ways to see available IDs
-
-
 class Bookmark(ABC):
 
-    _session_root: Session
-    """
-    The root session object (most likely a `AppSession` object).
-    """
-
-    _store: BookmarkStore | MISSING_TYPE
-    """
-    Session specific bookmark store value.
+    _proxy_exclude_fns: 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."""
 
-    This value could help determine how session state is saved. However, 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.
-    """
+    _on_bookmark_callbacks: AsyncCallbacks
+    _on_bookmarked_callbacks: AsyncCallbacks
+    _on_restore_callbacks: AsyncCallbacks
+    _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
     def store(self) -> BookmarkStore:
         """
         App's bookmark store value
@@ -106,47 +97,31 @@ def store(self) -> BookmarkStore:
         * `"server"`: Save / reload the bookmark state on the server.
         * `"disable"` (default): Bookmarking is diabled.
         """
-
-        # Read from the App's bookmark store value.
-        return self._session_root.app.bookmark_store
-
-    _proxy_exclude_fns: 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."""
-
-    _on_bookmark_callbacks: AsyncCallbacks
-    _on_bookmarked_callbacks: AsyncCallbacks
-    _on_restore_callbacks: AsyncCallbacks
-    _on_restored_callbacks: AsyncCallbacks
-
-    _restore_context_value: RestoreContext | None
-    """
-    Placeholder value that should only be manually set within the session's `init` websocket message.
-    """
+        ...
 
     @property
+    @abstractmethod
     def _restore_context(self) -> RestoreContext | None:
         """
         A read-only value of the session's RestoreContext object.
         """
-        return self._root_bookmark._restore_context_value
+        ...
 
-    async def __call__(self) -> None:
-        await self._root_bookmark.do_bookmark()
+    @abstractmethod
+    def _set_restore_context(self, restore_context: RestoreContext):
+        """
+        Set the session's RestoreContext object.
 
-    @property
-    def _root_bookmark(self) -> "Bookmark":
-        """The base session's bookmark object."""
-        return self._session_root.bookmark
+        This should only be done within the `init` websocket message.
+        """
+        ...
 
-    def __init__(self, session_root: Session):
-        # from ._restore_state import RestoreContext
+    async def __call__(self) -> None:
+        await self.do_bookmark()
+
+    def __init__(self):
 
         super().__init__()
-        self._session_root = session_root
-        self._restore_context_value = None
-        self._store = MISSING
 
         self._proxy_exclude_fns = []
         self.exclude = []
@@ -288,8 +263,47 @@ def on_restored(
 
 
 class BookmarkApp(Bookmark):
-    def __init__(self, session_root: Session):
-        super().__init__(session_root)
+    _session: AppSession
+    """
+    The root session object (most likely a `AppSession` object).
+    """
+    _restore_context_value: RestoreContext
+    """
+    Placeholder value that should only be manually set within the session's `init` websocket message.
+    """
+
+    def __init__(self, session: AppSession):
+        from ..session._session import AppSession
+
+        assert isinstance(session, AppSession)
+        super().__init__()
+
+        self._session = session
+        # self._restore_context_value = None
+
+    # 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
+    def store(self) -> BookmarkStore:
+        """
+        App's bookmark store value
+
+        Possible values:
+        * `"url"`: Save / reload the bookmark state in the URL.
+        * `"server"`: Save / reload the bookmark state on the server.
+        * `"disable"` (default): Bookmarking is diabled.
+        """
+
+        return self._session.app.bookmark_store
+
+    @property
+    def _restore_context(self) -> RestoreContext | None:
+        """
+        A read-only value of the session's RestoreContext object.
+        """
+        return self._restore_context_value
+
+    def _set_restore_context(self, restore_context: RestoreContext):
+        self._restore_context_value = restore_context
 
     def _create_effects(self) -> None:
         """
@@ -305,7 +319,7 @@ def _create_effects(self) -> None:
         if self.store == "disable":
             return
 
-        session = self._session_root
+        session = self._session
 
         from .. import reactive
         from ..session import session_context
@@ -432,7 +446,7 @@ async def update_query_string(
     ) -> None:
         if mode not in {"replace", "push"}:
             raise ValueError(f"Invalid mode: {mode}")
-        await self._session_root._send_message(
+        await self._session._send_message(
             {
                 "updateQueryString": {
                     "queryString": query_string,
@@ -462,17 +476,17 @@ async def do_bookmark(self) -> None:
             from ..session import session_context
 
             async def root_state_on_save(state: BookmarkState) -> None:
-                with session_context(self._session_root):
+                with session_context(self._session):
                     await self._on_bookmark_callbacks.invoke(state)
 
             root_state = BookmarkState(
-                input=self._session_root.input,
+                input=self._session.input,
                 exclude=self._get_bookmark_exclude(),
                 on_save=root_state_on_save,
             )
 
             if self.store == "server":
-                query_string = await root_state._save_state(app=self._session_root.app)
+                query_string = await root_state._save_state(app=self._session.app)
             elif self.store == "url":
                 query_string = await root_state._encode_state()
             # # Can we have browser storage?
@@ -484,7 +498,7 @@ async def root_state_on_save(state: BookmarkState) -> None:
             else:
                 raise ValueError("Unknown bookmark store: " + self.store)
 
-            clientdata = self._session_root.clientdata
+            clientdata = self._session.clientdata
 
             port = str(clientdata.url_port())
             full_url = "".join(
@@ -503,7 +517,7 @@ async def root_state_on_save(state: BookmarkState) -> None:
             # If onBookmarked callback was provided, invoke it; if not call
             # the default.
             if self._on_bookmarked_callbacks.count() > 0:
-                with session_context(self._session_root):
+                with session_context(self._session):
                     await self._on_bookmarked_callbacks.invoke(full_url)
             else:
                 # `session.bookmark.show_modal(url)`
@@ -523,14 +537,20 @@ async def root_state_on_save(state: BookmarkState) -> None:
 class BookmarkProxy(Bookmark):
 
     _ns: ResolvedId
+    _session: SessionProxy
 
     def __init__(self, session_proxy: SessionProxy):
-        super().__init__(session_proxy.root_scope())
+        from ..session._session import SessionProxy
+
+        assert isinstance(session_proxy, SessionProxy)
+        super().__init__()
 
         self._ns = session_proxy.ns
-        self._session_proxy = session_proxy
+        self._session = session_proxy
 
-        self._session_root.bookmark._proxy_exclude_fns.append(
+        # 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(
             lambda: [str(self._ns(name)) for name in self.exclude]
         )
 
@@ -540,39 +560,39 @@ def __init__(self, session_proxy: SessionProxy):
 
         # The goal of this method is to save the scope's values. All namespaced inputs
         # will already exist within the `root_state`.
-        @self._root_bookmark.on_bookmark
+        @self._session._parent.bookmark.on_bookmark
         async def scoped_on_bookmark(root_state: BookmarkState) -> None:
             return await self._scoped_on_bookmark(root_state)
 
         from ..session import session_context
 
-        @self._root_bookmark.on_bookmarked
+        @self._session._parent.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):
+            with session_context(self._session):
                 await self._on_bookmarked_callbacks.invoke(url)
 
         ns_prefix = str(self._ns + self._ns._sep)
 
-        @self._root_bookmark.on_restore
+        @self._session._parent.bookmark.on_restore
         async def scoped_on_restore(restore_state: RestoreState) -> None:
             if self._on_restore_callbacks.count() == 0:
                 return
 
             scoped_restore_state = restore_state._state_within_namespace(ns_prefix)
 
-            with session_context(self._session_proxy):
+            with session_context(self._session):
                 await self._on_restore_callbacks.invoke(scoped_restore_state)
 
-        @self._root_bookmark.on_restored
+        @self._session._parent.bookmark.on_restored
         async def scoped_on_restored(restore_state: RestoreState) -> None:
             if self._on_restored_callbacks.count() == 0:
                 return
 
             scoped_restore_state = restore_state._state_within_namespace(ns_prefix)
-            with session_context(self._session_proxy):
+            with session_context(self._session):
                 await self._on_restored_callbacks.invoke(scoped_restore_state)
 
     async def _scoped_on_bookmark(self, root_state: BookmarkState) -> None:
@@ -583,8 +603,8 @@ async def _scoped_on_bookmark(self, root_state: BookmarkState) -> None:
         from ..bookmark._bookmark import BookmarkState
 
         scoped_state = BookmarkState(
-            input=self._session_root.input,
-            exclude=self._root_bookmark.exclude,
+            input=self._session.input,
+            exclude=self.exclude,
             on_save=None,
         )
 
@@ -603,7 +623,7 @@ async def _scoped_on_bookmark(self, root_state: BookmarkState) -> None:
         # Invoke the callback on the scopeState object
         from ..session import session_context
 
-        with session_context(self._session_proxy):
+        with session_context(self._session):
             await self._on_bookmark_callbacks.invoke(scoped_state)
 
         # Copy `values` from scoped_state to root_state (adding namespace)
@@ -613,6 +633,19 @@ async def _scoped_on_bookmark(self, root_state: BookmarkState) -> None:
                     raise ValueError("All scope values must be named.")
                 root_state.values[str(self._ns(key))] = value
 
+    @property
+    def store(self) -> BookmarkStore:
+        return self._session._parent.bookmark.store
+
+    @property
+    def _restore_context(self) -> RestoreContext | None:
+        return self._session._parent.bookmark._restore_context
+
+    def _set_restore_context(self, restore_context: RestoreContext) -> NoReturn:
+        raise NotImplementedError(
+            "The `RestoreContext` should only be set on the root session object."
+        )
+
     def _create_effects(self) -> NoReturn:
         raise NotImplementedError(
             "Please call `._create_effects()` from the root session only."
@@ -635,21 +668,18 @@ def on_bookmarked(
         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:
-        await self._root_bookmark.update_query_string(query_string, mode)
+        await self._session._parent.bookmark.update_query_string(query_string, mode)
 
     async def do_bookmark(self) -> None:
-        await self._root_bookmark.do_bookmark()
-
-    @property
-    def store(self) -> BookmarkStore:
-        return self._root_bookmark.store
+        await self._session._parent.bookmark.do_bookmark()
 
     def on_restore(
         self,
@@ -670,8 +700,24 @@ def on_restored(
 
 class BookmarkExpressStub(Bookmark):
 
-    def __init__(self, session_root: ExpressStubSession) -> None:
-        super().__init__(session_root)
+    def __init__(self, session: ExpressStubSession) -> None:
+        super().__init__()
+
+        from ..express._stub_session import ExpressStubSession
+
+        assert isinstance(session, ExpressStubSession)
+        self._session = session
+
+    @property
+    def store(self) -> BookmarkStore:
+        return "disable"
+
+    @property
+    def _restore_context(self) -> RestoreContext | None:
+        return None
+
+    def _set_restore_context(self, restore_context: RestoreContext) -> None:
+        return None
 
     def _create_effects(self) -> NoReturn:
         raise NotImplementedError(