Datasets:

HongchengGao
/

EngiWorld-Tasks

from __future__ import annotations

import csv
import json
import math
import os
import subprocess
import tempfile
import textwrap
from pathlib import Path


TARGET = Path(os.environ.get("ENGIWORLD_EVAL_TARGET", "/home/user/Desktop"))
CSV_PATH = TARGET / "tool_library.csv"
STEP_PATH = TARGET / "multi_feature.step"
FCSTD_PATH = TARGET / "task-05.FCStd"
NC_PATH = TARGET / "task-05.nc"
NATIVE_MARKER = "TASK_C05_NATIVE="
EXPECTED_TOOLS = (
    (1, "end mill", 16.0, 7000.0, 500.0, 5),
    (2, "drill", 14.0, 7000.0, 500.0, 5),
    (3, "drill", 12.0, 7000.0, 500.0, 5),
)


def close(actual: float, expected: float, tolerance: float = 1e-6) -> bool:
    return math.isfinite(actual) and abs(actual - expected) <= tolerance


def load_tool_library(path: Path) -> bool:
    if not path.is_file() or not 40 <= path.stat().st_size <= 20_000:
        return False
    try:
        with path.open(newline="", encoding="utf-8-sig") as stream:
            reader = csv.DictReader(stream)
            if reader.fieldnames != [
                "tool_number",
                "type",
                "diameter",
                "spindle",
                "feed",
                "operation_count",
            ]:
                return False
            rows = list(reader)
        parsed = []
        for row in rows:
            number = float(row["tool_number"])
            operation_count = float(row["operation_count"])
            if not close(number, round(number)) or not close(operation_count, round(operation_count)):
                return False
            parsed.append(
                (
                    int(round(number)),
                    row["type"].strip().lower(),
                    float(row["diameter"]),
                    float(row["spindle"]),
                    float(row["feed"]),
                    int(round(operation_count)),
                )
            )
    except (OSError, TypeError, ValueError, csv.Error):
        return False
    if len(parsed) != len(EXPECTED_TOOLS):
        return False
    for actual, expected in zip(parsed, EXPECTED_TOOLS):
        if actual[:2] != expected[:2] or actual[-1] != expected[-1]:
            return False
        if any(not close(float(a), float(e)) for a, e in zip(actual[2:5], expected[2:5])):
            return False
    return True


def native_check(fcstd_path: Path, step_path: Path, nc_path: Path) -> bool:
    for path, minimum, maximum in (
        (fcstd_path, 1_000, 20_000_000),
        (step_path, 1_000, 20_000_000),
        (nc_path, 1_000, 5_000_000),
    ):
        if not path.is_file() or not minimum <= path.stat().st_size <= maximum:
            return False

    checker = textwrap.dedent(
        r'''
        import json
        import math
        import re
        import FreeCAD as App
        import Part
        import Path.Post.Command as PathPostCommand
        from Path.Post.Processor import PostProcessor

        FILE = __FILE__
        STEP_FILE = __STEP_FILE__
        NC_FILE = __NC_FILE__
        MARKER = __MARKER__
        TOL = 1e-4
        WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:E[+-]?\d+)?)", re.I)
        HOLES = {
            (-42.0, 0.0): (2, 14.0),
            (42.0, 0.0): (2, 14.0),
            (0.0, -28.0): (3, 12.0),
            (0.0, 28.0): (3, 12.0),
        }
        EXPECTED_MODULES = [
            "Path.Op.MillFace",
            "Path.Op.PocketShape",
            "Path.Op.Drilling",
            "Path.Op.Drilling",
            "Path.Op.Profile",
        ]
        EXPECTED_CLASSES = ["ObjectFace", "ObjectPocket", "ObjectDrilling", "ObjectDrilling", "ObjectProfile"]
        result = {"ok": False}
        doc = None

        def near(value, expected, tolerance=TOL):
            return math.isfinite(float(value)) and abs(float(value) - expected) <= tolerance

        def bounds(shape):
            box = shape.BoundBox
            return [box.XMin, box.XMax, box.YMin, box.YMax, box.ZMin, box.ZMax]

        def cylinders(shape):
            found = []
            for face in shape.Faces:
                if isinstance(face.Surface, Part.Cylinder):
                    surface = face.Surface
                    box = face.BoundBox
                    found.append((
                        round(surface.Center.x, 4),
                        round(surface.Center.y, 4),
                        round(2.0 * surface.Radius, 4),
                        round(box.ZMin, 4),
                        round(box.ZMax, 4),
                    ))
            return sorted(found)

        def check_shape(shape, expected_box, expected_cylinders, expected_volume, label):
            if shape.isNull() or not shape.isValid() or len(shape.Solids) != 1:
                raise RuntimeError(label + " is not one valid solid")
            if any(not near(a, b, 1e-5) for a, b in zip(bounds(shape), expected_box)):
                raise RuntimeError(label + " bounds are wrong")
            if not near(shape.Volume, expected_volume, 1e-3):
                raise RuntimeError(label + " volume is wrong")
            if cylinders(shape) != sorted(expected_cylinders):
                raise RuntimeError(label + " cylindrical geometry is wrong")

        def shape_of_reference(base, subname):
            try:
                return base.Shape.getElement(str(subname))
            except Exception:
                return None

        def selected_points(operation):
            points = [(float(point.x), float(point.y)) for point in operation.Locations]
            disabled = set(str(value) for value in operation.Disabled)
            for base, subnames in operation.Base:
                for subname in subnames:
                    if "{}.{}".format(base.Name, subname) in disabled:
                        continue
                    point = operation.Proxy.holePosition(operation, base, subname)
                    if point is None:
                        raise RuntimeError("Drilling Base contains a non-hole feature")
                    points.append((float(point.x), float(point.y)))
            return points

        def sampled_segments(operation, target_z, z_tolerance=0.03):
            segments = []
            x = y = z = None
            for command in operation.Path.Commands:
                name = str(command.Name).upper()
                params = command.Parameters
                if name not in ("G0", "G00", "G1", "G01", "G2", "G02", "G3", "G03"):
                    continue
                nx = float(params.get("X", x)) if params.get("X", x) is not None else None
                ny = float(params.get("Y", y)) if params.get("Y", y) is not None else None
                nz = float(params.get("Z", z)) if params.get("Z", z) is not None else None
                cutting = name in ("G1", "G01", "G2", "G02", "G3", "G03")
                if cutting and None not in (x, y, z, nx, ny, nz) and near(z, target_z, z_tolerance) and near(nz, target_z, z_tolerance):
                    start = (float(x), float(y))
                    end = (float(nx), float(ny))
                    if name in ("G2", "G02", "G3", "G03") and "I" in params and "J" in params:
                        cx = float(x) + float(params["I"])
                        cy = float(y) + float(params["J"])
                        radius = math.hypot(float(x) - cx, float(y) - cy)
                        a0 = math.atan2(float(y) - cy, float(x) - cx)
                        a1 = math.atan2(float(ny) - cy, float(nx) - cx)
                        if name in ("G2", "G02"):
                            sweep = -((a0 - a1) % (2.0 * math.pi))
                        else:
                            sweep = (a1 - a0) % (2.0 * math.pi)
                        if near(sweep, 0.0, 1e-8) and math.hypot(end[0] - start[0], end[1] - start[1]) < TOL:
                            sweep = -2.0 * math.pi if name in ("G2", "G02") else 2.0 * math.pi
                        count = max(2, int(math.ceil(abs(sweep) * max(radius, 1.0) / 0.5)))
                        previous = start
                        for index in range(1, count + 1):
                            angle = a0 + sweep * index / count
                            point = (cx + radius * math.cos(angle), cy + radius * math.sin(angle))
                            segments.append((previous, point))
                            previous = point
                    elif math.hypot(end[0] - start[0], end[1] - start[1]) > TOL:
                        segments.append((start, end))
                x, y, z = nx, ny, nz
            return segments

        def point_segment_distance(point, segment):
            px, py = point
            (ax, ay), (bx, by) = segment
            dx, dy = bx - ax, by - ay
            length2 = dx * dx + dy * dy
            if length2 <= 1e-16:
                return math.hypot(px - ax, py - ay)
            t = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / length2))
            return math.hypot(px - (ax + t * dx), py - (ay + t * dy))

        def arc_points(start, end, name, params):
            if "I" not in params or "J" not in params:
                raise RuntimeError("arc lacks I/J center offsets")
            cx = start[0] + float(params["I"])
            cy = start[1] + float(params["J"])
            radius = math.hypot(start[0] - cx, start[1] - cy)
            if radius <= TOL:
                raise RuntimeError("arc radius is zero")
            if abs(math.hypot(end[0] - cx, end[1] - cy) - radius) > 0.02:
                raise RuntimeError("arc end radius differs from its start radius")
            a0 = math.atan2(start[1] - cy, start[0] - cx)
            a1 = math.atan2(end[1] - cy, end[0] - cx)
            if name in ("G2", "G02"):
                sweep = -((a0 - a1) % (2.0 * math.pi))
            else:
                sweep = (a1 - a0) % (2.0 * math.pi)
            if near(sweep, 0.0, 1e-8) and math.hypot(end[0] - start[0], end[1] - start[1]) < TOL:
                sweep = -2.0 * math.pi if name in ("G2", "G02") else 2.0 * math.pi
            count = max(2, int(math.ceil(abs(sweep) * radius / 0.5)))
            points = [
                (cx + radius * math.cos(a0 + sweep * index / count), cy + radius * math.sin(a0 + sweep * index / count))
                for index in range(count + 1)
            ]
            points[-1] = end
            return points

        def validate_area_motion(operation, kind):
            safe_z = float(operation.SafeHeight.Value)
            x = y = z = None
            allowed = {"G0", "G00", "G1", "G01", "G2", "G02", "G3", "G03"}
            for command in operation.Path.Commands:
                name = str(command.Name).upper()
                params = command.Parameters
                if name.startswith(("M", "T", "S")):
                    raise RuntimeError(kind + " operation contains a tool or spindle command")
                if name.startswith("G") and name not in allowed:
                    raise RuntimeError(kind + " contains an unexpected modal command")
                if name not in allowed:
                    continue
                nx = float(params.get("X", x)) if params.get("X", x) is not None else None
                ny = float(params.get("Y", y)) if params.get("Y", y) is not None else None
                nz = float(params.get("Z", z)) if params.get("Z", z) is not None else None
                has_xy = "X" in params or "Y" in params
                if name in ("G0", "G00") and has_xy:
                    if z is None or nz is None or float(z) < safe_z - TOL or float(nz) < safe_z - TOL:
                        raise RuntimeError(kind + " contains an unsafe low-Z XY rapid")
                if name in ("G0", "G00") and "Z" in params:
                    if nz is None or ((z is None or float(nz) < float(z) - TOL) and float(nz) < safe_z - TOL):
                        raise RuntimeError(kind + " contains an unsafe downward Z rapid")
                if name in ("G1", "G01", "G2", "G02", "G3", "G03"):
                    if None in (x, y, z, nx, ny, nz):
                        raise RuntimeError(kind + " cutting move has unknown coordinates")
                    lower_z = min(float(z), float(nz))
                    limit = {"Face": 0.0, "Pocket": -6.0, "Profile": -18.0}[kind]
                    if lower_z < limit - 0.02:
                        raise RuntimeError(kind + " cuts below its final depth")
                    start = (float(x), float(y))
                    end = (float(nx), float(ny))
                    points = arc_points(start, end, name, params) if name in ("G2", "G02", "G3", "G03") else [start, end]
                    if kind == "Pocket" and any(abs(px) > 17.08 or abs(py) > 7.08 for px, py in points):
                        raise RuntimeError("Pocket cutter gouges outside the R8 pocket")
                    if kind == "Profile" and any(rectangle_distance(px, py) < 7.92 for px, py in points):
                        raise RuntimeError("Profile cutter enters the finished part")
                x, y, z = nx, ny, nz

        def validate_drill_motion(operation):
            x = y = z = None
            retract_mode = None
            cycle_active = False
            allowed = {"G0", "G00", "G80", "G81", "G82", "G83", "G90", "G98", "G99"}
            for command in operation.Path.Commands:
                name = str(command.Name).upper()
                params = command.Parameters
                if name.startswith(("M", "T", "S")):
                    raise RuntimeError("Drilling operation contains a tool or spindle command")
                if name.startswith("G") and name not in allowed:
                    raise RuntimeError("Drilling contains an unexpected motion command")
                if name == "G98":
                    retract_mode = 98
                    continue
                if name == "G99":
                    retract_mode = 99
                    continue
                if name == "G80":
                    cycle_active = False
                    continue
                if name in ("G0", "G00"):
                    nx = float(params.get("X", x)) if params.get("X", x) is not None else None
                    ny = float(params.get("Y", y)) if params.get("Y", y) is not None else None
                    nz = float(params.get("Z", z)) if params.get("Z", z) is not None else None
                    has_xy = "X" in params or "Y" in params
                    if has_xy and (z is None or nz is None or float(z) <= 1.0 or float(nz) <= 1.0):
                        raise RuntimeError("Drilling contains an unsafe low-Z XY rapid")
                    if "Z" in params and (nz is None or ((z is None or float(nz) < float(z) - TOL) and float(nz) <= 1.0)):
                        raise RuntimeError("Drilling contains an unsafe downward Z rapid")
                    x, y, z = nx, ny, nz
                elif name in ("G81", "G82", "G83"):
                    if retract_mode not in (98, 99) or z is None:
                        raise RuntimeError("Drilling cycle lacks a safe retract mode")
                    nx = float(params.get("X", x)) if params.get("X", x) is not None else None
                    ny = float(params.get("Y", y)) if params.get("Y", y) is not None else None
                    if nx is None or ny is None or "R" not in params or "Z" not in params:
                        raise RuntimeError("Drilling cycle coordinates are incomplete")
                    return_z = float(z) if retract_mode == 98 else float(params["R"])
                    if return_z <= 1.0:
                        raise RuntimeError("Drilling returns below the stock top")
                    cycle_active = True
                    x, y, z = nx, ny, return_z
            if cycle_active:
                raise RuntimeError("Drilling leaves a canned cycle active")

        def distance_to_path(point, segments):
            if not segments:
                return float("inf")
            return min(point_segment_distance(point, segment) for segment in segments)

        def check_face_coverage(operation):
            segments = sampled_segments(operation, 0.0)
            if not segments:
                raise RuntimeError("Face path is empty or trivial")
            for ix in range(63):
                x = -62.0 + 2.0 * ix
                for iy in range(43):
                    y = -42.0 + 2.0 * iy
                    if distance_to_path((x, y), segments) > 8.08:
                        raise RuntimeError("Face path does not cover the complete stock top")

        def inside_rounded_pocket(x, y):
            ax, ay = abs(x), abs(y)
            if ax > 25.0 + TOL or ay > 15.0 + TOL:
                return False
            if ax <= 17.0 or ay <= 7.0:
                return True
            return (ax - 17.0) ** 2 + (ay - 7.0) ** 2 <= 64.0 + TOL

        def check_pocket_coverage(operation):
            segments = sampled_segments(operation, -6.0)
            if not segments:
                raise RuntimeError("Pocket path does not clear the final depth")
            for ix in range(101):
                x = -25.0 + 0.5 * ix
                for iy in range(61):
                    y = -15.0 + 0.5 * iy
                    if inside_rounded_pocket(x, y) and distance_to_path((x, y), segments) > 8.08:
                        raise RuntimeError("Pocket path leaves material at final depth")
            all_cutting = []
            for depth in (-3.0, -6.0):
                all_cutting.extend(sampled_segments(operation, depth))
            for segment in all_cutting:
                for x, y in segment:
                    if abs(x) > 17.08 or abs(y) > 7.08:
                        raise RuntimeError("Pocket cutter gouges outside the R8 pocket")

        def rectangle_distance(x, y):
            return math.hypot(max(abs(x) - 60.0, 0.0), max(abs(y) - 40.0, 0.0))

        def check_profile_coverage(operation):
            segments = sampled_segments(operation, -18.0)
            if len(segments) < 4:
                raise RuntimeError("Profile path is empty or not closed")
            for segment in segments:
                for x, y in segment:
                    if rectangle_distance(x, y) < 7.92:
                        raise RuntimeError("Profile cutter enters the finished part")
            boundary = []
            for index in range(121):
                x = -60.0 + index
                boundary.extend(((x, -40.0), (x, 40.0)))
            for index in range(81):
                y = -40.0 + index
                boundary.extend(((-60.0, y), (60.0, y)))
            closed_contour = None
            for start in range(len(segments)):
                for end in range(start + 3, len(segments)):
                    first = segments[start][0]
                    last = segments[end][1]
                    if math.hypot(first[0] - last[0], first[1] - last[1]) > 0.12:
                        continue
                    candidate = segments[start : end + 1]
                    if all(distance_to_path(point, candidate) <= 8.08 for point in boundary):
                        closed_contour = candidate
                        break
                if closed_contour is not None:
                    break
            if closed_contour is None:
                raise RuntimeError("Profile lacks a closed contour covering the complete outside boundary")

        def strip_comments(text):
            output = []
            paren_depth = 0
            semicolon_comment = False
            for char in text:
                if semicolon_comment:
                    if char == "\n":
                        semicolon_comment = False
                        output.append(char)
                elif paren_depth:
                    if char == "(":
                        paren_depth += 1
                    elif char == ")":
                        paren_depth -= 1
                    elif char == "\n":
                        output.append(char)
                elif char == "(":
                    paren_depth = 1
                elif char == ")":
                    raise RuntimeError("unmatched NC comment terminator")
                elif char == ";":
                    semicolon_comment = True
                else:
                    output.append(char)
            if paren_depth:
                raise RuntimeError("unterminated NC comment")
            return "".join(output)

        def canonical_nc(text):
            canonical = []
            blocks = [line.strip().upper() for line in strip_comments(text).splitlines() if line.strip()]
            wrappers = [index for index, block in enumerate(blocks) if block == "%"]
            if wrappers:
                if wrappers != [0, len(blocks) - 1]:
                    raise RuntimeError("percent wrappers are not a single outer pair")
                blocks = blocks[1:-1]
            for cleaned in blocks:
                if "%" in cleaned:
                    raise RuntimeError("percent wrapper is embedded in an NC block")
                words = []
                cursor = 0
                for match in WORD_RE.finditer(cleaned):
                    if cleaned[cursor:match.start()].strip():
                        raise RuntimeError("malformed NC block")
                    letter = match.group(1)
                    value = float(match.group(2))
                    if not math.isfinite(value):
                        raise RuntimeError("non-finite NC word")
                    if letter != "N":
                        if letter in ("G", "M", "T", "H"):
                            if not near(value, round(value), 1e-6):
                                raise RuntimeError("non-integral modal NC word")
                            value = int(round(value))
                            if letter == "M" and value == 30:
                                value = 2
                        else:
                            value = round(value, 3)
                            if value == -0.0:
                                value = 0.0
                        words.append((letter, value))
                    cursor = match.end()
                if cleaned[cursor:].strip() or not words:
                    raise RuntimeError("malformed or empty NC block")
                canonical.append(tuple(sorted(words)))
            return canonical

        try:
            version = App.Version()
            if tuple(version[:3]) != ("0", "21", "2") or "b9bfa5c5507506e4515816414cd27f4851d00489" not in version:
                raise RuntimeError("wrong FreeCAD build")
            doc = App.openDocument(FILE)
            if doc is None:
                raise RuntimeError("FCStd did not open")
            doc.recompute()
            jobs = [
                obj for obj in doc.Objects
                if type(getattr(obj, "Proxy", None)).__module__ == "Path.Main.Job"
                and type(getattr(obj, "Proxy", None)).__name__ == "ObjectJob"
            ]
            if len(jobs) != 1:
                raise RuntimeError("expected exactly one native Job")
            job = jobs[0]
            models = list(job.Model.Group)
            controllers = list(job.Tools.Group)
            operations = list(job.Operations.Group)
            if len(models) != 1 or len(controllers) != 3 or len(operations) != 5:
                raise RuntimeError("wrong Job group cardinality")
            if [type(op.Proxy).__module__ for op in operations] != EXPECTED_MODULES:
                raise RuntimeError("wrong native operation sequence")
            if [type(op.Proxy).__name__ for op in operations] != EXPECTED_CLASSES:
                raise RuntimeError("wrong native operation types")
            path_ops = [obj for obj in doc.Objects if type(getattr(obj, "Proxy", None)).__module__.startswith("Path.Op.")]
            if set(path_ops) != set(operations):
                raise RuntimeError("FCStd contains ungrouped or fake Path operations")
            if any(not bool(op.Active) for op in operations):
                raise RuntimeError("an operation is inactive")
            if str(job.PostProcessor).lower() != "linuxcnc" or list(job.Fixtures) != ["G54"]:
                raise RuntimeError("wrong postprocessor or fixture")
            if str(job.OrderOutputBy) != "Operation" or bool(job.SplitOutput):
                raise RuntimeError("wrong operation output ordering")
            if str(job.PostProcessorOutputFile) != "/home/user/Desktop/task-05.nc":
                raise RuntimeError("wrong NC output path")

            source_objects = list(job.Proxy.baseObjects(job))
            if len(source_objects) != 1:
                raise RuntimeError("Job must reference exactly one source model")
            pocket_area = 50.0 * 30.0 - 4.0 * 8.0 ** 2 + math.pi * 8.0 ** 2
            removed_holes = 2.0 * math.pi * 7.0 ** 2 * 18.0 + 2.0 * math.pi * 6.0 ** 2 * 18.0
            expected_volume = 120.0 * 80.0 * 18.0 - pocket_area * 6.0 - removed_holes
            source_cylinders = [
                (-42.0, 0.0, 14.0, 0.0, 18.0),
                (42.0, 0.0, 14.0, 0.0, 18.0),
                (0.0, -28.0, 12.0, 0.0, 18.0),
                (0.0, 28.0, 12.0, 0.0, 18.0),
            ] + [(x, y, 16.0, 12.0, 18.0) for x in (-17.0, 17.0) for y in (-7.0, 7.0)]
            model_cylinders = [
                (-42.0, 0.0, 14.0, -18.0, 0.0),
                (42.0, 0.0, 14.0, -18.0, 0.0),
                (0.0, -28.0, 12.0, -18.0, 0.0),
                (0.0, 28.0, 12.0, -18.0, 0.0),
            ] + [(x, y, 16.0, -6.0, 0.0) for x in (-17.0, 17.0) for y in (-7.0, 7.0)]
            actual_step = Part.read(STEP_FILE)
            check_shape(actual_step, [-60.0, 60.0, -40.0, 40.0, 0.0, 18.0], source_cylinders, expected_volume, "input STEP")
            check_shape(source_objects[0].Shape, [-60.0, 60.0, -40.0, 40.0, 0.0, 18.0], source_cylinders, expected_volume, "FCStd source")
            expected_shape = Part.makeBox(120.0, 80.0, 18.0, App.Vector(-60.0, -40.0, 0.0))
            expected_pocket = Part.makeBox(34.0, 30.0, 6.0, App.Vector(-17.0, -15.0, 12.0))
            expected_pocket = expected_pocket.fuse(Part.makeBox(50.0, 14.0, 6.0, App.Vector(-25.0, -7.0, 12.0)))
            for x in (-17.0, 17.0):
                for y in (-7.0, 7.0):
                    expected_pocket = expected_pocket.fuse(Part.makeCylinder(8.0, 6.0, App.Vector(x, y, 12.0)))
            expected_shape = expected_shape.cut(expected_pocket)
            for (x, y), (_tool, diameter) in HOLES.items():
                expected_shape = expected_shape.cut(Part.makeCylinder(diameter / 2.0, 20.0, App.Vector(x, y, -1.0)))
            expected_shape = expected_shape.removeSplitter()
            if not near(actual_step.common(expected_shape).Volume, expected_volume, 1e-3):
                raise RuntimeError("input STEP differs from the required finished geometry")
            if not near(actual_step.common(source_objects[0].Shape).Volume, expected_volume, 1e-3):
                raise RuntimeError("FCStd source differs from the submitted STEP")
            check_shape(models[0].Shape, [-60.0, 60.0, -40.0, 40.0, -18.0, 0.0], model_cylinders, expected_volume, "Job model")
            translated = actual_step.copy()
            translated.translate(App.Vector(0.0, 0.0, -18.0))
            if not near(translated.common(models[0].Shape).Volume, expected_volume, 1e-3):
                raise RuntimeError("Job model differs from the translated STEP")
            if not (near(models[0].Placement.Base.x, 0.0) and near(models[0].Placement.Base.y, 0.0) and near(models[0].Placement.Base.z, -18.0)):
                raise RuntimeError("G54 is not at the source top-face center")

            stock = job.Stock
            if stock.Shape.isNull() or not stock.Shape.isValid() or len(stock.Shape.Solids) != 1:
                raise RuntimeError("stock is invalid")
            if any(not near(a, b, 1e-5) for a, b in zip(bounds(stock.Shape), [-62.0, 62.0, -42.0, 42.0, -18.0, 1.0])):
                raise RuntimeError("stock bounds are wrong")
            if not near(stock.Shape.Volume, 124.0 * 84.0 * 19.0, 1e-3):
                raise RuntimeError("stock volume is wrong")
            expected_stock = Part.makeBox(124.0, 84.0, 19.0, App.Vector(-62.0, -42.0, -18.0))
            if not near(stock.Shape.common(expected_stock).Volume, expected_stock.Volume, 1e-3):
                raise RuntimeError("stock is not the required complete rectangular block")
            tool_map = {}
            expected_tools = {1: ("endmill", 16.0), 2: ("drill", 14.0), 3: ("drill", 12.0)}
            for controller in controllers:
                if type(getattr(controller, "Proxy", None)).__module__ != "Path.Tool.Controller" or type(controller.Proxy).__name__ != "ToolController":
                    raise RuntimeError("controller is not native")
                number = int(controller.ToolNumber)
                if number in tool_map or number not in expected_tools:
                    raise RuntimeError("invalid or duplicate tool number")
                tool = controller.Tool
                if type(getattr(tool, "Proxy", None)).__module__ != "Path.Tool.Bit" or type(tool.Proxy).__name__ != "ToolBit":
                    raise RuntimeError("controller does not reference a native ToolBit")
                shape_name, diameter = expected_tools[number]
                if str(tool.ShapeName).lower() != shape_name or not near(tool.Diameter.Value, diameter):
                    raise RuntimeError("tool type or diameter is wrong")
                if number in (2, 3) and not near(tool.TipAngle.Value, 118.0):
                    raise RuntimeError("drill tip angle is wrong")
                if not near(controller.SpindleSpeed, 7000.0) or str(controller.SpindleDir) != "Forward":
                    raise RuntimeError("spindle configuration is wrong")
                if not near(controller.HorizFeed.Value, 500.0 / 60.0) or not near(controller.VertFeed.Value, 500.0 / 60.0):
                    raise RuntimeError("feed does not match the CSV")
                controller_commands = [
                    command for command in controller.Path.Commands
                    if not str(command.Name).strip().startswith("(")
                ]
                if [str(command.Name).upper() for command in controller_commands] != ["M6", "M3"]:
                    raise RuntimeError("ToolController contains unexpected tool or spindle commands")
                change, spindle = controller_commands
                if set(change.Parameters) != {"T"} or not near(change.Parameters["T"], float(number)):
                    raise RuntimeError("ToolController changes to the wrong tool")
                if set(spindle.Parameters) != {"S"} or not near(spindle.Parameters["S"], 7000.0):
                    raise RuntimeError("ToolController spindle command is wrong")
                tool_map[number] = controller

            face, pocket, drill14, drill12, profile = operations
            expected_assignment = [1, 1, 2, 3, 1]
            if [int(op.ToolController.ToolNumber) for op in operations] != expected_assignment:
                raise RuntimeError("operation-to-tool mapping is wrong")
            for op in operations:
                if op.ToolController not in controllers or len(op.Path.Commands) < 8:
                    raise RuntimeError("operation uses an external tool or has no real path")
                if op.SafeHeight.Value <= 1.0 or op.ClearanceHeight.Value <= op.SafeHeight.Value:
                    raise RuntimeError("operation heights are unsafe")

            if not near(face.StartDepth.Value, 1.0) or not near(face.FinalDepth.Value, 0.0) or face.StepDown.Value <= 0.0:
                raise RuntimeError("Face depth contract is wrong")
            if any(base is not models[0] for base, _names in face.Base):
                raise RuntimeError("Face must reference the Job model")
            face_refs = [shape_of_reference(base, name) for base, names in face.Base for name in names]
            if len(face_refs) != 1 or face_refs[0] is None or not near(face_refs[0].BoundBox.ZMin, 0.0) or not near(face_refs[0].BoundBox.ZMax, 0.0):
                raise RuntimeError("Face does not reference the model top")
            check_face_coverage(face)
            validate_area_motion(face, "Face")

            if not near(pocket.StartDepth.Value, 0.0) or not near(pocket.FinalDepth.Value, -6.0) or pocket.StepDown.Value <= 0.0:
                raise RuntimeError("Pocket depth contract is wrong")
            if any(base is not models[0] for base, _names in pocket.Base):
                raise RuntimeError("Pocket must reference the Job model")
            pocket_refs = [shape_of_reference(base, name) for base, names in pocket.Base for name in names]
            if len(pocket_refs) != 1 or pocket_refs[0] is None:
                raise RuntimeError("Pocket must reference one bottom face")
            pbox = pocket_refs[0].BoundBox
            if not (near(pbox.ZMin, -6.0) and near(pbox.ZMax, -6.0) and near(pbox.XLength, 50.0) and near(pbox.YLength, 30.0)):
                raise RuntimeError("Pocket bottom face is wrong")
            check_pocket_coverage(pocket)
            validate_area_motion(pocket, "Pocket")

            assignments = []
            for operation, expected_tool in ((drill14, 2), (drill12, 3)):
                if not near(operation.StartDepth.Value, 0.0) or not near(operation.FinalDepth.Value, -19.0):
                    raise RuntimeError("Drilling nominal depth is wrong")
                if str(operation.ExtraOffset) != "Drill Tip" or str(operation.RetractMode) not in ("G98", "G99"):
                    raise RuntimeError("Drilling tip or retract mode is wrong")
                if operation.RetractHeight.Value <= 1.0:
                    raise RuntimeError("Drilling retract height is unsafe")
                points = selected_points(operation)
                expected_points = sorted(point for point, contract in HOLES.items() if contract[0] == expected_tool)
                if sorted((round(x, 4), round(y, 4)) for x, y in points) != expected_points:
                    raise RuntimeError("Drilling hole assignment is wrong")
                diameter = HOLES[expected_points[0]][1]
                tip_length = (diameter / 2.0) / math.tan(math.radians(118.0 / 2.0))
                expected_cycle_z = -19.0 - tip_length
                cycles = []
                names = [str(command.Name).upper() for command in operation.Path.Commands]
                if not any(name in ("G98", "G99") for name in names) or "G80" not in names:
                    raise RuntimeError("Drilling path lacks retract mode or cycle cancel")
                for command in operation.Path.Commands:
                    if str(command.Name).upper() not in ("G81", "G82", "G83"):
                        continue
                    params = command.Parameters
                    if not all(name in params for name in ("X", "Y", "Z", "R", "F")):
                        raise RuntimeError("Drilling cycle is incomplete")
                    if not near(params["Z"], expected_cycle_z, 0.01) or float(params["R"]) <= 1.0 or not near(params["F"], 500.0 / 60.0):
                        raise RuntimeError("Drilling cycle depth, retract, or feed is wrong")
                    cycles.append((round(float(params["X"]), 4), round(float(params["Y"]), 4)))
                if sorted(cycles) != expected_points:
                    raise RuntimeError("native path does not drill each hole exactly once")
                validate_drill_motion(operation)
                assignments.extend((x, y, expected_tool) for x, y in cycles)
            if sorted(assignments) != sorted((x, y, contract[0]) for (x, y), contract in HOLES.items()):
                raise RuntimeError("drilling operations do not cover all holes exactly once")

            if not near(profile.StartDepth.Value, 0.0) or not near(profile.FinalDepth.Value, -18.0) or profile.StepDown.Value <= 0.0:
                raise RuntimeError("Profile depth contract is wrong")
            if str(profile.Side) != "Outside" or not bool(profile.UseComp) or bool(profile.processHoles):
                raise RuntimeError("Profile is not an outside-only compensated contour")
            check_profile_coverage(profile)
            validate_area_motion(profile, "Profile")

            post_groups = PathPostCommand.buildPostList(job)
            if len(post_groups) != 1 or not post_groups[0][1]:
                raise RuntimeError("unable to rebuild the Job post list")
            regenerated = PostProcessor.load("linuxcnc").export(post_groups[0][1], "-", "--no-show-editor")
            with open(NC_FILE, "r", encoding="utf-8", errors="strict") as stream:
                submitted = stream.read()
            expected_nc = canonical_nc(regenerated)
            submitted_nc = canonical_nc(submitted)
            if not expected_nc or submitted_nc != expected_nc:
                raise RuntimeError("submitted NC does not match this FCStd Job")
            result = {"ok": True, "operations": 5, "nc_blocks": len(expected_nc), "assignments": len(assignments)}
        except Exception as exc:
            result = {"ok": False, "error": str(exc)}
        finally:
            if doc is not None:
                try:
                    App.closeDocument(doc.Name)
                except Exception:
                    pass
        print(MARKER + json.dumps(result, sort_keys=True))
        '''
    )
    checker = checker.replace("__FILE__", repr(str(fcstd_path)))
    checker = checker.replace("__STEP_FILE__", repr(str(step_path)))
    checker = checker.replace("__NC_FILE__", repr(str(nc_path)))
    checker = checker.replace("__MARKER__", repr(NATIVE_MARKER))
    try:
        with tempfile.TemporaryDirectory(prefix="task_c05_eval_") as temp_dir:
            script = Path(temp_dir) / "check_native.py"
            script.write_text(checker, encoding="utf-8")
            completed = subprocess.run(
                ["/usr/bin/freecadcmd", str(script)],
                stdout=subprocess.PIPE,
                stderr=subprocess.STDOUT,
                text=True,
                timeout=240,
                check=False,
            )
    except (OSError, subprocess.SubprocessError):
        return False
    if completed.returncode != 0:
        return False
    reports = [line[len(NATIVE_MARKER) :] for line in completed.stdout.splitlines() if line.startswith(NATIVE_MARKER)]
    if len(reports) != 1:
        return False
    try:
        report = json.loads(reports[0])
    except (TypeError, json.JSONDecodeError):
        return False
    return isinstance(report, dict) and report.get("ok") is True


def main() -> bool:
    return load_tool_library(CSV_PATH) and native_check(FCSTD_PATH, STEP_PATH, NC_PATH)


if __name__ == "__main__":
    try:
        ok = main()
    except Exception:
        ok = False
    print(True if ok else False)