Datasets:

HongchengGao
/

EngiWorld-Tasks

from __future__ import annotations

import hashlib
import json
import math
import os
import re
import secrets
import shlex
import stat
import subprocess
import sys
import tempfile
import traceback
import base64
import zipfile
import xml.etree.ElementTree as ET
from pathlib import Path
from pathlib import PurePosixPath


ROOT = Path("/home/user/Desktop")
FCSTD_PATH = ROOT / "task-08.FCStd"
STEP_PATH = ROOT / "rest_shape.step"
NC_PATH = ROOT / "task-08.nc"
EXPECTED_STEP_SHA256 = "6422d10ff940f6e558a26d5b1a85597e103de0a3c36b83774397d5be500abcf7"
EXPECTED_FREECAD_COMMIT = "b9bfa5c5507506e4515816414cd27f4851d00489"
FREECADCMD = Path("/usr/bin/freecadcmd")
INNER_ENV = "ENGIWORLD_TASK08_FREECAD"
MARKER_ENV = "ENGIWORLD_TASK08_MARKER"
NUMBER = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)"
WORD_RE = re.compile(rf"([A-Z])\s*({NUMBER})", re.IGNORECASE)
TOP_Z = 18.0
FLOOR_Z = 6.0
ALLOWED_OBJECT_TYPES = {
    "App::DocumentObjectGroup",
    "App::FeaturePython",
    "Part::Feature",
    "Part::FeaturePython",
    "PartDesign::Feature",
    "Path::FeaturePython",
    "Sketcher::SketchObject",
}
ALLOWED_PROXY_PAIRS = {
    ("Path.Base.SetupSheet", "SetupSheet"),
    ("Path.Main.Job", "ObjectJob"),
    ("Path.Main.Stock", "StockCreateBox"),
    ("Path.Main.Stock", "StockFromBase"),
    ("Path.Op.Adaptive", "PathAdaptive"),
    ("Path.Op.PocketShape", "ObjectPocket"),
    ("Path.Tool.Bit", "ToolBit"),
    ("Path.Tool.Controller", "ToolController"),
    ("draftobjects.clone", "Clone"),
}
ALLOWED_PROXY_STATES = {b"null", b"{}", b'"Clone"'}


def regular_file(path: Path, maximum_size: int) -> bool:
    try:
        info = path.lstat()
    except OSError:
        return False
    return stat.S_ISREG(info.st_mode) and not path.is_symlink() and 0 < info.st_size <= maximum_size


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def normalized_text_sha256(path: Path) -> str:
    data = path.read_bytes().replace(b"\r\n", b"\n").replace(b"\r", b"\n")
    return hashlib.sha256(data).hexdigest()


def safe_fcstd_container(path: Path) -> bool:
    if not regular_file(path, 20 * 1024 * 1024) or not zipfile.is_zipfile(path):
        return False
    try:
        with zipfile.ZipFile(path) as archive:
            entries = archive.infolist()
            names = [entry.filename for entry in entries]
            if (
                not 1 <= len(entries) <= 200
                or len(names) != len(set(names))
                or names.count("Document.xml") != 1
                or sum(entry.file_size for entry in entries) > 50 * 1024 * 1024
            ):
                return False
            for entry in entries:
                member = PurePosixPath(entry.filename)
                mode = (entry.external_attr >> 16) & 0o170000
                if (
                    entry.flag_bits & 0x1
                    or entry.compress_type not in {zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED}
                    or entry.file_size > 25 * 1024 * 1024
                    or entry.filename.startswith("/")
                    or "\\" in entry.filename
                    or ".." in member.parts
                    or mode == stat.S_IFLNK
                    or member.suffix.lower() in {".py", ".pyc", ".pyd", ".so", ".dll", ".exe", ".sh"}
                ):
                    return False
            xml_data = archive.read("Document.xml")
    except (OSError, KeyError, RuntimeError, zipfile.BadZipFile):
        return False
    if len(xml_data) > 5 * 1024 * 1024 or b"<!DOCTYPE" in xml_data.upper() or b"<!ENTITY" in xml_data.upper():
        return False
    try:
        root = ET.fromstring(xml_data)
    except ET.ParseError:
        return False
    objects = root.find("Objects")
    object_data = root.find("ObjectData")
    if objects is None or object_data is None:
        return False
    declarations = objects.findall("Object")
    data_objects = object_data.findall("Object")
    declared_names = [obj.get("name", "") for obj in declarations]
    data_names = [obj.get("name", "") for obj in data_objects]
    if (
        not 1 <= len(declarations) <= 100
        or len(declared_names) != len(set(declared_names))
        or set(declared_names) != set(data_names)
        or any(obj.get("type") not in ALLOWED_OBJECT_TYPES for obj in declarations)
    ):
        return False
    for extension in root.findall(".//Extension"):
        if extension.get("type") not in {
            "App::GroupExtension",
            "App::GroupExtensionPython",
            "Part::AttachExtension",
            "Part::AttachExtensionPython",
        }:
            return False
    all_python_properties = root.findall('.//*[@type="App::PropertyPythonObject"]')
    audited_python_properties = []
    for obj in data_objects:
        proxy_pair = None
        python_properties = [
            prop
            for prop in obj.findall("./Properties/Property")
            if prop.get("type") == "App::PropertyPythonObject"
        ]
        audited_python_properties.extend(python_properties)
        for prop in python_properties:
            name = prop.get("name", "")
            nodes = prop.findall("Python")
            if len(nodes) != 1 or name not in {"Proxy", "AdaptiveInputState", "AdaptiveOutputState"}:
                return False
            node = nodes[0]
            if node.get("encoded") != "yes":
                return False
            try:
                decoded = base64.b64decode(node.get("value", ""), validate=True)
            except (ValueError, TypeError):
                return False
            module = node.get("module")
            class_name = node.get("class")
            if name == "Proxy":
                if (module, class_name) not in ALLOWED_PROXY_PAIRS or decoded not in ALLOWED_PROXY_STATES:
                    return False
                proxy_pair = (module, class_name)
            else:
                if module is not None or class_name is not None or node.get("json") != "yes":
                    return False
                try:
                    json.loads(decoded.decode("utf-8"))
                except (UnicodeDecodeError, json.JSONDecodeError):
                    return False
        state_names = {prop.get("name") for prop in python_properties if prop.get("name") != "Proxy"}
        if state_names and proxy_pair is not None and proxy_pair[0] != "Path.Op.Adaptive":
            return False
    if len(all_python_properties) != len(audited_python_properties) or {
        id(prop) for prop in all_python_properties
    } != {id(prop) for prop in audited_python_properties}:
        return False
    return True


def close(first, second, tolerance: float = 1e-5) -> bool:
    return abs(float(first) - float(second)) <= tolerance


def proxy_module(obj) -> str:
    proxy = getattr(obj, "Proxy", None)
    return getattr(proxy.__class__, "__module__", "") if proxy is not None else ""


def shapes_equal(first, second, tolerance: float = 1e-5) -> bool:
    try:
        return (
            first.isValid()
            and second.isValid()
            and first.cut(second).Volume <= tolerance
            and second.cut(first).Volume <= tolerance
        )
    except Exception:
        return False


def object_state_clean(obj) -> bool:
    try:
        states = {str(value) for value in obj.State}
    except Exception:
        return False
    return not states.intersection({"Touched", "Invalid", "Error"})


def distance_to_segment(px: float, py: float, start, end) -> float:
    ax, ay = start
    bx, by = end
    dx = bx - ax
    dy = by - ay
    denominator = dx * dx + dy * dy
    if denominator <= 1e-16:
        return math.hypot(px - ax, py - ay)
    scale = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / denominator))
    return math.hypot(px - (ax + scale * dx), py - (ay + scale * dy))


def path_motions(commands):
    current = {"X": None, "Y": None, "Z": None}
    motions = []
    for command in commands:
        before = dict(current)
        parameters = command.Parameters
        for axis in ("X", "Y", "Z"):
            if axis in parameters:
                current[axis] = float(parameters[axis])
        name = str(command.Name).upper().replace(" ", "")
        current_complete = all(current[axis] is not None for axis in ("X", "Y", "Z"))
        before_complete = all(before[axis] is not None for axis in ("X", "Y", "Z"))
        if not before_complete and current_complete and name in {"G0", "G00", "G1", "G01", "G2", "G02", "G3", "G03"}:
            motions.append(("G0" if name in {"G0", "G00"} else "G1", dict(current), dict(current)))
            continue
        if name in {"G0", "G00", "G1", "G01"} and all(
            before[axis] is not None and current[axis] is not None for axis in ("X", "Y", "Z")
        ):
            motions.append(("G0" if name in {"G0", "G00"} else "G1", before, dict(current)))
        elif name in {"G2", "G02", "G3", "G03"} and all(
            before[axis] is not None and current[axis] is not None for axis in ("X", "Y", "Z")
        ):
            if "I" not in parameters and "J" not in parameters:
                raise ValueError("unsupported arc without I/J center offsets")
            center_x = before["X"] + float(parameters.get("I", 0.0))
            center_y = before["Y"] + float(parameters.get("J", 0.0))
            start_angle = math.atan2(before["Y"] - center_y, before["X"] - center_x)
            end_angle = math.atan2(current["Y"] - center_y, current["X"] - center_x)
            radius = math.hypot(before["X"] - center_x, before["Y"] - center_y)
            end_radius = math.hypot(current["X"] - center_x, current["Y"] - center_y)
            if radius <= 1e-8 or abs(radius - end_radius) > 1e-4:
                raise ValueError("invalid arc radius")
            clockwise = name in {"G2", "G02"}
            sweep = (start_angle - end_angle) % (2.0 * math.pi) if clockwise else (end_angle - start_angle) % (2.0 * math.pi)
            if sweep <= 1e-10:
                sweep = 2.0 * math.pi
            steps = max(2, int(math.ceil(radius * sweep / 0.25)))
            previous = dict(before)
            direction = -1.0 if clockwise else 1.0
            for step in range(1, steps + 1):
                fraction = step / steps
                angle = start_angle + direction * sweep * fraction
                point = {
                    "X": center_x + radius * math.cos(angle),
                    "Y": center_y + radius * math.sin(angle),
                    "Z": before["Z"] + (current["Z"] - before["Z"]) * fraction,
                }
                if step == steps:
                    point = dict(current)
                motions.append(("G1", previous, point))
                previous = point
    return motions


def contact_projection(before, after):
    """Return the XY projection of only the portion at or below the stock top."""
    before_z = before["Z"]
    after_z = after["Z"]
    if min(before_z, after_z) >= TOP_Z - 1e-4:
        return None

    start = dict(before)
    end = dict(after)
    delta_z = after_z - before_z
    if abs(delta_z) > 1e-12:
        fraction = (TOP_Z - before_z) / delta_z
        if 0.0 < fraction < 1.0:
            crossing = {
                axis: before[axis] + (after[axis] - before[axis]) * fraction
                for axis in ("X", "Y", "Z")
            }
            if before_z > TOP_Z:
                start = crossing
            elif after_z > TOP_Z:
                end = crossing
    return ((start["X"], start["Y"]), (end["X"], end["Y"]))


def operation_motions(operation):
    motions = path_motions(list(operation.Path.Commands))
    contact_segments = []
    floor_segments = []
    reached_floor = False
    for mode, before, after in motions:
        if min(before["Z"], after["Z"]) < FLOOR_Z - 1e-4:
            return None
        if mode == "G1" and abs(after["Z"] - FLOOR_Z) <= 1e-4:
            reached_floor = True
        if mode == "G1" and abs(before["Z"] - FLOOR_Z) <= 1e-4 and abs(after["Z"] - FLOOR_Z) <= 1e-4:
            floor_segments.append(((before["X"], before["Y"]), (after["X"], after["Y"])))
        contact = contact_projection(before, after)
        if contact is not None:
            contact_segments.append(contact)
    return (contact_segments, floor_segments) if reached_floor and floor_segments else None


def selected_faces(operation, Part, allow_edges: bool = False):
    faces = []
    boundaries = []
    try:
        bases = list(operation.Base)
    except Exception:
        return None
    if not bases:
        return None
    for boundary, names in bases:
        if boundary.Document != operation.Document or not names:
            return None
        boundaries.append(boundary)
        edges = []
        for name in names:
            name = str(name)
            if name.startswith("Edge") and allow_edges:
                try:
                    edges.append(boundary.Shape.getElement(name))
                except Exception:
                    return None
                continue
            if not name.startswith("Face"):
                return None
            try:
                face = boundary.Shape.getElement(name)
            except Exception:
                return None
            if not isinstance(face.Surface, Part.Plane):
                return None
            normal = face.normalAt(0.5, 0.5)
            if abs(abs(float(normal.z)) - 1.0) > 1e-5 or face.BoundBox.ZLength > 1e-5:
                return None
            copy = face.copy()
            copy.translate(__import__("FreeCAD").Vector(0.0, 0.0, TOP_Z - face.BoundBox.ZMin))
            faces.append(copy)
        if edges:
            try:
                import DraftGeomUtils

                wires = DraftGeomUtils.findWires(edges)
            except Exception:
                return None
            if not wires:
                return None
            for wire in wires:
                try:
                    if not wire.isClosed() or wire.BoundBox.ZLength > 1e-5:
                        return None
                    face = Part.Face(wire)
                    if not isinstance(face.Surface, Part.Plane):
                        return None
                    normal = face.normalAt(0.5, 0.5)
                    if abs(abs(float(normal.z)) - 1.0) > 1e-5:
                        return None
                    face.translate(__import__("FreeCAD").Vector(0.0, 0.0, TOP_Z - face.BoundBox.ZMin))
                    faces.append(face)
                except Exception:
                    return None
    return faces, boundaries


def fused_faces(faces):
    result = faces[0]
    for face in faces[1:]:
        result = result.fuse(face)
    try:
        result = result.removeSplitter()
    except Exception:
        pass
    return result


def expected_regions(Part, App):
    main = Part.makePlane(60.0, 36.0, App.Vector(-30.0, -18.0, TOP_Z))
    residuals = [
        Part.makePlane(8.0, 12.0, App.Vector(-4.0, 18.0, TOP_Z)),
        Part.makePlane(8.0, 12.0, App.Vector(-4.0, -30.0, TOP_Z)),
        Part.makePlane(12.0, 8.0, App.Vector(-42.0, -4.0, TOP_Z)),
        Part.makePlane(12.0, 8.0, App.Vector(30.0, -4.0, TOP_Z)),
    ]
    return main, residuals


def face_matches_region(face, expected, tolerance: float = 1e-4) -> bool:
    try:
        return face.cut(expected).Area <= tolerance and expected.cut(face).Area <= tolerance
    except Exception:
        return False


def rounded_rectangle_contains(x, y, bbox, radius):
    center_x = min(max(x, bbox.XMin + radius), bbox.XMax - radius)
    center_y = min(max(y, bbox.YMin + radius), bbox.YMax - radius)
    return math.hypot(x - center_x, y - center_y) <= radius + 1e-8


def segment_sweep(Part, App, start, end, radius: float):
    start_point = App.Vector(start[0], start[1], TOP_Z)
    end_point = App.Vector(end[0], end[1], TOP_Z)

    def disk(center):
        return Part.Face(Part.Wire([Part.makeCircle(radius, center)]))

    length = math.hypot(end[0] - start[0], end[1] - start[1])
    sweep = disk(start_point)
    if length <= 1e-10:
        return sweep
    normal_x = -(end[1] - start[1]) * radius / length
    normal_y = (end[0] - start[0]) * radius / length
    corners = [
        App.Vector(start[0] + normal_x, start[1] + normal_y, TOP_Z),
        App.Vector(end[0] + normal_x, end[1] + normal_y, TOP_Z),
        App.Vector(end[0] - normal_x, end[1] - normal_y, TOP_Z),
        App.Vector(start[0] - normal_x, start[1] - normal_y, TOP_Z),
    ]
    strip = Part.Face(Part.makePolygon(corners + [corners[0]]))
    return sweep.fuse(strip).fuse(disk(end_point)).removeSplitter()


def validate_region_path(operation, region_faces, allowed_face, diameter: float) -> bool:
    motion_sets = operation_motions(operation)
    if motion_sets is None:
        return False
    contact_segments, floor_segments = motion_sets
    radius = diameter / 2.0
    for face in region_faces:
        bbox = face.BoundBox
        if min(bbox.XLength, bbox.YLength) <= diameter:
            return False
        samples = 0
        x = bbox.XMin
        while x <= bbox.XMax + 1e-8:
            y = bbox.YMin
            while y <= bbox.YMax + 1e-8:
                point = __import__("FreeCAD").Vector(x, y, TOP_Z)
                if face.isInside(point, 1e-6, True) and rounded_rectangle_contains(x, y, bbox, radius):
                    if min(distance_to_segment(x, y, start, end) for start, end in floor_segments) > radius + 0.12:
                        return False
                    samples += 1
                y += 0.5
            x += 0.5
        if samples < 100:
            return False
    Part = __import__("Part")
    App = __import__("FreeCAD")
    stock_footprint = Part.makePlane(120.0, 80.0, App.Vector(-60.0, -40.0, TOP_Z))
    for start, end in contact_segments:
        sweep = segment_sweep(Part, App, start, end, radius)
        material_contact = sweep.common(stock_footprint)
        if material_contact.cut(allowed_face).Area > 1e-4:
            return False
    return True


def strip_comments(text: str):
    output = []
    index = 0
    while index < len(text):
        char = text[index]
        if char == "(":
            end = text.find(")", index + 1)
            if end < 0 or "(" in text[index + 1 : end]:
                raise ValueError("malformed parenthesis comment")
            output.extend(" " for _ in range(index, end + 1))
            index = end + 1
        elif char == ")":
            raise ValueError("unmatched parenthesis")
        elif char == ";":
            end = text.find("\n", index)
            if end < 0:
                end = len(text)
            output.extend(" " for _ in range(index, end))
            index = end
        else:
            output.append(char)
            index += 1
    return "".join(output)


def parse_nc(text: str):
    executable = strip_comments(text)
    raw_lines = executable.splitlines()
    percent_lines = [index for index, line in enumerate(raw_lines) if line.strip() == "%"]
    nonempty = [index for index, line in enumerate(raw_lines) if line.strip()]
    if percent_lines and (len(percent_lines) != 2 or percent_lines != [nonempty[0], nonempty[-1]]):
        raise ValueError("illegal percent wrapper")
    blocks = []
    for raw_line in raw_lines:
        line = raw_line.strip().upper()
        if not line or line == "%":
            continue
        tokens = []
        cursor = 0
        for match in WORD_RE.finditer(line):
            if line[cursor : match.start()].strip():
                raise ValueError("unparsed NC text")
            tokens.append((match.group(1).upper(), float(match.group(2))))
            cursor = match.end()
        if line[cursor:].strip() or not tokens:
            raise ValueError("unparsed NC line")
        blocks.append(tokens)
    if not blocks:
        raise ValueError("empty NC")
    return blocks


def canonical_blocks(text: str):
    result = []
    for block in parse_nc(text):
        normalized = []
        for letter, number in block:
            if letter == "N":
                continue
            if letter in {"G", "M", "T", "H", "O"} and close(number, round(number), 1e-9):
                value = str(int(round(number)))
            else:
                value = f"{number:.9f}".rstrip("0").rstrip(".")
                if value in {"-0", "+0"}:
                    value = "0"
            normalized.append(letter + value)
        result.append(tuple(sorted(normalized)))
    return result


def validate_nc_safety(text: str) -> bool:
    try:
        blocks = parse_nc(text)
    except Exception:
        return False
    state = {
        "units_mm": False,
        "absolute": False,
        "motion": None,
        "feed": None,
        "speed": None,
        "tool": None,
        "spindle": False,
        "tool_changed": False,
        "X": None,
        "Y": None,
        "Z": None,
    }
    changed_tools = []
    bottom_tools = set()
    saw_g21 = saw_g90 = ended = False
    for block_index, block in enumerate(blocks):
        words = {}
        g_codes = []
        m_codes = []
        for letter, number in block:
            if letter == "G":
                if not close(number, round(number), 1e-9):
                    return False
                g_codes.append(int(round(number)))
            elif letter == "M":
                if not close(number, round(number), 1e-9):
                    return False
                m_codes.append(int(round(number)))
            else:
                if letter in words:
                    return False
                words[letter] = number
        if any(code not in {0, 1, 2, 3, 17, 21, 40, 43, 49, 54, 55, 56, 57, 58, 59, 80, 90, 94} for code in g_codes):
            return False
        if any(code not in {2, 3, 4, 5, 6, 7, 8, 9, 30} for code in m_codes):
            return False
        if 21 in g_codes:
            state["units_mm"] = True
            saw_g21 = True
        if 90 in g_codes:
            state["absolute"] = True
            saw_g90 = True
        for code in g_codes:
            if code in (0, 1, 2, 3):
                state["motion"] = code
        if "T" in words:
            tool = int(round(words["T"]))
            if not close(words["T"], tool, 1e-9) or tool not in {1, 2}:
                return False
            state["tool"] = tool
        if "H" in words and (state["tool"] is None or not close(words["H"], state["tool"], 1e-9)):
            return False
        if "S" in words:
            if not close(words["S"], 7000, 1e-6):
                return False
            state["speed"] = words["S"]
        if "F" in words:
            if not close(words["F"], 500, 1e-5):
                return False
            state["feed"] = words["F"]
        if 5 in m_codes:
            state["spindle"] = False
        if 6 in m_codes:
            if state["spindle"] or state["tool"] is None:
                return False
            changed_tools.append(state["tool"])
            state["tool_changed"] = True
        if 3 in m_codes and 4 in m_codes:
            return False
        if 3 in m_codes or 4 in m_codes:
            if state["speed"] is None or not close(state["speed"], 7000, 1e-6):
                return False
            state["spindle"] = True
        before = {axis: state[axis] for axis in ("X", "Y", "Z")}
        moved = False
        for axis in ("X", "Y", "Z"):
            if axis in words:
                state[axis] = words[axis]
                moved = True
        if moved and state["motion"] in (0, 1, 2, 3):
            if not state["units_mm"] or not state["absolute"]:
                return False
            if state["motion"] != 0:
                if not state["tool_changed"] or not state["spindle"] or state["feed"] is None:
                    return False
                if state["Z"] is not None and state["Z"] < FLOOR_Z - 1e-4:
                    return False
                if state["Z"] is not None and abs(state["Z"] - FLOOR_Z) <= 1e-4:
                    bottom_tools.add(state["tool"])
        if 2 in m_codes or 30 in m_codes:
            if block_index != len(blocks) - 1 or state["spindle"]:
                return False
            ended = True
    return saw_g21 and saw_g90 and changed_tools == [1, 2] and bottom_tools == {1, 2} and ended


def valid_postprocessor_args(value: str) -> bool:
    try:
        arguments = shlex.split(value)
    except ValueError:
        return False
    flags = {
        "--no-header",
        "--no-comments",
        "--line-numbers",
        "--no-show-editor",
        "--modal",
        "--axis-modal",
        "--no-tlo",
    }
    index = 0
    while index < len(arguments):
        argument = arguments[index]
        if argument in flags:
            index += 1
            continue
        if argument == "--precision":
            index += 1
            if index >= len(arguments) or not re.fullmatch(r"(?:[3-9]|1[0-5])", arguments[index]):
                return False
            index += 1
            continue
        if re.fullmatch(r"--precision=(?:[3-9]|1[0-5])", argument):
            index += 1
            continue
        return False
    return True


def evaluate_in_freecad() -> bool:
    import builtins

    builtins.pythonopen = open
    import FreeCAD as App
    import Part
    import Path.Post.Command as PathPostCommand
    from Path.Post.Processor import PostProcessor

    if App.Version()[:4] != ["0", "21", "2", "33771 (Git)"] or App.Version()[-1] != EXPECTED_FREECAD_COMMIT:
        return False
    if not all(
        regular_file(path, maximum)
        for path, maximum in ((STEP_PATH, 5 * 1024 * 1024), (FCSTD_PATH, 20 * 1024 * 1024), (NC_PATH, 5 * 1024 * 1024))
    ):
        return False
    if normalized_text_sha256(STEP_PATH) != EXPECTED_STEP_SHA256:
        return False

    source_shape = Part.read(str(STEP_PATH))
    if (
        source_shape.ShapeType != "Solid"
        or len(source_shape.Solids) != 1
        or not source_shape.isValid()
        or not close(source_shape.Volume, 142272.0, 1e-3)
        or not close(source_shape.BoundBox.XMin, -60)
        or not close(source_shape.BoundBox.XMax, 60)
        or not close(source_shape.BoundBox.YMin, -40)
        or not close(source_shape.BoundBox.YMax, 40)
        or not close(source_shape.BoundBox.ZMin, 0)
        or not close(source_shape.BoundBox.ZMax, TOP_Z)
    ):
        return False
    stock_shape = Part.makeBox(120.0, 80.0, TOP_Z, App.Vector(-60.0, -40.0, 0.0))
    target_void = stock_shape.cut(source_shape).removeSplitter()
    if not target_void.isValid() or len(target_void.Solids) != 1 or not close(target_void.Volume, 30528.0, 1e-3):
        return False
    target_void = target_void.Solids[0]

    document = App.openDocument(str(FCSTD_PATH))
    if document is None:
        return False
    jobs = [obj for obj in document.Objects if proxy_module(obj) == "Path.Main.Job"]
    all_ops = [obj for obj in document.Objects if proxy_module(obj).startswith("Path.Op.")]
    if len(jobs) != 1 or len(all_ops) != 2:
        return False
    job = jobs[0]
    operations = list(job.Operations.Group)
    if len(operations) != 2 or {obj.Name for obj in operations} != {obj.Name for obj in all_ops}:
        return False
    main, rest = operations

    tracked = list(document.Objects)
    for obj in tracked:
        obj.touch()
    document.recompute()
    if not all(object_state_clean(obj) for obj in tracked):
        return False

    if proxy_module(main) != "Path.Op.PocketShape" or proxy_module(rest) != "Path.Op.Adaptive":
        return False
    if (
        not close(main.ExtraOffset.Value, 0.0)
        or str(rest.OperationType) != "Clearing"
        or not close(rest.StockToLeave.Value, 0.0)
    ):
        return False
    if (
        str(job.PostProcessor).strip().lower() != "linuxcnc"
        or bool(job.SplitOutput)
        or os.path.normpath(str(job.PostProcessorOutputFile)) != str(NC_PATH)
        or not valid_postprocessor_args(str(job.PostProcessorArgs))
    ):
        return False
    fixtures = [str(value).strip().upper() for value in job.Fixtures]
    if fixtures != ["G54"]:
        return False
    if len(job.Model.Group) != 1 or not shapes_equal(job.Model.Group[0].Shape, source_shape):
        return False
    if not shapes_equal(job.Stock.Shape, stock_shape):
        return False

    if len(job.Tools.Group) != 2:
        return False
    controllers = {int(controller.ToolNumber): controller for controller in job.Tools.Group}
    if set(controllers) != {1, 2} or main.ToolController != controllers[1] or rest.ToolController != controllers[2]:
        return False
    for number, diameter in ((1, 10.0), (2, 4.0)):
        controller = controllers[number]
        if proxy_module(controller) != "Path.Tool.Controller" or proxy_module(controller.Tool) != "Path.Tool.Bit":
            return False
        if (
            not close(controller.Tool.Diameter.Value, diameter)
            or not close(controller.SpindleSpeed, 7000)
            or str(controller.SpindleDir) not in {"Forward", "Reverse"}
            or not close(controller.HorizFeed.getValueAs("mm/min").Value, 500)
            or not close(controller.VertFeed.getValueAs("mm/min").Value, 500)
        ):
            return False
    if not controllers[2].Tool.Diameter.Value < controllers[1].Tool.Diameter.Value:
        return False
    for operation in operations:
        if (
            not close(operation.StartDepth.Value, TOP_Z)
            or not close(operation.FinalDepth.Value, FLOOR_Z)
            or operation.StepDown.Value <= 0
            or operation.ClearanceHeight.Value <= operation.SafeHeight.Value
            or operation.SafeHeight.Value <= TOP_Z
        ):
            return False

    main_selection = selected_faces(main, Part)
    rest_selection = selected_faces(rest, Part, allow_edges=True)
    if main_selection is None or rest_selection is None:
        return False
    main_faces, main_boundaries = main_selection
    rest_faces, rest_boundaries = rest_selection
    expected_main, expected_residuals = expected_regions(Part, App)
    main_region = fused_faces(main_faces)
    rest_region = fused_faces(rest_faces)
    expected_rest = fused_faces(expected_residuals)
    if not face_matches_region(main_region, expected_main) or not face_matches_region(rest_region, expected_rest):
        return False
    operation_void = main_region.extrude(App.Vector(0.0, 0.0, FLOOR_Z - TOP_Z))
    operation_void = operation_void.fuse(rest_region.extrude(App.Vector(0.0, 0.0, FLOOR_Z - TOP_Z))).removeSplitter()
    if not shapes_equal(operation_void, target_void, 1e-3):
        return False

    allowed_region = fused_faces([expected_main, *expected_residuals])
    if not validate_region_path(main, [expected_main], allowed_region, 10.0):
        return False
    if not validate_region_path(rest, expected_residuals, allowed_region, 4.0):
        return False

    try:
        submitted_text = NC_PATH.read_text(encoding="utf-8")
    except Exception:
        return False
    if not validate_nc_safety(submitted_text):
        return False
    sections = PathPostCommand.buildPostList(job)
    if len(sections) != 1:
        return False
    with tempfile.TemporaryDirectory(prefix="engiworld-task08-eval-") as temporary:
        repost_path = Path(temporary) / "task-08.nc"
        try:
            PostProcessor.load("linuxcnc").export(sections[0][1], str(repost_path), str(job.PostProcessorArgs))
            repost_text = repost_path.read_text(encoding="utf-8")
        except BaseException:
            return False
        if canonical_blocks(submitted_text) != canonical_blocks(repost_text):
            return False
    return True


def run_outer() -> bool:
    if not safe_fcstd_container(FCSTD_PATH):
        return False
    try:
        executable = FREECADCMD.resolve(strict=True)
        info = executable.stat()
    except OSError:
        return False
    if not stat.S_ISREG(info.st_mode) or info.st_uid != 0 or info.st_mode & 0o022:
        return False
    marker = "TASK08_RESULT_" + secrets.token_hex(16)
    evaluator = str(Path(__file__).resolve())
    command = (
        "import builtins; builtins.pythonopen=open; "
        f"exec(compile(open({evaluator!r}, encoding='utf-8').read(), {evaluator!r}, 'exec'))"
    )
    try:
        with tempfile.TemporaryDirectory(prefix="engiworld-task08-home-") as isolated_home:
            environment = {
                "HOME": isolated_home,
                "LANG": "C.UTF-8",
                "LC_ALL": "C.UTF-8",
                "LOGNAME": "user",
                "PATH": "/usr/bin:/bin",
                "USER": "user",
                "XDG_CACHE_HOME": str(Path(isolated_home) / ".cache"),
                "XDG_CONFIG_HOME": str(Path(isolated_home) / ".config"),
                INNER_ENV: "1",
                MARKER_ENV: marker,
            }
            completed = subprocess.run(
                [str(executable), "-c", command],
                capture_output=True,
                text=True,
                timeout=240,
                env=environment,
                cwd=isolated_home,
                check=False,
            )
    except Exception:
        return False
    marker_lines = [line.strip() for line in completed.stdout.splitlines() if line.strip().startswith(marker + "=")]
    return completed.returncode == 0 and marker_lines == [marker + "=True"]


if __name__ == "__main__":
    if os.environ.get(INNER_ENV) == "1":
        marker = os.environ.get(MARKER_ENV, "")
        ok = False
        try:
            ok = evaluate_in_freecad()
        except BaseException:
            traceback.print_exc(file=sys.stderr)
            ok = False
        print(f"{marker}={bool(ok)}")
    else:
        print(True if run_outer() else False)