feat: wolfxl-core + wolfxl-cli 0.4.0 + PyO3 0.28 (Python 3.14 support)

[wolfiesch]

Summary

Lands the Rust-side work for the wolfxl-cli-peek sprint: hybrid Cargo workspace, two new crates ready for crates.io (wolfxl-core, wolfxl-cli), and the PyO3 0.28 bump that unblocks Python 3.14.

• wolfxl-core 0.4.0 - pure-Rust xlsx reader with format-aware cell rendering. No PyO3 coupling. Publishable for third-party Rust consumers.
• wolfxl-cli 0.4.0 - installs the wolfxl binary. wolfxl peek <file> renders a styled box preview by default and text / csv / json exports tuned for piping into agent or shell pipelines (integer thousand-grouping, two-decimal floats, ISO dates, RFC 4180 CSV quoting including embedded \r/\n, stable JSON shape {sheet, rows, columns, headers, data}).
• PyO3 0.24 -> 0.28 - Python 3.14 support. All 611 pytest tests pass on 3.12 and 3.14. Public Python API unchanged.

What's in here

Eight commits since main:

• b9b6a1c refactor: convert wolfxl to hybrid Cargo workspace
• e27d090 feat(core): scaffold wolfxl-core crate for CLI consumption
• c32f181 feat(cli): wolfxl peek styled exports for text/csv/json
• d987410 chore(deps): bump pyo3 0.24 -> 0.28 for Python 3.14 support
• 72910cf merge: pyo3 0.28 bump for Python 3.14 support
• c375367 fix: address Codex pre-publish review findings
• f0f19f2 docs: 0.4.0 CHANGELOG entry + per-crate READMEs
• 894aa79 docs: scrub explicit prior-tool refs from public copy

Pre-publish review

External Codex review (gpt-5.3-codex) flagged five CLI rendering bugs (uppercase True / False instead of lowercase, missing ERROR: prefix on Excel error sentinels, floats not forced to two decimals, CSV not quoting on \r, header row int-grouping leaking into header text) and one currency carry bug in wolfxl-core (format_currency(1.995, 2) returned \"\$1.100\" instead of \"\$2.00\" because trunc() and fract() were rounded separately). All addressed in c375367. Render contract is locked in by 11 golden integration tests + 6 unit tests in crates/wolfxl-cli.

Test plan

• cargo test -p wolfxl-core -p wolfxl-cli - 18 tests pass (7 core + 11 CLI integration + 6 CLI unit on a separate target)
• cargo publish --dry-run -p wolfxl-core - packages cleanly
• cargo publish --dry-run -p wolfxl-cli - fails as expected (depends on unpublished wolfxl-core; resolves once core is on crates.io)
• uv run --with pytest --with openpyxl --with formulas pytest -q on Python 3.14 - 611 passed, 1 skipped

Follow-up (not blocking publish)

• Port xl/styles.xml cellXfs walker into wolfxl-core so number-format detection works on openpyxl-generated files (today they fall back to None).
• Migrate Bound::downcast -> cast (22 deprecation warnings left from PyO3 bump).

🤖 Generated with Claude Code

[Copilot]

Pull request overview

Introduces a Rust Cargo workspace with two new publishable crates (wolfxl-core, wolfxl-cli) and expands the Python-side parity/compatibility surface (including data_only, merged-cell/dimension behavior, and bulk cell_records) alongside the PyO3 0.28 upgrade.

Changes:

• Add wolfxl-core (pure Rust reader + format-aware rendering) and wolfxl-cli (new wolfxl peek CLI with golden tests).
• Add an openpyxl-parity harness + fixture corpus and wire it into CI as a dedicated job.
• Update Python API surface to support data_only, add cell_records/dimension helpers, and bump package/workspace versions to 0.4.0.

Reviewed changes

Copilot reviewed 53 out of 72 changed files in this pull request and generated 6 comments.

Show a summary per file

File	Description
uv.lock	Bumps editable wolfxl version to 0.4.0.
pyproject.toml	Updates Python package version to 0.4.0.
Cargo.toml	Converts repo to workspace; bumps root crate + PyO3 to 0.28.
CHANGELOG.md	Adds 0.4.0 release notes.
README.md	Documents cell_records() API and capability table entry.
docs/api/worksheet.md	Documents iter_cell_records/cell_records + calculate_dimension.
.github/workflows/ci.yml	Adds parity job (pytest on tests/parity/).
src/lib.rs	Adds PyObject alias; minor formatting; module order adjustment.
src/util.rs	Adds PyObject alias.
src/rust_xlsxwriter_backend.rs	Formatting/error-path refactors (no functional intent stated).
python/wolfxl/init.py	Re-exports Cell/Worksheet; wires data_only into workbook open paths; updates docstring.
python/wolfxl/_workbook.py	Plumbs data_only into read/modify mode initialization.
python/wolfxl/_worksheet.py	Adds merged-cells proxy, cell_records APIs, and robust calculate_dimension/dimension reading; passes data_only into Rust reads.
python/wolfxl/_cell.py	Passes data_only into Rust value reads; normalizes date payloads to midnight datetime.
python/wolfxl/utils/init.py	Exposes openpyxl-compatible utils surface.
python/wolfxl/utils/cell.py	Implements openpyxl-shape coordinate/range helpers.
python/wolfxl/utils/datetime.py	Implements openpyxl-compatible from_excel and epochs.
python/wolfxl/utils/numbers.py	Implements openpyxl-compatible is_date_format.
scripts/copy_synthgl_fixtures.py	Adds script to refresh SynthGL snapshot fixtures.
tests/test_wolfxl_compat.py	Adds coverage for cell_records, stale dimensions, data_only, merged-cell format behavior, and date handling.
tests/parity/init.py	Introduces parity harness package marker.
tests/parity/_scoring.py	Adds tiered mismatch scoring + fuzzy equality.
tests/parity/conftest.py	Adds parity fixture discovery (snapshot + optional env var corpus).
tests/parity/KNOWN_GAPS.md	Documents parity gap contract/rollout phases.
tests/parity/openpyxl_surface.py	Defines openpyxl surface contract entries for smoke/parity tests.
tests/parity/ratchet.json	Adds initial soft-tier baseline metadata + per-fixture entries.
tests/parity/test_surface_smoke.py	Adds importability smoke checks for supported/gap symbols.
tests/parity/test_utils_parity.py	Adds bug-for-bug parity tests for openpyxl utility functions.
tests/parity/test_read_parity.py	Adds per-fixture read parity + ratchet enforcement.
tests/parity/test_write_parity.py	Adds oracle-based write roundtrip tests (wolfxl → openpyxl).
tests/parity/fixtures/README.md	Documents fixture corpus layout and refresh process.
tests/parity/fixtures/synthgl_snapshot/aging/customer_ar_aging_buckets.xlsx	Adds committed parity fixture.
tests/parity/fixtures/synthgl_snapshot/aging/holdout_ap_aging_buckets.xlsx	Adds committed parity fixture.
tests/parity/fixtures/synthgl_snapshot/cross_ref/buried_header_entity_rollup.xlsx	Adds committed parity fixture.
tests/parity/fixtures/synthgl_snapshot/key_value/workbook_report_metadata_block.xlsx	Adds committed parity fixture.
tests/parity/fixtures/synthgl_snapshot/rollforward/holdout_fixed_asset_movements.xlsx	Adds committed parity fixture.
tests/parity/fixtures/synthgl_snapshot/stress/headcount_consolidation_looks_like_a5.xlsx	Adds committed parity fixture.
tests/parity/fixtures/synthgl_snapshot/stress/mixed_blank_semantics.xlsx	Adds committed parity fixture.
tests/parity/fixtures/synthgl_snapshot/stress/non_financial_scorecard_looks_like_a4.xlsx	Adds committed parity fixture.
tests/parity/fixtures/synthgl_snapshot/time_series/holdout_quarterly_ops_statement.xlsx	Adds committed parity fixture.
tests/parity/fixtures/synthgl_snapshot/time_series/sec_in_millions_except_per_share.xlsx	Adds committed parity fixture.
crates/wolfxl-core/Cargo.toml	Adds new crate manifest.
crates/wolfxl-core/README.md	Adds crate README.
crates/wolfxl-core/src/lib.rs	Adds crate public API + docs.
crates/wolfxl-core/src/error.rs	Adds crate error types.
crates/wolfxl-core/src/cell.rs	Adds Cell/CellValue model types.
crates/wolfxl-core/src/format.rs	Adds format classification + rendering + tests.
crates/wolfxl-core/src/sheet.rs	Adds sheet loading + value/style extraction.
crates/wolfxl-core/src/workbook.rs	Adds workbook open/sheet access.
crates/wolfxl-core/tests/integration_real_xlsx.rs	Adds optional integration test against sibling repo fixture.
crates/wolfxl-cli/Cargo.toml	Adds new CLI crate manifest + deps.
crates/wolfxl-cli/README.md	Adds CLI usage docs.
crates/wolfxl-cli/src/main.rs	Adds wolfxl CLI entrypoint + peek subcommand parsing.
crates/wolfxl-cli/src/commands/mod.rs	Adds commands module.
crates/wolfxl-cli/src/commands/peek.rs	Implements peek command dispatch + options.
crates/wolfxl-cli/tests/cli.rs	Adds golden-based CLI integration tests.
crates/wolfxl-cli/tests/golden/sample-financials.text	Adds golden output.
crates/wolfxl-cli/tests/golden/sample-financials.csv	Adds golden output.
crates/wolfxl-cli/tests/golden/sample-financials.json	Adds golden output.
crates/wolfxl-cli/tests/golden/wide-table.text	Adds golden output.
crates/wolfxl-cli/tests/golden/wide-table.csv	Adds golden output.
crates/wolfxl-cli/tests/golden/wide-table.json	Adds golden output.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

The workflow runs pytest tests/ on Python 3.9, but this module uses StrEnum (3.11+) and PEP 604 unions (str | None, 3.10+). This will fail to import under 3.9. Either adjust the CI matrix / requires-python to match the minimum supported version, or replace StrEnum/| with 3.9-compatible constructs (e.g. Enum + Optional[...] / Union[...] or a backport).

[wolfiesch]

Fixed in 799e8fb: replaced StrEnum with (str, Enum) mixin (3.9-compatible). PEP 604 unions only appear in annotations, which from __future__ import annotations keeps lazy-evaluated, so they're safe under 3.9 once StrEnum is gone.

[Copilot]

This file uses StrEnum (Python 3.11+) and will fail to import under Python 3.9, but CI runs the test suite on 3.9. Consider switching to Enum (with string values) or gating these parity tests to only run on Python versions that support StrEnum.

[wolfiesch]

Fixed in 799e8fb: switched to (str, Enum) mixin so the import works on Python 3.9. Verified locally with ruff check; CI matrix (3.9 + 3.12) will exercise it.

[Copilot]

_all_xlsx_fixtures dedupes by f"{path.name}:{size}", which can accidentally collapse distinct fixtures that share a filename and size in different directories/categories. That will silently reduce parity coverage. Use a stable relative path (e.g. relative to SNAPSHOT_DIR/root), or include the parent path segments in the dedupe key.

[wolfiesch]

Fixed in 799e8fb: dedupe key is now {relative_path}:{size}, where the relative path is computed against the source root (snapshot dir or live SynthGL dir). Two summary.xlsx files in different snapshot subfolders no longer collapse.

[Copilot]

The SOFT-tier description is inconsistent with the ratchet enforcement in test_read_parity.py, which fails when observed SOFT mismatches are greater than the baseline (i.e. SOFT must not increase). Update this docstring/comment to match the actual contract so future changes don’t invert the intended ratchet behavior.

[wolfiesch]

Fixed in 799e8fb: SOFT docstring now reads "count is tracked in ratchet.json; never allowed to increase over the committed baseline (regressions block CI)." Matches the > check in test_zz_ratchet_soft_failures_nondecreasing.

[Copilot]

excel_serial_to_datetime claims to match Excel/openpyxl’s 1900 leap-year correction, but it currently just adds days to the 1899-12-30 epoch with no adjustment for serials in (0, 60). That will produce off-by-one dates for early-1900 serials. Also, casting a negative days to u64 can wrap and yield incorrect results. Consider implementing the same (0 < serial < 60) adjustment used elsewhere and handle negative serials explicitly.

Suggested change

	let days = serial.trunc() as i64;
	let frac = serial.fract();
	// Excel treats 1900-01-00 as serial 0 and has the famous 1900 leap-year
	// bug; matching openpyxl's correction.
	let base = NaiveDate::from_ymd_opt(1899, 12, 30).expect("static date");
	let date = base
	.checked_add_days(chrono::Days::new(days as u64))
	.unwrap_or(base);
	if frac.abs() < f64::EPSILON {
	return CellValue::Date(date);
	}
	let mut days = serial.floor() as i64;
	let frac = serial - (days as f64);
	// Excel treats 1900-01-00 as serial 0 and has the famous 1900 leap-year
	// bug; matching openpyxl's correction for serials before the fake
	// 1900-02-29 entry.
	if serial > 0.0 && serial < 60.0 {
	days += 1;
	}
	let base = NaiveDate::from_ymd_opt(1899, 12, 30).expect("static date");
	let date = if days >= 0 {
	base.checked_add_days(chrono::Days::new(days as u64))
	} else {
	base.checked_sub_days(chrono::Days::new((-days) as u64))
	}
	.unwrap_or(base);
	if frac.abs() < f64::EPSILON {
	return CellValue::Date(date);
	}

[wolfiesch]

Fixed in 799e8fb: added the openpyxl +1 correction for serials in (0, 60). Serial 1 now maps to 1900-01-01 and serial 59 to 1900-02-28; serial 61 stays 1900-03-01 (skipping the fake serial-60 leap day). Negative serials now use checked_sub_days instead of letting the as u64 cast wrap. New tests excel_serial_matches_openpyxl_for_pre_leap_serials and excel_serial_negative_does_not_wrap lock the boundaries.

[Copilot]

test_ratchet_soft_failures_nondecreasing relies on pytest collecting tests alphabetically, but test_ratchet_... sorts before test_read_parity, so _OBSERVATIONS will still be empty and the ratchet check will always skip. Rename the ratchet test to sort after the read tests (e.g. prefix with zz_) or enforce this check via a session-level hook/fixture finalizer that runs after all parametrized cases.

[wolfiesch]

Fixed in 799e8fb: renamed to test_zz_ratchet_soft_failures_nondecreasing. The zz_ prefix sorts last under any plain alphabetical ordering, so _OBSERVATIONS is populated by the time the ratchet check runs. Robust to pytest-xdist / pytest-randomly reordering without needing a session finalizer.

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: f0f19f2c21

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Honor include_formula_blanks for uncached formulas

read_sheet_records() currently treats any present cell payload as a backing value (value.is_some()), so formula cells whose cached value is just the formula text still count as “backed” and are emitted even when include_formula_blanks=False. This makes the flag ineffective for template-only formulas in the common data_only=False path and returns records callers explicitly asked to suppress.

Useful? React with 👍 / 👎.

[wolfiesch]

Acknowledged - tracked as a follow-up. include_formula_blanks for uncached formulas is a real semantics gap, but it's in the legacy single-crate src/calamine_styled_backend.rs that this PR doesn't touch. The next sprint's wolfxl-core extraction (planned ~0.5.0) will need to either honor the flag at the new Sheet::load boundary or document the divergence. Filing as an issue rather than expanding the diff here.

[wolfiesch]

Tracked as #5 with the acceptance criteria spelled out, so it doesn't get lost when wolfxl-core grows the options surface in 0.5.0.

[chatgpt-codex-connector]

Strip bracketed tags before date-token classification

The date/time heuristic checks raw substrings (contains('d'), etc.) on the full format code, so non-date numeric formats with color tags like #,##0_);[Red](#,##0) are misclassified as Date because of the d in Red. This will mislabel numeric columns in any workflow consuming classify_format output.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 799e8fb: classify_format now strips [...] segments before the date/time substring scan via a new strip_bracketed_tags helper. The currency check still runs on raw fmt to preserve [$-409] detection. Locked in by bracketed_tags_dont_trigger_date_or_time_heuristic covering [Red], [Red]-, and [h]:mm:ss (the legitimate elapsed-hour case still classifies as Time).

[wolfiesch]

@codex review — addressed all 8 review findings in 799e8fb. Summary:

• 6 Copilot findings: StrEnum → (str, Enum) mixin (3.9-compat) in _scoring.py + openpyxl_surface.py; conftest dedupe key now uses relative path (no silent fixture collapse); SOFT docstring corrected to match the ratchet > check; ratchet test renamed test_zz_ for stable post-observation collection order; Excel 1900 leap-year correction (+1 for serials in 0..60) + negative-serial guard in sheet.rs.
• 1 Codex P2: format.rs strips bracketed tags before date/time substring scan via new strip_bracketed_tags helper; currency check still runs raw to keep [$-409] detection.
• 1 Codex P2 deferred + tracked as Honor include_formula_blanks for uncached formulas in wolfxl-core #5 (include_formula_blanks for uncached formulas — lives in legacy backend that this PR doesn't touch; will be addressed at the wolfxl-core options surface in 0.5.0).

CI: 9/9 green (lint, parity, 6× pytest matrix on ubuntu/macos/windows × 3.9/3.12).

[wolfiesch]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 799e8fbf00

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Respect include_formula_blanks for empty formula results

When include_formula_blanks=False, template formulas without cached values should be omitted, but has_formula_backing_entry is currently computed as value.is_some(). Inside a rectangular range, calamine returns Some(Data::Empty) for blank cells, so this flag becomes true and should_emit_formula still emits the formula record. In sheets where uncached formulas sit between populated cells, callers cannot suppress these placeholder formulas even though they explicitly opted out.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 69d0ae7.

Root cause was deeper than described: calamine returns Some(Data::String("")) for the empty <v/> element on a formula cell (not Some(Data::Empty) as suggested), and Some(Data::Empty) only for blanks inside the rectangular bounding box. Both forms are semantically "the formula has no cached result."

Fix hoists value_is_formula_placeholder (using data_is_formula_text) and applies it to both has_value and has_formula_backing_entry, so:

• include_formula_blanks=false actually suppresses the cell (it no longer falls through has_value via the empty string)
• data_only=true still skips it via value_is_uncached_formula

Locked in by a new pytest in tests/test_wolfxl_compat.py::test_cell_records_include_formula_blanks_false_skips_uncached_inside_range that constructs the exact B2 scenario via openpyxl. 506 passed locally.

[chatgpt-codex-connector]

Carry rounded day-fraction overflow before building time

frac * 86_400 is rounded to whole seconds, so fractions very close to 1.0 can become 86400. This path then clamps h with h.min(23) instead of carrying into the next day, producing an incorrect timestamp (for example a near-midnight value can become 23:00:00 on the same date). This creates deterministic off-by-one-day/time errors for valid serials near day boundaries.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 69d0ae7.

Replaced the h.min(23) clamp with a proper day-carry: when (frac * 86_400).round() lands on 86_400 (a full day), advance the date by one and reset secs to 0, so 44197 + 0.99999999 now returns 2021-01-02 00:00:00 instead of 2021-01-01 23:00:00.

Locked in by excel_serial_carries_near_midnight_fraction_to_next_day in crates/wolfxl-core/src/sheet.rs tests, plus a code comment explaining what the prior clamp was doing wrong. All 12 wolfxl-core tests + doctest still pass.

[wolfiesch]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 69d0ae7543

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Include buffered writes in max_row/max_column

The newly exposed max_row/max_column properties delegate to _max_row()/_max_col(), but in write mode those helpers only inspect _cells and ignore _append_buffer/_bulk_writes. As a result, after append() or write_rows() (before materialization/save), these properties under-report sheet size (often staying at 1), which can cause downstream range calculations and iteration bounds to miss newly added data.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 31c4259.

Extracted _pending_writes_bounds() as the single source of truth over _cells + _append_buffer + _bulk_writes, and folded it into _max_row() / _max_col() so write-mode append() and write_rows() are reflected before save. Read-mode path still calls _read_dimensions() (preserving <dimension>-tag parity with openpyxl — discovered during the refactor that routing everything through read_sheet_bounds breaks tests/parity/test_read_parity.py on workbooks where calamine's parsed range is narrower than the XML tag).

Locked in by tests/test_wolfxl_compat.py::test_max_row_max_column_reflect_pending_writes_in_write_mode — two append() calls of widths 3 and 4 expects max_row == 2, max_column == 4.

[chatgpt-codex-connector]

Account for unsaved edits in calculate_dimension

_read_dimension_bounds() returns Rust-reader bounds whenever _rust_reader exists, but modify mode also has _rust_reader while pending edits live in Python-side buffers/cells. This means calculate_dimension() can return stale pre-edit bounds in the same session after users modify cells, so callers that derive ranges from calculate_dimension() may omit unsaved writes.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 31c4259.

_read_dimension_bounds() now unions on-disk Rust bounds with _pending_writes_bounds() instead of short-circuiting to one or the other. So in modify mode, calculate_dimension() reflects the union of <dimension> extents and pending Python-side cell edits / append buffers / bulk writes.

Locked in by tests/test_wolfxl_compat.py::test_calculate_dimension_includes_modify_mode_pending_edits — opens an A1:B2 workbook in modify mode, writes ws['E10'], asserts calculate_dimension() == 'A1:E10'.

[chatgpt-codex-connector]

Handle Excel serial 0 as midnight time

The time-only branch excludes serial == 0 by checking serial > 0.0, so a zero serial falls through to the date path and is returned as 1899-12-30 instead of 00:00:00. For time-formatted cells containing midnight, this produces incorrect values in wolfxl-core (and therefore CLI output built on it).

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 31c4259.

Loosened the time-only branch from serial > 0.0 to serial >= 0.0, so excel_serial_to_datetime(0.0) now returns Time(0, 0, 0) instead of falling through to Date(1899-12-30). Matches openpyxl's from_excel(0) behavior for time-formatted cells.

Locked in by excel_serial_zero_returns_midnight_time in crates/wolfxl-core/src/sheet.rs.

[wolfiesch]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 31c4259ce7

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Handle sub-day serial rounding overflow in time conversion

For serial values in [0, 1), this branch rounds to whole seconds and immediately builds a NaiveTime. Inputs near 1.0 (for example 0.99999999) round to 86400, which makes h == 24, so from_hms_opt fails and the code falls back to CellValue::Float(serial). That silently changes a valid time-like cell into a numeric float instead of a time value, unlike the date+time branch below which already carries >= 86400 seconds safely.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 3667122. The sub-day branch now carries seconds==86_400 down to 0 before calling NaiveTime::from_hms_opt, mirroring the day-fraction carry already present in the date+time branch. Added unit test excel_serial_sub_day_near_midnight_carries_to_zero_time to lock it in. Without the carry, 0.99999999 silently demoted a time-typed cell to CellValue::Float.

[chatgpt-codex-connector]

Avoid stale record reads after unsaved edits in modify mode

This condition routes any worksheet with a Rust reader through the bulk Rust path, which means modify mode (_rust_reader + pending Python-side edits) reads from on-disk data only. As a result, iter_cell_records() / cell_records() can return stale values after in-memory edits (ws['A1']=..., append(), write_rows()) until save() runs, which is inconsistent with the current worksheet state.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 3667122. iter_cell_records now collects a pending overlay (_dirty + _append_buffer + _bulk_writes) and patches Rust-returned records plus yields any pending cells outside the original disk range that fall within the requested bounds. Pure read mode is unchanged - the overlay dict is empty and we skip it. Added test_cell_records_overlays_modify_mode_pending_edits to lock in the modify+overlay behavior.

[wolfiesch]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 3667122670

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Treat uncached formula placeholders as blank in data_only reads

When data_only=True, this branch skips formula handling and falls through to data_to_py, but formula cells without cached results are represented by calamine as placeholder values (e.g. empty string). That makes read_cell_value (and the bulk readers with the same pattern) return a non-blank value instead of the openpyxl-compatible blank/None result for uncached formulas, which can corrupt downstream ingestion in template-heavy sheets. This file already contains explicit placeholder handling in read_sheet_records, so the data-only readers should apply the same normalization.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 383b986. Added a shared is_uncached_formula_value helper and applied it in read_cell_value, read_sheet_values, and read_sheet_values_plain so all three readers normalize calamine's Some(Data::String("")) / Some(Data::Empty) placeholders to blank/None when data_only=true, matching what read_sheet_records already does. Tests test_read_cell_value_data_only_blanks_uncached_formula and test_iter_rows_values_only_blanks_uncached_formulas lock in the per-cell and bulk paths respectively.

[chatgpt-codex-connector]

Preserve canonical data_type labels in overlay records

The overlay path assigns data_type from Python runtime type names (str, int, bool, etc.), while non-overlay records from Rust use the API’s canonical labels (string, number, boolean, ...). In modify mode with pending edits, this produces mixed schemas in a single cell_records() result and breaks consumers that filter/group by the documented canonical tokens.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 383b986. Added _canonical_data_type helper that mirrors Rust's data_type_name closed set (string / number / boolean / date / datetime / blank). Routed both overlay emission paths (patched records and extra-overlay records) plus the python-side fallback iterator through it. Test test_cell_records_overlay_uses_canonical_data_type_labels covers all four primitive types including the bool-before-int subclass check.

[wolfiesch]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 383b986118

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Exclude read-only cached cells from pending bounds

_pending_writes_bounds() treats every entry in _cells as a pending write, but _cells is populated by read access (ws['A1'], non-values_only iteration) even when nothing was modified. Because _max_row, _max_col, and calculate_dimension() now union against this helper, merely touching a far cell can inflate worksheet bounds (for example, reading Z999 makes bounds look like row 999/col 26), which can trigger oversized scans and incorrect range calculations in downstream callers.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 4dea6a7. Switched _pending_writes_bounds to iterate self._dirty (the set of actually-modified cell keys) instead of self._cells (the read cache). Test test_max_row_does_not_inflate_from_read_only_cell_access verifies that reading ws['Z999'].value leaves max_row/max_column/calculate_dimension untouched, then confirms a real assignment grows them as expected.

[chatgpt-codex-connector]

Preserve formula data_type in overlay record patches

Overlay records in iter_cell_records() rely on _canonical_data_type(), which classifies all strings as "string". This mislabels unsaved formula edits (e.g. values starting with =) as plain strings, so pending formula changes lose data_type="formula" semantics compared with Rust-backed records. Any consumer that filters or counts formula records will miss modified-but-unsaved formulas.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 4dea6a7. _canonical_data_type now classifies string values starting with '=' as 'formula' to match openpyxl's convention and Rust's formula_map_cache path. Test test_cell_records_overlay_labels_pending_formulas_as_formula confirms a pending ws['B2'] = '=SUM(A1:A1)' shows up as data_type='formula' in cell_records().

[wolfiesch]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 4dea6a729e

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Recompute formula metadata when overlaying edited records

When cell_records() overlays pending modify-mode edits, it only updates value and data_type on top of the on-disk record. If a user replaces an existing formula cell with a literal (or the reverse), the stale formula field from the original record is left behind, so downstream consumers can see contradictory metadata for the same cell and mis-handle formula detection.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in da9431f. The overlay patch now refreshes the formula field instead of leaving the on-disk text behind: a literal-overwrites-formula edit pops the key, and a formula-overwrites-anything edit sets it from the new value (leading = stripped to match the Rust reader's convention). Lock-in tests test_cell_records_overlay_clears_stale_formula_metadata_on_literal_swap and test_cell_records_overlay_replaces_formula_metadata_on_formula_swap cover both directions.

[chatgpt-codex-connector]

Honor include_coordinate in write-mode cell_records fallback

In write mode (_rust_reader is None), iter_cell_records() forwards only include_empty to the Python fallback and drops include_coordinate, even though the API docs promise include_coordinate=False avoids A1 allocation. This makes write-mode output/schema diverge from read mode and forces unnecessary coordinate generation for large in-memory sheets.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in da9431f. iter_cell_records now forwards include_coordinate to _iter_cell_records_python, and the fallback only sets the coordinate key when requested. Lock-in test test_iter_cell_records_write_mode_honors_include_coordinate constructs a fresh Workbook() (no Rust reader → fallback path) and asserts the key is present/absent as the flag dictates.

[wolfiesch]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: da9431ff39

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Include formula text in overlay-only formula records

When iter_cell_records() overlays pending edits in modify mode, the branch that emits records not returned by Rust only sets row, column, value, and data_type. If a pending edit is a formula string (for example a new "=SUM(...)" in an on-disk empty cell), the emitted record becomes data_type="formula" but has no formula field, unlike formula records from the Rust path. This drops expression metadata for unsaved edits and breaks consumers that read record["formula"] for formula cells.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 5f6cc0c. The extra-overlay branch now emits the formula key alongside data_type='formula' when the pending value is a "=..." string, with the same leading-= strip applied for Rust-style consistency. Lock-in test test_cell_records_extra_overlay_emits_formula_field_for_pending_formula writes a formula into a previously empty cell (so the Rust reader returns no record for it) and asserts the resulting overlay record has both data_type='formula' and the expected formula field.

[chatgpt-codex-connector]

Prevent pending bounds from producing column index 0

_pending_writes_bounds() computes appended-row width with max(len(row) for row in buf). If buffered appends include an empty row (e.g. append([])), this yields 0, which can propagate to _max_col()==0; downstream 1-based coordinate helpers (like rowcol_to_a1 via dimension/reporting paths) then see an invalid column index. Clamp this width to at least 1 (or ignore zero-width rows) so pending bounds never generate column 0.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 5f6cc0c. _pending_writes_bounds() now uses max((len(row) for row in buf), default=0) and only contributes to the column-bounds branch when the width is >0. The same guard is applied to the bulk-write branch. An empty appended row still consumes a row index (so max_r grows) but leaves max_c alone, so _max_col() can never collapse to 0 from a zero-width append. Lock-in test test_pending_writes_bounds_skips_zero_width_appended_rows invokes ws.append([]) and asserts calculate_dimension() doesn't leak A0 into the result.

[wolfiesch]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 5f6cc0c123

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Align overlay date labels with Rust record schema

iter_cell_records() overlays pending Python edits using _canonical_data_type(), which maps datetime.date to "date", but the Rust read_sheet_records() path emits temporal cells as "datetime" (via data_type_name). In modify mode, editing a date cell can therefore produce mixed data_type tokens in one result set, which breaks consumers that group/filter on the documented canonical labels. Either map Python date to "datetime" here or make the Rust path emit "date" consistently.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 5d5fd84. _canonical_data_type now collapses all temporal types (datetime / date / time) to "datetime" to match Rust's data_type_name(), which emits a single "datetime" label for both Data::DateTime and Data::DateTimeIso. Updated the docstring to drop the now-absent "date" token. Lock-in test test_canonical_data_type_collapses_temporals_to_datetime asserts all three branches return "datetime".

[chatgpt-codex-connector]

Handle negative fractional Excel serials without u32 wrap

For negative serials with fractional parts (for example -0.5), secs is computed as (frac * 86_400.0).round() as u32, and casting a negative value to u32 wraps to a huge positive number. The downstream carry logic then yields incorrect date/time results instead of a valid pre-epoch datetime, so pre-1900 timestamp cells can be corrupted. Keep this arithmetic signed until normalization (borrow/carry) is finished.

Useful? React with 👍 / 👎.

[wolfiesch]

Fixed in 5d5fd84. The day-fraction arithmetic now uses signed i64; when secs_signed < 0 we borrow whole days off days (mirroring the existing >= 86_400 carry), then cast to u32 only after the value lands in [0, 86_400). Pulled days → NaiveDate into a days_to_date_from_excel_base helper since the borrow runs before date materialization now. Lock-in test excel_serial_negative_fractional_borrows_into_prior_day checks serial -0.5 lands on 1899-12-29 12:00:00.

[wolfiesch]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 5d5fd844d5

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

[chatgpt-codex-connector]

Offset cell iteration by the range origin

worksheet_range() can return a range whose origin is not (0, 0) (for example when the first populated cell is C5). This loop indexes value_range and style_range with raw 0..h / 0..w coordinates, but Range::get expects absolute sheet coordinates, so non-A1 sheets are read as blank or misaligned and their formats are attached to the wrong cells. Add the range start offsets when computing (row, col) before calling get.

Useful? React with 👍 / 👎.

[wolfiesch]

Thanks for flagging - I dug into the calamine-styles source before changing this. The claim that Range::get expects absolute coordinates is reversed: it's get_value that takes absolute coords; get takes relative ones. From calamine-styles 0.1.0/src/lib.rs:

// line 1099
pub fn get_value(&self, absolute_position: (u32, u32)) -> Option<&T> { ... }

// line 1140
pub fn get(&self, relative_position: (usize, usize)) -> Option<&T> {
    let (row, col) = relative_position;
    let width = self.width();
    if row >= self.height() || col >= width { None }
    else { self.inner.get(row * width + col) }
}

So value_range.get((r, c)) with r, c ∈ 0..h × 0..w (where (h, w) = value_range.get_size()) reads every cell in the range correctly, regardless of whether the range starts at A1 or C5. Cells are not "blank or misaligned" and number formats are attached to the right cells inside the range.

There is a legitimate but distinct concern in the neighborhood: Sheet's internal Vec<Vec<Cell>> doesn't preserve the absolute origin of the range, so sheet.rows()[0][0] represents the first populated cell rather than literal A1. The current public API (headers, rows, row, dimensions) exposes no absolute coordinates and the only consumer (crates/wolfxl-cli/src/render.rs) renders the populated block as a tabular preview — which matches xleak's behavior on non-A1 sheets — so v0.4.0 peek output is unaffected.

Tracking the absolute-origin work as a follow-up rather than blocking this PR: when we add --map / --cell A1 / citation features in sprint 2, Sheet will need a (start_row, start_col) field plus absolute-position accessors. Filing a follow-up issue now.

[wolfiesch]

Filed as #6 - Sheet absolute-origin work tracked there for sprint 2.

[wolfiesch]

@codex review

[chatgpt-codex-connector]

💡 Codex Review

wolfxl/src/calamine_styled_backend.rs

Lines 1974 to 1978 in 5d5fd84

	Ok(Event::Empty(ref e)) => {
	// Handle self-closing <c .../> (cells with no children — no formula).
	if e.local_name().as_ref() == b"c" {
	// No formula possible in an empty element, skip.
	}

Handle shared-formula <f/> entries in XML parser

parse_formulas_from_sheet_xml only captures formulas when <f> contains text and the Event::Empty branch ignores empty formula elements, but shared-formula follower cells are commonly encoded as self-closing <f t="shared" si="..."/>. Those cells never reach formula_map_cache, so read_cell_value, read_sheet_values, and read_sheet_records in data_only=false mode can return cached/literal values instead of formula metadata for drag-filled formula ranges. This causes incorrect read semantics on many real XLSX files that use shared formulas.

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".