Use consistent column filter shape

Author: schloerke

shiny/playwright/controller/_output.py

@@ -6,7 +6,9 @@
 from playwright.sync_api import Locator, Page
 from playwright.sync_api import expect as playwright_expect
 
-from ...render._data_frame import ColumnFilter, ColumnSort
+from shiny.types import ListOrTuple
+
+from ...render._data_frame import ColumnFilter, ColumnSort, assert_column_filters
 from .._types import AttrValue, ListPatternOrStr, PatternOrStr, StyleValue, Timeout
 from ..expect import expect_not_to_have_class, expect_to_have_class
 from ..expect._internal import (
@@ -1213,7 +1215,7 @@ def click_loc(loc: Locator, *, shift: bool = False):
 
     def set_filter(
         self,
-        filter: ColumnFilter | list[ColumnFilter] | None,
+        filter: ColumnFilter | ListOrTuple[ColumnFilter] | None,
         *,
         timeout: Timeout = None,
     ):
@@ -1228,6 +1230,7 @@ def set_filter(
                 * `None`: Resets all filters.
                 * `ColumnFilterStr`: A dictionary specifying a string filter with 'col' and 'value' keys.
                 * `ColumnFilterNumber`: A dictionary specifying a numeric range filter with 'col' and 'value' keys.
+                * A sequence of `ColumnFilterStr` or `ColumnFilterNumber` dictionaries, for multiple filters.
         timeout
             The maximum time to wait for the action to complete. Defaults to `None`.
         """
@@ -1240,100 +1243,52 @@ def set_filter(
         if filter is None:
             return
 
-        filter_items: Sequence[Union[ColumnFilter, dict[str, Any]]]
+        filter_items: ListOrTuple[ColumnFilter]
         if isinstance(filter, dict):
             filter_items = [filter]
         elif isinstance(filter, (list, tuple)):
-            filter_items = cast(Sequence[Union[ColumnFilter, dict[str, Any]]], filter)
+            filter_items = filter
         else:
             raise ValueError(
                 "Invalid filter value. Must be a ColumnFilter, "
                 "list[ColumnFilter], or None."
             )
 
-        for filterInfo in filter_items:
-            if "col" not in filterInfo:
-                raise ValueError("Column index (`col`) is required for filtering.")
+        assert_column_filters(filter_items, self.loc_column_label.count())
 
-            if "value" not in filterInfo:
-                raise ValueError("Filter value (`value`) is required for filtering.")
+        for filter_item in filter_items:
+            col_idx = filter_item["col"]
+            value = filter_item.get("value", None)
 
-            raw_cols = filterInfo["col"]
-            if isinstance(raw_cols, int):
-                column_indices: list[int] = [raw_cols]
-            elif isinstance(raw_cols, (list, tuple)):
-                cols_iter = cast(Sequence[Any], raw_cols)
-                if len(cols_iter) == 0:
-                    raise ValueError(
-                        "Column index list (`col`) must contain at least one " "entry."
-                    )
-                column_indices = []
-                for col_idx in cols_iter:
-                    if not isinstance(col_idx, int):
-                        raise ValueError(
-                            "Column index (`col`) values must be integers "
-                            "when specifying multiple columns."
-                        )
-                    column_indices.append(col_idx)
-            else:
-                raise ValueError(
-                    "Column index (`col`) must be an int or a list/tuple of " "ints."
-                )
+            filterColumn = self.loc_column_filter.nth(col_idx)
 
-            raw_value = filterInfo["value"]
+            if isinstance(value, (str, int, float)):
+                filterColumn.locator("> input").fill(str(value), timeout=timeout)
+                continue
 
-            if len(column_indices) > 1:
-                if not isinstance(raw_value, (list, tuple)):
-                    raise ValueError(
-                        "When filtering multiple columns, `value` must be a "
-                        "list or tuple with one entry per column."
-                    )
-                value_sequence = cast(Sequence[Any], raw_value)
-                if len(value_sequence) != len(column_indices):
+            if isinstance(value, (list, tuple)):
+                range_values = cast(Sequence[Any], value)
+                if len(range_values) != 2:
                     raise ValueError(
-                        "The number of filter values must match the number of "
-                        "target columns."
+                        "Numeric range filters must provide exactly two "
+                        "values (min, max)."
                     )
-                value_iter = list(value_sequence)
-            else:
-                value_iter = [raw_value]
-
-            for col_idx, value in zip(column_indices, value_iter):
-                filterColumn = self.loc_column_filter.nth(col_idx)
-
-                if value is None:
-                    continue
-
-                if isinstance(value, (str, int, float)):
-                    filterColumn.locator("> input").fill(str(value), timeout=timeout)
-                    continue
-
-                if isinstance(value, (list, tuple)):
-                    range_values = cast(Sequence[Any], value)
-                    if len(range_values) != 2:
-                        raise ValueError(
-                            "Numeric range filters must provide exactly two "
-                            "values (min, max)."
-                        )
-
-                    header_inputs = filterColumn.locator("> div > input")
-                    lower = range_values[0]
-                    upper = range_values[1]
-                    if lower is not None:
-                        header_inputs.nth(0).fill(str(lower), timeout=timeout)
-                    else:
-                        header_inputs.nth(0).fill("", timeout=timeout)
-
-                    if upper is not None:
-                        header_inputs.nth(1).fill(str(upper), timeout=timeout)
-                    else:
-                        header_inputs.nth(1).fill("", timeout=timeout)
-                    continue
-
-                raise ValueError(
-                    "Invalid filter value. Must be a string/number, a "
-                    "tuple/list of two numbers, or None."
-                )
+
+                header_inputs = filterColumn.locator("> div > input")
+                lower = range_values[0]
+                upper = range_values[1]
+                if lower is not None:
+                    header_inputs.nth(0).fill(str(lower), timeout=timeout)
+                else:
+                    header_inputs.nth(0).fill("", timeout=timeout)
+
+                if upper is not None:
+                    header_inputs.nth(1).fill(str(upper), timeout=timeout)
+                else:
+                    header_inputs.nth(1).fill("", timeout=timeout)
+                continue
+
+            raise ValueError("Invalid filter value.")
 
     def set_cell(
         self,

shiny/render/_data_frame.py

@@ -1172,31 +1172,7 @@ async def update_filter(
             with reactive.isolate():
                 ncol = self._nw_data().shape[1]
 
-            for column_filter, i in zip(filter, range(len(filter))):
-                assert isinstance(column_filter, dict)
-                assert isinstance(column_filter["col"], int)
-                assert 0 <= column_filter["col"] < ncol
-                if isinstance(column_filter["value"], str):
-                    ...
-                elif isinstance(column_filter["value"], (list, tuple)):
-                    assert len(column_filter["value"]) == 2
-                    if (
-                        column_filter["value"][0] is None
-                        and column_filter["value"][1] is None
-                    ):
-                        raise TypeError(
-                            "Expected `filter[{i}]['value']` to be a `str` or a `list`/`tuple` of type `int` or `None`. Received `None` for both values."
-                        )
-                    assert isinstance(
-                        column_filter["value"][0], (int, float, type(None))
-                    )
-                    assert isinstance(
-                        column_filter["value"][1], (int, float, type(None))
-                    )
-                else:
-                    raise TypeError(
-                        f"Expected `filter[{i}]['value']` to be a `str` or a `list`/`tuple` of type `int` or `None`. Received `{type(column_filter['value'])}`"
-                    )
+            assert_column_filters(filter, ncol)
 
         await self._send_message_to_browser(
             "updateColumnFilter",
@@ -1223,6 +1199,27 @@ def input_cell_selection(self) -> CellSelection | None:
         return self.cell_selection()
 
 
+def assert_column_filters(filters: ListOrTuple[ColumnFilter], ncol: int) -> None:
+    for column_filter, i in zip(filters, range(len(filters))):
+        assert isinstance(column_filter, dict)
+        assert isinstance(column_filter["col"], int)
+        assert 0 <= column_filter["col"] < ncol
+        if isinstance(column_filter["value"], str):
+            ...
+        elif isinstance(column_filter["value"], (list, tuple)):
+            assert len(column_filter["value"]) == 2
+            if column_filter["value"][0] is None and column_filter["value"][1] is None:
+                raise TypeError(
+                    "Expected `filter[{i}]['value']` to be a `str` or a `list`/`tuple` of type `int` or `None`. Received `None` for both values."
+                )
+            assert isinstance(column_filter["value"][0], (int, float, type(None)))
+            assert isinstance(column_filter["value"][1], (int, float, type(None)))
+        else:
+            raise TypeError(
+                f"Expected `filter[{i}]['value']` to be a `str` or a `list`/`tuple` of type `int` or `None`. Received `{type(column_filter['value'])}`"
+            )
+
+
 # TODO-barret; Make request to GT: Add class for gt location
 
 # TODO-barret; Are GT formatters eager or lazy?