task/single-software-execution/cli/solidcam/task-07/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"))
CONTRACTS = {
    "variant_01.nc": {"size": (34.0, 16.0), "bottom": -10.5, "diameter": 7.0, "program": 2701},
    "variant_02.nc": {"size": (38.0, 18.0), "bottom": -11.0, "diameter": 8.0, "program": 2702},
    "variant_03.nc": {"size": (42.0, 20.0), "bottom": -11.5, "diameter": 9.0, "program": 2703},
    "variant_04.nc": {"size": (46.0, 22.0), "bottom": -12.0, "diameter": 10.0, "program": 2704},
    "variant_05.nc": {"size": (50.0, 24.0), "bottom": -12.5, "diameter": 11.0, "program": 2705},
}

MAX_FILE_BYTES = 2_000_000
MAX_BLOCKS = 50_000
MAX_PATH_SEGMENTS = 200_000
SURFACE_TOL = 0.01
DEPTH_TOL = 0.08
FLOOR_TOL = 0.08
WALL_TOL = 0.15
COVERAGE_TOL = 0.20
WORD_RE = re.compile(r"([A-Z])([+-]?(?:\d+(?:\.\d*)?|\.\d+))")
ALLOWED_ADDRESSES = set("GMNOXYZIJRFSTH")
ALLOWED_G_CODES = {0, 1, 2, 3, 17, 20, 21, 28, 40, 43, 49, 53, 54, 80, 90, 91, 94}
ALLOWED_M_CODES = {3, 4, 5, 6, 8, 9, 30}


class EvaluationError(ValueError):
    pass


@dataclass(frozen=True)
class Point:
    x: float
    y: float
    z: float


@dataclass(frozen=True)
class Segment:
    points: tuple[Point, ...]
    motion: int
    tool: int | None
    spindle: float | None
    spindle_on: bool
    feed: float | None
    wcs: int | None
    length_comp: bool
    h_offset: int | None


@dataclass(frozen=True)
class Program:
    program_number: int
    tool_changes: tuple[int, ...]
    segments: tuple[Segment, ...]
    terminated: bool


def integer_code(value: float, label: str) -> int:
    if not math.isfinite(value) or abs(value - round(value)) > 1e-9:
        raise EvaluationError(f"non-integer {label}")
    return int(round(value))


def distance_3d(a: Point, b: Point) -> float:
    return math.dist((a.x, a.y, a.z), (b.x, b.y, b.z))


def strip_comments(source: str) -> list[str]:
    lines: list[str] = []
    depth = 0
    for raw in source.upper().splitlines():
        clean: list[str] = []
        for char in raw:
            if char == ";" and depth == 0:
                break
            if char == "(":
                if depth:
                    raise EvaluationError("nested parenthesis comment")
                depth = 1
            elif char == ")":
                if not depth:
                    raise EvaluationError("unmatched parenthesis comment")
                depth = 0
            elif depth == 0:
                clean.append(char)
        lines.append("".join(clean).strip())
    if depth:
        raise EvaluationError("unterminated parenthesis comment")
    return lines


def parse_words(line: str) -> dict[str, list[float]] | None:
    compact = re.sub(r"\s+", "", line)
    if not compact:
        return None
    if compact == "%":
        return {}
    if "%" in compact or any(char in compact for char in "#[]=/"):
        raise EvaluationError("unsupported executable syntax")
    matches = list(WORD_RE.finditer(compact))
    if not matches or "".join(match.group(0) for match in matches) != compact:
        raise EvaluationError("unknown executable text")
    grouped: dict[str, list[float]] = {}
    for match in matches:
        address = match.group(1)
        if address not in ALLOWED_ADDRESSES:
            raise EvaluationError(f"unknown address {address}")
        value = float(match.group(2))
        if not math.isfinite(value):
            raise EvaluationError("non-finite word")
        grouped.setdefault(address, []).append(value)
    for address, values in grouped.items():
        if address not in {"G", "M"} and len(values) != 1:
            raise EvaluationError(f"duplicate {address} address")
    return grouped


def directional_sweep(start_angle: float, end_angle: float, clockwise: bool, full_circle: bool) -> float:
    if full_circle:
        return -2.0 * math.pi if clockwise else 2.0 * math.pi
    if clockwise:
        magnitude = (start_angle - end_angle) % (2.0 * math.pi)
        return -magnitude
    return (end_angle - start_angle) % (2.0 * math.pi)


def center_from_radius(start: Point, end: Point, radius_word: float, clockwise: bool) -> tuple[float, float, float]:
    dx, dy = end.x - start.x, end.y - start.y
    chord = math.hypot(dx, dy)
    radius = abs(radius_word)
    if chord <= 1e-9 or radius < chord / 2.0 - 0.02:
        raise EvaluationError("invalid R arc")
    half = chord / 2.0
    height = math.sqrt(max(radius * radius - half * half, 0.0))
    mid_x, mid_y = (start.x + end.x) / 2.0, (start.y + end.y) / 2.0
    perp_x, perp_y = -dy / chord, dx / chord
    candidates = [
        (mid_x + height * perp_x, mid_y + height * perp_y),
        (mid_x - height * perp_x, mid_y - height * perp_y),
    ]
    choices: list[tuple[float, float, float]] = []
    for center_x, center_y in candidates:
        a0 = math.atan2(start.y - center_y, start.x - center_x)
        a1 = math.atan2(end.y - center_y, end.x - center_x)
        sweep = directional_sweep(a0, a1, clockwise, False)
        magnitude = abs(sweep)
        wants_minor = radius_word >= 0
        if (wants_minor and magnitude <= math.pi + 1e-7) or (not wants_minor and magnitude >= math.pi - 1e-7):
            choices.append((center_x, center_y, sweep))
    if not choices:
        raise EvaluationError("ambiguous R arc")
    return choices[0]


def arc_points(
    start: Point,
    end: Point,
    clockwise: bool,
    i_word: float | None,
    j_word: float | None,
    radius_word: float | None,
) -> tuple[Point, ...]:
    if radius_word is not None and (i_word is not None or j_word is not None):
        raise EvaluationError("arc mixes I/J and R")
    if radius_word is not None:
        center_x, center_y, sweep = center_from_radius(start, end, radius_word, clockwise)
        radius = abs(radius_word)
        start_angle = math.atan2(start.y - center_y, start.x - center_x)
    else:
        if i_word is None and j_word is None:
            raise EvaluationError("arc lacks I/J or R")
        center_x = start.x + (i_word or 0.0)
        center_y = start.y + (j_word or 0.0)
        radius = math.hypot(start.x - center_x, start.y - center_y)
        end_radius = math.hypot(end.x - center_x, end.y - center_y)
        if radius <= 1e-6 or abs(radius - end_radius) > max(0.05, radius * 0.002):
            raise EvaluationError("invalid I/J arc")
        start_angle = math.atan2(start.y - center_y, start.x - center_x)
        end_angle = math.atan2(end.y - center_y, end.x - center_x)
        full_circle = math.hypot(end.x - start.x, end.y - start.y) <= 1e-7
        sweep = directional_sweep(start_angle, end_angle, clockwise, full_circle)
    if abs(sweep) <= 1e-9:
        raise EvaluationError("zero-length arc")
    count = max(8, int(math.ceil(radius * abs(sweep) / 0.35)))
    if count > MAX_PATH_SEGMENTS:
        raise EvaluationError("arc is too large")
    points = []
    for index in range(count + 1):
        fraction = index / count
        angle = start_angle + sweep * fraction
        points.append(
            Point(
                center_x + radius * math.cos(angle),
                center_y + radius * math.sin(angle),
                start.z + (end.z - start.z) * fraction,
            )
        )
    points[0] = start
    points[-1] = end
    return tuple(points)


def parse_program(source: str) -> Program:
    units: str | None = None
    absolute: bool | None = None
    motion: int | None = None
    plane: int | None = None
    current: dict[str, float | None] = {"X": None, "Y": None, "Z": None}
    pending_tool: int | None = None
    active_tool: int | None = None
    spindle: float | None = None
    spindle_on = False
    feed: float | None = None
    wcs: int | None = None
    length_comp = False
    h_offset: int | None = None
    program_number: int | None = None
    tool_changes: list[int] = []
    segments: list[Segment] = []
    terminated = False
    block_count = 0

    for line in strip_comments(source):
        grouped = parse_words(line)
        if grouped is None or grouped == {}:
            continue
        block_count += 1
        if block_count > MAX_BLOCKS:
            raise EvaluationError("too many blocks")
        if terminated:
            raise EvaluationError("executable code after M30")

        if "O" in grouped:
            if program_number is not None or block_count != 1 or set(grouped) - {"N", "O"}:
                raise EvaluationError("invalid program-number block")
            program_number = integer_code(grouped["O"][0], "O number")
            continue
        if program_number is None:
            raise EvaluationError("executable code before O number")

        g_codes = [integer_code(value, "G code") for value in grouped.get("G", [])]
        m_codes = [integer_code(value, "M code") for value in grouped.get("M", [])]
        if any(code not in ALLOWED_G_CODES for code in g_codes):
            raise EvaluationError("unsupported G code")
        if any(code not in ALLOWED_M_CODES for code in m_codes):
            raise EvaluationError("unsupported M code")
        for family in ({0, 1, 2, 3}, {20, 21}, {90, 91}):
            if len(family.intersection(g_codes)) > 1:
                raise EvaluationError("conflicting modal G codes")
        if len(m_codes) != len(set(m_codes)):
            raise EvaluationError("duplicate M code")

        if 30 in m_codes:
            if m_codes[-1] != 30 or set(grouped) - {"N", "M"} or any(code not in {5, 9, 30} for code in m_codes):
                raise EvaluationError("unsafe M30 block")
            if 5 in m_codes:
                spindle_on = False
            terminated = True
            continue

        if 20 in g_codes:
            units = "inch"
        elif 21 in g_codes:
            units = "mm"
        if 90 in g_codes:
            absolute = True
        elif 91 in g_codes:
            absolute = False
        for code in (0, 1, 2, 3):
            if code in g_codes:
                motion = code
        if 17 in g_codes:
            plane = 17
        if 54 in g_codes:
            wcs = 54
        if "H" in grouped:
            if integer_code(grouped["H"][0], "H offset") != 1 or 43 not in g_codes:
                raise EvaluationError("only G43 H1 is allowed")
        if 43 in g_codes:
            if "H" not in grouped:
                raise EvaluationError("G43 lacks H1")
            length_comp = True
            h_offset = 1
        if 49 in g_codes:
            length_comp = False
            h_offset = None

        factor = 25.4 if units == "inch" else 1.0
        if "T" in grouped:
            pending_tool = integer_code(grouped["T"][0], "tool")
            if pending_tool != 1:
                raise EvaluationError("extra tool")
        if "S" in grouped:
            spindle = grouped["S"][0]
            if spindle <= 0:
                raise EvaluationError("non-positive spindle speed")
        if "F" in grouped:
            if units is None:
                raise EvaluationError("feed before units")
            feed = grouped["F"][0] * factor
            if feed <= 0:
                raise EvaluationError("non-positive feed")
        if 6 in m_codes:
            if pending_tool != 1:
                raise EvaluationError("M6 without T1")
            active_tool = 1
            tool_changes.append(1)
            spindle_on = False
            length_comp = False
            h_offset = None
        if 3 in m_codes or 4 in m_codes:
            if spindle is None or spindle <= 0:
                raise EvaluationError("spindle start lacks positive S")
            spindle_on = True
        if 5 in m_codes:
            spindle_on = False

        axes = {axis for axis in ("X", "Y", "Z") if axis in grouped}
        arc_addresses = {axis for axis in ("I", "J", "R") if axis in grouped}
        if (axes or arc_addresses) and units is None:
            raise EvaluationError("coordinates before units")

        if 28 in g_codes:
            if not axes or arc_addresses or "F" in grouped or {0, 1, 2, 3, 53}.intersection(g_codes):
                raise EvaluationError("invalid G28 reference return")
            for axis in axes:
                current[axis] = None
            continue

        if 53 in g_codes:
            if not axes or arc_addresses or "F" in grouped or 0 not in g_codes:
                raise EvaluationError("G53 cutting or modal motion is forbidden")
            for axis in axes:
                current[axis] = None
            continue

        if not axes and not arc_addresses:
            continue
        if absolute is None:
            raise EvaluationError("motion before G90/G91")
        if motion is None:
            raise EvaluationError("coordinates without motion mode")
        if motion in {0, 1} and arc_addresses:
            raise EvaluationError("arc address on linear motion")
        if motion in {2, 3} and plane != 17:
            raise EvaluationError("arc is not in G17 plane")

        old = dict(current)
        new = dict(current)
        for axis in ("X", "Y", "Z"):
            if axis not in grouped:
                continue
            value = grouped[axis][0] * factor
            if absolute:
                new[axis] = value
            else:
                if old[axis] is None:
                    raise EvaluationError("incremental move from unknown position")
                new[axis] = float(old[axis]) + value
        current = new
        if any(old[axis] is None or new[axis] is None for axis in ("X", "Y", "Z")):
            if motion != 0:
                raise EvaluationError("feed move from unknown position")
            continue

        start = Point(float(old["X"]), float(old["Y"]), float(old["Z"]))
        end = Point(float(new["X"]), float(new["Y"]), float(new["Z"]))
        if motion in {2, 3}:
            i_word = grouped.get("I", [None])[0]
            j_word = grouped.get("J", [None])[0]
            r_word = grouped.get("R", [None])[0]
            points = arc_points(
                start,
                end,
                motion == 2,
                None if i_word is None else i_word * factor,
                None if j_word is None else j_word * factor,
                None if r_word is None else r_word * factor,
            )
        else:
            points = (start, end)
        if len(segments) + len(points) > MAX_PATH_SEGMENTS:
            raise EvaluationError("too many path segments")
        segments.append(
            Segment(
                points=points,
                motion=motion,
                tool=active_tool,
                spindle=spindle,
                spindle_on=spindle_on,
                feed=feed,
                wcs=wcs,
                length_comp=length_comp,
                h_offset=h_offset,
            )
        )

    if program_number is None:
        raise EvaluationError("missing O number")
    return Program(program_number, tuple(tool_changes), tuple(segments), terminated)


def interpolate_at_z(a: Point, b: Point, z_value: float) -> Point:
    if abs(b.z - a.z) <= 1e-12:
        return a
    fraction = (z_value - a.z) / (b.z - a.z)
    return Point(a.x + (b.x - a.x) * fraction, a.y + (b.y - a.y) * fraction, z_value)


def below_surface_portion(a: Point, b: Point) -> tuple[Point, Point] | None:
    threshold = -SURFACE_TOL
    a_below, b_below = a.z <= threshold, b.z <= threshold
    if not a_below and not b_below:
        return None
    if a_below and b_below:
        return a, b
    crossing = interpolate_at_z(a, b, threshold)
    return (a, crossing) if a_below else (crossing, b)


def point_segment_distance_xy(x: float, y: float, a: Point, b: Point) -> float:
    dx, dy = b.x - a.x, b.y - a.y
    length_squared = dx * dx + dy * dy
    if length_squared <= 1e-16:
        return math.hypot(x - a.x, y - a.y)
    fraction = max(0.0, min(1.0, ((x - a.x) * dx + (y - a.y) * dy) / length_squared))
    return math.hypot(x - (a.x + fraction * dx), y - (a.y + fraction * dy))


def rectangle_distance(x: float, y: float, xmin: float, xmax: float, ymin: float, ymax: float) -> float:
    return math.hypot(max(xmin - x, 0.0, x - xmax), max(ymin - y, 0.0, y - ymax))


def grid_values(low: float, high: float, spacing: float) -> list[float]:
    if high < low:
        return []
    count = max(1, int(math.ceil((high - low) / spacing)))
    return [low + (high - low) * index / count for index in range(count + 1)]


def validate_program(program: Program, contract: dict[str, object]) -> None:
    if not program.terminated:
        raise EvaluationError("missing M30")
    if program.program_number != int(contract["program"]):
        raise EvaluationError("wrong exact O number")
    if program.tool_changes != (1,):
        raise EvaluationError("expected exactly one T1/M6")

    width, height = (float(value) for value in contract["size"])
    bottom = float(contract["bottom"])
    radius = float(contract["diameter"]) / 2.0
    x_limit = width / 2.0 - radius
    y_limit = height / 2.0 - radius
    floor_segments: list[tuple[Point, Point]] = []
    saw_cut = False
    saw_safe_rapid = False

    for segment in program.segments:
        if segment.motion == 0 and any(point.z >= 2.0 for point in segment.points):
            saw_safe_rapid = True
        for start, end in zip(segment.points, segment.points[1:]):
            portion = below_surface_portion(start, end)
            if portion is not None:
                for point in portion:
                    if point.z < bottom - DEPTH_TOL:
                        raise EvaluationError("toolpath cuts below the pocket floor")
                    if abs(point.x) > x_limit + WALL_TOL or abs(point.y) > y_limit + WALL_TOL:
                        raise EvaluationError("tool center overcuts a pocket wall")
                if segment.tool != 1 or segment.wcs != 54 or not segment.length_comp or segment.h_offset != 1:
                    raise EvaluationError("subsurface move lacks T1, G54, or G43 H1")
                if segment.motion in {1, 2, 3}:
                    if not segment.spindle_on or segment.spindle is None or segment.spindle <= 0:
                        raise EvaluationError("cut with spindle stopped")
                    if segment.feed is None or segment.feed <= 0:
                        raise EvaluationError("cut lacks positive feed")
                    if distance_3d(start, end) > 1e-6:
                        saw_cut = True
            if (
                segment.motion in {1, 2, 3}
                and abs(start.z - bottom) <= FLOOR_TOL
                and abs(end.z - bottom) <= FLOOR_TOL
                and math.hypot(end.x - start.x, end.y - start.y) > 1e-5
            ):
                floor_segments.append((start, end))

    if not saw_cut or not saw_safe_rapid or not floor_segments:
        raise EvaluationError("incomplete executable pocket program")

    floor_points = [point for pair in floor_segments for point in pair]
    if (
        min(point.x for point in floor_points) > -x_limit + WALL_TOL
        or max(point.x for point in floor_points) < x_limit - WALL_TOL
        or min(point.y for point in floor_points) > -y_limit + WALL_TOL
        or max(point.y for point in floor_points) < y_limit - WALL_TOL
    ):
        raise EvaluationError("floor toolpath does not reach all four walls")

    inset = 0.12
    spacing = min(0.75, max(0.45, radius / 6.0))
    for x in grid_values(-width / 2.0 + inset, width / 2.0 - inset, spacing):
        for y in grid_values(-height / 2.0 + inset, height / 2.0 - inset, spacing):
            if rectangle_distance(x, y, -x_limit, x_limit, -y_limit, y_limit) > radius - inset:
                continue
            if min(point_segment_distance_xy(x, y, start, end) for start, end in floor_segments) > radius + COVERAGE_TOL:
                raise EvaluationError("bottom swept area has uncleared material")


def evaluate_text(source: str, contract: dict[str, object]) -> bool:
    try:
        validate_program(parse_program(source), contract)
        return True
    except (EvaluationError, UnicodeError, ValueError, OverflowError):
        return False


def read_nc(path: Path) -> str:
    raw = path.read_bytes()
    if not raw or len(raw) > MAX_FILE_BYTES or b"\x00" in raw:
        raise EvaluationError("invalid NC file size or encoding")
    return raw.decode("utf-8-sig", errors="strict")


def evaluate_directory(target: Path) -> bool:
    for name, contract in CONTRACTS.items():
        path = target / name
        if not path.is_file() or not evaluate_text(read_nc(path), contract):
            return False
    return True


def main() -> bool:
    return evaluate_directory(TARGET)


if __name__ == "__main__":
    try:
        result = main()
    except Exception:
        result = False
    print("True" if result else "False")
    raise SystemExit(0)