| 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")) |
| NC_NAME = "task-12.nc" |
| MAX_BYTES = 1_000_000 |
| MAX_LINES = 12_000 |
| MAX_WORDS_PER_LINE = 40 |
| MAX_SEGMENTS = 20_000 |
| MAX_SAMPLES = 250_000 |
| WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))") |
|
|
| PROGRAM = 2032 |
| TOOLS = { |
| 1: {"diameter": 6.0, "spindle": 7200.0, "feed": 430.0}, |
| 2: {"diameter": 6.0, "spindle": 7600.0, "feed": 520.0}, |
| 3: {"diameter": 5.0, "spindle": 5000.0, "feed": 180.0}, |
| 4: {"diameter": 12.0, "spindle": 9000.0, "feed": 650.0}, |
| } |
| UPPER_RECTS = ((-37.0, -13.0, -12.0, 12.0), (-18.0, 18.0, -10.0, 10.0)) |
| DEEP_RECT = (-18.0, 18.0, -10.0, 10.0) |
| HOLES = ((-30.0, -20.0), (-30.0, 20.0), (30.0, -20.0), (30.0, 20.0)) |
| STOCK = (-60.0, 60.0, -40.0, 40.0) |
|
|
|
|
| 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 |
| cycle: int | None |
| tool: int | None |
| spindle: float | None |
| spindle_direction: int | None |
| feed: float | None |
| wcs: str | None |
| plane17: bool |
| length_comp: bool |
| h_offset: int | None |
| comp: int |
| d_offset: int | None |
| line_number: int |
|
|
|
|
| @dataclass |
| class Program: |
| segments: list[Segment] |
| selections: list[int] |
| changes: list[int] |
| programs: list[int] |
| terminated: bool |
| executable_lines: int |
|
|
|
|
| def close(a: float, b: float, tol: float) -> bool: |
| return abs(a - b) <= tol |
|
|
|
|
| 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(a: Point, b: Point, spacing: float = 0.7) -> list[Point]: |
| length = distance(a, b) |
| if not math.isfinite(length) or length > 1000.0: |
| raise EvaluationError("invalid or excessive segment length") |
| count = max(1, int(math.ceil(length / spacing))) |
| return [ |
| Point(a.x + (b.x - a.x) * i / count, a.y + (b.y - a.y) * i / count, a.z + (b.z - a.z) * i / count) |
| for i in range(count + 1) |
| ] |
|
|
|
|
| def strip_comments(src: str) -> list[str]: |
| if len(src.encode("utf-8")) > MAX_BYTES: |
| raise EvaluationError("NC file exceeds evaluator resource limit") |
| raw_lines = src.upper().splitlines() |
| if len(raw_lines) > MAX_LINES: |
| raise EvaluationError("NC line count exceeds evaluator resource limit") |
| output: list[str] = [] |
| depth = 0 |
| for raw in raw_lines: |
| clean: list[str] = [] |
| for char in raw: |
| if char == ";" and depth == 0: |
| break |
| if char == "(": |
| depth += 1 |
| if depth > 8: |
| raise EvaluationError("excessive nested comment") |
| elif char == ")": |
| if depth == 0: |
| raise EvaluationError("unmatched comment close") |
| depth -= 1 |
| elif depth == 0: |
| clean.append(char) |
| output.append("".join(clean).strip()) |
| if depth: |
| raise EvaluationError("unterminated comment") |
| return output |
|
|
|
|
| def exact_integer(value: float, label: str, minimum: int = 0, maximum: int = 1_000_000) -> int: |
| if not math.isfinite(value): |
| raise EvaluationError(f"non-finite {label}") |
| integer = round(value) |
| if abs(value - integer) > 1e-4 or integer < minimum or integer > maximum: |
| raise EvaluationError(f"invalid integer {label}") |
| return int(integer) |
|
|
|
|
| def arc_points(a: Point, b: Point, i: float, j: float, clockwise: bool) -> list[Point]: |
| cx, cy = a.x + i, a.y + j |
| radius = math.hypot(i, j) |
| if radius <= 1e-6 or radius > 500.0 or not close(math.hypot(b.x - cx, b.y - cy), radius, 0.15): |
| raise EvaluationError("invalid G17 arc") |
| start_angle = math.atan2(a.y - cy, a.x - cx) |
| end_angle = math.atan2(b.y - cy, b.x - cx) |
| 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 |
| direction = -1.0 if clockwise else 1.0 |
| count = max(12, int(math.ceil(radius * sweep / 0.7))) |
| return [ |
| Point( |
| cx + radius * math.cos(start_angle + direction * sweep * k / count), |
| cy + radius * math.sin(start_angle + direction * sweep * k / count), |
| a.z + (b.z - a.z) * k / count, |
| ) |
| for k in range(count + 1) |
| ] |
|
|
|
|
| def parse_program(src: 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 |
| active_tool: int | None = None |
| spindle: float | None = None |
| spindle_direction: int | None = None |
| feed: float | None = None |
| wcs: str | None = None |
| plane17 = False |
| 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 = 0 |
| previous_sequence: int | None = None |
| selections: list[int] = [] |
| changes: list[int] = [] |
| programs: list[int] = [] |
| segments: list[Segment] = [] |
| sample_count = 0 |
|
|
| for physical_line, line in enumerate(strip_comments(src), start=1): |
| 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 or len(found) > MAX_WORDS_PER_LINE or re.sub(r"[\s/]+", "", WORD_RE.sub("", line)): |
| raise EvaluationError("unknown executable text") |
| if terminated: |
| raise EvaluationError("executable code after program termination") |
| executable += 1 |
| grouped: dict[str, list[float]] = {} |
| for letter, token in found: |
| value = float(token) |
| if not math.isfinite(value) or abs(value) > 10_000_000: |
| raise EvaluationError("non-finite or excessive numeric word") |
| grouped.setdefault(letter, []).append(value) |
| if set(grouped) - set("NOGMTSFHDPQXYZIJR"): |
| raise EvaluationError("unsupported address word") |
| for letter in "NOTSFHDPQXYZIJR": |
| if len(grouped.get(letter, [])) > 1: |
| raise EvaluationError(f"duplicate {letter} address") |
| if "N" in grouped: |
| sequence = exact_integer(grouped["N"][0], "sequence") |
| if previous_sequence is not None and sequence <= previous_sequence: |
| raise EvaluationError("non-increasing sequence numbers") |
| previous_sequence = sequence |
| if "O" in grouped: |
| if set(grouped) - {"N", "O"}: |
| raise EvaluationError("program number mixed with executable words") |
| programs.append(exact_integer(grouped["O"][0], "program", 1, 999999)) |
| continue |
|
|
| gcodes = grouped.get("G", []) |
| mcodes = [exact_integer(value, "M code", 0, 999) for value in grouped.get("M", [])] |
| machine_return = False |
| for value in gcodes: |
| if close(value, 0.0, 1e-6): |
| motion = 0 |
| elif close(value, 1.0, 1e-6): |
| motion = 1 |
| elif close(value, 2.0, 1e-6): |
| motion = 2 |
| elif close(value, 3.0, 1e-6): |
| motion = 3 |
| elif close(value, 17.0, 1e-6): |
| plane17 = True |
| elif close(value, 20.0, 1e-6): |
| units = "inch" |
| elif close(value, 21.0, 1e-6): |
| units = "mm" |
| elif close(value, 28.0, 1e-6): |
| machine_return = True |
| elif close(value, 40.0, 1e-6): |
| comp, d_offset = 40, None |
| elif close(value, 41.0, 1e-6): |
| comp = 41 |
| elif close(value, 42.0, 1e-6): |
| comp = 42 |
| elif close(value, 43.0, 1e-6): |
| length_comp = True |
| elif close(value, 49.0, 1e-6): |
| length_comp, h_offset = False, None |
| elif close(value, 54.0, 1e-6): |
| wcs = "G54" |
| elif any(close(value, code, 1e-6) for code in (55.0, 56.0, 57.0, 58.0, 59.0, 54.1)): |
| raise EvaluationError("only G54 is valid for this part") |
| elif close(value, 80.0, 1e-6): |
| cycle = None |
| elif any(close(value, code, 1e-6) for code in (81.0, 82.0, 83.0)): |
| cycle = int(round(value)) |
| elif close(value, 90.0, 1e-6): |
| absolute = True |
| elif close(value, 91.0, 1e-6): |
| absolute = False |
| elif any(close(value, code, 1e-6) for code in (94.0, 98.0, 99.0)): |
| pass |
| else: |
| raise EvaluationError(f"unsupported G code {value:g}") |
|
|
| for code in mcodes: |
| if code not in {2, 3, 4, 5, 6, 8, 9, 30}: |
| raise EvaluationError(f"unsupported M code M{code}") |
| factor = 25.4 if units == "inch" else 1.0 |
| if "T" in grouped: |
| pending_tool = exact_integer(grouped["T"][0], "tool", 1, 99) |
| selections.append(pending_tool) |
| if "S" in grouped: |
| spindle = grouped["S"][0] |
| if spindle <= 0 or spindle > 100_000: |
| raise EvaluationError("invalid spindle speed") |
| if "F" in grouped: |
| feed = grouped["F"][0] * factor |
| if feed <= 0 or feed > 100_000: |
| raise EvaluationError("invalid feed") |
| if "H" in grouped: |
| h_offset = exact_integer(grouped["H"][0], "H offset", 1, 999) |
| if "D" in grouped: |
| d_offset = exact_integer(grouped["D"][0], "D offset", 1, 999) |
| if "Q" in grouped and (cycle != 83 or grouped["Q"][0] * factor <= 0): |
| raise EvaluationError("Q is only valid for positive G83 pecking") |
| if 6 in mcodes: |
| if pending_tool is None: |
| raise EvaluationError("M6 without an exact T word") |
| active_tool = pending_tool |
| changes.append(active_tool) |
| length_comp, h_offset, comp, d_offset = False, None, 40, None |
| if 3 in mcodes: |
| spindle_direction = 3 |
| if 4 in mcodes: |
| spindle_direction = 4 |
| if 5 in mcodes: |
| spindle_direction = None |
| if 2 in mcodes or 30 in mcodes: |
| terminated = True |
|
|
| coordinate_letters = set(grouped) & {"X", "Y", "Z"} |
| if coordinate_letters and absolute is None: |
| raise EvaluationError("coordinate motion before G90/G91") |
| if (coordinate_letters or "F" in grouped or "Q" in grouped or "R" in grouped) and units is None: |
| raise EvaluationError("dimensional word before G20/G21") |
| if machine_return: |
| if absolute is not False or any(abs(grouped[axis][0]) > 1e-9 for axis in coordinate_letters): |
| raise EvaluationError("only zero-intermediate G91 G28 return is accepted") |
| continue |
|
|
| def coordinate(axis: str, old: float) -> float: |
| if axis not in grouped: |
| return old |
| value = grouped[axis][0] * factor |
| return value if absolute else old + value |
|
|
| new = Point(coordinate("X", current.x), coordinate("Y", current.y), coordinate("Z", current.z)) |
| if max(abs(new.x), abs(new.y)) > 250.0 or new.z < -60.0 or new.z > 150.0: |
| raise EvaluationError("part-coordinate resource/safety envelope exceeded") |
|
|
| if cycle is not None and cycle != 80 and (coordinate_letters or any(close(value, cycle, 1e-6) for value in gcodes)): |
| if cycle not in {81, 82, 83}: |
| raise EvaluationError("unsupported drilling cycle") |
| if "Z" in grouped: |
| cycle_z = new.z |
| if "R" in grouped: |
| raw_r = grouped["R"][0] * factor |
| cycle_r = raw_r if absolute else current.z + raw_r |
| if cycle_z is None or cycle_r is None: |
| raise EvaluationError("incomplete drilling cycle") |
| top = Point(new.x, new.y, cycle_r) |
| bottom = Point(new.x, new.y, cycle_z) |
| sample = dense_line(top, bottom) |
| segments.append(Segment(top, bottom, sample, 1, cycle, active_tool, spindle, spindle_direction, feed, wcs, plane17, length_comp, h_offset, comp, d_offset, physical_line)) |
| sample_count += len(sample) |
| current = top |
| elif coordinate_letters and motion is not None: |
| if motion in {2, 3}: |
| if not plane17 or len(grouped.get("I", [])) != 1 or len(grouped.get("J", [])) != 1: |
| raise EvaluationError("G2/G3 requires G17 and one I/J pair") |
| sample = arc_points(current, new, grouped["I"][0] * factor, grouped["J"][0] * factor, motion == 2) |
| else: |
| if "I" in grouped or "J" in grouped: |
| raise EvaluationError("I/J supplied outside an arc") |
| sample = dense_line(current, new) |
| segments.append(Segment(current, new, sample, motion, None, active_tool, spindle, spindle_direction, feed, wcs, plane17, length_comp, h_offset, comp, d_offset, physical_line)) |
| sample_count += len(sample) |
| current = new |
| if len(segments) > MAX_SEGMENTS or sample_count > MAX_SAMPLES: |
| raise EvaluationError("toolpath sampling resource limit exceeded") |
|
|
| return Program(segments, selections, changes, programs, terminated, executable) |
|
|
|
|
| def point_in_rect(x: float, y: float, rect: tuple[float, float, float, float], tolerance: float = 0.0) -> bool: |
| xmin, xmax, ymin, ymax = rect |
| return xmin - tolerance <= x <= xmax + tolerance and ymin - tolerance <= y <= ymax + tolerance |
|
|
|
|
| def point_in_upper(x: float, y: float, tolerance: float = 0.0) -> bool: |
| return any(point_in_rect(x, y, rect, tolerance) for rect in UPPER_RECTS) |
|
|
|
|
| def disk_inside_region(x: float, y: float, radius: float, region, tolerance: float = 0.18) -> bool: |
| for index in range(32): |
| angle = 2.0 * math.pi * index / 32.0 |
| px, py = x + radius * math.cos(angle), y + radius * math.sin(angle) |
| if not region(px, py, tolerance): |
| return False |
| return region(x, y, tolerance) |
|
|
|
|
| def distance_to_stock(x: float, y: float) -> float: |
| xmin, xmax, ymin, ymax = STOCK |
| return math.hypot(max(xmin - x, 0.0, x - xmax), max(ymin - y, 0.0, y - ymax)) |
|
|
|
|
| def segment_xy_length(segment: Segment) -> float: |
| return math.hypot(segment.end.x - segment.start.x, segment.end.y - segment.start.y) |
|
|
|
|
| def cutting_state(segment: Segment, tool: int) -> None: |
| spec = TOOLS[tool] |
| if ( |
| segment.tool != tool |
| or segment.spindle_direction != 3 |
| or segment.spindle is None |
| or not close(segment.spindle, spec["spindle"], 0.5) |
| or segment.feed is None |
| or segment.feed <= 0 |
| or segment.wcs != "G54" |
| or not segment.length_comp |
| or segment.h_offset != tool |
| ): |
| raise EvaluationError(f"invalid T{tool} WCS/H/S/cutting state") |
|
|
|
|
| def primary_feed(segment: Segment, tool: int) -> bool: |
| return segment.feed is not None and close(segment.feed, TOOLS[tool]["feed"], 0.75) |
|
|
|
|
| def accessible_grid(rects: tuple[tuple[float, float, float, float], ...], radius: float, region, step: float = 1.5) -> list[tuple[float, float]]: |
| xmin = min(rect[0] for rect in rects) |
| xmax = max(rect[1] for rect in rects) |
| ymin = min(rect[2] for rect in rects) |
| ymax = max(rect[3] for rect in rects) |
| points: list[tuple[float, float]] = [] |
| x = xmin |
| while x <= xmax + 1e-9: |
| y = ymin |
| while y <= ymax + 1e-9: |
| if disk_inside_region(x, y, radius, region): |
| points.append((x, y)) |
| y += step |
| x += step |
| return points |
|
|
|
|
| def covered(path: list[Point], targets: list[tuple[float, float]], tolerance: float) -> bool: |
| return bool(path) and all(any(math.hypot(point.x - x, point.y - y) <= tolerance for point in path) for x, y in targets) |
|
|
|
|
| def validate_upper(program: Program) -> None: |
| radius = TOOLS[1]["diameter"] / 2.0 |
| bottom_path: list[Point] = [] |
| levels: set[float] = set() |
| for segment in [value for value in program.segments if value.tool == 1]: |
| if min(point.z for point in segment.samples) < 0.05: |
| if segment.motion in {1, 2, 3}: |
| cutting_state(segment, 1) |
| for point in segment.samples: |
| if point.z < -10.15: |
| raise EvaluationError("T1 cuts below the upper-pocket floor") |
| if point.z < 0.05 and not disk_inside_region(point.x, point.y, radius, point_in_upper): |
| raise EvaluationError("T1 leaves the upper irregular pocket") |
| if segment.motion in {1, 2, 3} and segment_xy_length(segment) > 0.05 and min(segment.start.z, segment.end.z) <= 0.0: |
| if not primary_feed(segment, 1) or not segment.plane17: |
| raise EvaluationError("T1 primary cutting feed/plane mismatch") |
| if abs(segment.start.z - segment.end.z) <= 0.15: |
| levels.add(round((segment.start.z + segment.end.z) / 2.0, 1)) |
| if all(abs(point.z + 10.0) <= 0.14 for point in segment.samples): |
| bottom_path.extend(segment.samples) |
| if len(levels) < 4 or min(levels) > -9.9: |
| raise EvaluationError("T1 lacks safe multi-depth cutting to Z-10") |
| grid = accessible_grid(UPPER_RECTS, radius, point_in_upper) |
| if not covered(bottom_path, grid, 2.5): |
| raise EvaluationError("upper irregular pocket bottom is under-cleared") |
|
|
|
|
| def validate_deep_step(program: Program) -> None: |
| radius = TOOLS[2]["diameter"] / 2.0 |
| region = lambda x, y, tolerance=0.0: point_in_rect(x, y, DEEP_RECT, tolerance) |
| bottom_path: list[Point] = [] |
| levels: set[float] = set() |
| for segment in [value for value in program.segments if value.tool == 2]: |
| if min(point.z for point in segment.samples) < -10.0: |
| if segment.motion in {1, 2, 3}: |
| cutting_state(segment, 2) |
| for point in segment.samples: |
| if point.z < -11.15: |
| raise EvaluationError("T2 cuts below the deep-step floor") |
| if point.z < -10.0 and not disk_inside_region(point.x, point.y, radius, region): |
| raise EvaluationError("T2 leaves the central deep-step boundary") |
| elif min(point.z for point in segment.samples) < 0.05: |
| for point in segment.samples: |
| if point.z < 0.05 and not disk_inside_region(point.x, point.y, radius, point_in_upper): |
| raise EvaluationError("T2 rapid/feed motion leaves the previously cleared upper pocket") |
| if segment.motion in {1, 2, 3} and segment_xy_length(segment) > 0.05 and min(segment.start.z, segment.end.z) < -10.35: |
| if not primary_feed(segment, 2) or not segment.plane17: |
| raise EvaluationError("T2 primary cutting feed/plane mismatch") |
| if abs(segment.start.z - segment.end.z) <= 0.15: |
| levels.add(round((segment.start.z + segment.end.z) / 2.0, 2)) |
| if all(abs(point.z + 11.0) <= 0.14 for point in segment.samples): |
| bottom_path.extend(segment.samples) |
| if len(levels) < 2 or min(levels) > -10.9: |
| raise EvaluationError("T2 lacks the Z-11 central deep step") |
| grid = accessible_grid((DEEP_RECT,), radius, region) |
| if not covered(bottom_path, grid, 1.9): |
| raise EvaluationError("central deep-step bottom is under-cleared") |
|
|
|
|
| def validate_drilling(program: Program) -> None: |
| locations: list[tuple[float, float]] = [] |
| drill_segments = [value for value in program.segments if value.tool == 3] |
| if not drill_segments: |
| raise EvaluationError("no T3 drilling segments") |
| for segment in drill_segments: |
| if segment.cycle not in {81, 82, 83} or segment_xy_length(segment) > 0.05: |
| if min(point.z for point in segment.samples) < 0.05: |
| raise EvaluationError("T3 contains non-drilling stock motion") |
| continue |
| cutting_state(segment, 3) |
| if not primary_feed(segment, 3): |
| raise EvaluationError("T3 drilling feed mismatch") |
| if segment.end.z > -18.2 or segment.end.z < -22.0: |
| raise EvaluationError("T3 hole is shallow or excessively deep") |
| nearest = min(HOLES, key=lambda value: math.hypot(segment.end.x - value[0], segment.end.y - value[1])) |
| if math.hypot(segment.end.x - nearest[0], segment.end.y - nearest[1]) > 0.35: |
| raise EvaluationError("unexpected T3 hole location") |
| locations.append(nearest) |
| if set(locations) != set(HOLES): |
| raise EvaluationError("four D5 through-hole locations are incomplete") |
|
|
|
|
| def validate_contour(program: Program) -> None: |
| radius = TOOLS[4]["diameter"] / 2.0 |
| levels: set[float] = set() |
| full_depth_path: list[Point] = [] |
| full_depth_length = 0.0 |
| for segment in [value for value in program.segments if value.tool == 4]: |
| if min(point.z for point in segment.samples) < 0.05: |
| if segment.motion in {1, 2, 3}: |
| cutting_state(segment, 4) |
| for point in segment.samples: |
| if point.z < -18.15: |
| raise EvaluationError("T4 cuts below the part bottom") |
| if point.z < 0.05 and distance_to_stock(point.x, point.y) < radius - 0.18: |
| raise EvaluationError("T4 enters or crosses the finished part") |
| if segment.motion in {1, 2, 3} and segment_xy_length(segment) > 0.05 and min(segment.start.z, segment.end.z) <= -0.1: |
| if abs(segment.start.z - segment.end.z) <= 0.15: |
| levels.add(round((segment.start.z + segment.end.z) / 2.0, 1)) |
| if all(abs(point.z + 18.0) <= 0.14 for point in segment.samples) and primary_feed(segment, 4): |
| if segment.comp in {41, 42} and segment.d_offset != 24: |
| raise EvaluationError("unexpected native contour compensation register") |
| full_depth_path.extend(segment.samples) |
| full_depth_length += distance(segment.start, segment.end) |
| if len(levels) < 3 or min(levels) > -17.9: |
| raise EvaluationError("T4 lacks a multi-depth full contour") |
| targets: list[tuple[float, float]] = [] |
| for index in range(93): |
| y = -46.0 + index |
| targets.extend(((-66.0, y), (66.0, y))) |
| for index in range(133): |
| x = -66.0 + index |
| targets.extend(((x, -46.0), (x, 46.0))) |
| if not covered(full_depth_path, targets, 0.85) or not 430.0 <= full_depth_length <= 520.0: |
| raise EvaluationError("T4 full-depth outside contour is incomplete") |
|
|
|
|
| def validate_program(program: Program) -> None: |
| if not program.terminated: |
| raise EvaluationError("NC program is not terminated") |
| if program.programs != [PROGRAM]: |
| raise EvaluationError("wrong exact O-number") |
|
|
| def first_occurrence_order(values: list[int]) -> list[int]: |
| seen: set[int] = set() |
| order: list[int] = [] |
| for value in values: |
| if value not in seen: |
| seen.add(value) |
| order.append(value) |
| return order |
|
|
| if first_occurrence_order(program.selections) != [1, 2, 3, 4]: |
| raise EvaluationError("first tool-selection order must be T1-T4") |
| if first_occurrence_order(program.changes) != [1, 2, 3, 4]: |
| raise EvaluationError("first effective tool-change order must be T1-T4") |
| for segment in program.segments: |
| if segment.motion in {1, 2, 3} and min(point.z for point in segment.samples) < 0.05: |
| if segment.tool not in TOOLS: |
| raise EvaluationError("stock motion without an allowed tool") |
| cutting_state(segment, int(segment.tool)) |
| validate_upper(program) |
| validate_deep_step(program) |
| validate_drilling(program) |
| validate_contour(program) |
|
|
|
|
| def evaluate_text(src: str) -> bool: |
| try: |
| validate_program(parse_program(src)) |
| return True |
| except (EvaluationError, ValueError, OverflowError, MemoryError): |
| 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 |
| return evaluate_text(path.read_text(encoding="utf-8", errors="strict")) |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| ok = main() |
| except Exception: |
| ok = False |
| print("True" if ok else "False") |
| raise SystemExit(0) |
|
|
