feat(data frame): Expose .data_view_rows(), .input_sort(), .input_filter(), .update_sort(), and .update_filter()

[schloerke]

Fixes #1351
Fixes #1345
Fixes #1378

Related to #1345 (comment)
Related discussion #1345 (comment) with @pstorozenko

Final solution:

Expose .data_view_info() reactive value which returns DataViewInfo which is defined as a list of data view information.

Expose individual reactive values for the user to access on their own:

• .data_view_rows: Calc_[tuple[int]]
• .input_sort: Calc_[ListOrTuple[ColumnSort]]
• .input_filter: Calc_[ListOrTuple[ColumnFilter]]
• .update_sort(self, sort: ListOrTuple[ColumnSort | int] | ColumnSort | int | None)
  • int values are upgraded to {col: <INT>, desc: bool}; desc defaults to True if column <INT> is number like, otherwise False.
• .update_filter(self, sort: ListOrTuple[ColumnFilter] | None)

class ColumnSort(TypedDict):
    col: int
    desc: bool

class ColumnFilterStr(TypedDict):
    col: int
    value: str

class ColumnFilterNumber(TypedDict):
    col: int
    # Similar to...
    value: tuple[float, float] | tuple[float, None] | tuple[None, float]

ColumnFilter = Union[ColumnFilterStr, ColumnFilterNumber]

---

---

From #1376

Previous return type for .input_cell_selection():

class CellSelectionNone(TypedDict):
    type: Literal["none"]

class CellSelectionRow(TypedDict):
    type: Literal["row"]
    rows: ListOrTuple[int]

class CellSelectionCol(TypedDict):
    type: Literal["col"]
    cols: ListOrTuple[int]

class CellSelectionRect(TypedDict):
    type: Literal["rect"]
    # Attempt to type the list of size 2, but it is not type enforced
    rows: tuple[int, int] | Annotated[list[int], 2]
    cols: tuple[int, int] | Annotated[list[int], 2]

CellSelection = Union[
    CellSelectionRow,
    CellSelectionCol,
    CellSelectionRect,
    CellSelectionNone,
]

def .input_cell_selection() -> CellSelection | None:

New return type for .input_cell_selection():

class CellSelection(TypedDict):
    type: Literal["none", "row", "col", "rect"]
    rows: ListOrTuple[int]
    cols: ListOrTuple[int]

def .input_cell_selection() -> CellSelection | None:

• If type = "none", rows and cols are empty tuples.

• If type = "row", cols is all column numbers of the data.

• If type = "col", rows is all row numbers of the data view rows

• If type = "rect", all rows and cols are provided (no longer just min/max values).

• If .input_cell_selection() receives an empty selection (e.g. type="row" and rows=[], or type="none"), then the return value will be None as no selection is currently taking place.

Previous user interaction:

@render.data_frame
def grid(): ...

selected_rows = (grid.input_cell_selection() or {}).get("rows", ())

New user interaction:

# # Ideal
# selected_rows = grid.input_cell_selection()["rows"]

selected_rows = (grid.input_cell_selection() or { "rows": [] })["rows"]

[wch]

Add public-facing examples that use this.

For example: an app where there is an interactive table, and below it, a code output that prints out:

• The values of sort and filter
• A data frame using rows, which reflects exactly the sorted and filtered data that the user is seeing in the interactive table, and also has an extra column indicating whether that row is selected.
• Also add a second code output that just prints the value of .data_view(selected=TRUE).

[jcheng5]

After Friday discussion: drop DataViewInfo, instead add rows as another accessor on the renderer. Also, input_cell_selection rows should be ordered the way the user sees it.