@dsh-bio/dsh-bio-gem 0.1.1

package/python/build.py

@@ -0,0 +1,343 @@
+# build.py — dsh-bio-gem M1：CarveMe 基因组→SBML 构建（纯 Windows）
+# 流程: 输入(protein.faa 优先; accesson 与 GFF+fna 二期待支持) -> carve 子进程
+#       -> validate G1-G3 -> 若 G3 FAIL 且给了 medium -> gapfind/gapfill 闭环 -> 模型卡 sidecar
+# 进度: 独立 CLI 模式将事件写入 <out>.progress.jsonl（TS 层 jobs.js 轮询）；CARVE_CMD 可被 env 覆盖。
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+import datetime
+
+# Python -I isolated 模式下脚本目录不进 sys.path——显式插入以导入同目录模块
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+DEFAULT_CARVE_VENV = os.path.join(os.path.expanduser("~"), ".dsh", "dsh-bio-gem", "venv-carveme")
+MODEL_ROOT = os.path.join(os.path.expanduser("~"), ".dsh", "dsh-bio-gem", "models")
+
+
+def _log(progress_path, event):
+    ev = {"ts": time.time(), **event}
+    with open(progress_path, "a", encoding="utf-8") as f:
+        f.write(json.dumps(ev, ensure_ascii=False) + "\n")
+
+
+def _carve_exe(venv=None):
+    venv = venv or DEFAULT_CARVE_VENV
+    exe = os.path.join(venv, "Scripts", "carve.exe")
+    if not os.path.exists(exe):
+        exe = "carve"  # 退回 PATH
+    return exe
+
+
+def resolve_input(input_spec, progress_path=None, engine="carveme"):
+    """输入归一化。
+    engine=carveme: *.faa（蛋白）；engine=gapseq: *.fna（核苷酸）——gapseq 吃 DNA。
+    accession 下载二期待支持。"""
+    if not input_spec:
+        raise ValueError("input required (protein.faa / accession / local files)")
+    if input_spec.lower().startswith(("gcf_", "gca_")):
+        raise NotImplementedError(
+            "accession 下载二期待支持：请先用 datasets CLI 或 NCBI 下载蛋白/基因组，再传入本地路径")
+    p = input_spec
+    if not os.path.exists(p):
+        d = os.path.dirname(p)
+        cands = []
+        if os.path.isdir(d):
+            cands = [f for f in os.listdir(d)
+                     if f.lower().endswith((".fna", ".faa", ".fasta", ".fa"))][:6]
+        raise ValueError(f"输入文件不存在: {p}；目录内候选: {cands or '无'}")
+    low = p.lower()
+    if engine == "gapseq":
+        if low.endswith((".fna", ".fasta", ".fa", ".fna.gz", ".fasta.gz")):
+            return p
+        raise ValueError(f"gapseq 引擎需要核苷酸 fasta（.fna/.fasta）：{p}")
+    if low.endswith((".faa", ".fasta", ".fa", ".faa.gz", ".fasta.gz")):
+        return p
+    if engine == "carveme" and low.endswith((".fna", ".fna.gz")):
+        # 路线 P0：裸/带注释基因组 -> 注释层 -> 蛋白（官方优先 + pyrodigal 兜底）
+        from annotate import nucleotide_to_protein
+        faa, src, stats = nucleotide_to_protein(p)
+        print(f"[annotate] source={src} seqs={stats.get('seqs')} -> {faa}")
+        return faa
+    raise ValueError(f"unsupported input type: {p}（carveme 请提供 protein.faa 或 genomic.fna；gapseq 请提供 genomic.fna）")
+
+
+def run_carve(proteins, out_xml, venv=None, progress_path=None, timeout=3600, gapfill_medium="M9"):
+    exe = _carve_exe(venv)
+    cmd = [exe, proteins, "-o", out_xml, "-g", gapfill_medium]
+    _log(progress_path, {"event": "carve_start", "cmd": " ".join(cmd)})
+    st = time.time()
+    env = dict(os.environ)
+    # carve 从 PATH 找 diamond（Windows venv 不激活时 Scripts 不在 PATH）——显式注入
+    script_dir = os.path.join(venv or DEFAULT_CARVE_VENV, "Scripts")
+    if script_dir and script_dir not in env.get("PATH", ""):
+        env["PATH"] = script_dir + os.pathsep + env.get("PATH", "")
+    try:
+        r = subprocess.run(cmd, capture_output=True, text=True, timeout=timeout,
+                           env=env, encoding="utf-8", errors="replace")
+    except subprocess.TimeoutExpired:
+        _log(progress_path, {"event": "carve_timeout", "s": int(timeout)})
+        raise
+    dt = time.time() - st
+    if r.returncode != 0:
+        _log(progress_path, {"event": "carve_fail", "rc": r.returncode,
+                             "stderr_tail": (r.stderr or "")[-800:],
+                             "stdout_tail": (r.stdout or "")[-400:]})
+        raise RuntimeError(f"carve failed rc={r.returncode}: {(r.stderr or '')[-800:]}")
+    _log(progress_path, {"event": "carve_done", "s": round(dt, 1),
+                         "stdout_tail": (r.stdout or "")[-300:]})
+    return out_xml
+
+
+def _active_medium(m):
+    """模型当前打开的交换 -> {EX_id: lb}（carve gapfill 实际设置的介质，可溯源）。
+    注意：CarveMe 默认把所有 EX 设成开放(-1000)，故全开交换数≠真介质成分；
+    精确介质请用 _media_db_exchanges()。"""
+    return {r.id: r.lower_bound for r in m.reactions
+            if r.id.startswith("EX_") and r.lower_bound < 0}
+
+
+def _media_db_exchanges(m, medium_name="M9", default_lb=-10.0):
+    """从 carveme 自带 media_db.tsv 提取介质成分 -> 模型 EX 交换字典（精确介质）。"""
+    import csv
+    db = os.path.join(DEFAULT_CARVE_VENV, "Lib", "site-packages", "carveme",
+                      "data", "input", "media_db.tsv")
+    if not os.path.exists(db):
+        return _active_medium(m)  # 退化：全部开放交换
+    comps = set()
+    with open(db, encoding="utf-8") as f:
+        rd = csv.DictReader(f, delimiter="\t")
+        for row in rd:
+            if row.get("medium") == medium_name and row.get("compound"):
+                comps.add(row["compound"].strip())
+    out = {}
+    for c in sorted(comps):
+        exid = "EX_" + c + "_e"
+        if exid in m.reactions:
+            out[exid] = default_lb
+    return out or _active_medium(m)
+
+
+def build(input_spec, name=None, medium=None, venv=None, out_dir=None, progress_path=None,
+          engine="carveme"):
+    """主入口。engine:
+      carveme（默认）: protein.faa -> carve(M9 gapfill) -> validate M9 -> 目标介质闭环
+      gapseq（M2）  : genomic.fna -> WSL2 gapseq doall（30-60min，需探测 OK）-> 模型 -> 目标介质验证
+    """
+    if progress_path is None:
+        progress_path = os.path.join(tempfile.gettempdir(), "gem_build.progress.jsonl")
+    _log(progress_path, {"event": "build_start", "input": input_spec, "engine": engine})
+    if engine == "gapseq":
+        return _build_gapseq(input_spec, name=name, medium=medium, out_dir=out_dir,
+                             progress_path=progress_path)
+    proteins = resolve_input(input_spec, progress_path, engine="carveme")
+    name = name or os.path.splitext(os.path.basename(proteins))[0]
+    out_dir = out_dir or MODEL_ROOT
+    os.makedirs(out_dir, exist_ok=True)
+    out_xml = os.path.join(out_dir, name + ".xml")
+
+    # 1) carve（自带 M9 gapfill，CarveMe 原生最小培养基）
+    st = time.time()
+    if not (os.path.exists(out_xml) and os.path.getmtime(out_xml) > os.path.getmtime(proteins)):
+        run_carve(proteins, out_xml, venv=venv, progress_path=progress_path,
+                  gapfill_medium="M9")
+    else:
+        _log(progress_path, {"event": "carve_skip_cached"})
+
+    from silentio import silent_read_sbml
+    m1 = silent_read_sbml(out_xml)
+    med_m9 = _media_db_exchanges(m1, "M9")  # 精确 M9 成分（非全开近似）
+
+    # 2) validate G1-G3：M9 介质（构建产物实测）
+    from validate import validate_model
+    rep_m9 = validate_model(out_xml, medium=med_m9, reference_growth=None)
+    g3_m9 = rep_m9["g3"]
+    _log(progress_path, {"event": "validate_m9", "overall": rep_m9["overall"],
+                         "g3": g3_m9["status"], "growth": g3_m9.get("growth_medium"),
+                         "exch": len(med_m9)})
+
+    # 3) 用户目标介质（可选）：preset 展开 + resolve -> G3；FAIL 时 L1/L2 规则补洞闭环
+    target = None
+    user_rep = None
+    if medium:
+        from gapfind import resolve_medium, expand_medium
+        medium_exp, preset_used = expand_medium(medium)
+        resolved, unresolved = resolve_medium(m1, medium_exp)
+        _log(progress_path, {"event": "target_medium", "preset": preset_used,
+                             "resolved": len(resolved), "unresolved": unresolved})
+        user_rep = validate_model(out_xml, medium=resolved, reference_growth=None)
+        g3_user = user_rep["g3"]
+        gapfixes = []
+        if g3_user["status"] == "FAIL" and resolved:
+            _log(progress_path, {"event": "gapfill_start"})
+            from gapfill import apply_fixes
+            gf = apply_fixes(out_xml, medium=resolved, max_add=20,
+                             out=out_xml[:-4] + "_gf.xml")
+            gapfixes = gf.get("applied", [])
+            if gapfixes:
+                user_rep = validate_model(gf["out"], medium=resolved, reference_growth=None)
+                out_xml = gf["out"]
+                g3_user = user_rep["g3"]
+                _log(progress_path, {"event": "gapfill_done", "applied": len(gapfixes),
+                                     "g3_after": g3_user["status"],
+                                     "growth_after": g3_user.get("growth_medium")})
+        target = {
+            "medium": medium, "resolved_exchanges": len(resolved),
+            "unresolved": unresolved,
+            "g3": user_rep["g3"]["status"],
+            "growth": user_rep["g3"].get("growth_medium"),
+            "gapfixes_applied": len(gapfixes if 'gapfixes' in dir() else []),
+        }
+        # 若 M9 已 PASS 而用户介质 FAIL：诚实保留（模型可用介质=M9）
+    dt = round(time.time() - st, 1)
+    # 4) 模型卡（schema v2 起步：supported_mediums 由验证结果得出）
+    supported = [
+        {"medium_name": "M9", "ex_reactions": sorted(med_m9),
+         "growth_rate": g3_m9.get("growth_medium"), "units": "mmol/gDW/h",
+         "validation_status": "verified_G3" if g3_m9.get("status") == "PASS" else "unverified"},
+    ]
+    if target and target.get("g3") == "PASS":
+        tname = "custom"
+        if isinstance(medium, dict):
+            tname = medium.get("medium_name") or "custom"
+        supported.append({
+            "medium_name": tname, "ex_reactions": target.get("resolved_exchanges"),
+            "growth_rate": target.get("growth"), "units": "mmol/gDW/h",
+            "validation_status": "verified_G3_G4" if target.get("gapfixes_applied", 0) == 0 else "verified_G3_only",
+        })
+    # 模型卡（schema v2：init_card 统一基座 —— lineage v0.1.0 起始 + changelog=[build]）
+    from model_card import init_card
+    card, card_path = init_card(
+        out_xml, name=name, engine="carveme", changelog_note="build",
+        engine_version=_carve_version(venv),
+        carve_cmd="carve INPUT -o OUT -g M9",
+        started=datetime.datetime.now().isoformat(timespec="seconds"),
+        elapsed_s=dt, model=out_xml,
+        validations_m9={k: rep_m9[k]["status"] for k in ("g1", "g2", "g3")},
+        growth_g3_m9=g3_m9.get("growth_medium"),
+        m9_exchanges=len(med_m9),
+        target=target,
+        supported_mediums=supported,
+        mapping={"protein_input": proteins})
+    _log(progress_path, {"event": "build_done", "model": out_xml, "card": card_path, "s": dt})
+    return {"model": out_xml, "card": card_path,
+            "validations_m9": card["validations_m9"],
+            "growth_g3_m9": card["growth_g3_m9"],
+            "target": target or {"note": "no target medium provided"},
+            "elapsed_s": dt}
+
+
+def _build_gapseq(input_fna, name=None, medium=None, out_dir=None, progress_path=None):
+    """gapseq 引擎：WSL2 桥 doall（30-60min）→ 模型拷回 → 目标介质验证闭环 → 模型卡。"""
+    from gapseq_wsl import probe, run_gapseq
+    from silentio import silent_read_sbml
+    from validate import validate_model
+    from gapfind import expand_medium, resolve_medium
+
+    _log(progress_path, {"event": "gapseq_probe"})
+    p = probe()
+    if not p.get("capable"):
+        _log(progress_path, {"event": "gapseq_unavailable", "level": p.get("level"),
+                             "detail": (p.get("detail") or "")[:300]})
+        raise RuntimeError(
+            f"gapseq 引擎不可用（level={p.get('level')}）：{(p.get('detail') or '')[:300]}。"
+            "请先配置 WSL2 + gapseq 环境，或改用 carveme 引擎。")
+
+    input_fna = resolve_input(input_fna, progress_path, engine="gapseq")
+    name = name or os.path.splitext(os.path.basename(input_fna))[0]
+    out_dir = out_dir or MODEL_ROOT
+    os.makedirs(out_dir, exist_ok=True)
+    _log(progress_path, {"event": "gapseq_start", "note": "doall 30-60min，后台等待不误判超时"})
+    st = time.time()
+    model = None
+    try:
+        model, log_tail = run_gapseq(input_fna, out_dir, name=name,
+                                     progress=(lambda ev: _log(progress_path, ev)))
+    except Exception as e:
+        _log(progress_path, {"event": "gapseq_fail", "err": str(e)[:300]})
+        raise
+    dt = round(time.time() - st, 1)
+    _log(progress_path, {"event": "gapseq_done", "model": model, "s": dt})
+
+    # 目标介质验证（gapseq 模型用 AB 自然名/用户 medium；无 medium 时 M9 兜底）
+    target = None
+    med_exp, preset_used = expand_medium(medium) if medium else ({}, None)
+    if medium:
+        m1 = silent_read_sbml(model)
+        resolved, unresolved = resolve_medium(m1, med_exp)
+        rep = validate_model(model, medium=resolved, reference_growth=None)
+        g3 = rep["g3"]
+        gapfixes = []
+        if g3["status"] == "FAIL" and resolved:
+            _log(progress_path, {"event": "gapseq_gapfill_start"})
+            from gapfill import apply_fixes
+            gf = apply_fixes(model, medium=resolved, max_add=20,
+                             out=model[:-4] + "_gf.xml")
+            gapfixes = gf.get("applied", [])
+            if gapfixes:
+                model = gf["out"]
+                rep = validate_model(model, medium=resolved, reference_growth=None)
+                g3 = rep["g3"]
+            _log(progress_path, {"event": "gapseq_gapfill_done", "applied": len(gapfixes),
+                                 "g3_after": g3["status"]})
+        target = {"medium": medium, "preset": preset_used, "g3": g3["status"],
+                  "growth": g3.get("growth_medium"), "unresolved": unresolved,
+                  "gapfixes_applied": len(gapfixes)}
+    else:
+        _log(progress_path, {"event": "gapseq_no_medium"})
+        rep = None
+
+    from model_card import init_card
+    card, card_path = init_card(
+        model, name=name, engine="gapseq", changelog_note="build",
+        engine_version=p.get("gapseq_version"),
+        gapseq_probe=p.get("level"),
+        started=datetime.datetime.now().isoformat(timespec="seconds"),
+        elapsed_s=dt, model=model,
+        validations={k: rep[k]["status"] for k in ("g1", "g2", "g3")} if rep else None,
+        growth_g3=rep["g3"].get("growth_medium") if rep else None,
+        target=target,
+        mapping={"genome_input": input_fna})
+    _log(progress_path, {"event": "build_done", "model": model, "card": card_path, "s": dt})
+    return {"model": model, "card": card_path,
+            "validations": card["validations"], "growth_g3": card["growth_g3"],
+            "target": target or {"note": "no target medium provided"},
+            "engine": "gapseq", "elapsed_s": dt}
+
+
+def _carve_version(venv=None):
+    try:
+        venv = venv or DEFAULT_CARVE_VENV
+        py = os.path.join(venv, "Scripts", "python.exe")
+        r = subprocess.run([py, "-c",
+                            "import importlib.metadata as im; print(im.version('carveme'))"],
+                           capture_output=True, text=True, timeout=60)
+        return (r.stdout or "").strip() or "unknown"
+    except Exception:
+        return "unknown"
+
+
+if __name__ == "__main__":
+    import argparse
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--input", required=True)
+    ap.add_argument("--name")
+    ap.add_argument("--engine", default="carveme", choices=["carveme", "gapseq"])
+    ap.add_argument("--medium-json")
+    ap.add_argument("--out-dir")
+    ap.add_argument("--progress")
+    a = ap.parse_args()
+    medium = json.loads(a.medium_json) if a.medium_json else None
+    try:
+        res = build(a.input, name=a.name, medium=medium, out_dir=a.out_dir,
+                    progress_path=a.progress, engine=a.engine)
+        print(json.dumps({"ok": True, "result": res}, ensure_ascii=False))
+    except Exception as e:
+        import traceback
+        sys.stderr.write("Traceback (most recent call last):\n")
+        traceback.print_exc(file=sys.stderr)
+        print(json.dumps({"ok": True, "result": None,
+                          "error_hint": f"build failed: {type(e).__name__}: {e}"},
+                         ensure_ascii=False))

package/python/build_whitelist.py

@@ -0,0 +1,127 @@
+# build_whitelist.py — B' 白名单 B0/B1：gapseq rxn 库 -> 反应白名单（本地基准，license 守则：不分发）
+# B0: 聚合 rxn/*.fasta（非空）→ rxn_proteins.fa + mapping（序列header -> 反应ID）
+# B1: diamond makedb + blastp 目标物种 faa → 命中反应集（EVIDENCE_sequence 候选池）
+import os
+import sys
+import time
+
+SEQDB = os.environ.get("GEM_GAPSEQ_DB", r"F:\Datasets\gapseq\db\Bacteria")
+DIAMOND = r"C:\Users\shuai\.dsh\dsh-bio-gem\venv-carveme\Scripts\diamond.exe"
+
+
+def build_rxn_fasta(out_fa, out_map=None, min_size=100):
+    """聚合 rxn/ 非空文件（文件名=反应 ID）→ 序列 fasta + mapping。返回 (seqs, files_used)。"""
+    rxn_dir = os.path.join(SEQDB, "rxn")
+    n_seq = 0
+    n_file = 0
+    with open(out_fa, "w", encoding="utf-8", errors="ignore") as fo:
+        if out_map:
+            fm = open(out_map, "w", encoding="utf-8")
+            fm.write("reaction_id\tseq_id\n")
+        for fn in os.listdir(rxn_dir):
+            if not fn.endswith(".fasta"):
+                continue
+            p = os.path.join(rxn_dir, fn)
+            if os.path.getsize(p) < min_size:
+                continue
+            rxn_id = fn[:-6]  # 文件名去 .fasta -> 反应 ID
+            with open(p, encoding="utf-8", errors="ignore") as f:
+                cur = None
+                buf = []
+                for line in f:
+                    line = line.rstrip("\n")
+                    if line.startswith(">"):
+                        if cur is not None:
+                            fo.write(f">{cur}\n{''.join(buf)}\n")
+                            if out_map:
+                                fm.write(f"{rxn_id}\t{cur}\n")
+                            n_seq += 1
+                        cur = f"{rxn_id}|{line[1:].split()[0]}"
+                        buf = []
+                    elif line.strip():
+                        buf.append(line.strip())
+                if cur is not None and buf:
+                    fo.write(f">{cur}\n{''.join(buf)}\n")
+                    if out_map:
+                        fm.write(f"{rxn_id}\t{cur}\n")
+                    n_seq += 1
+            n_file += 1
+        if out_map:
+            fm.close()
+    return n_seq, n_file
+
+
+def diamond_whitelist(faa, out_dir, db_path=None, rxn_fa=None, out_tsv=None,
+                      evalue=1e-5, min_bitscore=60, max_target_seqs=5):
+    """B1: diamond blastp 目标物种 faa vs rxn_all 数据库 -> 命中反应集。
+    db_path 缺省用 out_dir/rxn_all.dmnd（无则由 rxn_fa 建，rxn_fa 再缺则用 GEM_GAPSEQ_DB 的 B0 产物）。
+    返回 {"rxn_hits": {rxn_id: [seq_hit_desc...]}, "n_hits": N, "hits_tsv": path, "db": path}。
+    License 守则: rxn 库/命中集仅本地使用，不进 git/发布包（调用方负责落在 ~/.dsh 下）。"""
+    import subprocess
+    os.makedirs(out_dir, exist_ok=True)
+    if not os.path.exists(DIAMOND):
+        raise FileNotFoundError(f"diamond not found: {DIAMOND}")
+    if db_path is None:
+        db_path = os.path.join(out_dir, "rxn_all.dmnd")
+    if rxn_fa is None:
+        rxn_fa = os.path.join(out_dir, "rxn_all.fa")
+    if not os.path.exists(db_path):
+        if not os.path.exists(rxn_fa):
+            # B0 现场聚合（SEQDB rxn/ 目录 -> rxn_all.fa）
+            n_seq, n_file = build_rxn_fasta(rxn_fa)
+            if n_seq == 0:
+                raise FileNotFoundError(f"no rxn fasta built from {SEQDB}/rxn (GEM_GAPSEQ_DB?)")
+        rc, so, se, secs = subprocess_run([DIAMOND, "makedb", "--in", rxn_fa, "--db", db_path])
+        if rc != 0:
+            raise RuntimeError(f"diamond makedb failed rc={rc}: {se}")
+    if out_tsv is None:
+        out_tsv = os.path.join(out_dir, os.path.splitext(os.path.basename(faa))[0] + "_hits.tsv")
+    rc, so, se, secs = subprocess_run(
+        [DIAMOND, "blastp", "-d", db_path, "-q", faa, "-o", out_tsv,
+         "--evalue", str(evalue), "--max-target-seqs", str(max_target_seqs),
+         "--outfmt", "6", "qseqid", "sseqid", "pident", "evalue", "bitscore"],
+        timeout=3600)
+    if rc != 0:
+        raise RuntimeError(f"diamond blastp failed rc={rc}: {se}")
+    rxn_hits = {}
+    with open(out_tsv, encoding="utf-8", errors="ignore") as f:
+        for line in f:
+            p = line.rstrip("\r\n").split("\t")
+            if len(p) < 5:
+                continue
+            qseqid, sseqid = p[0], p[1]
+            try:
+                if float(p[4]) < min_bitscore:
+                    continue
+            except ValueError:
+                continue
+            rxn_id = sseqid.split("|")[0].strip()  # header 约定: RXNID|uniprot...
+            if not rxn_id:
+                continue
+            rxn_hits.setdefault(rxn_id, [])
+            if qseqid not in rxn_hits[rxn_id]:
+                rxn_hits[rxn_id].append(qseqid)
+    return {"rxn_hits": rxn_hits, "n_hits": len(rxn_hits),
+            "hits_tsv": out_tsv, "db": db_path, "evalue": evalue,
+            "min_bitscore": min_bitscore}
+
+
+def subprocess_run(cmd, timeout=3600):
+    import subprocess
+    st = time.time()
+    r = subprocess.run(cmd, capture_output=True, timeout=timeout)
+    return r.returncode, (r.stdout or b"").decode("utf-8", "ignore")[-800:], (r.stderr or b"").decode("utf-8", "ignore")[-800:], round(time.time() - st, 1)
+
+
+if __name__ == "__main__":
+    import json
+    fa = sys.argv[1] if len(sys.argv) > 1 else r"D:\Program\hermes\temp\gem_whitelist\rxn_all.fa"
+    out_dir = os.path.dirname(fa) or "."
+    os.makedirs(out_dir, exist_ok=True)
+    map_p = os.path.join(out_dir, "rxn_map.tsv")
+    t0 = time.time()
+    n_seq, n_file = build_rxn_fasta(fa, map_p)
+    print(json.dumps({"seqs": n_seq, "files_used": n_file, "out_fa": fa,
+                      "map": map_p, "elapsed_s": round(time.time() - t0, 1)},
+                     ensure_ascii=False, indent=2))
+    print(f"文件大小: {os.path.getsize(fa)/1e6:.1f} MB")

package/python/double_knockout.py

@@ -0,0 +1,201 @@
+# double_knockout.py — 阶段C-C2 双敲 v1（合成致死预测，L2 非平凡）
+# 候选池（预算可控）：① GPR 结构先验——纯 or 型且恰 2 基因的反应 = 穷尽型同工酶对（廉价必做）；
+#   ② FVA 预筛活性反应关联基因中"共享反应"的基因对（复用 essential_scan.prescreen_candidates +
+#   scan_essentiality；全扫受 max_pairs 预算上限，默认 5000，超限截断+报告）。
+# 判定：单敲双活（>EPS）且双敲死（<=EPS）→ 合成致死对。单敲生长值按对惰性计算并缓存。
+# 假设声明（方案文件要求，内置于输出与 description）：细菌双敲验证率无大规模实验数据支撑，
+#   本结果=假设生成，供实验设计参考非结论。
+# 退化护栏（阶段 A/B 教训）：wt<=EPS（介质下不生长）→ 不扫描不登记账本，degenerate:true + 介质适配提示。
+import os
+import re
+import sys
+import csv
+import time
+import json
+from itertools import combinations
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from silentio import silent_read_sbml
+from essential_scan import setup_model_medium, scan_essentiality, EPS
+
+ASSUMPTION_NOTE = "细菌双敲验证率无大规模实验数据支撑，本结果=假设生成，供实验设计参考非结论"
+
+
+def _gpr_or_pairs(m):
+    """穷尽型 or 同工酶对：纯 or GPR 且恰 2 个不同基因的反应。返回去重 {(a,b): [rxn...]}（a<b）。"""
+    out = {}
+    for r in m.reactions:
+        gpr = str(r.gpr or "").strip()
+        if not gpr or " and " in gpr.lower():
+            continue
+        genes = sorted({g.strip() for g in re.split(r"\bor\b", gpr, flags=re.I) if g.strip()})
+        if len(genes) == 2:
+            out.setdefault((genes[0], genes[1]), []).append(r.id)
+    return out
+
+
+def _double_growth(m, ga, gb):
+    with m:
+        m.genes.get_by_id(ga).knock_out()
+        m.genes.get_by_id(gb).knock_out()
+        v = m.optimize().objective_value
+    return round(float(v), 6) if (v is not None and v == v) else 0.0
+
+
+def _single_growth(m, gid):
+    with m:
+        m.genes.get_by_id(gid).knock_out()
+        v = m.optimize().objective_value
+    return round(float(v), 6) if (v is not None and v == v) else 0.0
+
+
+def double_knockout(model_path, medium=None, max_pairs=5000, export_csv=None,
+                    ledger_refs=True, ledger_path=None, progress=None):
+    log = progress or (lambda s: sys.stderr.write(str(s) + "\n"))
+    medium = medium or {"medium_name": "AB"}
+    t0 = time.time()
+    m = silent_read_sbml(model_path)
+    resolved, unresolved, preset = setup_model_medium(m, medium)
+    with m:
+        wt = m.optimize().objective_value
+    wt = round(float(wt), 6) if wt is not None else 0.0
+    log(f"[dk] {model_path} medium={medium} wt={wt} max_pairs={max_pairs}")
+
+    out = {"model": model_path, "medium": medium, "medium_preset": preset,
+           "wt_growth": wt, "units": "mmol/gDW/h", "assumption_note": ASSUMPTION_NOTE,
+           "max_pairs": max_pairs, "eps": EPS,
+           "degenerate": wt <= EPS}
+    if out["degenerate"]:
+        out["degenerate_note"] = (f"wt_growth={wt}<=EPS：被测模型在指定介质下不生长，双敲判定无意义，"
+                                  "未扫描、未登记账本。提示：内置介质预设为根瘤菌科（C58）调校，"
+                                  "非根瘤菌模型需先做介质适配（阶段B-B3 molybdate 教训）。")
+        try:
+            from benchmark import medium_adaptation_hints
+            out["medium_adaptation_hints"] = medium_adaptation_hints(model_path, medium)
+        except Exception as e:
+            sys.stderr.write(f"[dk] hints WARN: {type(e).__name__}: {e}" + "\n")
+        log(f"[dk] DEGENERATE wt={wt} <= EPS：不扫描不登记")
+        return out
+
+    # 1) 全量必需性扫描（复用 essential_scan 核心）：essential 集 + FVA 活性候选基因
+    t_scan = time.time()
+    scan = scan_essentiality(m, return_candidates=True)
+    essential = set(scan["essential_genes"])
+    alive = set(scan["candidate_genes"]) - essential
+    log(f"[dk] scan done ({round(time.time()-t_scan,1)}s): tested={scan['tested_genes']} "
+        f"essential={len(essential)} alive_singles={len(alive)}")
+
+    # 2) 候选池
+    prior = _gpr_or_pairs(m)
+    pool = []  # (a, b, rationale)
+    seen = set()
+    for (a, b), rxns in sorted(prior.items()):
+        if a in alive and b in alive:
+            pool.append((a, b, f"GPR先验(穷尽型or同工酶，反应:{','.join(sorted(rxns)[:3])})"))
+            seen.add((a, b))
+    n_prior = len(pool)
+    # ② 共享反应的存活基因对（E4c 先验排序：共享活性反应数降序——冗余暴露越多 SL 先验越高，
+    #    字母序破平；max_pairs 截断从"字母序前 N"变为"先验驱动 top-N"）
+    budget = max_pairs - n_prior
+    scan_pairs_total = 0
+    active_rxns = scan.get("active_rxn_ids") or []
+    if budget > 0:
+        shared_count = {}
+        for rid in sorted(active_rxns):
+            gset = sorted(g for g in (x.id for x in m.reactions.get_by_id(rid).genes)
+                          if g in alive)
+            for a, b in combinations(gset, 2):
+                if (a, b) not in seen:
+                    shared_count[(a, b)] = shared_count.get((a, b), 0) + 1
+        shared = sorted(shared_count, key=lambda p: (-shared_count[p], p[0], p[1]))
+        scan_pairs_total = len(shared)
+        for a, b in shared[:budget]:
+            pool.append((a, b, f"全扫(共享活性反应×{shared_count[(a, b)]})"))
+    truncated = scan_pairs_total > max(0, budget)
+    log(f"[dk] pool: prior={n_prior} scan_total={scan_pairs_total} "
+        f"scan_tested={min(scan_pairs_total, max(0, budget))} truncated={truncated}")
+
+    # 3) 逐对判定：双敲 LP；SL -> 补算两个单敲值（缓存）
+    results = []
+    singles = {}
+    tested = 0
+    for a, b, rationale in pool:
+        tested += 1
+        gd = _double_growth(m, a, b)
+        if gd <= EPS:
+            for g in (a, b):
+                if g not in singles:
+                    singles[g] = _single_growth(m, g)
+            results.append({"pair": [a, b], "single_a_growth": singles[a],
+                            "single_b_growth": singles[b], "double_growth": gd,
+                            "rationale": rationale, "source": "gem_double_knockout"})
+            log(f"[dk] SL {a} x {b} (double={gd}, {rationale[:24]})")
+        if tested % 500 == 0:
+            log(f"[dk] tested {tested}/{len(pool)}, SL so far {len(results)}")
+
+    # 4) 账本登记（每对一条 type=synthetic_lethal；幂等）
+    reg = None
+    if ledger_refs and results:
+        try:
+            import ledger as _ledger
+            from model_card import load_card as _load_card
+            lineage_v = ((_load_card(model_path) or {}).get("model_lineage") or {}).get("version")
+            cond = preset or (f"custom({len(resolved)} EX)" if resolved else "unspecified")
+            pair_rows = [{"gene_a": r["pair"][0], "gene_b": r["pair"][1]} for r in results]
+            reg = _ledger.register_synthetic_lethal(model_path, pair_rows, condition=cond,
+                                                    lineage_version=lineage_v, path=ledger_path)
+            log(f"[dk] ledger: appended={reg['appended']} skipped={reg['skipped_duplicates']}")
+        except Exception as e:
+            sys.stderr.write(f"[dk] ledger registration WARN: {type(e).__name__}: {e}\n")
+
+    out.update({
+        "genes_tested_single": scan["tested_genes"],
+        "essential_count": len(essential),
+        "alive_singles": len(alive),
+        "pairs_tested": tested,
+        "pairs_found": len(results),
+        "scan_ordering": "shared_rxn_count_desc_then_alpha (E4c)",
+        "budget": {"prior_pairs": n_prior, "scan_pairs_total": scan_pairs_total,
+                   "scan_pairs_tested": min(scan_pairs_total, max(0, budget)),
+                   "truncated": truncated},
+        "results": results,
+        "timing_seconds": round(time.time() - t0, 1),
+    })
+    if reg is not None:
+        out["ledger_registration"] = reg
+    if export_csv:
+        n = _export_csv(export_csv, results, out)
+        out["export_csv"] = export_csv
+        out["export_csv_rows"] = n
+        out["export_csv_bytes"] = os.path.getsize(export_csv)
+        log(f"[dk] CSV {export_csv}: {n} rows")
+    return out
+
+
+def _export_csv(path, results, out):
+    n = 0
+    with open(path, "w", newline="", encoding="utf-8-sig") as f:
+        w = csv.writer(f)
+        w.writerow(["# assumption", out["assumption_note"]])
+        w.writerow(["gene_a", "gene_b", "single_a_growth", "single_b_growth",
+                    "double_growth", "rationale", "source"])
+        for r in results:
+            w.writerow([r["pair"][0], r["pair"][1], r["single_a_growth"],
+                        r["single_b_growth"], r["double_growth"], r["rationale"], r["source"]])
+            n += 1
+    return n
+
+
+if __name__ == "__main__":
+    args = {}
+    if len(sys.argv) > 1:
+        with open(sys.argv[1], encoding="utf-8") as f:
+            args = json.load(f)
+    elif not sys.stdin.isatty():
+        args = json.loads(sys.stdin.read())
+    a = args.get("args", args)
+    print(json.dumps({"ok": True, "result": double_knockout(
+        a.get("model"), medium=a.get("medium"), max_pairs=a.get("max_pairs", 5000),
+        export_csv=a.get("export_csv"), ledger_refs=a.get("ledger_refs", True),
+        ledger_path=a.get("ledger_path"))}, ensure_ascii=False))