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

{python_calamine_reducto-0.7.17 → python_calamine_reducto-0.7.19}/.github/workflows/CI.yml

@@ -53,10 +53,54 @@ jobs:
 
       - run: pytest
 
+  lint:
+    name: rust lint and unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: configure git for private deps
+        run: git config --global url."https://x-access-token:${{ secrets.GH_PAT }}@github.com/".insteadOf "https://github.com/"
+
+      - name: install rust stable
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable
+          components: clippy, rustfmt
+
+      - name: cache rust
+        uses: Swatinem/rust-cache@v2
+        with:
+          key: v3
+
+      - name: set up python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+
+      - run: cargo fmt --check
+
+      - run: cargo clippy --all-targets -- -D warnings
+        env:
+          CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+
+      - run: cargo test
+        env:
+          CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+
+      - run: pip install numpy "mypy~=1.19.0"
+
+      - run: pip install -e .
+        env:
+          CARGO_NET_GIT_FETCH_WITH_CLI: "true"
+
+      - name: stubtest
+        run: python -m mypy.stubtest python_calamine
+
   # https://github.com/marketplace/actions/alls-green#why used for branch protection checks
   check:
     if: always()
-    needs: [test]
+    needs: [test, lint]
     runs-on: ubuntu-latest
     steps:
       - name: Decide whether the needed jobs succeeded or failed

{python_calamine_reducto-0.7.17 → python_calamine_reducto-0.7.19}/CLAUDE.md

@@ -100,13 +100,14 @@ python tests/create_test_fixture.py
 
 | Path | What |
 |------|------|
-| `src/types/grid.rs` | CellGrid, CellProxy, CellGridView — the core Reducto addition (~1500 lines) |
-| `src/types/workbook.rs` | get_sheet_grid, get_sheet_styles, get_sheet_layout, get_sheet_bounds |
+| `src/types/grid.rs` | CellGrid, CellProxy — the core Reducto addition |
+| `src/types/workbook.rs` | CalamineWorkbook: grid builders, bounds, layout, formulas |
 | `src/types/mod.rs` | Module exports |
 | `src/lib.rs` | PyO3 module registration |
 | `python/python_calamine/__init__.py` | Python re-exports |
 | `Cargo.toml` | Points calamine + ssfmt deps to reductoai forks |
-| `tests/test_grid.py` | 86 tests for all CellGrid APIs |
+| `tests/test_grid.py` | CellGrid API tests |
+| `tests/test_bounded_reads.py` | Reads whose cost must follow the filled cells |
 
 ## Architecture
 

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

@@ -80,7 +80,7 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 [[package]]
 name = "calamine"
 version = "0.32.0"
-source = "git+https://github.com/reductoai/calamine.git?branch=main#9e6866a552b5baa5b9f2270049eeb72846c4386e"
+source = "git+https://github.com/reductoai/calamine.git?branch=main#297ee32c41c7449e22f9fb94e93c0291b0b4d15d"
 dependencies = [
  "atoi_simd",
  "byteorder",
@@ -612,7 +612,7 @@ dependencies = [
 
 [[package]]
 name = "python-calamine-reducto"
-version = "0.7.17"
+version = "0.7.19"
 dependencies = [
  "calamine",
  "chrono",

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

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

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

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

{python_calamine_reducto-0.7.17 → python_calamine_reducto-0.7.19}/README.md

@@ -15,43 +15,40 @@ Our additions live on `main`.
 
 ## What we added
 
-### Style & layout bindings (`workbook.rs`)
-
-- **`get_sheet_styles(name)`** → list of `(row, col, style_dict)` tuples
-  - Font: bold, italic, size, color, name, underline, strikethrough
-  - Fill: pattern, fg_color, bg_color
-  - Borders: top, bottom, left, right styles
-  - Number format string
+### Workbook bindings (`workbook.rs`)
+
+- **`get_sheet_bounds(name)`** → `(max_filled_row, max_filled_col)`. xlsx streams the cells.
+- **`get_sheet_grid_streaming(name, include_styles=True, ...)`** →
+  `(grid, declared_rows, declared_cols, dropped_cells)`. Streams xlsx cells with no dense
+  range and trims sparse outlier cells.
+- **`for_each_band(name, band_rows, callback, ...)`** → streams the sheet as row bands.
+- **`get_sheet_grid(name, rows, cols, include_styles=True)`** → `CellGrid` from the dense range.
 - **`get_sheet_layout(name)`** → dict with row heights, column widths, defaults
-- **`get_sheet_bounds(name)`** → `(max_filled_row, max_filled_col)` computed in Rust
-- **`get_sheet_grid(name, rows, cols, include_styles=True)`** → `CellGrid`
-  (builds entire grid in a single Rust call)
+- **`get_sheet_formulas`**, **`get_sheet_merged_ranges`**, **`get_sheet_images`**,
+  **`get_sheet_data_validations`**, **`get_sheet_freeze_panes`**,
+  **`get_sheet_filled_count`**, **`get_sheet_uncached_formula_count`**,
+  **`get_all_tables_metadata`**
 
 ### CellGrid (`grid.rs`) — Rust-backed 2D grid
 
-Replaces numpy structured arrays. All cell data stays in Rust Vecs and only
-crosses to Python on demand.
+All cell data stays in Rust. The API converts a grid to a numpy structured array once,
+with `fill_numpy_array`.
 
 **Types:**
-- `CellGrid` — the main 2D grid (values, styles, merges, header, colors, formulas)
-- `CellProxy` — lightweight single-cell accessor (supports `cell.value` and `cell["value"]`)
-- `CellGridView` — zero-copy sub-grid view for slicing
+- `CellGrid` — the main 2D grid (values, styles, merges, header, colors, formulas).
+  Styles and color names are stored as indexes into small palettes.
+- `CellProxy` — single-cell accessor (`cell["value"]`)
 
 **Access patterns:**
 - `grid[r, c]` → `CellProxy`
-- `grid[r1:r2, c1:c2]` → `CellGridView`
 - `grid["field_name"]` → numpy 2D array of that field
 - `grid["field_name"] = value` → broadcast or copy from numpy
-
-**Grid operations:**
-- `vstack(other)` / `hstack(other)` — concatenation
-- `slice_copy(r1, r2, c1, c2)` — independent copy of region
-- `copy()` — deep copy
 - `CellGrid.empty(rows, cols)` — create empty grid
-- `masked_copy_from(source, mask, ...)` — boolean mask copy
 
 **Formatting:**
-- `apply_formatting(callback)` — calls Python SSF per cell
+- `apply_formatting_rust()` — SSF number formats in Rust
+- `apply_dateutil_reformat(date_parse)`, `apply_color_names(converter)`,
+  `propagate_merged_values()`
 - `apply_raw_as_formatted()` — `str(raw)` for large sheets
 
 ### Performance
@@ -88,8 +85,8 @@ git merge upstream/master
 
 | File | What |
 |------|------|
-| `src/types/grid.rs` | CellGrid, CellProxy, CellGridView |
-| `src/types/workbook.rs` | get_sheet_grid, get_sheet_styles, get_sheet_layout |
+| `src/types/grid.rs` | CellGrid, CellProxy |
+| `src/types/workbook.rs` | CalamineWorkbook: grid builders, bounds, layout, formulas |
 | `src/types/sheet.rs` | CalamineSheet, CalamineCellIterator |
 | `src/types/cell.rs` | CellValue enum → Python type conversion |
 | `src/lib.rs` | PyO3 module registration |

{python_calamine_reducto-0.7.17 → python_calamine_reducto-0.7.19}/python/python_calamine/__init__.py

@@ -4,7 +4,6 @@ from ._python_calamine import (
     CalamineTable,
     CalamineWorkbook,
     CellGrid,
-    CellGridView,
     CellProxy,
     PasswordError,
     SheetMetadata,
@@ -26,7 +25,6 @@ __all__ = (
     "CalamineTable",
     "CalamineWorkbook",
     "CellGrid",
-    "CellGridView",
     "CellProxy",
     "PasswordError",
     "SheetMetadata",

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

@@ -6,6 +6,10 @@ import enum
 import os
 import types
 import typing
+from collections.abc import Callable
+
+import numpy as np
+import numpy.typing as npt
 
 @typing.type_check_only
 class ReadBuffer(typing.Protocol):
@@ -174,6 +178,100 @@ class CalamineTable:
     ]:
         """Returning data from table as list of lists."""
 
+@typing.type_check_only
+class TableMetadata(typing.TypedDict):
+    name: str
+    sheet: str
+    columns: list[str]
+    start: tuple[int, int]
+    """First data row and column, 0-based (the header row is above it)."""
+    end: tuple[int, int]
+
+@typing.type_check_only
+class SheetLayout(typing.TypedDict):
+    column_widths: list[tuple[int, float, bool]]
+    """`(col, width, hidden)` for each column with a `<col>` entry."""
+    row_heights: list[tuple[int, float, bool]]
+    """`(row, height, hidden)` for each row with a custom height or flag."""
+    default_column_width: float | None
+    default_row_height: float | None
+
+@typing.type_check_only
+class DataValidation(typing.TypedDict):
+    type: str
+    sqref: str
+    formula1: str | None
+    formula2: str | None
+    allow_blank: bool
+
+@typing.final
+class CellProxy:
+    """One cell of a `CellGrid`. Read a field with `cell["value"]`."""
+
+    def __getitem__(self, key: str, /) -> typing.Any: ...
+
+@typing.final
+class CellGrid:
+    """A sheet grid held in Rust. The API converts it to numpy with `fill_numpy_array`."""
+
+    @property
+    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`."""
+
+    def __len__(self) -> int: ...
+    @classmethod
+    def empty(cls, rows: int, cols: int) -> CellGrid:
+        """An empty grid whose `merge_parent` is `(-1, -1)` for every cell."""
+
+    @typing.overload
+    def __getitem__(self, key: str, /) -> npt.NDArray[typing.Any]:
+        """The numpy array of one field, e.g. `grid["value"]`."""
+
+    @typing.overload
+    def __getitem__(self, key: tuple[int, int], /) -> CellProxy: ...
+    def __setitem__(
+        self,
+        key: typing.Literal["table_member", "header", "value"],
+        value: bool | npt.NDArray[np.bool_] | None,
+        /,
+    ) -> None: ...
+    def set_cell_formula(self, row: int, col: int, formula: str) -> None: ...
+    def set_cell_value(self, row: int, col: int, value: str) -> None: ...
+    def set_field_range(
+        self,
+        field: typing.Literal["table_member", "header"],
+        r1: int,
+        r2: int,
+        c1: int,
+        c2: int,
+        value: bool,
+    ) -> None: ...
+    def apply_formatting_rust(self) -> None:
+        """Format each value with its number format (SSF, in Rust)."""
+
+    def apply_dateutil_reformat(self, date_parse: Callable[[str], float | None]) -> None:
+        """Reformat text cells that have a date format. `date_parse` gives a date serial."""
+
+    def apply_raw_as_formatted(self) -> None: ...
+    def apply_color_names(self, converter: Callable[[str], str | None]) -> None:
+        """Set `cell_textcolor` and `cell_highlight` from the hex colors of each style."""
+
+    def propagate_merged_values(self) -> None: ...
+    def fill_numpy_array(self, arr: npt.NDArray[np.void]) -> None:
+        """Move every field into `arr`. The grid is empty after this call."""
+
 @typing.final
 class CalamineWorkbook:
     path: str | None
@@ -276,6 +374,72 @@ class CalamineWorkbook:
             TableNotFound: If table not found in workbook.
         """
 
+    def get_all_tables_metadata(self) -> list[TableMetadata]: ...
+    def get_sheet_layout(self, name: str) -> SheetLayout: ...
+    def get_sheet_grid(
+        self,
+        name: str,
+        max_filled_row: int,
+        max_filled_col: int,
+        include_styles: bool = True,
+    ) -> CellGrid:
+        """Build a grid from the dense range. Bounds of 0 compute them from the data."""
+
+    def get_sheet_grid_streaming(
+        self,
+        name: str,
+        include_styles: bool = True,
+        trigger_cells: int = 2_000_000,
+        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]:
+        """`(filled, max_filled_row, max_filled_col)` in one streaming pass. xlsx only."""
+
+    def get_sheet_uncached_formula_count(self, name: str) -> int | None: ...
+    def for_each_band(
+        self,
+        name: str,
+        band_rows: int,
+        callback: Callable[[CellGrid, int], object],
+        include_styles: bool = True,
+        trigger_cells: int = 2_000_000,
+        trigger_density: float = 0.001,
+        coverage: float = 0.999,
+        propagate_merges: bool = False,
+        trim_header_only: bool = False,
+    ) -> tuple[int, int, int]:
+        """Stream the sheet as row bands. Returns `(declared_rows, declared_cols, dropped_cells)`."""
+
+    def get_sheet_formulas(self, name: str) -> list[tuple[int, int, str]]:
+        """`(row, col, formula)` for each formula cell. Each formula starts with `=`."""
+
+    def get_sheet_images(self, name: str) -> list[tuple[bytes, str, int, int]]:
+        """`(data, extension, anchor_row, anchor_col)` for each image."""
+
+    def get_sheet_data_validations(self, name: str) -> list[DataValidation]: ...
+    def get_sheet_freeze_panes(self, name: str) -> tuple[int, int]:
+        """`(frozen_rows, frozen_cols)`."""
+
+    def get_sheet_merged_ranges(self, name: str) -> list[tuple[int, int, int, int]]:
+        """`(start_row, start_col, end_row, end_col)`, 0-based and inclusive."""
+
+    def get_sheet_bounds(self, name: str) -> tuple[int, int]:
+        """`(max_filled_row, max_filled_col)`, 1-based and exclusive.
+
+        xlsx does not count `""` cells, as `get_sheet_grid_streaming`. Other formats count them.
+        """
+
 class CalamineError(Exception): ...
 class PasswordError(CalamineError): ...
 class WorksheetNotFound(CalamineError): ...
@@ -301,6 +465,8 @@ __all__ = [
     "CalamineSheet",
     "CalamineTable",
     "CalamineWorkbook",
+    "CellGrid",
+    "CellProxy",
     "PasswordError",
     "SheetMetadata",
     "SheetTypeEnum",

{python_calamine_reducto-0.7.17 → python_calamine_reducto-0.7.19}/src/lib.rs

@@ -2,10 +2,9 @@ use pyo3::prelude::*;
 
 mod types;
 use crate::types::{
-    CalamineError, CalamineSheet, CalamineTable, CalamineWorkbook, CellGrid, CellGridIterator,
-    CellGridView, CellProxy, CellValue, Error, PasswordError, SheetMetadata, SheetTypeEnum,
-    SheetVisibleEnum, TableNotFound, TablesNotLoaded, TablesNotSupported, WorkbookClosed,
-    WorksheetNotFound, XmlError, ZipError,
+    CalamineError, CalamineSheet, CalamineTable, CalamineWorkbook, CellGrid, CellProxy, CellValue,
+    Error, PasswordError, SheetMetadata, SheetTypeEnum, SheetVisibleEnum, TableNotFound,
+    TablesNotLoaded, TablesNotSupported, WorkbookClosed, WorksheetNotFound, XmlError, ZipError,
 };
 
 #[pyfunction]
@@ -29,8 +28,6 @@ fn _python_calamine(py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<CalamineTable>()?;
     m.add_class::<CellGrid>()?;
     m.add_class::<CellProxy>()?;
-    m.add_class::<CellGridView>()?;
-    m.add_class::<CellGridIterator>()?;
     m.add("CalamineError", py.get_type::<CalamineError>())?;
     m.add("PasswordError", py.get_type::<PasswordError>())?;
     m.add("WorksheetNotFound", py.get_type::<WorksheetNotFound>())?;

{python_calamine_reducto-0.7.17 → python_calamine_reducto-0.7.19}/src/types/errors.rs

@@ -20,6 +20,24 @@ create_exception!(python_calamine, TablesNotSupported, CalamineError);
 create_exception!(python_calamine, TablesNotLoaded, CalamineError);
 create_exception!(python_calamine, TableNotFound, CalamineError);
 
+impl From<CalamineCrateError> for Error {
+    fn from(err: CalamineCrateError) -> Self {
+        Error::Calamine(err)
+    }
+}
+
+impl From<XlsxError> for Error {
+    fn from(err: XlsxError) -> Self {
+        Error::Calamine(err.into())
+    }
+}
+
+impl From<XlsbError> for Error {
+    fn from(err: XlsbError) -> Self {
+        Error::Calamine(err.into())
+    }
+}
+
 impl From<Error> for PyErr {
     fn from(val: Error) -> Self {
         match val {
@@ -52,6 +70,7 @@ impl From<Error> for PyErr {
                     XlsxError::XmlEof(error) => XmlError::new_err(error.to_string()),
                     XlsxError::Password => PasswordError::new_err(err.to_string()),
                     XlsxError::TableNotFound(error) => TableNotFound::new_err(error.to_string()),
+                    XlsxError::TablesNotLoaded => TablesNotLoaded::new_err(err.to_string()),
                     XlsxError::WorksheetNotFound(error) => {
                         WorksheetNotFound::new_err(error.to_string())
                     }
@@ -63,6 +82,8 @@ impl From<Error> for PyErr {
                     XlsbError::Xml(error) => XmlError::new_err(error.to_string()),
                     XlsbError::XmlAttr(error) => XmlError::new_err(error.to_string()),
                     XlsbError::Password => PasswordError::new_err(err.to_string()),
+                    XlsbError::TableNotFound(error) => TableNotFound::new_err(error.to_string()),
+                    XlsbError::TablesNotLoaded => TablesNotLoaded::new_err(err.to_string()),
                     XlsbError::WorksheetNotFound(error) => {
                         WorksheetNotFound::new_err(error.to_string())
                     }