Kemal Yaylali
07a01715fd
A table with filters made the user do the work. Rare disease triage is a different task:
which few variants could explain *this* patient's phenotype, and why. The app now answers
that, and lets a reviewer act on the answer.
Domain
- a case is a proband: a VCF plus the HPO terms observed in the patient (samples -> cases)
- HPO's gene-to-phenotype annotations are loaded as reference data (scripts/load-hpo.py)
- each candidate can be shortlisted or dismissed with a reason and a note
Ranking (app/services/triage.py, 21 tests)
- weighted sum of phenotype match, rarity, consequence severity and the model's score,
with every component shown next to the candidate
- rarity and consequence filter; phenotype only ranks, because a real diagnosis can sit in
a gene nobody has annotated yet and filtering on it would hide exactly that case
- ClinVar is deliberately not an input: it appears beside the result as independent
confirmation, so nothing ranks highly merely because ClinVar already said pathogenic
UI
- the funnel is the headline: variants called -> rare -> coding candidates -> phenotype-matched
- ranked candidates with evidence chips, not a grid of everything; filters are demoted
- a variant panel showing the score breakdown, the matched HPO terms, the raw VEP record and
links out to Ensembl/gnomAD/ClinVar, with the decision controls
- a printable case report: phenotype, funnel, shortlisted variants with reasons, provenance
API: /cases with phenotypes, /cases/{id}/candidates (funnel + ranked + weights),
/variants/{id}, /variants/{id}/decision, /cases/{id}/report, /phenotypes for the picker.
Scoring moved under the case and now answers 503 with the reason when no model registry is
reachable, instead of a 500.
Verified end to end on a simulated proband (scripts/make-demo-case.sh: real GIAB HG002
background + one real ClinVar 2-star pathogenic NF2 variant). 13 variants called -> 1 coding
candidate, and the planted variant ranks first at 0.80 on phenotype 1.00, rarity 1.00 and
consequence 1.00, with ClinVar agreeing afterwards.
Tests: api 75, ml 18, loader 16, web 27; ruff, mypy, svelte-check, terraform validate, both
kustomize overlays and the Nextflow stub run all clean.
80 lines
2.7 KiB
Python
80 lines
2.7 KiB
Python
"""Assemble a case's ranked candidates: load the latest results, rank them, attach decisions.
|
|
|
|
Everything for one job is loaded at once, which is fine for a gene panel or a chromosome — the
|
|
size of case this demo handles. A whole genome would need the narrowing pushed into SQL.
|
|
"""
|
|
import uuid
|
|
from dataclasses import dataclass
|
|
|
|
from sqlalchemy import select
|
|
from sqlalchemy.ext.asyncio import AsyncSession
|
|
from sqlalchemy.orm import selectinload
|
|
|
|
from app.models import Case, GenePhenotype, Job, JobStatus, Variant
|
|
from app.services import triage
|
|
|
|
EMPTY_FUNNEL = triage.Funnel(total=0, rare=0, candidates=0, phenotype_matched=0)
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class CaseView:
|
|
case: Case
|
|
job: Job | None
|
|
funnel: triage.Funnel
|
|
candidates: list[triage.Candidate]
|
|
|
|
@property
|
|
def labels(self) -> dict[str, str]:
|
|
return {p.hpo_id: p.label for p in self.case.phenotypes}
|
|
|
|
|
|
async def get_case(session: AsyncSession, case_id: uuid.UUID) -> Case | None:
|
|
return await session.scalar(
|
|
select(Case).where(Case.id == case_id).options(selectinload(Case.phenotypes))
|
|
)
|
|
|
|
|
|
async def latest_job(
|
|
session: AsyncSession, case_id: uuid.UUID, *, status: JobStatus | None = None
|
|
) -> Job | None:
|
|
stmt = select(Job).where(Job.case_id == case_id).order_by(Job.created_at.desc()).limit(1)
|
|
if status is not None:
|
|
stmt = stmt.where(Job.status == status)
|
|
return await session.scalar(stmt)
|
|
|
|
|
|
async def gene_terms_for(session: AsyncSession, genes: set[str]) -> dict[str, set[str]]:
|
|
"""gene symbol -> the HPO terms annotated to it."""
|
|
if not genes:
|
|
return {}
|
|
rows = await session.execute(
|
|
select(GenePhenotype.gene_symbol, GenePhenotype.hpo_id).where(
|
|
GenePhenotype.gene_symbol.in_(genes)
|
|
)
|
|
)
|
|
index: dict[str, set[str]] = {}
|
|
for gene, hpo_id in rows:
|
|
index.setdefault(gene, set()).add(hpo_id)
|
|
return index
|
|
|
|
|
|
async def build(session: AsyncSession, case: Case) -> CaseView:
|
|
job = await latest_job(session, case.id, status=JobStatus.succeeded)
|
|
if job is None:
|
|
return CaseView(case=case, job=None, funnel=EMPTY_FUNNEL, candidates=[])
|
|
variants = (
|
|
await session.scalars(
|
|
select(Variant)
|
|
.where(Variant.job_id == job.id)
|
|
.options(selectinload(Variant.prediction), selectinload(Variant.decision))
|
|
)
|
|
).all()
|
|
case_terms = [p.hpo_id for p in case.phenotypes]
|
|
gene_terms = await gene_terms_for(session, {v.gene for v in variants if v.gene})
|
|
return CaseView(
|
|
case=case,
|
|
job=job,
|
|
funnel=triage.funnel(variants, case_terms, gene_terms),
|
|
candidates=triage.rank(variants, case_terms, gene_terms),
|
|
)
|