from __future__ import annotations import hashlib import json import math import os import re from dataclasses import dataclass from pathlib import Path from typing import Iterable DEFAULT_TARGET = Path(os.environ.get("EVAL_TARGET_DIR", r"C:\Users\User\Desktop")) NC_NAME = "task-04.nc" FORMAL_INPUT_SHA256 = { "hole_table_plate.step": "3094AF53D864C0031251B738D51201551E439A32CD556E1AA09B345F3978C39D", "hole_table.csv": "25B7FDFF9FC8522F0882D77A0930242123FD9FEC2774D8EEE0969F530F725B5E", } XY_TOL_MM = 0.35 DEPTH_TOL_MM = 0.30 THROUGH_TIP_COMP_MAX_MM = 0.65 SAFE_CLEARANCE_MM = 1.0 WORD_RE = re.compile(r"([A-Z])([-+]?(?:\d+(?:\.\d*)?|\.\d+))") RUN_ID_RE = re.compile(r"[A-Za-z0-9._:-]{8,128}") @dataclass(frozen=True) class Hole: x: float y: float diameter: float depth: float kind: str HOLES = ( Hole(-45.0, -10.0, 5.0, 13.0, "through"), Hole(-35.0, 10.0, 5.0, 13.0, "through"), Hole(-25.0, -10.0, 5.0, 13.0, "through"), Hole(-15.0, 10.0, 5.0, 13.0, "through"), Hole(-5.0, -10.0, 5.0, 13.0, "through"), Hole(5.0, 10.0, 5.0, 13.0, "through"), Hole(15.0, -10.0, 6.0, 6.0, "blind"), Hole(25.0, 10.0, 6.0, 7.0, "blind"), Hole(35.0, -10.0, 6.0, 8.0, "blind"), Hole(45.0, 10.0, 6.0, 9.0, "blind"), ) class EvaluationError(ValueError): pass @dataclass class Record: line: int motion: int start: tuple[float, float, float] end: tuple[float, float, float] tool: int | None spindle_on: bool spindle: float | None feed: float | None wcs: str | None length_comp: bool h_offset: int | None @dataclass class DrillEvent: line: int x: float y: float bottom_z: float approach_z: float | None retract_z: float | None tool: int | None spindle_on: bool spindle: float | None feed: float | None wcs: str | None length_comp: bool h_offset: int | None method: str @dataclass class Program: records: list[Record] cycle_events: list[DrillEvent] saw_m30: bool def close(a: float, b: float, tol: float) -> bool: return abs(a - b) <= tol def sha256_file(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for chunk in iter(lambda: handle.read(1024 * 1024), b""): digest.update(chunk) return digest.hexdigest().upper() def strip_comments(raw: str, line_number: int) -> str: output: list[str] = [] depth = 0 for char in raw: if char == ";" and depth == 0: break if char == "(": depth += 1 elif char == ")": if depth == 0: raise EvaluationError(f"unmatched comment close on line {line_number}") depth -= 1 elif depth == 0: output.append(char) if depth: raise EvaluationError(f"unterminated comment on line {line_number}") return "".join(output).upper().strip() def parse_words(code: str, line_number: int) -> list[tuple[str, float]]: if code == "%": return [] if code.startswith("/"): code = code[1:].lstrip() matches = list(WORD_RE.finditer(code)) residue = WORD_RE.sub(" ", code) if residue.strip(): raise EvaluationError(f"unknown executable text on line {line_number}: {residue.strip()!r}") return [(match.group(1), float(match.group(2))) for match in matches] def exact_int(value: float, label: str, line_number: int) -> int: rounded = round(value) if not close(value, rounded, 1e-8): raise EvaluationError(f"fractional {label} code on line {line_number}") return int(rounded) def g_is(value: float, expected: float) -> bool: return close(value, expected, 1e-7) def parse_program(source: str) -> Program: units: float | None = None distance_mode: int | None = None motion: int | None = None active_cycle: int | None = None cycle_z: float | None = None cycle_r: float | None = None cycle_q: float | None = None retract_mode = 98 selected_tool: int | None = None active_tool: int | None = None spindle_on = False spindle: float | None = None feed: float | None = None wcs: str | None = None length_comp = False h_offset: int | None = None x = y = z = 0.0 terminated = False saw_m30 = False records: list[Record] = [] cycle_events: list[DrillEvent] = [] allowed_g = { 0.0, 1.0, 2.0, 3.0, 17.0, 20.0, 21.0, 28.0, 40.0, 43.0, 49.0, 53.0, 54.0, 54.1, 55.0, 56.0, 57.0, 58.0, 59.0, 80.0, 81.0, 82.0, 83.0, 90.0, 91.0, 94.0, 98.0, 99.0, } allowed_m = {0, 1, 2, 3, 4, 5, 6, 8, 9, 30} for line_number, raw in enumerate(source.splitlines(), 1): code = strip_comments(raw, line_number) if not code or code == "%": continue words = parse_words(code, line_number) if not words: continue if terminated: raise EvaluationError(f"executable code after M30 on line {line_number}") by_letter: dict[str, list[float]] = {} for letter, value in words: by_letter.setdefault(letter, []).append(value) for letter in by_letter: if letter not in "NGMTSFXYZIJRQHDPLO": raise EvaluationError(f"unsupported word {letter} on line {line_number}") for letter in "XYZIJRQHDFSTP": if len(by_letter.get(letter, [])) > 1: raise EvaluationError(f"duplicate {letter} word on line {line_number}") g_codes = by_letter.get("G", []) m_codes = [exact_int(v, "M", line_number) for v in by_letter.get("M", [])] for g in g_codes: if not any(g_is(g, allowed) for allowed in allowed_g): raise EvaluationError(f"unsupported G code G{g:g} on line {line_number}") for m in m_codes: if m not in allowed_m: raise EvaluationError(f"unsupported M code M{m} on line {line_number}") axis_present = any(letter in by_letter for letter in "XYZ") block_motion = any(any(g_is(g, candidate) for candidate in (0, 1, 2, 3, 81, 82, 83)) for g in g_codes) if 30 in m_codes: if axis_present or block_motion: raise EvaluationError(f"motion or cycle in M30 block on line {line_number}") saw_m30 = True terminated = True continue for g in g_codes: if g_is(g, 20): units = 25.4 elif g_is(g, 21): units = 1.0 elif g_is(g, 90): distance_mode = 90 elif g_is(g, 91): distance_mode = 91 elif any(g_is(g, candidate) for candidate in (0, 1, 2, 3)): motion = int(round(g)) active_cycle = None elif g_is(g, 80): active_cycle = None elif any(g_is(g, candidate) for candidate in (81, 82, 83)): active_cycle = int(round(g)) elif g_is(g, 98): retract_mode = 98 elif g_is(g, 99): retract_mode = 99 elif g_is(g, 43): length_comp = True elif g_is(g, 49): length_comp = False h_offset = None elif any(g_is(g, candidate) for candidate in (54, 55, 56, 57, 58, 59)): wcs = f"G{int(round(g))}" elif g_is(g, 54.1): p_value = by_letter.get("P", [None])[-1] if p_value is None or exact_int(p_value, "P", line_number) <= 0: raise EvaluationError(f"G54.1 requires positive P on line {line_number}") wcs = f"G54.1 P{exact_int(p_value, 'P', line_number)}" if "T" in by_letter: selected_tool = exact_int(by_letter["T"][-1], "T", line_number) if selected_tool <= 0: raise EvaluationError(f"tool number must be positive on line {line_number}") if 6 in m_codes: if selected_tool is None: raise EvaluationError(f"M6 without selected tool on line {line_number}") active_tool = selected_tool if "S" in by_letter: spindle = by_letter["S"][-1] if spindle <= 0: raise EvaluationError(f"spindle speed must be positive on line {line_number}") if 3 in m_codes or 4 in m_codes: spindle_on = True if 5 in m_codes: spindle_on = False if "F" in by_letter: if units is None: raise EvaluationError(f"feed appears before G20/G21 on line {line_number}") feed = by_letter["F"][-1] * units if feed <= 0: raise EvaluationError(f"feed must be positive on line {line_number}") if "H" in by_letter: h_offset = exact_int(by_letter["H"][-1], "H", line_number) if h_offset <= 0: raise EvaluationError(f"H offset must be positive on line {line_number}") if axis_present and (units is None or distance_mode is None): raise EvaluationError(f"axis motion before explicit units and distance mode on line {line_number}") initial = (x, y, z) scale = units or 1.0 machine_coordinate_block = any(g_is(g, 28) or g_is(g, 53) for g in g_codes) if machine_coordinate_block and active_cycle is not None: raise EvaluationError(f"machine-coordinate motion cannot launch a drilling cycle on line {line_number}") if machine_coordinate_block and axis_present: # G28/G53 do not establish a point in the active work coordinate system. # They may appear in a native post's safe-home sequence, but cannot # supply approach, hole, depth, or retract evidence. continue if active_cycle is not None: if distance_mode != 90: raise EvaluationError(f"canned cycles require G90 in this evaluator on line {line_number}") if "Z" in by_letter: cycle_z = by_letter["Z"][-1] * scale if "R" in by_letter: cycle_r = by_letter["R"][-1] * scale if "Q" in by_letter: cycle_q = by_letter["Q"][-1] * scale if "X" in by_letter: x = by_letter["X"][-1] * scale if "Y" in by_letter: y = by_letter["Y"][-1] * scale launches_cycle = any(g_is(g, candidate) for g in g_codes for candidate in (81, 82, 83)) or "X" in by_letter or "Y" in by_letter if launches_cycle: if cycle_z is None or cycle_r is None: raise EvaluationError(f"incomplete canned cycle on line {line_number}") if active_cycle == 83 and (cycle_q is None or cycle_q <= 0): raise EvaluationError(f"G83 requires positive Q on line {line_number}") retract_z = max(initial[2], cycle_r) if retract_mode == 98 else cycle_r cycle_events.append( DrillEvent( line_number, x, y, cycle_z, initial[2], retract_z, active_tool, spindle_on, spindle, feed, wcs, length_comp, h_offset, f"G{active_cycle}", ) ) z = retract_z continue if axis_present: if motion is None: raise EvaluationError(f"axis words before an explicit motion mode on line {line_number}") values: dict[str, float] = {} for axis in "XYZ": if axis in by_letter: values[axis] = by_letter[axis][-1] * scale if distance_mode == 90: x = values.get("X", x) y = values.get("Y", y) z = values.get("Z", z) else: x += values.get("X", 0.0) y += values.get("Y", 0.0) z += values.get("Z", 0.0) records.append( Record( line_number, motion, initial, (x, y, z), active_tool, spindle_on, spindle, feed, wcs, length_comp, h_offset, ) ) if not saw_m30: raise EvaluationError("M30 is required") return Program(records, cycle_events, saw_m30) def near_hole(x: float, y: float, hole: Hole) -> bool: return math.hypot(x - hole.x, y - hole.y) <= XY_TOL_MM def pure_vertical(record: Record) -> bool: return ( math.hypot(record.end[0] - record.start[0], record.end[1] - record.start[1]) <= 0.05 ) def explicit_events(program: Program) -> list[DrillEvent]: events: list[DrillEvent] = [] approach_z: float | None = None plunge: Record | None = None plunge_approach_z: float | None = None def emit(retract_z: float | None) -> None: nonlocal plunge, plunge_approach_z if plunge is None: return events.append( DrillEvent( plunge.line, plunge.end[0], plunge.end[1], plunge.end[2], plunge_approach_z if plunge_approach_z is not None else plunge.start[2], retract_z, plunge.tool, plunge.spindle_on, plunge.spindle, plunge.feed, plunge.wcs, plunge.length_comp, plunge.h_offset, "explicit", ) ) plunge = None plunge_approach_z = None for record in program.records: if plunge is not None: same_xy = math.hypot(record.end[0] - plunge.end[0], record.end[1] - plunge.end[1]) <= 0.05 if record.motion == 0 and same_xy and record.end[2] > plunge.end[2] + 0.5: emit(record.end[2]) approach_z = record.end[2] continue if ( record.motion in (1, 2, 3) and pure_vertical(record) and same_xy and record.end[2] < plunge.end[2] - 0.05 ): plunge = record continue if not same_xy: emit(None) if record.motion == 0: approach_z = record.end[2] elif ( record.motion in (1, 2, 3) and pure_vertical(record) and record.end[2] < record.start[2] - 0.05 ): plunge = record plunge_approach_z = approach_z if approach_z is not None else record.start[2] if plunge is not None: emit(None) return events def state_is_valid(event: DrillEvent) -> bool: return ( event.tool is not None and event.tool > 0 and event.spindle_on and event.spindle is not None and event.spindle > 0 and event.feed is not None and event.feed > 0 and event.wcs is not None and event.length_comp and event.h_offset is not None and event.h_offset > 0 ) def choose_coordinate_frame(events: Iterable[DrillEvent]) -> tuple[float, dict[Hole, DrillEvent]]: event_list = list(events) valid_frames: list[tuple[float, dict[Hole, DrillEvent]]] = [] for top_z in (0.0, 12.0): selected: dict[Hole, DrillEvent] = {} frame_ok = True for hole in HOLES: matching = [event for event in event_list if near_hole(event.x, event.y, hole)] expected_bottom = top_z - hole.depth deepest_allowed = expected_bottom - ( THROUGH_TIP_COMP_MAX_MM if hole.kind == "through" else DEPTH_TOL_MM ) shallowest_allowed = expected_bottom + DEPTH_TOL_MM final = [ event for event in matching if deepest_allowed <= event.bottom_z <= shallowest_allowed ] if len(final) != 1: frame_ok = False break if any(event.bottom_z < deepest_allowed for event in matching): frame_ok = False break selected[hole] = final[0] if frame_ok: valid_frames.append((top_z, selected)) if len(valid_frames) != 1: raise EvaluationError("hole depths do not match exactly one supported WCS frame") return valid_frames[0] def validate_program(program: Program) -> dict[str, object]: events = [*program.cycle_events, *explicit_events(program)] if not events: raise EvaluationError("no drilling operations found") for event in events: if not any(near_hole(event.x, event.y, hole) for hole in HOLES): raise EvaluationError(f"unexpected drilling location near line {event.line}") top_z, selected = choose_coordinate_frame(events) diameter_tools: dict[float, set[int]] = {5.0: set(), 6.0: set()} for hole, event in selected.items(): if not state_is_valid(event): raise EvaluationError(f"invalid machining state for hole ({hole.x:g},{hole.y:g})") if event.approach_z is None or event.approach_z < top_z + SAFE_CLEARANCE_MM: raise EvaluationError(f"unsafe approach for hole ({hole.x:g},{hole.y:g})") if event.retract_z is None or event.retract_z < top_z + SAFE_CLEARANCE_MM: raise EvaluationError(f"unsafe retract for hole ({hole.x:g},{hole.y:g})") diameter_tools[hole.diameter].add(int(event.tool)) if any(len(tools) != 1 for tools in diameter_tools.values()): raise EvaluationError("each diameter group must use one consistent final drilling tool") if diameter_tools[5.0] == diameter_tools[6.0]: raise EvaluationError("5 mm and 6 mm holes require distinct final drilling tools") return { "coordinate_frame_top_z_mm": top_z, "hole_count": len(selected), "diameter_tools": {str(key): sorted(value) for key, value in diameter_tools.items()}, "methods": sorted({event.method for event in selected.values()}), } def validate_outputs(target: Path) -> tuple[Program, dict[str, object]]: path = target / NC_NAME if not path.is_file() or path.stat().st_size < 80: raise EvaluationError(f"missing or empty {NC_NAME}") source = path.read_text(encoding="utf-8", errors="strict") program = parse_program(source) summary = validate_program(program) return program, summary def is_relative_to(path: Path, parent: Path) -> bool: try: path.relative_to(parent) return True except ValueError: return False def load_trusted_provenance(target: Path, path: Path | None, expected_hash: str | None) -> dict[str, object]: if path is None or expected_hash is None: raise EvaluationError("trusted provenance path and hash must be injected by the evaluator host") resolved = path.resolve(strict=True) target_resolved = target.resolve() writable_root = target_resolved for candidate in (target_resolved, *target_resolved.parents): if candidate.name.casefold() == "desktop": writable_root = candidate break if is_relative_to(resolved, writable_root): raise EvaluationError("provenance may not be read from the agent-writable target directory") if not re.fullmatch(r"[0-9A-Fa-f]{64}", expected_hash): raise EvaluationError("trusted provenance hash pin is malformed") if sha256_file(resolved) != expected_hash.upper(): raise EvaluationError("trusted provenance file is absent or not host-pinned") data = json.loads(resolved.read_text(encoding="utf-8")) if not isinstance(data, dict): raise EvaluationError("trusted provenance must be a JSON object") return data def expect_number(value: object, label: str) -> float: if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(float(value)): raise EvaluationError(f"{label} must be a finite number") return float(value) def validate_provenance( data: dict[str, object], target: Path, expected_run_id: str, nc_summary: dict[str, object], ) -> None: if data.get("schema") != "engiworld.trusted-cam-run.v1": raise EvaluationError("wrong provenance schema") if data.get("run_id") != expected_run_id: raise EvaluationError("provenance belongs to a stale or different evaluator run") if data.get("authority") != "evaluator-host-monitor" or data.get("immutable") is not True: raise EvaluationError("provenance is not trusted host evidence") product = data.get("product") if not isinstance(product, dict): raise EvaluationError("missing native product evidence") if str(product.get("name", "")).upper() != "SOLIDWORKS CAM" or int(product.get("major", 0)) != 2025: raise EvaluationError("native product must be SOLIDWORKS CAM 2025") if product.get("progid") != "SWCAM.CWApp" or product.get("addin_loaded") is not True: raise EvaluationError("SOLIDWORKS CAM add-in identity was not captured") inputs = data.get("formal_inputs") if not isinstance(inputs, dict): raise EvaluationError("missing formal input hashes") for name, expected in FORMAL_INPUT_SHA256.items(): if str(inputs.get(name, "")).upper() != expected: raise EvaluationError(f"wrong formal input hash for {name}") output = data.get("output") if not isinstance(output, dict) or output.get("name") != NC_NAME: raise EvaluationError("missing posted output evidence") if str(output.get("sha256", "")).upper() != sha256_file(target / NC_NAME): raise EvaluationError("posted output hash mismatch") if int(output.get("bytes", 0)) != (target / NC_NAME).stat().st_size: raise EvaluationError("posted output size mismatch") setup = data.get("setup") if not isinstance(setup, dict): raise EvaluationError("missing CAM setup evidence") origin = setup.get("cad_origin_mm") if origin != [0.0, 0.0, 12.0] or setup.get("tool_axis") != "-Z" or setup.get("work_offset") != "G54": raise EvaluationError("wrong CAM setup transform") post = data.get("postprocess") if not isinstance(post, dict) or post.get("return_code") != 0: raise EvaluationError("native postprocess did not succeed") if not str(post.get("postprocessor", "")).lower().endswith(".ctl"): raise EvaluationError("native .ctl postprocessor was not captured") if not re.fullmatch(r"[0-9A-Fa-f]{64}", str(post.get("postprocessor_sha256", ""))): raise EvaluationError("postprocessor hash is missing") operations = data.get("operations") if not isinstance(operations, list) or len(operations) != len(HOLES): raise EvaluationError("native operation evidence must cover ten holes") summary_tools = nc_summary.get("diameter_tools") if not isinstance(summary_tools, dict): raise EvaluationError("NC tool-group summary is missing") for hole in HOLES: matches = [ item for item in operations if isinstance(item, dict) and close(expect_number(item.get("x_mm"), "operation x"), hole.x, XY_TOL_MM) and close(expect_number(item.get("y_mm"), "operation y"), hole.y, XY_TOL_MM) ] if len(matches) != 1: raise EvaluationError(f"native operation evidence is ambiguous for ({hole.x:g},{hole.y:g})") item = matches[0] if not close(expect_number(item.get("diameter_mm"), "operation diameter"), hole.diameter, 0.05): raise EvaluationError("native operation diameter mismatch") if not close(expect_number(item.get("depth_mm"), "operation depth"), hole.depth, DEPTH_TOL_MM): raise EvaluationError("native operation depth mismatch") if item.get("kind") != hole.kind or item.get("toolpath_generated") is not True: raise EvaluationError("native operation lifecycle evidence is incomplete") if int(item.get("tool_station", 0)) <= 0 or int(item.get("segment_count", 0)) <= 0: raise EvaluationError("native tool or toolpath segment evidence is missing") expected_stations = summary_tools.get(str(hole.diameter)) if expected_stations != [int(item.get("tool_station", 0))]: raise EvaluationError("native operation tool station does not match the posted NC") simulation = data.get("simulation") if not isinstance(simulation, dict) or simulation.get("completed") is not True: raise EvaluationError("native simulation was not completed") if simulation.get("collision_free") is not True or simulation.get("all_holes_verified") is not True: raise EvaluationError("native simulation did not verify the requested result") def evaluate( target: Path, provenance_path: Path | None = None, provenance_sha256: str | None = None, expected_run_id: str | None = None, ) -> bool: _program, nc_summary = validate_outputs(target) if expected_run_id is None: expected_run_id = os.environ.get("ENGIWORLD_TRUSTED_RUN_ID") if not expected_run_id or not RUN_ID_RE.fullmatch(expected_run_id): raise EvaluationError("trusted run id was not injected by the evaluator host") provenance = load_trusted_provenance(target, provenance_path, provenance_sha256) validate_provenance(provenance, target, expected_run_id, nc_summary) return True def main() -> bool: try: _program, nc_summary = validate_outputs(DEFAULT_TARGET) provenance_path = os.environ.get("ENGIWORLD_TRUSTED_PROVENANCE") provenance_sha256 = os.environ.get("ENGIWORLD_TRUSTED_PROVENANCE_SHA256") expected_run_id = os.environ.get("ENGIWORLD_TRUSTED_RUN_ID") supplied = [provenance_path, provenance_sha256, expected_run_id] if any(supplied) and not all(supplied): raise EvaluationError("trusted provenance injection is incomplete") if all(supplied): if not RUN_ID_RE.fullmatch(str(expected_run_id)): raise EvaluationError("trusted run id is malformed") provenance = load_trusted_provenance( DEFAULT_TARGET, Path(str(provenance_path)), str(provenance_sha256) ) validate_provenance(provenance, DEFAULT_TARGET, str(expected_run_id), nc_summary) return True except Exception: return False if __name__ == "__main__": print("True" if main() else "False") raise SystemExit(0)