New f key filters CTable rows in the data panel

Filters use the same string expressions as CTable.where() (dotted
nested names, and/or) and page through the matching view; escape or
an empty expression restores the full table, and each node remembers
its filter for the session.

Author: FrancescAlted

doc/getting_started/b2view.rst

@@ -76,6 +76,22 @@ select the active dimension, ``up`` / ``down`` change its fixed index (or
 scroll the viewport), ``enter`` toggles a dimension between fixed and
 navigable, and ``escape`` leaves dim mode.
 
+Step 4 — Filter CTable rows
+---------------------------
+
+On a CTable node, press ``f`` and type a filter expression to page through
+only the matching rows — the same expressions ``CTable.where()`` accepts,
+including dotted nested column names and ``and`` / ``or``:
+
+.. code-block:: text
+
+    payment.tips > 100 and trip.km > 0 and trip.sec > 0
+
+The data header shows the active filter and the matching row count; all
+navigation (paging, ``g``, ``t`` / ``b``) then operates on the filtered
+rows.  Press ``escape`` (or submit an empty expression) to go back to the
+unfiltered table; each node remembers its filter for the session.
+
 CLI options
 -----------
 

src/blosc2/b2view/app.py

@@ -4,6 +4,7 @@
 
 from typing import TYPE_CHECKING, Any, ClassVar
 
+from rich.markup import escape as markup_escape
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.containers import Horizontal, Vertical, VerticalScroll
@@ -200,6 +201,8 @@ class HelpScreen(ModalScreen[None]):
                 ("pageup / pagedown", "previous / next page"),
                 ("t / b", "first / last row"),
                 ("g", "go to row..."),
+                ("f", "filter rows (CTable)"),
+                ("escape", "clear the active filter"),
             ],
         ),
         (
@@ -370,6 +373,49 @@ def action_cancel(self) -> None:
         self.dismiss(None)
 
 
+class FilterScreen(ModalScreen[str | None]):
+    """Small modal asking for a CTable row filter expression."""
+
+    CSS = """
+    FilterScreen {
+        align: center middle;
+    }
+    #filter-dialog {
+        width: 70;
+        height: auto;
+        border: thick $accent;
+        background: $surface;
+        padding: 1 2;
+    }
+    #filter-title {
+        text-style: bold;
+        margin-bottom: 1;
+    }
+    """
+
+    BINDINGS: ClassVar = [("escape", "cancel", "Cancel")]
+
+    def __init__(self, *, current: str | None = None):
+        super().__init__()
+        self.current = current or ""
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="filter-dialog"):
+            yield Static("Filter rows (empty clears)", id="filter-title")
+            yield Input(placeholder="e.g. payment.tips > 100 and trip.km > 0", id="filter-input")
+
+    def on_mount(self) -> None:
+        input_widget = self.query_one("#filter-input", Input)
+        input_widget.value = self.current
+        input_widget.focus()
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        self.dismiss(event.value.strip())
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+
 class B2ViewApp(App):
     """Browse TreeStore hierarchy and preview objects."""
 
@@ -407,6 +453,7 @@ class B2ViewApp(App):
         Binding("s", "grid_col_start", "Row start", show=False),
         Binding("e", "grid_col_end", "Row end", show=False),
         Binding("c", "go_to_column", "Go to column", show=False),
+        Binding("f", "filter_rows", "Filter rows", show=False),
         Binding("d", "dim_cycle", "Dim mode", show=False),
         Binding("enter", "dim_toggle_nav", "Toggle nav", show=False),
         Binding("escape", "dim_exit", "Exit dim mode", show=False),
@@ -456,7 +503,9 @@ def compose(self) -> ComposeResult:
                             yield Static("", id="vlmetadata")
                 with B2ViewPanel(id="data-pane") as data_pane:
                     data_pane.border_title = "data"
-                    data_pane.border_subtitle = "?(help) | d(im mode) | rows: t/b/g(oto) | cols: s/e/c(goto)"
+                    data_pane.border_subtitle = (
+                        "?(help) | d(im mode) | f(ilter) | rows: t/b/g(oto) | cols: s/e/c(goto)"
+                    )
                     yield Static("", id="data-header")
                     with Horizontal(id="data-table-row"):
                         yield BufferedDataTable(id="data-table", show_row_labels=True, zebra_stripes=True)
@@ -1041,6 +1090,12 @@ def _update_data_header(self, data: dict) -> None:
             header_parts.append(f"rows {data['start']}:{data['stop']} of {data['nrows']}")
             if "col_start" in data:
                 header_parts.append(f"cols {data['col_start']}:{data['col_stop']} of {data['ncols']}")
+            if data.get("source_kind") == "ctable" and self.browser is not None:
+                flt = self.browser.get_filter(self.selected_path)
+                if flt:
+                    total = self.browser.base_nrows(self.selected_path)
+                    header_parts.append(f"filter: [bold]{markup_escape(flt)}[/bold] ({total} total)")
+                    header_parts.append("<f>edit <Esc>clear")
 
         line = ", ".join(header_parts)
         if self._dim_mode and layout is not None:
@@ -1161,6 +1216,31 @@ def action_go_to_column(self) -> None:
         screen = GoToColumnScreen(ncols=page["ncols"], current=current, names=names)
         self.push_screen(screen, self._go_to_column)
 
+    def action_filter_rows(self) -> None:
+        if not self._in_data_grid():
+            return
+        if self.table_page.get("source_kind") != "ctable":
+            self.notify("Filtering is only supported for CTable nodes", severity="warning")
+            return
+        screen = FilterScreen(current=self.browser.get_filter(self.selected_path))
+        self.push_screen(screen, self._apply_filter)
+
+    def _apply_filter(self, expr: str | None) -> None:
+        if expr is None or self.browser is None or self.table_page is None:
+            return
+        if expr == (self.browser.get_filter(self.selected_path) or ""):
+            return
+        try:
+            self.browser.set_filter(self.selected_path, expr)
+        except Exception as exc:
+            self.notify(f"Invalid filter: {exc}", severity="error")
+            return
+        self.table_buffer = None
+        data = self._load_table_page(self.selected_path, 0)
+        self._update_data_table(data, cursor_row=0, cursor_col=0)
+        self._update_data_header(data)
+        self.query_one("#data-table", DataTable).focus()
+
     def _go_to_column(self, col: int | None) -> None:
         if col is None or self.table_page is None:
             return
@@ -1401,12 +1481,19 @@ def action_dim_toggle_nav(self) -> None:
         self._dim_toggle()
 
     def action_dim_exit(self) -> None:
-        """Escape: exit dim mode."""
-        if not self._dim_mode:
+        """Escape: exit dim mode, or clear an active CTable filter."""
+        if self._dim_mode:
+            self._dim_mode = False
+            if self.table_page is not None:
+                self._update_data_header(self.table_page)
             return
-        self._dim_mode = False
-        if self.table_page is not None:
-            self._update_data_header(self.table_page)
+        if (
+            self._in_data_grid()
+            and self.table_page.get("source_kind") == "ctable"
+            and self.browser is not None
+            and self.browser.get_filter(self.selected_path)
+        ):
+            self._apply_filter("")
 
     def action_grid_row_top(self) -> None:
         """Jump to the first row of the table."""

src/blosc2/b2view/model.py

@@ -136,6 +136,9 @@ def __init__(self, urlpath: str):
         self.urlpath = urlpath
         self.store = blosc2.open(urlpath, mode="r")
         self.is_tree = isinstance(self.store, blosc2.TreeStore)
+        # Per-path row filters for CTable nodes (path -> expr / where() view)
+        self._filters: dict[str, str] = {}
+        self._filter_views: dict[str, Any] = {}
 
     def close(self) -> None:
         close = getattr(self.store, "close", None)
@@ -260,6 +263,7 @@ def preview(
                     return preview_array_1d(obj, start=start, stop=stop)
             return preview_array(obj, slices=slices, max_rows=max_rows, max_cols=max_cols)
         if kind == "ctable":
+            obj = self._filter_views.get(path, obj)
             stop = min(start + max_rows, len(obj)) if stop is None else stop
             return preview_ctable(
                 obj, start=start, stop=stop, columns=columns, max_cols=max_cols, col_start=col_start
@@ -273,6 +277,31 @@ def column_names(self, path: str) -> list[str] | None:
         names = list(getattr(self._get_object(path), "col_names", []) or [])
         return names or None
 
+    def set_filter(self, path: str, expr: str | None) -> int:
+        """Set or clear the row filter of a CTable path; return its row count.
+
+        An empty (or None) *expr* clears the filter.  Errors from ``where()``
+        propagate to the caller and leave any previous filter untouched.
+        """
+        path = self.normalize_path(path)
+        expr = (expr or "").strip()
+        if not expr:
+            self._filters.pop(path, None)
+            self._filter_views.pop(path, None)
+            return len(self._get_object(path))
+        view = self._get_object(path).where(expr)
+        self._filters[path] = expr
+        self._filter_views[path] = view
+        return len(view)
+
+    def get_filter(self, path: str) -> str | None:
+        """Return the active filter expression for *path*, if any."""
+        return self._filters.get(self.normalize_path(path))
+
+    def base_nrows(self, path: str) -> int:
+        """Return the unfiltered row count of the CTable at *path*."""
+        return len(self._get_object(path))
+
     def _get_object(self, path: str) -> Any:
         """Return the object represented by *path*."""
         path = self.normalize_path(path)

tests/b2view/test_basics.py

@@ -39,7 +39,7 @@
 import tree_store_gen as gen
 from textual.widgets import DataTable, Input, Tree
 
-from blosc2.b2view.app import B2ViewApp, GoToColumnScreen, GoToRowScreen, HelpScreen
+from blosc2.b2view.app import B2ViewApp, FilterScreen, GoToColumnScreen, GoToRowScreen, HelpScreen
 
 pytestmark = [pytest.mark.asyncio, pytest.mark.tui]
 
@@ -487,3 +487,62 @@ async def test_ctable_column_paging(store_path):
         assert page["viewport_width"] == table.size.width
         assert len(page["columns"]) < len(wide_columns)
         assert table.virtual_size.width <= table.size.width
+
+
+# ── CTable filtering ─────────────────────────────────────────────────────
+
+
+async def test_ctable_filtering(store_path):
+    """The 'f' modal filters CTable rows; errors and clearing keep state sane."""
+    app = B2ViewApp(store_path, start_path="/level0/ctable", start_panel="data")
+    async with app.run_test(size=TERM_SIZE) as pilot:
+        await wait_for_table(pilot)
+        await focus_data_table(pilot)
+        expected = gen.ctable_values(NROWS)
+
+        async def submit_filter(expr: str) -> None:
+            await pilot.press("f")
+            await pilot.pause()
+            assert isinstance(app.screen, FilterScreen)
+            app.screen.query_one("#filter-input", Input).value = expr
+            await pilot.press("enter")
+            await wait_for_table(pilot)
+
+        # Apply a filter: rows with b in [100, 110) (column b holds 0..NROWS-1)
+        await submit_filter("b >= 100 and b < 110")
+        page = app.table_page
+        assert page["nrows"] == 10
+        np.testing.assert_array_equal(page["data"]["b"], expected["b"][100:110])
+        np.testing.assert_allclose(page["data"]["c"], expected["c"][100:110])
+
+        # An invalid expression notifies and keeps the previous filter
+        await submit_filter("nosuchcol > 1")
+        assert app.browser.get_filter("/level0/ctable") == "b >= 100 and b < 110"
+        assert app.table_page["nrows"] == 10
+
+        # Re-opening the modal prefills the active filter; escape cancels
+        await pilot.press("f")
+        await pilot.pause()
+        assert app.screen.query_one("#filter-input", Input).value == "b >= 100 and b < 110"
+        await pilot.press("escape")
+        await wait_for_table(pilot)
+        assert app.table_page["nrows"] == 10
+
+        # A filter matching nothing yields an empty (but live) grid
+        await submit_filter("b < 0")
+        assert app.table_page["nrows"] == 0
+
+        # An empty input clears the filter and restores the full table
+        await submit_filter("")
+        page = app.table_page
+        assert app.browser.get_filter("/level0/ctable") is None
+        assert page["nrows"] == NROWS
+        np.testing.assert_array_equal(page["data"]["b"], expected["b"][: page["stop"]])
+
+        # Escape on the data grid also clears an active filter
+        await submit_filter("b >= 100 and b < 110")
+        assert app.table_page["nrows"] == 10
+        await pilot.press("escape")
+        await wait_for_table(pilot)
+        assert app.browser.get_filter("/level0/ctable") is None
+        assert app.table_page["nrows"] == NROWS