python-calamine-reducto 0.7.18__tar.gz → 0.7.19__tar.gz

{python_calamine_reducto-0.7.18 → python_calamine_reducto-0.7.19}/Cargo.lock

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

{python_calamine_reducto-0.7.18 → python_calamine_reducto-0.7.19}/Cargo.toml

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

{python_calamine_reducto-0.7.18 → python_calamine_reducto-0.7.19}/PKG-INFO

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

{python_calamine_reducto-0.7.18 → python_calamine_reducto-0.7.19}/python/python_calamine/_python_calamine.pyi

@@ -218,6 +218,14 @@ class CellGrid:
     def shape(self) -> tuple[int, int]: ...
     @property
     def size(self) -> int: ...
+    @property
+    def row_coords(self) -> npt.NDArray[np.int32]:
+        """Grid row -> 0-based sheet row: `arange` plus the band top, unless gap compression engaged."""
+
+    @property
+    def col_coords(self) -> npt.NDArray[np.int32]:
+        """Grid column -> 0-based sheet column."""
+
     @property
     def uncached_formula_count(self) -> int | None:
         """Formula cells with no cached value (streaming xlsx grids), else `None`."""
@@ -385,10 +393,14 @@ class CalamineWorkbook:
         trigger_density: float = 0.001,
         coverage: float = 0.999,
         trim_header_only: bool = False,
+        max_empty_run: int | None = None,
     ) -> tuple[CellGrid, int, int, int]:
         """Stream a grid. Returns `(grid, declared_rows, declared_cols, dropped_cells)`.
 
         `trim_header_only` also drops the trailing columns whose only value is in the header row.
+        `max_empty_run` keeps at most that many rows (and columns) of each empty run inside the
+        trimmed bounds. It engages only above `trigger_cells`, and only when it halves the grid.
+        `coord` and `merge_parent` stay in sheet positions; `row_coords`/`col_coords` map them.
         """
 
     def get_sheet_filled_count(self, name: str) -> tuple[int, int, int]:

{python_calamine_reducto-0.7.18 → python_calamine_reducto-0.7.19}/src/types/grid.rs

@@ -185,7 +185,8 @@ pub struct CellGrid {
     // Styles (None when styling skipped for large sheets)
     pub(crate) styles: Option<CellStyles>,
 
-    // Merge map: (row, col) -> (parent_row, parent_col), absolute 0-based
+    // Merge map: (row, col) -> (parent_row, parent_col), both grid indexes. An anchor
+    // above the grid (a band) is negative. `anchor_position` maps it for `merge_parent`.
     pub(crate) merge_map: HashMap<(usize, usize), (i32, i32)>,
 
     // Mutable boolean fields
@@ -211,6 +212,14 @@ pub struct CellGrid {
     pub(crate) coord_row_offset: usize,
     pub(crate) coord_col_offset: usize,
 
+    // Added to a merge anchor for `merge_parent` (the band top for `propagate_merges`).
+    pub(crate) anchor_offset: (i32, i32),
+
+    // Gap compression: grid row/col -> 0-based sheet row/col, ascending. When set,
+    // `coord` and `merge_parent` use them and the offsets are 0.
+    pub(crate) row_coords: Option<Vec<i32>>,
+    pub(crate) col_coords: Option<Vec<i32>>,
+
     // Formula cells with no cached value in the source sheet. None when unknown
     // (non-xlsx, dense path, or a derived grid).
     pub(crate) uncached_formula_count: Option<u64>,
@@ -259,6 +268,9 @@ impl CellGrid {
             merge_parent_default,
             coord_row_offset: 0,
             coord_col_offset: 0,
+            anchor_offset: (0, 0),
+            row_coords: None,
+            col_coords: None,
             uncached_formula_count: None,
         }
     }
@@ -280,6 +292,38 @@ impl CellGrid {
         row * self.cols + col
     }
 
+    /// The 0-based sheet row of a grid row.
+    #[inline]
+    fn sheet_row(&self, row: usize) -> usize {
+        match &self.row_coords {
+            Some(coords) => coords[row] as usize,
+            None => row + self.coord_row_offset,
+        }
+    }
+
+    /// The 0-based sheet column of a grid column.
+    #[inline]
+    fn sheet_col(&self, col: usize) -> usize {
+        match &self.col_coords {
+            Some(coords) => coords[col] as usize,
+            None => col + self.coord_col_offset,
+        }
+    }
+
+    /// The flat index of a merge anchor, `None` when the anchor is outside the grid.
+    fn anchor_index(&self, pr: i32, pc: i32) -> Option<usize> {
+        let (row, col) = (usize::try_from(pr).ok()?, usize::try_from(pc).ok()?);
+        (row < self.rows && col < self.cols).then(|| self.idx(row, col))
+    }
+
+    /// The `merge_parent` of a merge anchor. A compressed grid keeps every anchor.
+    fn anchor_position(&self, pr: i32, pc: i32) -> (i32, i32) {
+        match (&self.row_coords, &self.col_coords) {
+            (Some(rows), Some(cols)) => (rows[pr as usize], cols[pc as usize]),
+            _ => (pr + self.anchor_offset.0, pc + self.anchor_offset.1),
+        }
+    }
+
     /// `fill_numpy_array` empties the per-cell storage (`header` first). A later
     /// cell access would index an empty `Vec`, so refuse it.
     fn ensure_not_drained(&self) -> PyResult<()> {
@@ -324,7 +368,7 @@ impl CellGrid {
         // Both parent and child cells — openpyxl uses value emptiness, not coordinates.
         match self.merge_map.get(&(row, col)) {
             Some(&(pr, pc)) if matches!(self.raw_values[self.idx(row, col)], RawValue::Empty) => {
-                (pr, pc)
+                self.anchor_position(pr, pc)
             }
             _ => self.merge_parent_default,
         }
@@ -368,8 +412,8 @@ impl CellGrid {
             }
             "coord" => {
                 let arr = [
-                    (row + self.coord_row_offset + 1) as i32,
-                    (col + self.coord_col_offset + 1) as i32,
+                    (self.sheet_row(row) + 1) as i32,
+                    (self.sheet_col(col) + 1) as i32,
                 ];
                 let numpy = py.import("numpy")?;
                 let result = numpy.call_method1("array", (arr.to_vec(), "int32"))?;
@@ -508,15 +552,8 @@ impl CellGrid {
             // For merged cells, use parent's style
             let (row, col) = (idx / self.cols, idx % self.cols);
             let style_idx = match self.merge_map.get(&(row, col)) {
-                Some(&(pr, pc)) if pr >= 0 && pc >= 0 => {
-                    let pidx = pr as usize * self.cols + pc as usize;
-                    if pidx < total {
-                        pidx
-                    } else {
-                        idx
-                    }
-                }
-                _ => idx,
+                Some(&(pr, pc)) => self.anchor_index(pr, pc).unwrap_or(idx),
+                None => idx,
             };
             let id = styles.ids[style_idx];
             let (font, fill) = match names.entry(id) {
@@ -562,26 +599,43 @@ impl CellGrid {
             if r < self.rows && c < self.cols {
                 let idx = r * self.cols + c;
                 if self.raw_values[idx].is_empty() {
-                    data[idx * 2] = pr;
-                    data[idx * 2 + 1] = pc;
+                    (data[idx * 2], data[idx * 2 + 1]) = self.anchor_position(pr, pc);
                 }
             }
         }
         data
     }
 
-    /// `coord` as flat 1-based `(row, col)` pairs, with the coord offsets.
+    /// `coord` as flat 1-based `(row, col)` sheet positions.
     fn coord_pairs(&self) -> Vec<i32> {
+        let col_coords: Vec<i32> = (0..self.cols)
+            .map(|c| (self.sheet_col(c) + 1) as i32)
+            .collect();
         let mut data = Vec::with_capacity(self.rows * self.cols * 2);
         for r in 0..self.rows {
-            for c in 0..self.cols {
-                data.push((r + self.coord_row_offset + 1) as i32);
-                data.push((c + self.coord_col_offset + 1) as i32);
+            let row = (self.sheet_row(r) + 1) as i32;
+            for &col in &col_coords {
+                data.push(row);
+                data.push(col);
             }
         }
         data
     }
 
+    /// 0-based sheet indexes of the grid rows or columns, as a numpy `int32` array:
+    /// a copy of the compressed `coords`, else `offset..offset + n`.
+    fn sheet_coords<'py>(
+        py: Python<'py>,
+        coords: Option<&[i32]>,
+        n: usize,
+        offset: usize,
+    ) -> Bound<'py, PyArray1<i32>> {
+        match coords {
+            Some(coords) => PyArray1::from_slice(py, coords),
+            None => PyArray1::from_iter(py, (offset..offset + n).map(|i| i as i32)),
+        }
+    }
+
     fn font_bolds(&self) -> Vec<bool> {
         match &self.styles {
             Some(styles) => styles
@@ -752,6 +806,29 @@ impl CellGrid {
         self.rows * self.cols
     }
 
+    /// Grid row -> 0-based sheet row: `arange` plus the coord offset (the band top),
+    /// unless gap compression engaged.
+    #[getter]
+    fn row_coords<'py>(&self, py: Python<'py>) -> Bound<'py, PyArray1<i32>> {
+        Self::sheet_coords(
+            py,
+            self.row_coords.as_deref(),
+            self.rows,
+            self.coord_row_offset,
+        )
+    }
+
+    /// Grid column -> 0-based sheet column, like `row_coords`.
+    #[getter]
+    fn col_coords<'py>(&self, py: Python<'py>) -> Bound<'py, PyArray1<i32>> {
+        Self::sheet_coords(
+            py,
+            self.col_coords.as_deref(),
+            self.cols,
+            self.coord_col_offset,
+        )
+    }
+
     /// Formula cells with no cached value, counted by `get_sheet_grid_streaming`.
     /// `None` when unknown (non-xlsx workbook or a grid from another builder).
     #[getter]
@@ -1110,7 +1187,7 @@ impl CellGrid {
             self.merge_map.iter().map(|(&k, &v)| (k, v)).collect();
         for ((row, col), (pr, pc)) in entries {
             // Skip if this IS the parent
-            if pr == row as i32 && pc == col as i32 {
+            if (pr, pc) == (row as i32, col as i32) {
                 continue;
             }
             let idx = row * self.cols + col;
@@ -1119,9 +1196,8 @@ impl CellGrid {
                 .as_ref()
                 .map(|s| s.is_empty())
                 .unwrap_or(true);
-            if child_empty && pr >= 0 && pc >= 0 {
-                let parent_idx = pr as usize * self.cols + pc as usize;
-                if parent_idx < self.formatted_values.len() {
+            if child_empty {
+                if let Some(parent_idx) = self.anchor_index(pr, pc) {
                     self.formatted_values[idx] = self.formatted_values[parent_idx].clone();
                 }
             }