task/single-software-execution/cli/solidcam/task-12/eval.py

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)