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

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)