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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosetta-eclab
-Version: 0.1.2
+Version: 0.1.3
 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
 
@@ -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.3}/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
 
@@ -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.3/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.3}/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

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.3}/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)
@@ -133,8 +139,9 @@ def read(path: str | Path, reference: str = "galvani") -> MprData:
     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 []
     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.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rosetta-eclab"
-version = "0.1.2"
+version = "0.1.3"
 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.3}/rosetta_eclab.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosetta-eclab
-Version: 0.1.2
+Version: 0.1.3
 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
 
@@ -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.3}/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.3}/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.3/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.3/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.2 → rosetta_eclab-0.1.3}/tests/test_cli.py

@@ -11,8 +11,9 @@ from pathlib import Path
 import numpy as np
 import pytest
 
-from namer import cli, mprfile
+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")
@@ -60,6 +61,41 @@ def test_galvani_low_byte_misreads_are_reported():
     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"

{rosetta_eclab-0.1.2 → rosetta_eclab-0.1.3}/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