python-calamine-reducto 0.7.14__tar.gz → 0.7.15__tar.gz

{python_calamine_reducto-0.7.14 → python_calamine_reducto-0.7.15}/Cargo.lock

@@ -612,7 +612,7 @@ dependencies = [
 
 [[package]]
 name = "python-calamine-reducto"
-version = "0.7.14"
+version = "0.7.15"
 dependencies = [
  "calamine",
  "chrono",

{python_calamine_reducto-0.7.14 → python_calamine_reducto-0.7.15}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "python-calamine-reducto"
-version = "0.7.14"
+version = "0.7.15"
 edition = "2021"
 readme = "README.md"
 

{python_calamine_reducto-0.7.14 → python_calamine_reducto-0.7.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-calamine-reducto
-Version: 0.7.14
+Version: 0.7.15
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: 3.11

{python_calamine_reducto-0.7.14 → python_calamine_reducto-0.7.15}/src/types/workbook.rs

@@ -700,6 +700,7 @@ impl CalamineWorkbook {
         trigger_cells=2_000_000,
         trigger_density=0.001,
         coverage=0.999,
+        propagate_merges=false,
     ))]
     fn py_for_each_band(
         &mut self,
@@ -711,6 +712,7 @@ impl CalamineWorkbook {
         trigger_cells: usize,
         trigger_density: f64,
         coverage: f64,
+        propagate_merges: bool,
     ) -> PyResult<(usize, usize, u64)> {
         self.for_each_band(
             py,
@@ -721,6 +723,7 @@ impl CalamineWorkbook {
             trigger_cells,
             trigger_density,
             coverage,
+            propagate_merges,
         )
     }
 
@@ -792,6 +795,36 @@ impl CalamineWorkbook {
         Ok((fp.frozen_rows, fp.frozen_cols))
     }
 
+    /// Merged cell ranges as absolute 0-based `(start_row, start_col, end_row,
+    /// end_col)`. Cheap (bounded by the merge count, not the cell count) and does
+    /// not materialize a grid — lets a `for_each_band(propagate_merges=True)`
+    /// caller know each merge's anchor so it can carry the anchor's formatted
+    /// value across bands. Empty for non-xlsx workbooks without merges.
+    #[pyo3(name = "get_sheet_merged_ranges")]
+    fn py_get_sheet_merged_ranges(
+        &mut self,
+        py: Python<'_>,
+        name: &str,
+    ) -> PyResult<Vec<(usize, usize, usize, usize)>> {
+        py.detach(|| -> PyResult<Vec<(usize, usize, usize, usize)>> {
+            let ranges = match self.sheets.worksheet_merge_cells(name)? {
+                Some(ranges) => ranges,
+                None => return Ok(Vec::new()),
+            };
+            Ok(ranges
+                .iter()
+                .map(|dim| {
+                    (
+                        dim.start.0 as usize,
+                        dim.start.1 as usize,
+                        dim.end.0 as usize,
+                        dim.end.1 as usize,
+                    )
+                })
+                .collect())
+        })
+    }
+
     /// Compute filled bounds for a sheet entirely in Rust.
     #[pyo3(name = "get_sheet_bounds")]
     fn py_get_sheet_bounds(
@@ -1107,6 +1140,16 @@ impl CalamineWorkbook {
     ///
     /// The callback must not call back into this workbook (its cell reader is
     /// borrowed for the duration); fetch formulas/layout/etc. beforehand.
+    ///
+    /// With `propagate_merges`, a band's merge map keeps every merge that
+    /// intersects it (including children whose anchor is in an earlier band) and
+    /// stores the anchor at its **absolute** coordinate, so each band's
+    /// `is_merged`/`merge_parent`/`coord` are byte-identical to the same row
+    /// range of the dense grid. The merged *value* still propagates only within a
+    /// band here (the anchor's formatted value is not known at stream time); the
+    /// caller carries it across bands. Without the flag, the legacy behavior
+    /// applies: band-local anchors, dropping cross-band merges (matching
+    /// `CellGrid::slice_copy`).
     fn for_each_band(
         &mut self,
         py: Python<'_>,
@@ -1117,6 +1160,7 @@ impl CalamineWorkbook {
         trigger_cells: usize,
         trigger_density: f64,
         coverage: f64,
+        propagate_merges: bool,
     ) -> PyResult<(usize, usize, u64)> {
         if band_rows == 0 {
             return Err(PyValueError::new_err("band_rows must be >= 1"));
@@ -1151,7 +1195,8 @@ impl CalamineWorkbook {
             }
         }
 
-        let mut acc = BandAccumulator::new(rows, cols, band_rows, include_styles, merges);
+        let mut acc =
+            BandAccumulator::new(rows, cols, band_rows, include_styles, merges, propagate_merges);
         let mut cb_err: Option<PyErr> = None;
         self.sheets.for_each_cell(name, |(r, c), dref, style| {
             if cb_err.is_some() {
@@ -1353,6 +1398,9 @@ struct BandAccumulator {
     include_styles: bool,
     /// Merged ranges clipped to the trimmed bounds, absolute 0-based (sr, sc, er, ec).
     merges: Vec<(usize, usize, usize, usize)>,
+    /// Keep cross-band merges with absolute anchors (dense-slice parity) instead
+    /// of the legacy band-local + drop-cross-band behavior.
+    propagate_merges: bool,
     /// Absolute first row of the in-progress band.
     top: usize,
     raw: Vec<RawValue>,
@@ -1367,6 +1415,7 @@ impl BandAccumulator {
         band_rows: usize,
         include_styles: bool,
         merges: Vec<(usize, usize, usize, usize)>,
+        propagate_merges: bool,
     ) -> Self {
         let h = band_rows.min(rows);
         BandAccumulator {
@@ -1375,6 +1424,7 @@ impl BandAccumulator {
             cols,
             include_styles,
             merges,
+            propagate_merges,
             top: 0,
             raw: vec![RawValue::Empty; h * cols],
             styles: if include_styles {
@@ -1463,20 +1513,40 @@ impl BandAccumulator {
         Ok(())
     }
 
-    /// Band-local merge map: ranges intersected with this band, remapped to
-    /// band-local coords. Cross-band merges (parent above the band) are dropped,
-    /// matching `CellGrid::slice_copy`.
+    /// Merge map for the in-progress band. Keys are band-local; values are the
+    /// merge anchor's coordinate.
+    ///
+    /// With `propagate_merges`, every merge that intersects the band is kept and
+    /// the anchor is stored at its **absolute** coordinate — even when the anchor
+    /// lies in an earlier band — so `is_merged`/`merge_parent` match a dense slice
+    /// of the same rows (whose anchors are likewise absolute and may point above
+    /// the slice). Otherwise the legacy behavior applies: the anchor is remapped
+    /// band-local and merges anchored above the band are dropped, matching
+    /// `CellGrid::slice_copy`.
     fn band_merge_map(&self, h: usize) -> HashMap<(usize, usize), (i32, i32)> {
         let mut merge_map = HashMap::new();
+        let band_bottom = self.top + h - 1;
         for &(sr, sc, er, ec) in &self.merges {
-            let parent_r = sr as i32 - self.top as i32;
-            let parent_c = sc as i32;
-            if parent_r < 0 || parent_r as usize >= h || parent_c as usize >= self.cols {
-                continue;
-            }
-            for r in sr.max(self.top)..=er.min(self.top + h - 1) {
-                for c in sc..=ec {
-                    merge_map.insert((r - self.top, c), (parent_r, parent_c));
+            if self.propagate_merges {
+                if er < self.top || sr > band_bottom || sc >= self.cols {
+                    continue;
+                }
+                let anchor = (sr as i32, sc as i32);
+                for r in sr.max(self.top)..=er.min(band_bottom) {
+                    for c in sc..=ec.min(self.cols - 1) {
+                        merge_map.insert((r - self.top, c), anchor);
+                    }
+                }
+            } else {
+                let parent_r = sr as i32 - self.top as i32;
+                let parent_c = sc as i32;
+                if parent_r < 0 || parent_r as usize >= h || parent_c as usize >= self.cols {
+                    continue;
+                }
+                for r in sr.max(self.top)..=er.min(band_bottom) {
+                    for c in sc..=ec {
+                        merge_map.insert((r - self.top, c), (parent_r, parent_c));
+                    }
                 }
             }
         }

{python_calamine_reducto-0.7.14 → python_calamine_reducto-0.7.15}/tests/test_band.py

@@ -32,10 +32,14 @@ def _xml_escape(v: str) -> str:
     return v.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
 
 
-def _make_xlsx(rows_in_order: list[tuple[int, list[tuple[int, object]]]]) -> str:
+def _make_xlsx(
+    rows_in_order: list[tuple[int, list[tuple[int, object]]]],
+    merges: list[str] | None = None,
+) -> str:
     """Write a minimal single-sheet xlsx (stdlib only — no openpyxl) and return
     its path. `rows_in_order` is [(row_1based, [(col_1based, value), ...]), ...]
-    emitted in the given order, so callers can produce out-of-order rows."""
+    emitted in the given order, so callers can produce out-of-order rows.
+    `merges` is an optional list of A1-style ranges (e.g. "A2:A5")."""
     cells_xml = []
     for r, cols in rows_in_order:
         cs = []
@@ -48,10 +52,14 @@ def _make_xlsx(rows_in_order: list[tuple[int, list[tuple[int, object]]]]) -> str
             else:
                 cs.append(f'<c r="{ref}"><v>{value}</v></c>')
         cells_xml.append(f'<row r="{r}">{"".join(cs)}</row>')
+    merge_xml = ""
+    if merges:
+        refs = "".join(f'<mergeCell ref="{m}"/>' for m in merges)
+        merge_xml = f'<mergeCells count="{len(merges)}">{refs}</mergeCells>'
     sheet = (
         '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
         '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">'
-        f'<sheetData>{"".join(cells_xml)}</sheetData></worksheet>'
+        f'<sheetData>{"".join(cells_xml)}</sheetData>{merge_xml}</worksheet>'
     )
     content_types = (
         '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'
@@ -175,6 +183,81 @@ def test_band_merges_match_dense_within_band() -> None:
             assert list(band[r, c]["merge_parent"]) == list(dense[r, c]["merge_parent"])
 
 
+def _make_cross_band_merge_xlsx() -> str:
+    """6×4 sheet with two merges that both straddle a band boundary for any band
+    height < 4: a single-column vertical merge A2:A5 (anchor in row 2) and a
+    multi-column block merge C2:D4 (anchor in row 2, exercising the column loop)."""
+    return _make_xlsx(
+        [
+            (1, [(1, "h1"), (2, "h2"), (3, "h3"), (4, "h4")]),
+            (2, [(1, "Vert"), (3, "Block")]),
+            (3, [(2, "x3")]),
+            (4, [(2, "x4")]),
+            (5, [(2, "x5")]),
+            (6, [(1, "tail"), (2, "x6")]),
+        ],
+        merges=["A2:A5", "C2:D4"],
+    )
+
+
+@pytest.mark.parametrize("band_rows", [1, 2, 3, 4, 6])
+def test_band_merges_match_dense_cross_band(band_rows: int) -> None:
+    """With propagate_merges, a merge spanning a band boundary reproduces the
+    dense is_merged/merge_parent/coord in every band — including children whose
+    anchor lives in an earlier band (the anchor stays at its absolute coord, as
+    in a dense slice of the same rows)."""
+    wb = CalamineWorkbook.from_path(_make_cross_band_merge_xlsx())
+    name = wb.sheet_names[0]
+
+    dense, _, _, _ = wb.get_sheet_grid_streaming(name)
+    rows, cols = dense.shape
+
+    _, bands = _collect_bands(wb, name, band_rows, propagate_merges=True)
+    assert [top for top, _ in bands] == list(range(0, rows, band_rows))
+
+    for top, band in bands:
+        bh, _ = band.shape
+        for br in range(bh):
+            for c in range(cols):
+                assert band[br, c]["is_merged"] == dense[top + br, c]["is_merged"]
+                assert list(band[br, c]["merge_parent"]) == list(
+                    dense[top + br, c]["merge_parent"]
+                )
+                assert list(band[br, c]["coord"]) == [top + br + 1, c + 1]
+
+
+def test_band_merges_legacy_drops_cross_band() -> None:
+    """Without propagate_merges (default), a child whose anchor is in an earlier
+    band is dropped from the merge map — legacy CellGrid::slice_copy parity."""
+    wb = CalamineWorkbook.from_path(_make_cross_band_merge_xlsx())
+    name = wb.sheet_names[0]
+
+    _, bands = _collect_bands(wb, name, 2)
+    # band1 = rows 2–3 (0-based); A3/A4 are merge children whose anchor (row 1)
+    # is in band0, so the legacy path drops them.
+    top1, band1 = bands[1]
+    assert top1 == 2
+    assert not band1[0, 0]["is_merged"]
+    assert not band1[1, 0]["is_merged"]
+
+
+def test_merged_ranges_reports_absolute_bounds() -> None:
+    """get_sheet_merged_ranges returns each merge as absolute 0-based
+    (start_row, start_col, end_row, end_col), so a propagate_merges caller can
+    find every anchor without materializing the grid."""
+    wb = CalamineWorkbook.from_path(_make_cross_band_merge_xlsx())
+    name = wb.sheet_names[0]
+    ranges = set(wb.get_sheet_merged_ranges(name))
+    # A2:A5 -> rows 1-4, col 0; C2:D4 -> rows 1-3, cols 2-3.
+    assert ranges == {(1, 0, 4, 0), (1, 2, 3, 3)}
+
+
+def test_merged_ranges_empty_when_no_merges() -> None:
+    wb = CalamineWorkbook.from_path(_make_xlsx([(1, [(1, "a")])]))
+    name = wb.sheet_names[0]
+    assert wb.get_sheet_merged_ranges(name) == []
+
+
 def test_filled_count_matches_dense_grid() -> None:
     """get_sheet_filled_count reports the non-empty cell count + filled bounds
     without materializing a grid, so callers can route on it up front."""