cellpy 2.1.2a3__tar.gz → 2.1.2a4__tar.gz

cellpy-2.1.2a4/.issueflows/03-solved-issues/issue862_original.md

@@ -0,0 +1,45 @@
+# Issue #862: dva_plot(direction='both') does not distinguish the half-cycles visually (ica_plotter does)
+
+Source: https://github.com/jepegit/cellpy/issues/862
+
+## Original issue text
+
+**cellpy version:** 2.1.2a3
+
+## Summary
+
+`ica_plotter` gained a visual distinction for `direction="both"` in #821 — the charge lobe is dashed (`line_dash`), so the two half-cycles are separable at a glance. `dva_plot(direction="both")` overlays both half-cycles too, but draws them **identically**: same colour, same trace name, no dash.
+
+Only the hover tells them apart. On a static export (PNG/SVG/PDF for a report) that information is gone entirely.
+
+## Reproduction
+
+```python
+import json, plotly.io as pio
+from cellpy.utils.plotutils import dva_plot
+from cellpy.utils import example_data
+
+cell = example_data.cellpy_file()
+fig = json.loads(pio.to_json(dva_plot(cell, cycles=[1], direction="both", backend="plotly")))
+for t in fig["data"]:
+    print(t["name"], t["line"], t.get("showlegend"))
+```
+
+```
+1 {'color': 'rgb(68, 1, 84)', 'width': 1.5} True
+1 {'color': 'rgb(68, 1, 84)', 'width': 1.5} False
+```
+
+Both traces: same `name`, same `legendgroup`, same colour, `dash` unset. Compare `ica_plotter(..., direction="both")`, which yields `1, charge` / `1, discharge` with `dash='dot'` on one of them.
+
+The hover *is* correct — `customdata[1]` carries `charge`/`discharge` and the template shows it — so this is purely about the visual encoding.
+
+## Why it matters for apps
+
+We're adding a DVA view to [cellpy-simple-gui](https://github.com/cellpy/cellpy-simple-gui) next to the existing ICA view. Same "Both" control, same user expectation, but two different behaviours: ICA is readable, DVA looks like a single doubled-back curve. We'll dash the discharge half app-side for now, which is exactly the kind of divergence #821 removed for ICA.
+
+## Suggested fix
+
+Apply the #821 treatment in `dva_plot`: `line_dash` per direction (and ideally `"<cycle>, charge"` / `"<cycle>, discharge"` names, matching `ica_plotter`), so the two families stay consistent with each other.
+
+Happy to send a PR if you'd like.

cellpy-2.1.2a4/.issueflows/03-solved-issues/issue862_plan.md

@@ -0,0 +1,90 @@
+# Plan — Issue #862: dva_plot(direction='both') does not distinguish half-cycles visually
+
+## Goal
+
+Make charge vs discharge half-cycles visually distinguishable (not just via hover) when `direction="both"` in `dva_plot` — and, since it's the same code path, in `ica_plot` too.
+
+## Investigation note (corrects the issue's framing)
+
+`ica_plot` and `dva_plot` (`cellpy/utils/plotutils.py`) both route through the same shared
+`prepare` (`cellpy/plotting/prepare/ica.py`) → `_render_ica_dva` renderer (one method per
+backend: [`PlotlyBackend._render_ica_dva`](cellpy/plotting/backends/plotly.py) and
+[`MatplotlibBackend._render_ica_dva`](cellpy/plotting/backends/mpl.py)). Reproduced with the
+example cell: **`ica_plot(direction="both")` currently has the identical bug** — both docstrings
+say outright "Line style is shared across charge and discharge." The issue's comparison is to
+`cellpy.plotting.collected.ica_plotter` (the separate `Collection.plot` family-kind path fixed
+in #821, `line_dash=direction_col` via `px.line`), not to `plotutils.ica_plot`.
+
+Net effect: this is a **one-shared-fix** — patching `_render_ica_dva` fixes both `ica_plot` and
+`dva_plot` at once, and they stay consistent with each other by construction (no per-kind
+special-casing needed).
+
+## Constraints
+
+- Keep the fix minimal: line style only (dash), not a legend/trace-naming overhaul. The issue's
+  "ideally `<cycle>, charge` / `<cycle>, discharge` names" is explicitly a nice-to-have
+  ("ideally"), and both backends currently key their legend/colorbar by **cycle** (color), grouped
+  across directions — renaming would double legend entries per cycle. Out of scope here.
+- Match the #821 convention already established in `collected.py` for consistency across the
+  codebase: charge = solid, discharge = dotted (`px.line`'s default dash sequence gives the first
+  category `"solid"`, second `"dot"`, and `"charge"` < `"discharge"` alphabetically).
+- Both backends (plotly + matplotlib) must get the fix — the issue only mentions plotly exports,
+  but the mpl backend has the identical "shared line style" bug and docstring.
+- Do not change trace/line count, names, or hover content — `tests/data/figure_specs.json`
+  (structural snapshot, #567) does not record line style, so no golden-file update is needed as
+  long as trace count/names/axes are untouched.
+
+### Prior art
+
+- `cellpy/plotting/collected.py::sequence_plotter` (#821 fix, lines ~573-580): sets
+  `plotly_arguments["line_dash"] = direction_col` when `direction == "both"`, for the *separate*
+  `Collection.plot(family_kind="ica")` path. Same convention (dash keyed by the `direction`
+  column values `"charge"` / `"discharge"` from `cellpy.ica.CHARGE` / `cellpy.ica.DISCHARGE`) is
+  reused here, but applied manually (since `_render_ica_dva` builds `go.Scatter` traces directly,
+  not through `px.line`).
+- `tests/test_collected_ica_direction.py::test_ica_line_direction_both_overlays_without_coerce` —
+  existing pattern for asserting `{tr.line.dash for tr in fig.data}` has ≥2 distinct values;
+  mirror this style for the new plotutils-level test.
+
+## Approach
+
+1. **Plotly backend** (`cellpy/plotting/backends/plotly.py::PlotlyBackend._render_ica_dva`):
+   in the `for (cycle, direction), group in frame.groupby(group_cols, ...)` loop, compute
+   `dash = "dot" if direction == DISCHARGE else "solid"` and pass `dash=dash` into the existing
+   `line=dict(color=color, width=1.5)` dict. Import `CHARGE, DISCHARGE` from `cellpy.ica`
+   (`ICA_COLS` is already imported there).
+2. **Matplotlib backend** (`cellpy/plotting/backends/mpl.py::MatplotlibBackend._render_ica_dva`):
+   in the `for (cycle, _direction), group in frame.groupby(...)` loop, rename `_direction` to
+   `direction`, compute `linestyle = ":" if direction == DISCHARGE else "-"`, pass
+   `linestyle=linestyle` to `ax.plot(...)`.
+3. **Docstrings** — update both `_render_ica_dva` docstrings' "Line style is shared across charge
+   and discharge" line to describe the new dash/linestyle behaviour.
+4. **Tests** — add to `tests/test_ica_plot_prepare.py`:
+   - `test_ica_plot_both_direction_dash_differs` (and `dva_plot` equivalent, or parametrized over
+     both) for the plotly backend: call `ica_plot`/`dva_plot(direction="both", backend="plotly")`,
+     assert `{tr.line.dash for tr in fig.data}` has at least 2 distinct values.
+   - matplotlib equivalent: assert `{line.get_linestyle() for line in fig.get_axes()[0].get_lines()}`
+     has at least 2 distinct values for `direction="both"`.
+   - A `direction="charge"` (single-direction) sanity check that dash stays `"solid"`/`"-"` for
+     both kinds, guarding against a future regression that always-dashes regardless of direction.
+
+## Files to touch
+
+- `cellpy/plotting/backends/plotly.py` — `PlotlyBackend._render_ica_dva`: add per-direction dash.
+- `cellpy/plotting/backends/mpl.py` — `MatplotlibBackend._render_ica_dva`: add per-direction linestyle.
+- `tests/test_ica_plot_prepare.py` — new direction/dash tests.
+- `HISTORY.md` (at `/iflow-close`, per project convention) — patch-level fix note.
+
+## Test strategy
+
+- `uv run pytest tests/test_ica_plot_prepare.py -m essential` for the fast path; then the
+  documented merge gate `uv run pytest -m essential` (per `AGENTS.md`).
+- Plotting tests run fine outside `MPLBACKEND=Agg` requirement here since this repo's local dev
+  loop uses conda per project rules — will run via the activated `cellpy_dev_313` env (or `uv run`
+  if conda isn't needed locally); confirm whichever is available in the close step actually runs.
+- Manually re-run the issue's repro snippet for both `ica_plot` and `dva_plot` to confirm dash
+  values differ and match before/after.
+
+## Open questions
+
+None — scope, convention (match #821), and file list are all resolved from the codebase itself.

cellpy-2.1.2a4/.issueflows/03-solved-issues/issue862_status.md

@@ -0,0 +1,28 @@
+# Status — Issue #862
+
+- [x] Done
+
+## What's done
+
+- Investigated and confirmed `ica_plot` and `dva_plot` share the same `_render_ica_dva`
+  renderer (plotly + mpl) and both currently lacked dash distinction for `direction="both"`
+  (the issue's "ica_plotter already does this" comparison was to the separate
+  `cellpy.plotting.collected.ica_plotter`, fixed in #821 — a different code path).
+- Plan written (`issue862_plan.md`), accepted.
+- `PlotlyBackend._render_ica_dva` (`cellpy/plotting/backends/plotly.py`): dash keyed by
+  direction (`charge` solid, `discharge` dotted) whenever both directions are overlaid in the
+  frame; single-direction plots stay solid.
+- `MatplotlibBackend._render_ica_dva` (`cellpy/plotting/backends/mpl.py`): same behaviour via
+  `linestyle` (`"-"` / `":"`).
+- Docstrings updated on both renderers.
+- New tests in `tests/test_ica_plot_prepare.py`: dash/linestyle differ for `direction="both"`
+  (both `ica_plot` and `dva_plot`, both backends), and stays solid for a single direction.
+- `uv run pytest tests/test_ica_plot_prepare.py`, related plotting tests (49 passed), and the
+  full `uv run pytest -m essential` merge gate (698 passed, 1 skipped, 2 xfailed, 1 xpassed, no
+  regressions) all green with `MPLBACKEND=Agg`.
+- `black --diff` / `flake8` on touched files: only pre-existing, unrelated findings (line-length
+  config mismatch); no new issues from this change.
+
+## Remaining work
+
+None.

cellpy-2.1.2a4/.issueflows/03-solved-issues/issue863_original.md

@@ -0,0 +1,35 @@
+# Issue #863: No collect_dva: DVA is single-cell only, unlike summaries/cycles/ICA
+
+Source: https://github.com/jepegit/cellpy/issues/863
+
+## Original issue text
+
+**cellpy version:** 2.1.2a3
+
+## Summary
+
+`cellpy.collect` exposes `collect_summaries`, `collect_cycles` and `collect_ica`, each returning a `Collection` that spans a batch of cells and plots through the collected path. **DVA has no equivalent** — `dva_plot(cell, ...)` takes a single cell, so differential voltage is the one analysis family that cannot be compared across cells.
+
+```python
+>>> import cellpy.collect as C
+>>> [hasattr(C, f"collect_{k}") for k in ("summaries", "cycles", "ica", "dva")]
+[True, True, True, False]
+```
+
+The `dva` plot family *is* registered (`registry.get("dva")` → `extras={'entry_point': 'dva_plot', 'kind': 'dva'}`), which makes the gap easy to trip over: the family shows up in the registry alongside `ica`, but there is no collector behind it.
+
+## Why it matters for apps
+
+We just added a DVA view to [cellpy-simple-gui](https://github.com/cellpy/cellpy-simple-gui) next to the existing ICA view. ICA gets the full collected treatment — multiple cells, grouping, group-averaging, the whole `Collection` API. DVA had to be wired as a one-cell-at-a-time special case straight onto `dva_plot`, which means:
+
+- no multi-cell DVA comparison, though that is exactly what you want when screening electrode formulations;
+- a second code path in the app, with its own export (`dva_plot(return_data=True)` returns pandas, while collections are polars);
+- the two sibling views behave differently for no reason the user can see.
+
+`ica.dvdq` already produces the tidy per-cell frame (`cycle`, `direction`, `capacity`, `voltage`, `dvdq`), so the missing piece looks like the collector wrapper rather than the analysis.
+
+## Wish
+
+A `collect_dva(batch, options=IcaOptions(...))` returning a `Collection` the same way `collect_ica` does — same `Collection.plot()` entry, same grouping/spread behaviour, same polars frame for export. That would let apps treat ICA and DVA as the two halves of one feature instead of two unrelated ones.
+
+Happy to help if useful.

cellpy-2.1.2a4/.issueflows/03-solved-issues/issue863_plan.md

@@ -0,0 +1,103 @@
+# Plan — Issue #863: No collect_dva (DVA is single-cell only)
+
+## Goal
+
+Add `cellpy.collect.collect_dva(batch, options=IcaOptions(...))` returning a `Collection`,
+mirroring `collect_ica`, so DVA gets the same multi-cell `Collection.plot()` / grouping /
+save / export treatment as summaries/cycles/ICA.
+
+## Constraints
+
+- Reuse the existing `cellpy.collect.options.IcaOptions` dataclass for both ICA and DVA (per
+  the issue's own proposed signature) rather than inventing a `DvaOptions` — add the one field
+  DVA actually needs (`capacity_resolution`) instead of a parallel dataclass.
+- Match `collect_ica`'s per-cell cycle-isolation behaviour exactly (cycles resolved from the
+  *originally requested* set every iteration — the legacy cross-cell narrowing bug,
+  collectors.py:1691 — must not regress for DVA either).
+- `Collection.plot()` must work out of the box for a DVA collection (`kind="dva"`) — currently
+  `Collection._FAMILY` has no `"dva"` entry (falls back to `"cycles"`, wrong columns) and
+  `render_collected` has no `family_kind == "dva"` branch (falls through to raw
+  `sequence_plotter` without ICA/DVA column defaults). Both must be wired, or `collect_dva(...).plot()`
+  breaks immediately — this is the same gap the issue calls out for the *plot family registry*
+  (`registry.get("dva")` already exists) vs the *collector*.
+- Correct resolution knob: `cellpy.ica.dqdv` differentiates along **voltage** (needs `voltage_resolution`
+  for the q(V) interpolation); `cellpy.ica.dvdq` differentiates along **capacity** (needs
+  `capacity_resolution` for the V(q) interpolation, per `cellpy.ica.IcaOptions` docstring +
+  `dvdq`'s own docstring: "differentiates the smoothed V(q) curve"). `collect_ica` forwards
+  `voltage_resolution`; `collect_dva` must forward `capacity_resolution`, not `voltage_resolution`.
+- Follow the existing one-file-per-collect-family convention (`cells.py`, `curves.py`, `ica.py`,
+  `summary.py`) — new `cellpy/collect/dva.py`, not a growing `ica.py`.
+- Keep the legacy `BatchCollector` convenience-wrapper parity too (`ica_collector` exists
+  alongside `collect_ica`) — add `dva_collector` for symmetry; it is a 5-line wrapper.
+
+### Prior art
+
+- `cellpy/collect/ica.py::collect_ica` — the function to mirror almost line-for-line: per-cell
+  `iter_cells` loop, per-cell cycle isolation via the *originally requested* tuple, `_as_polars`
+  conversion, `pl.concat(..., how="diagonal_relaxed")`, `opts.transforms` post-hooks,
+  `CollectionMeta(kind=..., options={...}, cells_included=...)`.
+- `cellpy/plotting/collected.py::ica_plotter` (wraps `_cycles_plotter` with
+  `x="voltage", y="dqdv", z="cycle", g="cell"`) — mirror as `dva_plotter` with
+  `x="capacity", y="dvdq"` (labels/units swapped: "Capacity"/"mAh/g" and "dV/dQ"/"V/(mAh/g)").
+  `_cycles_plotter` / `sequence_plotter` are already column-name-generic — no changes needed there.
+- `cellpy/collect/collection.py::Collection._FAMILY` and
+  `cellpy/plotting/collected.py::render_collected` — both need a `"dva"` branch/entry (see
+  Constraints above).
+- `cellpy/collect/collector.py::ica_collector` — mirror as `dva_collector`.
+- `tests/test_collectors.py::test_ica_collector_uses_the_specced_frame` /
+  `test_ica_collector_film_mode` / `test_ica_collector_fig_pr_cycle` — mirror for DVA in a new
+  `tests/test_collect_dva.py` (or add alongside in `test_collectors.py`; matches existing
+  `populated_batch` fixture reuse pattern).
+
+## Approach
+
+1. `cellpy/collect/options.py::IcaOptions` — add `capacity_resolution: float | None = None`
+   field (alongside existing `cycles`, `voltage_resolution`, `transforms`).
+2. New `cellpy/collect/dva.py::collect_dva(batch, options=None, **overrides) -> Collection`:
+   copy `collect_ica`'s structure, swap `ica.dqdv` → `ica.dvdq`, forward
+   `opts.capacity_resolution` (not `voltage_resolution`) into the per-cell call, `kind="dva"`,
+   `name=f"{batch.journal.name or 'batch'}_dva"`, `meta.options={"cycles": ..., "capacity_resolution": ...}`.
+3. `cellpy/collect/collector.py` — add `dva_collector(batch, options=None, *, autorun=True, **overrides)`
+   convenience wrapper bound to `collect_dva` (mirrors `ica_collector`).
+4. `cellpy/collect/__init__.py` — import/export `collect_dva`, `dva_collector`.
+5. `cellpy/collect/collection.py::Collection._FAMILY` — add `"dva": "dva"`.
+6. `cellpy/plotting/collected.py`:
+   - Add `dva_plotter(collected_curves, cycles_to_plot=None, backend="plotly", method="fig_pr_cell", direction="charge", **kwargs)`
+     mirroring `ica_plotter`, calling `_cycles_plotter(..., x="capacity", y="dvdq", z="cycle", g="cell", x_label="Capacity", x_unit="mAh/g", y_label="dV/dQ", y_unit="V/(mAh/g)", default_title="Differential Voltage Analysis Plots", ...)`.
+   - `render_collected`: add `if family_kind == "dva": return dva_plotter(frame, backend=backend, method=method, **opts)`.
+   - Update `collected_plot`'s docstring `family_kind` line to list `"dva"` too.
+7. **Tests** — new `tests/test_collect_dva.py` (reusing `populated_batch` from `tests/test_batch.py`,
+   same `pytest.importorskip("plotly")` guard as `test_collectors.py`):
+   - `collect_dva` produces the specced frame (`cycle`, `direction`, `capacity`, `voltage`, `dvdq`)
+     and `.plot()` renders a non-empty figure.
+   - `dva_collector` convenience wrapper runs end to end (mirrors `test_ica_collector_uses_the_specced_frame`).
+   - `capacity_resolution` reaches `ica.dvdq` (monkeypatch spy, mirrors
+     `test_collect_cycles_forwards_mode_and_method`), and that `voltage_resolution` is
+     **not** what gets forwarded (guards the resolution-knob mixup called out above).
+   - `Collection(kind="dva").plot()` picks the `dva` family (not the `cycles` fallback) —
+     regression guard for the `_FAMILY` wiring.
+
+## Files to touch
+
+- `cellpy/collect/options.py` — add `capacity_resolution` to `IcaOptions`.
+- `cellpy/collect/dva.py` — new, `collect_dva`.
+- `cellpy/collect/collector.py` — add `dva_collector`.
+- `cellpy/collect/__init__.py` — export both.
+- `cellpy/collect/collection.py` — `_FAMILY` entry.
+- `cellpy/plotting/collected.py` — `dva_plotter` + `render_collected` branch + docstring.
+- `tests/test_collect_dva.py` — new.
+- `HISTORY.md` (at `/iflow-close`).
+
+## Test strategy
+
+- `uv run pytest tests/test_collect_dva.py tests/test_collectors.py -v` (needs plotting extras;
+  both files already guard with `pytest.importorskip("plotly")`).
+- `MPLBACKEND=Agg uv run pytest -m essential` merge gate.
+- Mark new tests `@pytest.mark.essential` matching the existing collector test conventions (none
+  of `test_collectors.py`'s existing tests carry the marker today — check current state at build
+  time and follow whatever the file does, per the essential-tests-review step in `/iflow-close`).
+
+## Open questions
+
+None — the API shape, options reuse, and the two wiring gaps (`_FAMILY`, `render_collected`)
+were all resolved by reading the existing ICA collector/plotter pair end to end.

cellpy-2.1.2a4/.issueflows/03-solved-issues/issue863_status.md

@@ -0,0 +1,33 @@
+# Status — Issue #863
+
+- [x] Done
+
+## What's done
+
+- Investigated `collect_ica` / `ica_plotter` / `Collection._FAMILY` / `render_collected` end to
+  end to establish the mirror pattern for DVA.
+- Identified the resolution-knob subtlety: `dqdv` uses `voltage_resolution`, `dvdq` uses
+  `capacity_resolution`.
+- Plan written (`issue863_plan.md`), accepted.
+- `cellpy/collect/options.py::IcaOptions` — added `capacity_resolution` field (shared by ICA
+  and DVA, each forwarding only its own knob).
+- New `cellpy/collect/dva.py::collect_dva` — mirrors `collect_ica`, per-cell cycle isolation,
+  `kind="dva"`, forwards `capacity_resolution` to `ica.dvdq`.
+- `cellpy/collect/collector.py::dva_collector` convenience wrapper.
+- Exported `collect_dva` / `dva_collector` from `cellpy/collect/__init__.py`.
+- `cellpy/collect/collection.py::Collection._FAMILY["dva"] = "dva"`.
+- `cellpy/plotting/collected.py`: new `dva_plotter` (mirrors `ica_plotter`, x=capacity/y=dvdq),
+  wired into `render_collected`'s `family_kind == "dva"` branch, docstring updated.
+- New `tests/test_collect_dva.py` (5 tests): specced frame, `Collection.kind`, resolution-knob
+  regression guard (`capacity_resolution` reaches `dvdq`, not `voltage_resolution`), `_FAMILY`
+  wiring regression guard, `fig_pr_cycle` layout.
+- `uv run pytest tests/test_collect_dva.py` (5 passed), related collect/ICA/plotting tests
+  (70 passed), and the full `uv run pytest -m essential` merge gate (703 passed, 1 skipped,
+  2 xfailed, 1 xpassed — no regressions) all green with `MPLBACKEND=Agg`.
+- `black --diff` / `flake8` on touched/new files: only pre-existing, unrelated findings
+  (line-length config mismatch; fixture-shadowing F811 identical to `test_collectors.py`;
+  pre-existing unused `field` import in `options.py`); nothing new from this change.
+
+## Remaining work
+
+None.

{cellpy-2.1.2a3 → cellpy-2.1.2a4}/.issueflows/04-designs-and-guides/test-registry.md

@@ -47,6 +47,14 @@ current issue**. `/iflow-doctor` may audit the whole suite against this table.
 | tests/test_cli_light_import.py::test_setup_deps_probes_optional_modules | yes | yes | cli_api.setup_config --deps | #839 | opt-in optional probe |
 | tests/test_cellpy_file_v9.py::test_failed_resave_keeps_the_old_file | yes | yes | cellpy_file.atomic.atomic_write / v9.save / CellpyCell.save | #845 | data-loss guard: interrupted re-save must not destroy the old file |
 | tests/test_cellpy_file_v9.py::test_failed_first_save_leaves_no_file | yes | yes | cellpy_file.atomic.atomic_write / v9.save | #845 | no half-written archive on a fresh path |
+| tests/test_ica_plot_prepare.py::test_ica_dva_plotly_both_direction_dash_differs | yes | yes | plotting.backends.plotly._render_ica_dva | #862 | charge solid / discharge dot |
+| tests/test_ica_plot_prepare.py::test_ica_dva_plotly_single_direction_stays_solid | yes | yes | plotting.backends.plotly._render_ica_dva | #862 | single direction stays solid |
+| tests/test_ica_plot_prepare.py::test_ica_dva_matplotlib_both_direction_linestyle_differs | yes | yes | plotting.backends.mpl._render_ica_dva | #862 | "-" / ":" linestyle |
+| tests/test_collect_dva.py::test_dva_collector_uses_the_specced_frame | yes | yes | collect.dva.collect_dva | #863 | specced frame cols |
+| tests/test_collect_dva.py::test_collect_dva_returns_a_dva_collection | yes | yes | collect.dva.collect_dva | #863 | kind="dva" |
+| tests/test_collect_dva.py::test_collect_dva_forwards_capacity_resolution_not_voltage_resolution | yes | yes | collect.dva.collect_dva / ica.dvdq | #863 | resolution-knob guard |
+| tests/test_collect_dva.py::test_dva_collection_plot_uses_the_dva_family_not_cycles | yes | yes | collect.collection.Collection._FAMILY | #863 | family wiring guard |
+| tests/test_collect_dva.py::test_dva_collector_fig_pr_cycle | yes | yes | plotting.collected.dva_plotter | #863 | per-cycle layout |
 | tests/test_cellpy_file_v9.py::test_incomplete_archive_is_rejected_before_replace | yes | yes | v9._verify_members | #845 | missing zip member never replaces a good file |
 | tests/test_cellpy_file_v9.py::test_failed_hdf5_resave_keeps_the_old_file | no | no | cellpy_file.write.save (v8/HDF5) | #845 | same guard for the legacy writer; unmarked to keep Tier 1 fast |
 | tests/test_config.py::test_active_config_file_prefers_toml | yes | yes | config.loader.active_config_file | #851 | "which config am I using" must stay honest |

{cellpy-2.1.2a3 → cellpy-2.1.2a4}/HISTORY.md

@@ -17,6 +17,8 @@
 - Pretty-print cycles collector facet strips (Cycle N / cell label, not cycle_num=). (#820)
 - Honour share_y / match_axes on collected summary spread_plot. (#817)
 - ICA plotter: honour direction for line layouts; support direction='both'. (#821)
+- ``ica_plot`` / ``dva_plot``: dash discharge (dotted) vs charge (solid) when ``direction='both'`` so the two half-cycles stay distinguishable on a static export. (#862)
+- ``cellpy.collect.collect_dva``: multi-cell DVA collection (mirrors ``collect_ica``), returning a ``Collection`` with the same ``Collection.plot()`` / grouping / save entry points; ``dva_collector`` convenience wrapper. (#863)
 
 ## [2.1.1.post6] - 2026-08-02
 

{cellpy-2.1.2a3 → cellpy-2.1.2a4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cellpy
-Version: 2.1.2a3
+Version: 2.1.2a4
 Summary: Extract and manipulate data from battery data testers.
 Project-URL: Homepage, https://github.com/jepegit/cellpy
 Project-URL: Repository, https://github.com/jepegit/cellpy

{cellpy-2.1.2a3 → cellpy-2.1.2a4}/cellpy/collect/__init__.py

@@ -22,12 +22,14 @@ from cellpy.collect.collection import Collection, CollectionMeta, load_collectio
 from cellpy.collect.collector import (
     BatchCollector,
     cycles_collector,
+    dva_collector,
     ica_collector,
     normalize_column,
     standard_gravimetric,
     summary_collector,
 )
 from cellpy.collect.curves import collect_cycles
+from cellpy.collect.dva import collect_dva
 from cellpy.collect.ica import collect_ica
 from cellpy.collect.options import (
     CurveOptions,
@@ -44,6 +46,7 @@ __all__ = [
     "collect_summaries",
     "collect_cycles",
     "collect_ica",
+    "collect_dva",
     "from_cells",
     "iter_cells",
     "CellItem",
@@ -55,6 +58,7 @@ __all__ = [
     "summary_collector",
     "cycles_collector",
     "ica_collector",
+    "dva_collector",
     "standard_gravimetric",
     "normalize_column",
 ]

{cellpy-2.1.2a3 → cellpy-2.1.2a4}/cellpy/collect/collection.py

@@ -56,8 +56,8 @@ class Collection:
     name: str
     meta: CollectionMeta
 
-    #: collection kind -> ``collected_plot`` family (#657).
-    _FAMILY = {"summary": "summary", "cycles": "cycles", "ica": "ica"}
+    #: collection kind -> ``collected_plot`` family (#657, #863).
+    _FAMILY = {"summary": "summary", "cycles": "cycles", "ica": "ica", "dva": "dva"}
 
     @property
     def is_grouped(self) -> bool:

{cellpy-2.1.2a3 → cellpy-2.1.2a4}/cellpy/collect/collector.py

@@ -18,6 +18,7 @@ from typing import Any, Callable
 import polars as pl
 
 from cellpy.collect.curves import collect_cycles
+from cellpy.collect.dva import collect_dva
 from cellpy.collect.ica import collect_ica
 from cellpy.collect.options import CurveOptions, IcaOptions, SummaryOptions
 from cellpy.collect.summary import collect_summaries
@@ -117,6 +118,13 @@ def ica_collector(
     return BatchCollector(batch, collect_ica, options, autorun=autorun, **overrides)
 
 
+def dva_collector(
+    batch: Any, options: IcaOptions | None = None, *, autorun: bool = True, **overrides
+) -> BatchCollector:
+    """Convenience :class:`BatchCollector` bound to :func:`collect_dva`."""
+    return BatchCollector(batch, collect_dva, options, autorun=autorun, **overrides)
+
+
 def normalize_column(
     column: str, norm_factor: float, out: str | None = None
 ) -> Callable[[pl.DataFrame], pl.DataFrame]:

cellpy-2.1.2a4/cellpy/collect/dva.py

@@ -0,0 +1,95 @@
+"""dV/dQ (DVA) collection.
+
+Per-cell dV/dQ curves via :func:`cellpy.ica.dvdq`, concatenated into one tidy
+frame with ``cell`` / ``group`` / ``sub_group`` keys. Mirrors
+:func:`cellpy.collect.ica.collect_ica` -- including the per-cell cycle
+isolation that fixes the legacy cross-cell narrowing bug (collectors.py:1691)
+-- but emits the specced DVA frame: ``cycle, direction, capacity, voltage,
+dvdq`` (#863).
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import polars as pl
+
+from cellpy.collect.cells import iter_cells
+from cellpy.collect.collection import Collection, CollectionMeta
+from cellpy.collect.options import IcaOptions
+
+
+def _as_polars(frame: Any) -> pl.DataFrame | None:
+    if frame is None:
+        return None
+    if isinstance(frame, pl.DataFrame):
+        return frame
+    try:
+        return pl.from_pandas(frame)
+    except (TypeError, ValueError):
+        return None
+
+
+def collect_dva(
+    batch: Any, options: IcaOptions | None = None, **overrides
+) -> Collection:
+    """Collect dV/dQ (differential voltage) curves per cell into one Collection.
+
+    Cycle selection is derived per cell from the *originally requested* cycles
+    every iteration, so a cell missing a cycle never narrows the request for
+    the cells after it (mirrors :func:`cellpy.collect.collect_ica`).
+    """
+    from cellpy.utils import ica
+
+    opts = options or IcaOptions()
+    if overrides:
+        opts = opts.replace(**overrides)
+    requested = tuple(opts.cycles) if opts.cycles is not None else None
+
+    # dV/dQ differentiates along capacity (V(q) interpolation), unlike
+    # dQ/dV's voltage_resolution (q(V) interpolation).
+    dvdq_kwargs: dict[str, Any] = {}
+    if opts.capacity_resolution is not None:
+        dvdq_kwargs["capacity_resolution"] = opts.capacity_resolution
+
+    frames: list[pl.DataFrame] = []
+    for item in iter_cells(batch):
+        cell = item.cell
+        if requested is None:
+            cycles = None
+        else:
+            available = set(cell.get_cycle_numbers())
+            cycles = [c for c in requested if c in available]
+            if not cycles:
+                continue
+
+        curve = _as_polars(ica.dvdq(cell, cycles=cycles, **dvdq_kwargs))
+        if curve is None or curve.height == 0:
+            continue
+        frames.append(
+            curve.with_columns(
+                pl.lit(item.label).alias("cell"),
+                pl.lit(item.group).alias("group"),
+                pl.lit(item.sub_group).alias("sub_group"),
+            )
+        )
+
+    data = pl.concat(frames, how="diagonal_relaxed") if frames else pl.DataFrame()
+    for transform in opts.transforms:
+        data = transform(data)
+
+    meta = CollectionMeta(
+        kind="dva",
+        batch_name=batch.journal.name,
+        options={
+            "cycles": list(requested) if requested else None,
+            "capacity_resolution": opts.capacity_resolution,
+        },
+        cells_included=list(batch.cells),
+    )
+    return Collection(
+        data=data,
+        kind="dva",
+        name=f"{batch.journal.name or 'batch'}_dva",
+        meta=meta,
+    )

{cellpy-2.1.2a3 → cellpy-2.1.2a4}/cellpy/collect/options.py

@@ -97,10 +97,19 @@ class CurveOptions:
 
 @dataclass(frozen=True)
 class IcaOptions:
-    """Options for dQ/dV (ICA) collection."""
+    """Options for dQ/dV (ICA) and dV/dQ (DVA) collection.
+
+    Shared by :func:`cellpy.collect.collect_ica` and
+    :func:`cellpy.collect.collect_dva` -- each forwards only the resolution
+    knob its own transform actually uses: ``dqdv`` differentiates along
+    voltage (needs ``voltage_resolution`` for the q(V) interpolation);
+    ``dvdq`` differentiates along capacity (needs ``capacity_resolution`` for
+    the V(q) interpolation).
+    """
 
     cycles: tuple[int, ...] | None = None
     voltage_resolution: float | None = None
+    capacity_resolution: float | None = None
     transforms: tuple[Transform, ...] = ()
 
     def replace(self, **changes) -> "IcaOptions":