598 lines
38 KiB
Python
598 lines
38 KiB
Python
|
#!/usr/bin/env python3
|
|||
|
|
"""Publication-grade extension-stage experiments for bbav5."""
|
|||
|
|
|
|||
|
|
from __future__ import annotations
|
|||
|
|
|
|||
|
|
import argparse
|
|||
|
|
import csv
|
|||
|
|
import hashlib
|
|||
|
|
import html
|
|||
|
|
import json
|
|||
|
|
import os
|
|||
|
|
import shutil
|
|||
|
|
import subprocess
|
|||
|
|
import sys
|
|||
|
|
import traceback
|
|||
|
|
from dataclasses import dataclass
|
|||
|
|
from datetime import datetime
|
|||
|
|
from pathlib import Path
|
|||
|
|
from typing import Any
|
|||
|
|
|
|||
|
|
PROJECT_ROOT = Path(__file__).resolve().parents[1]
|
|||
|
|
DEFAULT_JOB_ID = "job_1781621211960_ed6af0"
|
|||
|
|
DEFAULT_JOB_ROOT = PROJECT_ROOT / "workspace" / DEFAULT_JOB_ID
|
|||
|
|
DEFAULT_OUTPUT_ROOT = PROJECT_ROOT / "项目记录" / "拓展分析阶段_发表级完整实验_20260616"
|
|||
|
|
|
|||
|
|
|
|||
|
|
@dataclass(frozen=True)
|
|||
|
|
class PubCase:
|
|||
|
|
index: int
|
|||
|
|
archetype_id: str
|
|||
|
|
stage: str
|
|||
|
|
script_name: str
|
|||
|
|
script_content: str
|
|||
|
|
source_files: tuple[tuple[str, str], ...]
|
|||
|
|
required_outputs: tuple[str, ...]
|
|||
|
|
description: str
|
|||
|
|
|
|||
|
|
@property
|
|||
|
|
def dir_name(self) -> str:
|
|||
|
|
return f"{self.index:02d}_{self.archetype_id}"
|
|||
|
|
|
|||
|
|
|
|||
|
|
def _sh(script: str) -> str:
|
|||
|
|
return "#!/usr/bin/env bash\nset -euo pipefail\npython3 - <<'PY'\n" + script + "\nPY\n"
|
|||
|
|
|
|||
|
|
|
|||
|
|
SCRIPT_SEQUENCE = """
|
|||
|
|
from pathlib import Path
|
|||
|
|
ids = {line.strip().split()[0] for line in Path('ids.id').read_text().splitlines() if line.strip()}
|
|||
|
|
out=[]; keep=False
|
|||
|
|
for line in Path('input.fa').read_text().splitlines():
|
|||
|
|
if line.startswith('>'):
|
|||
|
|
gid=line[1:].split()[0]
|
|||
|
|
keep=gid in ids
|
|||
|
|
if keep:
|
|||
|
|
out.append(line)
|
|||
|
|
Path('extracted.fa').write_text('\\n'.join(out)+'\\n')
|
|||
|
|
Path('extracted.id').write_text('\\n'.join(sorted(ids))+'\\n')
|
|||
|
|
"""
|
|||
|
|
SCRIPT_HMMER = """
|
|||
|
|
from pathlib import Path
|
|||
|
|
rows=[]
|
|||
|
|
for line in Path('input.domtblout').read_text(errors='ignore').splitlines():
|
|||
|
|
if line and not line.startswith('#'):
|
|||
|
|
rows.append(line)
|
|||
|
|
Path('filtered.domtblout').write_text('\\n'.join(rows)+'\\n')
|
|||
|
|
seqs=sum(1 for line in Path('input.fa').read_text(errors='ignore').splitlines() if line.startswith('>'))
|
|||
|
|
Path('domain_input_summary.tsv').write_text(f'sequence_count\\t{seqs}\\ndomain_rows\\t{len(rows)}\\n')
|
|||
|
|
"""
|
|||
|
|
SCRIPT_MOTIF = """
|
|||
|
|
from pathlib import Path
|
|||
|
|
import re
|
|||
|
|
Path('meme.xml').write_text(Path('input.meme.xml').read_text(errors='ignore'))
|
|||
|
|
Path('meme.txt').write_text(Path('input.meme.txt').read_text(errors='ignore'))
|
|||
|
|
text=Path('input.meme.txt').read_text(errors='ignore')
|
|||
|
|
motifs=len(re.findall(r'^MOTIF\\s+', text, flags=re.M))
|
|||
|
|
seqs=sum(1 for line in Path('input.fa').read_text(errors='ignore').splitlines() if line.startswith('>'))
|
|||
|
|
Path('motif_input_summary.tsv').write_text(f'sequence_count\\t{seqs}\\nmotif_count\\t{motifs}\\n')
|
|||
|
|
"""
|
|||
|
|
SCRIPT_PHYLOGENY = """
|
|||
|
|
from pathlib import Path
|
|||
|
|
msa=Path('input.msa.fa').read_text(errors='ignore')
|
|||
|
|
tree=Path('tree.nwk').read_text(errors='ignore').strip()
|
|||
|
|
Path('output.msa.fa').write_text(msa)
|
|||
|
|
Path('output.nwk').write_text(tree+'\\n')
|
|||
|
|
seqs=sum(1 for line in msa.splitlines() if line.startswith('>'))
|
|||
|
|
tips=tree.count(':') if tree else 0
|
|||
|
|
Path('phylogeny_summary.tsv').write_text(f'alignment_sequence_count\\t{seqs}\\ntree_tip_like_count\\t{tips}\\n')
|
|||
|
|
"""
|
|||
|
|
SCRIPT_REFCLS = """
|
|||
|
|
from pathlib import Path
|
|||
|
|
for src,dst in [('assignment.tsv','output.assignment.tsv'),('subfamily.tsv','output.subfamily.tsv'),('confidence.tsv','output.confidence.tsv')]:
|
|||
|
|
p=Path(src)
|
|||
|
|
if p.exists():
|
|||
|
|
Path(dst).write_text(p.read_text(errors='ignore'))
|
|||
|
|
rows=sum(1 for line in Path('assignment.tsv').read_text(errors='ignore').splitlines() if line.strip())
|
|||
|
|
Path('reference_classification_summary.tsv').write_text(f'assignment_rows\\t{rows}\\n')
|
|||
|
|
"""
|
|||
|
|
SCRIPT_SYNTENY = """
|
|||
|
|
from pathlib import Path
|
|||
|
|
Path('output.blast').write_text(Path('links.blast').read_text(errors='ignore'))
|
|||
|
|
Path('output.collinearity').write_text(Path('links.collinearity').read_text(errors='ignore'))
|
|||
|
|
blast_rows=sum(1 for line in Path('links.blast').read_text(errors='ignore').splitlines() if line.strip())
|
|||
|
|
q=sum(1 for line in Path('query.fa').read_text(errors='ignore').splitlines() if line.startswith('>'))
|
|||
|
|
r=sum(1 for line in Path('reference.fa').read_text(errors='ignore').splitlines() if line.startswith('>'))
|
|||
|
|
Path('synteny_summary.tsv').write_text(f'query_sequence_count\\t{q}\\nreference_sequence_count\\t{r}\\nblast_rows\\t{blast_rows}\\n')
|
|||
|
|
"""
|
|||
|
|
SCRIPT_KAKS = """
|
|||
|
|
from pathlib import Path
|
|||
|
|
text=Path('kaks_results.csv').read_text(errors='ignore')
|
|||
|
|
Path('output.kaks_results.csv').write_text(text)
|
|||
|
|
rows=[x for x in text.splitlines() if x.strip()]
|
|||
|
|
Path('kaks_summary.csv').write_text(f'kaks_rows,{len(rows)}\\n')
|
|||
|
|
"""
|
|||
|
|
SCRIPT_PEP = """
|
|||
|
|
from pathlib import Path
|
|||
|
|
src=Path('properties.tsv')
|
|||
|
|
Path('output.properties.tsv').write_text(src.read_text(errors='ignore'))
|
|||
|
|
if Path('subcellular.tsv').exists():
|
|||
|
|
Path('output.subcellular.tsv').write_text(Path('subcellular.tsv').read_text(errors='ignore'))
|
|||
|
|
seqs=sum(1 for line in Path('input.fa').read_text(errors='ignore').splitlines() if line.startswith('>'))
|
|||
|
|
rows=sum(1 for line in src.read_text(errors='ignore').splitlines() if line.strip())
|
|||
|
|
Path('pep_properties_summary.tsv').write_text(f'protein_count\\t{seqs}\\nproperty_rows\\t{rows}\\n')
|
|||
|
|
"""
|
|||
|
|
|
|||
|
|
|
|||
|
|
def cases(job_root: Path) -> tuple[PubCase, ...]:
|
|||
|
|
return (
|
|||
|
|
PubCase(1, "sequence_extraction", "identify", "run_sequence_extraction.sh", _sh(SCRIPT_SEQUENCE), (("final/Ft.SPL.curated_members.pep.fa", "input.fa"), ("final/Ft.SPL.curated_members.id", "ids.id")), ("extracted.fa", "extracted.id"), "Extract Ft.SPL protein FASTA records by curated member IDs."),
|
|||
|
|
PubCase(2, "hmmer_domain", "domain", "run_hmmer_domain.sh", _sh(SCRIPT_HMMER), (("domain/analysis/Ft.SPL.results.domtblout", "input.domtblout"), ("final/Ft.SPL.curated_members.pep.fa", "input.fa")), ("filtered.domtblout", "domain_input_summary.tsv"), "Parse real HMMER domtblout rows and summarize the matching FASTA input."),
|
|||
|
|
PubCase(3, "motif_meme", "motif", "run_motif_meme.sh", _sh(SCRIPT_MOTIF), (("final/Ft.SPL.meme.xml", "input.meme.xml"), ("final/Ft.SPL.meme.txt", "input.meme.txt"), ("final/Ft.SPL.curated_members.pep.fa", "input.fa")), ("meme.xml", "meme.txt", "motif_input_summary.tsv"), "Preserve and summarize real MEME motif outputs."),
|
|||
|
|
PubCase(4, "phylogeny_tree", "phylogeny", "run_phylogeny_tree.sh", _sh(SCRIPT_PHYLOGENY), (("phylogeny/analysis/Ft.SPL.pep.mafft.msa.fa", "input.msa.fa"), ("final/Ft.SPL.tree.nwk", "tree.nwk")), ("output.msa.fa", "output.nwk", "phylogeny_summary.tsv"), "Preserve real MSA and Newick tree with structural summary."),
|
|||
|
|
PubCase(5, "reference_classification", "reference_classification", "run_reference_classification.sh", _sh(SCRIPT_REFCLS), (("final/Ft.SPL.target_plus_reference.reference_classification.assignment.tsv", "assignment.tsv"), ("final/Ft.SPL.target_plus_reference.reference_classification.subfamily.tsv", "subfamily.tsv"), ("final/Ft.SPL.target_plus_reference.reference_classification.confidence.tsv", "confidence.tsv")), ("output.assignment.tsv", "output.subfamily.tsv", "reference_classification_summary.tsv"), "Normalize real reference-based subfamily classification tables."),
|
|||
|
|
PubCase(6, "synteny_collinearity", "interspecies_synteny", "run_synteny_collinearity.sh", _sh(SCRIPT_SYNTENY), (("interspecies_synteny/analysis/Ft.SPL.selected_target.family.pep.fa", "query.fa"), ("interspecies_synteny/analysis/Ft.SPL.selected_ref.family.pep.fa", "reference.fa"), ("interspecies_synteny/analysis/Ft.At.blast", "links.blast"), ("interspecies_synteny/analysis/Ft.At.collinearity", "links.collinearity")), ("output.blast", "output.collinearity", "synteny_summary.tsv"), "Preserve real BLAST and collinearity evidence with query/reference roles."),
|
|||
|
|
PubCase(7, "kaks_pairwise", "kaks", "run_kaks_pairwise.sh", _sh(SCRIPT_KAKS), (("final/Ft.SPL.Ft_to_At.kaks_results.csv", "kaks_results.csv"),), ("output.kaks_results.csv", "kaks_summary.csv"), "Normalize real pairwise Ka/Ks result table."),
|
|||
|
|
PubCase(8, "pep_properties", "pep", "run_pep_properties.sh", _sh(SCRIPT_PEP), (("final/Ft.SPL.curated_members.pep.fa", "input.fa"), ("final/properties_data.tsv", "properties.tsv"), ("pep/analysis/tm_summary.tsv", "subcellular.tsv")), ("output.properties.tsv", "pep_properties_summary.tsv"), "Preserve real protein property and topology summary tables."),
|
|||
|
|
)
|
|||
|
|
|
|||
|
|
|
|||
|
|
def main() -> int:
|
|||
|
|
ap = argparse.ArgumentParser(description=__doc__)
|
|||
|
|
ap.add_argument("--prepare", action="store_true")
|
|||
|
|
ap.add_argument("--run", action="store_true")
|
|||
|
|
ap.add_argument("--negative-controls", action="store_true")
|
|||
|
|
ap.add_argument("--report", action="store_true")
|
|||
|
|
ap.add_argument("--all", action="store_true")
|
|||
|
|
ap.add_argument("--job-id", default=DEFAULT_JOB_ID)
|
|||
|
|
ap.add_argument("--job-root", type=Path, default=DEFAULT_JOB_ROOT)
|
|||
|
|
ap.add_argument("--output-root", type=Path, default=DEFAULT_OUTPUT_ROOT)
|
|||
|
|
ap.add_argument("--converter", default="archetype_spec", choices=["archetype_spec", "deepseek_agent", "deepseek_api", "local_rule", "rule"])
|
|||
|
|
ap.add_argument("--runtime-env", default="test4py311")
|
|||
|
|
ap.add_argument("--stop-on-failure", action="store_true")
|
|||
|
|
args = ap.parse_args()
|
|||
|
|
if not any((args.prepare, args.run, args.negative_controls, args.report, args.all)):
|
|||
|
|
args.all = True
|
|||
|
|
out = args.output_root.resolve()
|
|||
|
|
out.mkdir(parents=True, exist_ok=True)
|
|||
|
|
if args.prepare or args.all:
|
|||
|
|
prepare(args.job_root.resolve(), out)
|
|||
|
|
if args.run or args.all:
|
|||
|
|
run_batch(out, args.converter, args.runtime_env, args.stop_on_failure)
|
|||
|
|
if args.negative_controls or args.all:
|
|||
|
|
run_negative_controls(out, args.runtime_env)
|
|||
|
|
if args.report or args.all:
|
|||
|
|
write_report(out, args.job_id, args.job_root.resolve())
|
|||
|
|
write_manifest(out)
|
|||
|
|
return 0
|
|||
|
|
|
|||
|
|
|
|||
|
|
def prepare(job_root: Path, out: Path) -> None:
|
|||
|
|
if not job_root.exists():
|
|||
|
|
raise FileNotFoundError(f"job root not found: {job_root}")
|
|||
|
|
packages = out / "packages"
|
|||
|
|
logs = out / "logs"
|
|||
|
|
packages.mkdir(parents=True, exist_ok=True)
|
|||
|
|
logs.mkdir(parents=True, exist_ok=True)
|
|||
|
|
rows = []
|
|||
|
|
for case in cases(job_root):
|
|||
|
|
root = packages / case.dir_name
|
|||
|
|
raw_code, raw_data, expected = root / "raw_code", root / "raw_test_data", root / "expected_outputs"
|
|||
|
|
for p in (raw_code, raw_data, expected, root / "_raw_run_work"):
|
|||
|
|
clean_dir(p)
|
|||
|
|
script = raw_code / case.script_name
|
|||
|
|
script.write_text(case.script_content, encoding="utf-8")
|
|||
|
|
script.chmod(0o755)
|
|||
|
|
write_json(raw_code / "bbav5_extension_hint.json", extension_hint(case))
|
|||
|
|
copied = []
|
|||
|
|
for rel, dest in case.source_files:
|
|||
|
|
src = job_root / rel
|
|||
|
|
if not src.exists():
|
|||
|
|
raise FileNotFoundError(f"missing source for {case.archetype_id}: {src}")
|
|||
|
|
shutil.copy2(src, raw_data / dest)
|
|||
|
|
copied.append({"source": str(src), "dest": dest, "size": src.stat().st_size, "sha256": sha256(src)})
|
|||
|
|
raw = run_raw(root, case, logs / f"{case.dir_name}.raw.log")
|
|||
|
|
ok = raw["success"] and all((expected / x).is_file() and (expected / x).stat().st_size > 0 for x in case.required_outputs)
|
|||
|
|
rec = {"archetype_id": case.archetype_id, "stage": case.stage, "case_dir": str(root), "source_files": copied, "raw_code_ok": raw["success"], "expected_output_ok": ok, "required_outputs": list(case.required_outputs), "raw_run": raw}
|
|||
|
|
rows.append(rec)
|
|||
|
|
write_json(root / "prepare_record.json", rec)
|
|||
|
|
(root / "README.md").write_text(case_readme(case, copied), encoding="utf-8")
|
|||
|
|
write_json(out / "prepare_manifest.json", {"schema_version": "extension_publication_prepare_v1", "created_at": now(), "job_root": str(job_root), "case_count": len(rows), "prepared": sum(1 for r in rows if r["expected_output_ok"]), "cases": rows})
|
|||
|
|
|
|||
|
|
|
|||
|
|
def run_raw(root: Path, case: PubCase, log_path: Path) -> dict[str, Any]:
|
|||
|
|
work, expected = root / "_raw_run_work", root / "expected_outputs"
|
|||
|
|
copy_tree(root / "raw_test_data", work)
|
|||
|
|
copy_tree(root / "raw_code", work)
|
|||
|
|
before = file_set(work)
|
|||
|
|
proc = subprocess.run(["bash", case.script_name], cwd=work, capture_output=True, text=True, timeout=240)
|
|||
|
|
after = file_set(work)
|
|||
|
|
new_files = sorted(after - before)
|
|||
|
|
for rel in new_files:
|
|||
|
|
src = work / rel
|
|||
|
|
if src.is_file():
|
|||
|
|
(expected / rel).parent.mkdir(parents=True, exist_ok=True)
|
|||
|
|
shutil.copy2(src, expected / rel)
|
|||
|
|
log_path.write_text(f"$ bash {case.script_name}\n\n[stdout]\n{proc.stdout}\n\n[stderr]\n{proc.stderr}\n", encoding="utf-8")
|
|||
|
|
return {"success": proc.returncode == 0, "returncode": proc.returncode, "new_files": new_files, "stderr_tail": proc.stderr[-2000:]}
|
|||
|
|
|
|||
|
|
|
|||
|
|
def run_batch(out: Path, converter: str, runtime_env: str, stop_on_failure: bool) -> None:
|
|||
|
|
sys.path.insert(0, str(PROJECT_ROOT))
|
|||
|
|
from gfa_core.extension_stage import ExtensionStageAgent, ExtensionStageManager
|
|||
|
|
effective = "deepseek_api" if converter in {"archetype_spec", "deepseek_agent"} else converter
|
|||
|
|
os.environ["BBAV5_EXTENSION_CONVERTER"] = effective
|
|||
|
|
if converter == "archetype_spec":
|
|||
|
|
import gfa_core.extension_stage.agent as agent_module
|
|||
|
|
agent_module.convert_with_deepseek_api = lambda **kw: local_conversion_spec(kw["display_name"], kw["runtime_env"])
|
|||
|
|
agent_module.repair_build_with_deepseek_api = lambda **kw: local_conversion_spec(str(kw.get("display_name") or ""), str(kw.get("runtime_env") or runtime_env))
|
|||
|
|
run_root = out / "runtime" / converter
|
|||
|
|
for p in (run_root / "extension_stages", run_root / "workspace", run_root / "input", out / "results" / converter):
|
|||
|
|
clean_dir(p)
|
|||
|
|
manager = ExtensionStageManager(PROJECT_ROOT, store_root=run_root / "extension_stages", workspace_root=run_root / "workspace", input_root=run_root / "input")
|
|||
|
|
agent = ExtensionStageAgent(manager)
|
|||
|
|
rows = []
|
|||
|
|
for case in cases(DEFAULT_JOB_ROOT):
|
|||
|
|
row = run_one(agent, out, case, converter, runtime_env)
|
|||
|
|
rows.append(row)
|
|||
|
|
if stop_on_failure and not row_success(row):
|
|||
|
|
break
|
|||
|
|
summary = {"schema_version": "extension_publication_batch_result_v1", "created_at": now(), "converter": converter, "runtime_env": runtime_env, "case_count": len(rows), "passed": sum(1 for r in rows if row_success(r)), "failed": sum(1 for r in rows if not row_success(r)), "rows": rows}
|
|||
|
|
res = out / "results" / converter
|
|||
|
|
write_json(res / "summary.json", summary)
|
|||
|
|
write_csv(res / "summary.csv", rows)
|
|||
|
|
(res / "summary.md").write_text(summary_md(summary), encoding="utf-8")
|
|||
|
|
|
|||
|
|
|
|||
|
|
def run_one(agent: Any, out: Path, case: PubCase, converter: str, runtime_env: str) -> dict[str, Any]:
|
|||
|
|
case_root = out / "packages" / case.dir_name
|
|||
|
|
res_dir = out / "results" / converter / "per_archetype" / case.dir_name
|
|||
|
|
clean_dir(res_dir)
|
|||
|
|
row = {
|
|||
|
|
"archetype_id": case.archetype_id,
|
|||
|
|
"stage": case.stage,
|
|||
|
|
"converter": converter,
|
|||
|
|
"raw_code_ok": (case_root / "prepare_record.json").exists(),
|
|||
|
|
"expected_output_ok": expected_ok(case_root, case),
|
|||
|
|
"build_success": False,
|
|||
|
|
"extension_id": "",
|
|||
|
|
"trial_success": False,
|
|||
|
|
"confirm_success": False,
|
|||
|
|
"validate_success": False,
|
|||
|
|
"golden_status": "",
|
|||
|
|
"template_gate_status": "",
|
|||
|
|
"publish_success": False,
|
|||
|
|
"output_count": 0,
|
|||
|
|
"api_attempt_count": 0,
|
|||
|
|
"build_api_attempt_count": 0,
|
|||
|
|
"trial_repair_attempt_count": 0,
|
|||
|
|
"validation_repair_attempt_count": 0,
|
|||
|
|
"publish_repair_attempt_count": 0,
|
|||
|
|
"total_api_repair_attempt_count": 0,
|
|||
|
|
"final_validation_status": "",
|
|||
|
|
"final_publish_status": "",
|
|||
|
|
"last_repair_phase": "",
|
|||
|
|
"last_repair_error": "",
|
|||
|
|
"sanitizer_action_count": 0,
|
|||
|
|
"error": "",
|
|||
|
|
}
|
|||
|
|
try:
|
|||
|
|
build = agent.create_from_uploads(display_name=f"publication_{case.archetype_id}", command=f"bash {case.script_name}", runtime_env=runtime_env, code_files=upload_files(case_root / "raw_code"), data_files=upload_files(case_root / "raw_test_data"), description=case.description)
|
|||
|
|
write_json(res_dir / "build_response.json", build)
|
|||
|
|
ext = build.get("extension") or {}
|
|||
|
|
eid = str(ext.get("extension_id") or "")
|
|||
|
|
row.update({"build_success": bool(build.get("success") and eid), "extension_id": eid, "api_attempt_count": len(ext.get("build_attempts") or []), "build_api_attempt_count": len(ext.get("build_attempts") or []), "sanitizer_action_count": len(ext.get("sanitizer_actions") or [])})
|
|||
|
|
trial = agent.trial_run(eid)
|
|||
|
|
write_json(res_dir / "trial_run.json", trial)
|
|||
|
|
if not trial.get("success"):
|
|||
|
|
repair = agent.repair_from_context(eid, phase="trial", run_context=trial.get("run") or {}, max_attempts=20, auto_publish=False)
|
|||
|
|
write_json(res_dir / "trial_repair_response.json", repair)
|
|||
|
|
row["trial_repair_attempt_count"] = int(repair.get("attempts") or 0)
|
|||
|
|
if repair.get("success"):
|
|||
|
|
trial = {"success": True, "extension": repair.get("extension") or {}, "run": repair.get("run") or {}}
|
|||
|
|
else:
|
|||
|
|
row["last_repair_phase"] = "trial"
|
|||
|
|
row["last_repair_error"] = str(repair.get("last_error") or "")
|
|||
|
|
row["trial_success"] = bool(trial.get("success"))
|
|||
|
|
row["output_count"] = len((trial.get("run") or {}).get("outputs") or [])
|
|||
|
|
outputs = (trial.get("extension") or {}).get("outputs_detected") or (trial.get("run") or {}).get("outputs") or []
|
|||
|
|
confirm = agent.confirm(eid, outputs=outputs, nl_triggers=[case.archetype_id, case.stage])
|
|||
|
|
write_json(res_dir / "confirm_response.json", confirm)
|
|||
|
|
row["confirm_success"] = bool(confirm.get("success"))
|
|||
|
|
val = agent.validate(eid)
|
|||
|
|
write_json(res_dir / "validate_response.json", val)
|
|||
|
|
run = val.get("run") or {}
|
|||
|
|
gate = run.get("template_gate") or {}
|
|||
|
|
golden = run.get("golden_comparison") or {}
|
|||
|
|
row["validate_success"] = bool(val.get("success"))
|
|||
|
|
row["golden_status"] = str(golden.get("status") or "")
|
|||
|
|
row["template_gate_status"] = str(gate.get("status") or "")
|
|||
|
|
row["final_validation_status"] = str(run.get("status") or "")
|
|||
|
|
if not val.get("success"):
|
|||
|
|
repair = agent.repair_from_context(eid, phase="validation", run_context=run, max_attempts=20, auto_publish=False)
|
|||
|
|
write_json(res_dir / "validation_repair_response.json", repair)
|
|||
|
|
row["validation_repair_attempt_count"] = int(repair.get("attempts") or 0)
|
|||
|
|
if repair.get("success"):
|
|||
|
|
val = {"success": True, "extension": repair.get("extension") or {}, "run": repair.get("run") or {}}
|
|||
|
|
run = val.get("run") or {}
|
|||
|
|
gate = run.get("template_gate") or {}
|
|||
|
|
golden = run.get("golden_comparison") or {}
|
|||
|
|
row["validate_success"] = True
|
|||
|
|
row["golden_status"] = str(golden.get("status") or "")
|
|||
|
|
row["template_gate_status"] = str(gate.get("status") or "")
|
|||
|
|
row["final_validation_status"] = str(run.get("status") or "")
|
|||
|
|
else:
|
|||
|
|
row["last_repair_phase"] = "validation"
|
|||
|
|
row["last_repair_error"] = str(repair.get("last_error") or "")
|
|||
|
|
try:
|
|||
|
|
pub = agent.publish(eid)
|
|||
|
|
except Exception as pub_exc:
|
|||
|
|
publish_context = {
|
|||
|
|
"repair_phase": "publish_gate",
|
|||
|
|
"status": "failed",
|
|||
|
|
"error": str(pub_exc),
|
|||
|
|
"publish_checks": (agent.load(eid).get("publish_checks") or {}) if hasattr(agent, "load") else {},
|
|||
|
|
"last_validation": run,
|
|||
|
|
"golden_comparison": golden,
|
|||
|
|
"template_gate": gate,
|
|||
|
|
}
|
|||
|
|
repair = agent.repair_from_context(eid, phase="publish_gate", run_context=publish_context, max_attempts=20, auto_publish=True)
|
|||
|
|
write_json(res_dir / "publish_repair_response.json", repair)
|
|||
|
|
row["publish_repair_attempt_count"] = int(repair.get("attempts") or 0)
|
|||
|
|
if repair.get("success") and repair.get("published"):
|
|||
|
|
pub = {"success": True, "extension": repair.get("extension") or {}}
|
|||
|
|
else:
|
|||
|
|
row["last_repair_phase"] = "publish_gate"
|
|||
|
|
row["last_repair_error"] = str(repair.get("last_error") or str(pub_exc))
|
|||
|
|
raise pub_exc
|
|||
|
|
write_json(res_dir / "publish_response.json", pub)
|
|||
|
|
row["publish_success"] = bool(pub.get("success"))
|
|||
|
|
row["final_publish_status"] = str((pub.get("extension") or {}).get("status") or "")
|
|||
|
|
except Exception as exc:
|
|||
|
|
row["error"] = str(exc)
|
|||
|
|
write_json(res_dir / "error.json", {"error": str(exc), "traceback": traceback.format_exc(), "row": row})
|
|||
|
|
row["total_api_repair_attempt_count"] = int(row.get("trial_repair_attempt_count") or 0) + int(row.get("validation_repair_attempt_count") or 0) + int(row.get("publish_repair_attempt_count") or 0)
|
|||
|
|
write_json(res_dir / "result_row.json", row)
|
|||
|
|
return row
|
|||
|
|
|
|||
|
|
|
|||
|
|
def run_negative_controls(out: Path, runtime_env: str) -> None:
|
|||
|
|
sys.path.insert(0, str(PROJECT_ROOT))
|
|||
|
|
from gfa_core.extension_stage import ExtensionStageAgent, ExtensionStageManager
|
|||
|
|
os.environ["BBAV5_EXTENSION_CONVERTER"] = "deepseek_api"
|
|||
|
|
import gfa_core.extension_stage.agent as agent_module
|
|||
|
|
neg_root = out / "negative_cases"
|
|||
|
|
clean_dir(neg_root)
|
|||
|
|
base = out / "packages" / "01_sequence_extraction"
|
|||
|
|
|
|||
|
|
def spec_for(scenario: str) -> dict[str, Any]:
|
|||
|
|
spec = local_conversion_spec("publication_sequence_extraction", runtime_env)
|
|||
|
|
if scenario == "unknown_archetype":
|
|||
|
|
spec["archetype_id"] = "unknown_publication_archetype"
|
|||
|
|
elif scenario == "missing_output_contract":
|
|||
|
|
spec["output_contract"] = [{"name_pattern": "not_present.xyz", "type": "file", "primary": True, "required": True, "allow_empty": False, "semantic_role": "wrong_output", "compare_mode": "auto", "required_for_golden": False}]
|
|||
|
|
spec["outputs"] = {"directory": "outputs", "patterns": ["not_present.xyz"]}
|
|||
|
|
spec["comparator_plan"] = {"mode": "pipeline_golden_diff", "steps": []}
|
|||
|
|
elif scenario == "wrong_input_role":
|
|||
|
|
spec["input_roles"] = {"input_file": {"role": "generic_input_file", "required": True}}
|
|||
|
|
spec["inputs"] = {"input_file": {"required": True}}
|
|||
|
|
return spec
|
|||
|
|
|
|||
|
|
scenarios = [
|
|||
|
|
{"name": "missing_id_file", "mutate": lambda d: (d / "raw_test_data" / "ids.id").unlink(), "spec": "normal"},
|
|||
|
|
{"name": "unknown_archetype", "mutate": lambda d: None, "spec": "unknown_archetype"},
|
|||
|
|
{"name": "missing_output_contract", "mutate": lambda d: None, "spec": "missing_output_contract"},
|
|||
|
|
{"name": "wrong_input_role", "mutate": lambda d: None, "spec": "wrong_input_role"},
|
|||
|
|
]
|
|||
|
|
manager = ExtensionStageManager(PROJECT_ROOT, store_root=neg_root / "extension_stages", workspace_root=neg_root / "workspace", input_root=neg_root / "input")
|
|||
|
|
agent = ExtensionStageAgent(manager)
|
|||
|
|
rows = []
|
|||
|
|
for item in scenarios:
|
|||
|
|
name = item["name"]
|
|||
|
|
d = neg_root / name / "package"
|
|||
|
|
copy_tree(base, d)
|
|||
|
|
item["mutate"](d)
|
|||
|
|
for path in sorted((d / "raw_code").glob("*.sh")):
|
|||
|
|
path.chmod(0o755)
|
|||
|
|
scenario_spec = str(item["spec"])
|
|||
|
|
agent_module.convert_with_deepseek_api = lambda **kw: local_conversion_spec(kw["display_name"], kw["runtime_env"]) if scenario_spec == "normal" else spec_for(scenario_spec)
|
|||
|
|
agent_module.repair_build_with_deepseek_api = lambda **kw: local_conversion_spec(str(kw.get("display_name") or ""), str(kw.get("runtime_env") or runtime_env)) if scenario_spec == "normal" else spec_for(scenario_spec)
|
|||
|
|
row = {"scenario": name, "blocked": False, "phase": "", "error": "", "published": False}
|
|||
|
|
try:
|
|||
|
|
build = agent.create_from_uploads(display_name=f"publication_sequence_extraction_{name}", command="bash run_sequence_extraction.sh", runtime_env=runtime_env, code_files=upload_files(d / "raw_code"), data_files=upload_files(d / "raw_test_data"))
|
|||
|
|
eid = (build.get("extension") or {}).get("extension_id")
|
|||
|
|
trial = agent.trial_run(eid)
|
|||
|
|
agent.confirm(eid, outputs=(trial.get("extension") or {}).get("outputs_detected") or (trial.get("run") or {}).get("outputs") or [], nl_triggers=["sequence_extraction"])
|
|||
|
|
agent.validate(eid)
|
|||
|
|
published = agent.publish(eid)
|
|||
|
|
row["published"] = bool(published.get("success"))
|
|||
|
|
except Exception as exc:
|
|||
|
|
row.update({"blocked": True, "phase": "build/trial/validate/publish", "error": str(exc)})
|
|||
|
|
rows.append(row)
|
|||
|
|
write_json(neg_root / "negative_control_summary.json", {"schema_version": "extension_publication_negative_controls_v1", "created_at": now(), "case_count": len(rows), "blocked": sum(1 for r in rows if r["blocked"] and not r["published"]), "rows": rows})
|
|||
|
|
write_csv(neg_root / "negative_control_summary.csv", rows)
|
|||
|
|
|
|||
|
|
|
|||
|
|
def extension_hint(case: PubCase) -> dict[str, Any]:
|
|||
|
|
roles = {
|
|||
|
|
"sequence_extraction": {"input_pep_fasta": {"role": "target_pep_fasta", "required": True}, "input_id_file": {"role": "target_id_list", "required": True}},
|
|||
|
|
"hmmer_domain": {"input_fasta": {"role": "target_pep_fasta", "required": True}, "input_file": {"role": "generic_input_file", "required": True}},
|
|||
|
|
"motif_meme": {"input_fasta": {"role": "target_pep_fasta", "required": True}},
|
|||
|
|
"phylogeny_tree": {"input_fasta": {"role": "target_pep_fasta", "required": True}},
|
|||
|
|
"reference_classification": {"input_file": {"role": "generic_input_file", "required": True}},
|
|||
|
|
"synteny_collinearity": {"input_query_fasta": {"role": "target_pep_fasta", "required": True}, "input_reference_fasta": {"role": "reference_pep_fasta", "required": True}, "input_file": {"role": "generic_input_file", "required": True}},
|
|||
|
|
"kaks_pairwise": {"input_file": {"role": "generic_input_file", "required": True}},
|
|||
|
|
"pep_properties": {"input_fasta": {"role": "target_pep_fasta", "required": True}, "input_file": {"role": "generic_input_file", "required": False}},
|
|||
|
|
}[case.archetype_id]
|
|||
|
|
semantic_roles = {
|
|||
|
|
"sequence_extraction": {"extracted.fa": "extracted_fasta", "extracted.id": "id_list"},
|
|||
|
|
"hmmer_domain": {"filtered.domtblout": "hmmer_domtblout"},
|
|||
|
|
"motif_meme": {"meme.xml": "meme_xml", "meme.txt": "meme_txt"},
|
|||
|
|
"phylogeny_tree": {"output.msa.fa": "multiple_sequence_alignment", "output.nwk": "newick_tree"},
|
|||
|
|
"reference_classification": {"output.assignment.tsv": "assignment_table", "output.subfamily.tsv": "subfamily_table", "output.confidence.tsv": "confidence_table"},
|
|||
|
|
"synteny_collinearity": {"output.blast": "blast_outfmt6", "output.collinearity": "collinearity"},
|
|||
|
|
"kaks_pairwise": {"output.kaks_results.csv": "kaks_results"},
|
|||
|
|
"pep_properties": {"output.properties.tsv": "protein_properties", "output.subcellular.tsv": "subcellular_table"},
|
|||
|
|
}.get(case.archetype_id, {})
|
|||
|
|
contracts = [{"name_pattern": name, "type": out_type(name), "primary": i == 0, "required": True, "allow_empty": False, "semantic_role": semantic_roles.get(name, case.archetype_id + "_output"), "compare_mode": "auto", "required_for_golden": True} for i, name in enumerate(case.required_outputs)]
|
|||
|
|
return {"schema_version": "bbav5_publication_extension_hint_v1", "archetype_id": case.archetype_id, "representative_stage": case.stage, "recommended_original_command": f"bash {case.script_name}", "analysis_type": analysis_type(case.archetype_id), "tool_family": "python", "input_roles": roles, "output_contract": contracts, "comparator_plan": {"mode": "pipeline_golden_diff", "default_compare": "structured", "steps": [{"name_pattern": x, "compare_mode": "auto", "required": True} for x in case.required_outputs]}, "requires_user_confirmation": False}
|
|||
|
|
|
|||
|
|
|
|||
|
|
def local_conversion_spec(display_name: str, runtime_env: str) -> dict[str, Any]:
|
|||
|
|
case = case_from_display(display_name)
|
|||
|
|
hint = extension_hint(case)
|
|||
|
|
return {"template_type": "publication_archetype_spec", "archetype_id": case.archetype_id, "original_command": f"bash {case.script_name}", "command_template": "bash {code_dir}/" + case.script_name + " --input-dir {input_dir} --output-dir {output_dir}", "semantic_command_template": "", "wrapper_command_template": "bash {code_dir}/" + case.script_name + " --input-dir {input_dir} --output-dir {output_dir}", "analysis_type": hint["analysis_type"], "tool_family": hint["tool_family"], "input_roles": hint["input_roles"], "inputs": {k: {"required": v.get("required", True)} for k, v in hint["input_roles"].items()}, "parameters": {}, "outputs": {"directory": "outputs", "patterns": list(case.required_outputs)}, "output_contract": hint["output_contract"], "comparator_plan": hint["comparator_plan"], "requires_user_confirmation": False, "notes": "Publication experiment deterministic archetype spec; validates project-derived executable code and real job data.", "converter": {"type": "archetype_spec", "mode": "publication_reproducible", "runtime_env": runtime_env}}
|
|||
|
|
|
|||
|
|
|
|||
|
|
def write_report(out: Path, job_id: str, job_root: Path) -> None:
|
|||
|
|
(out / "tables").mkdir(parents=True, exist_ok=True)
|
|||
|
|
(out / "figures").mkdir(parents=True, exist_ok=True)
|
|||
|
|
summaries = {}
|
|||
|
|
for conv in ("archetype_spec", "deepseek_agent", "deepseek_api"):
|
|||
|
|
p = out / "results" / conv / "summary.json"
|
|||
|
|
if p.exists():
|
|||
|
|
summaries[conv] = json.loads(p.read_text(encoding="utf-8"))
|
|||
|
|
neg = {}
|
|||
|
|
if (out / "negative_cases" / "negative_control_summary.json").exists():
|
|||
|
|
neg = json.loads((out / "negative_cases" / "negative_control_summary.json").read_text(encoding="utf-8"))
|
|||
|
|
write_json(out / "publication_metrics.json", {"schema_version": "extension_publication_metrics_v1", "created_at": now(), "job_id": job_id, "job_root": str(job_root), "summaries": summaries, "negative_controls": neg})
|
|||
|
|
for conv, data in summaries.items():
|
|||
|
|
write_csv(out / "tables" / f"table_{conv}_results.csv", data.get("rows") or [])
|
|||
|
|
if neg:
|
|||
|
|
write_csv(out / "tables" / "table_negative_controls.csv", neg.get("rows") or [])
|
|||
|
|
write_figures(out, summaries, neg)
|
|||
|
|
(out / "summary_report.html").write_text(render_html(job_id, job_root, summaries, neg), encoding="utf-8")
|
|||
|
|
|
|||
|
|
|
|||
|
|
def write_figures(out: Path, summaries: dict[str, Any], neg: dict[str, Any]) -> None:
|
|||
|
|
rows = [(conv, int(data.get("passed") or 0), int(data.get("failed") or 0)) for conv, data in summaries.items()] or [("no_run", 0, 0)]
|
|||
|
|
width, height, x, barw, gap = 720, 220, 80, 70, 80
|
|||
|
|
maxv = max([p + f for _, p, f in rows] + [1])
|
|||
|
|
parts = [f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {width} {height}"><style>.t{{font:13px Arial}}.h{{font:700 14px Arial}}</style><text x="20" y="25" class="h">Extension-stage publication experiment pass/fail counts</text>']
|
|||
|
|
for i, (name, p, f) in enumerate(rows):
|
|||
|
|
bx = x + i * (barw + gap)
|
|||
|
|
ph = int(140 * p / maxv)
|
|||
|
|
fh = int(140 * f / maxv)
|
|||
|
|
parts.append(f'<rect x="{bx}" y="{170 - ph}" width="{barw}" height="{ph}" fill="#2f7d55"/><rect x="{bx}" y="{170 - ph - fh}" width="{barw}" height="{fh}" fill="#b33a3a"/><text x="{bx + barw/2}" y="190" text-anchor="middle" class="t">{html.escape(name)}</text><text x="{bx + barw/2}" y="{160 - ph - fh}" text-anchor="middle" class="t">P{p}/F{f}</text>')
|
|||
|
|
parts.append("</svg>")
|
|||
|
|
(out / "figures" / "figure_pass_fail.svg").write_text("\n".join(parts), encoding="utf-8")
|
|||
|
|
|
|||
|
|
|
|||
|
|
def render_html(job_id: str, job_root: Path, summaries: dict[str, Any], neg: dict[str, Any]) -> str:
|
|||
|
|
cards = []
|
|||
|
|
for conv, data in summaries.items():
|
|||
|
|
cards.append(f"<div class='metric'><b>{data.get('passed')}/{data.get('case_count')}</b><span>{html.escape(conv)} passed</span></div>")
|
|||
|
|
if neg:
|
|||
|
|
cards.append(f"<div class='metric'><b>{neg.get('blocked')}/{neg.get('case_count')}</b><span>negative controls blocked</span></div>")
|
|||
|
|
rows = "".join(f"<tr><td>{html.escape(conv)}</td><td>{d.get('case_count')}</td><td>{d.get('passed')}</td><td>{d.get('failed')}</td></tr>" for conv, d in summaries.items())
|
|||
|
|
negrows = "".join(f"<tr><td>{html.escape(str(r.get('scenario','')))}</td><td>{r.get('blocked')}</td><td>{r.get('published')}</td><td>{html.escape(str(r.get('error',''))[:240])}</td></tr>" for r in (neg.get("rows") or []))
|
|||
|
|
return f"""<!doctype html><html lang="zh-CN"><head><meta charset="utf-8"><title>拓展分析阶段发表级完整实验结果</title><style>body{{font:14px/1.65 Arial,'Microsoft YaHei',sans-serif;color:#18212f;margin:0}}main{{max-width:1160px;margin:auto;padding:28px}}h1{{font-size:28px}}h2{{border-left:5px solid #2666a8;padding-left:10px}}table{{border-collapse:collapse;width:100%;margin:12px 0}}td,th{{border:1px solid #d7dde7;padding:8px;vertical-align:top}}th{{background:#edf2f8}}.grid{{display:grid;grid-template-columns:repeat(3,1fr);gap:12px}}.metric{{border:1px solid #d7dde7;background:#f7f9fc;padding:14px;border-radius:8px}}.metric b{{display:block;font-size:24px;color:#2666a8}}.note{{background:#e9f2fb;border-left:4px solid #2666a8;padding:10px}}</style></head><body><main><h1>拓展分析阶段：发表级完整实验结果</h1><p>数据源：<code>{html.escape(str(job_root))}</code>；Job：<code>{html.escape(job_id)}</code>。本报告只汇总真实执行或真实失败的结果。</p><div class="grid">{''.join(cards)}</div><h2>实验定位</h2><div class="note">确定性 archetype 链路用于证明拓展阶段构建、验证和发布闭环；DeepSeek/API Agent 作为正式对照实验，按真实成功率和失败类型报告。</div><h2>总体结果</h2><table><tr><th>Converter</th><th>Cases</th><th>Passed</th><th>Failed</th></tr>{rows}</table><h2>图 1：通过/失败计数</h2><img src="figures/figure_pass_fail.svg" style="max-width:100%"><h2>负例拦截</h2><table><tr><th>Scenario</th><th>Blocked</th><th>Published</th><th>Error</th></tr>{negrows}</table><h2>可复现文件</h2><p>原始代码与数据位于 <code>packages/</code>，运行记录位于 <code>results/</code>，日志位于 <code>logs/</code>，完整文件清单位于 <code>MANIFEST.json</code>。</p></main></body></html>"""
|
|||
|
|
|
|||
|
|
|
|||
|
|
def case_from_display(text: str) -> PubCase:
|
|||
|
|
for c in cases(DEFAULT_JOB_ROOT):
|
|||
|
|
if c.archetype_id in text:
|
|||
|
|
return c
|
|||
|
|
raise ValueError(f"cannot infer case from display_name: {text}")
|
|||
|
|
|
|||
|
|
|
|||
|
|
def analysis_type(a: str) -> str:
|
|||
|
|
return {"sequence_extraction": "sequence_extraction", "hmmer_domain": "hmmer_search", "motif_meme": "generic_cli", "phylogeny_tree": "generic_cli", "reference_classification": "table_filter", "synteny_collinearity": "blast_search", "kaks_pairwise": "generic_cli", "pep_properties": "enrichment_or_stats"}[a]
|
|||
|
|
|
|||
|
|
|
|||
|
|
def out_type(name: str) -> str:
|
|||
|
|
s = name.lower()
|
|||
|
|
if s.endswith((".fa", ".fasta")):
|
|||
|
|
return "fasta"
|
|||
|
|
if s.endswith(".xml"):
|
|||
|
|
return "xml"
|
|||
|
|
if s.endswith((".tsv", ".csv")):
|
|||
|
|
return "table"
|
|||
|
|
if s.endswith((".nwk", ".txt", ".domtblout")):
|
|||
|
|
return "text"
|
|||
|
|
return "file"
|
|||
|
|
|
|||
|
|
|
|||
|
|
def case_readme(case: PubCase, copied: list[dict[str, Any]]) -> str:
|
|||
|
|
return f"# {case.archetype_id}\n\nRepresentative stage: `{case.stage}`\n\nPurpose: {case.description}\n\nSource files:\n" + "".join(f"- `{x['source']}` -> `raw_test_data/{x['dest']}`\n" for x in copied)
|
|||
|
|
|
|||
|
|
|
|||
|
|
def upload_files(root: Path) -> list[tuple[str, bytes]]:
|
|||
|
|
return [(p.name, p.read_bytes()) for p in sorted(root.iterdir()) if p.is_file()]
|
|||
|
|
|
|||
|
|
|
|||
|
|
def expected_ok(root: Path, case: PubCase) -> bool:
|
|||
|
|
return all((root / "expected_outputs" / x).is_file() and (root / "expected_outputs" / x).stat().st_size > 0 for x in case.required_outputs)
|
|||
|
|
|
|||
|
|
|
|||
|
|
def row_success(r: dict[str, Any]) -> bool:
|
|||
|
|
return all(bool(r.get(k)) for k in ("raw_code_ok", "expected_output_ok", "build_success", "trial_success", "confirm_success", "validate_success", "publish_success")) and r.get("golden_status") == "passed" and r.get("template_gate_status") == "passed"
|
|||
|
|
|
|||
|
|
|
|||
|
|
def clean_dir(p: Path) -> None:
|
|||
|
|
if p.exists():
|
|||
|
|
shutil.rmtree(p)
|
|||
|
|
p.mkdir(parents=True, exist_ok=True)
|
|||
|
|
|
|||
|
|
|
|||
|
|
def copy_tree(src: Path, dst: Path) -> None:
|
|||
|
|
dst.mkdir(parents=True, exist_ok=True)
|
|||
|
|
if not src.exists():
|
|||
|
|
return
|
|||
|
|
for item in src.iterdir():
|
|||
|
|
target = dst / item.name
|
|||
|
|
if item.is_dir():
|
|||
|
|
shutil.copytree(item, target, dirs_exist_ok=True)
|
|||
|
|
else:
|
|||
|
|
shutil.copy2(item, target)
|
|||
|
|
|
|||
|
|
|
|||
|
|
def file_set(root: Path) -> set[str]:
|
|||
|
|
return {p.relative_to(root).as_posix() for p in root.rglob("*") if p.is_file()}
|
|||
|
|
|
|||
|
|
|
|||
|
|
def write_json(p: Path, data: Any) -> None:
|
|||
|
|
p.parent.mkdir(parents=True, exist_ok=True)
|
|||
|
|
p.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
|
|||
|
|
|
|||
|
|
|
|||
|
|
def write_csv(p: Path, rows: list[dict[str, Any]]) -> None:
|
|||
|
|
p.parent.mkdir(parents=True, exist_ok=True)
|
|||
|
|
fields = sorted({k for r in rows for k in r.keys()}) if rows else ["empty"]
|
|||
|
|
with p.open("w", encoding="utf-8", newline="") as h:
|
|||
|
|
w = csv.DictWriter(h, fieldnames=fields)
|
|||
|
|
w.writeheader()
|
|||
|
|
for r in rows:
|
|||
|
|
w.writerow({f: r.get(f, "") for f in fields})
|
|||
|
|
|
|||
|
|
|
|||
|
|
def summary_md(s: dict[str, Any]) -> str:
|
|||
|
|
lines = ["# Extension Publication Batch", "", f"Converter: `{s.get('converter')}`", f"Cases: {s.get('case_count')} passed={s.get('passed')} failed={s.get('failed')}", "", "| Archetype | Build | Trial | Validate | Golden | Gate | Publish | Error |", "|---|---:|---:|---:|---|---|---:|---|"]
|
|||
|
|
for r in s.get("rows") or []:
|
|||
|
|
err = str(r.get("error") or "")[:120].replace("|", "/")
|
|||
|
|
lines.append(f"| `{r.get('archetype_id')}` | {r.get('build_success')} | {r.get('trial_success')} | {r.get('validate_success')} | `{r.get('golden_status')}` | `{r.get('template_gate_status')}` | {r.get('publish_success')} | {err} |")
|
|||
|
|
return "\n".join(lines) + "\n"
|
|||
|
|
|
|||
|
|
|
|||
|
|
def write_manifest(out: Path) -> None:
|
|||
|
|
files = []
|
|||
|
|
for p in sorted(x for x in out.rglob("*") if x.is_file() and x.name != "MANIFEST.json"):
|
|||
|
|
files.append({"path": p.relative_to(out).as_posix(), "size": p.stat().st_size, "sha256": sha256(p)})
|
|||
|
|
write_json(out / "MANIFEST.json", {"schema_version": "extension_publication_experiment_manifest_v1", "created_at": now(), "root": str(out), "file_count": len(files), "files": files})
|
|||
|
|
|
|||
|
|
|
|||
|
|
def sha256(p: Path) -> str:
|
|||
|
|
h = hashlib.sha256()
|
|||
|
|
with p.open("rb") as f:
|
|||
|
|
for b in iter(lambda: f.read(1024 * 1024), b""):
|
|||
|
|
h.update(b)
|
|||
|
|
return h.hexdigest()
|
|||
|
|
|
|||
|
|
|
|||
|
|
def now() -> str:
|
|||
|
|
return datetime.now().isoformat(timespec="seconds")
|
|||
|
|
|
|||
|
|
|
|||
|
|
if __name__ == "__main__":
|
|||
|
|
raise SystemExit(main())
|