cellpycore 0.2.5__tar.gz → 0.2.6__tar.gz

cellpycore-0.2.6/.issueflows/03-solved-issues/issue147_original.md

@@ -0,0 +1,15 @@
+# Issue #147: update_core_data: empty new_raw with refresh_derived duplicates c-rate columns
+
+Source: https://github.com/cellpy/cellpy-core/issues/147
+
+## Original issue text
+
+Found by the cellpy L6 golden-equality oracle (jepegit/cellpy#778).
+
+`CellpyCellCore.update_core_data(data, new_raw=<empty frame>)` short-circuits inside `merge.update_data` (returns `_copy_data(data)`), but `refresh_derived=True` (default) then runs `summarizers.c_rates_to_summary` on a summary that already carries `charge_c_rate` / `discharge_c_rate`. The join adds `charge_c_rate_right` / `discharge_c_rate_right`.
+
+Expected: an empty `new_raw` is a no-op (frames identical to the input).
+
+Repro (cellpy 2.1.4 / cellpycore 0.2.5): `tests/test_incremental_update.py::test_empty_tail_is_noop` in jepegit/cellpy (strict xfail until fixed).
+
+Suggested fix: skip the `refresh_derived` block when `new_raw` is empty, or make `c_rates_to_summary` drop existing c-rate columns before joining (idempotent).

cellpycore-0.2.6/.issueflows/03-solved-issues/issue147_plan.md

@@ -0,0 +1,99 @@
+# Issue #147 — plan
+
+Source: https://github.com/cellpy/cellpy-core/issues/147
+
+## Goal
+
+`CellpyCellCore.update_core_data(data, new_raw=<empty>)` must be a true no-op:
+returned frames identical to the input (no `charge_c_rate_right` /
+`discharge_c_rate_right` / `ir_*_right` columns).
+
+## Constraints
+
+- Polars-native engine; accept pandas frames for convenience (existing pattern).
+- Input `Data` must not be mutated (`update_data` contract; keep the `_copy_data` return).
+- Non-empty `new_raw` path unchanged (oracle tests in `tests/test_merge.py` stay green).
+- Google-style docstrings; `ruff check` + `ruff format --check` clean.
+- Downstream: cellpy `tests/test_incremental_update.py::test_empty_tail_is_noop` is
+  `xfail(strict=True)` against this issue. Once cellpy bumps its `cellpycore` pin to a
+  release containing this fix, that xfail marker must be removed (cellpy follow-up, out
+  of scope here — note in PR body).
+
+### Prior art
+
+- `merge.update_data` (`src/cellpycore/merge.py:221`): already short-circuits on
+  `new_raw is None or _frame_is_empty(new_raw)` → `_copy_data(data)`. The bug is that
+  `update_core_data` does not honour that short-circuit before `refresh_derived`.
+- `merge._frame_is_empty` (`merge.py:389`): polars/pandas-agnostic emptiness check —
+  reuse it in `cell_core.py` instead of writing a new one.
+- `summarizers.c_rates_to_summary` (`summarizers.py:1172`) and
+  `summarizers.ir_to_summary` (`summarizers.py:1274`): both do a bare
+  `summary.join(..., how="left")` and are therefore **not idempotent** — calling either
+  twice on the same summary yields `*_right` columns. `ir_to_summary` has the identical
+  latent defect (only masked because the issue repro has no IR column in raw).
+- `tests/test_merge.py::test_update_core_data_refresh_derived` (line 336): existing
+  test for the derived-refresh path; new tests go beside it, reusing `_single_test_raw`,
+  `_process_raw`, `_schema` helpers.
+- Toolbox (`.issueflows/00-tools/`) empty; graphify report not needed (three
+  known call sites, all located by grep).
+
+## Approach
+
+Two small changes — a direct no-op fix plus idempotency hardening of the two
+summarizers so the same class of bug cannot recur from another caller.
+
+1. **`update_core_data`: return early on empty `new_raw`.**
+   After the pandas→polars coercion, if `_frame_is_empty(new_raw)` (or `new_raw is None`),
+   return `update_data(...)`'s result directly (it already returns `_copy_data(data)`)
+   and skip the whole `refresh_derived` block. Cheapest, and matches the documented
+   "empty tail is a no-op" expectation. Docstring: add one sentence stating that an
+   empty `new_raw` returns an unmodified copy and skips derived refresh.
+
+2. **Make `c_rates_to_summary` and `ir_to_summary` idempotent.**
+   Before the join, drop the target columns if already present:
+   `summary = summary.drop([c for c in (charge_c_rate, discharge_c_rate) if c in summary.columns])`
+   (same for `ir_charge` / `ir_discharge`). Re-running then overwrites instead of
+   producing `*_right`. This is the "either" alternative from the issue; doing both
+   keeps the no-op guarantee cheap (1) and removes the footgun for any other caller (2).
+
+Order: 1 → 2 → tests → ruff.
+
+## Files to touch
+
+- `src/cellpycore/cell_core.py` — `update_core_data`: early return on empty `new_raw`
+  (import `_frame_is_empty` alongside `update_data` from `cellpycore.merge`); docstring note.
+- `src/cellpycore/summarizers.py` — `c_rates_to_summary`, `ir_to_summary`: drop
+  pre-existing target columns before the join; one docstring line each ("idempotent:
+  existing columns are replaced").
+- `tests/test_merge.py` — new tests (see below).
+- `CHANGELOG.md` (if present — check at close) — fix entry.
+
+## Test strategy
+
+Run: `uv run pytest` then `uv run ruff check && uv run ruff format --check`.
+
+New tests in `tests/test_merge.py`:
+
+- `test_update_core_data_empty_new_raw_is_noop` — build `base` via `_process_raw`, run
+  `cell.update_core_data(base, extension.clear())` (polars empty frame with same
+  schema) with default `refresh_derived=True`; assert `updated.summary.columns ==
+  base.summary.columns`, no column ends with `_right`, and `raw`/`steps`/`summary`
+  `.equals()` the input. Also assert input `base` untouched.
+- `test_update_core_data_empty_pandas_new_raw_is_noop` — same with
+  `extension.to_pandas().iloc[0:0]` (the cellpy repro shape).
+- `test_c_rates_to_summary_idempotent` — call twice on processed data; columns
+  unchanged after second call, values equal.
+- `test_ir_to_summary_idempotent` — same for IR (needs raw with
+  `internal_resistance` column; check `_single_test_raw` provides it, else add it).
+
+Existing oracle tests (`test_update_overlap_matches_full_recompute_oracle`,
+`test_update_gap_append_matches_full_recompute_oracle`,
+`test_update_core_data_refresh_derived`, `tests/test_e2e.py`) guard the non-empty path.
+
+## Open questions
+
+- Scope of step 2 (idempotency hardening of both summarizers): include it, or ship only
+  the early return (step 1)? Recommendation: include — two-line change each, closes the
+  same defect in `ir_to_summary`, and the issue lists it as an acceptable fix.
+- Version bump at close: `patch` (bug fix, no API change). Cellpy needs a new
+  `cellpycore` release to drop its xfail.

cellpycore-0.2.6/.issueflows/03-solved-issues/issue147_status.md

@@ -0,0 +1,24 @@
+# Issue #147 — status
+
+- [x] Done
+
+## What's done
+
+- Plan accepted (2026-09-08): early return in `update_core_data` on empty `new_raw`
+  + idempotent `c_rates_to_summary` / `ir_to_summary`.
+- `cell_core.update_core_data`: returns the `update_data` copy directly when `new_raw`
+  is `None` or empty (skips `refresh_derived`); docstring updated.
+- `summarizers.c_rates_to_summary` / `ir_to_summary`: drop pre-existing target columns
+  before the join via new `_drop_existing` helper → idempotent; docstrings updated.
+- Tests (`tests/test_merge.py`): `test_update_core_data_empty_new_raw_is_noop`,
+  `test_update_core_data_empty_pandas_new_raw_is_noop`,
+  `test_c_rates_to_summary_idempotent`, `test_ir_to_summary_idempotent`.
+  Verified all 4 fail on `main` code, pass with fix.
+- Full suite: 285 passed. `ruff check` + `ruff format --check` clean.
+- `HISTORY.md` bullet under `[Unreleased]`. No version bump (0.2.5 already pending release).
+
+## Remaining work
+
+- None in this repo.
+- Follow-up (cellpy repo, after `cellpycore` pin bump to a release with this fix): remove
+  strict `xfail` on `tests/test_incremental_update.py::test_empty_tail_is_noop`.

cellpycore-0.2.6/.issueflows/03-solved-issues/issue148_original.md

@@ -0,0 +1,15 @@
+# Issue #148: update_data: gap-append keeps the partial trailing step (step spanning the cut is split)
+
+Source: https://github.com/cellpy/cellpy-core/issues/148
+
+## Original issue text
+
+Found by the cellpy L6 golden-equality oracle (jepegit/cellpy#778).
+
+When `new_raw` starts strictly after the existing `datapoint_num` max (`gap_append=True`), `merge.update_data` keeps *all* existing step rows and rebuilds only from the first new datapoint. If the existing raw ends mid-step (the tester step continues in the new rows), that step ends up as two rows: the kept partial row and a new partial row. Downstream the per-cycle summary C-rate drifts (e.g. `discharge_c_rate` 248.6919 vs 248.68871 on `neware_uio.csv` cut at row 4000).
+
+With any overlap (>= 1 already-seen row) `_trim_steps_for_overlap` rebuilds from the start of the spanning step and the result is identical to a full load.
+
+Expected: gap-append should also trim the trailing step of `kept_steps` when the first new row continues the same (cycle, step) and rebuild from that step's `datapoint_num_first`; alternatively document that callers must re-read from the start of the last step.
+
+Repro: `tests/test_incremental_update.py::test_gap_append_mid_step_equals_full_load` in jepegit/cellpy (strict xfail until fixed).

cellpycore-0.2.6/.issueflows/03-solved-issues/issue148_plan.md

@@ -0,0 +1,144 @@
+# Issue #148 — plan
+
+Source: https://github.com/cellpy/cellpy-core/issues/148
+
+## Goal
+
+`merge.update_data` gap-append (`new_raw` starts strictly after existing
+`datapoint_num` / `source_datapoint_num` max) must not split a tester step that
+continues across the cut. Resulting steps + summary match a full
+`make_step_table` / `make_summary` on the concatenated raw (same contract as
+the overlap path).
+
+## Constraints
+
+- Polars-native; do not mutate the input `Data` (`_copy_data` / new frames).
+- Overlap path (`r2_start <= r1_max`) stays unchanged — already trims via
+  `_trim_steps_for_overlap` and the existing oracle stays green.
+- Gap-append that starts on a **new** (cycle, step) stays as today: keep every
+  existing step row, rebuild from the first new `datapoint_num`.
+- Single-`test_id` only (`update_data` v1). Match `(cycle_num, step_num)` as
+  the issue states; do not invent `sub_step_num` matching (engine still
+  hardcodes sub-step `1`).
+- Google-style docstrings; `ruff check` + `ruff format --check` clean.
+- Downstream: cellpy `tests/test_incremental_update.py::test_gap_append_mid_step_equals_full_load`
+  is `xfail(strict=True)` against this issue. Dropping that marker is a cellpy
+  follow-up after the next `cellpycore` pin bump — note in PR body, out of
+  scope here.
+
+### Prior art
+
+- `merge.update_data` (`src/cellpycore/merge.py`): `gap_append = r2_start > r1_max`
+  keeps **all** `steps_pl` and sets `from_data_point` to `min(new datapoint_num)`.
+  That is the bug. Overlap branch already calls `_trim_steps_for_overlap`.
+- `_trim_steps_for_overlap` (`merge.py`): finds the step whose
+  `[datapoint_num_first, datapoint_num_last]` contains the first overlapping
+  datapoint, drops that step and later ones, returns `from_data_point` = that
+  step's first. On a **gap**, the first new datapoint is *after* every existing
+  `datapoint_num_last`, so this helper currently keeps all steps — it cannot
+  detect continuation by range alone.
+- `summarizers.make_step_table(..., from_data_point=)` (`summarizers.py`):
+  filters `datapoint_num >= from_data_point` then `group_by(test_id, cycle_num,
+  step_num, sub)`. Rebuilding from the spanning step's first datapoint
+  concatenates the kept partial raw + new rows into one step group. That is
+  why overlap works and why gap-append must use the same `from_data_point`.
+- Issue #86 original algorithm: *"If r2(0) >= r1(last): find what step r2(0)
+  is in. That step and all the ones after will then belong to R2."* Gap-append
+  skipped that "find the step" part; this issue completes it.
+- `tests/test_merge.py::test_update_gap_append_matches_full_recompute_oracle`:
+  cut is at `source_datapoint_num == 20` (`_single_test_raw` n_cycles=3) —
+  **step boundary** (start of cycle 3 step 1), so it does not catch this bug.
+  New tests go beside it; reuse `_single_test_raw`, `_process_raw`,
+  `_steps_oracle_equal`, `_summary_oracle_equal`.
+- `step-c-rate-split.md`: `update_data` still appends `c_rate` to rebuilt rows
+  when kept steps carry it — keep that. Split steps are why downstream
+  `discharge_c_rate` drifts.
+- Toolbox (`.issueflows/00-tools/`) empty. Graphify community 76 is the
+  `merge.py` helper cluster (`_trim_steps_for_overlap`, `update_data`); no
+  extra helper to reuse.
+
+## Approach
+
+Implement the issue's primary expected behaviour (trim), not the
+"document that callers must re-read" alternative.
+
+1. **Continuation trim on gap-append.** After detecting `gap_append`, still
+   keep **all** existing raw (`kept_raw = raw_pl` — new rows do not repeat the
+   partial step). Trim steps: if the first new row's `(cycle_num, step_num)`
+   equals the **last** existing step's `(cycle_num, step_num)`, drop that last
+   step and set `from_data_point` to its `datapoint_num_first`. Else keep all
+   steps and `from_data_point = min(new datapoint_num)` (current behaviour).
+
+   Implement as a **continuation fallback inside** `_trim_steps_for_overlap`
+   (when `overlap_idx is None`), then call that helper from the gap-append
+   branch with `new_pl` as the "incoming" frame. One trim function, two
+   callers. Do not add a second helper unless the fallback makes the overlap
+   docstring dishonest — if so, a tiny `_trim_steps_for_gap_append` next to it
+   is the fallback (same predicate).
+
+   Predicate (last step vs first incoming row, after sort by
+   `datapoint_num` / `datapoint_num_first`):
+
+   ```text
+   last[shdr.cycle_num] == first_new[nhdr.cycle_num]
+   and last[shdr.step_num] == first_new[nhdr.step_num]
+   ```
+
+2. **Do not trim `kept_raw` on gap.** Overlap drops existing rows with
+   `partition >= r2_start` because `new_raw` re-sends them. Gap does not.
+   `make_step_table(from_data_point=spanning_first)` then sees kept partial
+   points **plus** new points and rebuilds one step row.
+
+3. **Docs.** One sentence on `update_data` and on `_trim_steps_for_overlap`:
+   gap-append that continues the trailing `(cycle, step)` rebuilds that step
+   from `datapoint_num_first`, same as overlap.
+
+Order: helper + `update_data` call site → tests → ruff → `HISTORY.md` at
+close.
+
+## Files to touch
+
+- `src/cellpycore/merge.py` — continuation fallback in
+  `_trim_steps_for_overlap` (or sibling helper); gap-append branch calls it
+  instead of keeping all steps; docstring.
+- `tests/test_merge.py` — new oracle test(s) (see below).
+- `HISTORY.md` — `[Unreleased]` fix bullet at close.
+
+No `cell_core.py` change unless a docstring cross-ref is useful;
+`update_core_data` already forwards to `update_data`.
+
+## Test strategy
+
+Run: `uv run pytest` then `uv run ruff check && uv run ruff format --check`.
+
+New tests in `tests/test_merge.py`, same helpers as the existing update
+oracles:
+
+- `test_update_gap_append_mid_step_matches_full_recompute_oracle` — the
+  issue. `_single_test_raw(..., n_cycles=2)`: cycle 2 step 1 is datapoints
+  10–14. `base_raw` = `source_datapoint_num <= 12`, `extension` =
+  `source_datapoint_num >= 13` (`r2_start > r1_max` → gap). Assert
+  `_steps_oracle_equal` + `_summary_oracle_equal` vs `_process_raw(full_raw)`.
+  Also `updated.steps.height == oracle.steps.height` (no extra split row).
+- `test_update_core_data_gap_append_mid_step_c_rate_matches_full` — same cut
+  through `CellpyCellCore.update_core_data` (default `refresh_derived=True`);
+  `discharge_c_rate` / `charge_c_rate` match a fully processed oracle
+  (`pytest.approx`). Guards the cellpy L6 symptom.
+
+Existing `test_update_gap_append_matches_full_recompute_oracle` (step-boundary
+gap) and `test_update_overlap_matches_full_recompute_oracle` stay green.
+Optional e2e mid-step cut on the Arbin fixture is **out of scope** (unit
+oracle is enough; fixture may be absent).
+
+## Open questions
+
+- Trim vs document-only (issue lists both)? **Recommend trim** — overlap
+  already does this; #86's update algorithm already said "find what step
+  r2(0) is in". Document-only would leave core wrong and keep the cellpy
+  xfail forever.
+- Extend `_trim_steps_for_overlap` vs a new `_trim_steps_for_gap_append`?
+  **Recommend extend** (continuation fallback when the first incoming
+  datapoint is past every `datapoint_num_last`). New helper if that muddies
+  the overlap-only name.
+- Version bump at close: **patch** (behaviour bug, no API change). Cellpy
+  needs a new `cellpycore` release to drop its xfail.

cellpycore-0.2.6/.issueflows/03-solved-issues/issue148_status.md

@@ -0,0 +1,27 @@
+# Issue #148 — status
+
+- [x] Done
+
+## What's done
+
+- Plan accepted (2026-09-08): trim trailing step on gap-append continuation;
+  rebuild from that step's `datapoint_num_first`.
+- `_trim_steps_for_overlap`: continuation fallback when the first incoming
+  datapoint is past every existing step but `(cycle_num, step_num)` matches
+  the last kept step.
+- `update_data` gap-append branch now calls `_trim_steps_for_overlap` on
+  `new_pl`; post-offset `from_data_point` still follows a non-continuation
+  gap.
+- Tests: `test_update_gap_append_mid_step_matches_full_recompute_oracle`,
+  `test_update_core_data_gap_append_mid_step_c_rate_matches_full`.
+- `uv run pytest`: 287 passed, 3 deselected. `ruff check` + `ruff format --check`
+  clean.
+- Version bump `0.2.5` → `0.2.6`. `HISTORY.md` promoted (`#147`/`#148` under
+  `[0.2.6]`; `#142` backfilled under `[0.2.5]` to match tag `v0.2.5`).
+
+## Remaining work
+
+- None in this repo.
+- Follow-up (cellpy repo, after `cellpycore` pin bump to a release with this
+  fix): remove strict `xfail` on
+  `tests/test_incremental_update.py::test_gap_append_mid_step_equals_full_load`.

{cellpycore-0.2.5 → cellpycore-0.2.6}/HISTORY.md

@@ -4,6 +4,17 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.2.6] - 2026-09-08
+
+- `update_core_data` treats an empty `new_raw` as a no-op (skips the derived refresh
+  instead of re-joining `*_c_rate` / `ir_*` columns as `*_right` duplicates);
+  `c_rates_to_summary` and `ir_to_summary` are now idempotent. (#147)
+- `update_data` gap-append that continues the trailing `(cycle, step)` now
+  rebuilds that step from `datapoint_num_first` instead of splitting it into
+  two partial rows (summary C-rate matches a full load). (#148)
+
+## [0.2.5] - 2026-09-08
+
 - Harden `cycle_mode` unwrapping in `OldCellpyCellCore` / `_cycle_mode_to_test_mode`. (#142)
 
 ## [0.2.4] - 2026-07-23

{cellpycore-0.2.5 → cellpycore-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cellpycore
-Version: 0.2.5
+Version: 0.2.6
 Summary: Core engine for cellpy: fast, thread-safe step and cycle summarization of battery-cycling raw data
 License-Expression: MIT
 License-File: LICENSE

{cellpycore-0.2.5 → cellpycore-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cellpycore"
-version = "0.2.5"
+version = "0.2.6"
 license = "MIT"
 license-files = ["LICEN[CS]E*"]
 description = "Core engine for cellpy: fast, thread-safe step and cycle summarization of battery-cycling raw data"

{cellpycore-0.2.5 → cellpycore-0.2.6}/src/cellpycore/cell_core.py

@@ -552,16 +552,18 @@ class CellpyCellCore:
             **kwargs: Forwarded to ``update_data`` / ``make_step_table``.
 
         Returns:
-            A new updated ``Data`` object. The input is not modified.
+            A new updated ``Data`` object. The input is not modified. An empty
+            ``new_raw`` is a no-op: an unmodified copy is returned and the
+            derived refresh is skipped.
         """
         import polars as pl
 
-        from cellpycore.merge import update_data
+        from cellpycore.merge import _frame_is_empty, update_data
         from cellpycore.summarizers import _resolve_nom_cap_abs
 
         nom_cap_abs = _resolve_nom_cap_abs(nom_cap_abs, nom_cap)
 
-        if not isinstance(new_raw, pl.DataFrame):
+        if new_raw is not None and not isinstance(new_raw, pl.DataFrame):
             new_raw = pl.from_pandas(new_raw)
 
         test_mode = _cycle_mode_to_test_mode(self.cycle_mode)
@@ -574,6 +576,12 @@ class CellpyCellCore:
             **kwargs,
         )
 
+        if new_raw is None or _frame_is_empty(new_raw):
+            # update_data already returned an unmodified copy; the summary still
+            # carries the derived columns, so re-joining them would duplicate
+            # them as ``*_right`` (issue #147).
+            return out
+
         if refresh_derived:
             from cellpycore import summarizers
 

{cellpycore-0.2.5 → cellpycore-0.2.6}/src/cellpycore/merge.py

@@ -185,7 +185,9 @@ def update_data(
 
     Trims the overlap at ``source_datapoint_num`` (or ``datapoint_num`` when
     absent), refreshes affected step rows via ``make_step_table(from_data_point=…)``,
-    and rebuilds the per-cycle summary on the combined frames.
+    and rebuilds the per-cycle summary on the combined frames. Gap-append that
+    continues the trailing ``(cycle_num, step_num)`` rebuilds that step from
+    ``datapoint_num_first`` (same contract as overlap).
 
     Args:
         data: Processed ``Data`` with ``raw``, ``steps``, and ``summary``.
@@ -250,7 +252,12 @@ def update_data(
 
     if gap_append:
         kept_raw = raw_pl
-        kept_steps = steps_pl
+        kept_steps, from_data_point = _trim_steps_for_overlap(
+            steps_pl,
+            new_pl,
+            shdr,
+            nhdr,
+        )
     else:
         kept_raw = raw_pl.filter(pl.col(partition) < r2_start)
         kept_steps, from_data_point = _trim_steps_for_overlap(
@@ -260,14 +267,16 @@ def update_data(
             nhdr,
         )
 
+    pre_offset_new_min = int(new_pl[nhdr.datapoint_num].min())  # type: ignore[arg-type]
     dp_max_kept = _max_column(kept_raw, nhdr.datapoint_num)
-    new_dp_min = int(new_pl[nhdr.datapoint_num].min())  # type: ignore[arg-type]
-    if new_dp_min <= dp_max_kept:
+    if pre_offset_new_min <= dp_max_kept:
         new_pl = _offset_int_column(new_pl, nhdr.datapoint_num, dp_max_kept)
 
     combined_raw = pl.concat([kept_raw, new_pl], how="vertical")
 
-    if gap_append:
+    # Non-continuation gap-append starts at the first new datapoint. If those
+    # rows were offset to avoid colliding with kept raw, follow the offset.
+    if gap_append and from_data_point == pre_offset_new_min:
         from_data_point = int(new_pl[nhdr.datapoint_num].min())  # type: ignore[arg-type]
 
     slice_data = Data()
@@ -341,13 +350,19 @@ def _trim_steps_for_overlap(
     shdr: config.StepCols,
     nhdr: config.RawCols,
 ) -> tuple[pl.DataFrame, int]:
-    """Drop the overlap step and all later steps; return kept steps and ``from_data_point``."""
+    """Drop the spanning step and later ones; return kept steps and ``from_data_point``.
+
+    The spanning step is the row whose ``[datapoint_num_first, datapoint_num_last]``
+    contains the first incoming datapoint. If that datapoint is past every
+    existing step (gap-append) but the first incoming row continues the last
+    step's ``(cycle_num, step_num)``, drop that trailing step and rebuild from
+    its ``datapoint_num_first``.
+    """
     if overlap_raw.is_empty():
         return steps, int(steps[shdr.datapoint_num_first].min())  # type: ignore[arg-type]
 
-    first_dp = int(
-        overlap_raw.sort(nhdr.datapoint_num)[nhdr.datapoint_num][0]  # type: ignore[index]
-    )
+    incoming = overlap_raw.sort(nhdr.datapoint_num)
+    first_dp = int(incoming[nhdr.datapoint_num][0])  # type: ignore[index]
     steps_sorted = steps.sort(shdr.datapoint_num_first)
     overlap_idx = None
     for idx, row in enumerate(steps_sorted.iter_rows(named=True)):
@@ -361,6 +376,19 @@ def _trim_steps_for_overlap(
     if overlap_idx is None:
         from_data_point = first_dp
         kept = steps_sorted.filter(pl.col(shdr.datapoint_num_last) < first_dp)
+        if (
+            not kept.is_empty()
+            and nhdr.cycle_num in incoming.columns
+            and nhdr.step_num in incoming.columns
+        ):
+            last_step = kept.tail(1).row(0, named=True)
+            first_new = incoming.row(0, named=True)
+            if (
+                last_step[shdr.cycle_num] == first_new[nhdr.cycle_num]
+                and last_step[shdr.step_num] == first_new[nhdr.step_num]
+            ):
+                from_data_point = int(last_step[shdr.datapoint_num_first])
+                kept = kept.head(kept.height - 1)
         return kept, from_data_point
 
     kept = steps_sorted.head(overlap_idx)

{cellpycore-0.2.5 → cellpycore-0.2.6}/src/cellpycore/summarizers.py

@@ -1191,6 +1191,8 @@ def c_rates_to_summary(
     and passes it in (default 1.0, i.e. no conversion), so this function does no
     unit handling itself.
 
+    Idempotent: C-rate columns already present in the summary are replaced.
+
     Args:
         data (core.Data): The data object (needs ``summary`` and ``steps``).
         schema: The column-header schema to use. Defaults to the native
@@ -1265,6 +1267,10 @@ def c_rates_to_summary(
     charge = _first_rate("charge", headers_summary.charge_c_rate)
     discharge = _first_rate("discharge", headers_summary.discharge_c_rate)
 
+    # Idempotent: replace existing C-rate columns instead of joining ``*_right``.
+    summary = _drop_existing(
+        summary, headers_summary.charge_c_rate, headers_summary.discharge_c_rate
+    )
     summary = summary.join(charge, left_on=left_on, right_on=right_on, how="left")
     summary = summary.join(discharge, left_on=left_on, right_on=right_on, how="left")
     data.summary = summary
@@ -1285,6 +1291,8 @@ def ir_to_summary(
     #23, fixing the legacy off-by-one attribution). Cycles for which the extractor
     yields no value (for example a cycle with no charge step) get ``NaN``.
 
+    Idempotent: IR columns already present in the summary are replaced.
+
     Args:
         data (Data): The data object (needs ``summary``, ``raw`` and ``steps``).
         schema: The column-header schema to use. Defaults to the native
@@ -1322,6 +1330,10 @@ def ir_to_summary(
         and headers_summary.test_id in summary.columns
         else headers_summary.cycle_num
     )
+    # Idempotent: replace existing IR columns instead of joining ``*_right``.
+    summary = _drop_existing(
+        summary, headers_summary.ir_charge, headers_summary.ir_discharge
+    )
     summary = summary.join(per_cycle, on=join_on, how="left")
     # Missing IR (e.g. a cycle without a charge/discharge step) stays NaN rather
     # than the legacy 0.0, so "no measurement" is distinguishable from a real 0.
@@ -1333,6 +1345,12 @@ def ir_to_summary(
     return data
 
 
+def _drop_existing(frame: pl.DataFrame, *columns: str) -> pl.DataFrame:
+    """Drop ``columns`` that are present in ``frame`` (missing ones are ignored)."""
+    present = [c for c in columns if c in frame.columns]
+    return frame.drop(present) if present else frame
+
+
 def _main():
     print("summarizers.py - no main function yet")
 

{cellpycore-0.2.5 → cellpycore-0.2.6}/uv.lock

@@ -73,7 +73,7 @@ css = [
 
 [[package]]
 name = "cellpycore"
-version = "0.2.5"
+version = "0.2.6"
 source = { editable = "." }
 dependencies = [
     { name = "pandas" },
@@ -138,7 +138,7 @@ name = "cffi"
 version = "2.0.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+    { name = "pycparser" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
 wheels = [