| """Audit OracleMem artifacts for evidence-unit and coverage completeness.
|
|
|
| This is a lightweight structural audit. It does not judge annotation quality;
|
| it checks whether artifacts expose the fields needed for a non-synthetic
|
| OracleMem coverage package:
|
|
|
| * evidence units;
|
| * query-to-unit requirements;
|
| * candidate memories with costs and groups;
|
| * candidate-by-unit coverage rows.
|
|
|
| Existing LongMemEval artifacts are expected to be session-evidence diagnostics,
|
| not full coverage matrices. The report makes that boundary explicit.
|
| """
|
|
|
| from __future__ import annotations
|
|
|
| import argparse
|
| import json
|
| from collections import Counter
|
| from dataclasses import asdict, dataclass, field
|
| from pathlib import Path
|
| from typing import Any, Iterable
|
|
|
|
|
| DEFAULT_ARTIFACTS: tuple[tuple[str, str, str], ...] = (
|
| (
|
| "oraclemem_exact_500_results",
|
| "oraclemem_runs/exact_500/raw_results.jsonl",
|
| "Synthetic exact result rows; selected ids and metrics, not full matrix.",
|
| ),
|
| (
|
| "oraclemem_stress_exact_500_results",
|
| "oraclemem_runs/stress_exact_500/raw_results.jsonl",
|
| "Synthetic stress result rows; selected ids and metrics, not full matrix.",
|
| ),
|
| (
|
| "oraclemem_decomp_det_300_summary",
|
| "oraclemem_runs/decomp_det_300/summary.json",
|
| "Synthetic deterministic decomposition summary.",
|
| ),
|
| (
|
| "longmemeval_retrieval_rows",
|
| "llm_memory_validation/competitor_run_v2/retrieval_rows.json",
|
| "LongMemEval-S retrieval rows with coarse gold session ids.",
|
| ),
|
| (
|
| "longmemeval_focus_summary",
|
| "llm_memory_validation/longmemeval_focus_report_core4/summary.json",
|
| "LongMemEval-S retrieval report summary.",
|
| ),
|
| (
|
| "gpt55_reader_outputs",
|
| "llm_memory_validation/longmemeval_reader_api_gpt55_answer_supported_focus_full/reader_outputs.jsonl",
|
| "Frozen-context GPT-5.5 reader outputs.",
|
| ),
|
| (
|
| "gpt55_error_audit_rows",
|
| "llm_memory_validation/longmemeval_reader_api_gpt55_answer_supported_focus_full/error_audit_rows.jsonl",
|
| "Reader error audit rows.",
|
| ),
|
| (
|
| "gpt55_reader_semantic_sample",
|
| "llm_memory_validation/longmemeval_reader_api_gpt55_answer_supported_focus_full/semantic_audit_sample_50.jsonl",
|
| "Reader semantic audit sample.",
|
| ),
|
| (
|
| "gpt55_scoring_audit_summary",
|
| "llm_memory_validation/scoring_audit_gpt55/normalized_scoring_v2.json",
|
| "Normalized scoring audit summary.",
|
| ),
|
| (
|
| "gpt55_scoring_audit_sample",
|
| "llm_memory_validation/scoring_audit_gpt55/semantic_audit_sample_50.jsonl",
|
| "Balanced human/judge scoring audit sample.",
|
| ),
|
| )
|
|
|
|
|
| UNIT_KEYS = {"unit_id", "evidence_unit_id"}
|
| UNIT_CONTAINER_KEYS = {"units", "evidence_units"}
|
| QUERY_ID_KEYS = {"query_id", "question_id"}
|
| UNIT_REQUIREMENT_KEYS = {"required_unit_ids", "required_units"}
|
| SESSION_REQUIREMENT_KEYS = {"answer_session_ids", "gold_session_ids"}
|
| CANDIDATE_KEYS = {"candidate_id"}
|
| SELECTED_CANDIDATE_KEYS = {"selected_candidate_ids"}
|
| CANDIDATE_DETAIL_KEYS = {
|
| "candidate_id",
|
| "experience_id",
|
| "candidate_group",
|
| "representation_type",
|
| "representation",
|
| "text",
|
| "serialized",
|
| "cost",
|
| "cost_tokens",
|
| }
|
| COVERAGE_KEYS = {"coverage", "coverage_label", "fidelity"}
|
| COVERAGE_SUMMARY_KEYS = {
|
| "update_metrics",
|
| "retrieval_metrics",
|
| "retrieval_summary",
|
| "gold_recall_in_context",
|
| "evidence_use",
|
| "support_in_context",
|
| "retrieved_at_5",
|
| }
|
| CONTEXT_KEYS = {"context_session_ids", "used_memory_ids", "retrieved_memories"}
|
| PACKAGE_FILE_ALIASES: tuple[tuple[str, tuple[str, ...]], ...] = (
|
| ("manifest", ("candidate_generation_manifest.json", "manifest.json")),
|
| ("evidence_units", ("evidence_units.jsonl",)),
|
| ("queries", ("queries.jsonl",)),
|
| ("experiences", ("experiences.jsonl",)),
|
| ("candidate_memories", ("candidate_memories.jsonl",)),
|
| ("coverage_matrix", ("coverage_matrix.jsonl",)),
|
| ("annotation_decisions", ("annotation_decisions.jsonl",)),
|
| )
|
|
|
|
|
| @dataclass
|
| class ArtifactAudit:
|
| name: str
|
| path: str
|
| role: str
|
| exists: bool
|
| format: str = "missing"
|
| row_count: int = 0
|
| sampled_rows: int = 0
|
| key_counts: dict[str, int] = field(default_factory=dict)
|
| signals: dict[str, bool] = field(default_factory=dict)
|
| completeness: dict[str, float] = field(default_factory=dict)
|
| statuses: dict[str, str] = field(default_factory=dict)
|
| gaps: list[str] = field(default_factory=list)
|
| errors: list[str] = field(default_factory=list)
|
| package_files: dict[str, bool] = field(default_factory=dict)
|
|
|
|
|
| def _load_json(path: Path, sample_rows: int) -> tuple[str, int, list[dict[str, Any]]]:
|
| data = json.loads(path.read_text(encoding="utf-8"))
|
| records: list[dict[str, Any]] = []
|
| row_count = 0
|
|
|
| if isinstance(data, list):
|
| row_count = len(data)
|
| records = [row for row in data[:sample_rows] if isinstance(row, dict)]
|
| return "json_list", row_count, records
|
|
|
| if isinstance(data, dict):
|
| list_values = {
|
| key: value
|
| for key, value in data.items()
|
| if isinstance(value, list) and value and all(isinstance(item, dict) for item in value[:5])
|
| }
|
| if list_values:
|
| for key, rows in list_values.items():
|
| row_count += len(rows)
|
| remaining = max(0, sample_rows - len(records))
|
| if remaining:
|
| for row in rows[:remaining]:
|
| item = dict(row)
|
| item["_container_key"] = key
|
| records.append(item)
|
| return "json_dict_of_lists", row_count, records
|
|
|
| records = [data]
|
| return "json_object", 1, records
|
|
|
| return type(data).__name__, 1, []
|
|
|
|
|
| def _load_jsonl(path: Path, sample_rows: int) -> tuple[str, int, list[dict[str, Any]]]:
|
| records: list[dict[str, Any]] = []
|
| row_count = 0
|
| with path.open("r", encoding="utf-8") as handle:
|
| for line_number, line in enumerate(handle, start=1):
|
| stripped = line.strip()
|
| if not stripped:
|
| continue
|
| row_count += 1
|
| if len(records) >= sample_rows:
|
| continue
|
| try:
|
| row = json.loads(stripped)
|
| except json.JSONDecodeError as exc:
|
| raise ValueError(f"bad JSONL at line {line_number}: {exc}") from exc
|
| if isinstance(row, dict):
|
| records.append(row)
|
| return "jsonl", row_count, records
|
|
|
|
|
| def _load_records(path: Path, sample_rows: int) -> tuple[str, int, list[dict[str, Any]]]:
|
| if path.is_dir():
|
| records: list[dict[str, Any]] = []
|
| row_count = 0
|
| per_file_sample = max(1, sample_rows // max(1, len(PACKAGE_FILE_ALIASES)))
|
| for label, child_names in PACKAGE_FILE_ALIASES:
|
| child = next((path / child_name for child_name in child_names if (path / child_name).exists()), None)
|
| if child is None:
|
| continue
|
| if len(records) >= sample_rows:
|
| remaining = per_file_sample
|
| else:
|
| remaining = max(per_file_sample, sample_rows - len(records))
|
| child_format, child_count, child_records = _load_records(child, remaining)
|
| row_count += child_count
|
| for record in child_records[:remaining]:
|
| item = dict(record)
|
| item["_container_key"] = label
|
| item["_container_file"] = child.name
|
| item["_container_format"] = child_format
|
| records.append(item)
|
| return "coverage_package_dir", row_count, records
|
|
|
| suffix = path.suffix.lower()
|
| if suffix == ".jsonl":
|
| return _load_jsonl(path, sample_rows)
|
| if suffix == ".json":
|
| return _load_json(path, sample_rows)
|
| if suffix == ".md":
|
| return "markdown", 1, [{"text": path.read_text(encoding="utf-8", errors="replace")}]
|
| return suffix.lstrip(".") or "unknown", 0, []
|
|
|
|
|
| def _package_file_presence(path: Path) -> dict[str, bool]:
|
| if not path.is_dir():
|
| return {}
|
| return {
|
| label: any((path / child_name).exists() for child_name in child_names)
|
| for label, child_names in PACKAGE_FILE_ALIASES
|
| }
|
|
|
|
|
| def _all_keys(records: Iterable[dict[str, Any]]) -> Counter[str]:
|
| counts: Counter[str] = Counter()
|
| for record in records:
|
| for key in record:
|
| counts[str(key)] += 1
|
| return counts
|
|
|
|
|
| def _has_any_key(records: list[dict[str, Any]], keys: set[str]) -> bool:
|
| return any(any(key in record for key in keys) for record in records)
|
|
|
|
|
| def _has_nested_container(records: list[dict[str, Any]], keys: set[str]) -> bool:
|
| for record in records:
|
| for key in keys:
|
| value = record.get(key)
|
| if isinstance(value, list) and value:
|
| return True
|
| if isinstance(value, dict) and value:
|
| return True
|
| return False
|
|
|
|
|
| def _fraction_with(records: list[dict[str, Any]], keys: set[str]) -> float:
|
| if not records:
|
| return 0.0
|
| return sum(1 for record in records if any(key in record for key in keys)) / len(records)
|
|
|
|
|
| def _candidate_detail_signal(records: list[dict[str, Any]]) -> bool:
|
| for record in records:
|
| if not any(key in record for key in CANDIDATE_KEYS):
|
| continue
|
| has_experience = "experience_id" in record
|
| has_rep = "representation_type" in record or "representation" in record
|
| has_text = "text" in record or "serialized" in record
|
| has_cost = "cost" in record or "cost_tokens" in record
|
| if has_experience and has_rep and has_text and has_cost:
|
| return True
|
| return False
|
|
|
|
|
| def _coverage_matrix_signal(records: list[dict[str, Any]]) -> bool:
|
| for record in records:
|
| if "coverage" in record and (
|
| "candidate_id" in record
|
| or "experience_id" in record
|
| or "unit_id" in record
|
| or "evidence_unit_id" in record
|
| ):
|
| return True
|
| if "candidate_id" in record and ("unit_id" in record or "evidence_unit_id" in record):
|
| if any(key in record for key in COVERAGE_KEYS):
|
| return True
|
| return False
|
|
|
|
|
| def _invalid_coverage_rows(records: list[dict[str, Any]]) -> int:
|
| invalid = 0
|
| for record in records:
|
| if "coverage" not in record:
|
| continue
|
| coverage = record["coverage"]
|
| values: list[Any] = []
|
| if isinstance(coverage, dict):
|
| values.extend(coverage.values())
|
| elif isinstance(coverage, list):
|
| for item in coverage:
|
| if isinstance(item, dict):
|
| values.append(item.get("coverage", item.get("fidelity")))
|
| else:
|
| values.append(item)
|
| else:
|
| values.append(coverage)
|
| for value in values:
|
| try:
|
| numeric = float(value)
|
| except (TypeError, ValueError):
|
| invalid += 1
|
| continue
|
| if numeric < 0.0 or numeric > 1.0:
|
| invalid += 1
|
| return invalid
|
|
|
|
|
| def _status_and_gaps(signals: dict[str, bool], invalid_coverage_rows: int) -> tuple[dict[str, str], list[str]]:
|
| statuses: dict[str, str] = {}
|
| gaps: list[str] = []
|
|
|
| if signals["unit_level_evidence"]:
|
| statuses["evidence_units"] = "unit-level present"
|
| elif signals["session_level_evidence"]:
|
| statuses["evidence_units"] = "session-level only"
|
| gaps.append("No explicit evidence_units/unit_id records; evidence is coarse session id support.")
|
| else:
|
| statuses["evidence_units"] = "missing"
|
| gaps.append("No evidence-unit or session-level gold evidence ids detected.")
|
|
|
| if signals["unit_query_requirements"]:
|
| statuses["query_requirements"] = "unit requirements present"
|
| elif signals["session_query_requirements"]:
|
| statuses["query_requirements"] = "session ids only"
|
| gaps.append("No required_unit_ids detected for query-level semantic coverage.")
|
| else:
|
| statuses["query_requirements"] = "missing"
|
| gaps.append("No query requirement fields detected.")
|
|
|
| if signals["candidate_details"]:
|
| statuses["candidate_memories"] = "candidate records present"
|
| elif signals["selected_candidate_ids"]:
|
| statuses["candidate_memories"] = "selected ids only"
|
| gaps.append("Selected candidate ids are present, but candidate texts/costs/coverage are not serialized here.")
|
| elif signals["retrieved_context"]:
|
| statuses["candidate_memories"] = "retrieved context only"
|
| gaps.append("Retrieved/context memories are present, but not finite write-choice candidates.")
|
| else:
|
| statuses["candidate_memories"] = "missing"
|
| gaps.append("No candidate-memory records detected.")
|
|
|
| if signals["coverage_matrix"]:
|
| statuses["coverage_matrix"] = "candidate-unit coverage present"
|
| elif signals["coverage_summaries"]:
|
| statuses["coverage_matrix"] = "summary metrics only"
|
| gaps.append("Coverage/evidence appears only as aggregate or reader/retrieval metrics.")
|
| else:
|
| statuses["coverage_matrix"] = "missing"
|
| gaps.append("No candidate-by-evidence coverage matrix detected.")
|
|
|
| if invalid_coverage_rows:
|
| gaps.append(f"Sample contains {invalid_coverage_rows} coverage values outside [0, 1] or nonnumeric.")
|
|
|
| full_ready = (
|
| signals["unit_level_evidence"]
|
| and signals["unit_query_requirements"]
|
| and signals["candidate_details"]
|
| and signals["coverage_matrix"]
|
| and invalid_coverage_rows == 0
|
| )
|
| synthetic_result_only = signals["exact_ratio"] and signals["selected_candidate_ids"] and not signals["coverage_matrix"]
|
| session_diagnostic = signals["session_level_evidence"] and not signals["unit_query_requirements"]
|
|
|
| if full_ready:
|
| statuses["oracle_denominator"] = "machine-checkable coverage package"
|
| elif synthetic_result_only:
|
| statuses["oracle_denominator"] = "result rows only; regenerate/serialize hidden synthetic instance for matrix audit"
|
| elif session_diagnostic:
|
| statuses["oracle_denominator"] = "not exact OracleMem; session-evidence diagnostic"
|
| else:
|
| statuses["oracle_denominator"] = "not coverage-ready"
|
|
|
| return statuses, gaps
|
|
|
|
|
| def audit_artifact(name: str, path: Path, role: str, sample_rows: int) -> ArtifactAudit:
|
| audit = ArtifactAudit(name=name, path=str(path), role=role, exists=path.exists())
|
| if not path.exists():
|
| audit.errors.append("missing path")
|
| audit.gaps.append("Artifact path does not exist.")
|
| return audit
|
|
|
| audit.package_files = _package_file_presence(path)
|
| try:
|
| fmt, row_count, records = _load_records(path, sample_rows)
|
| except Exception as exc:
|
| audit.errors.append(str(exc))
|
| audit.gaps.append("Could not parse artifact.")
|
| return audit
|
|
|
| key_counts = _all_keys(records)
|
| invalid_coverage_rows = _invalid_coverage_rows(records)
|
| signals = {
|
| "unit_level_evidence": _has_any_key(records, UNIT_KEYS)
|
| or _has_nested_container(records, UNIT_CONTAINER_KEYS),
|
| "session_level_evidence": _has_any_key(records, SESSION_REQUIREMENT_KEYS),
|
| "unit_query_requirements": _has_any_key(records, UNIT_REQUIREMENT_KEYS),
|
| "session_query_requirements": _has_any_key(records, SESSION_REQUIREMENT_KEYS),
|
| "candidate_details": _candidate_detail_signal(records),
|
| "selected_candidate_ids": _has_any_key(records, SELECTED_CANDIDATE_KEYS),
|
| "coverage_matrix": _coverage_matrix_signal(records),
|
| "coverage_summaries": _has_any_key(records, COVERAGE_SUMMARY_KEYS),
|
| "retrieved_context": _has_any_key(records, CONTEXT_KEYS),
|
| "exact_ratio": _has_any_key(records, {"ratio_to_opt", "denominator_label", "optimum_value"}),
|
| }
|
| statuses, gaps = _status_and_gaps(signals, invalid_coverage_rows)
|
| if audit.package_files:
|
| missing_package_files = [
|
| label for label, present in audit.package_files.items() if not present
|
| ]
|
| if missing_package_files:
|
| statuses["oracle_denominator"] = "not coverage-ready"
|
| gaps.append(
|
| "Coverage package directory is missing required files: "
|
| + ", ".join(missing_package_files)
|
| + "."
|
| )
|
|
|
| audit.format = fmt
|
| audit.row_count = row_count
|
| audit.sampled_rows = len(records)
|
| audit.key_counts = dict(sorted(key_counts.items()))
|
| audit.signals = signals
|
| audit.completeness = {
|
| "sample_with_unit_ids": _fraction_with(records, UNIT_KEYS),
|
| "sample_with_required_unit_ids": _fraction_with(records, UNIT_REQUIREMENT_KEYS),
|
| "sample_with_gold_or_answer_session_ids": _fraction_with(records, SESSION_REQUIREMENT_KEYS),
|
| "sample_with_candidate_ids": _fraction_with(records, CANDIDATE_KEYS),
|
| "sample_with_selected_candidate_ids": _fraction_with(records, SELECTED_CANDIDATE_KEYS),
|
| "sample_with_coverage": _fraction_with(records, {"coverage"}),
|
| "sample_with_context_or_used_ids": _fraction_with(records, CONTEXT_KEYS),
|
| }
|
| audit.statuses = statuses
|
| audit.gaps = gaps
|
| return audit
|
|
|
|
|
| def _parse_artifact_arg(value: str) -> tuple[str, str, str]:
|
| if "=" in value:
|
| name, raw_path = value.split("=", 1)
|
| return name.strip(), raw_path.strip(), "User-specified artifact."
|
| path = Path(value)
|
| return path.stem, value, "User-specified artifact."
|
|
|
|
|
| def _markdown_table_row(audit: ArtifactAudit) -> str:
|
| gap = audit.gaps[0] if audit.gaps else "No structural gap detected."
|
| return (
|
| f"| `{audit.name}` | {audit.row_count} | "
|
| f"{audit.statuses.get('evidence_units', 'missing')} | "
|
| f"{audit.statuses.get('query_requirements', 'missing')} | "
|
| f"{audit.statuses.get('candidate_memories', 'missing')} | "
|
| f"{audit.statuses.get('coverage_matrix', 'missing')} | "
|
| f"{audit.statuses.get('oracle_denominator', 'not coverage-ready')} | "
|
| f"{gap} |"
|
| )
|
|
|
|
|
| def render_report(audits: list[ArtifactAudit]) -> str:
|
| ready = [
|
| audit
|
| for audit in audits
|
| if audit.statuses.get("oracle_denominator") == "machine-checkable coverage package"
|
| ]
|
| lines = [
|
| "# Coverage Artifact Audit",
|
| "",
|
| "This report checks whether existing artifacts expose the machine-readable fields needed for non-synthetic OracleMem coverage annotation. It is a structural audit only; it does not certify semantic label quality.",
|
| "",
|
| "## Verdict",
|
| "",
|
| ]
|
| if ready:
|
| names = ", ".join(f"`{audit.name}`" for audit in ready)
|
| lines.append(f"Coverage-ready package candidates detected: {names}.")
|
| else:
|
| lines.append(
|
| "No audited current artifact is a complete non-synthetic coverage package. Existing LongMemEval artifacts remain session-level retrieval/reader/scoring diagnostics; synthetic result rows rely on generator code for hidden coverage and do not serialize a full matrix in the result files."
|
| )
|
|
|
| lines.extend(
|
| [
|
| "",
|
| "## Artifact Matrix",
|
| "",
|
| "| Artifact | Rows | Evidence | Query Requirements | Candidates | Coverage | Denominator Status | First Gap |",
|
| "| --- | ---: | --- | --- | --- | --- | --- | --- |",
|
| ]
|
| )
|
| for audit in audits:
|
| lines.append(_markdown_table_row(audit))
|
|
|
| lines.extend(
|
| [
|
| "",
|
| "## Completeness Signals",
|
| "",
|
| "| Artifact | Sampled | Unit IDs | Required Units | Gold Sessions | Candidate IDs | Selected IDs | Coverage | Context/Used IDs |",
|
| "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
|
| ]
|
| )
|
| for audit in audits:
|
| c = audit.completeness
|
| lines.append(
|
| f"| `{audit.name}` | {audit.sampled_rows} | "
|
| f"{c.get('sample_with_unit_ids', 0.0):.3f} | "
|
| f"{c.get('sample_with_required_unit_ids', 0.0):.3f} | "
|
| f"{c.get('sample_with_gold_or_answer_session_ids', 0.0):.3f} | "
|
| f"{c.get('sample_with_candidate_ids', 0.0):.3f} | "
|
| f"{c.get('sample_with_selected_candidate_ids', 0.0):.3f} | "
|
| f"{c.get('sample_with_coverage', 0.0):.3f} | "
|
| f"{c.get('sample_with_context_or_used_ids', 0.0):.3f} |"
|
| )
|
|
|
| lines.extend(
|
| [
|
| "",
|
| "## Acceptance Gate",
|
| "",
|
| "Synthetic exact-small OracleMem instances can be exported for structural inspection with `python run_oraclemem_mvp.py --export-coverage-matrices`; pass an exported package directory to this script with `--artifact name=path/to/coverage_instances/base/seed_0`.",
|
| "",
|
| "To upgrade a non-synthetic LongMemEval/LoCoMo-style artifact from diagnostic to exact OracleMem coverage, add the package described in `COVERAGE_VALIDATION_PROTOCOL.md`: `evidence_units.jsonl`, `queries.jsonl` with `required_unit_ids`, `candidate_memories.jsonl`, `coverage_matrix.jsonl`, annotation decisions, and a candidate-generation manifest.",
|
| "",
|
| "Hard blockers for non-synthetic coverage are 100% schema completeness for eval queries, evidence units, positive coverage rows, candidate groups/costs, no future-source coverage, no generator leakage, and solver inputs derivable from the artifacts without hidden code defaults.",
|
| "",
|
| "| Acceptance item | Required threshold |",
|
| "| --- | ---: |",
|
| "| Eval queries with answer/category/session ids/adjudicated required units | 100% |",
|
| "| Required unit ids resolvable in `evidence_units.jsonl` | 100% |",
|
| "| Evidence units source-backed and adjudication resolved | 100% |",
|
| "| Positive coverage rows valid, sourced, rationalized, resolved | 100% |",
|
| "| Candidate groups, representation types, text, and costs valid | 100% |",
|
| "| Future-source coverage leakage | 0 rows |",
|
| "| Forbidden generator inputs leaked | 0 records |",
|
| "| Binary coverage agreement before adjudication | kappa >= 0.70 |",
|
| "| None/partial/full coverage agreement before adjudication | weighted kappa >= 0.60 |",
|
| "| Unit candidate availability at coverage >= 0.75 | >= 0.95 |",
|
| "| Query feasible support before budget | >= 0.90 |",
|
| "| Update/current-truth support for validity claims | >= 0.90 |",
|
| "| Hallucinated coverage after adjudication | 0 rows |",
|
| ]
|
| )
|
| return "\n".join(lines) + "\n"
|
|
|
|
|
| def main() -> None:
|
| parser = argparse.ArgumentParser(description=__doc__)
|
| parser.add_argument(
|
| "--output-dir",
|
| type=Path,
|
| default=Path("llm_memory_validation/coverage_artifact_audit"),
|
| )
|
| parser.add_argument(
|
| "--artifact",
|
| action="append",
|
| default=[],
|
| help="Additional artifact as name=path or path. Can be repeated.",
|
| )
|
| parser.add_argument("--no-defaults", action="store_true")
|
| parser.add_argument("--sample-rows", type=int, default=5000)
|
| args = parser.parse_args()
|
|
|
| specs: list[tuple[str, str, str]] = []
|
| if not args.no_defaults:
|
| specs.extend(DEFAULT_ARTIFACTS)
|
| specs.extend(_parse_artifact_arg(value) for value in args.artifact)
|
| if not specs:
|
| raise SystemExit("No artifacts to audit.")
|
|
|
| audits = [
|
| audit_artifact(name, Path(path), role, sample_rows=args.sample_rows)
|
| for name, path, role in specs
|
| ]
|
| payload = {
|
| "schema_version": 1,
|
| "sample_rows": args.sample_rows,
|
| "coverage_ready_artifacts": [
|
| audit.name
|
| for audit in audits
|
| if audit.statuses.get("oracle_denominator") == "machine-checkable coverage package"
|
| ],
|
| "artifacts": [asdict(audit) for audit in audits],
|
| }
|
|
|
| args.output_dir.mkdir(parents=True, exist_ok=True)
|
| (args.output_dir / "summary.json").write_text(
|
| json.dumps(payload, indent=2, sort_keys=True) + "\n",
|
| encoding="utf-8",
|
| )
|
| (args.output_dir / "REPORT.md").write_text(render_report(audits), encoding="utf-8")
|
| print(json.dumps(payload, indent=2, sort_keys=True))
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
