File size: 6,420 Bytes
3af6d41 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 | """Structure-consistency report: source frontend-spec vs clone frontend-spec.
Compares each captured page pair under materials/33/scope/frontend-specs/ and
emits a scored structure-similarity report: heading text/level overlap, control
kind+label overlap, and data-point coverage. This is the primary machine metric
for the structure+content+function acceptance direction; pixel alignment stays
a separate diagnostic (visual-diff / SSIM).
Diagnostic-only authority. Usage:
.venv/bin/python materials/33/clone/measure_structure_consistency.py
"""
from __future__ import annotations
import json
import re
from pathlib import Path
SITE_ROOT = Path(__file__).resolve().parents[1]
SPEC_ROOT = SITE_ROOT / "scope" / "frontend-specs"
PAGES = ("home", "browse", "search", "course", "specialization", "login")
def _norm(text: str) -> str:
return re.sub(r"\s+", " ", str(text)).strip().lower().rstrip("›").strip()
def _heading_key(heading: dict) -> tuple[int, str]:
return (int(heading.get("level", 0)), _norm(heading.get("text", "")))
def _control_key(control: dict) -> tuple[str, str]:
kind = str(control.get("kind") or control.get("type") or "unknown")
label = _norm(control.get("label") or control.get("text") or control.get("name") or "")
return (kind, label)
def _datapoint_key(point: dict) -> str:
return _norm(point.get("label") or point.get("name") or point.get("key") or "")
def _controls_summary(spec: dict) -> list[tuple[str, str]]:
controls = spec.get("controls", [])
if isinstance(controls, dict):
out = []
for kind, items in controls.items():
for item in items if isinstance(items, list) else [items]:
out.append(_control_key({"kind": kind, **item}))
return out
return [_control_key(c) for c in controls]
def _datapoints(spec: dict) -> list[str]:
points = spec.get("data_points", [])
if isinstance(points, dict):
return [_datapoint_key({"label": k}) for k in points]
return [_datapoint_key(p) for p in points]
def _jaccard(a: set, b: set) -> float:
if not a and not b:
return 1.0
if not a or not b:
return 0.0
return len(a & b) / len(a | b)
def _coverage(a: set, b: set) -> float:
"""Fraction of source keys present in the clone."""
if not a:
return 1.0
return len(a & b) / len(a)
def _heading_scores(
src_headings: list[dict], clone_headings: list[dict]
) -> dict:
"""Compare headings by text presence, with exact level as a bonus.
The raw (level, text) key treats h1 "Log in or create account" as a
different heading from h2, which over-penalizes pages whose markup uses a
different (but still hierarchical) heading level for the same content.
"""
src_texts = {_norm(h.get("text", "")) for h in src_headings if _norm(h.get("text", ""))}
clone_texts = {_norm(h.get("text", "")) for h in clone_headings if _norm(h.get("text", ""))}
text_jaccard = _jaccard(src_texts, clone_texts)
text_coverage = _coverage(src_texts, clone_texts)
src_levels = {_norm(h.get("text", "")): int(h.get("level", 0)) for h in src_headings}
clone_levels = {_norm(h.get("text", "")): int(h.get("level", 0)) for h in clone_headings}
shared = src_texts & clone_texts
level_match = 0.0
if shared:
level_match = sum(
1 for text in shared if src_levels.get(text) == clone_levels.get(text)
) / len(shared)
return {
"source": len(src_texts),
"clone": len(clone_texts),
"jaccard": round(text_jaccard, 4),
"coverage": round(text_coverage, 4),
"level_match": round(level_match, 4),
}
def score_page(page: str) -> dict:
src = json.loads((SPEC_ROOT / f"{page}.source.json").read_text(encoding="utf-8"))
clone = json.loads((SPEC_ROOT / f"{page}.clone.json").read_text(encoding="utf-8"))
src_headings = src.get("document", {}).get("headings", [])
clone_headings = clone.get("document", {}).get("headings", [])
src_ctrl = set(_controls_summary(src))
clone_ctrl = set(_controls_summary(clone))
src_dp = set(_datapoints(src))
clone_dp = set(_datapoints(clone))
heading_scores = _heading_scores(src_headings, clone_headings)
heading_jaccard = heading_scores["jaccard"]
control_jaccard = _jaccard(src_ctrl, clone_ctrl)
datapoint_coverage = _coverage(src_dp, clone_dp)
# structure score: headings dominate (page skeleton), then controls, then data
structure = round(0.5 * heading_jaccard + 0.3 * control_jaccard + 0.2 * datapoint_coverage, 4)
return {
"page": page,
"structure_score": structure,
"headings": {
"source": heading_scores["source"],
"clone": heading_scores["clone"],
"jaccard": heading_scores["jaccard"],
"coverage": heading_scores["coverage"],
"level_match": heading_scores["level_match"],
},
"controls": {
"source": len(src_ctrl),
"clone": len(clone_ctrl),
"jaccard": round(control_jaccard, 4),
"coverage": round(_coverage(src_ctrl, clone_ctrl), 4),
},
"data_points": {
"source": len(src_dp),
"clone": len(clone_dp),
"coverage": round(datapoint_coverage, 4),
},
}
def main() -> int:
rows = [score_page(page) for page in PAGES]
overall = round(sum(r["structure_score"] for r in rows) / len(rows), 4)
for row in rows:
h, c, d = row["headings"], row["controls"], row["data_points"]
print(
f"{row['page']:<14} structure={row['structure_score']:.3f} "
f"headings {h['coverage']:.2f}/{h['level_match']:.2f} ({h['source']}->{h['clone']}) "
f"controls {c['coverage']:.2f} ({c['source']}->{c['clone']}) "
f"data {d['coverage']:.2f} ({d['source']}->{d['clone']})"
)
print(f"overall structure consistency: {overall}")
report = {
"schema_version": "websitebench.offline-clone.structure-consistency.v1",
"authority": "diagnostic-only",
"pages": rows,
"overall_structure_consistency": overall,
}
out = SPEC_ROOT / "structure-consistency-report.json"
out.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
print(f"wrote {out}")
return 0
if __name__ == "__main__":
raise SystemExit(main())
|