| from __future__ import annotations |
|
|
| import base64 |
| import ctypes |
| import hashlib |
| import json |
| import math |
| import os |
| import re |
| import resource |
| import shlex |
| import stat |
| import subprocess |
| import sys |
| import tempfile |
| import traceback |
| import zipfile |
| import xml.etree.ElementTree as ET |
| from pathlib import Path |
| from pathlib import PurePosixPath |
|
|
|
|
| DESKTOP = Path("/home/user/Desktop") |
| ROOT = Path(os.environ.get("ENGIWORLD_TASK10_STAGE", str(DESKTOP))) |
| PART_PATH = ROOT / "part.step" |
| FIXTURE_PATH = ROOT / "fixture.step" |
| FCSTD_PATH = ROOT / "task-10.FCStd" |
| NC_PATH = ROOT / "task-10.nc" |
| EXPECTED_PART_SHA256 = "57e6e748d29109dce6f137ebce5e6b291868c6e2091a1155b5999116c31cf060" |
| EXPECTED_FIXTURE_SHA256 = "98300ac3a6160094e2c008bdc4760487d3337877fe24dfb14560fcab83907122" |
| EXPECTED_FREECAD_COMMIT = "b9bfa5c5507506e4515816414cd27f4851d00489" |
| FREECADCMD = Path("/usr/bin/freecadcmd") |
| BWRAP = Path("/usr/bin/bwrap") |
| NUMBER = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)" |
| WORD_RE = re.compile(rf"([A-Z])\s*({NUMBER})", re.IGNORECASE) |
|
|
| TOP_Z = 18.0 |
| FLOOR_Z = 13.0 |
| INTERMEDIATE_Z = 15.5 |
| SAFE_Z = 26.0 |
| CLEARANCE_Z = 27.0 |
| TOOL_DIAMETER = 10.0 |
| TOOL_RADIUS = TOOL_DIAMETER / 2.0 |
| CUTTING_EDGE_HEIGHT = 20.0 |
| FIXTURE_CLEARANCE = 3.0 |
| CENTER_CLEARANCE = TOOL_RADIUS + FIXTURE_CLEARANCE |
| POCKET_BOUNDS = (-25.0, 25.0, -15.0, 15.0) |
|
|
| ALLOWED_OBJECT_TYPES = { |
| "App::DocumentObjectGroup", |
| "App::FeaturePython", |
| "App::Line", |
| "App::Origin", |
| "App::Plane", |
| "Part::Feature", |
| "Part::FeaturePython", |
| "PartDesign::Feature", |
| "PartDesign::Body", |
| "Path::FeaturePython", |
| "Sketcher::SketchObject", |
| } |
| PROXY_STATES = { |
| ("Path.Base.SetupSheet", "SetupSheet"): b"null", |
| ("Path.Dressup.Boundary", "DressupPathBoundary"): b"null", |
| ("Path.Main.Job", "ObjectJob"): b"null", |
| ("Path.Main.Stock", "StockFromBase"): b"null", |
| ("Path.Main.Stock", "StockCreateBox"): b"null", |
| ("Path.Op.PocketShape", "ObjectPocket"): b"null", |
| ("Path.Tool.Bit", "ToolBit"): b"null", |
| ("Path.Tool.Controller", "ToolController"): b"{}", |
| ("draftobjects.clone", "Clone"): b'"Clone"', |
| } |
| STOCK_PROXY_PAIRS = { |
| ("Path.Main.Stock", "StockFromBase"), |
| ("Path.Main.Stock", "StockCreateBox"), |
| } |
| ALLOWED_EXTENSIONS = { |
| "App::GeoFeatureGroupExtension", |
| "App::GroupExtension", |
| "App::GroupExtensionPython", |
| "App::OriginGroupExtension", |
| "Part::AttachExtension", |
| "Part::AttachExtensionPython", |
| } |
|
|
| G_MODAL_GROUPS = ( |
| frozenset({0, 1, 2, 3, 80}), |
| frozenset({17}), |
| frozenset({90}), |
| frozenset({94}), |
| frozenset({21}), |
| frozenset({40}), |
| frozenset({43, 49}), |
| frozenset({54}), |
| ) |
| M_MODAL_GROUPS = ( |
| frozenset({2, 30}), |
| frozenset({3, 4, 5}), |
| frozenset({6}), |
| frozenset({7, 8, 9}), |
| ) |
|
|
|
|
| def close(first, second, tolerance: float = 1e-5) -> bool: |
| return abs(float(first) - float(second)) <= tolerance |
|
|
|
|
| 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 stage_file(source: Path, destination: Path, maximum_size: int) -> bool: |
| flags = ( |
| os.O_RDONLY |
| | getattr(os, "O_CLOEXEC", 0) |
| | getattr(os, "O_NOFOLLOW", 0) |
| | getattr(os, "O_NONBLOCK", 0) |
| ) |
| try: |
| descriptor = os.open(source, flags) |
| try: |
| info = os.fstat(descriptor) |
| if not stat.S_ISREG(info.st_mode) or not 0 < info.st_size <= maximum_size: |
| return False |
| remaining = info.st_size |
| chunks = [] |
| while remaining: |
| chunk = os.read(descriptor, min(1024 * 1024, remaining)) |
| if not chunk: |
| return False |
| chunks.append(chunk) |
| remaining -= len(chunk) |
| if os.read(descriptor, 1): |
| return False |
| finally: |
| os.close(descriptor) |
| destination.write_bytes(b"".join(chunks)) |
| destination.chmod(0o444) |
| return True |
| except OSError: |
| return False |
|
|
|
|
| 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) <= 120 |
| 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 |
| ratio = entry.file_size / max(entry.compress_size, 1) |
| if ( |
| entry.is_dir() |
| or entry.flag_bits & 0x1 |
| or entry.compress_type not in {zipfile.ZIP_STORED, zipfile.ZIP_DEFLATED} |
| or entry.file_size > 20 * 1024 * 1024 |
| or ratio > 200 |
| 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"} |
| or not ( |
| entry.filename == "Document.xml" |
| or entry.filename == "GuiDocument.xml" |
| or entry.filename == "Locations" |
| or entry.filename == "thumbnails/Thumbnail.png" |
| or member.suffix.lower() in {".brp", ".nc"} |
| ) |
| ): |
| return False |
| xml_data = archive.read("Document.xml") |
| gui_xml_data = archive.read("GuiDocument.xml") if "GuiDocument.xml" in names else None |
| except (OSError, KeyError, RuntimeError, zipfile.BadZipFile): |
| return False |
| xml_payloads = [xml_data] + ([gui_xml_data] if gui_xml_data is not None else []) |
| if any( |
| len(payload) > 5 * 1024 * 1024 |
| or b"<!DOCTYPE" in payload.replace(b"\x00", b"").upper() |
| or b"<!ENTITY" in payload.replace(b"\x00", b"").upper() |
| for payload in xml_payloads |
| ): |
| return False |
| try: |
| root = ET.fromstring(xml_data) |
| if gui_xml_data is not None: |
| ET.fromstring(gui_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) <= 60 |
| 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 |
| if any(extension.get("type") not in ALLOWED_EXTENSIONS for extension in root.findall(".//Extension")): |
| return False |
| archive_names = set(names) |
| for tag, suffix in (("Part", ".brp"), ("Path", ".nc")): |
| for node in root.findall(f".//{tag}"): |
| reference = node.get("file", "") |
| member = PurePosixPath(reference) |
| if ( |
| not reference |
| or reference.startswith("/") |
| or "\\" in reference |
| or ".." in member.parts |
| or len(member.parts) != 1 |
| or member.suffix.lower() != suffix |
| or reference not in archive_names |
| ): |
| return False |
|
|
| all_python_properties = root.findall('.//*[@type="App::PropertyPythonObject"]') |
| audited_python_properties = [] |
| seen_pairs = [] |
| for obj in data_objects: |
| 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: |
| nodes = prop.findall("Python") |
| if prop.get("name") != "Proxy" or len(nodes) != 1: |
| return False |
| node = nodes[0] |
| if set(node.attrib) != {"value", "encoded", "module", "class"} or node.get("encoded") != "yes": |
| return False |
| pair = (node.get("module"), node.get("class")) |
| if pair not in PROXY_STATES: |
| return False |
| try: |
| decoded = base64.b64decode(node.get("value", ""), validate=True) |
| except (ValueError, TypeError): |
| return False |
| if decoded != PROXY_STATES[pair]: |
| return False |
| seen_pairs.append(pair) |
| required_pairs = set(PROXY_STATES) - STOCK_PROXY_PAIRS |
| stock_pairs = [pair for pair in seen_pairs if pair in STOCK_PROXY_PAIRS] |
| 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} |
| or any(seen_pairs.count(pair) != 1 for pair in required_pairs) |
| or len(stock_pairs) != 1 |
| or len(seen_pairs) != len(required_pairs) + 1 |
| ): |
| return False |
|
|
| allowed_file_values = { |
| "", |
| "/home/user/Desktop/task-10.nc", |
| "/usr/lib/freecad/Mod/Path/Tools/Shape/endmill.fcstd", |
| } |
| for prop in root.findall('.//Property[@type="App::PropertyFile"]'): |
| strings = prop.findall("String") |
| if len(strings) != 1 or strings[0].get("value", "") not in allowed_file_values: |
| return False |
| return True |
|
|
|
|
| def proxy_module(obj) -> str: |
| proxy = getattr(obj, "Proxy", None) |
| return getattr(proxy.__class__, "__module__", "") if proxy is not None else "" |
|
|
|
|
| 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 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 expected_part(Part, App): |
| return Part.makeBox(120.0, 80.0, TOP_Z, App.Vector(-60.0, -40.0, 0.0)) |
|
|
|
|
| def expected_fixture(Part, App): |
| return Part.makeCompound( |
| [ |
| Part.makeBox(15.0, 20.0, 4.0, App.Vector(-45.0, -10.0, TOP_Z)), |
| Part.makeBox(15.0, 20.0, 4.0, App.Vector(30.0, -10.0, TOP_Z)), |
| ] |
| ) |
|
|
|
|
| def expected_avoidance(Part, App): |
| envelopes = [] |
| for solid in expected_fixture(Part, App).Solids: |
| box = solid.BoundBox |
| radius = CENTER_CLEARANCE |
| pieces = [ |
| Part.makeBox(box.XLength + 2.0 * radius, box.YLength, box.ZLength, |
| App.Vector(box.XMin - radius, box.YMin, box.ZMin)), |
| Part.makeBox(box.XLength, box.YLength + 2.0 * radius, box.ZLength, |
| App.Vector(box.XMin, box.YMin - radius, box.ZMin)), |
| Part.makeBox(box.XLength, box.YLength, box.ZLength + 2.0 * radius, |
| App.Vector(box.XMin, box.YMin, box.ZMin - radius)), |
| ] |
| for y in (box.YMin, box.YMax): |
| for z in (box.ZMin, box.ZMax): |
| pieces.append(Part.makeCylinder(radius, box.XLength, App.Vector(box.XMin, y, z), App.Vector(1, 0, 0))) |
| for x in (box.XMin, box.XMax): |
| for z in (box.ZMin, box.ZMax): |
| pieces.append(Part.makeCylinder(radius, box.YLength, App.Vector(x, box.YMin, z), App.Vector(0, 1, 0))) |
| for x in (box.XMin, box.XMax): |
| for y in (box.YMin, box.YMax): |
| pieces.append(Part.makeCylinder(radius, box.ZLength, App.Vector(x, y, box.ZMin), App.Vector(0, 0, 1))) |
| for x in (box.XMin, box.XMax): |
| for y in (box.YMin, box.YMax): |
| for z in (box.ZMin, box.ZMax): |
| pieces.append(Part.makeSphere(radius, App.Vector(x, y, z))) |
| envelope = pieces[0] |
| for piece in pieces[1:]: |
| envelope = envelope.fuse(piece) |
| envelopes.append(envelope) |
| return Part.makeCompound(envelopes) |
|
|
|
|
| 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 rounded_rectangle_contains(x: float, y: float, bounds, radius: float) -> bool: |
| xmin, xmax, ymin, ymax = bounds |
| center_x = min(max(x, xmin + radius), xmax - radius) |
| center_y = min(max(y, ymin + radius), ymax - radius) |
| return math.hypot(x - center_x, y - center_y) <= radius + 1e-8 |
|
|
|
|
| def disk_face(Part, App, x: float, y: float, z: float, radius: float): |
| edge = Part.makeCircle(radius, App.Vector(x, y, z)) |
| return Part.Face(Part.Wire([edge])) |
|
|
|
|
| def capsule_face(Part, App, start, end, z: float, radius: float): |
| start_disk = disk_face(Part, App, start[0], start[1], z, radius) |
| length = math.hypot(end[0] - start[0], end[1] - start[1]) |
| if length <= 1e-10: |
| return start_disk |
| nx = -(end[1] - start[1]) * radius / length |
| ny = (end[0] - start[0]) * radius / length |
| corners = [ |
| App.Vector(start[0] + nx, start[1] + ny, z), |
| App.Vector(end[0] + nx, end[1] + ny, z), |
| App.Vector(end[0] - nx, end[1] - ny, z), |
| App.Vector(start[0] - nx, start[1] - ny, z), |
| ] |
| strip = Part.Face(Part.makePolygon(corners + [corners[0]])) |
| end_disk = disk_face(Part, App, end[0], end[1], z, radius) |
| return start_disk.fuse(strip).fuse(end_disk).removeSplitter() |
|
|
|
|
| def cutter_at_point(Part, App, point): |
| return Part.makeCylinder( |
| TOOL_RADIUS, |
| CUTTING_EDGE_HEIGHT, |
| point, |
| App.Vector(0.0, 0.0, 1.0), |
| ) |
|
|
|
|
| def edge_point_at_length(edge, distance: float): |
| length = float(edge.Length) |
| if distance <= 0.0: |
| return edge.valueAt(edge.FirstParameter) |
| if distance >= length: |
| return edge.valueAt(edge.LastParameter) |
| parameter = edge.getParameterByLength(distance) |
| return edge.valueAt(parameter) |
|
|
|
|
| def certified_edge_clearance(edge, fixture_shape, Part, App): |
| length = float(edge.Length) |
| if not math.isfinite(length) or length <= 1e-10: |
| return None |
| cache = {} |
|
|
| def sample(distance: float): |
| key = round(distance, 12) |
| if key in cache: |
| return cache[key] |
| point = edge_point_at_length(edge, distance) |
| if not all(math.isfinite(value) for value in (point.x, point.y, point.z)): |
| raise ValueError("non-finite edge point") |
| cutter = cutter_at_point(Part, App, point) |
| clearance = float(cutter.distToShape(fixture_shape)[0]) |
| if not math.isfinite(clearance): |
| raise ValueError("non-finite fixture clearance") |
| cache[key] = (point, clearance) |
| return cache[key] |
|
|
| try: |
| start_point, start_clearance = sample(0.0) |
| end_point, end_clearance = sample(length) |
| except Exception: |
| return None |
| stack = [(0.0, length, start_clearance, end_clearance, 0)] |
| certified_minimum = float("inf") |
| while stack: |
| start_length, end_length, first_clearance, second_clearance, depth = stack.pop() |
| interval = end_length - start_length |
| lower_bound = min(first_clearance, second_clearance) - interval / 2.0 |
| if lower_bound >= FIXTURE_CLEARANCE - 0.02: |
| certified_minimum = min(certified_minimum, lower_bound) |
| continue |
| if min(first_clearance, second_clearance) < FIXTURE_CLEARANCE - 0.02 or depth >= 30: |
| return None |
| middle_length = (start_length + end_length) / 2.0 |
| try: |
| _, middle_clearance = sample(middle_length) |
| except Exception: |
| return None |
| if middle_clearance < FIXTURE_CLEARANCE - 0.02: |
| return None |
| stack.append((middle_length, end_length, middle_clearance, second_clearance, depth + 1)) |
| stack.append((start_length, middle_length, first_clearance, middle_clearance, depth + 1)) |
| if certified_minimum == float("inf"): |
| return None |
| return certified_minimum |
|
|
|
|
| def edge_chords(edge): |
| if edge is None: |
| return [] |
| try: |
| points = list(edge.discretize(Deflection=0.02)) |
| except Exception: |
| points = [edge.valueAt(edge.FirstParameter), edge.valueAt(edge.LastParameter)] |
| if len(points) < 2: |
| return [] |
| return list(zip(points, points[1:])) |
|
|
|
|
| def contact_chord(start, end): |
| if min(start.z, end.z) >= TOP_Z - 1e-5: |
| return None |
| first = start |
| second = end |
| dz = end.z - start.z |
| if abs(dz) > 1e-12: |
| fraction = (TOP_Z - start.z) / dz |
| if 0.0 < fraction < 1.0: |
| crossing = start + (end - start) * fraction |
| if start.z > TOP_Z: |
| first = crossing |
| elif end.z > TOP_Z: |
| second = crossing |
| return first, second |
|
|
|
|
| def property_semantics(obj, name: str) -> str: |
| details = [name] |
| for method_name in ("getGroupOfProperty", "getDocumentationOfProperty"): |
| try: |
| details.append(str(getattr(obj, method_name)(name))) |
| except Exception: |
| pass |
| return " ".join(details).lower().replace("_", " ") |
|
|
|
|
| def property_meaning(obj, name: str) -> str: |
| details = [name] |
| try: |
| details.append(str(obj.getDocumentationOfProperty(name))) |
| except Exception: |
| pass |
| return " ".join(details).lower().replace("_", " ") |
|
|
|
|
| def fixture_semantics(obj, name: str) -> bool: |
| text = property_semantics(obj, name) |
| return any(token in text for token in ("fixture", "check geometry", "checkgeometry", "clamp")) |
|
|
|
|
| def linked_to(obj, target) -> bool: |
| link_types = { |
| "App::PropertyLink", |
| "App::PropertyLinkChild", |
| "App::PropertyLinkGlobal", |
| "App::PropertyLinkHidden", |
| "App::PropertyLinkList", |
| "App::PropertyLinkListChild", |
| "App::PropertyLinkListGlobal", |
| "App::PropertyLinkListHidden", |
| "App::PropertyLinkSub", |
| "App::PropertyLinkSubChild", |
| "App::PropertyLinkSubGlobal", |
| "App::PropertyLinkSubHidden", |
| "App::PropertyLinkSubList", |
| "App::PropertyLinkSubListChild", |
| "App::PropertyLinkSubListGlobal", |
| "App::PropertyLinkSubListHidden", |
| "App::PropertyXLink", |
| "App::PropertyXLinkContainer", |
| "App::PropertyXLinkList", |
| "App::PropertyXLinkSub", |
| "App::PropertyXLinkSubList", |
| } |
|
|
| def targets(value): |
| if value is None: |
| return [] |
| if hasattr(value, "Name") and hasattr(value, "Document"): |
| return [value] |
| if isinstance(value, tuple) and value and hasattr(value[0], "Name"): |
| return [value[0]] |
| if isinstance(value, (list, tuple)): |
| result = [] |
| for item in value: |
| result.extend(targets(item)) |
| return result |
| return [] |
|
|
| try: |
| links = [ |
| (name, targets(getattr(obj, name))) |
| for name in obj.PropertiesList |
| if obj.getTypeIdOfProperty(name) in link_types |
| and fixture_semantics(obj, name) |
| ] |
| return bool(links) and all( |
| values and all(value == target for value in values) and not obj.getEditorMode(name) |
| for name, values in links |
| ) |
| except Exception: |
| return False |
|
|
|
|
| def semantic_scalar_values(obj, predicate): |
| scalar_types = { |
| "App::PropertyDistance", |
| "App::PropertyFloat", |
| "App::PropertyFloatConstraint", |
| "App::PropertyInteger", |
| "App::PropertyIntegerConstraint", |
| "App::PropertyLength", |
| "App::PropertyPercent", |
| "App::PropertyQuantity", |
| } |
| try: |
| values = [] |
| for name in obj.PropertiesList: |
| if obj.getTypeIdOfProperty(name) not in scalar_types: |
| continue |
| semantics = property_semantics(obj, name) |
| meaning = property_meaning(obj, name) |
| normalized_name = name.lower().replace("_", "").replace(" ", "") |
| if not predicate(normalized_name, semantics, meaning): |
| continue |
| if obj.getEditorMode(name): |
| return [] |
| value = getattr(obj, name) |
| number = value.Value if hasattr(value, "Value") else value |
| values.append(float(number)) |
| return values |
| except Exception: |
| return [] |
|
|
|
|
| def has_scalar_value(obj, expected: float) -> bool: |
| values = semantic_scalar_values( |
| obj, |
| lambda name, semantics, meaning: ( |
| name not in {"clearanceheight", "safeheight"} |
| and any(token in semantics for token in ("fixture", "check geometry", "checkgeometry", "clamp")) |
| and any(token in meaning for token in ("clear", "offset", "distance", "gap", "safety")) |
| and not ("tool" in meaning and "radius" in meaning) |
| ), |
| ) |
| return bool(values) and all(close(value, expected) for value in values) |
|
|
|
|
| def avoidance_has_editable_offset(avoidance) -> bool: |
| total_markers = ("center", "envelope", "total", "combined") |
| total_values = semantic_scalar_values( |
| avoidance, |
| lambda name, semantics, meaning: ( |
| any(marker in meaning for marker in total_markers) |
| and any(token in meaning for token in ("clear", "offset", "distance", "gap", "safety")) |
| and any(token in semantics for token in ("fixture", "check geometry", "checkgeometry", "clamp")) |
| and not ("tool" in meaning and "radius" in meaning) |
| ), |
| ) |
| fixture_values = semantic_scalar_values( |
| avoidance, |
| lambda name, semantics, meaning: ( |
| any(token in meaning for token in ("clear", "offset", "distance", "gap", "safety")) |
| and any(token in semantics for token in ("fixture", "check geometry", "checkgeometry", "clamp")) |
| and any(token in meaning for token in ("fixture", "clamp")) |
| and not any(marker in meaning for marker in total_markers) |
| and not ("tool" in meaning and "radius" in meaning) |
| ), |
| ) |
| radius_values = semantic_scalar_values( |
| avoidance, |
| lambda name, semantics, meaning: ( |
| "tool" in meaning |
| and "radius" in meaning |
| and any(token in semantics for token in ("fixture", "check geometry", "checkgeometry", "clamp")) |
| ), |
| ) |
| if total_values and not all(close(value, CENTER_CLEARANCE) for value in total_values): |
| return False |
| if fixture_values and not all(close(value, FIXTURE_CLEARANCE) for value in fixture_values): |
| return False |
| if radius_values and not all(close(value, TOOL_RADIUS) for value in radius_values): |
| return False |
| return bool(total_values) or (bool(fixture_values) and bool(radius_values)) |
|
|
|
|
| def avoidance_is_linked_offset(avoidance, fixture_object, fixture_shape, Part, App) -> bool: |
| try: |
| shape = avoidance.Shape |
| if ( |
| not linked_to(avoidance, fixture_object) |
| or not avoidance_has_editable_offset(avoidance) |
| or shape.isNull() |
| or not shape.isValid() |
| ): |
| return False |
| if fixture_shape.cut(shape).Volume > 1e-4: |
| return False |
| expected_shape = expected_avoidance(Part, App) |
| if expected_shape.cut(shape).Volume > 1e-3: |
| return False |
| expected_bounds = expected_shape.BoundBox |
| actual_bounds = shape.BoundBox |
| if any( |
| not close(actual, expected, 1e-4) |
| for actual, expected in ( |
| (actual_bounds.XMin, expected_bounds.XMin), |
| (actual_bounds.XMax, expected_bounds.XMax), |
| (actual_bounds.YMin, expected_bounds.YMin), |
| (actual_bounds.YMax, expected_bounds.YMax), |
| (actual_bounds.ZMin, expected_bounds.ZMin), |
| (actual_bounds.ZMax, expected_bounds.ZMax), |
| ) |
| ): |
| return False |
| return True |
| except Exception: |
| return False |
|
|
|
|
| def validate_operation_path(operation, fixture_shape, Part, App, PathGeom): |
| commands = list(operation.Path.Commands) |
| current = {axis: None for axis in ("X", "Y", "Z")} |
| first_motion = True |
| floor_segments = [] |
| level_segments = {INTERMEDIATE_Z: [], FLOOR_Z: []} |
| minimum_clearance = float("inf") |
| for command in commands: |
| name = str(command.Name).upper().replace(" ", "") |
| if name not in {"G0", "G00", "G1", "G01", "G2", "G02", "G3", "G03"}: |
| continue |
| parameters = command.Parameters |
| before = dict(current) |
| for axis in current: |
| if axis in parameters: |
| current[axis] = float(parameters[axis]) |
| if first_motion: |
| first_motion = False |
| if name not in {"G0", "G00"} or "Z" not in parameters or float(parameters["Z"]) < CLEARANCE_Z - 1e-4: |
| return None |
| if not all(value is not None for value in current.values()): |
| continue |
| if not all(value is not None for value in before.values()): |
| if current["Z"] < CLEARANCE_Z - 1e-4: |
| return None |
| continue |
| start = App.Vector(before["X"], before["Y"], before["Z"]) |
| try: |
| edge = PathGeom.edgeForCmd(command, start) |
| except Exception: |
| return None |
| chords = edge_chords(edge) |
| if not chords: |
| continue |
| rapid = name in {"G0", "G00"} |
| for first, second in chords: |
| if min(first.z, second.z) < FLOOR_Z - 1e-4: |
| return None |
| horizontal = math.hypot(second.x - first.x, second.y - first.y) > 1e-6 |
| if rapid and min(first.z, second.z) < SAFE_Z - 1e-4: |
| vertical_retract = not horizontal and second.z >= first.z - 1e-6 |
| if not vertical_retract: |
| return None |
| if rapid: |
| continue |
| contact = contact_chord(first, second) |
| if contact is None: |
| continue |
| low_first, low_second = contact |
| if any( |
| point.x < POCKET_BOUNDS[0] + TOOL_RADIUS - 0.02 |
| or point.x > POCKET_BOUNDS[1] - TOOL_RADIUS + 0.02 |
| or point.y < POCKET_BOUNDS[2] + TOOL_RADIUS - 0.02 |
| or point.y > POCKET_BOUNDS[3] - TOOL_RADIUS + 0.02 |
| for point in (low_first, low_second) |
| ): |
| return None |
| if horizontal and close(first.z, second.z, 1e-4): |
| for level in level_segments: |
| if close(first.z, level, 1e-4): |
| segment = ((first.x, first.y), (second.x, second.y)) |
| level_segments[level].append(segment) |
| if level == FLOOR_Z: |
| floor_segments.append(segment) |
| clearance = certified_edge_clearance(edge, fixture_shape, Part, App) |
| if clearance is None: |
| return None |
| minimum_clearance = min(minimum_clearance, clearance) |
| if not floor_segments or minimum_clearance == float("inf"): |
| return None |
| for level, segments in level_segments.items(): |
| if not segments: |
| return None |
| samples = 0 |
| x = POCKET_BOUNDS[0] |
| while x <= POCKET_BOUNDS[1] + 1e-8: |
| y = POCKET_BOUNDS[2] |
| while y <= POCKET_BOUNDS[3] + 1e-8: |
| if rounded_rectangle_contains(x, y, POCKET_BOUNDS, TOOL_RADIUS): |
| if min(distance_to_segment(x, y, start, end) for start, end in segments) > TOOL_RADIUS + 0.12: |
| return None |
| samples += 1 |
| y += 0.5 |
| x += 0.5 |
| if samples < 4000: |
| return None |
| return minimum_clearance |
|
|
|
|
| ACTIVE_COMMENT = re.compile( |
| r"^(?:ABORT|DEBUG|LOG|LOGAPPEND|LOGCLOSE|LOGOPEN|MSG|PRINT|PROBECLOSE|PROBEOPEN)(?:\s|,|$)" |
| ) |
|
|
|
|
| def reject_active_comment(content: str) -> None: |
| if ACTIVE_COMMENT.match(content.strip().upper()): |
| raise ValueError("active LinuxCNC comment") |
|
|
|
|
| def strip_comments(text: str): |
| output = [] |
| for raw_line in text.splitlines(keepends=True): |
| if raw_line.endswith("\r\n"): |
| line, ending = raw_line[:-2], "\r\n" |
| elif raw_line.endswith(("\r", "\n")): |
| line, ending = raw_line[:-1], raw_line[-1] |
| else: |
| line, ending = raw_line, "" |
| cleaned = list(line) |
| parenthesis_comments = [] |
| semicolon_comment = None |
| index = 0 |
| while index < len(line): |
| char = line[index] |
| if char == "(": |
| end = line.find(")", index + 1) |
| if end < 0 or "(" in line[index + 1 : end]: |
| raise ValueError("malformed parenthesis comment") |
| parenthesis_comments.append(line[index + 1 : end]) |
| cleaned[index : end + 1] = " " * (end + 1 - index) |
| index = end + 1 |
| elif char == ")": |
| raise ValueError("unmatched parenthesis") |
| elif char == ";": |
| semicolon_comment = line[index + 1 :] |
| cleaned[index:] = " " * (len(line) - index) |
| break |
| else: |
| index += 1 |
| if semicolon_comment is not None: |
| reject_active_comment(semicolon_comment) |
| elif parenthesis_comments: |
| reject_active_comment(parenthesis_comments[-1]) |
| output.append("".join(cleaned) + ending) |
| return "".join(output) |
|
|
|
|
| def parse_nc(text: str): |
| executable = strip_comments(text) |
| raw_lines = executable.splitlines() |
| nonempty = [index for index, line in enumerate(raw_lines) if line.strip()] |
| percent_lines = [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") |
| letter = match.group(1).upper() |
| number_text = match.group(2) |
| number = float(number_text) |
| if not math.isfinite(number): |
| raise ValueError("non-finite NC word") |
| if letter == "N" and (tokens or not re.fullmatch(r"\d+(?:\.\d+)?", number_text)): |
| raise ValueError("invalid line number") |
| tokens.append((letter, number)) |
| 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 block_codes(block): |
| codes = {"G": [], "M": []} |
| for letter, number in block: |
| if letter not in codes: |
| continue |
| if not close(number, round(number), 1e-9): |
| raise ValueError("fractional G/M code") |
| codes[letter].append(int(round(number))) |
| for letter, groups in (("G", G_MODAL_GROUPS), ("M", M_MODAL_GROUPS)): |
| values = codes[letter] |
| if len(values) != len(set(values)): |
| raise ValueError("duplicate G/M code") |
| if any(sum(code in group for code in values) > 1 for group in groups): |
| raise ValueError("conflicting modal codes") |
| return codes["G"], codes["M"] |
|
|
|
|
| def canonical_blocks(text: str): |
| result = [] |
| position = {axis: None for axis in ("X", "Y", "Z")} |
| modal_motion = None |
| modal_feed = None |
| for block in parse_nc(text): |
| g_codes, _ = block_codes(block) |
| words = {} |
| codes = [] |
| for letter, number in block: |
| if letter == "N": |
| continue |
| if letter in {"G", "M"}: |
| codes.append((letter, number)) |
| else: |
| if letter in words: |
| raise ValueError("duplicate NC word") |
| words[letter] = number |
| for code in g_codes: |
| if code in {0, 1, 2, 3}: |
| modal_motion = code |
| if "F" in words: |
| modal_feed = words["F"] |
| moved = any(axis in words for axis in position) |
| for axis in position: |
| if axis in words: |
| position[axis] = words[axis] |
| if moved and modal_motion in {0, 1, 2, 3} and all(value is not None for value in position.values()): |
| for axis, value in position.items(): |
| words.setdefault(axis, value) |
| codes = [(letter, number) for letter, number in codes if letter != "G" or int(round(number)) not in {0, 1, 2, 3}] |
| codes.append(("G", float(modal_motion))) |
| if modal_motion in {1, 2, 3} and modal_feed is not None: |
| words.setdefault("F", modal_feed) |
| normalized = [] |
| for letter, number in codes + list(words.items()): |
| if letter == "M" and close(number, 30.0, 1e-9): |
| number = 2.0 |
| 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": False, |
| "absolute": False, |
| "wcs": False, |
| "motion": None, |
| "feed": None, |
| "speed": None, |
| "tool": None, |
| "spindle": False, |
| "changed": False, |
| "X": None, |
| "Y": None, |
| "Z": None, |
| } |
| tool_changes = [] |
| levels = set() |
| terminators = 0 |
| for block_index, block in enumerate(blocks): |
| words = {} |
| try: |
| g_codes, m_codes = block_codes(block) |
| except ValueError: |
| return False |
| for letter, number in block: |
| if letter not in {"F", "G", "H", "I", "J", "K", "M", "N", "S", "T", "X", "Y", "Z"}: |
| return False |
| if letter not in {"G", "M"}: |
| if letter in words: |
| return False |
| words[letter] = number |
| if any(code not in {0, 1, 2, 3, 17, 21, 40, 43, 49, 54, 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"] = True |
| if 90 in g_codes: |
| state["absolute"] = True |
| if 54 in g_codes: |
| state["wcs"] = True |
| for code in g_codes: |
| if code in {0, 1, 2, 3}: |
| state["motion"] = code |
| if "T" in words: |
| if not close(words["T"], 1.0, 1e-9): |
| return False |
| state["tool"] = 1 |
| if "H" in words and not close(words["H"], 1.0, 1e-9): |
| return False |
| if "S" in words: |
| if not close(words["S"], 7000.0, 1e-6): |
| return False |
| state["speed"] = words["S"] |
| if "F" in words: |
| if not close(words["F"], 500.0, 1e-4): |
| 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"] != 1: |
| return False |
| state["changed"] = True |
| tool_changes.append(1) |
| if 3 in m_codes or 4 in m_codes: |
| if state["speed"] is None or not close(state["speed"], 7000.0): |
| return False |
| state["spindle"] = True |
| before = {axis: state[axis] for axis in ("X", "Y", "Z")} |
| moved = False |
| for axis in before: |
| if axis in words: |
| state[axis] = words[axis] |
| moved = True |
| if moved and state["motion"] in {0, 1, 2, 3}: |
| if not state["units"] or not state["absolute"] or not state["wcs"]: |
| return False |
| if state["motion"] == 0: |
| if state["Z"] is None: |
| return False |
| if before["Z"] is None and state["Z"] < CLEARANCE_Z - 1e-4: |
| return False |
| horizontal = ( |
| before["X"] is not None |
| and before["Y"] is not None |
| and state["X"] is not None |
| and state["Y"] is not None |
| and (not close(before["X"], state["X"]) or not close(before["Y"], state["Y"])) |
| ) |
| if before["Z"] is not None and min(before["Z"], state["Z"]) < SAFE_Z - 1e-4: |
| vertical_retract = not horizontal and state["Z"] >= before["Z"] - 1e-6 |
| if not vertical_retract: |
| return False |
| else: |
| if not state["changed"] or not state["spindle"] or state["feed"] is None or state["Z"] is None: |
| return False |
| if state["Z"] < FLOOR_Z - 1e-4: |
| return False |
| horizontal = ( |
| before["X"] is not None |
| and before["Y"] is not None |
| and (not close(before["X"], state["X"]) or not close(before["Y"], state["Y"])) |
| ) |
| if horizontal and before["Z"] is not None and close(before["Z"], state["Z"], 1e-4): |
| if close(state["Z"], INTERMEDIATE_Z, 1e-4): |
| levels.add(INTERMEDIATE_Z) |
| if close(state["Z"], FLOOR_Z, 1e-4): |
| levels.add(FLOOR_Z) |
| if 2 in m_codes or 30 in m_codes: |
| terminators += 1 |
| if block_index != len(blocks) - 1 or state["spindle"]: |
| return False |
| return ( |
| state["units"] |
| and state["absolute"] |
| and state["wcs"] |
| and tool_changes == [1] |
| and levels == {INTERMEDIATE_Z, FLOOR_Z} |
| and terminators == 1 |
| ) |
|
|
|
|
| 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"(?:\d|1\d|20)", arguments[index]): |
| return False |
| index += 1 |
| continue |
| if re.fullmatch(r"--precision=(?:\d|1\d|20)", 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.Geom as PathGeom |
| 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 ( |
| (PART_PATH, 5 * 1024 * 1024), |
| (FIXTURE_PATH, 5 * 1024 * 1024), |
| (FCSTD_PATH, 20 * 1024 * 1024), |
| (NC_PATH, 5 * 1024 * 1024), |
| ) |
| ): |
| return False |
| if not safe_fcstd_container(FCSTD_PATH): |
| return False |
| if ( |
| normalized_text_sha256(PART_PATH) != EXPECTED_PART_SHA256 |
| or normalized_text_sha256(FIXTURE_PATH) != EXPECTED_FIXTURE_SHA256 |
| ): |
| return False |
|
|
| part_shape = Part.read(str(PART_PATH)) |
| fixture_shape = Part.read(str(FIXTURE_PATH)) |
| expected_part_shape = expected_part(Part, App) |
| expected_fixture_shape = expected_fixture(Part, App) |
| if ( |
| len(part_shape.Solids) != 1 |
| or len(fixture_shape.Solids) != 2 |
| or not shapes_equal(part_shape, expected_part_shape, 1e-3) |
| or not shapes_equal(fixture_shape, expected_fixture_shape, 1e-3) |
| or part_shape.common(fixture_shape).Volume > 1e-5 |
| ): |
| return False |
|
|
| document = App.openDocument(str(FCSTD_PATH)) |
| if document is None or "prototype" in str(document.Label).lower(): |
| return False |
| jobs = [obj for obj in document.Objects if proxy_module(obj) == "Path.Main.Job"] |
| pockets = [obj for obj in document.Objects if proxy_module(obj) == "Path.Op.PocketShape"] |
| dressups = [obj for obj in document.Objects if proxy_module(obj) == "Path.Dressup.Boundary"] |
| stocks = [obj for obj in document.Objects if proxy_module(obj) == "Path.Main.Stock"] |
| controllers = [obj for obj in document.Objects if proxy_module(obj) == "Path.Tool.Controller"] |
| tools = [obj for obj in document.Objects if proxy_module(obj) == "Path.Tool.Bit"] |
| if not all(len(items) == 1 for items in (jobs, pockets, dressups, stocks, controllers, tools)): |
| return False |
| job, pocket, dressup, controller, tool = jobs[0], pockets[0], dressups[0], controllers[0], tools[0] |
|
|
| 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 ( |
| list(job.Operations.Group) != [dressup] |
| or dressup.Base != pocket |
| or bool(dressup.Inside) |
| or str(job.PostProcessor).strip().lower() != "linuxcnc" |
| or bool(job.SplitOutput) |
| or os.path.normpath(str(job.PostProcessorOutputFile)) != "/home/user/Desktop/task-10.nc" |
| or not valid_postprocessor_args(str(job.PostProcessorArgs)) |
| or [str(value).strip().upper() for value in job.Fixtures] != ["G54"] |
| ): |
| return False |
| if len(job.Model.Group) != 1 or not shapes_equal(job.Model.Group[0].Shape, part_shape, 1e-3): |
| return False |
| if not shapes_equal(job.Stock.Shape, part_shape, 1e-3): |
| return False |
|
|
| fixture_objects = [ |
| obj |
| for obj in document.Objects |
| if hasattr(obj, "Shape") |
| and not obj.Shape.isNull() |
| and shapes_equal(obj.Shape, fixture_shape, 1e-3) |
| ] |
| if ( |
| len(fixture_objects) != 1 |
| or job.Model.Group[0] in fixture_objects |
| ): |
| return False |
| source_model = job.Model.Group[0] |
| fixture_object = fixture_objects[0] |
|
|
| if ( |
| controller.Tool != tool |
| or int(controller.ToolNumber) != 1 |
| or not close(controller.SpindleSpeed, 7000.0) |
| or str(controller.SpindleDir) != "Forward" |
| or not close(controller.HorizFeed.getValueAs("mm/min").Value, 500.0) |
| or not close(controller.VertFeed.getValueAs("mm/min").Value, 500.0) |
| or pocket.ToolController != controller |
| or not close(tool.Diameter.Value, TOOL_DIAMETER) |
| or not close(tool.ShankDiameter.Value, TOOL_DIAMETER) |
| or str(tool.ShapeName).lower() != "endmill" |
| ): |
| return False |
|
|
| for obj in (pocket, dressup): |
| if not linked_to(obj, fixture_object) or not has_scalar_value(obj, FIXTURE_CLEARANCE): |
| return False |
| if ( |
| not close(pocket.StartDepth.Value, TOP_Z) |
| or not close(pocket.FinalDepth.Value, FLOOR_Z) |
| or not close(pocket.StepDown.Value, 2.5) |
| or not close(pocket.SafeHeight.Value, SAFE_Z) |
| or not close(pocket.ClearanceHeight.Value, CLEARANCE_Z) |
| ): |
| return False |
|
|
| try: |
| bases = list(pocket.Base) |
| except Exception: |
| return False |
| if len(bases) != 1 or len(bases[0][1]) != 1 or not str(bases[0][1][0]).startswith("Face"): |
| return False |
| boundary = bases[0][0] |
| try: |
| selected = boundary.Shape.getElement(str(bases[0][1][0])) |
| except Exception: |
| return False |
| expected_boundary = Part.makePlane(50.0, 30.0, App.Vector(-25.0, -15.0, TOP_Z)) |
| if ( |
| selected.BoundBox.ZLength > 1e-5 |
| or selected.cut(expected_boundary).Area > 1e-4 |
| or expected_boundary.cut(selected).Area > 1e-4 |
| ): |
| return False |
|
|
| avoidance = dressup.Stock |
| if ( |
| avoidance is None |
| or not avoidance_is_linked_offset(avoidance, fixture_object, fixture_shape, Part, App) |
| ): |
| return False |
|
|
| minimum_clearance = validate_operation_path(dressup, fixture_shape, Part, App, PathGeom) |
| if minimum_clearance is None or minimum_clearance < FIXTURE_CLEARANCE - 0.02: |
| 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 or dressup not in sections[0][1] or pocket in sections[0][1]: |
| return False |
| with tempfile.TemporaryDirectory(prefix="engiworld-task10-repost-") as temporary: |
| repost_path = Path(temporary) / "task-10.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: |
| trusted_source = globals().get("TRUSTED_EVALUATOR_SOURCE") |
| if os.geteuid() != 0 or not isinstance(trusted_source, bytes): |
| return False |
| try: |
| if ctypes.CDLL(None).prctl(4, 0, 0, 0, 0) != 0: |
| return False |
| except Exception: |
| return False |
| try: |
| executable = FREECADCMD.resolve(strict=True) |
| info = executable.stat() |
| bwrap = BWRAP.resolve(strict=True) |
| bwrap_info = bwrap.stat() |
| except OSError: |
| return False |
| if any( |
| not stat.S_ISREG(item.st_mode) or item.st_uid != 0 or item.st_mode & 0o022 |
| for item in (info, bwrap_info) |
| ): |
| return False |
| try: |
| with tempfile.TemporaryDirectory(prefix="engiworld-task10-stage-") as stage_text: |
| stage = Path(stage_text) |
| pairs = ( |
| (DESKTOP / "part.step", stage / "part.step", 5 * 1024 * 1024), |
| (DESKTOP / "fixture.step", stage / "fixture.step", 5 * 1024 * 1024), |
| (DESKTOP / "task-10.FCStd", stage / "task-10.FCStd", 20 * 1024 * 1024), |
| (DESKTOP / "task-10.nc", stage / "task-10.nc", 5 * 1024 * 1024), |
| ) |
| if not all(stage_file(source, destination, maximum) for source, destination, maximum in pairs): |
| return False |
| evaluator_path = stage / "eval.py" |
| descriptor = os.open(evaluator_path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o444) |
| try: |
| view = memoryview(trusted_source) |
| while view: |
| written = os.write(descriptor, view) |
| if written <= 0: |
| return False |
| view = view[written:] |
| os.fsync(descriptor) |
| finally: |
| os.close(descriptor) |
| stage.chmod(0o755) |
| evaluator = "/work/eval.py" |
| command = ( |
| "import builtins,os; builtins.pythonopen=open; " |
| "exec(\"try:\\n" |
| f" ns={{'__name__':'task10_inner','__file__':{evaluator!r}}}\\n" |
| f" exec(compile(open({evaluator!r}, encoding='utf-8').read(), {evaluator!r}, 'exec'), ns)\\n" |
| " ok=ns['evaluate_in_freecad']()\\n" |
| "except BaseException:\\n os._exit(125)\\n" |
| "os._exit(0 if ok is True else 1)\")" |
| ) |
| environment = { |
| "HOME": "/tmp", |
| "LANG": "C.UTF-8", |
| "LC_ALL": "C.UTF-8", |
| "LOGNAME": "user", |
| "PATH": "/usr/bin:/bin", |
| "PYTHONNOUSERSITE": "1", |
| "TMPDIR": "/tmp", |
| "USER": "user", |
| "XDG_CACHE_HOME": "/tmp/.cache", |
| "XDG_CONFIG_HOME": "/tmp/.config", |
| "ENGIWORLD_TASK10_STAGE": "/work", |
| } |
| sandbox = [ |
| str(bwrap), |
| "--unshare-all", |
| "--unshare-user", |
| "--die-with-parent", |
| "--new-session", |
| "--cap-drop", "ALL", |
| "--disable-userns", |
| "--ro-bind", "/usr", "/usr", |
| "--symlink", "usr/bin", "/bin", |
| "--symlink", "usr/lib", "/lib", |
| "--symlink", "usr/lib64", "/lib64", |
| "--dir", "/etc", |
| "--ro-bind", "/etc/fonts", "/etc/fonts", |
| "--ro-bind", "/etc/group", "/etc/group", |
| "--ro-bind", "/etc/ld.so.cache", "/etc/ld.so.cache", |
| "--ro-bind", "/etc/localtime", "/etc/localtime", |
| "--ro-bind", "/etc/nsswitch.conf", "/etc/nsswitch.conf", |
| "--ro-bind", "/etc/passwd", "/etc/passwd", |
| "--proc", "/proc", |
| "--dev", "/dev", |
| "--size", str(256 * 1024 * 1024), |
| "--tmpfs", "/tmp", |
| "--ro-bind", str(stage), "/work", |
| "--uid", "1000", |
| "--gid", "1000", |
| "--clearenv", |
| ] |
| for name, value in environment.items(): |
| sandbox.extend(("--setenv", name, value)) |
| sandbox.extend(("--chdir", "/tmp", "--", str(executable), "-c", command)) |
|
|
| def apply_limits(): |
| resource.setrlimit(resource.RLIMIT_AS, (3 * 1024**3, 3 * 1024**3)) |
| resource.setrlimit(resource.RLIMIT_CORE, (0, 0)) |
| resource.setrlimit(resource.RLIMIT_CPU, (230, 230)) |
| resource.setrlimit(resource.RLIMIT_FSIZE, (64 * 1024**2, 64 * 1024**2)) |
| resource.setrlimit(resource.RLIMIT_NOFILE, (256, 256)) |
| resource.setrlimit(resource.RLIMIT_NPROC, (128, 128)) |
|
|
| completed = subprocess.run( |
| sandbox, |
| stdin=subprocess.DEVNULL, |
| stdout=subprocess.DEVNULL, |
| stderr=subprocess.DEVNULL, |
| timeout=240, |
| env={"PATH": "/usr/bin:/bin"}, |
| cwd="/", |
| preexec_fn=apply_limits, |
| check=False, |
| ) |
| except Exception: |
| return False |
| return completed.returncode == 0 |
|
|
|
|
| if __name__ == "__main__": |
| print(True if run_outer() else False) |
|
|
