cellpy 2.1.2a2__tar.gz → 2.1.2a4__tar.gz

{cellpy-2.1.2a2 → cellpy-2.1.2a4}/.gitignore

@@ -24,6 +24,10 @@ tmp/
 #testdata/hdf5/20160306_snx001_10_cc_01.h5
 # testdata/batchfiles/cellpy_batch_test.json
 
+# Stray local leftovers (not essential-suite tmp_path output; do not commit) (#855)
+/cellpy_batch_test_batch.json
+/testdata/hdf5/20160805_test001_45_cc.cellpy
+
 dev_data/
 dev_data/tmp
 dev_data/bugfixing

cellpy-2.1.2a4/.issueflows/03-solved-issues/cycle_status_2026-08-09.md

@@ -0,0 +1,18 @@
+# Cycle status
+
+- queue: yolo 2.1.2 (resolved `label:yolo`, milestone `v.2.1.2`)
+- onfail: stop
+- started: 2026-08-09T12:17:00+02:00
+- finished: 2026-08-09
+- repo: jepegit/cellpy
+- stash: still on stash list as `iflow-cycle: untracked before yolo 2.1.2 batch` — restore with `git stash pop` if needed
+
+## Queue
+
+- [x] #846 — No selective summary rebuild after metadata edits — merged https://github.com/jepegit/cellpy/pull/856
+- [x] #849 — config: model_dump_for_file() plaintext Arbin SQL credentials — merged https://github.com/jepegit/cellpy/pull/857
+- [x] #850 — config: override() thread-safety — merged https://github.com/jepegit/cellpy/pull/858
+- [x] #853 — cellpy info --configloc project cellpy.toml — merged https://github.com/jepegit/cellpy/pull/859
+- [x] #855 — add test generated files to gitignore — merged https://github.com/jepegit/cellpy/pull/860
+
+- [x] Done

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

@@ -0,0 +1,51 @@
+# Issue #845: Non-atomic v9 .cellpy writes can corrupt (and destroy) the file on interrupt
+
+Source: https://github.com/jepegit/cellpy/issues/845
+
+## Original issue text
+
+## Problem
+The v9 writer saves straight onto the destination path:
+
+```python
+# cellpy/readers/cellpy_file/v9.py
+with zipfile.ZipFile(path, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
+    ...  # meta.json -> raw.parquet -> steps / summary / fid
+```
+
+Mode `"w"` truncates `path` **immediately**, then members are appended in
+order. An interrupt / kill / exception mid-write (common when parquet-serialising
+large raw tables) leaves a zip that still opens but is missing members:
+
+```
+cellpy.exceptions.CorruptCellpyFile: missing zip member 'raw.parquet'
+```
+
+Because the write is in place, this also **destroys the previously-good file** —
+a re-save that fails halfway loses the old data too.
+
+## How it surfaced
+Building cellpy-simple-gui, a project save (many `cell.save(..., overwrite=True)`)
+was interrupted. One `.cellpy` contained only `meta.json` (~1 KB); later cells
+were never written and the partially-written one no longer loaded. The app now
+stages the *project folder* atomically, but each individual `cell.save()` can
+still truncate a good `.cellpy` in place — the app can't protect a single file.
+
+## Suggested fix
+Write to a same-directory temp file, then atomically replace:
+
+```python
+tmp = path.with_suffix(path.suffix + ".tmp")
+with zipfile.ZipFile(tmp, "w", zipfile.ZIP_DEFLATED) as zf:
+    ...
+# optional: verify required members are present in tmp
+os.replace(tmp, path)   # atomic on the same filesystem
+```
+
+so a reader never sees a half-written archive and a failed save leaves the
+previous file intact. `v8`/older writers, if they share this pattern, would
+benefit too.
+
+
+---
+*Found while building [cellpy-simple-gui](https://github.com/cellpy/cellpy-simple-gui) on cellpy 2.1.1.post7. Context: [CELLPY_PAINPOINTS.md §19](https://github.com/cellpy/cellpy-simple-gui/blob/main/CELLPY_PAINPOINTS.md).*

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

@@ -0,0 +1,124 @@
+# Issue #845 — plan: atomic `.cellpy` / `.h5` writes
+
+Source: https://github.com/jepegit/cellpy/issues/845
+Milestone: v.2.1.2 · Labels: bug, v2
+
+## Goal
+
+A failed or interrupted `CellpyCell.save()` must never leave a half-written
+cellpy-file, and must never destroy the previously-good file. Writers stage into
+a same-directory temp file and `os.replace()` it into place only after the
+archive is complete.
+
+## Constraints
+
+- **Two destructive spots, not one.** Besides the non-atomic zip write in
+  `v9.save`, `CellpyCell.save` already `os.remove(...)`s the destination
+  *before* calling the writer
+  ([`cellreader.py:1663-1676`](../../cellpy/readers/cellreader.py)). Fixing only
+  the writer still loses the old file on failure — the pre-delete must go.
+- **Dropping the pre-delete forces the v8/HDF5 path in too.** `write.save` opens
+  `pandas.HDFStore(path)` in default mode `"a"`; without the pre-delete it would
+  *append into* an existing file instead of replacing it. So v8 must become
+  atomic in the same change — not scope creep, a correctness consequence.
+- Keep `overwrite=False` semantics: existing file → refuse and return (no write).
+- Keep the legacy locked-file UX: a `PermissionError` on a locked destination
+  logs critical and returns rather than raising out of `save()`.
+- Remote save is already rejected upstream (`outfile_all.is_external` →
+  `ValueError`), so writers only ever see local paths. `OtherPath` implements
+  `__fspath__`, so `Path(outfile_all)` is safe.
+- Same filesystem required for atomicity — temp file goes in the **destination's
+  own directory**, never `TMPDIR`.
+- Cross-platform: `os.replace` is atomic on POSIX and overwrites on Windows, but
+  raises `PermissionError` if the destination is open in another process.
+
+### Prior art
+
+- `.issueflows/00-tools/` (README index) — nothing about file IO; no reuse.
+- Grep `os.replace` / `atomic` / `.tmp` across `cellpy/` — **no existing atomic
+  write helper**; this is the first one.
+- `cellpy/readers/cellpy_file/v9.py` `save` — the writer to wrap.
+- `cellpy/readers/cellpy_file/write.py` `save` — v8/HDF5 writer, same pattern.
+- `cellpy/internals/otherpath.py` `OtherPath` — provides `__fspath__`,
+  `with_name`, `is_file`; no staging/replace logic to mirror.
+- graphify: `graphify-out/` present but not consulted for this narrow IO fix.
+
+## Approach
+
+1. **New helper** `cellpy/readers/cellpy_file/atomic.py` — one context manager:
+
+   ```python
+   @contextlib.contextmanager
+   def atomic_write(path, *, verify=None):
+       """Yield a same-dir temp path; os.replace() it onto `path` on success."""
+   ```
+
+   - temp name `f"{path.name}.tmp{os.getpid()}"` in `path.parent`, removed first
+     if a stale one exists (so the writer, not the helper, creates the file —
+     `HDFStore` and `ZipFile` both want to create it themselves);
+   - `path.parent.mkdir(parents=True, exist_ok=True)` before yielding;
+   - on exception inside the block: unlink the temp, re-raise (destination
+     untouched);
+   - on success: run `verify(tmp)` if given, then `os.replace(tmp, path)`;
+   - if `os.replace` itself fails (locked destination on Windows): **keep** the
+     temp file, log critical with its path so the data is recoverable, re-raise.
+
+2. **`v9.save`** — wrap the `zipfile.ZipFile(...)` block in `atomic_write`, and
+   pass a `verify` that reopens the temp zip and asserts the required members
+   (`meta.json`, `raw/steps/summary.parquet`, plus `fid.parquet` when written)
+   are in `namelist()`. Cheap (central-directory read only, no `testzip()`
+   decompression of the whole raw table).
+
+3. **`write.save` (v8/HDF5)** — same wrap; `HDFStore(tmp, mode="w", …)`. No
+   member verification (would mean reopening the store).
+
+4. **`CellpyCell.save`** — the `outfile_all.is_file()` branch keeps the
+   `overwrite=False` refusal but **stops deleting** the file when
+   `overwrite=True`; the writers now replace it. Wrap the two writer calls so a
+   `PermissionError` still logs critical + returns instead of propagating.
+
+## Files to touch
+
+| Path | Change |
+|---|---|
+| `cellpy/readers/cellpy_file/atomic.py` | **new** — `atomic_write` context manager (~40 lines incl. docstring) |
+| `cellpy/readers/cellpy_file/v9.py` | `save` writes through `atomic_write` + member verification |
+| `cellpy/readers/cellpy_file/write.py` | `save` writes through `atomic_write`, `HDFStore(tmp, mode="w")` |
+| `cellpy/readers/cellreader.py` | drop pre-write `os.remove`; keep overwrite refusal; `PermissionError` guard around writer calls |
+| `tests/test_cellpy_file_v9.py` | new interrupt/atomicity tests (`@pytest.mark.essential`) |
+| `HISTORY.md` | changelog entry at `/iflow-close` |
+
+## Test strategy
+
+Command: `conda activate cellpy_dev_313 && pytest` (project rule); merge gate is
+`pytest -m essential`. Targeted runs:
+`pytest tests/test_cellpy_file_v9.py tests/test_cellpy_file_roundtrip.py -m ""`.
+
+New tests (fault injection by monkeypatching
+`v9._frame_to_parquet_bytes` to raise on the summary frame, i.e. after
+`meta.json` + `raw.parquet` are already inside the temp zip):
+
+1. **Old file survives a failed re-save** — save a good `.cellpy`, snapshot it,
+   make the second `save(..., overwrite=True)` blow up, then assert the file
+   still loads with identical frames.
+2. **No debris** — after that failure, no `*.tmp*` left in the directory.
+3. **Failed first save leaves no file** — a fresh destination that fails
+   mid-write must not exist afterwards (no more "opens but missing
+   `raw.parquet`" `CorruptCellpyFile`).
+4. **Member verification** — an incomplete-but-successful zip (patch the writer
+   to skip `summary.parquet`) is rejected before `os.replace`, leaving the old
+   file intact.
+5. **HDF5 path** — same "old file survives" check for
+   `cellpy_file_format="hdf5"`, skipped when HDF5 support is unavailable.
+
+Marker: `essential` for 1–3 (data-loss guard, cheap); 4–5 plain.
+
+## Open questions
+
+1. **Keep or discard the staged temp file when `os.replace` fails?** Plan keeps
+   it + logs critical (recoverable data, small debris risk on a locked file).
+   Alternative: always unlink for a spotless directory.
+2. **v8/HDF5 in this PR?** Plan says yes — required once the pre-delete is
+   dropped. Splitting it out would mean keeping a v8-only pre-delete branch.
+3. **Other writers out of scope** (`to_csv`, batch journal JSON, exporters) —
+   confirm they stay for a follow-up issue.

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

@@ -0,0 +1,49 @@
+# Issue #845 — status
+
+Branch: `845-atomic-cellpy-writes`
+
+- [x] Done
+
+## What's done
+
+- **`cellpy/readers/cellpy_file/atomic.py`** (new) — `atomic_write(path,
+  verify=...)` context manager: stages `<name>.tmp<pid>` in the destination's own
+  directory (same filesystem, so `os.replace` stays atomic), unlinks the staged
+  file if the write raises, and runs an optional `verify` before replacing.
+  Per the confirmed decision, a failing `os.replace` (locked destination on
+  Windows) **keeps** the staged file and logs critical with its path.
+- **`v9.save`** — writes the zip through `atomic_write` and verifies the staged
+  archive holds every required member (`meta.json`, raw/steps/summary parquet,
+  plus `fid.parquet` when written) from the central directory only, so an
+  incomplete-but-openable zip is rejected before it can replace a good file.
+- **`write.save` (v8/HDF5)** — same staging, `HDFStore(staged, mode="w")`.
+- **`CellpyCell.save`** — dropped the pre-write `os.remove` that destroyed the
+  old file before the writer even started; kept the `overwrite=False` refusal and
+  the locked-file "log critical + return" UX (now via `PermissionError` around
+  the writer calls). Docstring documents the atomicity guarantee.
+- **Docs** — `docs/getting_started/agents.md` notes that `save` is atomic, so
+  app builders (this came from cellpy-simple-gui) don't need per-file staging.
+- **Tests** (`tests/test_cellpy_file_v9.py`, 4 new): failed re-save keeps the old
+  file bit-for-bit + reloads; failed first save leaves no file; incomplete
+  archive rejected before replace; HDF5 re-save keeps the old file. First three
+  marked `essential`. Verified they **fail on the pre-fix code** and pass after.
+
+## Test results
+
+- `uv run pytest tests/test_cellpy_file_v9.py -m ""` → 7 passed.
+- `uv run pytest -m essential` (merge gate) → 679 passed, 1 skipped.
+- Full default suite → 1525 passed, 3 failed: `test_search_for_files`,
+  `test_search_for_files_with_dirs`, `test_search_for_files_recursive` —
+  **pre-existing**, reproduced on the stashed baseline. Same for the three
+  `slowtest` `cellpy new` cookiecutter failures seen with `-m ""`.
+- Note: the conda env `cellpy_dev_313` has a broken `pyarrow` DLL
+  (`ImportError: DLL load failed while importing lib`), so tests were run through
+  `uv run` / `.venv` instead. Unrelated to this issue, but worth repairing.
+- `flake8`/`black` findings on the touched files are the repo's pre-existing
+  E501-at-79 and F401 noise; the new module is black-clean.
+
+## Remaining work
+
+- `HISTORY.md` changelog bullet — owned by `/iflow-close`.
+- Out of scope (candidates for a follow-up issue): other writers that still
+  write in place (`to_csv`, batch journal JSON, exporters).

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

@@ -0,0 +1,36 @@
+# Issue #846: No selective summary rebuild after metadata edits (mass/area/nom-cap/cycle mode)
+
+Source: https://github.com/jepegit/cellpy/issues/846
+
+## Original issue text
+
+## Problem
+Editing physical metadata after load — mass, active electrode area, nominal
+capacity, cycle mode — requires a **full** `cell.make_summary()`. There's no
+public API to rebuild only the dependent summary columns (e.g. gravimetric
+capacities after a mass change, C-rates after a nominal-capacity change).
+
+There's also no documented **meta → summary-column dependency map**, so an app
+can't do targeted updates or tell the user precisely what a change will affect.
+
+## How it surfaced
+cellpy-simple-gui's "Manage Cells" lets users change these knobs post-load. The
+app assigns `cell.mass` / `cell.active_electrode_area` / `cell.nominal_capacity`
+/ `cell.cycle_mode` and then always calls the full `make_summary()`. Correct,
+but opaque and potentially expensive for large cells, and easy to get subtly
+wrong (which attribute invalidates which column?).
+
+## Suggested fix (either is useful)
+1. Cheap selective-refresh helpers keyed by meta field, e.g.
+   `cell.refresh_after(("mass",))` that recomputes just the affected columns; or
+2. A small documented dependency map / note ("`nominal_capacity` affects
+   `charge_c_rate`, `discharge_c_rate`, normalized cycle index; `mass` affects
+   `*_gravimetric`; `area` affects `*_areal`; …") so GUIs can scope rebuilds
+   and messaging.
+
+Dedicated setters (vs bare attribute assignment) would also help
+discoverability of "what do I call after changing mass?".
+
+
+---
+*Found while building [cellpy-simple-gui](https://github.com/cellpy/cellpy-simple-gui) on cellpy 2.1.1.post7. Context: [CELLPY_PAINPOINTS.md §19](https://github.com/cellpy/cellpy-simple-gui/blob/main/CELLPY_PAINPOINTS.md).*

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

@@ -0,0 +1,54 @@
+# Plan: #846 selective summary rebuild after metadata edits
+
+## Goal
+
+Give apps (e.g. cellpy-simple-gui) a public meta→summary dependency map and a
+`refresh_after(...)` helper so post-load mass/area/nom-cap/cycle-mode edits
+do not require an opaque full `make_summary()` when a summary already exists.
+
+## Constraints
+
+- Yolo-sized: no new selective column engine; reuse existing
+  `core.add_scaled_summary_columns` seam already used by `_make_summary`.
+- Document **current** behaviour accurately: C-rate columns come from the step
+  table and are **not** derived from `nominal_capacity` (core comment).
+- Keep setters as assignment; point them at `refresh_after` in docstrings.
+- Do not change default `make_summary` behaviour.
+
+### Prior art
+
+- `_make_summary` → `core.make_core_summary` + `core.add_scaled_summary_columns`
+  (`cellpy/readers/cellreader.py`) — scaled path is already the meta-dependent half.
+- `cellpycore.summarizers.generate_specific_summary_columns` /
+  `equivalent_cycles_to_summary` — overwrite via `with_columns` (safe re-run).
+- Toolbox: none relevant.
+
+## Approach
+
+1. Add module-level `SUMMARY_META_DEPENDENCIES` (and alias map) describing what
+   each meta field invalidates / affects.
+2. Add `CellpyCell.refresh_after(fields, **kwargs)`:
+   - normalize field names (`mass`/`active_mass`, `area`/`active_electrode_area`,
+     `nom_cap`/`nominal_capacity`, `cycle_mode`);
+   - if no summary → `make_summary(**kwargs)`;
+   - else recompute `nom_cap_abs` + specific conversion factors and call
+     `core.add_scaled_summary_columns` in place (no `make_core_summary`).
+3. Docstring notes on mass / area / nom_cap / cycle_mode setters.
+4. One paragraph in `docs/getting_started/agents.md`.
+5. Unit tests for map keys + mass change updates gravimetric columns without
+   requiring a full rebuild path assertion.
+
+## Files to touch
+
+- `cellpy/readers/cellreader.py` — map + `refresh_after` + setter docs
+- `docs/getting_started/agents.md` — short usage note
+- `tests/test_refresh_after_meta.py` — new focused tests
+- `.issueflows/01-current-issues/issue846_{plan,status}.md`
+
+## Test strategy
+
+`uv run pytest tests/test_refresh_after_meta.py -q` then `uv run pytest -m essential -q`.
+
+## Open questions
+
+None — batch cycle confirm covers Accept.

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

@@ -0,0 +1,13 @@
+# Status: #846
+
+- [x] Done
+
+## What's done
+
+- `SUMMARY_META_DEPENDENCIES` + `normalize_summary_meta_fields`
+- `CellpyCell.refresh_after` / `_refresh_scaled_summary_columns`
+- Setter docs; agents.md note; tests (1 essential); HISTORY bullet
+
+## Remaining work
+
+None.

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

@@ -0,0 +1,65 @@
+# Issue #849: config: model_dump_for_file() writes legacy Arbin SQL credentials in plaintext
+
+Source: https://github.com/jepegit/cellpy/issues/849
+
+## Original issue text
+
+**cellpy version:** 2.1.2a2
+
+## Summary
+
+`CellpyConfig.model_dump_for_file()` is documented as *"Dump config suitable for TOML persistence (secrets excluded)"*, and it does drop the `[secrets]` section. But `ArbinConfig` (and the other instrument models) are `model_config = ConfigDict(extra="allow")`, so the **legacy** Arbin SQL credentials — `SQL_PWD`, `SQL_UID` — pass straight through and get written to `cellpy.toml` in plaintext.
+
+The asymmetry is the dangerous part: a hand-written `[secrets]` block is correctly rejected on load, but the same credential smuggled in under `[instruments.Arbin]` is written **and** silently accepted on reload.
+
+## Reproduction
+
+```python
+import tempfile
+from pathlib import Path
+from cellpy.config.models import CellpyConfig
+from cellpy.config.loader import write_toml, load_config, LoadOptions
+
+tmp = Path(tempfile.mkdtemp())
+toml_path = tmp / "cellpy.toml"
+
+cfg = CellpyConfig.model_validate(
+    {"instruments": {"Arbin": {"SQL_PWD": "hunter2", "SQL_UID": "jepe"}}}
+)
+
+write_toml(toml_path, cfg.model_dump_for_file())      # the "secrets excluded" dump
+print("hunter2" in toml_path.read_text())             # -> True
+
+res = load_config(None, LoadOptions(user_config_file=toml_path, skip_env=True))
+print(res.config.instruments.Arbin.SQL_PWD)           # -> hunter2   (no error)
+```
+
+Output:
+
+```
+written TOML contains plaintext password: True
+['SQL_PWD = "hunter2"', 'SQL_UID = "jepe"']
+reload accepted the file (no ConfigurationError)
+value round-tripped: hunter2
+[secrets] correctly rejected: ConfigurationError
+```
+
+## Why this bites app developers
+
+This is on the realistic migration path, not a contrived one:
+
+1. A user has a legacy `.cellpy_prms_*.conf` with a real `Instruments.Arbin.SQL_PWD`.
+2. The legacy loader merges it (`_drop_legacy_secrets` only pops the top-level `secrets` key, so `instruments.Arbin.SQL_PWD` survives).
+3. Any app offering a **Settings → Save** button calls the documented secrets-safe dump…
+4. …and writes the user's database password to `%LOCALAPPDATA%\cellpy\cellpy\cellpy.toml` — a file they'd reasonably share, sync, or commit alongside a project.
+
+We hit this while designing a settings UI for [cellpy-simple-gui](https://github.com/cellpy/cellpy-simple-gui); we now have to scrub `instruments.*.SQL_*` ourselves before writing, which is exactly the kind of thing the `model_dump_for_file()` contract should be handling.
+
+## Suggested fixes (any one would do)
+
+- **Map on legacy load** — translate `Instruments.Arbin.SQL_PWD`/`SQL_UID`/`SQL_server` into the `secrets` section during YAML migration, so they land in the one place that already knows they're credentials.
+- **Scrub on dump** — strip known credential-ish keys (`*PWD*`, `*UID*`, `*password*`) from instrument sections in `model_dump_for_file()`.
+- **Type them** — declare `SQL_PWD` on `ArbinConfig` as `SecretStr | None` with `exclude=True` rather than letting it ride in on `extra="allow"`.
+- **Symmetric guard** — have `_reject_secrets_from_file` (or a warning) also catch credential keys in instrument sections, so a file that does contain one is not silently honoured.
+
+Happy to send a PR if you have a preference on which route.

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

@@ -0,0 +1,46 @@
+# Plan: #849 scrub instrument credentials from file dump
+
+## Goal
+
+Honour `model_dump_for_file()` contract: never write legacy Arbin `SQL_PWD` /
+`SQL_UID` (or other credential-ish instrument keys) to `cellpy.toml`, and stop
+silently accepting them on TOML load.
+
+## Constraints
+
+- Env-only secrets stay the rule (existing `[secrets]` rejection).
+- Legacy YAML migration: drop instrument credential keys with a warning (do
+  not strand users), same spirit as `_drop_legacy_secrets`.
+- KISS: scrub/reject known keys; do not redesign `ArbinConfig` as SecretStr in
+  this issue.
+
+### Prior art
+
+- `CellpyConfig.model_dump_for_file` — pops `[secrets]` only today.
+- `_reject_secrets_from_file` / `_drop_legacy_secrets` in `loader.py`.
+- `tests/test_config_secrets.py` — essential suite for this contract.
+
+## Approach
+
+1. Shared helper listing credential-ish instrument keys (`SQL_PWD`, `SQL_UID`,
+   `*PASSWORD*`, `*_PWD` / `PWD` suffixes).
+2. `model_dump_for_file`: deep-scrub instruments before return.
+3. TOML load: reject those keys with `ConfigurationError` (symmetric to
+   `[secrets]`).
+4. Legacy YAML: pop + warn.
+5. Extend `test_config_secrets.py` with the issue reproduction.
+
+## Files to touch
+
+- `cellpy/config/models.py` — scrub in dump
+- `cellpy/config/loader.py` — reject / drop on load
+- `tests/test_config_secrets.py` — new essential cases
+- issue tracking + HISTORY
+
+## Test strategy
+
+`uv run pytest tests/test_config_secrets.py -q` then `uv run pytest -m essential -q`.
+
+## Open questions
+
+None.

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

@@ -0,0 +1,13 @@
+# Status: #849
+
+- [x] Done
+
+## What's done
+
+- Scrub instrument credential keys in `model_dump_for_file`
+- Reject those keys on TOML load; drop+warn on legacy YAML
+- Essential tests + HISTORY
+
+## Remaining work
+
+None.

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

@@ -0,0 +1,53 @@
+# Issue #850: config: override() is process-global and not thread-safe (cross-talk in threaded apps)
+
+Source: https://github.com/jepegit/cellpy/issues/850
+
+## Original issue text
+
+**cellpy version:** 2.1.2a2
+
+## Summary
+
+`cellpy.config.override()` reads as a scoped, reentrant context manager, but it mutates a module-level `_override_stack` and swaps the global `_session` via `reload()`. In a threaded application, one thread's "scoped" override is visible to every other thread, and the `finally: pop + reload` can land while another thread is still inside its own block.
+
+## Reproduction
+
+```python
+import time
+from concurrent.futures import ThreadPoolExecutor
+from cellpy import config
+
+def worker(mode):
+    with config.override(reader={"cycle_mode": mode}):
+        time.sleep(0.05)                       # let the two blocks interleave
+        return mode, config.get_config().reader.cycle_mode
+
+with ThreadPoolExecutor(max_workers=2) as ex:
+    print(list(ex.map(worker, ["anode", "cathode"])))
+```
+
+Result:
+
+```
+[('anode', 'anode'), ('cathode', 'anode')]
+```
+
+The `cathode` worker observes `anode` **inside its own `override()` block**. Each worker should see the value it asked for.
+
+## Why this bites app developers
+
+Any GUI/service that runs cellpy work off the request thread hits this. In [cellpy-simple-gui](https://github.com/cellpy/cellpy-simple-gui) loads/exports run in a `ThreadPoolExecutor`, so the natural pattern — "override `reader.cycle_mode` / `units` for *this* job" — is quietly racy: two concurrent jobs can silently compute with each other's settings, and the result is wrong numbers rather than an exception. That failure mode is much worse than a crash, because nothing signals it.
+
+Our workaround is to resolve config on the main thread and pass concrete values into the job, and to treat `override()` as main-thread-only. That works, but it means the config stack can't be used for per-job policy at all.
+
+## Suggested fix
+
+Back the override stack (and ideally the session) with a **`contextvars.ContextVar`** rather than a module global:
+
+- `ContextVar` isolation is per-thread *and* per-async-task, so it fixes threaded apps and any future async usage in one move.
+- `copy_context()` semantics also make the intent ("scoped to this unit of work") actually true.
+- Worth pairing with a note in the configuration docs about which parts of the stack are process-global (`reload`, `set_load_options`) versus scoped.
+
+If a full `ContextVar` migration is too invasive for a patch release, an interim step would be documenting `override()` as process-global/not thread-safe and adding a `threading.RLock` around the stack mutation + reload, so at least the stack cannot be corrupted.
+
+Happy to send a PR if you'd like the `ContextVar` version.

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

@@ -0,0 +1,44 @@
+# Plan: #850 thread-safe config.override via ContextVar
+
+## Goal
+
+Make `config.override()` scoped per thread / async task so concurrent jobs
+cannot observe each other's overrides.
+
+## Constraints
+
+- Keep nested LIFO stacking and existing tests in `tests/test_config.py`.
+- `reload` / `set_load_options` stay process-global (document in docstring).
+- Yolo-sized: ContextVar for override stack + active config; do not
+  ContextVar-migrate the whole session.
+
+### Prior art
+
+- `cellpy/config/session.py` — `_override_stack` + `reload()` swap global `_session`.
+- `tests/test_config.py` — nested override + essential fixture.
+
+## Approach
+
+1. Replace module `_override_stack` with `ContextVar` tuple stack +
+   `ContextVar` for the active overridden `CellpyConfig`.
+2. `get_config()` returns context config when set, else session config.
+3. `override()` pushes stack, builds config via deep-merge on
+   `session.config.model_dump()` + `CellpyConfig.model_validate`, yields it;
+   no global `_session` swap.
+4. `reload()` rebuilds global session **without** applying the override stack;
+   if currently inside an override, refresh the context-local config.
+5. Threaded regression test matching the issue reproduction.
+
+## Files to touch
+
+- `cellpy/config/session.py`
+- `tests/test_config.py`
+- HISTORY + issue tracking
+
+## Test strategy
+
+`uv run pytest tests/test_config.py -q` then `uv run pytest -m essential -q`.
+
+## Open questions
+
+None.

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

@@ -0,0 +1,13 @@
+# Status: #850
+
+- [x] Done
+
+## What's done
+
+- ContextVar override stack + context-local config
+- Thread isolation essential test
+- HISTORY
+
+## Remaining work
+
+None.

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

@@ -0,0 +1,52 @@
+# Issue #851: cellpy info / edit config / info --check still point at the legacy .conf after migration
+
+Source: https://github.com/jepegit/cellpy/issues/851
+
+## Original issue text
+
+## Problem / context
+
+After `cellpy setup migrate` writes `cellpy.toml`, the config *loader* correctly prefers it — `load_config` only falls back to the legacy YAML when no TOML was loaded (`cellpy/config/loader.py:203-213`). But the CLI still reports and edits the old file:
+
+```
+❯ cellpy setup migrate
+[cellpy] (setup migrate) source: C:\Users\jepe\.cellpy_prms_jepe.conf
+[cellpy] (setup migrate) target: C:\Users\jepe\AppData\Local\cellpy\cellpy\cellpy.toml
+[cellpy] (setup migrate) done - the old file is kept untouched.
+
+❯ cellpy info
+[cellpy] version: 2.1.1.post8.dev1+fad801ac
+[cellpy] -> C:\Users\jepe\.cellpy_prms_jepe.conf     # ← stale, nothing reads this
+```
+
+Root cause: `_configloc()` (`cellpy/cli_api.py:1276`) calls `prmreader.get_user_dir_and_dst()`, which composes `~/.cellpy_prms_<user>.conf` unconditionally and never consults `cellpy.config.loader.user_config_path()`.
+
+Three surfaces are affected, and two are worse than a wrong printout:
+
+- **`cellpy info` / `cellpy info --configloc`** — names a file that no longer has any effect.
+- **`cellpy edit config`** (`cli_api.py:1876`) — opens the stale `.conf`, so the user edits a file that is silently ignored. Most damaging: the edit appears to succeed and changes nothing.
+- **`cellpy info --check`** (`_check_config_file`, `cli_api.py:999-1011`) — validates the stale YAML via `_read_prm_file_without_updating`, so it checks paths the runtime is not using.
+
+`cellpy info --show-config` is already correct — it goes through `config.get_config()` with provenance (`_dump_config_resolved`, `cli_api.py:1223`).
+
+## Spec
+
+- Resolve the *active* config file with the same precedence as `load_config`: user `cellpy.toml` → legacy `.conf` → none. Put this in one helper (e.g. `cellpy.config.loader.active_config_file()`) so the CLI and the loader cannot drift apart again.
+- `_configloc()` reports that file. When a legacy `.conf` exists but is shadowed by a TOML, say so explicitly, e.g.
+  `[cellpy] (legacy C:\Users\jepe\.cellpy_prms_jepe.conf is ignored — cellpy.toml takes precedence)`.
+- `cellpy edit config` opens the active file.
+- `_check_config_file` validates the active file; for a TOML, check it through the config models rather than the YAML reader.
+
+## Acceptance criteria
+
+- With a `cellpy.toml` present, `cellpy info` prints the TOML path and mentions the shadowed legacy file when one exists.
+- With no TOML, output is unchanged from today (legacy path).
+- `cellpy edit config` opens the TOML when it exists.
+- `cellpy info --check` passes/fails based on the TOML's paths, not the legacy YAML's.
+- Tests cover all three states: TOML only, legacy only, both (TOML wins + shadow notice). Marked `essential` — this is the "which config am I actually using" question and it must stay honest.
+
+## Out of scope
+
+- Changing precedence itself, or deprecating/deleting the legacy `.conf`.
+- `cellpy setup migrate` behaviour (it works correctly).
+- Project-level `cellpy.toml` discovery (`find_project_config_file`) — worth a follow-up, since a project file also outranks the user file and `info` will not mention it either.