Blame for verify.py

#!/usr/bin/env python3
"""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())

    # One row is: frequency, then a real/imag pair per S-parameter.
    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())