from __future__ import annotations 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")) CONTRACTS = { "variant_01.nc": {"size": (34.0, 16.0), "bottom": -10.5, "diameter": 7.0, "program": 2701}, "variant_02.nc": {"size": (38.0, 18.0), "bottom": -11.0, "diameter": 8.0, "program": 2702}, "variant_03.nc": {"size": (42.0, 20.0), "bottom": -11.5, "diameter": 9.0, "program": 2703}, "variant_04.nc": {"size": (46.0, 22.0), "bottom": -12.0, "diameter": 10.0, "program": 2704}, "variant_05.nc": {"size": (50.0, 24.0), "bottom": -12.5, "diameter": 11.0, "program": 2705}, } MAX_FILE_BYTES = 2_000_000 MAX_BLOCKS = 50_000 MAX_PATH_SEGMENTS = 200_000 SURFACE_TOL = 0.01 DEPTH_TOL = 0.08 FLOOR_TOL = 0.08 WALL_TOL = 0.15 COVERAGE_TOL = 0.20 WORD_RE = re.compile(r"([A-Z])([+-]?(?:\d+(?:\.\d*)?|\.\d+))") ALLOWED_ADDRESSES = set("GMNOXYZIJRFSTH") ALLOWED_G_CODES = {0, 1, 2, 3, 17, 20, 21, 28, 40, 43, 49, 53, 54, 80, 90, 91, 94} ALLOWED_M_CODES = {3, 4, 5, 6, 8, 9, 30} class EvaluationError(ValueError): pass @dataclass(frozen=True) class Point: x: float y: float z: float @dataclass(frozen=True) class Segment: points: tuple[Point, ...] motion: int tool: int | None spindle: float | None spindle_on: bool feed: float | None wcs: int | None length_comp: bool h_offset: int | None @dataclass(frozen=True) class Program: program_number: int tool_changes: tuple[int, ...] segments: tuple[Segment, ...] terminated: bool def integer_code(value: float, label: str) -> int: if not math.isfinite(value) or abs(value - round(value)) > 1e-9: raise EvaluationError(f"non-integer {label}") return int(round(value)) def distance_3d(a: Point, b: Point) -> float: return math.dist((a.x, a.y, a.z), (b.x, b.y, b.z)) def strip_comments(source: str) -> list[str]: lines: list[str] = [] depth = 0 for raw in source.upper().splitlines(): clean: list[str] = [] for char in raw: if char == ";" and depth == 0: break if char == "(": if depth: raise EvaluationError("nested parenthesis comment") depth = 1 elif char == ")": if not depth: raise EvaluationError("unmatched parenthesis comment") depth = 0 elif depth == 0: clean.append(char) lines.append("".join(clean).strip()) if depth: raise EvaluationError("unterminated parenthesis comment") return lines def parse_words(line: str) -> dict[str, list[float]] | None: compact = re.sub(r"\s+", "", line) if not compact: return None if compact == "%": return {} if "%" in compact or any(char in compact for char in "#[]=/"): raise EvaluationError("unsupported executable syntax") matches = list(WORD_RE.finditer(compact)) if not matches or "".join(match.group(0) for match in matches) != compact: raise EvaluationError("unknown executable text") grouped: dict[str, list[float]] = {} for match in matches: address = match.group(1) if address not in ALLOWED_ADDRESSES: raise EvaluationError(f"unknown address {address}") value = float(match.group(2)) if not math.isfinite(value): raise EvaluationError("non-finite word") grouped.setdefault(address, []).append(value) for address, values in grouped.items(): if address not in {"G", "M"} and len(values) != 1: raise EvaluationError(f"duplicate {address} address") return grouped def directional_sweep(start_angle: float, end_angle: float, clockwise: bool, full_circle: bool) -> float: if full_circle: return -2.0 * math.pi if clockwise else 2.0 * math.pi if clockwise: magnitude = (start_angle - end_angle) % (2.0 * math.pi) return -magnitude return (end_angle - start_angle) % (2.0 * math.pi) def center_from_radius(start: Point, end: Point, radius_word: float, clockwise: bool) -> tuple[float, float, float]: dx, dy = end.x - start.x, end.y - start.y chord = math.hypot(dx, dy) radius = abs(radius_word) if chord <= 1e-9 or radius < chord / 2.0 - 0.02: raise EvaluationError("invalid R arc") half = chord / 2.0 height = math.sqrt(max(radius * radius - half * half, 0.0)) mid_x, mid_y = (start.x + end.x) / 2.0, (start.y + end.y) / 2.0 perp_x, perp_y = -dy / chord, dx / chord candidates = [ (mid_x + height * perp_x, mid_y + height * perp_y), (mid_x - height * perp_x, mid_y - height * perp_y), ] choices: list[tuple[float, float, float]] = [] for center_x, center_y in candidates: a0 = math.atan2(start.y - center_y, start.x - center_x) a1 = math.atan2(end.y - center_y, end.x - center_x) sweep = directional_sweep(a0, a1, clockwise, False) magnitude = abs(sweep) wants_minor = radius_word >= 0 if (wants_minor and magnitude <= math.pi + 1e-7) or (not wants_minor and magnitude >= math.pi - 1e-7): choices.append((center_x, center_y, sweep)) if not choices: raise EvaluationError("ambiguous R arc") return choices[0] def arc_points( start: Point, end: Point, clockwise: bool, i_word: float | None, j_word: float | None, radius_word: float | None, ) -> tuple[Point, ...]: if radius_word is not None and (i_word is not None or j_word is not None): raise EvaluationError("arc mixes I/J and R") if radius_word is not None: center_x, center_y, sweep = center_from_radius(start, end, radius_word, clockwise) radius = abs(radius_word) start_angle = math.atan2(start.y - center_y, start.x - center_x) else: if i_word is None and j_word is None: raise EvaluationError("arc lacks I/J or R") center_x = start.x + (i_word or 0.0) center_y = start.y + (j_word or 0.0) radius = math.hypot(start.x - center_x, start.y - center_y) end_radius = math.hypot(end.x - center_x, end.y - center_y) if radius <= 1e-6 or abs(radius - end_radius) > max(0.05, radius * 0.002): raise EvaluationError("invalid I/J arc") start_angle = math.atan2(start.y - center_y, start.x - center_x) end_angle = math.atan2(end.y - center_y, end.x - center_x) full_circle = math.hypot(end.x - start.x, end.y - start.y) <= 1e-7 sweep = directional_sweep(start_angle, end_angle, clockwise, full_circle) if abs(sweep) <= 1e-9: raise EvaluationError("zero-length arc") count = max(8, int(math.ceil(radius * abs(sweep) / 0.35))) if count > MAX_PATH_SEGMENTS: raise EvaluationError("arc is too large") points = [] for index in range(count + 1): fraction = index / count angle = start_angle + sweep * fraction points.append( Point( center_x + radius * math.cos(angle), center_y + radius * math.sin(angle), start.z + (end.z - start.z) * fraction, ) ) points[0] = start points[-1] = end return tuple(points) def parse_program(source: str) -> Program: units: str | None = None absolute: bool | None = None motion: int | None = None plane: int | None = None current: dict[str, float | None] = {"X": None, "Y": None, "Z": None} pending_tool: int | None = None active_tool: int | None = None spindle: float | None = None spindle_on = False feed: float | None = None wcs: int | None = None length_comp = False h_offset: int | None = None program_number: int | None = None tool_changes: list[int] = [] segments: list[Segment] = [] terminated = False block_count = 0 for line in strip_comments(source): grouped = parse_words(line) if grouped is None or grouped == {}: continue block_count += 1 if block_count > MAX_BLOCKS: raise EvaluationError("too many blocks") if terminated: raise EvaluationError("executable code after M30") if "O" in grouped: if program_number is not None or block_count != 1 or set(grouped) - {"N", "O"}: raise EvaluationError("invalid program-number block") program_number = integer_code(grouped["O"][0], "O number") continue if program_number is None: raise EvaluationError("executable code before O number") g_codes = [integer_code(value, "G code") for value in grouped.get("G", [])] m_codes = [integer_code(value, "M code") for value in grouped.get("M", [])] if any(code not in ALLOWED_G_CODES for code in g_codes): raise EvaluationError("unsupported G code") if any(code not in ALLOWED_M_CODES for code in m_codes): raise EvaluationError("unsupported M code") for family in ({0, 1, 2, 3}, {20, 21}, {90, 91}): if len(family.intersection(g_codes)) > 1: raise EvaluationError("conflicting modal G codes") if len(m_codes) != len(set(m_codes)): raise EvaluationError("duplicate M code") if 30 in m_codes: if m_codes[-1] != 30 or set(grouped) - {"N", "M"} or any(code not in {5, 9, 30} for code in m_codes): raise EvaluationError("unsafe M30 block") if 5 in m_codes: spindle_on = False terminated = True continue if 20 in g_codes: units = "inch" elif 21 in g_codes: units = "mm" if 90 in g_codes: absolute = True elif 91 in g_codes: absolute = False for code in (0, 1, 2, 3): if code in g_codes: motion = code if 17 in g_codes: plane = 17 if 54 in g_codes: wcs = 54 if "H" in grouped: if integer_code(grouped["H"][0], "H offset") != 1 or 43 not in g_codes: raise EvaluationError("only G43 H1 is allowed") if 43 in g_codes: if "H" not in grouped: raise EvaluationError("G43 lacks H1") length_comp = True h_offset = 1 if 49 in g_codes: length_comp = False h_offset = None factor = 25.4 if units == "inch" else 1.0 if "T" in grouped: pending_tool = integer_code(grouped["T"][0], "tool") if pending_tool != 1: raise EvaluationError("extra tool") if "S" in grouped: spindle = grouped["S"][0] if spindle <= 0: raise EvaluationError("non-positive spindle speed") if "F" in grouped: if units is None: raise EvaluationError("feed before units") feed = grouped["F"][0] * factor if feed <= 0: raise EvaluationError("non-positive feed") if 6 in m_codes: if pending_tool != 1: raise EvaluationError("M6 without T1") active_tool = 1 tool_changes.append(1) spindle_on = False length_comp = False h_offset = None if 3 in m_codes or 4 in m_codes: if spindle is None or spindle <= 0: raise EvaluationError("spindle start lacks positive S") spindle_on = True if 5 in m_codes: spindle_on = False axes = {axis for axis in ("X", "Y", "Z") if axis in grouped} arc_addresses = {axis for axis in ("I", "J", "R") if axis in grouped} if (axes or arc_addresses) and units is None: raise EvaluationError("coordinates before units") if 28 in g_codes: if not axes or arc_addresses or "F" in grouped or {0, 1, 2, 3, 53}.intersection(g_codes): raise EvaluationError("invalid G28 reference return") for axis in axes: current[axis] = None continue if 53 in g_codes: if not axes or arc_addresses or "F" in grouped or 0 not in g_codes: raise EvaluationError("G53 cutting or modal motion is forbidden") for axis in axes: current[axis] = None continue if not axes and not arc_addresses: continue if absolute is None: raise EvaluationError("motion before G90/G91") if motion is None: raise EvaluationError("coordinates without motion mode") if motion in {0, 1} and arc_addresses: raise EvaluationError("arc address on linear motion") if motion in {2, 3} and plane != 17: raise EvaluationError("arc is not in G17 plane") old = dict(current) new = dict(current) for axis in ("X", "Y", "Z"): if axis not in grouped: continue value = grouped[axis][0] * factor if absolute: new[axis] = value else: if old[axis] is None: raise EvaluationError("incremental move from unknown position") new[axis] = float(old[axis]) + value current = new if any(old[axis] is None or new[axis] is None for axis in ("X", "Y", "Z")): if motion != 0: raise EvaluationError("feed move from unknown position") continue start = Point(float(old["X"]), float(old["Y"]), float(old["Z"])) end = Point(float(new["X"]), float(new["Y"]), float(new["Z"])) if motion in {2, 3}: i_word = grouped.get("I", [None])[0] j_word = grouped.get("J", [None])[0] r_word = grouped.get("R", [None])[0] points = arc_points( start, end, motion == 2, None if i_word is None else i_word * factor, None if j_word is None else j_word * factor, None if r_word is None else r_word * factor, ) else: points = (start, end) if len(segments) + len(points) > MAX_PATH_SEGMENTS: raise EvaluationError("too many path segments") segments.append( Segment( points=points, motion=motion, tool=active_tool, spindle=spindle, spindle_on=spindle_on, feed=feed, wcs=wcs, length_comp=length_comp, h_offset=h_offset, ) ) if program_number is None: raise EvaluationError("missing O number") return Program(program_number, tuple(tool_changes), tuple(segments), terminated) def interpolate_at_z(a: Point, b: Point, z_value: float) -> Point: if abs(b.z - a.z) <= 1e-12: return a fraction = (z_value - a.z) / (b.z - a.z) return Point(a.x + (b.x - a.x) * fraction, a.y + (b.y - a.y) * fraction, z_value) def below_surface_portion(a: Point, b: Point) -> tuple[Point, Point] | None: threshold = -SURFACE_TOL a_below, b_below = a.z <= threshold, b.z <= threshold if not a_below and not b_below: return None if a_below and b_below: return a, b crossing = interpolate_at_z(a, b, threshold) return (a, crossing) if a_below else (crossing, b) def point_segment_distance_xy(x: float, y: float, a: Point, b: Point) -> float: dx, dy = b.x - a.x, b.y - a.y length_squared = dx * dx + dy * dy if length_squared <= 1e-16: return math.hypot(x - a.x, y - a.y) fraction = max(0.0, min(1.0, ((x - a.x) * dx + (y - a.y) * dy) / length_squared)) return math.hypot(x - (a.x + fraction * dx), y - (a.y + fraction * dy)) def rectangle_distance(x: float, y: float, xmin: float, xmax: float, ymin: float, ymax: float) -> float: return math.hypot(max(xmin - x, 0.0, x - xmax), max(ymin - y, 0.0, y - ymax)) def grid_values(low: float, high: float, spacing: float) -> list[float]: if high < low: return [] count = max(1, int(math.ceil((high - low) / spacing))) return [low + (high - low) * index / count for index in range(count + 1)] def validate_program(program: Program, contract: dict[str, object]) -> None: if not program.terminated: raise EvaluationError("missing M30") if program.program_number != int(contract["program"]): raise EvaluationError("wrong exact O number") if program.tool_changes != (1,): raise EvaluationError("expected exactly one T1/M6") width, height = (float(value) for value in contract["size"]) bottom = float(contract["bottom"]) radius = float(contract["diameter"]) / 2.0 x_limit = width / 2.0 - radius y_limit = height / 2.0 - radius floor_segments: list[tuple[Point, Point]] = [] saw_cut = False saw_safe_rapid = False for segment in program.segments: if segment.motion == 0 and any(point.z >= 2.0 for point in segment.points): saw_safe_rapid = True for start, end in zip(segment.points, segment.points[1:]): portion = below_surface_portion(start, end) if portion is not None: for point in portion: if point.z < bottom - DEPTH_TOL: raise EvaluationError("toolpath cuts below the pocket floor") if abs(point.x) > x_limit + WALL_TOL or abs(point.y) > y_limit + WALL_TOL: raise EvaluationError("tool center overcuts a pocket wall") if segment.tool != 1 or segment.wcs != 54 or not segment.length_comp or segment.h_offset != 1: raise EvaluationError("subsurface move lacks T1, G54, or G43 H1") if segment.motion in {1, 2, 3}: if not segment.spindle_on or segment.spindle is None or segment.spindle <= 0: raise EvaluationError("cut with spindle stopped") if segment.feed is None or segment.feed <= 0: raise EvaluationError("cut lacks positive feed") if distance_3d(start, end) > 1e-6: saw_cut = True if ( segment.motion in {1, 2, 3} and abs(start.z - bottom) <= FLOOR_TOL and abs(end.z - bottom) <= FLOOR_TOL and math.hypot(end.x - start.x, end.y - start.y) > 1e-5 ): floor_segments.append((start, end)) if not saw_cut or not saw_safe_rapid or not floor_segments: raise EvaluationError("incomplete executable pocket program") floor_points = [point for pair in floor_segments for point in pair] if ( min(point.x for point in floor_points) > -x_limit + WALL_TOL or max(point.x for point in floor_points) < x_limit - WALL_TOL or min(point.y for point in floor_points) > -y_limit + WALL_TOL or max(point.y for point in floor_points) < y_limit - WALL_TOL ): raise EvaluationError("floor toolpath does not reach all four walls") inset = 0.12 spacing = min(0.75, max(0.45, radius / 6.0)) for x in grid_values(-width / 2.0 + inset, width / 2.0 - inset, spacing): for y in grid_values(-height / 2.0 + inset, height / 2.0 - inset, spacing): if rectangle_distance(x, y, -x_limit, x_limit, -y_limit, y_limit) > radius - inset: continue if min(point_segment_distance_xy(x, y, start, end) for start, end in floor_segments) > radius + COVERAGE_TOL: raise EvaluationError("bottom swept area has uncleared material") def evaluate_text(source: str, contract: dict[str, object]) -> bool: try: validate_program(parse_program(source), contract) return True except (EvaluationError, UnicodeError, ValueError, OverflowError): return False def read_nc(path: Path) -> str: raw = path.read_bytes() if not raw or len(raw) > MAX_FILE_BYTES or b"\x00" in raw: raise EvaluationError("invalid NC file size or encoding") return raw.decode("utf-8-sig", errors="strict") def evaluate_directory(target: Path) -> bool: for name, contract in CONTRACTS.items(): path = target / name if not path.is_file() or not evaluate_text(read_nc(path), contract): return False return True def main() -> bool: return evaluate_directory(TARGET) if __name__ == "__main__": try: result = main() except Exception: result = False print("True" if result else "False") raise SystemExit(0)