@dsh-bio/dsh-bio-gem 0.1.3 → 0.1.13

package/python/biomass_tools.py

@@ -4,7 +4,7 @@
 # apply（显式）: biomass_profile 覆盖表（op=set|add|remove）→ 副本替换 biomass → 强制 G1-G6 重验
 #               + 三联对照（生长/表型/必需基因 delta）→ model_lineage 追加（有 card 时）
 # 原则: 默认不应用任何 profile；生长变差 WARN 不阻塞；C58 CarveMe AB 0.624 锚点保护（delta 如实报告）。
-# units: growth 一律 mmol/gDW/h。
+# units: growth 一律 1/h（比生长速率；biomass 反应 gDW 归一化口径，数值 = μ）。
 import os
 import re
 import sys
@@ -18,7 +18,7 @@ import cobra
 EX_PREFIX = ("EX_", "DM_", "SK_")
 DEFAULT_UNIVERSAL = r"D:\Program\hermes\temp\gem_universal\iML1515.xml"
 DEFAULT_INX = r"F:\A_NGJ plan\Zcode\models\iNX1344_v4.xml"
-GROWTH_UNITS = "mmol/gDW/h"
+GROWTH_UNITS = "1/h"
 EPS = 1e-6
 
 # 分类词表（name 规约匹配为主，id 规约为辅；覆盖 BiGG/ModelSEED/MetaCyc 常见命名）

package/python/bootstrap_carveme.py

@@ -0,0 +1,259 @@
+# bootstrap_carveme.py — CarveMe 运行时「零手动部署」（探测 → uv venv → carveme → diamond → 冒烟 → manifest）
+#
+# 产品原则：用户零手动安装。gem_build(engine=carveme) 首次调用时自动补齐运行时：
+#   1. 探测现有 venv（carve.exe + diamond.exe + 冒烟通过）→ 就绪则秒回
+#   2. 缺则部署：uv venv（uv 探测链见下）→ uv pip install carveme → 下载 diamond 官方二进制 → 冒烟
+#   3. 全过程写进度事件（progress.jsonl），失败给「可执行指引」而不是裸异常
+#
+# uv 探测链：GEM_UV env → genie 自举 uv（~/.dsh/dsh-bio-genie/bin/uv.exe）→ PATH uv
+# diamond 来源：GitHub release 固定版本（v2.2.8, diamond-windows.zip, 3.4MB 纯二进制）
+#   下载策略：直连 → 环境变量代理（HTTPS_PROXY/HTTP_PROXY）→ 失败给指引
+#
+# 幂等性：重复调用不重复部署；diamond 单独缺失时只补 diamond；manifest.json 记录版本与来源
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+import urllib.request
+import zipfile
+
+DEFAULT_CARVE_VENV = os.path.join(os.path.expanduser("~"), ".dsh", "dsh-bio-gem", "venv-carveme")
+GEM_ROOT = os.path.join(os.path.expanduser("~"), ".dsh", "dsh-bio-gem")
+DIAMOND_VERSION = "v2.2.8"
+DIAMOND_URL = f"https://github.com/bbuchfink/diamond/releases/download/{DIAMOND_VERSION}/diamond-windows.zip"
+GENIE_UV = os.path.join(os.path.expanduser("~"), ".dsh", "dsh-bio-genie", "bin", "uv.exe")
+
+VERIFY_TIMEOUT = 60
+DOWNLOAD_TIMEOUT = 300
+
+
+def _log(progress_path, event):
+    """进度事件（与 build.py 同格式；progress_path 为 None 时静默）。"""
+    if not progress_path:
+        return
+    try:
+        ev = {"ts": time.time(), **event}
+        with open(progress_path, "a", encoding="utf-8") as f:
+            f.write(json.dumps(ev, ensure_ascii=False) + "\n")
+    except Exception:
+        pass
+
+
+def _run(cmd, timeout=VERIFY_TIMEOUT, env=None):
+    return subprocess.run(cmd, capture_output=True, text=True, timeout=timeout,
+                          env=env, encoding="utf-8", errors="replace")
+
+
+def find_uv():
+    """uv 探测链：GEM_UV → genie 自举 → PATH。返回 (uv_path, source) 或 (None, None)。"""
+    env_uv = os.environ.get("GEM_UV")
+    if env_uv and os.path.exists(env_uv):
+        return env_uv, "env:GEM_UV"
+    if os.path.exists(GENIE_UV):
+        return GENIE_UV, "genie-bootstrap"
+    which = shutil.which("uv")
+    if which:
+        return which, "PATH"
+    return None, None
+
+
+def _carve_exe(venv=None):
+    return os.path.join(venv or DEFAULT_CARVE_VENV, "Scripts", "carve.exe")
+
+
+def _diamond_exe(venv=None):
+    return os.path.join(venv or DEFAULT_CARVE_VENV, "Scripts", "diamond.exe")
+
+
+def _probe(venv=None, deep=False):
+    """就绪探测。
+    deep=False（默认）：文件存在 + manifest 信任 —— 秒级（gem_build 每次调用的日常路径）；
+    deep=True：额外跑 diamond/carve 冒烟（部署完成后复验一次用）。
+    返回 (ok, detail)。"""
+    carve, diamond = _carve_exe(venv), _diamond_exe(venv)
+    if not os.path.exists(carve):
+        return False, {"missing": "carve.exe"}
+    if not os.path.exists(diamond):
+        return False, {"missing": "diamond.exe"}
+    if not deep and _read_manifest(venv):
+        return True, {"mode": "fast-manifest"}
+    try:
+        r1 = _run([diamond, "--version"])
+        if r1.returncode != 0:
+            return False, {"diamond_broken": (r1.stderr or r1.stdout or "")[:200]}
+        # carve 无 --version：用 -h 验证可启动（exit 0）
+        r2 = _run([carve, "-h"])
+        if r2.returncode not in (0, 1):  # argparse -h 正常为 0；某些版本非 0
+            return False, {"carve_broken": (r2.stderr or r2.stdout or "")[:200]}
+        return True, {"diamond": (r1.stdout or "").strip()[:80], "mode": "deep-smoke"}
+    except Exception as e:
+        return False, {"probe_error": f"{type(e).__name__}: {e}"}
+
+
+def _download(url, dest, progress_path=None):
+    """下载（直连 → 环境代理 → 抛错含指引）。返回使用的通道。"""
+    headers = {"User-Agent": "dsh-bio-gem-bootstrap/1.0"}
+
+    def _get(opener=None):
+        req = urllib.request.Request(url, headers=headers)
+        op = opener.open(req, timeout=DOWNLOAD_TIMEOUT) if opener else urllib.request.urlopen(req, timeout=DOWNLOAD_TIMEOUT)
+        with op as resp, open(dest, "wb") as f:
+            shutil.copyfileobj(resp, f)
+
+    try:
+        _get()
+        return "direct"
+    except Exception as e1:
+        _log(progress_path, {"event": "diamond_direct_failed", "err": str(e1)[:200]})
+    proxy = (os.environ.get("HTTPS_PROXY") or os.environ.get("https_proxy")
+             or os.environ.get("HTTP_PROXY") or os.environ.get("http_proxy"))
+    if proxy:
+        try:
+            opener = urllib.request.build_opener(
+                urllib.request.ProxyHandler({"http": proxy, "https": proxy}))
+            _get(opener)
+            return f"proxy:{proxy}"
+        except Exception as e2:
+            _log(progress_path, {"event": "diamond_proxy_failed", "err": str(e2)[:200]})
+    raise RuntimeError(
+        f"无法下载 diamond（{url}）。可执行的手动方案：\n"
+        f"  1) 设置代理后重试：set HTTPS_PROXY=http://127.0.0.1:端口\n"
+        f"  2) 或手动下载 diamond-windows.zip，把解压出的 diamond.exe 放到：\n"
+        f"     {os.path.join(DEFAULT_CARVE_VENV, 'Scripts')}")
+
+
+def ensure_carveme(venv=None, progress_path=None, force_diamond=False):
+    """确保 CarveMe 运行时可用（幂等）。返回 dict：
+    {ready, action: already|deployed|repaired|failed, carve, diamond, version, note?, error?}
+    """
+    venv = venv or DEFAULT_CARVE_VENV
+    ok, detail = _probe(venv)
+    if ok and not force_diamond:
+        return {"ready": True, "action": "already", "carve": _carve_exe(venv),
+                "diamond": _diamond_exe(venv), "note": detail.get("diamond", "")}
+
+    _log(progress_path, {"event": "bootstrap_start", "venv": venv, "probe": detail})
+    os.makedirs(os.path.dirname(venv), exist_ok=True)
+
+    uv, uv_src = find_uv()
+    if not uv:
+        return {"ready": False, "action": "failed", "error":
+                "未找到 uv（探测链：GEM_UV env → ~/.dsh/dsh-bio-genie/bin/uv.exe → PATH）。"
+                "请安装 uv（https://docs.astral.sh/uv/）或安装宿主插件 dsh-bio-genie 以复用其自举 uv。"}
+
+    # ---- 1) venv + carveme（carve.exe 缺失或损坏时） ----
+    need_env = not os.path.exists(_carve_exe(venv))
+    if need_env:
+        _log(progress_path, {"event": "uv_venv", "uv": uv, "uv_source": uv_src})
+        try:
+            r = _run([uv, "venv", venv, "--python", "3.13"], timeout=300)
+            if r.returncode != 0 or not os.path.exists(os.path.join(venv, "Scripts", "python.exe")):
+                return {"ready": False, "action": "failed",
+                        "error": f"uv venv 创建失败 rc={r.returncode}: {(r.stderr or '')[-300:]}"}
+        except Exception as e:
+            return {"ready": False, "action": "failed", "error": f"uv venv 异常: {e}"}
+
+        py = os.path.join(venv, "Scripts", "python.exe")
+        _log(progress_path, {"event": "uv_pip_carveme", "detail": "uv pip install carveme"})
+        try:
+            r = _run([uv, "pip", "install", "--python", py, "carveme"], timeout=900)
+            if r.returncode != 0:
+                return {"ready": False, "action": "failed",
+                        "error": f"carveme 安装失败 rc={r.returncode}: {(r.stderr or '')[-400:]}"}
+        except Exception as e:
+            return {"ready": False, "action": "failed", "error": f"carveme 安装异常: {e}"}
+
+    # ---- 2) diamond（缺失/损坏时补） ----
+    if not os.path.exists(_diamond_exe(venv)) or force_diamond:
+        scripts_dir = os.path.join(venv, "Scripts")
+        os.makedirs(scripts_dir, exist_ok=True)
+        tmp_zip = os.path.join(venv, "diamond-download.zip")
+        _log(progress_path, {"event": "diamond_download", "url": DIAMOND_URL})
+        try:
+            channel = _download(DIAMOND_URL, tmp_zip, progress_path)
+        except RuntimeError as e:
+            return {"ready": False, "action": "failed", "error": str(e)}
+        try:
+            with zipfile.ZipFile(tmp_zip) as z:
+                names = z.namelist()
+                if "diamond.exe" not in names:
+                    return {"ready": False, "action": "failed",
+                            "error": f"diamond zip 内容异常: {names}"}
+                z.extract("diamond.exe", scripts_dir)
+        except Exception as e:
+            return {"ready": False, "action": "failed", "error": f"diamond 解压失败: {e}"}
+        finally:
+            try:
+                os.remove(tmp_zip)
+            except OSError:
+                pass
+        _log(progress_path, {"event": "diamond_ready", "channel": channel})
+
+    # ---- 3) 冒烟复验（deep：真跑 diamond/carve 一次） ----
+    ok2, detail2 = _probe(venv, deep=True)
+    version = _read_carve_version(venv)
+    manifest = {
+        "carve_version": version,
+        "diamond_version": DIAMOND_VERSION,
+        "diamond_url": DIAMOND_URL,
+        "uv_source": uv_src,
+        "installed_at": time.strftime("%Y-%m-%d %H:%M:%S"),
+    }
+    try:
+        with open(os.path.join(venv, "manifest.json"), "w", encoding="utf-8") as f:
+            json.dump(manifest, f, ensure_ascii=False, indent=1)
+    except OSError:
+        pass
+
+    if not ok2:
+        return {"ready": False, "action": "failed",
+                "error": f"部署后冒烟未通过: {detail2}"}
+    action = "deployed" if need_env else "repaired"
+    _log(progress_path, {"event": "bootstrap_done", "action": action, "manifest": manifest})
+    return {"ready": True, "action": action, "carve": _carve_exe(venv),
+            "diamond": _diamond_exe(venv), "manifest": manifest}
+
+
+def _read_carve_version(venv=None):
+    py = os.path.join(venv or DEFAULT_CARVE_VENV, "Scripts", "python.exe")
+    if not os.path.exists(py):
+        return None
+    try:
+        r = _run([py, "-c",
+                  "import importlib.metadata as im; print(im.version('carveme'))"])
+        if r.returncode == 0:
+            return (r.stdout or "").strip()
+    except Exception:
+        pass
+    return None
+
+
+def carveme_status(venv=None):
+    """只读状态（供诊断/工具面板）。"""
+    ok, detail = _probe(venv)
+    return {"ready": ok, "venv": venv or DEFAULT_CARVE_VENV,
+            "carve": _carve_exe(venv), "diamond": _diamond_exe(venv),
+            "detail": detail, "manifest": _read_manifest(venv),
+            "uv": find_uv()[1]}
+
+
+def _read_manifest(venv=None):
+    p = os.path.join(venv or DEFAULT_CARVE_VENV, "manifest.json")
+    try:
+        with open(p, encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return None
+
+
+if __name__ == "__main__":
+    # CLI：python bootstrap_carveme.py [status|ensure]
+    action = sys.argv[1] if len(sys.argv) > 1 else "ensure"
+    if action == "status":
+        print(json.dumps(carveme_status(), ensure_ascii=False, indent=1))
+    else:
+        out = ensure_carveme()
+        print(json.dumps(out, ensure_ascii=False, indent=1))
+        sys.exit(0 if out.get("ready") else 1)

package/python/build.py

@@ -138,6 +138,14 @@ def build(input_spec, name=None, medium=None, venv=None, out_dir=None, progress_
     os.makedirs(out_dir, exist_ok=True)
     out_xml = os.path.join(out_dir, name + ".xml")
 
+    # 0) 运行时自举（零手动安装）：carve + diamond 缺失时自动部署（幂等，就绪时秒过）
+    from bootstrap_carveme import ensure_carveme
+    boot = ensure_carveme(venv=venv, progress_path=progress_path)
+    if not boot.get("ready"):
+        _log(progress_path, {"event": "bootstrap_failed", "error": boot.get("error")})
+        raise RuntimeError("CarveMe 运行时不可用：" + str(boot.get("error")))
+    _log(progress_path, {"event": "bootstrap_ok", "action": boot.get("action")})
+
     # 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)):
@@ -195,7 +203,7 @@ def build(input_spec, name=None, medium=None, venv=None, out_dir=None, progress_
     # 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",
+         "growth_rate": g3_m9.get("growth_medium"), "units": "1/h",
          "validation_status": "verified_G3" if g3_m9.get("status") == "PASS" else "unverified"},
     ]
     if target and target.get("g3") == "PASS":
@@ -204,7 +212,7 @@ def build(input_spec, name=None, medium=None, venv=None, out_dir=None, progress_
             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",
+            "growth_rate": target.get("growth"), "units": "1/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]）

package/python/coherence.py

@@ -0,0 +1,159 @@
+# coherence.py — dsh-bio-gem 模型自洽性前置诊断（G0）
+#
+# 目的：在 G3/G4/G5 与 gapfind 之前，先判断**模型自身数据质量是否允许下结论**，
+# 避免把「未映射代谢物」这类数据问题，误报成「通路缺口 / 必需基因异常」。
+#
+# 实测来源（2026-09-10 E2E，iNX1344_v3 —— MetaCyc 风格 id 的公开模型）：
+#   - gem_gapfind 报 5 个 L3「内部通路缺口」，根因实为 biomass 前体未映射；
+#   - agent 为证伪这些假阳性，手写 cobra 代码 18 次（占该轮调用的一半）。
+#
+# ⚠️⚠️ 判据设计原则：**零误报优先**。以下两类判据在设计中被实测否决，切勿加回：
+#
+#  1. 「biomass 元素配平」——对 biomass 方程**不适用**。标准 biomass 方程代表大分子
+#     聚合，产物侧用占位代谢物表示生物量（无独立化学式），元素净不平衡是**预期**
+#     行为而非缺陷。对照实验：教科书模型 e_coli_core 的 Biomass_Ecoli_core 净不平衡
+#     C -42.56 / N -5.45 / P -3.68，用它判据会把公认良好的模型判成 FAIL。
+#  2. 「前体可达性（demand 逐前体 FBA）」——初版实现同样在 e_coli_core 上把
+#     atp_c / accoa_c / nad_c / nadph_c 误报为「既不能合成也不能摄取」。全开交换下
+#     的 demand 语义与胞内辅因子/能量货币的循环补给路径纠缠，判据未成熟。
+#     正确方法（agent 在 E2E 中手工探索过）待重新设计后引入。
+#
+# 保留的判据都经过「问题模型报出真问题 + 标准模型零误报」双向验证：
+#   - id 体系识别（信息性，决定下游名称映射口径）
+#   - biomass 未映射前体（无 name / 无 formula）→ iNX1344_v3 报 8 个，e_coli_core 报 0 个
+#   - 产物侧出现 ATP（生长方向疑似写反）→ 两个模型均不报
+import os
+import re
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# 代谢物 id 命名体系 → 正则（命中率 < ID_FRACTION 记为 mixed/unknown）
+ID_SYSTEM_PATTERNS = (
+    ("bigg", re.compile(r"^[a-z][a-z0-9]{1,}_[a-z]\d?$")),      # atp_c / h2o_c / g6p_c
+    ("metacyc", re.compile(r"^[Mm]?\d{5}(?:_[a-z]\d?)?$")),     # M00002_c / cpd00002_c0
+    ("carveme", re.compile(r"^M_[a-z0-9]+_[a-z]\d?$")),         # M_atp_c
+)
+ID_FRACTION = 0.5
+
+
+# ---------------------------------------------------------------- ID 体系
+def classify_id_system(model):
+    """按代谢物 id 命名习惯**归类** ID 体系（决定下游关卡的名称映射口径）。
+
+    与 `benchmark.detect_id_system` 的区别（刻意不同名，勿合并）：后者列举
+    基因/反应/代谢物的 ID **风格样本**（返回基因、反应、代谢物三组标签与计数）；
+    本函数按正则归类出**体系名**（bigg / metacyc / carveme / mixed / unknown）
+    并给出各体系命中比例，供路由与降级逻辑判断。
+    """
+    mets = [x for x in model.metabolites if x.id]
+    if not mets:
+        return {"system": "unknown", "fractions": {}, "sampled": 0}
+    hits = {name: 0 for name, _ in ID_SYSTEM_PATTERNS}
+    for met in mets:
+        for name, pat in ID_SYSTEM_PATTERNS:
+            if pat.match(met.id):
+                hits[name] += 1
+                break
+    n = len(mets)
+    fracs = {k: round(v / n, 4) for k, v in hits.items()}
+    best = max(fracs, key=fracs.get)
+    system = best if fracs[best] >= ID_FRACTION else ("mixed" if any(fracs.values()) else "unknown")
+    return {"system": system, "fractions": fracs, "sampled": n}
+
+
+# ---------------------------------------------------------------- biomass
+def locate_biomass(model):
+    """定位 biomass 反应：先按 id/name 命中，再退回 objective 变量。
+
+    与 `biomass_tools.find_biomass` 的区别（刻意不同名，勿合并）：后者按
+    `objective_coefficient != 0` 找 FBA 目标反应、多个时取组分最多者，服务于
+    biomass 精修；本函数按**名称**优先，服务于「这个模型的生长目标长什么样」
+    的数据质量诊断，返回 (reaction, 命中方式)。
+    """
+    for r in model.reactions:
+        if "biomass" in f"{r.id} {r.name or ''}".lower():
+            return r, "id_or_name"
+    try:
+        syms = [s.name for s in model.objective.expression.free_symbols]
+    except Exception:  # noqa: BLE001
+        syms = []
+    live = [r for r in model.reactions if r.id in syms]
+    if len(live) == 1:
+        return live[0], "objective"
+    if live:
+        return live[0], "objective_multi"
+    return None, "not_found"
+
+
+def check_biomass(model):
+    """biomass 可用性：未映射前体（主判据）+ 产物侧 ATP（方向异常）。
+
+    不做元素配平判定——标准 biomass 方程本就不配平（见模块头注释）。
+    """
+    bio, source = locate_biomass(model)
+    if bio is None:
+        return {"status": "WARN", "found_by": source,
+                "notes": ["未定位到 biomass 反应（id/name 与 objective 均未命中）→ 无法评估生长目标"]}
+
+    prods = [k for k, v in bio.metabolites.items() if v > 0]
+    subs = [k for k, v in bio.metabolites.items() if v < 0]
+    unmapped = [k.id for k in bio.metabolites if not (k.formula or "").strip()]
+    unnamed = [k.id for k in bio.metabolites if not (k.name or "").strip()]
+    # 方向异常：产物侧出现 ATP（生长应消耗 ATP、产出 ADP）。ADP/Pi 在产物侧属正常。
+    atp_in_products = [k.id for k in prods if (k.name or "").strip().upper() == "ATP"]
+
+    notes, status = [], "PASS"
+    if unmapped:
+        status = "WARN"
+        notes.append(f"biomass 含 {len(unmapped)} 个未映射代谢物（无 formula）→ "
+                     "其质量未定义，配平/缺口类结论均不可靠；先补映射再解读下游结果")
+    if unnamed:
+        notes.append(f"另有 {len(unnamed)} 个无名称代谢物 → 报告可读性受限")
+    if atp_in_products:
+        status = "FAIL"
+        notes.append(f"产物侧出现 ATP（{atp_in_products[:3]}）→ 生长方向疑似写反")
+    if not notes:
+        notes.append("biomass 组成部分映射完整，未发现方向异常")
+
+    return {
+        "status": status, "found_by": source,
+        "reaction": bio.id, "reaction_name": bio.name or "",
+        "bounds": [bio.lower_bound, bio.upper_bound],
+        "n_substrates": len(subs), "n_products": len(prods),
+        "unmapped_metabolites": unmapped, "unnamed_metabolites": unnamed[:10],
+        "atp_in_products": atp_in_products,
+        "notes": notes,
+    }
+
+
+# ---------------------------------------------------------------- 汇总
+def model_coherence(model):
+    """模型数据质量诊断：ID 体系 + biomass 可用性。"""
+    idrep = classify_id_system(model)
+    biorep = check_biomass(model)
+
+    rank = {"PASS": 0, "WARN": 1, "FAIL": 2}
+    status = max((biorep.get("status", "PASS"),), key=lambda s: rank.get(s, 0))
+
+    hints = []
+    if biorep.get("unmapped_metabolites"):
+        hints.append(f"biomass 含未映射代谢物 {biorep['unmapped_metabolites'][:3]} → "
+                     "先补 name/formula，再信任何配平 / 缺口 / 必需性结论")
+    if biorep.get("atp_in_products"):
+        hints.append("biomass 产物侧出现 ATP → 生长方向疑似写反，先修方程")
+    if idrep["system"] in ("metacyc", "mixed", "unknown"):
+        hints.append(f"id 体系为 {idrep['system']}（非 BiGG）→ 培养基/代谢物名称需跨体系匹配，"
+                     "天然名解析失败时先判为命名口径问题，而非模型缺陷")
+
+    return {
+        "status": status,
+        "id_system": idrep,
+        "biomass": biorep,
+        "downstream_hint": "；".join(hints),
+    }
+
+
+def coherence_from_path(model_path):
+    from silentio import silent_read_sbml
+    return model_coherence(silent_read_sbml(model_path))

package/python/double_knockout.py

@@ -63,7 +63,7 @@ def double_knockout(model_path, medium=None, max_pairs=5000, export_csv=None,
     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,
+           "wt_growth": wt, "units": "1/h", "assumption_note": ASSUMPTION_NOTE,
            "max_pairs": max_pairs, "eps": EPS,
            "degenerate": wt <= EPS}
     if out["degenerate"]:

package/python/essential_scan.py

@@ -151,7 +151,7 @@ def essential_scan(model_path, medium=None, gene_subset=None, progress=None, led
         "medium_unresolved": unresolved,
         "note": "必需判定=A 培养基下敲除生长<1e-6；evidence 分级按基因支撑反应是否含 EVIDENCE_math（Q2）",
         # 阶段A-M4 口径声明（只增）：wt_growth 为单点 FBA 值
-        "units": "mmol/gDW/h",
+        "units": "1/h",
         "point_value_note": "单点 FBA 值，非解空间硬结论；条件对比请用 gem_fluxscan 区间分离判定",
     })
     # 模型卡 schema v2 回写（产物旁已有 card 才写；无卡不凭空造卡）