rosetta-eclab 0.1.2__tar.gz → 0.1.4__tar.gz

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosetta-eclab
-Version: 0.1.2
+Version: 0.1.4
 Summary: Name the columns of BioLogic EC-Lab .mpr files that your parser does not know - no language model, evidence for every answer
 Author: Nataniel Ataseven
 License-Expression: GPL-3.0-or-later
@@ -18,9 +18,9 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=2.0
 Requires-Dist: yadg==7.0.1
-Requires-Dist: galvani==0.5.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Requires-Dist: galvani==0.5.0; extra == "test"
 Dynamic: license-file
 
 # Rosetta
@@ -52,6 +52,8 @@ Python 3.10 or later:
 pip install rosetta-eclab
 ```
 
+Rosetta does not install galvani. If galvani or datalab-org-galvani is installed, "unknown to galvani" means unknown to the galvani you actually have. Without either, Rosetta uses a frozen copy of galvani 0.5.0's column map and says so. The names Rosetta gives never depend on which galvani is installed.
+
 To run the tests or reproduce the benchmark, clone the repository instead:
 
 ```sh
@@ -96,7 +98,7 @@ peis.issue_225.with_ece.mpr
   every column ID is in galvani's column map; nothing to name
 ```
 
-The fix was released in datalab-org-galvani 0.6.0 ([galvani-mirror#11](https://github.com/datalab-org/galvani-mirror/issues/11)). IDs that are missing from the map altogether, such as 880 or 883 and 884, are what Rosetta names.
+The fix was released in datalab-org-galvani 0.6.0 ([galvani-mirror#11](https://github.com/datalab-org/galvani-mirror/issues/11)). Rosetta prints the note only when the installed galvani reads the low byte. IDs that are missing from the map altogether, such as 880 or 883 and 884, are what Rosetta names.
 
 ## How it works
 
@@ -137,7 +139,7 @@ The namer improved between hold-outs, so the total includes earlier versions. Th
 - **Values EC-Lab computes after the fact** cannot be reconstructed reliably. For example, a capacitance is held per segment.
 - **Noise-like DC currents** in impedance records, and **external analog inputs** with no sibling column, usually get ABSTAIN.
 - **Two quantities with the same definition in a file** cannot be told apart from the data. In galvanostatic cycling, for example, `dQ` and `Q charge or discharge` reset at the same points. A prior over how common each name is for the technique decides between them, and the alternative is shown.
-- **Supported formats:** EC-Lab data-module versions 2, 3, 10 and 11. Very old files (version 0) are not supported yet.
+- **Supported formats:** EC-Lab data-module versions 0, 2, 3, 10 and 11. Version 0 (older EC-Lab) is read with galvani's offsets, because yadg does not read it. All 59 public version-0 files decode byte for byte like galvani 0.5.0, and the two with an EC-Lab text export match it. The file technique is not read from version-0 files, so the namer works without it.
 
 ## Reproduce the benchmark
 
@@ -155,4 +157,4 @@ pytest tests
 
 ## Data and licence
 
-Rosetta is free software under the **GNU General Public License v3.0 or later** (see `LICENSE`). It uses [yadg](https://github.com/dgbowl/yadg) and [galvani](https://github.com/echemdata/galvani), both GPL. Measurement files are downloaded at run time and never committed. Sources, licences and attributions are listed in [`DATA_SOURCES.md`](https://github.com/Nataniel0212/rosetta-eclab/blob/main/DATA_SOURCES.md). Rosetta is not affiliated with BioLogic.
+Rosetta is free software under the **GNU General Public License v3.0 or later** (see `LICENSE`). It uses [yadg](https://github.com/dgbowl/yadg) (GPL), and `spike2/galvani_0.5.0_colmap.json` is a copy of the column map of [galvani](https://github.com/echemdata/galvani) 0.5.0 (GPL-3.0-or-later). Measurement files are downloaded at run time and never committed. Sources, licences and attributions are listed in [`DATA_SOURCES.md`](https://github.com/Nataniel0212/rosetta-eclab/blob/main/DATA_SOURCES.md). Rosetta is not affiliated with BioLogic.

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.4}/README.md

@@ -27,6 +27,8 @@ Python 3.10 or later:
 pip install rosetta-eclab
 ```
 
+Rosetta does not install galvani. If galvani or datalab-org-galvani is installed, "unknown to galvani" means unknown to the galvani you actually have. Without either, Rosetta uses a frozen copy of galvani 0.5.0's column map and says so. The names Rosetta gives never depend on which galvani is installed.
+
 To run the tests or reproduce the benchmark, clone the repository instead:
 
 ```sh
@@ -71,7 +73,7 @@ peis.issue_225.with_ece.mpr
   every column ID is in galvani's column map; nothing to name
 ```
 
-The fix was released in datalab-org-galvani 0.6.0 ([galvani-mirror#11](https://github.com/datalab-org/galvani-mirror/issues/11)). IDs that are missing from the map altogether, such as 880 or 883 and 884, are what Rosetta names.
+The fix was released in datalab-org-galvani 0.6.0 ([galvani-mirror#11](https://github.com/datalab-org/galvani-mirror/issues/11)). Rosetta prints the note only when the installed galvani reads the low byte. IDs that are missing from the map altogether, such as 880 or 883 and 884, are what Rosetta names.
 
 ## How it works
 
@@ -112,7 +114,7 @@ The namer improved between hold-outs, so the total includes earlier versions. Th
 - **Values EC-Lab computes after the fact** cannot be reconstructed reliably. For example, a capacitance is held per segment.
 - **Noise-like DC currents** in impedance records, and **external analog inputs** with no sibling column, usually get ABSTAIN.
 - **Two quantities with the same definition in a file** cannot be told apart from the data. In galvanostatic cycling, for example, `dQ` and `Q charge or discharge` reset at the same points. A prior over how common each name is for the technique decides between them, and the alternative is shown.
-- **Supported formats:** EC-Lab data-module versions 2, 3, 10 and 11. Very old files (version 0) are not supported yet.
+- **Supported formats:** EC-Lab data-module versions 0, 2, 3, 10 and 11. Version 0 (older EC-Lab) is read with galvani's offsets, because yadg does not read it. All 59 public version-0 files decode byte for byte like galvani 0.5.0, and the two with an EC-Lab text export match it. The file technique is not read from version-0 files, so the namer works without it.
 
 ## Reproduce the benchmark
 
@@ -130,4 +132,4 @@ pytest tests
 
 ## Data and licence
 
-Rosetta is free software under the **GNU General Public License v3.0 or later** (see `LICENSE`). It uses [yadg](https://github.com/dgbowl/yadg) and [galvani](https://github.com/echemdata/galvani), both GPL. Measurement files are downloaded at run time and never committed. Sources, licences and attributions are listed in [`DATA_SOURCES.md`](https://github.com/Nataniel0212/rosetta-eclab/blob/main/DATA_SOURCES.md). Rosetta is not affiliated with BioLogic.
+Rosetta is free software under the **GNU General Public License v3.0 or later** (see `LICENSE`). It uses [yadg](https://github.com/dgbowl/yadg) (GPL), and `spike2/galvani_0.5.0_colmap.json` is a copy of the column map of [galvani](https://github.com/echemdata/galvani) 0.5.0 (GPL-3.0-or-later). Measurement files are downloaded at run time and never committed. Sources, licences and attributions are listed in [`DATA_SOURCES.md`](https://github.com/Nataniel0212/rosetta-eclab/blob/main/DATA_SOURCES.md). Rosetta is not affiliated with BioLogic.

rosetta_eclab-0.1.4/namer/galvani_ref.py

@@ -0,0 +1,67 @@
+"""galvani as a reference parser, without depending on one particular galvani.
+
+Two distributions install the module `galvani`: galvani (echemdata, 0.5.0 on PyPI)
+and datalab-org-galvani (0.6.0 reads EC-Lab 11.50+ column IDs in full). Rosetta
+does not install either, so it never overwrites the one a user already has.
+
+reference() returns the installed galvani's own column map, and whether that
+galvani reads only the low byte of each column ID in the 11.50+ layout. Without
+galvani installed, the frozen 0.5.0 map (spike2/galvani_snapshot.py) stands in.
+"""
+
+from __future__ import annotations
+
+import inspect
+from dataclasses import dataclass
+
+from spike2.galvani_snapshot import snapshot_map
+
+LOW_BYTE_IDIOM = "column_types[1::2]"  # galvani 0.5.0 keeps every second byte of the ID array
+
+
+@dataclass(frozen=True)
+class Reference:
+    colmap: dict[int, tuple[str, str]]
+    label: str  # e.g. "galvani 0.5.0", "datalab-org-galvani 0.6.0"
+    low_byte: bool | None  # True: reads only the low byte of 11.50+ column IDs; None: cannot tell
+    installed: bool
+
+
+def _label() -> str:
+    from importlib.metadata import PackageNotFoundError, packages_distributions, version
+
+    parts = []
+    for d in sorted(set(packages_distributions().get("galvani", []))):
+        try:
+            parts.append(f"{d} {version(d)}")
+        except PackageNotFoundError:
+            parts.append(d)
+    if not parts:
+        return "galvani"
+    if len(parts) == 1:
+        return parts[0]
+    return f"galvani (installed by both {' and '.join(parts)}; its files are from whichever was installed last)"
+
+
+def _reads_low_byte(biologic) -> bool | None:
+    try:
+        src = inspect.getsource(biologic.MPRfile.__init__)
+    except (OSError, TypeError, AttributeError):
+        return None
+    return LOW_BYTE_IDIOM in src
+
+
+def installed() -> Reference | None:
+    try:
+        from galvani import BioLogic
+    except ImportError:
+        return None
+    colmap = {int(k): (v[0], v[1]) for k, v in BioLogic.VMPdata_colID_dtype_map.items()}
+    return Reference(colmap, _label(), _reads_low_byte(BioLogic), installed=True)
+
+
+def reference() -> Reference:
+    ref = installed()
+    if ref is not None:
+        return ref
+    return Reference(snapshot_map(), "galvani 0.5.0", low_byte=True, installed=False)

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.4}/namer/library.py

@@ -451,15 +451,15 @@ def is_code(ctx, lo=0, hi=200, max_distinct=8) -> float:
 # --- expected storage types (public parser maps: yadg 7.0.1 and galvani 0.5.0) ---------
 
 def expected_dtypes() -> dict[str, set[str]]:
-    from galvani import BioLogic
     from yadg.extractors.eclab.mpr_columns import data_columns
 
     from spike2 import vocab
+    from spike2.galvani_snapshot import snapshot_map  # frozen 0.5.0 map, whichever galvani is installed
 
     out: dict[str, set[str]] = {}
     for dt, name, _unit in data_columns.values():
         out.setdefault(vocab.canonical(name), set()).add(dt)
-    for full, dt in BioLogic.VMPdata_colID_dtype_map.values():
+    for full, dt in snapshot_map().values():
         name = full.split("/")[0] if not full.startswith("Q charge/discharge") else "Q charge/discharge"
         out.setdefault(vocab.canonical(name), set()).add(dt)
     return out
@@ -561,7 +561,11 @@ def build() -> dict[str, Quantity]:
     q("z cycle", shapes=[Shape("integer counter in a sequence with impedance", lambda c: 0.75 * is_counter(c) if c.col("freq") is not None else 0.0)])
     q("Ns", shapes=[Shape("sequence index from 0 that changes with the control", lambda c: ns_shape(c))])
     q("I Range", shapes=[Shape("instrument range code (few values, not starting at 0)", lambda c: irange_shape(c))])
-    q("Pwe", relations=[Relation("Ewe*I", ("Ewe", CURRENT), lambda c: _e(c) * _i(c), [W_PER_V_MA])])
+    q("Pwe", relations=[
+        Relation("Ewe*I", ("Ewe", CURRENT), lambda c: _e(c) * _i(c), [W_PER_V_MA]),
+        # some older EC-Lab files store the power's magnitude (galvani's bio_logic1.mpr and bio_logic3.mpr)
+        Relation("|Ewe*I|", ("Ewe", CURRENT), lambda c: np.abs(_e(c) * _i(c)), [W_PER_V_MA]),
+    ])
     q("Ewe", relations=[
         Relation("Pwe/I", ("Pwe", ("I", "dq", "(Q-Qo)")), lambda c: c.col("Pwe") / _i(c), [1000.0]),
         Relation("follows potential control", ("control",), lambda c: c.col("control"), [1.0]),

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.4}/namer/mprfile.py

@@ -16,6 +16,8 @@ from pathlib import Path
 
 import numpy as np
 
+from . import galvani_ref
+
 FLAG_IDS = (1, 2, 3, 21, 31, 65)
 CANDIDATES = {1: ["|u1"], 2: ["<u2", "<i2"], 4: ["<f4", "<u4", "<i4"], 8: ["<f8", "<u8", "<i8"]}
 
@@ -79,25 +81,29 @@ def _plausibility(v: np.ndarray, dtype: str) -> float:
     return 0.9 if span < 2 ** (8 * width - 4) else 0.2
 
 
-def _galvani_low_byte_note(full_ids: list[int], gmap: dict) -> list[str]:
-    """galvani 0.5.0 reads only the low byte of each column ID in the 11.50+ layout.
+def _galvani_notes(full_ids: list[int], ref: galvani_ref.Reference, layout_11_50: bool) -> list[str]:
+    """What the reference galvani makes of this file, beyond plain unknown IDs.
 
+    galvani 0.5.0 reads only the low byte of each column ID in the 11.50+ layout.
     IDs above 255 then become other IDs (471 -> 215), which galvani either does not
     know (it stops) or knows as a different column. Its map repeats a few entries at
     the low-byte ID (211 = 467), so only IDs whose low-byte entry differs are listed.
     """
-    misread = [x for x in full_ids if x > 255 and gmap.get(x & 0xFF) != gmap.get(x)]
-    if not misread:
-        return []
-    from importlib.metadata import version
-
-    pairs = ", ".join(f"{x} as {x & 0xFF}" for x in misread)
-    return [f"galvani {version('galvani')} reads only the low byte of each column ID in this file layout, "
-            f"so it misreads {pairs}"]
+    notes = []
+    if not ref.installed:
+        notes.append("galvani is not installed, so 'known to galvani' means the column map of galvani 0.5.0 "
+                     "(bundled with Rosetta)")
+    if layout_11_50 and ref.low_byte:
+        gmap = ref.colmap
+        misread = [x for x in full_ids if x > 255 and gmap.get(x & 0xFF) != gmap.get(x)]
+        if misread:
+            pairs = ", ".join(f"{x} as {x & 0xFF}" for x in misread)
+            notes.append(f"{ref.label} reads only the low byte of each column ID in this file layout, "
+                         f"so it misreads {pairs}")
+    return notes
 
 
 def read(path: str | Path, reference: str = "galvani") -> MprData:
-    from galvani import BioLogic
     from yadg.extractors.eclab.mpr import parse_columns, process_settings
 
     logging.getLogger("yadg").setLevel(logging.CRITICAL)
@@ -125,16 +131,29 @@ def read(path: str | Path, reference: str = "galvani") -> MprData:
     elif version in (2, 3):
         yids = full = np.frombuffer(data, offset=5, dtype="<u2", count=n_columns).tolist()
         offset = 0x195 if version == 2 else 0x196
+    elif version == 0:  # older EC-Lab files; offsets as in galvani (yadg 7.0.1 does not read version 0)
+        if data[5]:  # one byte per column ID; all public version-0 files use this layout
+            yids = full = list(data[5:5 + n_columns])
+            offset = 100
+        else:  # galvani: EC-Lab 11.50+ writes [0 1 0 3 0 174 ...]; no public file to test against
+            yids = full = list(data[6:5 + 2 * n_columns:2])
+            offset = 1007
     else:
         raise NotImplementedError(f"data module version {version} is not supported yet")
+    if n_points == 0:
+        raise ValueError("the file has no data points")
     region = len(data) - offset
-    if n_points == 0 or region % n_points:
+    if region % n_points:
         raise ValueError(f"record size is not a whole number of bytes ({region} / {n_points})")
     rec = region // n_points
 
     names, dtypes, units, _ = parse_columns(yids, technique)  # yadg's map: names for known columns
-    gmap = {int(k): v for k, v in BioLogic.VMPdata_colID_dtype_map.items()}
-    notes = _galvani_low_byte_note(full, gmap) if version in (10, 11) and reference == "galvani" else []
+    gref = galvani_ref.reference() if reference == "galvani" else None
+    gmap = gref.colmap if gref else {}
+    notes = _galvani_notes(full, gref, version in (10, 11)) if gref else []
+    if version == 0 and reference == "yadg":
+        notes.append("yadg 7.0.1 cannot read this file at all (data module version 0); "
+                     "'known' here means listed in yadg's column map")
     layout = []  # record layout in file order: (raw_id or None for the flags byte, ...)
     for yid, fid in zip(yids, full):
         if yid in FLAG_IDS:  # all flag IDs share one byte, at the position of the first one

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rosetta-eclab"
-version = "0.1.2"
+version = "0.1.4"
 description = "Name the columns of BioLogic EC-Lab .mpr files that your parser does not know - no language model, evidence for every answer"
 readme = "README.md"
 license = "GPL-3.0-or-later"
@@ -19,10 +19,12 @@ classifiers = [
     "Programming Language :: Python :: 3",
     "Topic :: Scientific/Engineering :: Chemistry",
 ]
+# galvani is not a dependency: two distributions install the module (galvani and datalab-org-galvani),
+# and requiring one would overwrite the other. Rosetta uses whichever is installed, or a frozen copy
+# of galvani 0.5.0's column map (spike2/galvani_0.5.0_colmap.json).
 dependencies = [
     "numpy>=2.0",
     "yadg==7.0.1",
-    "galvani==0.5.0",
 ]
 
 [project.urls]
@@ -30,7 +32,7 @@ Repository = "https://github.com/Nataniel0212/rosetta-eclab"
 Issues = "https://github.com/Nataniel0212/rosetta-eclab/issues"
 
 [project.optional-dependencies]
-test = ["pytest"]
+test = ["pytest", "galvani==0.5.0"]
 
 [project.scripts]
 rosetta = "rosetta_eclab.cli:main"
@@ -45,3 +47,4 @@ rosetta_eclab = "namer"
 
 [tool.setuptools.package-data]
 rosetta_eclab = ["data/*.json", "data/*.npy"]
+spike2 = ["*.json"]

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.4}/rosetta_eclab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosetta-eclab
-Version: 0.1.2
+Version: 0.1.4
 Summary: Name the columns of BioLogic EC-Lab .mpr files that your parser does not know - no language model, evidence for every answer
 Author: Nataniel Ataseven
 License-Expression: GPL-3.0-or-later
@@ -18,9 +18,9 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=2.0
 Requires-Dist: yadg==7.0.1
-Requires-Dist: galvani==0.5.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
+Requires-Dist: galvani==0.5.0; extra == "test"
 Dynamic: license-file
 
 # Rosetta
@@ -52,6 +52,8 @@ Python 3.10 or later:
 pip install rosetta-eclab
 ```
 
+Rosetta does not install galvani. If galvani or datalab-org-galvani is installed, "unknown to galvani" means unknown to the galvani you actually have. Without either, Rosetta uses a frozen copy of galvani 0.5.0's column map and says so. The names Rosetta gives never depend on which galvani is installed.
+
 To run the tests or reproduce the benchmark, clone the repository instead:
 
 ```sh
@@ -96,7 +98,7 @@ peis.issue_225.with_ece.mpr
   every column ID is in galvani's column map; nothing to name
 ```
 
-The fix was released in datalab-org-galvani 0.6.0 ([galvani-mirror#11](https://github.com/datalab-org/galvani-mirror/issues/11)). IDs that are missing from the map altogether, such as 880 or 883 and 884, are what Rosetta names.
+The fix was released in datalab-org-galvani 0.6.0 ([galvani-mirror#11](https://github.com/datalab-org/galvani-mirror/issues/11)). Rosetta prints the note only when the installed galvani reads the low byte. IDs that are missing from the map altogether, such as 880 or 883 and 884, are what Rosetta names.
 
 ## How it works
 
@@ -137,7 +139,7 @@ The namer improved between hold-outs, so the total includes earlier versions. Th
 - **Values EC-Lab computes after the fact** cannot be reconstructed reliably. For example, a capacitance is held per segment.
 - **Noise-like DC currents** in impedance records, and **external analog inputs** with no sibling column, usually get ABSTAIN.
 - **Two quantities with the same definition in a file** cannot be told apart from the data. In galvanostatic cycling, for example, `dQ` and `Q charge or discharge` reset at the same points. A prior over how common each name is for the technique decides between them, and the alternative is shown.
-- **Supported formats:** EC-Lab data-module versions 2, 3, 10 and 11. Very old files (version 0) are not supported yet.
+- **Supported formats:** EC-Lab data-module versions 0, 2, 3, 10 and 11. Version 0 (older EC-Lab) is read with galvani's offsets, because yadg does not read it. All 59 public version-0 files decode byte for byte like galvani 0.5.0, and the two with an EC-Lab text export match it. The file technique is not read from version-0 files, so the namer works without it.
 
 ## Reproduce the benchmark
 
@@ -155,4 +157,4 @@ pytest tests
 
 ## Data and licence
 
-Rosetta is free software under the **GNU General Public License v3.0 or later** (see `LICENSE`). It uses [yadg](https://github.com/dgbowl/yadg) and [galvani](https://github.com/echemdata/galvani), both GPL. Measurement files are downloaded at run time and never committed. Sources, licences and attributions are listed in [`DATA_SOURCES.md`](https://github.com/Nataniel0212/rosetta-eclab/blob/main/DATA_SOURCES.md). Rosetta is not affiliated with BioLogic.
+Rosetta is free software under the **GNU General Public License v3.0 or later** (see `LICENSE`). It uses [yadg](https://github.com/dgbowl/yadg) (GPL), and `spike2/galvani_0.5.0_colmap.json` is a copy of the column map of [galvani](https://github.com/echemdata/galvani) 0.5.0 (GPL-3.0-or-later). Measurement files are downloaded at run time and never committed. Sources, licences and attributions are listed in [`DATA_SOURCES.md`](https://github.com/Nataniel0212/rosetta-eclab/blob/main/DATA_SOURCES.md). Rosetta is not affiliated with BioLogic.

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.4}/rosetta_eclab.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ namer/debug.py
 namer/engine.py
 namer/evaluate.py
 namer/fallback.py
+namer/galvani_ref.py
 namer/golden.py
 namer/library.py
 namer/misses.py
@@ -27,6 +28,8 @@ spike2/corpus.py
 spike2/dsl.py
 spike2/elim.py
 spike2/features.py
+spike2/galvani_0.5.0_colmap.json
+spike2/galvani_snapshot.py
 spike2/lock.py
 spike2/run.py
 spike2/score.py

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.4}/spike2/corpus.py

@@ -96,9 +96,9 @@ def decode(path: Path) -> FileData:
         raise NotImplementedError(f"data module version {data_version}")
     names, dtypes, units, _flags = parse_columns(ids, technique)
     arr = np.frombuffer(data, offset=offset, dtype=np.dtype(list(zip(names, dtypes))), count=n_points)
-    from galvani import BioLogic
+    from .galvani_snapshot import snapshot_map
 
-    km = {int(k): v for k, v in BioLogic.VMPdata_colID_dtype_map.items()}  # galvani 0.5.0: full IDs it knows
+    km = snapshot_map()  # galvani 0.5.0 (frozen copy): full IDs it knows
     cols, pos = [], 0
     # yadg's own flag test (on its reading of the IDs) decides which entries are flags
     data_ids = [(i, f) for i, f in zip(ids, full_ids) if i not in (1, 2, 3, 21, 31, 65)]

rosetta_eclab-0.1.4/spike2/galvani_0.5.0_colmap.json

@@ -0,0 +1,129 @@
+{
+"source": "galvani 0.5.0 (GPL-3.0), galvani/BioLogic.py, VMPdata_colID_dtype_map: column ID -> [name/unit, numpy dtype]",
+"columns": {
+  "4": ["time/s", "<f8"],
+  "5": ["control/V/mA", "<f4"],
+  "6": ["Ewe/V", "<f4"],
+  "7": ["dq/mA.h", "<f8"],
+  "8": ["I/mA", "<f4"],
+  "9": ["Ece/V", "<f4"],
+  "11": ["<I>/mA", "<f8"],
+  "13": ["(Q-Qo)/mA.h", "<f8"],
+  "16": ["Analog IN 1/V", "<f4"],
+  "17": ["Analog IN 2/V", "<f4"],
+  "19": ["control/V", "<f4"],
+  "20": ["control/mA", "<f4"],
+  "23": ["dQ/mA.h", "<f8"],
+  "24": ["cycle number", "<f8"],
+  "26": ["Rapp/Ohm", "<f4"],
+  "27": ["Ewe-Ece/V", "<f4"],
+  "32": ["freq/Hz", "<f4"],
+  "33": ["|Ewe|/V", "<f4"],
+  "34": ["|I|/A", "<f4"],
+  "35": ["Phase(Z)/deg", "<f4"],
+  "36": ["|Z|/Ohm", "<f4"],
+  "37": ["Re(Z)/Ohm", "<f4"],
+  "38": ["-Im(Z)/Ohm", "<f4"],
+  "39": ["I Range", "<u2"],
+  "69": ["R/Ohm", "<f4"],
+  "70": ["P/W", "<f4"],
+  "74": ["|Energy|/W.h", "<f8"],
+  "75": ["Analog OUT/V", "<f4"],
+  "76": ["<I>/mA", "<f4"],
+  "77": ["<Ewe>/V", "<f4"],
+  "78": ["Cs-2/µF-2", "<f4"],
+  "96": ["|Ece|/V", "<f4"],
+  "98": ["Phase(Zce)/deg", "<f4"],
+  "99": ["|Zce|/Ohm", "<f4"],
+  "100": ["Re(Zce)/Ohm", "<f4"],
+  "101": ["-Im(Zce)/Ohm", "<f4"],
+  "123": ["Energy charge/W.h", "<f8"],
+  "124": ["Energy discharge/W.h", "<f8"],
+  "125": ["Capacitance charge/µF", "<f8"],
+  "126": ["Capacitance discharge/µF", "<f8"],
+  "131": ["Ns", "<u2"],
+  "163": ["|Estack|/V", "<f4"],
+  "168": ["Rcmp/Ohm", "<f4"],
+  "169": ["Cs/µF", "<f4"],
+  "172": ["Cp/µF", "<f4"],
+  "173": ["Cp-2/µF-2", "<f4"],
+  "174": ["<Ewe>/V", "<f4"],
+  "178": ["(Q-Qo)/C", "<f4"],
+  "179": ["dQ/C", "<f4"],
+  "211": ["Q charge/discharge/mA.h", "<f8"],
+  "212": ["half cycle", "<u4"],
+  "213": ["z cycle", "<u4"],
+  "217": ["THD Ewe/%", "<f4"],
+  "218": ["THD I/%", "<f4"],
+  "220": ["NSD Ewe/%", "<f4"],
+  "221": ["NSD I/%", "<f4"],
+  "223": ["NSR Ewe/%", "<f4"],
+  "224": ["NSR I/%", "<f4"],
+  "230": ["|Ewe h2|/V", "<f4"],
+  "231": ["|Ewe h3|/V", "<f4"],
+  "232": ["|Ewe h4|/V", "<f4"],
+  "233": ["|Ewe h5|/V", "<f4"],
+  "234": ["|Ewe h6|/V", "<f4"],
+  "235": ["|Ewe h7|/V", "<f4"],
+  "236": ["|I h2|/A", "<f4"],
+  "237": ["|I h3|/A", "<f4"],
+  "238": ["|I h4|/A", "<f4"],
+  "239": ["|I h5|/A", "<f4"],
+  "240": ["|I h6|/A", "<f4"],
+  "241": ["|I h7|/A", "<f4"],
+  "242": ["|E2|/V", "<f4"],
+  "271": ["Phase(Z1) / deg", "<f4"],
+  "272": ["Phase(Z2) / deg", "<f4"],
+  "301": ["|Z1|/Ohm", "<f4"],
+  "302": ["|Z2|/Ohm", "<f4"],
+  "331": ["Re(Z1)/Ohm", "<f4"],
+  "332": ["Re(Z2)/Ohm", "<f4"],
+  "361": ["-Im(Z1)/Ohm", "<f4"],
+  "362": ["-Im(Z2)/Ohm", "<f4"],
+  "391": ["<E1>/V", "<f4"],
+  "392": ["<E2>/V", "<f4"],
+  "422": ["Phase(Zstack)/deg", "<f4"],
+  "423": ["|Zstack|/Ohm", "<f4"],
+  "424": ["Re(Zstack)/Ohm", "<f4"],
+  "425": ["-Im(Zstack)/Ohm", "<f4"],
+  "426": ["<Estack>/V", "<f4"],
+  "430": ["Phase(Zwe-ce)/deg", "<f4"],
+  "431": ["|Zwe-ce|/Ohm", "<f4"],
+  "432": ["Re(Zwe-ce)/Ohm", "<f4"],
+  "433": ["-Im(Zwe-ce)/Ohm", "<f4"],
+  "434": ["(Q-Qo)/C", "<f4"],
+  "435": ["dQ/C", "<f4"],
+  "438": ["step time/s", "<f8"],
+  "441": ["<Ecv>/V", "<f4"],
+  "462": ["Temperature/°C", "<f4"],
+  "467": ["Q charge/discharge/mA.h", "<f8"],
+  "468": ["half cycle", "<u4"],
+  "469": ["z cycle", "<u4"],
+  "471": ["<Ece>/V", "<f4"],
+  "473": ["THD Ewe/%", "<f4"],
+  "474": ["THD I/%", "<f4"],
+  "476": ["NSD Ewe/%", "<f4"],
+  "477": ["NSD I/%", "<f4"],
+  "479": ["NSR Ewe/%", "<f4"],
+  "480": ["NSR I/%", "<f4"],
+  "486": ["|Ewe h2|/V", "<f4"],
+  "487": ["|Ewe h3|/V", "<f4"],
+  "488": ["|Ewe h4|/V", "<f4"],
+  "489": ["|Ewe h5|/V", "<f4"],
+  "490": ["|Ewe h6|/V", "<f4"],
+  "491": ["|Ewe h7|/V", "<f4"],
+  "492": ["|I h2|/A", "<f4"],
+  "493": ["|I h3|/A", "<f4"],
+  "494": ["|I h4|/A", "<f4"],
+  "495": ["|I h5|/A", "<f4"],
+  "496": ["|I h6|/A", "<f4"],
+  "497": ["|I h7|/A", "<f4"],
+  "498": ["Q charge/mA.h", "<f8"],
+  "499": ["Q discharge/mA.h", "<f8"],
+  "500": ["step time/s", "<f8"],
+  "501": ["Efficiency/%", "<f8"],
+  "502": ["Capacity/mA.h", "<f8"],
+  "505": ["Rdc/Ohm", "<f4"],
+  "509": ["Acir/Dcir Control", "<u1"]
+}
+}

rosetta_eclab-0.1.4/spike2/galvani_snapshot.py

@@ -0,0 +1,48 @@
+"""galvani 0.5.0's column map, frozen in this repository.
+
+The benchmarks and the namer's expected storage types use this copy, so their
+answers do not depend on which galvani (if any) is installed. namer/galvani_ref.py
+uses the installed galvani for "known to galvani" instead.
+
+  python -m spike2.galvani_snapshot --write   # regenerate from an installed galvani 0.5.0
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from functools import lru_cache
+from pathlib import Path
+
+SNAPSHOT = Path(__file__).resolve().parent / "galvani_0.5.0_colmap.json"
+SOURCE = "galvani 0.5.0 (GPL-3.0), galvani/BioLogic.py, VMPdata_colID_dtype_map: column ID -> [name/unit, numpy dtype]"
+
+
+@lru_cache(maxsize=1)
+def snapshot_map() -> dict[int, tuple[str, str]]:
+    d = json.loads(SNAPSHOT.read_text(encoding="utf-8"))
+    return {int(k): (v[0], v[1]) for k, v in d["columns"].items()}
+
+
+def write() -> int:
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        ok = version("galvani") == "0.5.0"
+    except PackageNotFoundError:
+        ok = False
+    if not ok:
+        print("needs galvani 0.5.0 installed (pip install galvani==0.5.0)", file=sys.stderr)
+        return 1
+    from galvani import BioLogic
+
+    rows = [f"  {json.dumps(str(k))}: {json.dumps([v[0], v[1]], ensure_ascii=False)}"
+            for k, v in sorted(BioLogic.VMPdata_colID_dtype_map.items())]
+    text = '{\n"source": ' + json.dumps(SOURCE) + ',\n"columns": {\n' + ",\n".join(rows) + "\n}\n}\n"
+    SNAPSHOT.write_text(text, encoding="utf-8", newline="\n")
+    print(f"wrote {SNAPSHOT} ({len(rows)} columns)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(write() if "--write" in sys.argv else 0)

rosetta_eclab-0.1.4/tests/test_cli.py

@@ -0,0 +1,158 @@
+"""Fast tests for the command-line tool (the full regression check is `python -m namer.golden check`).
+
+Needs the public test files: python scripts/fetch_testdata.py
+"""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from namer import cli, galvani_ref, mprfile
+from spike2 import corpus
+from spike2.galvani_snapshot import snapshot_map
+
+EXT = corpus.EXT
+pytestmark = pytest.mark.skipif(not (EXT / "gcpl.mpr").exists(), reason="run scripts/fetch_testdata.py first")
+
+
+def recode(src: Path, dst: Path, old_id: int, new_id: int) -> None:
+    """Simulate a vendor format change: give one column a column ID no parser knows."""
+    raw = bytearray(src.read_bytes())
+    i = raw.index(b"VMP data")
+    m = raw.index(b"MODULE", i - 10)
+    data_start = None
+    for name, _ver, mdata in mprfile._modules(bytes(raw)):
+        if name == "VMP data":
+            data_start = bytes(raw).index(mdata)
+    assert data_start is not None and m >= 0
+    n_cols = raw[data_start + 4]
+    ids = np.frombuffer(bytes(raw[data_start + 5: data_start + 5 + 2 * n_cols]), dtype="<u2").tolist()
+    k = ids.index(old_id)
+    raw[data_start + 5 + 2 * k: data_start + 7 + 2 * k] = int(new_id).to_bytes(2, "little")
+    dst.write_bytes(bytes(raw))
+
+
+def test_reader_matches_reference_decoder():
+    for name in ("gcpl.mpr", "bcd.issue_241.mpr", "peis.mpr", "cv.mpr"):
+        ref = corpus.decode(EXT / name)
+        got = mprfile.read(EXT / name, reference="yadg")
+        a = [(c.name, c.dtype, c.values.tobytes()) for c in got.columns]
+        b = [(c.name, c.dtype, np.asarray(c.values).tobytes()) for c in ref.columns]
+        assert a == b, name
+
+
+def _mpt(path: Path) -> dict[str, np.ndarray]:
+    lines = path.read_bytes().decode("latin-1").splitlines()
+    n_header = int(lines[1].split(":")[1])
+    head = lines[n_header - 1].rstrip("\t").split("\t")
+    rows = [line.rstrip("\t").split("\t") for line in lines[n_header:] if line.strip()]
+    return {h: np.array([float(r[i].replace(",", ".")) for r in rows]) for i, h in enumerate(head)}
+
+
+def test_version_0_files_match_the_vendor_export():
+    """Data module version 0 (older EC-Lab): yadg cannot read it; the values must match EC-Lab's own .mpt."""
+    m = mprfile.read(EXT / "bio_logic1.mpr", reference="galvani")
+    mpt = _mpt(EXT / "bio_logic1.mpt")
+    cols = {c.name: c.values.astype("f8") for c in m.columns}
+    assert m.n_points == len(mpt["time/s"]) == 3119 and not m.unknown
+    for name, ref in (("time", "time/s"), ("Ewe", "Ewe/V"), ("dq", "dq/mA.h"), ("Pwe", "P/W")):
+        np.testing.assert_allclose(cols[name], mpt[ref], rtol=1e-6, atol=1e-9, err_msg=name)
+    assert any("yadg 7.0.1 cannot read" in n for n in mprfile.read(EXT / "bio_logic1.mpr", reference="yadg").notes)
+    assert not any("yadg" in n for n in m.notes)
+
+
+def test_empty_file_is_reported_plainly():
+    with pytest.raises(ValueError, match="no data points"):
+        mprfile.read(EXT / "wait.mpr")
+
+
+def test_power_magnitude_in_version_0_file_is_named(tmp_path):
+    """Version-0 files store |Ewe*I| as the power; hidden, it must come back as Pwe (it was named Ece)."""
+    raw = bytearray((EXT / "bio_logic1.mpr").read_bytes())
+    mdata = next(md for name, _v, md in mprfile._modules(bytes(raw)) if name == "VMP data")
+    start = bytes(raw).index(mdata)
+    ids = list(raw[start + 5: start + 5 + raw[start + 4]])
+    raw[start + 5 + ids.index(70)] = 255  # one-byte column IDs in version 0
+    f = tmp_path / "old_drift.mpr"
+    f.write_bytes(bytes(raw))
+    m = mprfile.read(f, reference="galvani")
+    assert [c.raw_id for c in m.unknown] == [255]
+    res = cli.name_unknown(m)
+    assert res[0]["verdict"] == "NAME" and res[0]["name"] == "Pwe", res[0]
+
+
+def test_real_drift_duplicates_are_reported():
+    m = mprfile.read(EXT / "gcpl.issue_230.mpr", reference="galvani")
+    assert [c.raw_id for c in m.unknown] == [883, 884]
+    res = cli.name_unknown(m)
+    assert [r["verdict"] for r in res] == ["DUPLICATE", "DUPLICATE"]
+
+
+def test_galvani_low_byte_misreads_are_reported():
+    """galvani 0.5.0 stops on this file only because it reads 471 (<Ece>/V) as 215; nothing is unknown."""
+    m = mprfile.read(EXT / "peis.issue_225.with_ece.mpr", reference="galvani")
+    assert m.unknown == []
+    assert any("471 as 215" in n for n in m.notes), m.notes
+    assert not any("low byte" in n for n in mprfile.read(EXT / "gcpl.mpr", reference="galvani").notes)
+    assert not any("low byte" in n for n in mprfile.read(EXT / "peis.issue_225.with_ece.mpr", reference="yadg").notes)
+
+
+def _galvani_version() -> str | None:
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        return version("galvani")
+    except PackageNotFoundError:
+        return None
+
+
+def test_frozen_map_is_galvani_050():
+    if _galvani_version() != "0.5.0":
+        pytest.skip("needs galvani 0.5.0 (pip install '.[test]')")
+    from galvani import BioLogic
+
+    assert snapshot_map() == {int(k): (v[0], v[1]) for k, v in BioLogic.VMPdata_colID_dtype_map.items()}
+    ref = galvani_ref.installed()
+    assert ref.label == "galvani 0.5.0" and ref.low_byte is True
+
+
+def test_full_id_galvani_gets_no_low_byte_note(monkeypatch):
+    """A galvani that reads column IDs in full (datalab-org-galvani 0.6.0) misreads nothing."""
+    ref = galvani_ref.Reference(snapshot_map(), "datalab-org-galvani 0.6.0", low_byte=False, installed=True)
+    monkeypatch.setattr(galvani_ref, "reference", lambda: ref)
+    m = mprfile.read(EXT / "peis.issue_225.with_ece.mpr", reference="galvani")
+    assert m.unknown == [] and not any("low byte" in n for n in m.notes), m.notes
+
+
+def test_without_galvani_the_frozen_map_stands_in(monkeypatch):
+    monkeypatch.setattr(galvani_ref, "installed", lambda: None)
+    m = mprfile.read(EXT / "gcpl.issue_230.mpr", reference="galvani")
+    assert [c.raw_id for c in m.unknown] == [883, 884]
+    assert any("not installed" in n for n in m.notes), m.notes
+    assert any("galvani 0.5.0 reads only the low byte" in n and "438 as 182" in n for n in m.notes), m.notes
+
+
+@pytest.mark.parametrize("old_id,expected", [(467, "Q charge or discharge"), (7, "dq"), (4, "time")])
+def test_simulated_drift_is_named(tmp_path, old_id, expected):
+    f = tmp_path / "drift.mpr"
+    recode(EXT / "gcpl.mpr", f, old_id, 950)
+    m = mprfile.read(f, reference="galvani")
+    assert [c.raw_id for c in m.unknown] == [950]
+    res = cli.name_unknown(m)
+    assert res[0]["verdict"] == "NAME" and res[0]["name"] == expected, res[0]
+
+
+def test_noise_column_is_not_named(tmp_path):
+    """Replace a column's bytes with noise: the tool must abstain, not invent a name."""
+    f = tmp_path / "noise.mpr"
+    shutil.copy(EXT / "gcpl.mpr", f)
+    recode(EXT / "gcpl.mpr", f, 467, 950)
+    m = mprfile.read(f, reference="galvani")
+    c = m.unknown[0]
+    c.values = np.random.default_rng(0).normal(5.0, 2.0, c.values.size)
+    res = cli.name_unknown(m)
+    assert res[0]["verdict"] != "NAME", res[0]

rosetta_eclab-0.1.2/tests/test_cli.py

@@ -1,82 +0,0 @@
-"""Fast tests for the command-line tool (the full regression check is `python -m namer.golden check`).
-
-Needs the public test files: python scripts/fetch_testdata.py
-"""
-
-from __future__ import annotations
-
-import shutil
-from pathlib import Path
-
-import numpy as np
-import pytest
-
-from namer import cli, mprfile
-from spike2 import corpus
-
-EXT = corpus.EXT
-pytestmark = pytest.mark.skipif(not (EXT / "gcpl.mpr").exists(), reason="run scripts/fetch_testdata.py first")
-
-
-def recode(src: Path, dst: Path, old_id: int, new_id: int) -> None:
-    """Simulate a vendor format change: give one column a column ID no parser knows."""
-    raw = bytearray(src.read_bytes())
-    i = raw.index(b"VMP data")
-    m = raw.index(b"MODULE", i - 10)
-    data_start = None
-    for name, _ver, mdata in mprfile._modules(bytes(raw)):
-        if name == "VMP data":
-            data_start = bytes(raw).index(mdata)
-    assert data_start is not None and m >= 0
-    n_cols = raw[data_start + 4]
-    ids = np.frombuffer(bytes(raw[data_start + 5: data_start + 5 + 2 * n_cols]), dtype="<u2").tolist()
-    k = ids.index(old_id)
-    raw[data_start + 5 + 2 * k: data_start + 7 + 2 * k] = int(new_id).to_bytes(2, "little")
-    dst.write_bytes(bytes(raw))
-
-
-def test_reader_matches_reference_decoder():
-    for name in ("gcpl.mpr", "bcd.issue_241.mpr", "peis.mpr", "cv.mpr"):
-        ref = corpus.decode(EXT / name)
-        got = mprfile.read(EXT / name, reference="yadg")
-        a = [(c.name, c.dtype, c.values.tobytes()) for c in got.columns]
-        b = [(c.name, c.dtype, np.asarray(c.values).tobytes()) for c in ref.columns]
-        assert a == b, name
-
-
-def test_real_drift_duplicates_are_reported():
-    m = mprfile.read(EXT / "gcpl.issue_230.mpr", reference="galvani")
-    assert [c.raw_id for c in m.unknown] == [883, 884]
-    res = cli.name_unknown(m)
-    assert [r["verdict"] for r in res] == ["DUPLICATE", "DUPLICATE"]
-
-
-def test_galvani_low_byte_misreads_are_reported():
-    """galvani 0.5.0 stops on this file only because it reads 471 (<Ece>/V) as 215; nothing is unknown."""
-    m = mprfile.read(EXT / "peis.issue_225.with_ece.mpr", reference="galvani")
-    assert m.unknown == []
-    assert any("471 as 215" in n for n in m.notes), m.notes
-    assert not any("low byte" in n for n in mprfile.read(EXT / "gcpl.mpr", reference="galvani").notes)
-    assert not any("low byte" in n for n in mprfile.read(EXT / "peis.issue_225.with_ece.mpr", reference="yadg").notes)
-
-
-@pytest.mark.parametrize("old_id,expected", [(467, "Q charge or discharge"), (7, "dq"), (4, "time")])
-def test_simulated_drift_is_named(tmp_path, old_id, expected):
-    f = tmp_path / "drift.mpr"
-    recode(EXT / "gcpl.mpr", f, old_id, 950)
-    m = mprfile.read(f, reference="galvani")
-    assert [c.raw_id for c in m.unknown] == [950]
-    res = cli.name_unknown(m)
-    assert res[0]["verdict"] == "NAME" and res[0]["name"] == expected, res[0]
-
-
-def test_noise_column_is_not_named(tmp_path):
-    """Replace a column's bytes with noise: the tool must abstain, not invent a name."""
-    f = tmp_path / "noise.mpr"
-    shutil.copy(EXT / "gcpl.mpr", f)
-    recode(EXT / "gcpl.mpr", f, 467, 950)
-    m = mprfile.read(f, reference="galvani")
-    c = m.unknown[0]
-    c.values = np.random.default_rng(0).normal(5.0, 2.0, c.values.size)
-    res = cli.name_unknown(m)
-    assert res[0]["verdict"] != "NAME", res[0]

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.4}/rosetta_eclab.egg-info/requires.txt

@@ -1,6 +1,6 @@
 numpy>=2.0
 yadg==7.0.1
-galvani==0.5.0
 
 [test]
 pytest
+galvani==0.5.0