clairic-flash / clairic_runtime /identifier_spelling.py
areneau's picture
Add complete Clairic Transformers package
dc7d8aa verified
Raw History Blame Contribute Delete
10.5 kB
from __future__ import annotations
from collections.abc import Callable
from typing import TYPE_CHECKING, Any
if TYPE_CHECKING:
from .api import PredictRequest
from .backend import EncodedRequest
from copy import deepcopy
from jsonschema import Draft202012Validator, ValidationError
from . import ar, identifier_scope
VERSION = "identifier-codepoint-spelling-v1"
PDF_VIEW_ID = "pdf-po-codepoint-spelling-focus-v1"
MANY_IMAGE_VIEW_ID = "po-three-four-images-detail3-800000px-v2"
MANY_IMAGE_MAX_PIXELS = 800000
INSTRUCTION = "Spell the printed purchase order reference with one space between each individual character. Preserve the actual characters; do not normalize letters and digits."
def decode_wire(value: object) -> str:
if not isinstance(value, str):
raise ValueError("Identifier spelling wire must be a string")
if any((55296 <= ord(character) <= 57343 for character in value)):
raise ValueError("Identifier spelling wire contains an unpaired surrogate")
if value and (
len(value) % 2 == 0 or any((character != " " for character in value[1::2]))
):
raise ValueError("Invalid identifier spelling separators")
return value[::2]
def prepare(
record: dict[str, Any],
public_fields: dict[str, dict[str, Any]],
query_labels: dict[str, str],
*,
has_media: bool,
) -> dict[str, Any]:
if not has_media or not query_labels:
return record
(_, eligible) = identifier_scope.prepare_fields(public_fields, has_media=True)
contracts = {}
for name, label in query_labels.items():
if label != "purchase_order_reference" or eligible.get(name) != label:
continue
public = public_fields[name]
spec = record["fields"][name]
wire = {
key: value
for (key, value) in spec.items()
if key not in {"minLength", "maxLength", "pattern"}
}
wire["instructions"] = INSTRUCTION + "\n" + spec.get("instructions", "")
record["fields"][name] = wire
contracts[name] = {
"scalar": deepcopy(public),
"wire": VERSION,
"query_name": name,
}
if contracts:
record["_meta"]["identifier_spelling"] = contracts
return record
def normalize_predictions(
record: dict[str, Any], predictions: dict[str, dict[str, Any]]
) -> dict[str, dict[str, Any]]:
result = dict(predictions)
for name, contract in (
record.get("_meta", {}).get("identifier_spelling", {}).items()
):
original = result.get(name)
if (
original is None
or not original.get("valid")
or (not original.get("complete"))
or (original.get("wire_decoder") == VERSION)
):
continue
answer = dict(original)
wire = original["value"]
answer.update(
wire_value=wire,
wire_decoder=VERSION,
native_decoder=original.get("decoder"),
decoder=ar.VERSION + "+" + VERSION,
score_representation="native_json_codepoint_spelling_wire",
)
if answer.get("span") is not None:
answer["native_wire_span"] = answer["span"]
if "span_method" in answer:
answer["native_wire_span_method"] = answer.pop("span_method")
answer["span"] = None
try:
decoded = None if wire is None else decode_wire(wire)
Draft202012Validator(ar.schema(contract["scalar"])).validate(decoded)
answer["value"] = decoded
except (ValueError, TypeError, ValidationError):
answer.update(
value=None, valid=False, failure_reason="invalid_identifier_spelling"
)
result[name] = answer
return result
def prepare_pdf_tasks(
request: PredictRequest,
encoded: EncodedRequest,
encode: Callable[..., EncodedRequest],
*,
enabled: bool,
) -> EncodedRequest:
if not enabled or not request.documents:
return encoded
(record, forecasts, tasks, typed, eos) = encoded
active = {name for (name, _, _) in tasks}
selected = {
name: request.fields[name]
for (name, contract) in record.get("_meta", {})
.get("identifier_spelling", {})
.items()
if name in active and contract.get("wire") == VERSION
}
originals = record.get("_original_images", ())
pdf_pages = originals[len(request.images) :]
if not selected or not pdf_pages:
return encoded
child_request = request.model_copy(update={"fields": selected})
(child, _, replacements, child_typed, child_eos) = encode(
child_request,
identifier_view=True,
pdf_spelling_view=True,
image_views=lambda: originals,
image_view_key=PDF_VIEW_ID,
)
if child_typed is not None or child_eos != eos:
raise ValueError("A PDF PO spelling view must retain the scalar AR contract")
by_name = {name: (name, ids, media) for (name, ids, media) in replacements}
if set(by_name) != set(selected):
raise ValueError("PDF PO spelling tasks differ from the selected public fields")
updated = [by_name.get(task[0], task) for task in tasks]
salts = dict(record.get("_ar_task_salts", {}))
for name in selected:
record["fields"][name] = child["fields"][name]
record["_ar_constraints"][name] = child["_ar_constraints"][name]
salts[name] = child["_cache_salt"]
record["_meta"]["identifier_spelling_pdf_view"] = {
"version": PDF_VIEW_ID,
"fields": list(selected),
"image_count": len(originals),
"pdf_page_count": len(pdf_pages),
}
record.update(
_ar_tasks=updated, _ar_task_salts=salts, _ar_prefix=[], _ar_group_prefixes=[]
)
return (record, forecasts, updated, typed, eos)
def prepare_fallback(
request: PredictRequest,
encoded: EncodedRequest,
encode: Callable[..., EncodedRequest],
) -> EncodedRequest:
(record, _, tasks, _, eos) = encoded
contracts = record.get("_meta", {}).get("identifier_spelling", {})
active = {name for (name, _, _) in tasks}
selected = {name: request.fields[name] for name in contracts if name in active}
if not selected:
return encoded
child_request = request.model_copy(update={"fields": selected})
(child, _, child_tasks, child_typed, child_eos) = encode(
child_request, identifier_spelling_disabled=True
)
if (
child_typed is not None
or child_eos != eos
or {name for (name, _, _) in child_tasks} != set(selected)
or child.get("_meta", {}).get("identifier_spelling")
):
raise ValueError(
"Identifier spelling fallback must retain the original scalar contract"
)
record["_identifier_spelling_fallback"] = child
return encoded
def prepare_many_image_tasks(
request: PredictRequest,
encoded: EncodedRequest,
encode: Callable[..., EncodedRequest],
) -> EncodedRequest:
if request.documents or len(request.images) not in (3, 4):
return encoded
(record, forecasts, tasks, typed, eos) = encoded
active = {name for (name, _, _) in tasks}
selected = {
name: request.fields[name]
for (name, contract) in record.get("_meta", {})
.get("identifier_spelling", {})
.items()
if name in active and contract.get("wire") == VERSION
}
if not selected:
return encoded
originals = record.get("_original_images", ())
if len(originals) != len(request.images):
raise ValueError("PO detail view must retain every original image in order")
(child, _, replacements, child_typed, child_eos) = encode(
request.model_copy(update={"fields": selected}),
identifier_view=True,
po_detail_view=True,
image_views=lambda: originals,
image_view_key=MANY_IMAGE_VIEW_ID,
)
if child_typed is not None or child_eos != eos:
raise ValueError("A PO image detail view must retain the scalar AR contract")
by_name = {name: (name, ids, media) for (name, ids, media) in replacements}
if set(by_name) != set(selected):
raise ValueError("PO image detail tasks differ from the selected public fields")
updated = [by_name.get(task[0], task) for task in tasks]
salts = dict(record.get("_ar_task_salts", {}))
for name in selected:
record["fields"][name] = child["fields"][name]
record["_ar_constraints"][name] = child["_ar_constraints"][name]
salts[name] = child["_cache_salt"]
record["_meta"]["identifier_spelling_image_view"] = {
"version": MANY_IMAGE_VIEW_ID,
"fields": list(selected),
"image_count": len(originals),
"max_scale": 3.0,
"max_pixels": MANY_IMAGE_MAX_PIXELS,
}
record.update(
_ar_tasks=updated, _ar_task_salts=salts, _ar_prefix=[], _ar_group_prefixes=[]
)
return (record, forecasts, updated, typed, eos)
def fallback_record(
record: dict[str, Any], predictions: dict[str, dict[str, Any]]
) -> dict[str, Any] | None:
selected = {
name
for (name, prediction) in predictions.items()
if prediction.get("failure_reason") == "invalid_identifier_spelling"
}
fallback = record.get("_identifier_spelling_fallback")
if not selected or fallback is None:
return None
tasks = [task for task in fallback["_ar_tasks"] if task[0] in selected]
return (
{
**fallback,
"_ar_tasks": tasks,
"_ar_prefix": [],
"_ar_group_prefixes": [],
"_ar_media_groups": [],
"_null_recovery": True,
}
if tasks
else None
)
def merge_fallback(
predictions: dict[str, dict[str, Any]],
alternatives: dict[str, dict[str, Any]],
fallback: dict[str, Any],
) -> dict[str, dict[str, Any]]:
result = dict(predictions)
lengths = {name: len(ids) for (name, ids, _) in fallback["_ar_tasks"]}
for name, alternative in alternatives.items():
original = predictions[name]
result[name] = {
**alternative,
"identifier_spelling_fallback": True,
"identifier_spelling_attempt": dict(original),
"score_representation": "native_json_scalar_fallback",
"tokens": original["tokens"] + alternative["tokens"],
"retry_input_tokens": original.get("retry_input_tokens", 0) + lengths[name],
}
return result