Spaces:
Running
Running
| """Check the compiler against landmark editing designs. | |
| The question anyone serious asks within two minutes is "how do you know it's | |
| right?", and "it is deterministic and well tested" is an engineering answer to | |
| a scientific question. This is the scientific answer: run the compiler against | |
| designs the field has already settled and show it arrives at the same verdict. | |
| THE CLAIM THIS SUPPORTS, STATED PRECISELY | |
| ----------------------------------------- | |
| It reproduces **known-correct decisions**. It does NOT discover new biology, | |
| and the two must never be blurred — the first is defensible and the second | |
| would be a lie a reviewer could take apart in one question. | |
| TWO KINDS OF CASE, COUNTED SEPARATELY | |
| ------------------------------------- | |
| `basis="chemistry"` the expected verdict follows from the genetic code and | |
| the two base-editor chemistries. Anyone can re-derive | |
| it, so it needs no citation and counts as validation. | |
| `basis="literature"` the expectation is a claim about what a real programme | |
| actually did. It requires a citation. Without one the | |
| case is reported UNVERIFIED and does **not** count as a | |
| pass — it is a named gap, which is more useful than a | |
| silent absence. | |
| That split is the honesty mechanism. "12 of 12 validated" means nothing if | |
| half were asserted from memory; here the report always carries both numbers | |
| and the unverified ones by name. | |
| Pure logic: no network, no GPU, no model. It runs in CI on every commit, so a | |
| change that breaks a landmark verdict fails the build rather than being | |
| noticed in a demo. | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import pathlib | |
| from dataclasses import dataclass, field | |
| from typing import Any, Dict, List, Optional | |
| from dee.core import compiler as _compiler | |
| __all__ = ["CaseResult", "ValidationReport", "load_cases", "run_validation", | |
| "report_to_dict"] | |
| CORPUS_PATH = (pathlib.Path(__file__).resolve().parent.parent | |
| / "data" / "landmark_designs.json") | |
| class CaseResult: | |
| case_id: str | |
| name: str | |
| basis: str | |
| status: str # "pass" | "fail" | "unverified" | |
| expected: Dict[str, Any] = field(default_factory=dict) | |
| observed: Dict[str, Any] = field(default_factory=dict) | |
| mismatches: List[str] = field(default_factory=list) | |
| why: str = "" | |
| citation: str = "" | |
| class ValidationReport: | |
| results: List[CaseResult] | |
| def chemistry_total(self) -> int: | |
| return sum(1 for r in self.results if r.basis == "chemistry") | |
| def chemistry_passed(self) -> int: | |
| return sum(1 for r in self.results | |
| if r.basis == "chemistry" and r.status == "pass") | |
| def unverified(self) -> List[str]: | |
| return [r.name for r in self.results if r.status == "unverified"] | |
| def failures(self) -> List[CaseResult]: | |
| return [r for r in self.results if r.status == "fail"] | |
| def headline(self) -> str: | |
| """One sentence that cannot be misread as more than it is.""" | |
| n, tot = self.chemistry_passed, self.chemistry_total | |
| base = (f"{n} of {tot} landmark decisions reproduced " | |
| "(derivable from the genetic code and base-editor chemistry)") | |
| if self.unverified: | |
| base += (f"; {len(self.unverified)} further case(s) awaiting a " | |
| "citation and not counted") | |
| return base + "." | |
| def load_cases(path: Optional[pathlib.Path] = None) -> List[Dict[str, Any]]: | |
| p = path or CORPUS_PATH | |
| if not p.exists(): | |
| return [] | |
| data = json.loads(p.read_text()) | |
| return [c for c in (data.get("cases") or []) if isinstance(c, dict)] | |
| def _expand_allele(value: Any) -> str: | |
| """Alleles may be a literal string or {"repeat": "A", "times": 400}. | |
| The compact form exists because a 400-base deletion is a legitimate case | |
| and pasting 400 characters into JSON makes the corpus unreadable. It is | |
| NOT a shorthand the compiler understands — an earlier corpus wrote "A400" | |
| expecting it to mean 400 A's, and the compiler correctly read it as an | |
| allele containing a digit and refused. The harness caught that, which is | |
| the harness working. | |
| """ | |
| if isinstance(value, dict): | |
| base = str(value.get("repeat") or "") | |
| times = int(value.get("times") or 0) | |
| return base * times | |
| return str(value or "") | |
| def _observe(case: Dict[str, Any]) -> Dict[str, Any]: | |
| """Run the compiler on a case and flatten what it decided.""" | |
| call = _compiler.classify_lesion(_expand_allele(case.get("wt_base")), | |
| _expand_allele(case.get("patient_base"))) | |
| corr = call.correction | |
| return { | |
| "compiles": call.compiles, | |
| "route": call.route, | |
| "editor_family": corr.editor_family if corr else None, | |
| "strand": corr.strand if corr else None, | |
| "diagnostics": [d.code for d in call.diagnostics], | |
| } | |
| def _compare(expected: Dict[str, Any], observed: Dict[str, Any]) -> List[str]: | |
| """Only the keys the case actually asserts. A case that says nothing about | |
| strand is not failed for the strand.""" | |
| out: List[str] = [] | |
| for key in ("compiles", "route", "editor_family", "strand"): | |
| if key in expected and observed.get(key) != expected[key]: | |
| out.append(f"{key}: expected {expected[key]!r}, " | |
| f"got {observed.get(key)!r}") | |
| want_diag = expected.get("diagnostic") | |
| if want_diag and want_diag not in (observed.get("diagnostics") or []): | |
| out.append(f"diagnostic {want_diag!r} not raised " | |
| f"(raised {observed.get('diagnostics')!r})") | |
| return out | |
| def run_validation(cases: Optional[List[Dict[str, Any]]] = None | |
| ) -> ValidationReport: | |
| """Every case, with literature cases short-circuited unless cited.""" | |
| results: List[CaseResult] = [] | |
| for case in (cases if cases is not None else load_cases()): | |
| basis = str(case.get("basis") or "literature") | |
| why = case.get("why") | |
| why_text = " ".join(why) if isinstance(why, list) else str(why or "") | |
| citation = str(case.get("citation") or "").strip() | |
| expected = case.get("expect") or {} | |
| # A literature claim without a citation is not evidence, and must not | |
| # be run as though it were — an uncited expectation is just a guess | |
| # with a filename. | |
| if basis == "literature" and not citation: | |
| results.append(CaseResult( | |
| case_id=str(case.get("id") or ""), name=str(case.get("name") or ""), | |
| basis=basis, status="unverified", expected=expected, | |
| why=why_text, citation=citation)) | |
| continue | |
| if not expected: | |
| results.append(CaseResult( | |
| case_id=str(case.get("id") or ""), name=str(case.get("name") or ""), | |
| basis=basis, status="unverified", expected={}, | |
| why=why_text or "No expectation recorded.", citation=citation)) | |
| continue | |
| observed = _observe(case) | |
| mismatches = _compare(expected, observed) | |
| results.append(CaseResult( | |
| case_id=str(case.get("id") or ""), name=str(case.get("name") or ""), | |
| basis=basis, status="pass" if not mismatches else "fail", | |
| expected=expected, observed=observed, mismatches=mismatches, | |
| why=why_text, citation=citation)) | |
| return ValidationReport(results) | |
| def report_to_dict(report: ValidationReport) -> Dict[str, Any]: | |
| return { | |
| "headline": report.headline, | |
| "chemistry_passed": report.chemistry_passed, | |
| "chemistry_total": report.chemistry_total, | |
| "unverified": report.unverified, | |
| "all_passed": not report.failures, | |
| "cases": [ | |
| {"id": r.case_id, "name": r.name, "basis": r.basis, | |
| "status": r.status, "expected": r.expected, "observed": r.observed, | |
| "mismatches": r.mismatches, "why": r.why, "citation": r.citation} | |
| for r in report.results | |
| ], | |
| } | |