Expose .data_view_info() for @render.data_frame obj

Author: schloerke

js/data-frame/index.tsx

@@ -320,7 +320,6 @@ const ShinyDataGrid: FC<ShinyDataGridProps<unknown>> = ({
 
   useEffect(() => {
     if (!id) return;
-    const shinyId = `${id}_cell_selection`;
     let shinyValue: CellSelection | null = null;
     if (rowSelectionModes.is_none()) {
       shinyValue = null;
@@ -334,28 +333,27 @@ const ShinyDataGrid: FC<ShinyDataGridProps<unknown>> = ({
     } else {
       console.error("Unhandled row selection mode:", rowSelectionModes);
     }
-    Shiny.setInputValue!(shinyId, shinyValue);
+    Shiny.setInputValue!(`${id}_cell_selection`, shinyValue);
   }, [id, rowSelection, rowSelectionModes, table, table.getSortedRowModel]);
 
   useEffect(() => {
     if (!id) return;
-    const shinyId = `${id}_column_sort`;
-    Shiny.setInputValue!(shinyId, sorting);
+    Shiny.setInputValue!(`${id}_column_sort`, sorting);
   }, [id, sorting]);
   useEffect(() => {
     if (!id) return;
-    const shinyId = `${id}_column_filter`;
-    Shiny.setInputValue!(shinyId, columnFilters);
+    Shiny.setInputValue!(`${id}_column_filter`, columnFilters);
   }, [id, columnFilters]);
   useEffect(() => {
     if (!id) return;
-    const shinyId = `${id}_data_view_indices`;
-
     // Already prefiltered rows!
     const shinyValue: RowModel<unknown[]> = table.getSortedRowModel();
 
     const rowIndices = table.getSortedRowModel().rows.map((row) => row.index);
-    Shiny.setInputValue!(shinyId, rowIndices);
+    Shiny.setInputValue!(`${id}_data_view_rows`, rowIndices);
+
+    // Legacy value as of 2024-05-13
+    Shiny.setInputValue!(`${id}_data_view_indices`, rowIndices);
   }, [
     id,
     table,

shiny/render/_data_frame.py

@@ -2,6 +2,9 @@
 
 import warnings
 
+# TODO-barret; Should `.input_cell_selection()` ever return None? Is that value even helpful? Empty lists would be much more user friendly.
+# TODO-barret-render.data_frame; Add method `update_sort()`
+# TODO-barret-render.data_frame; Add method `update_filter()`
 # TODO-barret-render.data_frame; Docs
 # TODO-barret-render.data_frame; Add examples!
 from typing import (
@@ -58,11 +61,6 @@
 from ._data_frame_utils._datagridtable import DataFrameResult
 
 
-class SelectedIndices(TypedDict):
-    rows: tuple[int] | None
-    columns: tuple[int] | None
-
-
 class ColumnSort(TypedDict):
     id: str
     desc: bool
@@ -78,6 +76,18 @@ class ColumnFilterNumber(TypedDict):
     value: tuple[float, float]
 
 
+ColumnFilter = Union[ColumnFilterStr, ColumnFilterNumber]
+
+
+class DataViewInfo(TypedDict):
+    sort: tuple[ColumnSort, ...]
+    filter: tuple[ColumnFilter, ...]
+
+    rows: tuple[int, ...]  # sorted and filtered row number
+    selected_rows: tuple[int, ...]  # selected and sorted and filtered row number
+    # selected_columns: tuple[int, ...]  # selected and sorted and filtered row number
+
+
 # # TODO-future; Use `dataframe-api-compat>=0.2.6` to injest dataframes and return standardized dataframe structures
 # # TODO-future: Find this type definition: https://github.com/data-apis/dataframe-api-compat/blob/273c0be45962573985b3a420869d0505a3f9f55d/dataframe_api_compat/polars_standard/dataframe_object.py#L22
 # # Related: https://data-apis.org/dataframe-api-compat/quick_start/
@@ -275,6 +285,18 @@ def data_view(self, *, selected: bool = False) -> pd.DataFrame:
         else:
             return self._data_view_all()
 
+    data_view_info: reactive.Calc_[DataViewInfo]
+    """
+    Reactive value of the data frame's view information.
+
+    This includes:
+    * `sort`: An array of `{"id": str, "desc": bool }` information. This is the output of `.input_column_sort()`.
+    * `filter`: An array of `{"id": str, "value": str | tuple[float, float]}` information. This is the output of `.input_column_filter()`.
+    * `rows`: The row numbers of the data frame that are currently being viewed in the browser after sorting and filtering has been applied.
+    * `selected_rows`: `rows` values that have been selected by the user. This value created from the `rows` key in `.input_cell_selection()`.
+
+    """
+
     # TODO-barret-render.data_frame; Allow for DataTable and DataGrid to accept SelectionModes
     selection_modes: reactive.Calc_[SelectionModes]
     """
@@ -285,7 +307,7 @@ def data_view(self, *, selected: bool = False) -> pd.DataFrame:
     """
     Reactive value of selected cell information.
 
-    This method is a wrapper around `input.<id>_selected_cells()`, where `<id>` is
+    This method is a wrapper around `input.<id>_cell_selection()`, where `<id>` is
     the `id` of the data frame output. This method returns the selected rows and
     will cause reactive updates as the selected rows change.
 
@@ -297,7 +319,7 @@ def data_view(self, *, selected: bool = False) -> pd.DataFrame:
           selected cells.
     """
 
-    _input_data_view_indices: reactive.Calc_[list[int]]
+    _input_data_view_rows: reactive.Calc_[tuple[int, ...]]
     """
     Reactive value of the data frame's view indices.
 
@@ -311,6 +333,16 @@ def data_view(self, *, selected: bool = False) -> pd.DataFrame:
     This is the data frame with all the user's edit patches applied to it.
     """
 
+    input_column_sort: reactive.Calc_[tuple[ColumnSort, ...]]
+    """
+    Reactive value of the data frame's column sorting information.
+    """
+
+    input_column_filter: reactive.Calc_[tuple[ColumnFilter, ...]]
+    """
+    Reactive value of the data frame's column filters.
+    """
+
     def _reset_reactives(self) -> None:
         self._value.set(None)
         self._cell_patch_map.set({})
@@ -380,36 +412,53 @@ def self_input_cell_selection() -> CellSelection | None:
 
         self.input_cell_selection = self_input_cell_selection
 
-        # # Array of sorted column information
-        # # TODO-barret-render.data_frame; Expose and update column sorting
-        # # Do not expose until update methods are provided
-        # @reactive.calc
-        # def self__input_column_sort() -> list[ColumnSort]:
-        #     column_sort = self._get_session().input[f"{self.output_id}_column_sort"]()
-        #     return column_sort
+        @reactive.calc
+        def self_input_column_sort() -> tuple[ColumnSort, ...]:
+            column_sort = self._get_session().input[f"{self.output_id}_column_sort"]()
+            return tuple(column_sort)
 
-        # self._input_column_sort = self__input_column_sort
+        self.input_column_sort = self_input_column_sort
 
-        # # Array of column filters applied by user
-        # # TODO-barret-render.data_frame; Expose and update column filters
-        # # Do not expose until update methods are provided
-        # @reactive.calc
-        # def self__input_column_filter() -> list[ColumnFilterStr | ColumnFilterNumber]:
-        #     column_filter = self._get_session().input[
-        #         f"{self.output_id}_column_filter"
-        #     ]()
-        #     return column_filter
+        @reactive.calc
+        def self_input_column_filter() -> tuple[ColumnFilter, ...]:
+            column_filter = self._get_session().input[
+                f"{self.output_id}_column_filter"
+            ]()
+            return tuple(column_filter)
+
+        self.input_column_filter = self_input_column_filter
+
+        @reactive.calc
+        def self_data_view_info() -> DataViewInfo:
+
+            cell_selection = self.input_cell_selection()
+            selected_rows = tuple(
+                cell_selection["rows"]
+                if cell_selection is not None and "rows" in cell_selection
+                else tuple[int]()
+            )
+
+            sort = self.input_column_sort()
+            filter = self.input_column_filter()
+            rows = self._input_data_view_rows()
+
+            return {
+                "sort": sort,
+                "filter": filter,
+                "rows": rows,
+                "selected_rows": selected_rows,
+            }
 
-        # self._input_column_filter = self__input_column_filter
+        self.data_view_info = self_data_view_info
 
         @reactive.calc
-        def self__input_data_view_indices() -> list[int]:
-            data_view_indices = self._get_session().input[
-                f"{self.output_id}_data_view_indices"
+        def self__input_data_view_rows() -> tuple[int, ...]:
+            data_view_rows = self._get_session().input[
+                f"{self.output_id}_data_view_rows"
             ]()
-            return data_view_indices
+            return tuple(data_view_rows)
 
-        self._input_data_view_indices = self__input_data_view_indices
+        self._input_data_view_rows = self__input_data_view_rows
 
         # @reactive.calc
         # def self__data_selected() -> pd.DataFrame:
@@ -485,23 +534,21 @@ def _subset_data_view(selected: bool) -> pd.DataFrame:
                 data = self._data_patched().copy(deep=False)
 
                 # Turn into list for pandas compatibility
-                data_view_indices = list(self._input_data_view_indices())
+                data_view_rows = list(self._input_data_view_rows())
 
                 # Possibly subset the indices to selected rows
                 if selected:
                     cell_selection = self.input_cell_selection()
                     if cell_selection is not None and cell_selection["type"] == "row":
                         # Use a `set` for faster lookups
-                        selected_row_indices_set = set(cell_selection["rows"])
+                        selected_row_set = set(cell_selection["rows"])
 
                         # Subset the data view indices to only include the selected rows
-                        data_view_indices = [
-                            index
-                            for index in data_view_indices
-                            if index in selected_row_indices_set
+                        data_view_rows = [
+                            row for row in data_view_rows if row in selected_row_set
                         ]
 
-                return data.iloc[data_view_indices]
+                return data.iloc[data_view_rows]
 
         # Helper reactives so that internal calculations can be cached for use in other calculations
         @reactive.calc

shiny/www/shared/py-shiny/data-frame/data-frame.js

@@ -0,0 +1,84 @@
+# pyright: reportUnknownMemberType = false
+# pyright: reportMissingTypeStubs = false
+# pyright: reportArgumentType = false
+# pyright: reportUnknownMemberType = false
+
+from palmerpenguins import load_penguins_raw
+
+from shiny import App, Inputs, Outputs, Session, module, render, ui
+
+# Load the dataset
+penguins = load_penguins_raw().head(5)[["Sample Number", "Individual ID", "Date Egg"]]
+df = penguins
+MOD_ID = "testing"
+
+
+@module.ui
+def mod_ui():
+    return ui.TagList(
+        ui.card(
+            ui.layout_column_wrap(
+                ui.TagList(
+                    ui.div("Size: ", ui.output_text_verbatim("info_size")),
+                    ui.div("Sort: ", ui.output_text_verbatim("sort")),
+                    ui.div("Filter: ", ui.output_text_verbatim("filter")),
+                    ui.div("Rows: ", ui.output_text_verbatim("rows")),
+                    ui.div("Selected Rows: ", ui.output_text_verbatim("selected_rows")),
+                ),
+                ui.output_data_frame("penguins_df"),
+                width=1 / 2,
+            )
+        ),
+    )
+
+
+app_ui = ui.page_fillable(
+    {"class": "p-3"},
+    mod_ui(MOD_ID),
+)
+
+
+@module.server
+def mod_server(input: Inputs, output: Outputs, session: Session):
+    @render.data_frame
+    def penguins_df():
+        # return df
+        return render.DataGrid(
+            df,
+            selection_mode="rows",
+            editable=False,
+            filters=True,
+        )
+        # return render.DataTable(df, selection_mode="none", editable=True)
+        # return render.DataGrid(df, selection_mode="rows", editable=True)
+        # return render.DataTable(df, selection_mode="rows", editable=True)
+        return render.DataGrid(df, selection_mode="rows", editable=False)
+        # return render.DataTable(df, selection_mode="rows", editable=False)
+
+    @render.code
+    def info_size():
+        return str(len(penguins_df.data_view_info()))
+
+    @render.code
+    def sort():
+        return str(penguins_df.data_view_info()["sort"])
+
+    @render.code
+    def filter():
+        return str(penguins_df.data_view_info()["filter"])
+
+    @render.code
+    def rows():
+        return str(penguins_df.data_view_info()["rows"])
+
+    @render.code
+    def selected_rows():
+        return str(penguins_df.data_view_info()["selected_rows"])
+
+
+def server(input: Inputs, output: Outputs, session: Session):
+    mod_server(MOD_ID)
+
+
+app = App(app_ui, server, debug=False)
+app.sanitize_errors = True

shiny/www/shared/py-shiny/data-frame/data-frame.js.map

@@ -0,0 +1,42 @@
+from conftest import ShinyAppProc
+from controls import OutputDataFrame, OutputTextVerbatim
+from playwright.sync_api import Page
+
+
+def test_validate_html_columns(page: Page, local_app: ShinyAppProc) -> None:
+    page.goto(local_app.url)
+
+    data_frame = OutputDataFrame(page, "testing-penguins_df")
+
+    OutputTextVerbatim(page, "testing-info_size").expect_value("4")
+
+    sort = OutputTextVerbatim(page, "testing-sort")
+    filter = OutputTextVerbatim(page, "testing-filter")
+    rows = OutputTextVerbatim(page, "testing-rows")
+    selected_rows = OutputTextVerbatim(page, "testing-selected_rows")
+
+    sort.expect_value("()")
+    filter.expect_value("()")
+    rows.expect_value("(0, 1, 2, 3, 4)")
+    selected_rows.expect_value("()")
+
+    data_frame.set_column_sort(col=2)
+    data_frame.set_column_sort(col=2)
+    sort.expect_value("({'id': 'Date Egg', 'desc': True},)")
+    filter.expect_value("()")
+    rows.expect_value("(2, 3, 4, 0, 1)")
+    selected_rows.expect_value("()")
+
+    data_frame.set_column_filter(1, text="A2")
+    sort.expect_value("({'id': 'Date Egg', 'desc': True},)")
+
+    data_frame.set_column_filter(0, text=["2", ""])
+    filter.expect_value(
+        "({'id': 'Individual ID', 'value': 'A2'}, {'id': 'Sample Number', 'value': (2, None)})"
+    )
+
+    rows.expect_value("(3, 1)")
+    selected_rows.expect_value("()")
+    data_frame.select_rows([0])
+    rows.expect_value("(3, 1)")
+    selected_rows.expect_value("(3,)")