| |
| """Independent check of the corpus, using nothing but the standard library. |
| |
| `score.py` grades *your* checker, so it cannot be run until you have one. This |
| script needs nothing: it checks that the corpus you have is internally |
| consistent -- every file matching the digest recorded for it, and no label |
| contradicting itself. |
| |
| python3 verify.py |
| |
| What it checks |
| -------------- |
| 1. Every case named in the index has its Touchstone file present. |
| 2. Every file's SHA-256 matches the digest recorded in the index, so a corrupt |
| or truncated download is caught rather than silently scored against. |
| 3. The index and `manifest.json` agree on the set of cases. |
| 4. Every label is self-consistent: a case that is expected to fail a law must |
| name which laws, a case expected to pass all of them must name none, and |
| every law named must be one of the five the corpus defines. |
| 5. Every Touchstone file parses as a real N-port network with the port count |
| and reference impedance the index claims. |
| |
| What it does NOT check |
| ---------------------- |
| It does not re-derive the physics. Deciding whether `active_gain.s2p` really |
| violates passivity is the job of a checker, and re-implementing that here would |
| give the corpus a second, unvalidated opinion about its own ground truth -- |
| exactly the circularity a conformance corpus exists to avoid. This verifies |
| integrity and label consistency. `score.py` is where physics gets graded. |
| |
| It is also **not** a proof of authenticity. The digests live in `index.jsonl`, |
| inside the same download, so anyone who can rewrite a data file can rewrite its |
| digest to match. This detects corruption, truncation and inconsistent editing; |
| it does not detect deliberate substitution. Compare against the published |
| commit on the Hub if that is what you need. |
| |
| Exit status is 0 if everything holds and 1 otherwise, so it is usable in CI. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import pathlib |
| import re |
| import sys |
|
|
| HERE = pathlib.Path(__file__).resolve().parent |
| DATA = HERE / "data" |
|
|
| LAWS = { |
| "passivity", |
| "reciprocity", |
| "energy_conservation", |
| "positive_real_z0", |
| "group_delay_nonneg", |
| } |
|
|
|
|
| def parse_touchstone(path: pathlib.Path) -> tuple[int, float, int]: |
| """Return (n_ports, z0_ohm, n_points) from a Touchstone 1.x file. |
| |
| In Touchstone 1.x the port count lives in the extension (`.s2p`, `.s4p`) -- |
| it is not derivable from the payload, because a 2-port's row stride of 9 |
| numbers is divisible by a 1-port's stride of 3, so counting alone would |
| happily mis-read every 2-port file as a 1-port. The extension is the |
| authority; the payload is then checked for consistency with it. |
| """ |
| m = re.fullmatch(r"\.s(\d+)p", path.suffix, re.I) |
| if not m: |
| raise ValueError(f"{path.name}: not a Touchstone .sNp filename") |
| n_ports = int(m.group(1)) |
|
|
| z0 = 50.0 |
| values: list[float] = [] |
| for raw in path.read_text(encoding="utf-8").splitlines(): |
| line = raw.split("!", 1)[0].strip() |
| if not line: |
| continue |
| if line.startswith("#"): |
| opt = re.search(r"\bR\s*([0-9.eE+-]+)", line, re.I) |
| if opt: |
| z0 = float(opt.group(1)) |
| continue |
| values.extend(float(tok) for tok in line.split()) |
|
|
| |
| stride = 1 + 2 * n_ports * n_ports |
| if not values or len(values) % stride: |
| raise ValueError( |
| f"{path.name}: {len(values)} numbers is not a whole number of " |
| f"{n_ports}-port rows (stride {stride})" |
| ) |
| return n_ports, z0, len(values) // stride |
|
|
|
|
| def main() -> int: |
| problems: list[str] = [] |
|
|
| index_path = DATA / "index.jsonl" |
| if not index_path.exists(): |
| print(f"FATAL: {index_path} is missing", file=sys.stderr) |
| return 1 |
| rows = [json.loads(line) for line in index_path.read_text(encoding="utf-8").splitlines() if line.strip()] |
|
|
| for row in rows: |
| name = row["name"] |
| f = DATA / row["file"] |
|
|
| if not f.exists(): |
| problems.append(f"{name}: file {row['file']} is missing") |
| continue |
|
|
| digest = hashlib.sha256(f.read_bytes()).hexdigest() |
| if digest != row["sha256"]: |
| problems.append(f"{name}: sha256 mismatch (file has been altered)") |
|
|
| fails = row["expected_failures"] |
| unknown = set(fails) - LAWS |
| if unknown: |
| problems.append(f"{name}: names laws that do not exist: {sorted(unknown)}") |
| if row["expected_to_pass_all_laws"] and fails: |
| problems.append(f"{name}: labelled as passing all laws but lists failures {fails}") |
| if not row["expected_to_pass_all_laws"] and not fails: |
| problems.append(f"{name}: labelled as failing but names no law") |
|
|
| try: |
| n_ports, z0, n_points = parse_touchstone(f) |
| except ValueError as exc: |
| problems.append(f"{name}: {exc}") |
| continue |
| if n_ports != row["n_ports"]: |
| problems.append(f"{name}: index says {row['n_ports']}-port, file parses as {n_ports}-port") |
| if abs(z0 - row["z0_ohm"]) > 1e-9: |
| problems.append(f"{name}: index says z0={row['z0_ohm']}, file declares {z0}") |
|
|
| manifest_path = DATA / "manifest.json" |
| if not manifest_path.exists(): |
| problems.append("data/manifest.json is missing") |
| else: |
| manifest = json.loads(manifest_path.read_text(encoding="utf-8")) |
| in_manifest = {c["name"] for c in manifest.get("cases", [])} |
| in_index = {r["name"] for r in rows} |
| if in_manifest != in_index: |
| only_m = sorted(in_manifest - in_index) |
| only_i = sorted(in_index - in_manifest) |
| problems.append(f"manifest/index disagree (manifest-only={only_m}, index-only={only_i})") |
|
|
| realizable = sum(1 for r in rows if r["physically_realizable"]) |
| print("sparam-conformance corpus verification (stdlib only)\n") |
| print(f" cases {len(rows)}") |
| print(f" physically valid {realizable}") |
| print(f" physically invalid {len(rows) - realizable}") |
| print(f" laws {len(LAWS)}") |
| matched = sum( |
| 1 |
| for r in rows |
| if (DATA / r["file"]).exists() |
| and hashlib.sha256((DATA / r["file"]).read_bytes()).hexdigest() == r["sha256"] |
| ) |
| print(f" sha256 matched {matched}/{len(rows)}") |
| print() |
|
|
| if problems: |
| print(f" INCONSISTENT -- {len(problems)} problem(s):\n") |
| for p in problems: |
| print(f" - {p}") |
| return 1 |
|
|
| print(" self-consistent: every file matches its recorded digest, and every") |
| print(" label agrees with itself") |
| print() |
| print(" scope: internal consistency only. The digests ship in this download,") |
| print(" so this detects corruption, not substitution. It does not re-derive") |
| print(" the physics -- run score.py against a checker for that.") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| raise SystemExit(main()) |
|
|
