clairic / clairic_runtime /row_omission.py
areneau's picture
Update Clairic Transformers runtime
524fd9d verified
Raw History Blame Contribute Delete
7.5 kB
"""Recover unresolved image rows backed by a completed row inventory."""
from copy import deepcopy
import json
from typing import Any
from . import ar, image_rows
from .schema import MAX_LIST_ITEMS
def prepare(
record: dict[str, Any], predictions: dict[str, dict[str, Any]]
) -> tuple[dict[str, Any], list[dict[str, Any]]] | None:
if record.get("_null_recovery") or record.get("_row_omission_recovery"):
return None
annotations = (
record.get("_meta", {}).get("extraction_contract", {}).get("fields", {})
)
tasks = {name: (name, ids, media) for name, ids, media in record["_ar_tasks"]}
if len(tasks) != len(record["_ar_tasks"]):
return None
contexts, retry_tasks = [], []
constraints = dict(record.get("_ar_constraints", {}))
for parent, annotation in annotations.items():
queries = annotation.get("image_row_fields")
spec, inventory = record["fields"].get(parent, {}), predictions.get(parent, {})
value = inventory.get("value")
if (
set(annotation) != {"image_row_fields"}
or not isinstance(queries, list)
or len(queries) != len(set(queries))
or not queries
or not image_rows.is_inventory(spec)
or spec.get("knowledge")
or not inventory.get("valid")
or not inventory.get("complete")
or not isinstance(value, list)
or not value
or len(value) > min(spec.get("max_items", MAX_LIST_ITEMS), len(queries))
or any(
not isinstance(row, dict)
or set(row) != {"label"}
or not isinstance(row["label"], str)
or not row["label"].strip()
for row in value
)
or any(child not in predictions for child in queries)
):
continue
properties = spec.get("items", {}).get("properties", {})
text_keys = [
key
for key, child in properties.items()
if child.get("type") == "text" and not child.get("knowledge")
]
if not text_keys:
continue
labels = [row["label"] for row in value]
proposals = [predictions[child] for child in queries]
selected, conflicts = image_rows._select(labels, proposals, text_keys)
if not conflicts or any(
row is not None and (not row.get("valid") or not row.get("complete"))
for row in selected
):
continue
children, local_constraints = [], {}
for index in conflicts:
child = queries[index]
row, child_spec = predictions[child], record["fields"].get(child, {})
row_value = row.get("value")
task = tasks.get(child)
native = constraints.get(child, {})
if (
annotations.get(child) != {"parent": parent, "index": index + 1}
or child_spec.get("type") != "object"
or not child_spec.get("_image_row_proposal")
or child_spec.get("knowledge")
or not row.get("valid")
or not row.get("complete")
or not isinstance(row_value, dict)
or not row_value
or any(cell is not None for cell in row_value.values())
or any(row is previous for previous in selected if previous is not None)
or task is None
or task[2] is None
or set(native) != {"json_schema"}
):
break
schema = json.loads(native["json_schema"])
if schema != ar.schema(child_spec) or not set(text_keys) <= set(
schema.get("properties", {})
):
break
# A completed inventory requires a matching textual cell; the
# original selector remains the acceptance test for that label.
# Full branches retain required fields with the native grammar compiler.
branches = []
for key in text_keys:
branch = deepcopy(schema)
branch["properties"][key]["type"] = "string"
branches.append(branch)
local_constraints[child] = {"json_schema": json.dumps({"anyOf": branches})}
children.append(child)
else:
constraints.update(local_constraints)
retry_tasks.extend(tasks[child] for child in children)
contexts.append(
{
"parent": parent,
"queries": queries,
"labels": labels,
"text_keys": text_keys,
"selected": selected,
"conflicts": conflicts,
"children": children,
}
)
if not retry_tasks:
return None
repair = {
**record,
"_ar_tasks": retry_tasks,
"_ar_constraints": constraints,
"_ar_prefix": None,
"_ar_group_prefixes": [],
"_ar_media_groups": [],
"_null_recovery": True,
"_row_omission_recovery": True,
}
return repair, contexts
def merge(
record: dict[str, Any],
predictions: dict[str, dict[str, Any]],
alternatives: dict[str, dict[str, Any]],
plan: tuple[dict[str, Any], list[dict[str, Any]]],
) -> tuple[dict[str, dict[str, Any]], list[dict[str, Any]]]:
repair, contexts = plan
lengths = {name: len(ids) for name, ids, _ in repair["_ar_tasks"]}
result = dict(predictions)
evidence = []
for context in contexts:
candidates = {}
for child in context["children"]:
original, alternative = predictions[child], alternatives.get(child, {})
account = {
"tokens": original["tokens"] + alternative.get("tokens", 0),
"retry_input_tokens": original.get("retry_input_tokens", 0)
+ lengths[child],
}
result[child] = {**original, **account}
value = alternative.get("value")
if (
alternative.get("valid")
and alternative.get("complete")
and isinstance(value, dict)
and any(cell is not None for cell in value.values())
):
candidates[child] = {
**alternative,
**account,
"image_row_omission_recovered": True,
}
trial = {**result, **candidates}
selected, conflicts = image_rows._select(
context["labels"],
[trial[name] for name in context["queries"]],
context["text_keys"],
)
unchanged = all(
previous is None or selected[index] is previous
for index, previous in enumerate(context["selected"])
)
accepted = (
not conflicts and unchanged and len(candidates) == len(context["children"])
)
if accepted:
result.update(candidates)
evidence.append(
{
"parent": context["parent"],
"original_conflicts": context["conflicts"],
"retry_children": context["children"],
"conflicts_after_retry": conflicts,
"previously_matched_proposals_preserved_exactly": unchanged,
"accepted": accepted,
}
)
return result, evidence