chipwright 0.2.0__py3-none-any.whl

chipwright/tests/test_llm_modality.py

@@ -0,0 +1,259 @@
+"""LLM modality pure helpers — chat-template wrap, profile-JSON parse, generation parse, mock run.
+
+No device and no onnxruntime: the device is a tiny fake exposing push_file/shell/pull/exists.
+Runnable as `python3 test_llm_modality.py`.
+"""
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from chipwright.modalities.llm import (
+    apply_chat_template, parse_profile, parse_generation, run,
+    retokenize, load_bundle_tokenizer, greedy_sampler, apply_greedy_to_config,
+)
+
+
+# --- chat template --------------------------------------------------------------------------------
+
+def test_chatml_wrap_has_im_markers_and_open_assistant_turn():
+    out = apply_chat_template("What is the capital of France?", template="chatml")
+    assert "<|im_start|>user\nWhat is the capital of France?<|im_end|>" in out
+    assert out.endswith("<|im_start|>assistant\n")      # open turn so generation continues
+
+
+def test_chatml_wrap_includes_system_when_given():
+    out = apply_chat_template("hi", template="chatml", system="You are terse.")
+    assert "<|im_start|>system\nYou are terse.<|im_end|>" in out
+
+
+def test_raw_template_is_passthrough():
+    assert apply_chat_template("just text", template="raw") == "just text"
+
+
+def test_unknown_template_is_refused_by_name():
+    try:
+        apply_chat_template("x", template="llama-chat")
+    except ValueError as e:
+        assert "llama-chat" in str(e)
+    else:
+        assert False, "expected ValueError for unknown template"
+
+
+# --- profile JSON parse ---------------------------------------------------------------------------
+
+def test_parse_profile_maps_latency_fields():
+    prof = json.dumps({
+        "token_generation_rate": 33.0,
+        "prompt_processing_rate": 292.0,
+        "time_to_first_token_ms": 55.0,
+        "init_time": 0.88,
+    })
+    lat = parse_profile(prof)
+    assert lat["decode_toks_per_sec"] == 33.0
+    assert lat["prefill_toks_per_sec"] == 292.0
+    assert lat["time_to_first_token_ms"] == 55.0
+    assert lat["model_load_s"] == 0.88
+
+
+def test_parse_profile_handles_nested_and_missing_fields():
+    prof = {"profile": {"decode": {"rate": 30.0}}}   # nested; others absent
+    lat = parse_profile(prof)
+    assert lat["decode_toks_per_sec"] == 30.0
+    assert lat["prefill_toks_per_sec"] is None       # absent -> shown as None, not hidden
+
+
+# --- generation parse -----------------------------------------------------------------------------
+
+def test_parse_generation_extracts_text_and_token_ids():
+    stdout = "loading...\n[BEGIN]Paris.[END]\ntoken_ids: [40, 1138, 13]\ndone"
+    g = parse_generation(stdout)
+    assert g["text"] == "Paris."
+    assert g["tokens"] == [40, 1138, 13]
+
+
+def test_parse_generation_missing_tokens_is_none():
+    g = parse_generation("[BEGIN]hello[END]")
+    assert g["text"] == "hello"
+    assert g["tokens"] is None
+
+
+def test_parse_generation_without_end_marker_reads_to_eof():
+    # w4a16 degenerates and never emits EOS; the board kills the run on `timeout` before [END],
+    # so the text must be read up to EOF, not dropped as empty.
+    g = parse_generation("noise\n[BEGIN]: Paris is the capital of France and it keeps going")
+    assert g["text"] == "Paris is the capital of France and it keeps going"
+
+
+# --- retokenize (text -> token ids; genie emits no ids on QAIRT 2.51) -----------------------------
+
+class _Enc:
+    def __init__(self, ids): self.ids = ids
+
+
+class FakeTokenizer:
+    """Duck-typed stand-in for a HuggingFace Tokenizer: encode(text, add_special_tokens).ids."""
+    def __init__(self, mapping=None): self.mapping = mapping or {}; self.calls = []
+    def encode(self, text, add_special_tokens=False):
+        self.calls.append((text, add_special_tokens))
+        return _Enc(self.mapping.get(text, [len(text)]))
+
+
+def test_retokenize_uses_injected_tokenizer_with_special_tokens_off():
+    tok = FakeTokenizer({"Paris.": [40, 1138, 13]})
+    ids = retokenize("Paris.", tokenizer=tok)
+    assert ids == [40, 1138, 13]
+    assert tok.calls == [("Paris.", False)]        # special tokens OFF — we match answer tokens
+
+
+def test_retokenize_with_real_tokenizers_library_roundtrips():
+    # Build a tiny real tokenizer.json via the `tokenizers` library and prove the file path loads.
+    from tokenizers import Tokenizer
+    from tokenizers.models import WordLevel
+    from tokenizers.pre_tokenizers import Whitespace
+    import tempfile
+    vocab = {"paris": 0, "london": 1, "is": 2, "the": 3, "capital": 4, "[UNK]": 5}
+    t = Tokenizer(WordLevel(vocab, unk_token="[UNK]"))
+    t.pre_tokenizer = Whitespace()
+    p = os.path.join(tempfile.mkdtemp(), "tokenizer.json")
+    t.save(p)
+    ids = retokenize("paris is the capital", p)
+    assert ids == [0, 2, 3, 4]
+
+
+def test_load_bundle_tokenizer_missing_file_fails_by_name():
+    try:
+        load_bundle_tokenizer("/no/such/tokenizer.json")
+    except FileNotFoundError as e:
+        assert "tokenizer" in str(e).lower()
+    else:
+        assert False, "expected FileNotFoundError for a missing bundle tokenizer"
+
+
+def test_load_bundle_tokenizer_fails_by_name_without_library(monkeypatch=None):
+    # If `tokenizers` cannot be imported, the modality must fail BY NAME, not silently return no tokens.
+    import builtins
+    real_import = builtins.__import__
+
+    def blocked(name, *a, **k):
+        if name == "tokenizers" or name.startswith("tokenizers."):
+            raise ImportError("blocked for test")
+        return real_import(name, *a, **k)
+
+    builtins.__import__ = blocked
+    try:
+        load_bundle_tokenizer("/tmp/whatever.json")
+        assert False, "expected RuntimeError naming the tokenizers library"
+    except RuntimeError as e:
+        assert "tokenizers" in str(e)
+    finally:
+        builtins.__import__ = real_import
+
+
+# --- greedy sampler: top-k:1, NOT sampler.greedy (genie silently ignores greedy) ------------------
+
+def test_greedy_sampler_sets_topk_1_not_relying_on_greedy_flag():
+    s = greedy_sampler()
+    assert s["top-k"] == 1          # the control genie HONORS
+    assert s["temp"] == 0.0
+    assert s["top-p"] == 1.0
+
+
+def test_apply_greedy_to_config_forces_topk1_without_mutating_input():
+    cfg = {"dialog": {"sampler": {"version": 1, "greedy": True, "temp": 0.8, "top-k": 40}}}
+    out = apply_greedy_to_config(cfg)
+    assert out["dialog"]["sampler"]["top-k"] == 1
+    assert out["dialog"]["sampler"]["temp"] == 0.0
+    # input is not mutated (pure) — the on-disk bundle config is never clobbered
+    assert cfg["dialog"]["sampler"]["top-k"] == 40
+
+
+# --- mock-device run ------------------------------------------------------------------------------
+
+class _Proc:
+    def __init__(self, stdout): self.returncode = 0; self.stdout = stdout
+
+
+class FakeDevice:
+    """Minimal device fake over the (push_file/shell/pull/exists) interface."""
+    def __init__(self, stdout, profile=None):
+        self._stdout = stdout
+        self._profile = profile
+        self.pushed = []
+        self.shelled = []
+        self._present = set()
+    def push_file(self, local, remote):
+        self.pushed.append((os.path.basename(local), remote))
+        self._present.add(remote)
+    def shell(self, cmd):
+        self.shelled.append(cmd)
+        return _Proc(self._stdout)
+    def exists(self, remote):
+        return remote.endswith("profile.json") and self._profile is not None or remote in self._present
+    def pull(self, remote, local):
+        with open(local, "w") as f:
+            f.write(self._profile or "{}")
+
+
+def test_run_pushes_bundle_file_by_file_and_parses(tmp_path=None):
+    import tempfile
+    d = tempfile.mkdtemp()
+    # genie_config.json must be valid JSON so the greedy patch (top-k:1) can read it.
+    with open(os.path.join(d, "genie_config.json"), "w") as f:
+        json.dump({"dialog": {"sampler": {"version": 1, "greedy": True, "temp": 0.8}}}, f)
+    for name in ("tokenizer.json", "context_0.bin"):
+        with open(os.path.join(d, name), "w") as f:
+            f.write("x")
+    stdout = "loading...\n[BEGIN]Paris.[END]"            # genie emits TEXT, no token ids on QAIRT 2.51
+    profile = json.dumps({"token_generation_rate": 33.0, "prompt_processing_rate": 292.0})
+    dev = FakeDevice(stdout, profile=profile)
+    meta = {"template": "chatml", "genie_config": "genie_config.json",
+            "bundle_files": ["genie_config.json", "tokenizer.json", "context_0.bin"]}
+    tok = FakeTokenizer({"Paris.": [40, 1138]})         # inject: no real tokenizer.json needed
+
+    out = run(dev, d, meta, "capital of France?", tokenizer=tok, profile=True)  # exercise the profile-on path
+
+    pushed = [remote for _, remote in dev.pushed]
+    # bundle pushed one file at a time (FR-L02: never a single multi-GB directory push)
+    assert sum(1 for p in pushed if p.endswith(("genie_config.json", "tokenizer.json", "context_0.bin"))) == 3
+    # prompt went over as a FILE (--prompt_file), not inline on the shell command line
+    assert any(p.endswith("prompt.txt") for p in pushed)
+    with open(os.path.join(d, "prompt.txt")) as f:
+        assert "im_start" in f.read()                   # chat template applied, written to the prompt file
+    cmd = " ".join(dev.shelled)
+    assert "--prompt_file" in cmd
+    assert "--print-token-ids" not in cmd and "--max-length" not in cmd   # Bug 1: non-existent flags gone
+    # greedy run drives genie at a derived top-k:1 config (Bug 2), not sampler.greedy
+    assert any(p.endswith("genie_config.greedy.json") for p in pushed)
+    assert "-c genie_config.greedy.json" in cmd
+    with open(os.path.join(d, "genie_config.greedy.json")) as f:
+        assert json.load(f)["dialog"]["sampler"]["top-k"] == 1
+    # text parsed, then RETOKENIZED into ids for the gate
+    assert out["text"] == "Paris."
+    assert out["tokens"] == [40, 1138]
+    assert out["latency"]["decode_toks_per_sec"] == 33.0
+
+
+def test_run_omits_profile_by_default():
+    """`--profile` defaults OFF: on a real SM8850/v81 board it broke genie 2.51's output and
+    false-FAILed a known-good artifact (token_match 0.0). Default run must not pass the flag."""
+    import tempfile
+    d = tempfile.mkdtemp()
+    for name in ("tokenizer.json", "genie_config.json"):
+        with open(os.path.join(d, name), "w") as f:
+            f.write("{}" if name.endswith(".json") else "x")
+    dev = FakeDevice("[BEGIN]Paris.[END]")
+    meta = {"template": "chatml", "genie_config": "genie_config.json",
+            "bundle_files": ["genie_config.json", "tokenizer.json"]}
+    out = run(dev, d, meta, "capital of France?", tokenizer=FakeTokenizer({"Paris.": [40]}))
+    cmd = " ".join(dev.shelled)
+    assert "--profile" not in cmd                 # default off (silicon finding)
+    assert out["latency"] == {}                   # no profile pulled/parsed when off
+
+
+if __name__ == "__main__":
+    fns = [f for n, f in sorted(globals().items()) if n.startswith("test_")]
+    for f in fns:
+        f(); print("ok", f.__name__)
+    print(f"\n{len(fns)} passed")

chipwright/tests/test_packaging.py

@@ -0,0 +1,147 @@
+"""Packaging guards — the public registry must be portable (runnable by a stranger).
+
+The #1 release blocker was author-local absolute paths baked into the bundled registry, which make
+`chipwright run` fail for everyone but the author. These tests fail the build if that regresses.
+"""
+import os
+import sys
+
+import pytest
+import yaml
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+PKG = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+PUBLIC_INDEX = os.path.join(PKG, "data", "index.yaml")  # bundled public index (ships in the wheel)
+
+
+def test_public_index_has_no_absolute_paths():
+    """The bundled public registry must not carry author-local absolute paths."""
+    text = open(PUBLIC_INDEX).read()
+    offenders = [ln for ln in text.splitlines() if "/Users/" in ln or "/home/" in ln]
+    assert not offenders, "author-local absolute paths leaked into the public registry:\n" + "\n".join(offenders)
+
+
+def test_public_index_parses_and_keeps_records():
+    """The public index still parses and every verified record survived the portability strip."""
+    doc = yaml.safe_load(open(PUBLIC_INDEX))
+    assert doc.get("registry_schema") == 1
+    models = doc.get("models", [])
+    assert models, "public registry has no models"
+    for m in models:
+        for v in m.get("variants", []):
+            # a variant must not carry a local path; it is runnable via url, or build-only, or a record.
+            assert "local" not in v or not str(v.get("local", "")).startswith(("/Users", "/home")), m["model"]
+
+
+def test_verified_record_on_field_not_yaml_coerced():
+    """The verification record's device field is `on:` — which YAML 1.1 coerces to boolean `true` if
+    unquoted. Guard against a `true:` key sneaking back in: a record MUST name its device under "on"."""
+    doc = yaml.safe_load(open(PUBLIC_INDEX))
+    for m in doc.get("models", []):
+        for v in m.get("variants", []):
+            ver = v.get("verified")
+            if isinstance(ver, dict):
+                assert True not in ver, (
+                    f"{m['model']}: a verified-record key coerced to boolean true (quote `on:` as \"on\")")
+                if any(k in ver for k in ("date", "loads")):   # a real record → it names its device
+                    assert "on" in ver, f"{m['model']}: verified record missing the `on:` device field"
+
+
+def test_every_variant_is_resolvable_or_buildable():
+    """Each variant either hosts an artifact (url+sha256), or is build-only, or carries a record —
+    never a dangling local path that only the author can reach."""
+    doc = yaml.safe_load(open(PUBLIC_INDEX))
+    for m in doc.get("models", []):
+        for v in m.get("variants", []):
+            has_hosted = bool(v.get("url"))
+            has_record = bool(v.get("verified"))
+            has_recipe = bool(v.get("recipe") or m.get("recipe") or v.get("source") or m.get("source"))
+            assert has_hosted or has_record or has_recipe, (
+                f"{m['model']} variant is neither hosted, recorded, nor buildable")
+
+
+def test_default_index_is_bundled_inside_the_package():
+    """The default index must live inside the `chipwright` package so it ships in the wheel and
+    resolves after a clean `pip install` — not at a repo-relative path that vanishes once installed."""
+    from chipwright.registry import DEFAULT_INDEX
+    assert os.path.exists(DEFAULT_INDEX), DEFAULT_INDEX
+    assert os.path.abspath(DEFAULT_INDEX).startswith(PKG + os.sep), (
+        f"DEFAULT_INDEX {DEFAULT_INDEX} is outside the package dir {PKG}; it won't ship in the wheel")
+
+
+def test_missing_sshpass_refuses_by_name(monkeypatch):
+    """`sshpass` is an undeclared-by-pip system dep; a missing binary must refuse by name with the
+    install hint, not raise a cryptic FileNotFoundError deep in subprocess (spec 003 FR-R05)."""
+    from chipwright import device
+    monkeypatch.setattr(device.shutil, "which", lambda _: None)
+    with pytest.raises(RuntimeError, match="sshpass"):
+        device.RemoteQNN("1.2.3.4", "root", "pw", 22)
+
+
+def _variant(**kw):
+    from chipwright.resolver import Variant
+    base = dict(model="x", version="1", arch="v68", quant="w8a16", shape="s",
+                sdk_tested="2.37.1", sdk_compatible=">=2.34,<2.40")
+    base.update(kw)
+    return Variant(**base)
+
+
+def test_locate_ref_local_path_expands(monkeypatch):
+    """A local run reference is just expanduser'd — unchanged behaviour."""
+    from chipwright import run as runmod
+    got = runmod._locate_ref({"cpu_onnx": "~/x/model.onnx"}, "cpu_onnx")
+    assert got == os.path.expanduser("~/x/model.onnx")
+    assert runmod._locate_ref({}, "meta") is None
+
+
+def test_locate_ref_url_fetches_by_sha(monkeypatch):
+    """A hosted (url) reference is fetched into the cache by its companion sha, keeping its filename."""
+    from chipwright import run as runmod, cache
+    calls = {}
+    monkeypatch.setattr(cache, "fetch_named",
+                        lambda url, sha, name, sidecars: calls.update(url=url, sha=sha, name=name, side=sidecars) or "/c/model.onnx")
+    r = {"cpu_onnx": "https://h/f/model.onnx", "cpu_onnx_sha256": "abc",
+         "cpu_onnx_sidecars": [{"url": "https://h/f/model.data", "sha256": "def", "name": "model.data"}]}
+    got = runmod._locate_ref(r, "cpu_onnx")
+    assert got == "/c/model.onnx"
+    assert calls["url"].endswith("model.onnx") and calls["sha"] == "abc" and calls["name"] == "model.onnx"
+    assert calls["side"] == [("https://h/f/model.data", "def", "model.data")]
+
+
+def test_locate_ref_url_without_sha_refuses_by_name():
+    """A url reference with no sha is refused — never fetch a reference the gate can't verify."""
+    from chipwright import run as runmod
+    with pytest.raises(RuntimeError, match="unverified reference|_sha256"):
+        runmod._locate_ref({"input": "https://h/f/input.npy"}, "input")
+
+
+def test_run_refuses_when_no_artifact(monkeypatch):
+    """Refusal path 1 (spec 003 FR-R02 / SC-R03): a record-only variant with no hosted url and no
+    local path must refuse by name — pointing at `build` and CW_REGISTRY — not a raw traceback."""
+    from chipwright import run as runmod
+    v = _variant(run={"modality": "asr_encoder"})  # no url, no local
+    with pytest.raises(RuntimeError, match="build .* chipwright build|CW_REGISTRY"):
+        runmod.run_variant(v)
+
+
+def test_run_refuses_when_no_cpu_reference(monkeypatch, tmp_path):
+    """Refusal path 2 (spec 003 FR-R03 / SC-R03): an artifact present but no CPU reference in the
+    active registry must refuse — the verification gate can't run, and a pass is never reported."""
+    from chipwright import run as runmod
+    art = tmp_path / "a.bin"
+    art.write_bytes(b"x")
+    v = _variant(local=str(art), run={"modality": "asr_encoder", "board_name": "fx"})  # no cpu_onnx
+
+    class _FakeDev:
+        def __init__(self, *a, **k):
+            pass
+
+        def ensure_ctx(self, _art, _name):
+            return "/board/ctx"
+
+    monkeypatch.setattr(runmod, "_board_env",
+                        lambda: dict(host="h", user="root", pw="p", port=22))
+    monkeypatch.setattr(runmod, "RemoteQNN", _FakeDev)
+    with pytest.raises(RuntimeError, match="CPU reference|verification gate"):
+        runmod.run_variant(v)

chipwright/tests/test_precision_support.py

@@ -0,0 +1,128 @@
+"""Precision-support matrix (FR-L06) + arch v79/v81 as first-class hard axes (FR-L05).
+
+Pure, no board: the recipe parse/validate and the resolver refusal are both plain functions. Also
+runnable as `python3 test_precision_support.py`.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from chipwright.env import TargetKey
+from chipwright.recipe import from_dict
+from chipwright.resolver import Outcome, Variant, precision_refusal, resolve
+
+
+# --- recipe schema: precision_support parses + validates -----------------------------------------
+_BASE = {"name": "qwen2.5-1.5b", "version": "1.0.0",
+         "source": {"format": "onnx", "sha256": "abc"},
+         "target": {"arch": "v81", "quant": "w4a16", "shape": "ctx4096"}}
+
+
+def _recipe(**extra):
+    doc = dict(_BASE)
+    doc.update(extra)
+    return from_dict(doc)
+
+
+def test_recipe_parses_precision_matrix():
+    r = _recipe(precision_support={
+        "w4a16": "supported",
+        "w8a16": "blocked:kv-cache-encoding",
+        "fp16": "unsupported:genie-engine"})
+    assert r.precision_status("w4a16") == "supported"
+    assert r.precision_status("w8a16") == "blocked:kv-cache-encoding"
+    assert r.supported_precisions == ["w4a16"]
+
+
+def test_recipe_without_matrix_is_empty_not_error():
+    r = _recipe()
+    assert r.precision_support == {} and r.supported_precisions == []
+
+
+def test_recipe_rejects_unknown_status_kind():
+    for bad in ({"w8a16": "maybe"}, {"w8a16": "nope:x"}):
+        try:
+            _recipe(precision_support=bad)
+        except ValueError:
+            continue
+        raise AssertionError(f"expected ValueError for {bad!r}")
+
+
+def test_recipe_rejects_blocked_without_reason():
+    for bad in ({"w8a16": "blocked"}, {"w8a16": "unsupported:"}, {"w8a16": "blocked: "}):
+        try:
+            _recipe(precision_support=bad)
+        except ValueError:
+            continue
+        raise AssertionError(f"a blocked/unsupported status must NAME a reason: {bad!r}")
+
+
+# --- the pure refusal helper ---------------------------------------------------------------------
+def test_precision_refusal_helper():
+    support = {"w4a16": "supported", "w8a16": "blocked:kv-cache-encoding"}
+    assert precision_refusal("w4a16", support) is None          # supported -> no refusal
+    assert precision_refusal("int4", support) is None           # not declared -> not refused here
+    assert precision_refusal("w8a16", support) == "blocked:kv-cache-encoding"
+    assert precision_refusal("w8a16", None) is None             # no matrix -> nothing to refuse
+
+
+# --- resolver refuses a non-supported precision and NAMES the reason -----------------------------
+_SUPPORT = {"w4a16": "supported", "w8a16": "blocked:kv-cache-encoding", "fp16": "unsupported:genie-engine"}
+
+
+def _llm_variant(arch="v81", quant="w4a16", **kw):
+    base = dict(model="qwen2.5-1.5b", version="1.0.0", arch=arch, quant=quant, shape="ctx4096",
+                sdk_tested="2.38.0", sdk_compatible=">=2.34,<2.40", precision_support=_SUPPORT)
+    base.update(kw)
+    return Variant(**base)
+
+
+def test_resolve_refuses_blocked_precision_by_name():
+    t = TargetKey(htp_arch="v81", qairt="2.38.0")
+    d = resolve(t, [_llm_variant(url="u", sha256="s")], want_quant="w8a16")
+    assert d.outcome is Outcome.FAIL and d.axis == "precision"
+    assert "kv-cache-encoding" in d.reason
+
+
+def test_resolve_refuses_unsupported_precision_by_name():
+    t = TargetKey(htp_arch="v81", qairt="2.38.0")
+    d = resolve(t, [_llm_variant(url="u", sha256="s")], want_quant="fp16")
+    assert d.outcome is Outcome.FAIL and d.axis == "precision"
+    assert "genie-engine" in d.reason
+
+
+def test_resolve_allows_supported_precision():
+    t = TargetKey(htp_arch="v81", qairt="2.38.0")
+    d = resolve(t, [_llm_variant(url="u", sha256="s")], want_quant="w4a16")
+    assert d.ok and d.outcome is Outcome.USE
+
+
+def test_resolve_takes_explicit_matrix_over_variants():
+    # a caller may pass the matrix directly (e.g. straight from the recipe) — it wins
+    t = TargetKey(htp_arch="v81", qairt="2.38.0")
+    v = _llm_variant(url="u", sha256="s", precision_support=None)
+    d = resolve(t, [v], want_quant="w8a16", precision_support=_SUPPORT)
+    assert d.outcome is Outcome.FAIL and d.axis == "precision"
+
+
+# --- arch v79 and v81 are first-class hard axes (not special-cased anywhere) ----------------------
+def test_arch_v79_and_v81_resolve_as_hard_axis():
+    for arch in ("v79", "v81"):
+        t = TargetKey(htp_arch=arch, qairt="2.38.0")
+        d = resolve(t, [_llm_variant(arch=arch, url="u", sha256="s")], want_quant="w4a16")
+        assert d.ok, f"{arch} should USE its own artifact"
+
+
+def test_arch_mismatch_v79_vs_v81_fails_on_arch_axis():
+    t = TargetKey(htp_arch="v79", qairt="2.38.0")           # board is v79
+    d = resolve(t, [_llm_variant(arch="v81", url="u", sha256="s")], want_quant="w4a16")
+    assert d.outcome is Outcome.FAIL and d.axis == "htp_arch"
+    assert "v79" in d.reason
+
+
+if __name__ == "__main__":
+    fns = [f for n, f in sorted(globals().items()) if n.startswith("test_")]
+    for f in fns:
+        f(); print("ok", f.__name__)
+    print(f"\n{len(fns)} passed")

chipwright/tests/test_registry.py

@@ -0,0 +1,107 @@
+"""Registry — load the bundled public index (chipwright/data/index.yaml, read-only) and check Variant parsing.
+
+Uses the real seed index so the test fails if the shipped index stops parsing. Also runnable as
+`python3 test_registry.py`.
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
+
+from chipwright.registry import DEFAULT_INDEX, Registry
+
+
+def test_bundled_index_exists_and_loads():
+    assert os.path.exists(DEFAULT_INDEX), DEFAULT_INDEX
+    reg = Registry()
+    assert reg.schema == 1
+    models = reg.models()
+    for expected in ("laya-decision", "whisper-small-en", "zipformer-enin", "qwen2.5-1.5b-instruct"):
+        assert expected in models, expected
+
+
+def test_each_model_yields_variants():
+    reg = Registry()
+    for model in reg.models():
+        vs = reg.variants(model)
+        assert vs, f"{model} has no variants"
+        for v in vs:
+            assert v.model == model
+            assert v.arch and v.quant and v.shape
+
+
+def test_hosted_variant_has_artifact():
+    reg = Registry()
+    laya = reg.variants("laya-decision")[0]
+    assert laya.url is not None
+    assert laya.sha256 is not None
+    assert laya.has_artifact is True
+
+
+def test_recipe_only_variant_has_recipe_not_artifact():
+    reg = Registry()
+    whisper = reg.variants("whisper-small-en")[0]
+    assert whisper.url is None and whisper.local is None
+    assert whisper.has_artifact is False
+    assert whisper.has_recipe is True
+    assert whisper.recipe.endswith(".yaml")
+
+
+# The public registry is portable (no author-local paths — see spec 003), so the `local` and
+# run-asset fields are exercised against a fixture registry, not the shipped index. This tests the
+# PARSER capability without coupling it to machine-specific content.
+_FIXTURE = """registry_schema: 1
+models:
+  - model: fixture-model
+    variants:
+      - arch: v68
+        quant: w8a16
+        shape: win39
+        sdk_tested: "2.37.1"
+        sdk_compatible: ">=2.34,<2.40"
+        ext: qnnctx
+        local: /tmp/fixture_artifact.bin
+        run: {modality: asr_encoder, board_name: fx, meta: /tmp/m.json, cpu_onnx: /tmp/e.onnx, input: /tmp/i.npy, threshold: 0.95}
+"""
+
+
+def _fixture_registry(tmp_path):
+    p = tmp_path / "fixture_index.yaml"
+    p.write_text(_FIXTURE)
+    return Registry(index=str(p))
+
+
+def test_local_field_parses_as_on_disk_artifact(tmp_path):
+    v = _fixture_registry(tmp_path).variants("fixture-model")[0]
+    # a `local:` path counts as a present artifact even with no url
+    assert v.url is None
+    assert v.local is not None and v.local.endswith(".bin")
+    assert v.has_artifact is True
+
+
+def test_run_field_parses_into_dict(tmp_path):
+    v = _fixture_registry(tmp_path).variants("fixture-model")[0]
+    assert isinstance(v.run, dict)
+    assert v.run["modality"] == "asr_encoder"
+    assert v.run["threshold"] == 0.95
+    for key in ("board_name", "meta", "cpu_onnx", "input"):
+        assert key in v.run
+
+
+def test_verified_record_parses():
+    reg = Registry()
+    laya = reg.variants("laya-decision")[0]
+    assert isinstance(laya.verified, dict)
+    assert laya.verified["loads"] is True
+
+
+def test_unknown_model_returns_empty_list():
+    reg = Registry()
+    assert reg.variants("does-not-exist") == []
+
+
+if __name__ == "__main__":
+    fns = [f for n, f in sorted(globals().items()) if n.startswith("test_")]
+    for f in fns:
+        f(); print("ok", f.__name__)
+    print(f"\n{len(fns)} passed")