docking_pipeline/audit_regressor_ablation.py

from __future__ import annotations

import argparse
import json
from pathlib import Path
from typing import Any

from .provenance import require_file


def audit_regressor_ablation(run_dir: str | Path) -> dict[str, Any]:
    root = Path(run_dir)
    summary = json.loads(require_file(root / "metrics" / "regressor_ablation_summary.json", "regressor ablation summary").read_text(encoding="utf-8"))
    audit = json.loads(require_file(root / "metrics" / "regressor_audit_metrics.json", "regressor audit metrics").read_text(encoding="utf-8"))
    payload = {
        "run_dir": str(root),
        "recommended_strategy_final": summary.get("recommended_strategy_final"),
        "recommended_reason": summary.get("recommended_reason"),
        "regressor_adds_value": summary.get("regressor_adds_value"),
        "fixed_score_regressor_name": audit.get("fixed_score_regressor_name"),
        "fixed_score_regressor_target": audit.get("fixed_score_regressor_target"),
        "regressor_reason": audit.get("regressor_reason"),
    }
    (root / "regressor_ablation_audit.md").write_text(
        "\n".join(
            [
                f"# audit-regressor-ablation: {root.name}",
                "",
                f"- recommended_strategy_final: `{payload['recommended_strategy_final']}`",
                f"- recommended_reason: `{payload['recommended_reason']}`",
                f"- regressor_adds_value: `{payload['regressor_adds_value']}`",
                f"- fixed_score_regressor_name: `{payload['fixed_score_regressor_name']}`",
                f"- fixed_score_regressor_target: `{payload['fixed_score_regressor_target']}`",
                f"- regressor_reason: `{payload['regressor_reason']}`",
            ]
        )
        + "\n",
        encoding="utf-8",
    )
    return payload


def build_arg_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description="Audit a completed regressor ablation benchmark run.")
    parser.add_argument("--run-dir", required=True)
    return parser


def run_from_args(args: argparse.Namespace) -> dict[str, Any]:
    return audit_regressor_ablation(args.run_dir)


def main() -> int:
    print(json.dumps(run_from_args(build_arg_parser().parse_args()), indent=2))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())