cellpycore 0.2.4__tar.gz → 0.2.6__tar.gz

{cellpycore-0.2.4/.issueflows/02-partly-solved-issues → cellpycore-0.2.6/.issueflows/03-solved-issues}/issue100_status.md

@@ -1,6 +1,6 @@
 # Issue #100 — status
 
-- [ ] Done
+- [x] Done
 
 ## What's done
 

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

@@ -0,0 +1,48 @@
+# Issue #142: Harden cycle_mode unwrapping in OldCellpyCellCore / _cycle_mode_to_test_mode
+
+Source: https://github.com/cellpy/cellpy-core/issues/142
+
+## Original issue text
+
+## Context
+
+Found while working **jepegit/cellpy#668** (v1.x batch notebook): after a custom `update_cell` → `make_step_table()` → `make_summary()`, the legacy bridge crashes with:
+
+```text
+AttributeError: 'list' object has no attribute 'strip'
+```
+
+in `cellpycore.cell_core._cycle_mode_to_test_mode` when `OldCellpyCellCore.cycle_mode` is still list-shaped (often double-nested from cellpy-file meta, e.g. `[['anode']]`).
+
+### Why this is a core issue (not just v1.x)
+
+- `cellpy` **master** already mitigates on the **consumer load path** via recursive `test_meta._unwrap` after `meta_test_dependent.update(as_list=True, …)` (and has unit tests).
+- The **engine/bridge** still assumes a scalar string:
+  - `OldCellpyCellCore.cycle_mode` getter only does one-level `m[0]`
+  - setter **keeps** list values (`[x.lower() for x in cycle_mode]`) instead of storing a scalar
+  - `_cycle_mode_to_test_mode` calls `cycle_mode.strip()` with no list/tuple handling
+
+Any path that skips consumer unwrap (legacy loads, in-memory meta mutation, older cellpy pins) can still hit this. v1.x (#668) will add a consumer-side unwrap backport; core should still be defensive.
+
+## What to do
+
+1. **Getter** (`OldCellpyCellCore.cycle_mode`): recursively unwrap 1-element `list`/`tuple` to a scalar (same semantics as cellpy `test_meta._unwrap`).
+2. **Setter**: unwrap first, then store a **scalar** string (or `None`) — do not persist a list of lowered strings.
+3. **`_cycle_mode_to_test_mode`**: if given a list/tuple, unwrap before `.strip()`; keep existing string / `None` / unknown-spelling behaviour.
+4. **Tests** covering at least:
+   - `'anode'` / `'full_cell'`
+   - `['anode']`
+   - `[['anode']]`
+   - `None`
+   - make_summary / make_core_summary does not raise on nested list meta
+
+## Acceptance
+
+- Nested list `cycle_mode` no longer crashes summarization through the legacy bridge.
+- Existing CE / inverted-convention tests (issue #129 era) stay green.
+- No API break for callers that already pass a plain string.
+
+## Links
+
+- Downstream report: https://github.com/jepegit/cellpy/issues/668
+- Related consumer mitigation on master: unwrap in `cellpy.readers.cellpy_file.read` / `test_meta._unwrap`

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

@@ -0,0 +1,86 @@
+# Issue #142 — plan: harden `cycle_mode` unwrapping
+
+## Goal
+
+Stop nested list-shaped `cycle_mode` (e.g. `[['anode']]`) from crashing
+`_cycle_mode_to_test_mode` / summarization on the legacy bridge; store and
+expose a scalar string (or `None`) from the `cycle_mode` property.
+
+## Constraints
+
+- Back-compat: plain string callers unchanged; issue #127 spelling tables and
+  issue #129 bridge CE polarity tests stay green.
+- KISS: no new package/module; private helper next to existing translator in
+  `cell_core.py`. No numpy dependency (cellpy’s `_unwrap` also peels numpy
+  scalars / NaN — out of scope here; meta on the bridge is Python
+  `list`/`tuple`/`str`/`None`).
+- Metadata boundary unchanged: still optional; only normalize this one field
+  at the property / translator edge.
+- Scope: getter, setter, `_cycle_mode_to_test_mode` (+ tests). No cellpy
+  consumer changes (jepegit/cellpy#668 stays separate).
+
+### Prior art
+
+- `cellpy.readers.test_meta._unwrap` — recursive peel of 1-element
+  `list`/`tuple`; multi-element left as-is. **Mirror** that rule in core
+  (list/tuple only).
+- `_cycle_mode_to_test_mode` + `#127` tests in `tests/test_schema.py` —
+  spelling / warning contract; **extend**, don’t rewrite.
+- `CellpyCellCore.cycle_mode` getter already does one-level `m[0]`; setter
+  wrongly keeps a lowered **list**. `OldCellpyCellCore` inherits this
+  property (no override).
+- `test_bridge_summary_respects_cycle_mode` (`tests/test_golden.py`) — CE
+  polarity regression for string `"anode"`; keep green; add a nested-list
+  smoke if cheap.
+- Toolbox: empty (nothing reusable). Graph: `cycle_mode` /
+  `_cycle_mode_to_test_mode` / `OldCellpyCellCore` communities confirm the
+  change set is `cell_core.py` + `test_schema.py`.
+
+## Approach
+
+1. Add `_unwrap_meta_scalar(value)` in `cell_core.py` (module-private):
+   while `list`/`tuple` and `len == 1`, recurse; else return value.
+2. **Getter:** unwrap `meta_test_dependent.cycle_mode`; if still
+   `list`/`tuple`, take `[0]` when non-empty else `None` (preserves today’s
+   first-element behaviour for multi-element placeholders).
+3. **Setter:** unwrap first; if still sequence, take first or `None`; then
+   store **scalar** `str.lower()` or `None` on both meta and `_cycle_mode`
+   (never a list of lowered strings). Handle `None` without calling `.lower()`.
+4. **`_cycle_mode_to_test_mode`:** unwrap (+ first-element if still sequence)
+   before `.strip()`; keep existing `None` / empty / known / unknown+warn
+   behaviour. Type hint can widen to `Optional[str | list | tuple]` or stay
+   loose — behaviour matters more than the annotation.
+5. No public API export of the helper.
+
+Multi-element lists (`['anode','cathode']`) are not a real cellpy-file shape
+today; taking `[0]` matches the old getter and avoids a new failure mode.
+
+## Files to touch
+
+| Path | Change |
+|------|--------|
+| [`src/cellpycore/cell_core.py`](../../src/cellpycore/cell_core.py) | `_unwrap_meta_scalar`; harden getter / setter / `_cycle_mode_to_test_mode` |
+| [`tests/test_schema.py`](../../tests/test_schema.py) | Parametrize unwrap cases next to `#127` block; nested-list → INVERTED; setter stores scalar; optional `make_core_summary` / `make_summary` smoke with nested meta |
+
+## Test strategy
+
+```bash
+uv run pytest tests/test_schema.py -k cycle_mode
+uv run pytest   # full suite before close
+uv run ruff check && uv run ruff format --check
+```
+
+New coverage (minimum from issue):
+
+- `_cycle_mode_to_test_mode`: `'anode'`, `'full_cell'`, `['anode']`,
+  `[['anode']]`, `None` (and keep existing spelling params green).
+- Getter/setter: set `[['anode']]` or assign list → property returns
+  `"anode"`; stored meta is a `str`, not a list.
+- Smoke: `OldCellpyCellCore` (or `CellpyCellCore`) with nested list on
+  `meta_test_dependent.cycle_mode` → `make_core_summary` / `make_summary`
+  does not raise.
+
+## Open questions
+
+None blocking — defaults above match the issue + cellpy `_unwrap`. Say if
+you want multi-element lists to warn instead of silently taking `[0]`.

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

@@ -0,0 +1,20 @@
+# Issue #142 — status
+
+- [x] Done
+
+## What's done
+
+- Plan confirmed (`issue142_plan.md`).
+- Added `_unwrap_meta_scalar` / `_as_cycle_mode_scalar` in `cell_core.py`.
+- Hardened `CellpyCellCore.cycle_mode` getter/setter to store/return scalar
+  (or `None`); nested lists no longer persist as lowered lists.
+- `_cycle_mode_to_test_mode` unwraps list/tuple before `.strip()`.
+- Tests in `tests/test_schema.py` (issue #142 block): translator shapes,
+  setter scalar store, getter unwrap, `OldCellpyCellCore.make_core_summary`
+  smoke with `[['anode']]` meta.
+- Full suite: 281 passed; ruff green.
+- `HISTORY.md` Unreleased bullet added.
+
+## Remaining work
+
+- None (close / PR).

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.4 → cellpycore-0.2.6}/.issueflows/04-designs-and-guides/cellpy-core-integration-roadmap.md

@@ -46,7 +46,7 @@ Reconciled against the actual repo state on **2026-06-26**. Status legend: ✅ d
 | STEP-09 Harmonize headers | ✅ done | `config.Cols` + spec tests; `legacy/mapping.py` gives lossless/total `config.Cols` ↔ legacy `Headers*` round-trip (`tests/test_header_mapping.py`) (#34/#35) |
 | STEP-10 Metadata scaffolding | ✅ done | `cellpycore.metadata` (`models.py`/`io.py`); `TestMeta`/`CellMeta`/`TestMetaCollection` + (de)serialize/merge; graceful-degradation guard (`tests/test_metadata.py`) (#37) |
 | STEP-11 Timestamp representation | ✅ done | `epoch_time_utc` + `first/last_epoch_time_utc` are int64-ns UTC; `cellpycore.timestamps` conversion helpers + fixture regenerated (`tests/test_timestamps.py`) (#32, PR #38) |
-| STEP-12 Unit-handling boundary | 🟡 partly done | `CellpyUnits` schema in `units/spec.py` (#40/#112) + `units.py` tooling behind the optional `units` extra; factors cross the seam by value; `cellpy` still keeps duplicate converters (delegation pending) |
+| STEP-12 Unit-handling boundary | ✅ done | `CellpyUnits` schema in `units/spec.py` (#40/#112) + `units.py` tooling behind the optional `units` extra; factors cross the seam by value; `cellpy` now delegates `get_converter_to_specific` / `nominal_capacity_as_absolute` to `cellpycore.units` (jepegit/cellpy #451) — the duplicate converters are retired |
 
 Per-step `Status:` lines below repeat this for context; this table is the quick reference.
 The forward work beyond these twelve steps (STEP-13+) is enumerated in
@@ -266,12 +266,15 @@ Adopt the internal int64-ns timestamp representation.
 
 ## STEP-12 Unit-handling boundary (scaffolding/tooling in core; population & policy upstream)
 
-**Status:** 🟡 partly done — the `CellpyUnits` schema lives in `cellpycore.units.spec`
+**Status:** ✅ done — the `CellpyUnits` schema lives in `cellpycore.units.spec`
 (#40, #112) and the pint-based conversion tooling (`cellpycore.units`:
 `get_converter_to_specific`, `nominal_capacity_as_absolute`, `Q`, output-unit defaults)
-already exist behind the optional `units` extra, attached to the `OldCellpyCellCore`
-bridge, and conversion factors already cross the seam **by value**. Remaining on the
-**cellpy** side only: duplicate converter functions not yet delegated to core.
+exists behind the optional `units` extra, attached to the `OldCellpyCellCore`
+bridge, and conversion factors cross the seam **by value**. The final cellpy-side move
+has landed: `CellpyCell.get_converter_to_specific` / `nominal_capacity_as_absolute`
+(and `convert_value` / `calculate_scaler`) now delegate to `cellpycore.units`
+(jepegit/cellpy #451, unit plan Phase 2), guarded by converter-parity fixtures on both
+sides — the duplicated converters are retired.
 
 **Codebase:** `cellpy-core` (scaffolding/tooling — `legacy.py` + `units.py`); population
 (`raw_units` from loaders) and the decision to delegate are `cellpy`'s opt-in.
@@ -299,8 +302,9 @@ already did for headers and the step engine).
 
 ## Remaining work (STEP-13+) — finalized 2026-06-28 (issue #39)
 
-The original twelve steps are complete except for the two intentionally-continuous /
-partly-done ones (STEP-06 golden fixtures, STEP-12 unit boundary). Going through the
+The original twelve steps are complete except for the one intentionally-continuous
+one (STEP-06 golden fixtures); STEP-12 (unit boundary) closed once the cellpy-side
+converter delegation landed (jepegit/cellpy #451). Going through the
 roadmap and the companion design docs surfaced the remaining work below. Each item is now
 tracked as its own **cellpy-core** GitHub issue (the cellpy-side delegation work stays on
 jepegit/cellpy). Captured under issue #39.
@@ -339,12 +343,12 @@ flowchart TD
     S08 --> S09["STEP-09 Harmonize headers ✅"]
     S08 --> S10["STEP-10 Metadata scaffolding ✅"]
     S08 --> S11["STEP-11 Timestamp representation ✅"]
-    S03 --> S12["STEP-12 Unit-handling boundary 🟡"]
+    S03 --> S12["STEP-12 Unit-handling boundary ✅"]
     S07["STEP-07 Build-backend swap ✅"] -.independent.-> S08
 
     classDef done fill:#d4edda,stroke:#28a745,color:#155724;
     classDef partly fill:#fff3cd,stroke:#ffc107,color:#856404;
     classDef todo fill:#f8d7da,stroke:#dc3545,color:#721c24;
-    class S01,S02,S03,S04,S05,S07,S08,S09,S10,S11 done;
-    class S06,S12 partly;
+    class S01,S02,S03,S04,S05,S07,S08,S09,S10,S11,S12 done;
+    class S06 partly;
 ```

cellpycore-0.2.6/.vscode/settings.json

@@ -0,0 +1,14 @@
+{
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true,
+    "python-envs.pythonProjects": [
+        {
+            "path": ".",
+            "envManager": "ms-python.python:venv",
+            "packageManager": "ms-python.python:pip"
+        }
+    ]
+}

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

@@ -4,6 +4,19 @@ 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
 
 - Add Equivalent Full Cycles (EFC) utilities (#138). `summarizers.throughput_to_raw`

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: cellpycore
-Version: 0.2.4
+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.4 → cellpycore-0.2.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cellpycore"
-version = "0.2.4"
+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"