add bookmarking to df - part 1

Author: karangattu

shiny/render/_data_frame.py

@@ -562,6 +562,8 @@ def _reset_reactives(self) -> None:
         self._updated_data.unset()
 
     def _init_reactives(self) -> None:
+        from ..bookmark._restore_state import RestoreState
+        from ..bookmark._save_state import BookmarkState
 
         # Init
         self._value = reactive.Value(None)
@@ -588,6 +590,57 @@ async def _():
             # It currently is, as `@reactive.event()` is being used
             await self._attempt_update_cell_style()
 
+        def bookmark_cell_patch_id() -> str:
+            return f"{self.output_id}--cell_patch_map"
+
+        def bookmark_data_id() -> str:
+            return f"{self.output_id}--data"
+
+        @self._get_session().bookmark.on_bookmark
+        def _(state: BookmarkState):
+            cell_patch_map = self._cell_patch_map()
+            if cell_patch_map:
+                cell_patch_id_val = bookmark_cell_patch_id()
+                if cell_patch_id_val in state.values:
+                    raise RuntimeError(
+                        f"Bookmark state already contains a value for {cell_patch_id_val}. Please use a different ID."
+                    )
+                state.values[cell_patch_id_val] = cell_patch_map
+
+            updated_data = self._updated_data()
+            if updated_data:
+                # TODO-barret-render.data_frame; Handle restoring updated data
+                # Related: Restoring Chat UI: https://github.com/posit-dev/py-shiny/issues/1952
+                raise RuntimeError(
+                    "Bookmarking an updated data frame is not supported."
+                )
+
+        @self._get_session().bookmark.on_restore
+        def _(state: RestoreState):
+            if state.input[f"{self.output_id}_cell_selection"]:
+                self.update_cell_selection(
+                    state.input[f"{self.output_id}_cell_selection"]
+                )
+            if state.input[f"{self.output_id}_column_sort"]:
+                self.update_sort(state.input[f"{self.output_id}_column_sort"])
+            if state.input[f"{self.output_id}_column_filter"]:
+                self.update_filter(state.input[f"{self.output_id}_column_filter"])
+            if state.input[f"{self.output_id}_cell_selection"]:
+                self.update_cell_selection(
+                    state.input[f"{self.output_id}_cell_selection"]
+                )
+            if state.input[f"{self.output_id}_data_view_rows"]:
+
+            cell_patch_map = state.values.get(bookmark_cell_patch_id(), None)
+            if cell_patch_map:
+                self._cell_patch_map.set(cell_patch_map)
+                self._updated_data.set(self._nw_data_to_original_type(self._nw_data()))
+
+            updated_data = state.values.get(bookmark_data_id(), None)
+            if updated_data:
+                # TODO-barret-render.data_frame; Handle restoring updated data
+                raise RuntimeError("Restoring an updated data frame is not supported.")
+
     def _get_session(self) -> Session:
         if self._session is None:
             raise RuntimeError(

tests/playwright/ai_generated_apps/bookmark/dataframe/app-express.py

@@ -0,0 +1,81 @@
+from palmerpenguins import load_penguins
+from shiny import reactive
+from shiny.express import app_opts, input, render, session, ui
+
+penguins = load_penguins()
+
+app_opts(bookmark_store="url")
+
+
+ui.h2("Palmer Penguins")
+
+ui.h5("Current selection: ", {"class": "pt-2"})
+
+
+@render.code
+def _():
+    return penguins_df.cell_selection()["rows"]
+
+
+ui.br()
+
+
+@render.data_frame
+def penguins_df():
+    return render.DataGrid(penguins, selection_mode="rows")
+
+
+@render.text
+def penguins_df_text():
+    return f"Selection mode: rows - Selected: {penguins_df.cell_selection()['rows']}"
+
+
+ui.br()
+
+
+@render.data_frame
+def penguins_row_df():
+    return render.DataGrid(penguins, selection_mode="row")
+
+
+@render.text
+def penguins_row_df_text():
+    return f"Selection mode: row - Selected: {penguins_row_df.cell_selection()['rows']}"
+
+
+ui.br()
+
+
+@render.data_frame
+def penguins_filter_df():
+    return render.DataGrid(penguins, filters=True)
+
+
+@render.text
+def penguins_filter_df_text():
+    return f"Filters enabled - Selected: {penguins_filter_df.cell_selection()['rows']}"
+
+
+ui.br()
+
+
+@render.data_frame
+def penguins_editable_df():
+    return render.DataGrid(penguins, editable=True)
+
+
+@render.text
+def penguins_editable_df_text():
+    return f"Editable grid - Selected: {penguins_editable_df.cell_selection()['rows']}"
+
+
+ui.br()
+
+ui.input_bookmark_button()
+
+ui.br()
+
+
+@session.bookmark.on_bookmarked
+async def _(url: str):
+    await session.bookmark.update_query_string(url)