| """Spec checker: verify a plan's box table against a structured request spec, without eyes. |
| |
| Spec schema (stored with ~40% of generated requests): |
| { |
| "entities": [{"class": "person", "count": 3}, {"class": "bench", "count": 1}], |
| "relations": [{"a": "person", "b": "bench", "rel": "left_of"}, ...], # rel in left_of/right_of/above/below |
| "text": ["OPEN 24/7", ...] # strings that must appear verbatim |
| } |
| Relations compare box centres (ids are numbered left-to-right, top-to-bottom, so the first instance of a |
| class is its leftmost/topmost one); counts accept separate rows per instance OR one collection row whose |
| desc states the count as digits or a number word. |
| """ |
| import json |
| import re |
|
|
| from bbox import split, valid_box |
|
|
| NUM_WORDS = {1: "one", 2: "two", 3: "three", 4: "four", 5: "five", 6: "six", 7: "seven", 8: "eight", |
| 9: "nine", 10: "ten", 11: "eleven", 12: "twelve", 15: "fifteen", 20: "twenty"} |
| RELS = {"left_of": lambda a, b: a[1] < b[1], "right_of": lambda a, b: a[1] > b[1], |
| "above": lambda a, b: a[0] < b[0], "below": lambda a, b: a[0] > b[0]} |
|
|
|
|
| def class_of(row_id: str) -> str: |
| m = re.match(r"(.+?)_(\d+)$", row_id) |
| return m.group(1) if m else row_id |
|
|
|
|
| def instance_index(row_id: str) -> int: |
| m = re.match(r"(.+?)_(\d+)$", row_id) |
| return int(m.group(2)) if m else 0 |
|
|
|
|
| def centre(box: list) -> tuple: |
| return (box[0] + box[2]) / 2.0, (box[1] + box[3]) / 2.0 |
|
|
|
|
| def parse_plan(output: str): |
| """(rows, reasons) for a single-line plan output; rows is None when it does not parse cleanly.""" |
| reasons = [] |
| caption, rows = split(output) |
| if rows is None: |
| return None, ["no JSON table found"] |
| for r in rows: |
| if not isinstance(r, dict) or valid_box(r.get("bbox")) is None: |
| reasons.append(f"invalid row {r!r}") |
| if reasons: |
| return None, reasons |
| if not is_plan_finished(caption, rows): |
| reasons.append("not every row id is cited as <id> in the caption") |
| return rows, reasons |
|
|
|
|
| def is_plan_finished(caption: str, rows: list) -> bool: |
| from bbox import ID |
| return all(isinstance(r.get("id"), str) and ID.fullmatch(r["id"]) and f"<{r['id']}>" in caption for r in rows) |
|
|
|
|
| def normalize_class(name: str) -> str: |
| """lowercase + simple singularization, so spec vocabulary can meet plan id nouns.""" |
| n = name.strip().lower() |
| if len(n) > 3 and n.endswith("s") and not n.endswith("ss"): |
| n = n[:-1] |
| return re.sub(r"\s+", " ", n) |
|
|
|
|
| def check_count(rows: list, cls: str, count: int, known_classes=None) -> str | None: |
| """None when satisfied, else a reason string. With known_classes (the plan's id-noun |
| vocabulary), a class that matches nothing in the plan returns UNVERIFIABLE instead of a |
| failure — the checker cannot judge counts for entities the plan named differently.""" |
| c = normalize_class(cls) |
| cls_rows = sorted((r for r in rows if normalize_class(class_of(r["id"])) == c), |
| key=lambda r: instance_index(r["id"])) |
| if len(cls_rows) == count: |
| return None |
| |
| for r in cls_rows: |
| d = r["desc"].lower() |
| if re.search(rf"\b{count}\b", d) or (count in NUM_WORDS and re.search(rf"\b{NUM_WORDS[count]}\b", d)): |
| return None |
| if known_classes is not None and c not in {normalize_class(k) for k in known_classes}: |
| return f"UNVERIFIABLE count: {cls!r} not in plan vocabulary" |
| return f"{cls}: {len(cls_rows)} row(s) vs stated count {count}, no collection row stating it" |
|
|
|
|
| def check_relation(rows: list, a: str, rel: str, b: str, known_classes=None) -> str | None: |
| unres = known_classes is not None |
| if rel not in RELS: |
| return (f"UNVERIFIABLE relation: unsupported {rel!r}" if unres else f"unknown relation {rel!r}") |
| cmp = RELS[rel] |
| |
| def pick(name): |
| if re.match(r"(.+?)_(\d+)$", name): |
| hits = [r for r in rows if r["id"] == name] |
| else: |
| hits = sorted((r for r in rows if class_of(r["id"]) == name), |
| key=lambda r: instance_index(r["id"])) |
| if not hits: |
| return None |
| (cy, cx) = centre(hits[0]["bbox"]) |
| return (cx, cy) |
|
|
| pa, pb = pick(a), pick(b) |
| if pa is None: |
| return (f"UNVERIFIABLE relation: {a!r} not in plan vocabulary" if unres |
| else f"relation {a!r} {rel} {b!r}: no row for {a!r}") |
| if pb is None: |
| return (f"UNVERIFIABLE relation: {b!r} not in plan vocabulary" if unres |
| else f"relation {a!r} {rel} {b!r}: no row for {b!r}") |
| |
| ax, ay = pa |
| bx, by = pb |
| ok = {"left_of": ax < bx, "right_of": ax > bx, "above": ay < by, "below": ay > by}[rel] |
| return None if ok else f"relation violated: {a!r} ({ax:.0f},{ay:.0f}) {rel} {b!r} ({bx:.0f},{by:.0f})" |
|
|
|
|
| def check_text(rows: list, strings: list) -> list: |
| out = [] |
| for s in strings: |
| if not any(s in r["desc"] for r in rows): |
| out.append(f"quoted string {s!r} not verbatim in any desc") |
| return out |
|
|
|
|
| def check_plan(output: str, spec: dict, known_classes=None) -> tuple[bool, list]: |
| """(ok, reasons) for one teacher/student output against its spec. |
| Reasons beginning with 'UNVERIFIABLE' are checker limitations, not plan errors.""" |
| rows, reasons = parse_plan(output) |
| if rows is None: |
| return False, reasons |
| for e in spec.get("entities", []): |
| r = check_count(rows, e["class"], e["count"], known_classes) |
| if r: |
| reasons.append(r) |
| for rel in spec.get("relations", []): |
| r = check_relation(rows, rel["a"], rel["rel"], rel["b"], known_classes) |
| if r: |
| reasons.append(r) |
| reasons.extend(check_text(rows, spec.get("text", []))) |
| return not reasons, reasons |
|
|
