| from __future__ import annotations |
|
|
| import math |
| import os |
| import re |
| from collections import Counter |
| from dataclasses import dataclass |
| from pathlib import Path |
|
|
|
|
| TARGET = Path(os.environ.get("EVAL_TARGET_DIR", r"C:\Users\User\Desktop")) |
| NC_NAME = "task-06.nc" |
| MAX_BYTES = 2_000_000 |
| TOOLS = { |
| 1: {"diameter": 10.0, "spindle": 7500.0, "feed": 520.0}, |
| 2: {"diameter": 5.0, "spindle": 5000.0, "feed": 180.0}, |
| 3: {"diameter": 6.0, "spindle": 9000.0, "feed": 650.0}, |
| } |
| HOLES = [(-35.0, -20.0), (-35.0, 20.0), (35.0, -20.0), (35.0, 20.0)] |
| WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))") |
| ALLOWED_WORDS = {"N", "O", "G", "M", "X", "Y", "Z", "I", "J", "R", "P", "Q", "T", "S", "F", "H", "D"} |
|
|
|
|
| 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: float | None |
| spindle_on: bool |
| feed: float | None |
| wcs: str | None |
| length_comp: bool |
| h_offset: int | None |
| comp: int |
| d_offset: int | None |
| machine_coordinates: bool |
| cycle: int | None |
| line_number: int |
|
|
|
|
| @dataclass |
| class Program: |
| segments: list[Segment] |
| tool_changes: list[int] |
| tool_references: set[int] |
| terminated: bool |
| explicit_units: bool |
| explicit_distance: bool |
| executable_lines: int |
|
|
|
|
| def close(a: float, b: float, tolerance: float) -> bool: |
| return abs(a - b) <= tolerance |
|
|
|
|
| def integral(value: float, label: str) -> int: |
| if not math.isfinite(value) or not close(value, round(value), 1e-9): |
| raise EvaluationError(f"non-integral {label}") |
| return int(round(value)) |
|
|
|
|
| def distance(a: Point, b: Point) -> float: |
| return math.dist((a.x, a.y, a.z), (b.x, b.y, b.z)) |
|
|
|
|
| def dense_line(start: Point, end: Point, spacing: float = 0.75) -> list[Point]: |
| count = max(1, int(math.ceil(distance(start, end) / spacing))) |
| return [ |
| Point( |
| start.x + (end.x - start.x) * index / count, |
| start.y + (end.y - start.y) * index / count, |
| start.z + (end.z - start.z) * index / count, |
| ) |
| for index in range(count + 1) |
| ] |
|
|
|
|
| def strip_comments(source: str) -> list[tuple[int, str]]: |
| rows: 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("unmatched comment close") |
| depth -= 1 |
| elif depth == 0: |
| clean.append(char) |
| rows.append((line_number, "".join(clean).strip())) |
| if depth: |
| raise EvaluationError("unterminated comment") |
| return rows |
|
|
|
|
| def sweep_for(center_x: float, center_y: float, start: Point, end: Point, clockwise: bool) -> tuple[float, float, float]: |
| start_angle = math.atan2(start.y - center_y, start.x - center_x) |
| end_angle = math.atan2(end.y - center_y, end.x - center_x) |
| sweep = (start_angle - end_angle) % (2 * math.pi) if clockwise else (end_angle - start_angle) % (2 * math.pi) |
| if sweep <= 1e-9: |
| sweep = 2 * math.pi |
| return start_angle, sweep, -1.0 if clockwise else 1.0 |
|
|
|
|
| def sampled_arc(start: Point, end: Point, center_x: float, center_y: float, clockwise: bool) -> list[Point]: |
| radius = math.hypot(start.x - center_x, start.y - center_y) |
| if radius <= 1e-6 or not close(math.hypot(end.x - center_x, end.y - center_y), radius, 0.25): |
| raise EvaluationError("invalid arc geometry") |
| start_angle, sweep, direction = sweep_for(center_x, center_y, start, end, clockwise) |
| count = max(12, int(math.ceil(radius * sweep / 0.75))) |
| return [ |
| Point( |
| center_x + radius * math.cos(start_angle + direction * sweep * index / count), |
| center_y + radius * math.sin(start_angle + direction * sweep * index / count), |
| start.z + (end.z - start.z) * index / count, |
| ) |
| for index in range(count + 1) |
| ] |
|
|
|
|
| def arc_points_ij(start: Point, end: Point, i_value: float, j_value: float, clockwise: bool) -> list[Point]: |
| return sampled_arc(start, end, start.x + i_value, start.y + j_value, clockwise) |
|
|
|
|
| def arc_points_r(start: Point, end: Point, r_value: float, clockwise: bool) -> list[Point]: |
| chord_x, chord_y = end.x - start.x, end.y - start.y |
| chord = math.hypot(chord_x, chord_y) |
| radius = abs(r_value) |
| if chord <= 1e-9 or radius < chord / 2 - 1e-6: |
| raise EvaluationError("invalid R arc") |
| middle_x, middle_y = (start.x + end.x) / 2, (start.y + end.y) / 2 |
| height = math.sqrt(max(0.0, radius * radius - (chord / 2) ** 2)) |
| normal_x, normal_y = -chord_y / chord, chord_x / chord |
| centers = [ |
| (middle_x + normal_x * height, middle_y + normal_y * height), |
| (middle_x - normal_x * height, middle_y - normal_y * height), |
| ] |
| choices = [] |
| for center_x, center_y in centers: |
| _start_angle, sweep, _direction = sweep_for(center_x, center_y, start, end, clockwise) |
| choices.append((center_x, center_y, sweep)) |
| if r_value >= 0: |
| center_x, center_y, _sweep = min(choices, key=lambda item: item[2]) |
| else: |
| center_x, center_y, _sweep = max(choices, key=lambda item: item[2]) |
| return sampled_arc(start, end, center_x, center_y, clockwise) |
|
|
|
|
| def parse_program(source: str) -> Program: |
| units: str | None = None |
| absolute: bool | None = None |
| motion: int | None = None |
| current = Point(0.0, 0.0, 0.0) |
| pending_tool: int | None = None |
| tool: int | None = None |
| tool_references: set[int] = set() |
| tool_changes: list[int] = [] |
| spindle: float | None = None |
| spindle_on = False |
| feed: float | None = None |
| wcs: str | None = None |
| length_comp = False |
| h_offset: int | None = None |
| comp = 40 |
| d_offset: int | None = None |
| cycle: int | None = None |
| cycle_z: float | None = None |
| cycle_r: float | None = None |
| terminated = False |
| executable_lines = 0 |
| segments: list[Segment] = [] |
|
|
| for line_number, line in strip_comments(source): |
| if not line or line == "%": |
| continue |
| if any(char in line for char in "#[]="): |
| raise EvaluationError("macros and expressions are unsupported") |
| found = WORD_RE.findall(line) |
| if not found: |
| raise EvaluationError(f"unparsed executable text on line {line_number}") |
| residue = re.sub(r"[\s/]+", "", WORD_RE.sub("", line)) |
| if residue: |
| raise EvaluationError(f"unknown executable text on line {line_number}") |
| if terminated: |
| raise EvaluationError("executable code after M30") |
| executable_lines += 1 |
|
|
| grouped: dict[str, list[float]] = {} |
| for letter, raw_value in found: |
| if letter not in ALLOWED_WORDS: |
| raise EvaluationError(f"unsupported address {letter}") |
| value = float(raw_value) |
| if not math.isfinite(value): |
| raise EvaluationError("non-finite numeric word") |
| grouped.setdefault(letter, []).append(value) |
| for letter, values in grouped.items(): |
| if letter not in {"G", "M"} and len(values) != 1: |
| raise EvaluationError(f"duplicate {letter} address") |
| for letter in ("N", "O", "T", "H", "D"): |
| if letter in grouped: |
| integral(grouped[letter][0], letter) |
|
|
| gcodes = grouped.get("G", []) |
| mcodes = [integral(value, "M") for value in grouped.get("M", [])] |
| if any(code not in {0, 1, 3, 4, 5, 6, 8, 9, 30} for code in mcodes): |
| raise EvaluationError("unsupported M code") |
| if "T" in grouped: |
| pending_tool = integral(grouped["T"][0], "T") |
| tool_references.add(pending_tool) |
| if 6 in mcodes: |
| if pending_tool is None: |
| raise EvaluationError("M6 without tool") |
| tool = pending_tool |
| tool_changes.append(tool) |
| spindle = None |
| spindle_on = False |
| feed = None |
| length_comp = False |
| h_offset = None |
| comp = 40 |
| d_offset = None |
| cycle = None |
| cycle_z = None |
| cycle_r = None |
|
|
| machine_coordinates = any(close(code, 53.0, 1e-6) for code in gcodes) |
| reference_return = any(close(code, 28.0, 1e-6) for code in gcodes) |
| for code in gcodes: |
| rounded = int(round(code)) |
| if close(code, 20.0, 1e-6): |
| units = "inch" |
| elif close(code, 21.0, 1e-6): |
| units = "mm" |
| elif close(code, 90.0, 1e-6): |
| absolute = True |
| elif close(code, 91.0, 1e-6): |
| absolute = False |
| elif rounded in (0, 1, 2, 3) and close(code, rounded, 1e-6): |
| motion = rounded |
| elif rounded in (54, 55, 56, 57, 58, 59) and close(code, rounded, 1e-6): |
| wcs = f"G{rounded}" |
| elif close(code, 54.1, 1e-6): |
| if "P" not in grouped: |
| raise EvaluationError("G54.1 requires P") |
| p_value = integral(grouped["P"][0], "P") |
| if p_value <= 0: |
| raise EvaluationError("invalid G54.1 offset") |
| wcs = f"G54.1P{p_value}" |
| elif close(code, 43.0, 1e-6): |
| length_comp = True |
| elif close(code, 49.0, 1e-6): |
| length_comp = False |
| h_offset = None |
| elif rounded in (40, 41, 42) and close(code, rounded, 1e-6): |
| comp = rounded |
| if rounded == 40: |
| d_offset = None |
| elif rounded in (81, 82, 83) and close(code, rounded, 1e-6): |
| cycle = rounded |
| elif rounded == 80 and close(code, 80.0, 1e-6): |
| cycle = None |
| elif any(close(code, value, 1e-6) for value in (4.0, 17.0, 28.0, 53.0, 94.0, 98.0, 99.0)): |
| pass |
| else: |
| raise EvaluationError(f"unsupported G code G{code:g}") |
|
|
| factor = 25.4 if units == "inch" else 1.0 |
| if "S" in grouped: |
| spindle = grouped["S"][0] |
| if "F" in grouped: |
| feed = grouped["F"][0] * factor |
| if "H" in grouped: |
| h_offset = integral(grouped["H"][0], "H") |
| if "D" in grouped: |
| d_offset = integral(grouped["D"][0], "D") |
| if (3 in mcodes or 4 in mcodes) and 5 in mcodes: |
| raise EvaluationError("conflicting spindle commands") |
| if 3 in mcodes or 4 in mcodes: |
| spindle_on = True |
| if 5 in mcodes: |
| spindle_on = False |
|
|
| has_coordinates = any(letter in grouped for letter in ("X", "Y", "Z")) |
| if absolute is None and has_coordinates: |
| raise EvaluationError("motion before explicit G90/G91") |
| if units is None and any(letter in grouped for letter in ("X", "Y", "Z", "I", "J", "R", "Q", "F")): |
| raise EvaluationError("dimensional word before explicit G20/G21") |
|
|
| def coordinate(axis: str, old_value: float) -> float: |
| if axis not in grouped: |
| return old_value |
| new_value = grouped[axis][0] * factor |
| return new_value if absolute else old_value + new_value |
|
|
| new = Point(coordinate("X", current.x), coordinate("Y", current.y), coordinate("Z", current.z)) |
| if reference_return: |
| current = new |
| elif machine_coordinates: |
| pass |
| elif cycle is not None and has_coordinates: |
| if "Z" in grouped: |
| cycle_z = new.z |
| if "R" in grouped: |
| r_word = grouped["R"][0] * factor |
| cycle_r = r_word if absolute else current.z + r_word |
| if cycle_z is None or cycle_r is None: |
| raise EvaluationError("incomplete drilling cycle") |
| at_xy = Point(new.x, new.y, current.z) |
| top = Point(new.x, new.y, cycle_r) |
| bottom = Point(new.x, new.y, cycle_z) |
| if distance(current, at_xy) > 1e-6: |
| segments.append(Segment(current, at_xy, dense_line(current, at_xy), 0, tool, spindle, spindle_on, feed, wcs, length_comp, h_offset, comp, d_offset, False, cycle, line_number)) |
| if distance(at_xy, top) > 1e-6: |
| segments.append(Segment(at_xy, top, dense_line(at_xy, top), 0, tool, spindle, spindle_on, feed, wcs, length_comp, h_offset, comp, d_offset, False, cycle, line_number)) |
| segments.append(Segment(top, bottom, dense_line(top, bottom), 1, tool, spindle, spindle_on, feed, wcs, length_comp, h_offset, comp, d_offset, False, cycle, line_number)) |
| current = top |
| elif has_coordinates and motion is not None: |
| if motion in (2, 3): |
| has_ij = "I" in grouped or "J" in grouped |
| has_r = "R" in grouped |
| if has_ij and has_r: |
| raise EvaluationError("arc cannot mix I/J and R") |
| if has_ij: |
| if "I" not in grouped or "J" not in grouped: |
| raise EvaluationError("XY arc requires both I and J") |
| samples = arc_points_ij(current, new, grouped["I"][0] * factor, grouped["J"][0] * factor, motion == 2) |
| elif has_r: |
| samples = arc_points_r(current, new, grouped["R"][0] * factor, motion == 2) |
| else: |
| raise EvaluationError("arc requires I/J or R") |
| else: |
| samples = dense_line(current, new) |
| segments.append(Segment(current, new, samples, motion, tool, spindle, spindle_on, feed, wcs, length_comp, h_offset, comp, d_offset, False, None, line_number)) |
| current = new |
| if 30 in mcodes: |
| terminated = True |
|
|
| return Program(segments, tool_changes, tool_references, terminated, units is not None, absolute is not None, executable_lines) |
|
|
|
|
| def cutting_segments(program: Program, tool: int) -> list[Segment]: |
| return [ |
| segment |
| for segment in program.segments |
| if segment.tool == tool |
| and segment.motion in (1, 2, 3) |
| and not segment.machine_coordinates |
| and distance(segment.start, segment.end) > 1e-5 |
| ] |
|
|
|
|
| def validate_common(program: Program) -> None: |
| if not program.terminated or not program.explicit_units or not program.explicit_distance or program.executable_lines < 15: |
| raise EvaluationError("incomplete executable program") |
| if program.tool_references - set(TOOLS): |
| raise EvaluationError("unexpected tool reference") |
| if len(program.tool_changes) != 3 or Counter(program.tool_changes) != Counter({1: 1, 2: 1, 3: 1}): |
| raise EvaluationError("each supplied tool must be changed exactly once") |
| if any(segment.motion in (1, 2, 3) and segment.tool is None for segment in program.segments): |
| raise EvaluationError("feed motion before tool change") |
| for tool, contract in TOOLS.items(): |
| segments = cutting_segments(program, tool) |
| if not segments: |
| raise EvaluationError(f"T{tool} has no cutting motion") |
| for segment in segments: |
| if not segment.spindle_on: |
| raise EvaluationError(f"T{tool} cuts with spindle stopped") |
| if segment.spindle is None or not close(segment.spindle, contract["spindle"], 1.0): |
| raise EvaluationError(f"T{tool} has wrong spindle speed") |
| if segment.feed is None or not close(segment.feed, contract["feed"], 0.75): |
| raise EvaluationError(f"T{tool} has wrong cutting feed") |
| if segment.wcs != "G54": |
| raise EvaluationError(f"T{tool} cuts outside G54") |
| if not segment.length_comp or segment.h_offset != tool: |
| raise EvaluationError(f"T{tool} lacks matching G43/H{tool}") |
| safe_rapids = [ |
| segment |
| for segment in program.segments |
| if segment.tool == tool and segment.motion == 0 and not segment.machine_coordinates and max(segment.start.z, segment.end.z) >= 2.0 |
| ] |
| if not safe_rapids: |
| raise EvaluationError(f"T{tool} lacks safe rapid clearance") |
|
|
|
|
| def grid_covered(points: list[Point], xs: list[float], ys: list[float], radius: float) -> bool: |
| return all(any(math.hypot(point.x - x_value, point.y - y_value) <= radius for point in points) for x_value in xs for y_value in ys) |
|
|
|
|
| def validate_pocket(program: Program) -> None: |
| segments = cutting_segments(program, 1) |
| material_points = [point for segment in segments for point in segment.samples if point.z <= 0.25] |
| if not material_points: |
| raise EvaluationError("missing pocket cutting") |
| if any(abs(point.x) > 17.75 or abs(point.y) > 9.75 for point in material_points): |
| raise EvaluationError("T1 cuts outside the D10 pocket-center envelope") |
| if any(point.z < -11.25 for point in material_points): |
| raise EvaluationError("pocket is over-deep") |
| bottom = [point for point in material_points if -11.25 <= point.z <= -10.5] |
| if not bottom or min(point.z for point in bottom) > -10.75: |
| raise EvaluationError("pocket bottom depth is missing") |
| if not grid_covered(bottom, [-17.0, -8.5, 0.0, 8.5, 17.0], [-9.0, 0.0, 9.0], 4.75): |
| raise EvaluationError("44 x 28 pocket is not cleared to depth 11") |
|
|
|
|
| def nearest_hole(x_value: float, y_value: float) -> tuple[int, float]: |
| distances = [math.hypot(x_value - hole_x, y_value - hole_y) for hole_x, hole_y in HOLES] |
| index = min(range(len(distances)), key=distances.__getitem__) |
| return index, distances[index] |
|
|
|
|
| def validate_drill(program: Program) -> None: |
| deepest: dict[int, float] = {} |
| for segment in cutting_segments(program, 2): |
| if math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) > 0.25: |
| raise EvaluationError("T2 performs lateral feed cutting") |
| if segment.end.z >= segment.start.z - 0.25: |
| raise EvaluationError("T2 drilling feed is not downward") |
| index, hole_distance = nearest_hole(segment.end.x, segment.end.y) |
| if hole_distance > 0.75: |
| raise EvaluationError("T2 drills an unexpected location") |
| bottom = min(segment.start.z, segment.end.z) |
| if bottom < -20.25: |
| raise EvaluationError("drill exceeds permitted through-tip allowance") |
| deepest[index] = min(deepest.get(index, float("inf")), bottom) |
| if set(deepest) != set(range(4)): |
| raise EvaluationError("one or more holes are missing") |
| if any(not (-20.25 <= deepest[index] <= -18.0) for index in range(4)): |
| raise EvaluationError("one or more holes are not through") |
|
|
|
|
| def signed_area(points: list[Point]) -> float: |
| return 0.5 * sum(first.x * second.y - second.x * first.y for first, second in zip(points, points[1:])) |
|
|
|
|
| def near_closed_subloops(points: list[Point], minimum_points: int = 40, gap: float = 2.0) -> list[list[Point]]: |
| loops: list[list[Point]] = [] |
| if len(points) >= minimum_points and distance(points[0], points[-1]) <= gap: |
| loops.append(points) |
| for start in range(len(points) - minimum_points): |
| for end in range(start + minimum_points, len(points)): |
| if distance(points[start], points[end]) <= gap: |
| loops.append(points[start : end + 1]) |
| return loops |
|
|
|
|
| def validate_profile(program: Program) -> None: |
| segments = cutting_segments(program, 3) |
| material_points = [point for segment in segments for point in segment.samples if point.z <= 0.25] |
| if not material_points: |
| raise EvaluationError("missing profile cutting") |
| if any(point.z < -18.25 for point in material_points): |
| raise EvaluationError("profile is over-deep") |
| for point in material_points: |
| if abs(point.x) > 70.0 or abs(point.y) > 50.0: |
| raise EvaluationError("profile contains extreme over-travel") |
| if max(abs(point.x) - 60.0, abs(point.y) - 40.0) < -0.75: |
| raise EvaluationError("T3 performs destructive cutting inside the nominal perimeter") |
|
|
| candidates: list[tuple[list[Point], list[Segment]]] = [] |
| run: list[Point] = [] |
| run_segments: list[Segment] = [] |
| for segment in segments: |
| horizontal = abs(segment.start.z - segment.end.z) <= 0.3 and -18.25 <= min(segment.start.z, segment.end.z) <= -17.75 |
| if horizontal: |
| if not run or distance(run[-1], segment.start) <= 0.5: |
| if not run: |
| run.append(segment.start) |
| run.extend(segment.samples[1:]) |
| run_segments.append(segment) |
| else: |
| candidates.append((run, run_segments)) |
| run = [segment.start, *segment.samples[1:]] |
| run_segments = [segment] |
| elif run: |
| candidates.append((run, run_segments)) |
| run = [] |
| run_segments = [] |
| if run: |
| candidates.append((run, run_segments)) |
|
|
| for points, candidate_segments in candidates: |
| for loop in near_closed_subloops(points): |
| xs = [point.x for point in loop] |
| ys = [point.y for point in loop] |
| offset = ( |
| close(min(xs), -63.0, 0.75) |
| and close(max(xs), 63.0, 0.75) |
| and close(min(ys), -43.0, 0.75) |
| and close(max(ys), 43.0, 0.75) |
| and all(max(abs(point.x) - 60.0, abs(point.y) - 40.0) >= 2.0 for point in loop) |
| ) |
| if offset: |
| return |
| nominal_points = [point for point in loop if abs(point.x) <= 60.75 and abs(point.y) <= 40.75] |
| nominal = ( |
| nominal_points |
| and close(min(point.x for point in nominal_points), -60.0, 0.75) |
| and close(max(point.x for point in nominal_points), 60.0, 0.75) |
| and close(min(point.y for point in nominal_points), -40.0, 0.75) |
| and close(max(point.y for point in nominal_points), 40.0, 0.75) |
| and all( |
| any(abs(point.x - x_value) <= 0.75 and abs(point.y - y_value) <= 0.75 for point in nominal_points) |
| for x_value, y_value in ((-60.0, -40.0), (60.0, -40.0), (60.0, 40.0), (-60.0, 40.0)) |
| ) |
| ) |
| if nominal: |
| required_comp = 42 if signed_area(nominal_points) > 0 else 41 |
| if any(segment.comp == required_comp and segment.d_offset is not None and segment.d_offset > 0 for segment in candidate_segments): |
| return |
| raise EvaluationError("missing full-depth compensated closed outside profile") |
|
|
|
|
| def evaluate_text(source: str) -> bool: |
| try: |
| program = parse_program(source) |
| validate_common(program) |
| validate_pocket(program) |
| validate_drill(program) |
| validate_profile(program) |
| return True |
| except (EvaluationError, OverflowError, ValueError): |
| return False |
|
|
|
|
| def main() -> bool: |
| path = TARGET / NC_NAME |
| if not path.is_file() or path.stat().st_size <= 0 or path.stat().st_size > MAX_BYTES: |
| return False |
| raw = path.read_bytes() |
| if b"\x00" in raw: |
| return False |
| try: |
| source = raw.decode("utf-8", errors="strict") |
| except UnicodeDecodeError: |
| return False |
| return evaluate_text(source) |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| result = main() |
| except Exception: |
| result = False |
| print("True" if result else "False") |
| raise SystemExit(0) |
|
|
