| from __future__ import annotations |
|
|
| import hashlib |
| import math |
| import os |
| import re |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
|
|
| TARGET = Path(os.environ.get("EVAL_TARGET_DIR", r"C:\Users\User\Desktop")) |
| NC_NAME = "task-16_B.nc" |
| FORMAL_INPUT_SHA256 = { |
| "revision_A.step": "DAECF5831BDF01B09ED6A70451FECD392DF71E713BFBFCCA394AB38DE8FFBFCF", |
| "revision_B.step": "311AE1C5C1DCDC072F6FFE14A156538CD6437BA83D8C9993991C965998F64F96", |
| "tools.csv": "9D72E8222EC38E3D7CBC5CB1DF6DCCB9DB3E847B8040BC5B4C83D17116CE0D96", |
| } |
| TOOLS = { |
| 1: {"diameter": 8.0, "spindle": 8000.0, "feed": 500.0}, |
| 2: {"diameter": 5.0, "spindle": 5000.0, "feed": 180.0}, |
| } |
| B_HOLES = ((-30.0, -15.0), (30.0, 15.0)) |
| WORD_RE = re.compile(r"([A-Z])\s*([-+]?(?:\d+(?:\.\d*)?|\.\d+))") |
| 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} |
| STATE_TOL = 1.0 |
| DEPTH_TOL = 0.35 |
| MAX_BYTES = 1_000_000 |
| MAX_LINES = 12_000 |
| MAX_WORDS_PER_LINE = 40 |
| MAX_SEGMENTS = 20_000 |
| MAX_SAMPLES = 250_000 |
|
|
|
|
| class EvaluationError(ValueError): |
| pass |
|
|
|
|
| @dataclass(frozen=True) |
| class Point: |
| x: float |
| y: float |
| z: float |
|
|
|
|
| @dataclass |
| class Segment: |
| start: Point |
| end: Point |
| samples: list[Point] |
| motion: int |
| tool: int | None |
| spindle_on: bool |
| spindle: float | None |
| feed: float | None |
| wcs: str | None |
| length_comp: bool |
| h_offset: int | None |
| line: int |
|
|
|
|
| @dataclass |
| class DrillEvent: |
| 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 |
| line: int |
|
|
|
|
| @dataclass |
| class Program: |
| segments: list[Segment] |
| cycles: list[DrillEvent] |
| tool_changes: list[int] |
| saw_m30: bool |
|
|
|
|
| def close(actual: float, expected: float, tolerance: float) -> bool: |
| return abs(actual - expected) <= tolerance |
|
|
|
|
| def sha256(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 comments(source: str) -> list[str]: |
| result: list[str] = [] |
| depth = 0 |
| buffer: list[str] = [] |
| for line_number, raw in enumerate(source.upper().splitlines(), 1): |
| index = 0 |
| while index < len(raw): |
| char = raw[index] |
| if char == ";" and depth == 0: |
| result.append(raw[index + 1 :]) |
| break |
| if char == "(": |
| if depth == 0: |
| buffer = [] |
| depth += 1 |
| if depth > 8: |
| raise EvaluationError("excessive nested comment") |
| elif char == ")": |
| if depth == 0: |
| raise EvaluationError(f"unmatched comment close on line {line_number}") |
| depth -= 1 |
| if depth == 0: |
| result.append("".join(buffer)) |
| buffer = [] |
| elif depth: |
| buffer.append(char) |
| index += 1 |
| if depth: |
| raise EvaluationError("unterminated parenthesized comment") |
| return result |
|
|
|
|
| def executable_lines(source: str) -> list[tuple[int, str]]: |
| result: list[tuple[int, str]] = [] |
| depth = 0 |
| for line_number, raw in enumerate(source.upper().splitlines(), 1): |
| clean: list[str] = [] |
| 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: |
| clean.append(char) |
| result.append((line_number, "".join(clean).strip())) |
| if depth: |
| raise EvaluationError("unterminated parenthesized comment") |
| return result |
|
|
|
|
| def words(code: str, line: int) -> list[tuple[str, float]]: |
| if not code or code == "%": |
| return [] |
| if code.startswith("/"): |
| raise EvaluationError(f"block-delete code is not deterministic on line {line}") |
| matches = list(WORD_RE.finditer(code)) |
| if len(matches) > MAX_WORDS_PER_LINE: |
| raise EvaluationError(f"too many words on line {line}") |
| residue = WORD_RE.sub(" ", code) |
| if residue.strip(): |
| raise EvaluationError(f"unknown executable text on line {line}: {residue.strip()!r}") |
| result = [(match.group(1), float(match.group(2))) for match in matches] |
| if any(not math.isfinite(value) or abs(value) > 10_000_000 for _, value in result): |
| raise EvaluationError(f"non-finite or excessive numeric word on line {line}") |
| return result |
|
|
|
|
| def exact_int(value: float, label: str, line: int) -> int: |
| rounded = round(value) |
| if not close(value, rounded, 1e-8): |
| raise EvaluationError(f"fractional {label} on line {line}") |
| return int(rounded) |
|
|
|
|
| def line_samples(start: Point, end: Point, spacing: float = 0.5) -> list[Point]: |
| length = math.dist((start.x, start.y, start.z), (end.x, end.y, end.z)) |
| if not math.isfinite(length) or length > 1000.0: |
| raise EvaluationError("invalid or excessive line length") |
| count = max(1, int(math.ceil(length / spacing))) |
| return [Point(start.x + (end.x - start.x) * i / count, start.y + (end.y - start.y) * i / count, start.z + (end.z - start.z) * i / count) for i in range(count + 1)] |
|
|
|
|
| def directed_sweep(start: float, end: float, clockwise: bool) -> float: |
| sweep = (start - end) % (2 * math.pi) if clockwise else (end - start) % (2 * math.pi) |
| return sweep if sweep > 1e-9 else 2 * math.pi |
|
|
|
|
| def arc_samples(start: Point, end: Point, grouped: dict[str, list[float]], scale: float, clockwise: bool) -> list[Point]: |
| if "I" in grouped or "J" in grouped: |
| cx = start.x + grouped.get("I", [0.0])[-1] * scale |
| cy = start.y + grouped.get("J", [0.0])[-1] * scale |
| radius = math.hypot(start.x - cx, start.y - cy) |
| if radius <= 1e-6 or radius > 500.0 or not close(math.hypot(end.x - cx, end.y - cy), radius, 0.2): |
| raise EvaluationError("invalid I/J arc") |
| a0 = math.atan2(start.y - cy, start.x - cx) |
| a1 = math.atan2(end.y - cy, end.x - cx) |
| sweep = directed_sweep(a0, a1, clockwise) |
| elif "R" in grouped: |
| dx, dy = end.x - start.x, end.y - start.y |
| chord = math.hypot(dx, dy) |
| signed_radius = grouped["R"][-1] * scale |
| radius = abs(signed_radius) |
| if chord <= 1e-9 or radius > 500.0 or chord > 2 * radius + 0.2: |
| raise EvaluationError("invalid R arc") |
| mx, my = (start.x + end.x) / 2, (start.y + end.y) / 2 |
| height = math.sqrt(max(radius * radius - (chord / 2) ** 2, 0.0)) |
| nx, ny = -dy / chord, dx / chord |
| candidates = [] |
| for cx0, cy0 in ((mx + nx * height, my + ny * height), (mx - nx * height, my - ny * height)): |
| aa0 = math.atan2(start.y - cy0, start.x - cx0) |
| aa1 = math.atan2(end.y - cy0, end.x - cx0) |
| candidates.append((directed_sweep(aa0, aa1, clockwise), cx0, cy0, aa0)) |
| sweep, cx, cy, a0 = (min if signed_radius >= 0 else max)(candidates, key=lambda item: item[0]) |
| else: |
| raise EvaluationError("G2/G3 requires I/J or R") |
| count = max(8, int(math.ceil(radius * sweep / 0.35))) |
| sign = -1.0 if clockwise else 1.0 |
| return [Point(cx + radius * math.cos(a0 + sign * sweep * i / count), cy + radius * math.sin(a0 + sign * sweep * i / count), start.z + (end.z - start.z) * i / count) for i in range(count + 1)] |
|
|
|
|
| def parse_program(source: str) -> Program: |
| units: float | None = None |
| absolute: bool | None = None |
| motion: int | None = None |
| current = Point(0.0, 0.0, 0.0) |
| position_known = True |
| pending_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 |
| cycle: int | None = None |
| cycle_z: float | None = None |
| cycle_r: float | None = None |
| cycle_q: float | None = None |
| retract_mode = 98 |
| terminated = False |
| segments: list[Segment] = [] |
| cycles: list[DrillEvent] = [] |
| tool_changes: list[int] = [] |
| sample_count = 0 |
|
|
| for line_number, code in executable_lines(source): |
| parsed = words(code, line_number) |
| if not parsed: |
| continue |
| if terminated: |
| raise EvaluationError(f"executable code after M30 on line {line_number}") |
| grouped: dict[str, list[float]] = {} |
| for letter, value in parsed: |
| grouped.setdefault(letter, []).append(value) |
| if any(letter not in "NGMTSFXYZIJRQHDPO" for letter in grouped): |
| raise EvaluationError(f"unsupported word on line {line_number}") |
| for letter in "NXYZIJRQHDSTPO": |
| if len(grouped.get(letter, [])) > 1: |
| raise EvaluationError(f"duplicate {letter} on line {line_number}") |
| if "N" in grouped: |
| exact_int(grouped["N"][0], "N", line_number) |
| if "O" in grouped and exact_int(grouped["O"][0], "O", line_number) <= 0: |
| raise EvaluationError(f"invalid O number on line {line_number}") |
| gcodes = grouped.get("G", []) |
| mcodes = [exact_int(value, "M", line_number) for value in grouped.get("M", [])] |
| if any(not any(close(code_value, allowed, 1e-7) for allowed in ALLOWED_G) for code_value in gcodes): |
| raise EvaluationError(f"unsupported G code on line {line_number}") |
| if any(code_value not in ALLOWED_M for code_value in mcodes): |
| raise EvaluationError(f"unsupported M code on line {line_number}") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (20.0, 21.0)) > 1: |
| raise EvaluationError("conflicting unit modes") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (90.0, 91.0)) > 1: |
| raise EvaluationError("conflicting distance modes") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (0.0, 1.0, 2.0, 3.0)) > 1: |
| raise EvaluationError("conflicting motion modes") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (80.0, 81.0, 82.0, 83.0)) > 1: |
| raise EvaluationError("conflicting canned-cycle modes") |
| if sum(any(close(code_value, mode, 1e-7) for code_value in gcodes) for mode in (98.0, 99.0)) > 1: |
| raise EvaluationError("conflicting retract modes") |
| if 30 in mcodes: |
| if set(grouped) - {"N", "M"} or mcodes != [30]: |
| raise EvaluationError("M30 block contains hidden executable words") |
| terminated = True |
| continue |
|
|
| g28 = any(close(code_value, 28.0, 1e-7) for code_value in gcodes) |
| g53 = any(close(code_value, 53.0, 1e-7) for code_value in gcodes) |
| if g28: |
| if any(any(close(code_value, mode, 1e-7) for mode in (0, 1, 2, 3, 81, 82, 83)) for code_value in gcodes): |
| raise EvaluationError("G28 cannot hide cutting motion") |
| if any(abs(value) > 1e-8 for letter in "XYZ" for value in grouped.get(letter, [])): |
| raise EvaluationError("only zero-intermediate G28 is accepted") |
|
|
| for code_value in gcodes: |
| if close(code_value, 20.0, 1e-7): units = 25.4 |
| elif close(code_value, 21.0, 1e-7): units = 1.0 |
| elif close(code_value, 90.0, 1e-7): absolute = True |
| elif close(code_value, 91.0, 1e-7): absolute = False |
| elif any(close(code_value, mode, 1e-7) for mode in (0, 1, 2, 3)): |
| motion = int(round(code_value)); cycle = None |
| elif any(close(code_value, mode, 1e-7) for mode in (81, 82, 83)): |
| cycle = int(round(code_value)) |
| elif close(code_value, 80.0, 1e-7): cycle = None |
| elif close(code_value, 98.0, 1e-7): retract_mode = 98 |
| elif close(code_value, 99.0, 1e-7): retract_mode = 99 |
| elif close(code_value, 43.0, 1e-7): length_comp = True |
| elif close(code_value, 49.0, 1e-7): length_comp = False; h_offset = None |
| elif any(close(code_value, value, 1e-7) for value in (54, 55, 56, 57, 58, 59)): wcs = f"G{int(round(code_value))}" |
| elif close(code_value, 54.1, 1e-7): |
| p_value = grouped.get("P", [None])[-1] |
| if p_value is None or exact_int(p_value, "P", line_number) <= 0: |
| raise EvaluationError("G54.1 requires positive P") |
| wcs = f"G54.1 P{exact_int(p_value, 'P', line_number)}" |
|
|
| if g28 and absolute is not False: |
| raise EvaluationError("G28 requires G91 zero-intermediate return") |
| arc_mode = cycle is None and motion in (2, 3) |
| if ("I" in grouped or "J" in grouped) and not arc_mode: |
| raise EvaluationError("I/J is valid only for G2/G3") |
| if "R" in grouped and cycle is None and not arc_mode: |
| raise EvaluationError("R is valid only for G2/G3 or a canned cycle") |
| if "Q" in grouped and cycle != 83: |
| raise EvaluationError("Q is valid only for G83") |
| if "P" in grouped and not any(close(code_value, 54.1, 1e-7) for code_value in gcodes): |
| raise EvaluationError("P is valid only with G54.1") |
| if "D" in grouped: |
| raise EvaluationError("D offset is unsupported without cutter compensation") |
|
|
| if "T" in grouped: |
| pending_tool = exact_int(grouped["T"][-1], "T", line_number) |
| if pending_tool not in TOOLS: |
| raise EvaluationError(f"unexpected tool T{pending_tool}") |
| if 6 in mcodes: |
| if pending_tool is None: |
| raise EvaluationError("M6 without T") |
| active_tool = pending_tool |
| tool_changes.append(active_tool) |
| spindle_on = False |
| length_comp = False |
| h_offset = None |
| if "S" in grouped: |
| spindle = grouped["S"][-1] |
| if spindle <= 0: |
| raise EvaluationError("spindle speed must be positive") |
| if 3 in mcodes or 4 in mcodes: |
| spindle_on = True |
| if 5 in mcodes: |
| spindle_on = False |
| if "F" in grouped: |
| if units is None: |
| raise EvaluationError("feed before units") |
| feed = grouped["F"][-1] * units |
| if feed <= 0: |
| raise EvaluationError("feed must be positive") |
| if "H" in grouped: |
| h_offset = exact_int(grouped["H"][-1], "H", line_number) |
| if h_offset <= 0: |
| raise EvaluationError("H must be positive") |
|
|
| axes = any(letter in grouped for letter in "XYZ") |
| if not axes: |
| continue |
| if units is None or absolute is None: |
| raise EvaluationError("axis motion before units and distance mode") |
| if g28: |
| if "Z" in grouped: |
| position_known = False |
| continue |
| if g53: |
| if motion not in (0, None) or cycle is not None: |
| raise EvaluationError("G53 is allowed only for non-cutting machine motion") |
| if "Z" in grouped: |
| position_known = False |
| continue |
|
|
| scale = units |
| if cycle is not None: |
| if not absolute: |
| raise EvaluationError("canned cycles require G90") |
| if "Z" in grouped: cycle_z = grouped["Z"][-1] * scale |
| if "R" in grouped: cycle_r = grouped["R"][-1] * scale |
| if "Q" in grouped: cycle_q = grouped["Q"][-1] * scale |
| x_value = grouped.get("X", [current.x / scale])[-1] * scale |
| y_value = grouped.get("Y", [current.y / scale])[-1] * scale |
| launches = any(any(close(code_value, mode, 1e-7) for mode in (81, 82, 83)) for code_value in gcodes) or "X" in grouped or "Y" in grouped |
| if launches: |
| if cycle_z is None or cycle_r is None: |
| raise EvaluationError("incomplete canned cycle") |
| if cycle == 83 and (cycle_q is None or cycle_q <= 0): |
| raise EvaluationError("G83 requires positive Q") |
| retract_z = max(current.z, cycle_r) if retract_mode == 98 else cycle_r |
| cycles.append(DrillEvent(x_value, y_value, cycle_z, current.z, retract_z, active_tool, spindle_on, spindle, feed, wcs, length_comp, h_offset, line_number)) |
| if len(cycles) > MAX_SEGMENTS: |
| raise EvaluationError("canned-cycle event limit exceeded") |
| current = Point(x_value, y_value, retract_z) |
| position_known = True |
| continue |
| if motion is None: |
| raise EvaluationError("axis words before explicit motion mode") |
|
|
| def axis(letter: str, old: float) -> float: |
| if letter not in grouped: |
| return old |
| value = grouped[letter][-1] * scale |
| return value if absolute else old + value |
|
|
| end = Point(axis("X", current.x), axis("Y", current.y), axis("Z", current.z)) |
| if not position_known: |
| current = end |
| if "Z" in grouped: |
| position_known = True |
| continue |
| samples = line_samples(current, end) if motion in (0, 1) else arc_samples(current, end, grouped, scale, motion == 2) |
| segments.append(Segment(current, end, samples, motion, active_tool, spindle_on, spindle, feed, wcs, length_comp, h_offset, line_number)) |
| sample_count += len(samples) |
| if len(segments) > MAX_SEGMENTS or sample_count > MAX_SAMPLES: |
| raise EvaluationError("toolpath sampling resource limit exceeded") |
| current = end |
|
|
| if not terminated: |
| raise EvaluationError("M30 is required") |
| return Program(segments, cycles, tool_changes, True) |
|
|
|
|
| def explicit_drills(program: Program) -> list[DrillEvent]: |
| events: list[DrillEvent] = [] |
| plunge: Segment | None = None |
| approach: float | None = None |
|
|
| def finish(retract: float | None) -> None: |
| nonlocal plunge |
| if plunge is None: |
| return |
| events.append(DrillEvent(plunge.end.x, plunge.end.y, plunge.end.z, approach if approach is not None else plunge.start.z, retract, plunge.tool, plunge.spindle_on, plunge.spindle, plunge.feed, plunge.wcs, plunge.length_comp, plunge.h_offset, plunge.line)) |
| plunge = None |
|
|
| for segment in program.segments: |
| if plunge is not None: |
| same_axis = math.hypot(segment.end.x - plunge.end.x, segment.end.y - plunge.end.y) <= 0.05 |
| if segment.motion == 0 and same_axis and segment.end.z > plunge.end.z + 0.5: |
| finish(segment.end.z) |
| approach = segment.end.z |
| continue |
| if segment.motion == 1 and same_axis and segment.end.z < plunge.end.z - 0.05: |
| plunge = segment |
| continue |
| if not same_axis: |
| finish(None) |
| if segment.motion == 0: |
| approach = segment.end.z |
| elif segment.motion == 1 and math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) <= 0.05 and segment.end.z < segment.start.z - 0.05: |
| plunge = segment |
| finish(None) |
| return events |
|
|
|
|
| def cutting_state(segment: Segment, tool: int) -> None: |
| contract = TOOLS[tool] |
| if segment.tool != tool or not segment.spindle_on or segment.spindle is None or not close(segment.spindle, contract["spindle"], STATE_TOL): |
| raise EvaluationError(f"T{tool} cutting has the wrong spindle state") |
| if segment.feed is None or segment.feed <= 0 or segment.wcs is None or not segment.length_comp or segment.h_offset != tool: |
| raise EvaluationError(f"T{tool} cutting lacks feed/WCS/matching H offset") |
| xy_length = math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) |
| if xy_length > 0.1 and not close(segment.feed, contract["feed"], STATE_TOL): |
| raise EvaluationError(f"T{tool} XY cutting uses the wrong feed") |
| if xy_length <= 0.1 and segment.feed > contract["feed"] + STATE_TOL: |
| raise EvaluationError(f"T{tool} plunge feed exceeds the supplied feed") |
|
|
|
|
| def drill_state(event: DrillEvent) -> None: |
| contract = TOOLS[2] |
| if event.tool != 2 or not event.spindle_on or event.spindle is None or not close(event.spindle, contract["spindle"], STATE_TOL): |
| raise EvaluationError("T2 drill has the wrong spindle state") |
| if event.feed is None or not close(event.feed, contract["feed"], STATE_TOL) or event.wcs is None or not event.length_comp or event.h_offset != 2: |
| raise EvaluationError("T2 drill lacks the supplied feed/WCS/H2") |
|
|
|
|
| def validate_frame(program: Program, top_z: float, floor_z: float, bottom_z: float) -> dict[str, float | int]: |
| t1_cutting = [segment for segment in program.segments if segment.tool == 1 and segment.motion in (1, 2, 3) and min(segment.start.z, segment.end.z) < top_z - 0.1] |
| if not t1_cutting: |
| raise EvaluationError("missing revision_B pocket cutting") |
| floor_points: list[Point] = [] |
| for segment in t1_cutting: |
| cutting_state(segment, 1) |
| for point in segment.samples: |
| if point.z >= top_z - 0.1: |
| continue |
| if point.z < floor_z - DEPTH_TOL or abs(point.x) > 20.35 or abs(point.y) > 10.35: |
| raise EvaluationError("T1 cuts outside or below the revision_B pocket") |
| if abs(point.z - floor_z) <= DEPTH_TOL: |
| floor_points.append(point) |
| if len(floor_points) < 80: |
| raise EvaluationError("revision_B pocket has too little full-depth cutting") |
| targets = [(float(x), float(y)) for x in range(-24, 25) for y in range(-14, 15)] |
| radius = TOOLS[1]["diameter"] / 2 + 0.4 |
| covered = sum(any(math.hypot(point.x - x, point.y - y) <= radius for point in floor_points) for x, y in targets) |
| coverage = covered / len(targets) |
| if coverage < 0.983: |
| raise EvaluationError("revision_B pocket floor is undercovered") |
|
|
| drill_events = [event for event in [*program.cycles, *explicit_drills(program)] if event.tool == 2] |
| if len(drill_events) != 2: |
| raise EvaluationError("revision_B requires exactly two T2 drilling events") |
| for event in drill_events: |
| drill_state(event) |
| if not any(math.hypot(event.x - x, event.y - y) <= 0.35 for x, y in B_HOLES): |
| raise EvaluationError("revision_A or unexpected hole was drilled") |
| if not (bottom_z - 4.0 <= event.bottom_z <= bottom_z + DEPTH_TOL): |
| raise EvaluationError("T2 drilling is not a bounded through cut") |
| if event.approach_z is None or event.approach_z < top_z + 1.0 or event.retract_z is None or event.retract_z < top_z + 1.0: |
| raise EvaluationError("unsafe T2 approach/retract") |
| for hole in B_HOLES: |
| if sum(math.hypot(event.x - hole[0], event.y - hole[1]) <= 0.35 for event in drill_events) != 1: |
| raise EvaluationError("missing or duplicate revision_B hole") |
|
|
| for segment in program.segments: |
| xy_length = math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) |
| if segment.tool == 2 and segment.motion in (1, 2, 3) and min(segment.start.z, segment.end.z) < top_z - 0.1 and xy_length > 0.1: |
| raise EvaluationError("T2 performs lateral subsurface cutting") |
| if segment.tool in (1, 2) and segment.motion == 0: |
| if xy_length > 0.1 and min(segment.start.z, segment.end.z) < top_z + 1.0: |
| raise EvaluationError("unsafe low lateral rapid") |
| if segment.end.z < segment.start.z and segment.end.z <= floor_z + DEPTH_TOL: |
| raise EvaluationError("rapid plunge reaches the final pocket floor") |
|
|
| first_t1 = min(segment.line for segment in t1_cutting) |
| last_t1 = max(segment.line for segment in t1_cutting) |
| if t1_cutting[0].start.z < top_z + 1.0: |
| raise EvaluationError("T1 has no safe initial approach") |
| if not any(segment.tool == 1 and segment.motion == 0 and segment.line > last_t1 and max(segment.start.z, segment.end.z) >= top_z + 1.0 for segment in program.segments): |
| raise EvaluationError("T1 has no safe final retract") |
| return {"top_z_mm": top_z, "floor_z_mm": floor_z, "bottom_z_mm": bottom_z, "pocket_coverage": round(coverage, 6), "floor_samples": len(floor_points), "first_t1_line": first_t1} |
|
|
|
|
| def validate_source(source: str) -> dict[str, float | int]: |
| if len(source.encode("utf-8")) > MAX_BYTES or len(source.splitlines()) > MAX_LINES: |
| raise EvaluationError("NC file exceeds evaluator resource limits") |
| if not any(re.search(r"\bREVISION_B\b", value) for value in comments(source)): |
| raise EvaluationError("REVISION_B must be present in a legal post comment") |
| program = parse_program(source) |
| if program.tool_changes != [1, 2]: |
| raise EvaluationError("tool changes must be exactly T1 then T2") |
| valid = [] |
| for frame in ((0.0, -9.0, -16.0), (16.0, 7.0, 0.0)): |
| try: |
| valid.append(validate_frame(program, *frame)) |
| except EvaluationError: |
| pass |
| if len(valid) != 1: |
| raise EvaluationError("program does not match exactly one supported revision_B Z frame") |
| return valid[0] |
|
|
|
|
| def evaluate_text(source: str) -> bool: |
| try: |
| validate_source(source) |
| return True |
| except (EvaluationError, ValueError, OverflowError, MemoryError): |
| return False |
|
|
|
|
| def validate_outputs(target: Path) -> dict[str, float | int]: |
| for name, expected in FORMAL_INPUT_SHA256.items(): |
| path = target / name |
| if not path.is_file() or sha256(path) != expected: |
| raise EvaluationError(f"formal input hash mismatch: {name}") |
| nc_path = target / NC_NAME |
| if not nc_path.is_file() or nc_path.stat().st_size < 200 or nc_path.stat().st_size > MAX_BYTES: |
| raise EvaluationError(f"missing or empty {NC_NAME}") |
| for path in target.iterdir(): |
| if path.is_file() and path.suffix.casefold() in {".nc", ".tap", ".gcode"} and re.search(r"(?:TASK[-_]?16|REVISION)[-_]?A(?:\.|[-_])", path.name, re.I): |
| raise EvaluationError("revision_A posted output is forbidden") |
| return validate_source(nc_path.read_text(encoding="utf-8", errors="strict")) |
|
|
|
|
| def main() -> bool: |
| try: |
| validate_outputs(TARGET) |
| return True |
| except Exception: |
| return False |
|
|
|
|
| if __name__ == "__main__": |
| print("True" if main() else "False") |
| raise SystemExit(0) |
|
|
