Now, plot_series gives a locked row window precedence over the row filter

Author: FrancescAlted

src/blosc2/b2view/model.py

@@ -433,20 +433,29 @@ def plot_series(
 
         Pass *row_start*/*row_stop* to zoom into a sub-range (always read
         exactly; ``x`` stays in absolute row coordinates).  The series is a
-        CTable column (*column* is its name; an active row filter is honored) or
-        an array (*column* is the global index along the column dimension of
-        *layout*, or None for 1-D arrays).
+        CTable column (*column* is its name; a locked row window takes
+        precedence, otherwise an active row filter is honored) or an array
+        (*column* is the global index along the column dimension of *layout*,
+        or None for 1-D arrays).
         """
         path = self.normalize_path(path)
         obj = self._get_object(path)
         kind = object_kind(obj)
 
         if kind == "ctable":
-            filtered = path in self._filter_views
-            view = self._filter_views.get(path, obj)
+            # A locked row window (set by 'v') takes precedence over any row
+            # filter, mirroring preview()/read_cell(): a plot shows exactly the
+            # rows the grid is showing.  The SUMMARY fast-path spans the whole
+            # column, so it is only valid when neither narrows the series.
+            if path in self._window_views:
+                view = self._window_views[path]
+                narrowed = True
+            else:
+                view = self._filter_views.get(path, obj)
+                narrowed = path in self._filter_views
             n = len(view)
             start, stop = self._clamp_range(row_start, row_stop, n)
-            if start == 0 and stop == n and not filtered:
+            if start == 0 and stop == n and not narrowed:
                 env = self._column_summary_envelope(obj, column, n, max_points)
                 if env is not None:
                     return {**env, "n": n, "row_start": start, "row_stop": stop, "method": "summary"}
@@ -514,8 +523,9 @@ def read_series(
     ) -> dict[str, Any]:
         """Return the *raw* values of one series over ``[row_start, row_stop)``.
 
-        Same series selection as :meth:`plot_series` (CTable column honoring an
-        active filter, or an array column via *layout*) but with no bucketing —
+        Same series selection as :meth:`plot_series` (CTable column honoring a
+        locked row window then an active filter, or an array column via
+        *layout*) but with no bucketing —
         every value is read exactly, for the high-res ``h`` view.  The result is
         ``{"x", "y", "n", "row_start", "row_stop"}`` with ``x`` in absolute row
         coordinates.  This reads exactly what is asked, so callers must bound the
@@ -526,7 +536,12 @@ def read_series(
         kind = object_kind(obj)
 
         if kind == "ctable":
-            view = self._filter_views.get(path, obj)
+            # Honor a locked row window first, then any row filter, matching
+            # preview()/read_cell() so the hi-res view tracks the visible grid.
+            if path in self._window_views:
+                view = self._window_views[path]
+            else:
+                view = self._filter_views.get(path, obj)
             n = len(view)
             start, stop = self._clamp_range(row_start, row_stop, n)
             y = safe_asarray(view[column][start:stop])

tests/b2view/test_plot_model.py

@@ -193,6 +193,27 @@ def test_read_series_clamps_range(plot_store):
     assert clamped["y"].shape == (N,)
 
 
+def test_locked_row_window_confines_plot_and_read_series(plot_store):
+    """A locked row window (the 'v' action) takes precedence over the full
+    series in both plot_series and read_series, matching preview()/read_cell()
+    (PR #663 review): a plot/hi-res of a windowed CTable shows only its rows."""
+    path, vals = plot_store
+    lo, hi = 1000, 1500
+    with StoreBrowser(path) as browser:
+        browser.set_row_window("/ctable", lo, hi)
+
+        env = browser.plot_series("/ctable", column="x", max_points=MAX_POINTS)
+        assert env["n"] == hi - lo  # window length, not the full series
+        assert env["method"] != "summary"  # whole-column fast-path disabled
+        expected = _reduce_envelope(vals[lo:hi], hi - lo, MAX_POINTS)
+        np.testing.assert_allclose(env["ymin"], expected["ymin"], equal_nan=True)
+        np.testing.assert_allclose(env["ymax"], expected["ymax"], equal_nan=True)
+
+        raw = browser.read_series("/ctable", column="x")
+        assert raw["n"] == hi - lo
+        np.testing.assert_array_equal(raw["y"], vals[lo:hi])
+
+
 def test_streaming_reducer_integer_dtype():
     vals = np.arange(1000, dtype=np.int64)
     env = _minmax_buckets_streaming(lambda s, e: vals[s:e], 1000, 100, span=33)