#!/usr/bin/env python3
"""Build the auditable v5.1 Prompt/Certified-FMFS overlay.
This module deliberately leaves :mod:`eval.v5_sidecar` and all v5.0
artifacts frozen. A v5.1 row is built offline from one dataset row and its
already-audited v5.0 sidecar row. It adds two contracts:
``fmfs.prompt``
Item-level, input-observable supervision. Physical and annotation masks
are aligned exactly with ``dimensions.items``. Unknown or ambiguous
items are omitted, never converted into model failures.
``fmfs.certified``
A strict endpoint. Automatic certification is intentionally restricted
to three simple, complete prompt templates. Unsupported feature graphs
remain ``unknown`` rather than being over-claimed as manufacturable.
The overlay is evaluator metadata, not a model target or an intermediate DSL.
It never executes generated code and never rewrites the prompt or GT.
"""
from __future__ import annotations
import argparse
import copy
import hashlib
import json
import math
import os
import re
import tempfile
from collections import Counter, defaultdict, deque
from pathlib import Path
from typing import Any, Mapping, Sequence
try:
from . import v5_sidecar as V5
except ImportError: # direct script / external plugin import
import v5_sidecar as V5
SCHEMA_VERSION = "edp-evaluator-sidecar-v5.1"
FMFS_VERSION = "fmfs-v5.1"
CERTIFICATE_SCOPE = "native_gt_dimension_manifest"
NUMBER_TOKEN = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)"
MM_UNIT_TOKEN = r"(?:mm|millimet(?:er|re)s?)"
PAIR_MEASUREMENT_RE = re.compile(
rf"(?<![\w.])(?P<first>{NUMBER_TOKEN})\s*[x\u00d7]\s*"
rf"(?P<second>{NUMBER_TOKEN})\s*(?P<unit>{MM_UNIT_TOKEN})\b",
re.IGNORECASE,
)
# A dedicated, typed list recognizer is safer than a generic numeric-list
# regex: it cannot absorb counts such as "5 edges" or "2 holes".
SHARED_UNIT_LIST_RE = re.compile(
rf"(?P<label>diameters?|radii)\s*\(?\s*"
rf"(?P<values>{NUMBER_TOKEN}(?:\s*,\s*{NUMBER_TOKEN})+"
rf"(?:\s*,?\s*(?:and|&)\s*{NUMBER_TOKEN})?)\s*"
rf"(?P<unit>{MM_UNIT_TOKEN})\b\s*\)?",
re.IGNORECASE,
)
SINGLE_MEASUREMENT_RE = re.compile(
rf"(?<![\w.])(?P<value>{NUMBER_TOKEN})\s*"
rf"(?P<unit>{MM_UNIT_TOKEN})\b",
re.IGNORECASE,
)
NUMBER_RE = re.compile(NUMBER_TOKEN)
FEATURE_HEADER_RE = re.compile(
r"(?:^|\s)(?P<header>The base solid:|A union feature:|A cut feature:)",
re.IGNORECASE,
)
HASH_RE = re.compile(r"^[0-9a-f]{64}$")
LINEAR_TYPES = frozenset(
{
"profile_width",
"profile_height",
"bounding_box_width",
"bounding_box_height",
"cutout_width",
"cutout_height",
"extrusion_depth",
}
)
CIRCULAR_TYPES = frozenset(
{"profile_diameter", "cut_profile_diameter", "hole_diameter", "profile_radius"}
)
class V51SidecarError(ValueError):
"""Raised when provenance or a v5.1 schema contract is inconsistent."""
def _sha256(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as handle:
for block in iter(lambda: handle.read(1024 * 1024), b""):
digest.update(block)
return digest.hexdigest()
def _text_sha256(text: str) -> str:
return hashlib.sha256(text.encode("utf-8")).hexdigest()
def _rounded(value: Any, digits: int = 9) -> float | None:
try:
result = float(value)
except (TypeError, ValueError):
return None
if not math.isfinite(result):
return None
result = round(result, digits)
return 0.0 if abs(result) < 0.5 * 10.0**-digits else result
def _user_prompt(row: Mapping[str, Any]) -> str:
messages = row.get("messages", [])
users = [
message.get("content", "")
for message in messages
if isinstance(message, Mapping) and message.get("role") == "user"
] if isinstance(messages, list) else []
return users[0] if len(users) == 1 and isinstance(users[0], str) else ""
def _feature_text(prompt: str) -> str:
marker = "Feature description:"
return prompt.split(marker, 1)[1].strip() if marker in prompt else prompt.strip()
def _normalise_space(text: str) -> str:
return " ".join(text.split())
def _feature_scopes(text: str) -> list[dict[str, Any]]:
matches = list(FEATURE_HEADER_RE.finditer(text))
if not matches:
return [
{
"id": "part:0",
"operation": "part",
"start": 0,
"end": len(text),
"text": text,
}
]
counts: Counter[str] = Counter()
scopes: list[dict[str, Any]] = []
for index, match in enumerate(matches):
header = match.group("header").lower()
operation = "base" if "base" in header else "union" if "union" in header else "cut"
ordinal = counts[operation]
counts[operation] += 1
start = match.end()
end = matches[index + 1].start() if index + 1 < len(matches) else len(text)
scopes.append(
{
"id": f"{operation}:{ordinal}",
"operation": operation,
"start": start,
"end": end,
"text": text[start:end].strip(),
}
)
return scopes
def _scope_for_span(scopes: Sequence[Mapping[str, Any]], start: int) -> Mapping[str, Any]:
for scope in scopes:
if int(scope["start"]) <= start < int(scope["end"]):
return scope
return scopes[0]
def _profile_kind(scope_text: str) -> str:
lower = scope_text.lower()
if "circular plate" in lower:
return "circle"
if "square plate" in lower:
return "square"
if "rectangular plate" in lower:
return "rectangle"
if "rectilinear" in lower or "l-shaped" in lower:
return "rectilinear"
if "polygonal plate" in lower:
return "polygon"
return "unknown"
def _semantic_spec(
text: str,
scope: Mapping[str, Any],
start: int,
end: int,
*,
group_kind: str,
component: int,
list_label: str | None = None,
) -> dict[str, Any]:
before = text[max(int(scope["start"]), start - 96) : start].lower()
after = text[end : min(int(scope["end"]), end + 48)].lower()
context = before + " " + after
operation = str(scope["operation"])
semantic_type: str | None = None
axis: str | None = None
family: str | None = None
expected_position: str | None = None
if group_kind == "shared_list":
semantic_type = "hole_diameter" if str(list_label).lower().startswith("diameter") else "profile_radius"
elif group_kind == "pair":
if "cutout" in context:
semantic_type = "cutout_width" if component == 1 else "cutout_height"
elif "bounding box" in context:
semantic_type = "bounding_box_width" if component == 1 else "bounding_box_height"
elif "square plate" in before or "rectangular plate" in before:
semantic_type = "profile_width" if component == 1 else "profile_height"
else:
if re.search(r"thickness\s+of\s*$", before) or "thickness" in before[-32:]:
semantic_type = "extrusion_depth"
elif re.match(r"\s*(?:mm\s+)?wide\b", after):
semantic_type = "profile_width"
elif re.match(r"\s*(?:mm\s+)?tall\b", after):
semantic_type = "profile_height"
elif re.search(r"(?:circular\s+holes?.*|hole\s+of\s+)diameter\s*$", before[-80:]):
semantic_type = "hole_diameter"
elif re.search(r"diameter\s*$", before):
semantic_type = "cut_profile_diameter" if operation == "cut" else "profile_diameter"
elif re.search(r"radius\s*$", before):
semantic_type = "profile_radius"
if semantic_type in LINEAR_TYPES:
family = "linear"
if semantic_type.endswith("width"):
axis = "horizontal"
elif semantic_type.endswith("height"):
axis = "vertical"
elif semantic_type == "extrusion_depth":
axis = "horizontal"
elif semantic_type in {"profile_diameter", "cut_profile_diameter", "hole_diameter"}:
family = "diameter"
elif semantic_type == "profile_radius":
family = "radius"
# The dataset's L-layout contract makes these positions deterministic for
# the plain part and base profile. Local union/cut feature orientation is
# not encoded in text and therefore remains unknown.
if semantic_type is not None and operation in {"part", "base"}:
expected_position = "upper_right" if semantic_type == "extrusion_depth" else "upper_left"
return {
"state": "typed" if semantic_type is not None else "numeric_only",
"type": semantic_type,
"family": family,
"axis": axis,
"expected_view_position": expected_position,
"feature_scope_id": scope["id"],
"feature_operation": operation,
"profile_kind": _profile_kind(str(scope["text"])),
}
def _hole_multiplicity(text: str, start: int, scope: Mapping[str, Any]) -> tuple[int, str]:
before = text[max(int(scope["start"]), start - 112) : start].lower()
match = re.search(r"(\d+)\s+circular\s+holes?\s*,?\s*each\s+of\s+diameter\s*$", before)
if match:
return max(1, int(match.group(1))), "explicit_each"
return 1, "single_mention"
def extract_typed_prompt_parameters(prompt: str) -> dict[str, Any]:
"""Extract typed millimetre values, including right-shared list units."""
text = _feature_text(prompt)
scopes = _feature_scopes(text)
occupied: list[tuple[int, int]] = []
raw: list[dict[str, Any]] = []
group_index = 0
def add_candidate(
*,
value_text: str,
value_span: tuple[int, int],
group_span: tuple[int, int],
component: int,
group_kind: str,
unit_source: str,
raw_group: str,
list_label: str | None = None,
expected_multiplicity: int = 1,
multiplicity_source: str = "single_mention",
) -> None:
value = _rounded(value_text)
scope = _scope_for_span(scopes, value_span[0])
semantic = _semantic_spec(
text,
scope,
value_span[0],
value_span[1],
group_kind=group_kind,
component=component,
list_label=list_label,
)
reason_codes: list[str] = []
physical_value = abs(float(value)) if value is not None and semantic["type"] == "extrusion_depth" else value
if value is None or abs(float(value)) <= 1e-12:
reason_codes.append("nonpositive_or_invalid_value")
elif value < 0 and semantic["type"] != "extrusion_depth":
reason_codes.append("negative_physical_length")
raw.append(
{
"group_id": f"g{group_index:03d}",
"component": component,
"group_kind": group_kind,
"signed_value_mm": value,
"physical_value_mm": _rounded(physical_value),
"unit": "mm",
"unit_source": unit_source,
"raw_group": raw_group,
"span": [value_span[0], value_span[1]],
"group_span": [group_span[0], group_span[1]],
"context": text[max(0, group_span[0] - 40) : min(len(text), group_span[1] + 40)],
"semantic": semantic,
"expected_multiplicity": expected_multiplicity,
"multiplicity_source": multiplicity_source,
"reason_codes": reason_codes,
}
)
for match in PAIR_MEASUREMENT_RE.finditer(text):
occupied.append(match.span())
for component, name in enumerate(("first", "second"), 1):
add_candidate(
value_text=match.group(name),
value_span=match.span(name),
group_span=match.span(),
component=component,
group_kind="pair",
unit_source="group_suffix",
raw_group=match.group(0),
)
group_index += 1
for match in SHARED_UNIT_LIST_RE.finditer(text):
if any(match.start() < right and match.end() > left for left, right in occupied):
continue
occupied.append(match.span())
values_start = match.start("values")
number_matches = list(NUMBER_RE.finditer(match.group("values")))
label = match.group("label")
for component, number in enumerate(number_matches, 1):
absolute_span = (values_start + number.start(), values_start + number.end())
add_candidate(
value_text=number.group(0),
value_span=absolute_span,
group_span=match.span(),
component=component,
group_kind="shared_list",
unit_source="right_shared",
raw_group=match.group(0),
list_label=label,
expected_multiplicity=1,
multiplicity_source="explicit_list_item",
)
group_index += 1
for match in SINGLE_MEASUREMENT_RE.finditer(text):
if any(match.start() < right and match.end() > left for left, right in occupied):
continue
scope = _scope_for_span(scopes, match.start())
multiplicity, multiplicity_source = _hole_multiplicity(text, match.start(), scope)
add_candidate(
value_text=match.group("value"),
value_span=match.span("value"),
group_span=match.span(),
component=1,
group_kind="single",
unit_source="explicit",
raw_group=match.group(0),
expected_multiplicity=multiplicity,
multiplicity_source=multiplicity_source,
)
group_index += 1
raw.sort(key=lambda item: (item["span"][0], item["component"]))
for index, item in enumerate(raw):
item["parameter_id"] = f"p{index:03d}"
return {
"status": "extracted" if raw else "unknown",
"source": "typed_user_prompt_numeric_mentions",
"feature_text_sha256": _text_sha256(text),
"candidate_count": len(raw),
"prompt_numbers_mm": [item["signed_value_mm"] for item in raw],
"candidates": raw,
"scope_count": len(scopes),
"scopes": scopes,
"reason_codes": [] if raw else ["no_explicit_mm_parameters"],
}
def _dimension_orientation(dimension: Mapping[str, Any]) -> str | None:
points = dimension.get("reference_points", {})
first, second = points.get("defpoint2"), points.get("defpoint3")
if not isinstance(first, Sequence) or not isinstance(second, Sequence):
return None
dx, dy = abs(float(second[0]) - float(first[0])), abs(float(second[1]) - float(first[1]))
length = math.hypot(dx, dy)
if length <= 1e-12:
return None
tolerance = math.sin(math.radians(5.0))
if dy / length <= tolerance:
return "horizontal"
if dx / length <= tolerance:
return "vertical"
return "aligned"
def _point_segment_distance(point: Sequence[float], first: Sequence[float], second: Sequence[float]) -> float:
px, py = float(point[0]), float(point[1])
ax, ay = float(first[0]), float(first[1])
bx, by = float(second[0]), float(second[1])
dx, dy = bx - ax, by - ay
denominator = dx * dx + dy * dy
if denominator <= 1e-18:
return math.hypot(px - ax, py - ay)
fraction = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / denominator))
return math.hypot(px - (ax + fraction * dx), py - (ay + fraction * dy))
def _distance_to_record(point: Sequence[float], record: Mapping[str, Any]) -> float | None:
bounds = record.get("bbox")
if not isinstance(bounds, Mapping):
return None
minimum, maximum = bounds.get("min"), bounds.get("max")
if not isinstance(minimum, Sequence) or not isinstance(maximum, Sequence):
return None
entity_type = record.get("type")
width = abs(float(maximum[0]) - float(minimum[0]))
height = abs(float(maximum[1]) - float(minimum[1]))
if entity_type == "LINE":
if width <= 1e-9 or height <= 1e-9:
return _point_segment_distance(point, minimum, maximum)
# A diagonal cannot be reconstructed safely from bbox corners alone.
return None
if entity_type == "CIRCLE" and abs(width - height) <= max(1e-7, 1e-5 * max(width, height, 1.0)):
centre = ((float(minimum[0]) + float(maximum[0])) / 2, (float(minimum[1]) + float(maximum[1])) / 2)
radius = (width + height) / 4
radial = math.dist((float(point[0]), float(point[1])), centre)
return min(abs(radial - radius), radial) # centre references are valid
return None
def _dimension_geometry_bindings(base: Mapping[str, Any]) -> list[dict[str, Any]]:
dimensions = list(base.get("dimensions", {}).get("items", []))
entities = list(base.get("entities", {}).get("items", []))
views = {int(item["index"]): item for item in base.get("views", {}).get("candidates", [])}
results: list[dict[str, Any]] = []
for dimension in dimensions:
view_index = dimension.get("view_candidate_index")
view = views.get(int(view_index)) if isinstance(view_index, int) else None
candidate_records = [
record
for record in entities
if record.get("view_candidate_index") == view_index
and record.get("type") in {"LINE", "CIRCLE", "ARC"}
]
family = "linear" if dimension.get("family") in {"linear", "aligned"} else dimension.get("family")
refs = dimension.get("reference_points", {})
names = ("defpoint2", "defpoint3") if family == "linear" else ("defpoint", "defpoint4")
points = [refs[name] for name in names if isinstance(refs.get(name), Sequence)]
diagonal = 1.0
if isinstance(view, Mapping):
bounds = view.get("geometry_bbox", {})
diagonal = max(1.0, math.hypot(float(bounds.get("width", 0.0)), float(bounds.get("height", 0.0))))
sigma = max(1e-6, 0.005 * diagonal)
qualities: list[float] = []
entity_indices: set[int] = set()
distances: list[float] = []
for point in points:
choices = []
for record in candidate_records:
distance = _distance_to_record(point, record)
if distance is not None and math.isfinite(distance):
choices.append((distance, int(record["index"])))
if not choices:
continue
distance, entity_index = min(choices)
distances.append(distance)
qualities.append(math.exp(-distance / sigma))
entity_indices.add(entity_index)
quality = sum(qualities) / len(points) if points and len(qualities) == len(points) else 0.0
geometry_state = "certified" if points and len(qualities) == len(points) and quality >= 0.90 else "unknown"
view_state = "certified" if geometry_state == "certified" and view is not None else "heuristic" if view is not None else "unknown"
results.append(
{
"geometry": {
"state": geometry_state,
"quality": _rounded(quality),
"entity_indices": sorted(entity_indices),
"reference_point_count": len(points),
"bound_reference_point_count": len(qualities),
"max_distance": _rounded(max(distances)) if distances else None,
"basis": "v5_bbox_primitive_reference_distance",
},
"view": {
"state": view_state,
"candidate_index": view_index,
"position": dimension.get("nearest_view_position"),
"role": dimension.get("nearest_view_role"),
"basis": "dimension_reference_geometry" if view_state == "certified" else "v5_binding_point_heuristic" if view_state == "heuristic" else None,
},
"orientation": _dimension_orientation(dimension),
}
)
return results
def _normal_family(value: Any) -> str:
return "linear" if str(value or "").lower() in {"linear", "aligned"} else str(value or "").lower()
def _value_matches(candidate: Mapping[str, Any], dimension: Mapping[str, Any]) -> tuple[bool, float | None, float | None]:
value, target = candidate.get("physical_value_mm"), dimension.get("display_value")
if not isinstance(value, (int, float)) or not isinstance(target, (int, float)):
return False, None, None
tolerance = max(0.05, 0.001 * abs(float(value)))
error = abs(abs(float(target)) - abs(float(value)))
return error <= tolerance, error, tolerance
def _compatible(
candidate: Mapping[str, Any],
dimension: Mapping[str, Any],
binding: Mapping[str, Any],
) -> bool:
semantic = candidate.get("semantic", {})
if semantic.get("state") != "typed" or candidate.get("reason_codes"):
return False
if _normal_family(dimension.get("family")) != semantic.get("family"):
return False
matches, _, _ = _value_matches(candidate, dimension)
if not matches or not dimension.get("reliable"):
return False
expected_position = semantic.get("expected_view_position")
if expected_position is not None and binding.get("view", {}).get("position") != expected_position:
return False
expected_axis = semantic.get("axis")
if expected_axis is not None and binding.get("orientation") != expected_axis:
return False
return binding.get("geometry", {}).get("state") == "certified"
def _maximum_slot_matching(
candidate_indices: Sequence[int],
edges: Mapping[int, Sequence[int]],
candidates: Sequence[Mapping[str, Any]],
) -> dict[int, int] | None:
slots: list[int] = []
for candidate_index in candidate_indices:
slots.extend([candidate_index] * int(candidates[candidate_index].get("expected_multiplicity", 1)))
matched_dimension_to_slot: dict[int, int] = {}
def augment(slot_index: int, visited: set[int]) -> bool:
candidate_index = slots[slot_index]
for dimension_index in sorted(edges.get(candidate_index, [])):
if dimension_index in visited:
continue
visited.add(dimension_index)
previous = matched_dimension_to_slot.get(dimension_index)
if previous is None or augment(previous, visited):
matched_dimension_to_slot[dimension_index] = slot_index
return True
return False
for slot_index in range(len(slots)):
if not augment(slot_index, set()):
return None
return {dimension_index: slots[slot_index] for dimension_index, slot_index in matched_dimension_to_slot.items()}
def _template_profile(text: str, category: Any) -> tuple[str | None, list[str], int | None]:
compact = _normalise_space(text)
value = rf"{NUMBER_TOKEN}\s*{MM_UNIT_TOKEN}"
pair = rf"{NUMBER_TOKEN}\s*[x\u00d7]\s*{NUMBER_TOKEN}\s*{MM_UNIT_TOKEN}"
thickness = rf"It is extruded to a thickness of {value}\."
patterns = [
(
"simple_rectangular_prism_v1",
rf"The part is a rectangular plate {value} wide and {value} tall\. {thickness}",
"CONVEX_PLATE",
3,
),
(
"simple_rectangular_prism_v1",
rf"The part is a square plate {pair}\. {thickness}",
"CONVEX_PLATE",
3,
),
(
"simple_concentric_annulus_v1",
rf"The part is a circular plate with diameter {value}, featuring a circular hole of diameter {value}\. {thickness}",
"DISK_WITH_HOLES",
3,
),
(
"simple_cylindrical_disk_v1",
rf"The part is a circular plate with diameter {value}\. {thickness}",
"DISK",
2,
),
]
for name, pattern, expected_category, count in patterns:
if re.fullmatch(pattern, compact, re.IGNORECASE):
reasons = [] if str(category or "").upper() == expected_category else ["category_not_supported_for_template"]
return name, reasons, count
return None, ["unsupported_completeness_template"], None
def _build_fmfs(
base: Mapping[str, Any], parameters: dict[str, Any], feature_text: str
) -> dict[str, Any]:
dimensions = list(base.get("dimensions", {}).get("items", []))
candidates = list(parameters.get("candidates", []))
bindings = _dimension_geometry_bindings(base)
for index, dimension in enumerate(dimensions):
dimension["v51_binding"] = bindings[index]
edges: dict[int, list[int]] = {}
for candidate_index, candidate in enumerate(candidates):
compatible = [
dimension_index
for dimension_index, dimension in enumerate(dimensions)
if _compatible(candidate, dimension, bindings[dimension_index])
]
candidate["compatible_gt_dimension_indices"] = compatible
edges[candidate_index] = compatible
typed_nodes = [index for index, candidate in enumerate(candidates) if candidate.get("semantic", {}).get("state") == "typed" and not candidate.get("reason_codes")]
dimension_to_candidates: defaultdict[int, list[int]] = defaultdict(list)
for candidate_index in typed_nodes:
for dimension_index in edges[candidate_index]:
dimension_to_candidates[dimension_index].append(candidate_index)
physical_mask = [False] * len(dimensions)
annotation_mask = [False] * len(dimensions)
items: list[dict[str, Any]] = []
resolved_candidates: set[int] = set()
visited_candidates: set[int] = set()
ambiguous_candidates: set[int] = set()
for seed in typed_nodes:
if seed in visited_candidates or not edges[seed]:
continue
queue: deque[tuple[str, int]] = deque([("c", seed)])
component_candidates: set[int] = set()
component_dimensions: set[int] = set()
while queue:
kind, index = queue.popleft()
if kind == "c":
if index in component_candidates:
continue
component_candidates.add(index)
queue.extend(("d", value) for value in edges[index])
else:
if index in component_dimensions:
continue
component_dimensions.add(index)
queue.extend(("c", value) for value in dimension_to_candidates[index])
visited_candidates.update(component_candidates)
demand = sum(int(candidates[index].get("expected_multiplicity", 1)) for index in component_candidates)
matching = _maximum_slot_matching(sorted(component_candidates), edges, candidates)
complete = demand == len(component_dimensions) and matching is not None and len(matching) == demand
if not complete:
ambiguous_candidates.update(component_candidates)
continue
assignment_state = "unique" if len(component_candidates) == len(component_dimensions) == demand == 1 else "symmetric_group"
component_parameter_ids = [candidates[index]["parameter_id"] for index in sorted(component_candidates)]
semantic_types = sorted({str(candidates[index]["semantic"]["type"]) for index in component_candidates})
annotation_ready = (
len(semantic_types) == 1
and all(
candidates[index]["semantic"].get("expected_view_position") is not None
and (
candidates[index]["semantic"].get("family") in {"diameter", "radius"}
or candidates[index]["semantic"].get("axis") is not None
)
for index in component_candidates
)
)
group_id = "b" + hashlib.sha256(
("|".join(component_parameter_ids) + ":" + ",".join(map(str, sorted(component_dimensions)))).encode("utf-8")
).hexdigest()[:10]
for dimension_index in sorted(component_dimensions):
dimension = dimensions[dimension_index]
binding = bindings[dimension_index]
matched_candidate = matching.get(dimension_index) if matching else None
source_candidate = candidates[matched_candidate] if matched_candidate is not None else candidates[min(component_candidates)]
matches, value_error, tolerance = _value_matches(source_candidate, dimension)
physical_mask[dimension_index] = True
annotation_eligible = bool(
annotation_ready
and binding["geometry"]["state"] == "certified"
and binding["view"]["state"] == "certified"
)
annotation_mask[dimension_index] = annotation_eligible
items.append(
{
"id": f"pf{len(items):03d}",
"gt_dimension_index": dimension_index,
"gt_dimension_id": dimension.get("id", f"d{dimension_index:03d}"),
"prompt_parameter_ids": component_parameter_ids,
"semantic_type": semantic_types[0] if len(semantic_types) == 1 else "symmetric_parameter_group",
"semantic_types": semantic_types,
"family": _normal_family(dimension.get("family")),
"value_mm": dimension.get("display_value"),
"physical_eligible": True,
"annotation_eligible": annotation_eligible,
"binding": {
"value": {
"state": "certified" if matches else "conflict",
"absolute_error_mm": _rounded(value_error),
"tolerance_mm": _rounded(tolerance),
},
"type": {
"state": "certified",
"expected": source_candidate["semantic"].get("family"),
"actual": _normal_family(dimension.get("family")),
},
"assignment": {
"state": assignment_state,
"group_id": group_id,
"candidate_dimension_indices": sorted(component_dimensions),
"demand": demand,
},
"view": binding["view"],
"geometry": binding["geometry"],
},
"reason_codes": [] if annotation_eligible else ["annotation_binding_not_certified"],
}
)
resolved_candidates.update(component_candidates)
template, template_reasons, expected_dimension_count = _template_profile(feature_text, base.get("category"))
candidate_conflicts = {
index for index, candidate in enumerate(candidates) if candidate.get("reason_codes")
}
if template is not None:
candidate_conflicts.update(index for index in typed_nodes if index not in resolved_candidates)
conflicting_ids = sorted(candidates[index]["parameter_id"] for index in candidate_conflicts)
unresolved_ids = sorted(
candidate["parameter_id"]
for index, candidate in enumerate(candidates)
if index not in resolved_candidates and index not in candidate_conflicts
)
unresolved_dimensions = [
dimensions[index].get("id", f"d{index:03d}")
for index, enabled in enumerate(physical_mask)
if not enabled
]
prompt_reasons: list[str] = []
if not any(physical_mask):
prompt_reasons.append("no_prompt_fmfs_physical_items")
if not any(annotation_mask):
prompt_reasons.append("no_prompt_fmfs_annotation_items")
if ambiguous_candidates:
prompt_reasons.append("ambiguous_parameter_dimension_assignment")
if unresolved_ids:
prompt_reasons.append("unresolved_prompt_parameters")
if conflicting_ids:
prompt_reasons.append("prompt_gt_conflict")
reliable_count = sum(bool(item.get("reliable")) for item in dimensions)
prompt_manifest = {
"physical_eligible": any(physical_mask),
"annotation_eligible": any(annotation_mask),
"physical_item_mask": physical_mask,
"annotation_item_mask": annotation_mask,
"physical_item_count": sum(physical_mask),
"annotation_item_count": sum(annotation_mask),
"items": items,
"unresolved_prompt_parameter_ids": unresolved_ids,
"conflicting_prompt_parameter_ids": conflicting_ids,
"unresolved_gt_dimension_ids": unresolved_dimensions,
"coverage": {
"physical_over_all_gt": _rounded(sum(physical_mask) / len(dimensions)) if dimensions else None,
"physical_over_reliable_gt": _rounded(sum(physical_mask) / reliable_count) if reliable_count else None,
"annotation_over_all_gt": _rounded(sum(annotation_mask) / len(dimensions)) if dimensions else None,
},
"reason_codes": prompt_reasons or ["ok"],
}
certified_reasons = list(template_reasons)
if template is not None:
if expected_dimension_count != len(dimensions):
certified_reasons.append("template_dimension_count_mismatch")
if not all(physical_mask) or not all(annotation_mask):
certified_reasons.append("template_items_not_fully_bound")
if conflicting_ids or unresolved_ids:
certified_reasons.append("template_prompt_parameters_unresolved")
if not all(bool(item.get("reliable")) for item in dimensions):
certified_reasons.append("unreliable_gt_dimensions")
if base.get("views", {}).get("status") != "ok" or base.get("views", {}).get("candidate_count") != 3:
certified_reasons.append("three_view_contract_not_certified")
if any(
isinstance(candidate.get("signed_value_mm"), (int, float))
and float(candidate["signed_value_mm"]) < 0
for candidate in candidates
):
certified_reasons.append("negative_template_parameter")
eligible = bool(template is not None and not certified_reasons)
if eligible:
status = "certified"
certified_reasons = ["ok"]
elif template is None or "category_not_supported_for_template" in certified_reasons:
status = "unknown"
else:
status = "conflict"
certified_manifest = {
"status": status,
"eligible": eligible,
"scope": CERTIFICATE_SCOPE,
"completeness_profile": template,
"physical_item_mask": list(physical_mask) if eligible else [False] * len(dimensions),
"annotation_item_mask": list(annotation_mask) if eligible else [False] * len(dimensions),
"item_ids": [item["id"] for item in items] if eligible else [],
"unresolved_gt_dimension_ids": [] if eligible else unresolved_dimensions,
"reason_codes": certified_reasons,
"notes": (
"Automatic certification covers only the declared native-GT dimension "
"manifest for a supported complete template; it is not a STEP/B-Rep "
"feature-tree completeness proof."
),
}
return {"version": FMFS_VERSION, "prompt": prompt_manifest, "certified": certified_manifest}
def build_v51_row(
dataset_row: Mapping[str, Any],
base_row: Mapping[str, Any],
*,
dataset_path: str | Path | None = None,
dataset_sha256: str | None = None,
base_sidecar_path: str | Path | None = None,
base_sidecar_sha256: str | None = None,
) -> dict[str, Any]:
part_id = str(dataset_row.get("id", "")).strip()
if not part_id or part_id != str(base_row.get("id", "")).strip():
raise V51SidecarError("dataset/base sidecar id mismatch")
if base_row.get("schema_version") != V5.SCHEMA_VERSION:
raise V51SidecarError(f"unsupported base schema {base_row.get('schema_version')!r}")
for field in ("category", "tier"):
if dataset_row.get(field) is not None and base_row.get(field) is not None and dataset_row.get(field) != base_row.get(field):
raise V51SidecarError(f"{part_id}: dataset/base {field} mismatch")
prompt = _user_prompt(dataset_row)
prompt_hash = _text_sha256(prompt)
expected_prompt_hash = base_row.get("source", {}).get("prompt_sha256")
if not prompt or prompt_hash != expected_prompt_hash:
raise V51SidecarError(f"{part_id}: prompt hash does not match base sidecar")
if not isinstance(base_row.get("gt_dxf_sha256"), str) or not HASH_RE.fullmatch(base_row["gt_dxf_sha256"]):
raise V51SidecarError(f"{part_id}: base sidecar has no valid GT hash")
output = copy.deepcopy(dict(base_row))
output["schema_version"] = SCHEMA_VERSION
output["source"] = {
**dict(base_row.get("source", {})),
"dataset": str(Path(dataset_path).resolve()) if dataset_path is not None else None,
"dataset_sha256": dataset_sha256,
"base_sidecar": str(Path(base_sidecar_path).resolve()) if base_sidecar_path is not None else None,
"base_sidecar_sha256": base_sidecar_sha256,
"base_schema_version": V5.SCHEMA_VERSION,
"prompt_sha256": prompt_hash,
"base_gt_dxf_sha256": base_row["gt_dxf_sha256"],
}
output["parameters"] = extract_typed_prompt_parameters(prompt)
output["fmfs"] = _build_fmfs(output, output["parameters"], _feature_text(prompt))
output["eligibility"] = {
**dict(base_row.get("eligibility", {})),
"prompt_fmfs_physical": output["fmfs"]["prompt"]["physical_eligible"],
"prompt_fmfs_annotation": output["fmfs"]["prompt"]["annotation_eligible"],
"certified_fmfs": output["fmfs"]["certified"]["eligible"],
"automatic_v51_reward": output["fmfs"]["prompt"]["physical_eligible"],
}
# Remove ambiguous v5.0 aliases so an old evaluator cannot silently treat a
# partial Prompt-FMFS manifest as a strict all-GT endpoint.
output["eligibility"].pop("fmfs", None)
output["eligibility"].pop("automatic_v5_reward", None)
return output
def _validate_hash(value: Any, label: str, path: Path, line_number: int) -> None:
if not isinstance(value, str) or not HASH_RE.fullmatch(value):
raise V51SidecarError(f"{path}:{line_number}: invalid {label}")
def _validate_loaded_row(row: Any, path: Path, line_number: int) -> dict[str, Any]:
if not isinstance(row, dict):
raise V51SidecarError(f"{path}:{line_number}: expected JSON object")
if row.get("schema_version") != SCHEMA_VERSION:
raise V51SidecarError(f"{path}:{line_number}: unsupported schema")
part_id = str(row.get("id", "")).strip()
if not part_id:
raise V51SidecarError(f"{path}:{line_number}: missing id")
source = row.get("source")
if not isinstance(source, dict) or source.get("base_schema_version") != V5.SCHEMA_VERSION:
raise V51SidecarError(f"{path}:{line_number}: invalid base provenance")
for field in ("dataset_sha256", "base_sidecar_sha256", "prompt_sha256", "base_gt_dxf_sha256"):
_validate_hash(source.get(field), f"source.{field}", path, line_number)
if source["base_gt_dxf_sha256"] != row.get("gt_dxf_sha256"):
raise V51SidecarError(f"{path}:{line_number}: GT hash binding mismatch")
dimensions = row.get("dimensions", {}).get("items")
fmfs = row.get("fmfs")
if not isinstance(dimensions, list) or not isinstance(fmfs, dict) or fmfs.get("version") != FMFS_VERSION:
raise V51SidecarError(f"{path}:{line_number}: invalid dimensions/FMFS contract")
prompt, certified = fmfs.get("prompt"), fmfs.get("certified")
if not isinstance(prompt, dict) or not isinstance(certified, dict):
raise V51SidecarError(f"{path}:{line_number}: missing prompt/certified FMFS")
for manifest_name, manifest in (("prompt", prompt), ("certified", certified)):
for mask_name in ("physical_item_mask", "annotation_item_mask"):
mask = manifest.get(mask_name)
if not isinstance(mask, list) or len(mask) != len(dimensions) or any(type(value) is not bool for value in mask):
raise V51SidecarError(f"{path}:{line_number}: invalid {manifest_name}.{mask_name}")
physical_mask = prompt["physical_item_mask"]
annotation_mask = prompt["annotation_item_mask"]
if any(annotation and not physical for physical, annotation in zip(physical_mask, annotation_mask)):
raise V51SidecarError(f"{path}:{line_number}: annotation mask exceeds physical mask")
items = prompt.get("items")
if not isinstance(items, list):
raise V51SidecarError(f"{path}:{line_number}: prompt.items must be a list")
seen_indices: set[int] = set()
for item in items:
if not isinstance(item, dict) or not isinstance(item.get("gt_dimension_index"), int):
raise V51SidecarError(f"{path}:{line_number}: invalid Prompt-FMFS item")
index = item["gt_dimension_index"]
if index in seen_indices or not 0 <= index < len(dimensions):
raise V51SidecarError(f"{path}:{line_number}: duplicate/out-of-range GT dimension index")
seen_indices.add(index)
assignment = item.get("binding", {}).get("assignment", {}).get("state")
if assignment not in {"unique", "symmetric_group"} or not physical_mask[index]:
raise V51SidecarError(f"{path}:{line_number}: unsafe Prompt-FMFS assignment")
if annotation_mask[index]:
binding = item.get("binding", {})
if binding.get("view", {}).get("state") != "certified" or binding.get("geometry", {}).get("state") != "certified":
raise V51SidecarError(f"{path}:{line_number}: annotation item lacks certified binding")
if {index for index, enabled in enumerate(physical_mask) if enabled} != seen_indices:
raise V51SidecarError(f"{path}:{line_number}: prompt item/mask mismatch")
status = certified.get("status")
if status not in {"certified", "conflict", "unknown"} or bool(certified.get("eligible")) != (status == "certified"):
raise V51SidecarError(f"{path}:{line_number}: inconsistent certified status")
if certified.get("eligible") and (
not all(certified["physical_item_mask"]) or not all(certified["annotation_item_mask"])
):
raise V51SidecarError(f"{path}:{line_number}: certified manifest is not complete")
row["id"] = part_id
return row
def load_sidecar_jsonl(path: str | Path) -> dict[str, dict[str, Any]]:
source_path = Path(path)
rows: dict[str, dict[str, Any]] = {}
provenance: tuple[str, str] | None = None
with source_path.open(encoding="utf-8") as handle:
for line_number, line in enumerate(handle, 1):
if not line.strip():
continue
try:
decoded = json.loads(line)
except json.JSONDecodeError as error:
raise V51SidecarError(f"{source_path}:{line_number}: {error}") from error
row = _validate_loaded_row(decoded, source_path, line_number)
if row["id"] in rows:
raise V51SidecarError(f"{source_path}:{line_number}: duplicate id {row['id']}")
current = (row["source"]["dataset_sha256"], row["source"]["base_sidecar_sha256"])
if provenance is None:
provenance = current
elif current != provenance:
raise V51SidecarError(f"{source_path}:{line_number}: mixed dataset/base provenance")
rows[row["id"]] = row
return rows
def _atomic_jsonl(path: Path, rows: Sequence[Mapping[str, Any]]) -> None:
path.parent.mkdir(parents=True, exist_ok=True)
descriptor, temporary = tempfile.mkstemp(prefix=path.name + ".", suffix=".tmp", dir=path.parent)
try:
with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
for row in rows:
handle.write(json.dumps(row, ensure_ascii=False, sort_keys=True, separators=(",", ":"), allow_nan=False) + "\n")
handle.flush()
os.fsync(handle.fileno())
os.replace(temporary, path)
finally:
if os.path.exists(temporary):
os.remove(temporary)
def build_sidecar_dataset(
dataset_path: str | Path,
base_sidecar_path: str | Path,
output_path: str | Path,
) -> dict[str, Any]:
dataset = Path(dataset_path).resolve()
base_path = Path(base_sidecar_path).resolve()
output = Path(output_path).resolve()
dataset_hash, base_hash = _sha256(dataset), _sha256(base_path)
dataset_rows: dict[str, dict[str, Any]] = {}
with dataset.open(encoding="utf-8") as handle:
for line_number, line in enumerate(handle, 1):
if not line.strip():
continue
try:
row = json.loads(line)
except json.JSONDecodeError as error:
raise V51SidecarError(f"{dataset}:{line_number}: {error}") from error
if not isinstance(row, dict) or not str(row.get("id", "")).strip():
raise V51SidecarError(f"{dataset}:{line_number}: invalid row/id")
part_id = str(row["id"]).strip()
if part_id in dataset_rows:
raise V51SidecarError(f"{dataset}:{line_number}: duplicate id {part_id}")
dataset_rows[part_id] = row
base_rows = V5.load_sidecar_jsonl(base_path)
if set(dataset_rows) != set(base_rows):
missing_base = sorted(set(dataset_rows) - set(base_rows))
missing_dataset = sorted(set(base_rows) - set(dataset_rows))
raise V51SidecarError(
f"dataset/base ID sets differ: missing_base={missing_base[:5]}, missing_dataset={missing_dataset[:5]}"
)
rows = [
build_v51_row(
dataset_rows[part_id],
base_rows[part_id],
dataset_path=dataset,
dataset_sha256=dataset_hash,
base_sidecar_path=base_path,
base_sidecar_sha256=base_hash,
)
for part_id in dataset_rows
]
_atomic_jsonl(output, rows)
status_counts = Counter(row["fmfs"]["certified"]["status"] for row in rows)
summary = {
"schema_version": SCHEMA_VERSION,
"dataset": str(dataset),
"dataset_sha256": dataset_hash,
"base_sidecar": str(base_path),
"base_sidecar_sha256": base_hash,
"output": str(output),
"output_sha256": _sha256(output),
"count": len(rows),
"prompt_physical_eligible": sum(row["fmfs"]["prompt"]["physical_eligible"] for row in rows),
"prompt_annotation_eligible": sum(row["fmfs"]["prompt"]["annotation_eligible"] for row in rows),
"certified_status_counts": dict(sorted(status_counts.items())),
}
return summary
def main(argv: Sequence[str] | None = None) -> int:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--dataset", type=Path, required=True)
parser.add_argument("--base-sidecar", type=Path, required=True)
parser.add_argument("--out", type=Path, required=True)
args = parser.parse_args(argv)
print(
json.dumps(
build_sidecar_dataset(args.dataset, args.base_sidecar, args.out),
ensure_ascii=False,
indent=2,
sort_keys=True,
)
)
return 0
if __name__ == "__main__":
raise SystemExit(main())
#!/usr/bin/env python3
"""Build the auditable v5.1 Prompt/Certified-FMFS overlay.
This module deliberately leaves :mod:`eval.v5_sidecar` and all v5.0
artifacts frozen. A v5.1 row is built offline from one dataset row and its
already-audited v5.0 sidecar row. It adds two contracts:
``fmfs.prompt``
Item-level, input-observable supervision. Physical and annotation masks
are aligned exactly with ``dimensions.items``. Unknown or ambiguous
items are omitted, never converted into model failures.
``fmfs.certified``
A strict endpoint. Automatic certification is intentionally restricted
to three simple, complete prompt templates. Unsupported feature graphs
remain ``unknown`` rather than being over-claimed as manufacturable.
The overlay is evaluator metadata, not a model target or an intermediate DSL.
It never executes generated code and never rewrites the prompt or GT.
"""
from __future__ import annotations
import argparse
import copy
import hashlib
import json
import math
import os
import re
import tempfile
from collections import Counter, defaultdict, deque
from pathlib import Path
from typing import Any, Mapping, Sequence
try:
from . import v5_sidecar as V5
except ImportError: # direct script / external plugin import
import v5_sidecar as V5
SCHEMA_VERSION = "edp-evaluator-sidecar-v5.1"
FMFS_VERSION = "fmfs-v5.1"
CERTIFICATE_SCOPE = "native_gt_dimension_manifest"
NUMBER_TOKEN = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)"
MM_UNIT_TOKEN = r"(?:mm|millimet(?:er|re)s?)"
PAIR_MEASUREMENT_RE = re.compile(
rf"(?<![\w.])(?P<first>{NUMBER_TOKEN})\s*[x\u00d7]\s*"
rf"(?P<second>{NUMBER_TOKEN})\s*(?P<unit>{MM_UNIT_TOKEN})\b",
re.IGNORECASE,
)
# A dedicated, typed list recognizer is safer than a generic numeric-list
# regex: it cannot absorb counts such as "5 edges" or "2 holes".
SHARED_UNIT_LIST_RE = re.compile(
rf"(?P<label>diameters?|radii)\s*\(?\s*"
rf"(?P<values>{NUMBER_TOKEN}(?:\s*,\s*{NUMBER_TOKEN})+"
rf"(?:\s*,?\s*(?:and|&)\s*{NUMBER_TOKEN})?)\s*"
rf"(?P<unit>{MM_UNIT_TOKEN})\b\s*\)?",
re.IGNORECASE,
)
SINGLE_MEASUREMENT_RE = re.compile(
rf"(?<![\w.])(?P<value>{NUMBER_TOKEN})\s*"
rf"(?P<unit>{MM_UNIT_TOKEN})\b",
re.IGNORECASE,
)
NUMBER_RE = re.compile(NUMBER_TOKEN)
FEATURE_HEADER_RE = re.compile(
r"(?:^|\s)(?P<header>The base solid:|A union feature:|A cut feature:)",
re.IGNORECASE,
)
HASH_RE = re.compile(r"^[0-9a-f]{64}$")
LINEAR_TYPES = frozenset(
{
"profile_width",
"profile_height",
"bounding_box_width",
"bounding_box_height",
"cutout_width",
"cutout_height",
"extrusion_depth",
}
)
CIRCULAR_TYPES = frozenset(
{"profile_diameter", "cut_profile_diameter", "hole_diameter", "profile_radius"}
)
class V51SidecarError(ValueError):
"""Raised when provenance or a v5.1 schema contract is inconsistent."""
def _sha256(path: Path) -> str:
digest = hashlib.sha256()
with path.open("rb") as handle:
for block in iter(lambda: handle.read(1024 * 1024), b""):
digest.update(block)
return digest.hexdigest()