Files

69 lines
3.4 KiB
Python
Raw Permalink Normal View History

"""Verify that captured real comparison evidence remains diagnostic by default."""
from __future__ import annotations
import hashlib
import json
from pathlib import Path
from openultrasast.model.contracts import ChangeContext, QuestionOutcome, ScopeDecision
from openultrasast.model.ladder import Rung
from openultrasast.model.pipeline import ModelFinding
from openultrasast.model.scan import ModelScanResult
from openultrasast.push.contracts import ComparisonAnalysis, PushComparison
from openultrasast.push.policy import AdmissionCandidate, CapabilityKey, admission_push_result, admit_candidates, compare_evidence
def restore_scan(data: dict) -> ModelScanResult:
"""Restore only the recorded evidence consumed by the comparison policy."""
return ModelScanResult(
findings=tuple(ModelFinding(**{**finding, "rung": Rung(finding["rung"])}) for finding in data["findings"]),
scope=ScopeDecision.from_payload(data["scope"]),
question_outcomes=tuple(QuestionOutcome.from_payload(outcome) for outcome in data["question_outcomes"]),
degradations=tuple(data["degradations"]),
)
def main() -> None:
artifact = Path("benchmarks/measurements/2026-09-13-delta-comparison-smoke.json")
raw = artifact.read_bytes()
assert raw, "comparison artifact is unreadable or empty"
recorded = json.loads(raw)
report = {
"purpose": "Current policy applied to captured actual engine evidence; no new engine execution or evaluated capability",
"input_bytes": len(raw),
"input_sha256": hashlib.sha256(raw).hexdigest(),
"cases": {},
}
for case, record in recorded["cases"].items():
evidence = record["evidence"]
head = restore_scan(evidence["head"])
base = restore_scan(evidence["delta"]["base_scan"])
context = ChangeContext.from_payload(evidence["context"])
comparison = PushComparison.from_payload(evidence["comparison"])
semantics = evidence["delta"]["semantics"]
deltas = compare_evidence(head, base, context=context, head_semantics=semantics, base_semantics=semantics)
assert deltas and all(delta.novelty == evidence["expected_novelty"] for delta in deltas)
candidates = []
for delta in deltas:
operation = delta.head_operation
assert operation is not None
key = CapabilityKey(
operation.question.language, "unspecified", "unspecified", delta.family, operation.mechanism, "unreviewed", semantics
)
candidates.append(AdmissionCandidate(delta, key, comparison))
admission = admit_candidates(candidates)
assert not admission.defects and len(admission.dispositions) == len(candidates)
assert all(not disposition.admitted for disposition in admission.dispositions)
assert "capability_unavailable" in admission.coverage_reasons
assert head.scope is not None
analysis = ComparisonAnalysis(comparison, (head.scope,), tuple(q.identity for q in head.question_outcomes), "complete_within_scope")
result = admission_push_result(admission, (analysis,))
assert result.finding_status == "none" and result.coverage_status == "incomplete" and result.push_disposition == "allow"
report["cases"][case] = {"admission": admission.to_payload(), "result": result.to_payload()}
print(json.dumps(report, indent=2))
if __name__ == "__main__":
main()