| from __future__ import annotations |
|
|
| import base64 |
| import hashlib |
| import json |
| import math |
| import os |
| import re |
| import stat |
| import subprocess |
| import sys |
| import tempfile |
| import zipfile |
| import xml.etree.ElementTree as ET |
| from collections import Counter |
| from pathlib import Path, PurePosixPath |
|
|
|
|
| TARGET = Path("/home/user/Desktop") |
| STEP = TARGET / "final_benchmark.step" |
| PARAMS = TARGET / "params.json" |
| FCSTD = TARGET / "task-20.FCStd" |
| NC = TARGET / "task-20.nc" |
| POST_LOG = TARGET / "post_log.txt" |
| FREECADCMD = Path("/usr/bin/freecadcmd") |
| EXPECTED_STEP_SHA256 = "259a0d5d6d7836c0b361b994b4f6f766a54787ade9f7b5e84b9d9173e983751e" |
| EXPECTED_PARAMS_SHA256 = "9eceee889093cdb2c5bf98397521ba1421c0da1fd4f61a4ec7005ac51ffcd232" |
| NUMBER = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)" |
| WORD_RE = re.compile(rf"([A-Z])\s*({NUMBER})", re.ASCII) |
| ALLOWED_ADDRESSES = {"N", "G", "M", "T", "H", "S", "F", "X", "Y", "Z", "I", "J", "R", "P", "Q"} |
| ALLOWED_G = {0, 1, 2, 3, 17, 21, 40, 43, 49, 54, 80, 81, 82, 83, 90, 94, 98, 99} |
| ALLOWED_M = {2, 3, 5, 6, 8, 9, 30} |
| EXPECTED_HOLES = { |
| (x, y) |
| for y in (-32.0, -16.0) |
| for x in (-70.0, -50.0, -30.0, -10.0, 10.0, 30.0, 50.0, 70.0) |
| } | {(-78.0, 38.0), (78.0, 38.0)} |
| REQUIRED_PROXIES = Counter( |
| { |
| ("Path.Main.Job", "ObjectJob"): 1, |
| ("Path.Base.SetupSheet", "SetupSheet"): 1, |
| ("draftobjects.clone", "Clone"): 1, |
| ("Path.Tool.Controller", "ToolController"): 5, |
| ("Path.Tool.Bit", "ToolBit"): 5, |
| ("Path.Op.MillFace", "ObjectFace"): 1, |
| ("Path.Op.PocketShape", "ObjectPocket"): 3, |
| ("Path.Op.Drilling", "ObjectDrilling"): 1, |
| ("Path.Op.Helix", "ObjectHelix"): 1, |
| ("Path.Op.Surface", "ObjectSurface"): 1, |
| ("Path.Op.Profile", "ObjectProfile"): 1, |
| } |
| ) |
|
|
|
|
| def fail(message): |
| print("task-20 evaluator: " + message, file=sys.stderr) |
| return False |
|
|
|
|
| def close(left, right, tolerance=1e-6): |
| try: |
| a, b = float(left), float(right) |
| except (TypeError, ValueError): |
| return False |
| return math.isfinite(a) and math.isfinite(b) and abs(a - b) <= tolerance |
|
|
|
|
| def regular_file(path, minimum, maximum): |
| try: |
| info = path.lstat() |
| except OSError: |
| return False |
| return stat.S_ISREG(info.st_mode) and not path.is_symlink() and minimum <= info.st_size <= maximum |
|
|
|
|
| def sha256(path): |
| 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): |
| data = path.read_bytes().replace(b"\r\n", b"\n").replace(b"\r", b"\n") |
| return hashlib.sha256(data).hexdigest() |
|
|
|
|
| def freeze_file(source, target, minimum, maximum): |
| flags = os.O_RDONLY | os.O_CLOEXEC | os.O_NOFOLLOW |
| try: |
| descriptor = os.open(source, flags) |
| try: |
| before = os.fstat(descriptor) |
| if not stat.S_ISREG(before.st_mode) or not minimum <= before.st_size <= maximum: |
| return False |
| chunks = [] |
| remaining = maximum + 1 |
| while remaining: |
| chunk = os.read(descriptor, min(1024 * 1024, remaining)) |
| if not chunk: |
| break |
| chunks.append(chunk) |
| remaining -= len(chunk) |
| after = os.fstat(descriptor) |
| finally: |
| os.close(descriptor) |
| stable = ( |
| before.st_dev, before.st_ino, before.st_size, before.st_mtime_ns, before.st_ctime_ns |
| ) == ( |
| after.st_dev, after.st_ino, after.st_size, after.st_mtime_ns, after.st_ctime_ns |
| ) |
| data = b"".join(chunks) |
| if not stable or len(data) != before.st_size: |
| return False |
| target.write_bytes(data) |
| target.chmod(0o600) |
| return True |
| except OSError: |
| return False |
|
|
|
|
| def validate_params(path): |
| if not regular_file(path, 1_000, 100_000) or normalized_text_sha256(path) != EXPECTED_PARAMS_SHA256: |
| return False |
| try: |
| data = json.loads(path.read_text(encoding="utf-8")) |
| except (OSError, UnicodeError, json.JSONDecodeError): |
| return False |
| try: |
| return ( |
| data["task"] == "task-20" |
| and data["version"] == "0.21.2" |
| and data["wcs"] == "G54" |
| and len(data["pockets"]) == 3 |
| and data["ordinary_through_holes"]["count"] == 16 |
| and len(data["counterbores"]) == 2 |
| and len(data["fixtures"]) == 4 |
| and len(data["tools"]) == 5 |
| and len(data["operations"]) == 8 |
| and data["postprocessor"] == "linuxcnc" |
| ) |
| except (KeyError, TypeError): |
| return False |
|
|
|
|
| def allowed_property_file(value): |
| if value in {"", "/home/user/Desktop/task-20.nc"}: |
| return True |
| pure = PurePosixPath(value) |
| return ( |
| pure.is_absolute() |
| and ".." not in pure.parts |
| and pure.suffix.lower() in {".fcstd", ".fctb"} |
| and ( |
| value.startswith("/usr/share/freecad/Mod/Path/Tools/") |
| or value.startswith("/usr/lib/freecad/Mod/Path/Tools/") |
| ) |
| ) |
|
|
|
|
| def validate_archive(path): |
| if not regular_file(path, 20_000, 20_000_000): |
| return False |
| try: |
| with zipfile.ZipFile(path) as archive: |
| names = archive.namelist() |
| if "Document.xml" not in names or len(names) != len(set(names)) or len(names) > 250: |
| return False |
| total = 0 |
| for entry in archive.infolist(): |
| pure = PurePosixPath(entry.filename) |
| mode = entry.external_attr >> 16 |
| if ( |
| not entry.filename |
| or "\\" in entry.filename |
| or pure.is_absolute() |
| or ".." in pure.parts |
| or entry.flag_bits & 1 |
| or stat.S_ISLNK(mode) |
| or entry.file_size > 20_000_000 |
| or (entry.compress_size == 0 and entry.file_size > 0) |
| or (entry.compress_size and entry.file_size / entry.compress_size > 400) |
| or pure.suffix.lower() in {".py", ".pyc", ".pyo", ".sh", ".so", ".dll", ".dylib", ".exe"} |
| ): |
| return False |
| total += entry.file_size |
| if total > 80_000_000: |
| return False |
| root = ET.fromstring(archive.read("Document.xml")) |
| proxies = Counter() |
| for element in root.iter("Python"): |
| module_name = element.attrib.get("module") |
| class_name = element.attrib.get("class") |
| encoded = element.attrib.get("encoded") |
| value = element.attrib.get("value") |
| if encoded != "yes" or not isinstance(value, str) or len(value) > 100_000: |
| return False |
| payload = json.loads(base64.b64decode(value, validate=True).decode("utf-8")) |
| if (module_name, class_name) == ("draftobjects.clone", "Clone"): |
| if not isinstance(payload, str): |
| return False |
| elif (module_name, class_name) == (None, None): |
| if payload is not None: |
| return False |
| elif payload is not None and not isinstance(payload, dict): |
| return False |
| proxies[(module_name, class_name)] += 1 |
| |
| |
| proxies.pop((None, None), None) |
| stock_count = proxies.pop(("Path.Main.Stock", "StockFromBase"), 0) |
| stock_count += proxies.pop(("Path.Main.Stock", "StockCreateBox"), 0) |
| if stock_count != 1: |
| return False |
| if proxies != REQUIRED_PROXIES: |
| return False |
| for prop in root.iter("Property"): |
| if prop.attrib.get("type") != "App::PropertyFile": |
| continue |
| values = [child.attrib.get("value") for child in prop if child.tag == "String"] |
| if len(values) != 1 or not allowed_property_file(values[0]): |
| return False |
| for element in root.iter(): |
| if element.tag not in {"Part", "Path"}: |
| continue |
| member = element.attrib.get("file") |
| if not member or member not in names or PurePosixPath(member).suffix.lower() not in {".brp", ".nc"}: |
| return False |
| return True |
| except (OSError, UnicodeError, ValueError, zipfile.BadZipFile, ET.ParseError, json.JSONDecodeError): |
| return False |
|
|
|
|
| def strip_comments(text): |
| output = [] |
| in_comment = False |
| for line in text.replace("\r\n", "\n").replace("\r", "\n").split("\n"): |
| code = [] |
| for char in line: |
| if in_comment: |
| if char == "(": |
| return None |
| if char == ")": |
| in_comment = False |
| elif char == "(": |
| in_comment = True |
| elif char == ")": |
| return None |
| elif char == ";": |
| break |
| else: |
| code.append(char) |
| output.append("".join(code)) |
| return None if in_comment else "\n".join(output) |
|
|
|
|
| def integral(value): |
| rounded = round(value) |
| return int(rounded) if math.isfinite(value) and abs(value - rounded) <= 1e-9 else None |
|
|
|
|
| def parse_nc(path): |
| try: |
| executable = strip_comments(path.read_text(encoding="utf-8")) |
| except (OSError, UnicodeError): |
| return None |
| if executable is None: |
| return None |
| blocks = [] |
| for raw in executable.splitlines(): |
| line = raw.strip().upper() |
| if not line or line == "%": |
| continue |
| words = [] |
| cursor = 0 |
| for match in WORD_RE.finditer(line): |
| if line[cursor:match.start()].strip(): |
| return None |
| value = float(match.group(2)) |
| if not math.isfinite(value): |
| return None |
| words.append((match.group(1), value)) |
| cursor = match.end() |
| if line[cursor:].strip() or not words: |
| return None |
| if any(letter not in ALLOWED_ADDRESSES for letter, _ in words): |
| return None |
| if any(sum(letter == address for letter, _ in words) > 1 for address in ALLOWED_ADDRESSES - {"G", "M"}): |
| return None |
| blocks.append(words) |
| return blocks or None |
|
|
|
|
| def validate_nc(path): |
| if not regular_file(path, 8_000, 2_000_000): |
| return False |
| blocks = parse_nc(path) |
| if blocks is None: |
| return False |
| state = { |
| "units": None, "absolute": False, "plane": None, "wcs": None, |
| "tool": None, "changed": False, "spindle": False, "speed": None, |
| "feed": None, "cycle": None, "X": None, "Y": None, "Z": None, |
| } |
| saw_m5 = False |
| ended = False |
| changed_tools = [] |
| cycles = [] |
| cuts = {number: [] for number in range(1, 6)} |
| for index, block in enumerate(blocks): |
| words = dict(block) |
| gs = [integral(value) for letter, value in block if letter == "G"] |
| ms = [integral(value) for letter, value in block if letter == "M"] |
| if ended or any(code is None or code not in ALLOWED_G for code in gs) or any(code is None or code not in ALLOWED_M for code in ms): |
| return False |
| if 21 in gs: |
| state["units"] = "mm" |
| if 17 in gs: |
| state["plane"] = "XY" |
| if 90 in gs: |
| state["absolute"] = True |
| if 54 in gs: |
| state["wcs"] = 54 |
| if 80 in gs: |
| state["cycle"] = None |
| if "T" in words: |
| tool = integral(words["T"]) |
| if tool not in range(1, 6): |
| return False |
| state["tool"] = tool |
| state["changed"] = False |
| if "H" in words and integral(words["H"]) != state["tool"]: |
| return False |
| if "S" in words: |
| if not close(words["S"], 7000.0): |
| return False |
| state["speed"] = words["S"] |
| if "F" in words: |
| if state["units"] != "mm" or not close(words["F"], 500.0, 0.01): |
| return False |
| state["feed"] = words["F"] |
| if 5 in ms: |
| state["spindle"] = False |
| saw_m5 = True |
| if 6 in ms: |
| if not saw_m5 or state["spindle"] or state["tool"] not in range(1, 6) or state["cycle"] is not None: |
| return False |
| state["changed"] = True |
| changed_tools.append(state["tool"]) |
| saw_m5 = False |
| if 3 in ms: |
| if not state["changed"] or state["speed"] is None: |
| return False |
| state["spindle"] = True |
| before = (state["X"], state["Y"], state["Z"]) |
| for axis in ("X", "Y", "Z"): |
| if axis in words: |
| state[axis] = words[axis] |
| motion = next((code for code in gs if code in {0, 1, 2, 3}), None) |
| cycle = next((code for code in gs if code in {81, 82, 83}), None) |
| if motion == 0 and ("X" in words or "Y" in words) and (state["Z"] is None or state["Z"] < -0.001): |
| safe_helix_centering = ( |
| state["tool"] == 4 |
| and state["Z"] is not None |
| and state["Z"] >= -4.001 |
| and close(state["Y"], 38.0, 0.01) |
| and min(abs(state["X"] + 78.0), abs(state["X"] - 78.0)) <= 1.01 |
| and before[0] is not None |
| and before[1] is not None |
| and close(before[1], 38.0, 0.01) |
| and min(abs(before[0] + 78.0), abs(before[0] - 78.0)) <= 1.01 |
| ) |
| if not safe_helix_centering: |
| return False |
| if cycle is not None: |
| state["cycle"] = cycle |
| if state["tool"] != 3 or not state["spindle"] or "X" not in words or "Y" not in words or "Z" not in words or "R" not in words: |
| return False |
| if words["Z"] > -20.0 + 1e-6 or not close(words["R"], 2.0, 0.01): |
| return False |
| cycles.append((round(words["X"], 4), round(words["Y"], 4), words["Z"])) |
| state["Z"] = words["R"] |
| elif motion in {1, 2, 3} and any(axis in words for axis in ("X", "Y", "Z")): |
| if state["cycle"] is not None or not state["spindle"] or not state["changed"] or state["feed"] is None: |
| return False |
| if state["units"] != "mm" or not state["absolute"] or state["plane"] != "XY" or state["wcs"] != 54: |
| return False |
| if any(state[axis] is None for axis in ("X", "Y", "Z")): |
| return False |
| if motion in {2, 3} and not all(letter in words for letter in ("I", "J")): |
| return False |
| cuts[state["tool"]].append((state["X"], state["Y"], state["Z"], motion, before, words)) |
| if 2 in ms or 30 in ms: |
| if index != len(blocks) - 1 or state["spindle"] or state["cycle"] is not None: |
| return False |
| ended = True |
| if not ended or changed_tools != [1, 2, 3, 4, 5, 2]: |
| return False |
| if len(cycles) != 18 or {(x, y) for x, y, _ in cycles} != EXPECTED_HOLES: |
| return False |
| if len({round(z, 3) for _, _, z in cycles}) != 1: |
| return False |
| face = cuts[1] |
| if len(face) < 30 or min(p[0] for p in face) > -90.1 or max(p[0] for p in face) < 90.1 or any(abs(p[2]) > 0.001 for p in face): |
| return False |
| for cx, floor in ((-55.0, -4.0), (0.0, -6.0), (55.0, -8.0)): |
| hits = [p for p in cuts[2] if close(p[2], floor, 0.01) and cx - 14 <= p[0] <= cx + 14 and 7 <= p[1] <= 23] |
| if len(hits) < 8: |
| return False |
| profile = [p for p in cuts[2] if close(p[2], -18.0, 0.01)] |
| if len(profile) < 8 or not close(min(p[0] for p in profile), -94.0, 0.05) or not close(max(p[0] for p in profile), 94.0, 0.05) or not close(min(p[1] for p in profile), -54.0, 0.05) or not close(max(p[1] for p in profile), 54.0, 0.05): |
| return False |
| helix = cuts[4] |
| if len(helix) < 12 or min(p[2] for p in helix) > -3.999 or not all(36.9 <= p[1] <= 39.1 for p in helix): |
| return False |
| if not any(p[0] < -77 for p in helix) or not any(p[0] > 77 for p in helix): |
| return False |
| surface = [p for p in cuts[5] if close(p[2], -0.5, 0.01)] |
| if len(surface) < 6 or min(p[0] for p in surface) > -18.0 or max(p[0] for p in surface) < 18.0 or min(p[1] for p in surface) > 36.6 or max(p[1] for p in surface) < 39.4: |
| return False |
| return True |
|
|
|
|
| def validate_post_log(path, step_path, fcstd_path, nc_path): |
| if not regular_file(path, 800, 100_000): |
| return False |
| try: |
| text = path.read_text(encoding="utf-8") |
| except (OSError, UnicodeError): |
| return False |
| lowered = text.lower() |
| if ( |
| not re.search(r"0\D+21\D+2\D+33771", text) |
| or "b9bfa5c5507506e4515816414cd27f4851d00489" not in lowered |
| or "linuxcnc" not in lowered |
| or "g54" not in lowered |
| or not re.search(r"(?:operation(?:_count| count)?|operations)\D{0,12}8\b", lowered) |
| or lowered.count("show editor = 0") < 2 |
| or lowered.count("postprocessing...") < 2 |
| or lowered.count("done postprocessing.") < 2 |
| or "reopen" not in lowered |
| or "recompute" not in lowered |
| or "repost" not in lowered |
| or "up-to-date" not in lowered |
| or not re.search(r"(?:warning|error)[^\n]{0,30}\b0\b", lowered) |
| ): |
| return False |
| modules = ["MillFace", "PocketShape", "PocketShape", "PocketShape", "Drilling", "Helix", "Surface", "Profile"] |
| if any(lowered.count("path.op." + name.lower()) < modules.count(name) for name in set(modules)): |
| return False |
| expected_hashes = { |
| "NC": normalized_text_sha256(nc_path), |
| "FCStd": sha256(fcstd_path), |
| "STEP": normalized_text_sha256(step_path), |
| } |
| for label, digest in expected_hashes.items(): |
| pattern = r"(?i)\b{}\b[^\n]{{0,30}}\bsha[-_ ]?256\b[^0-9a-f]{{0,12}}([0-9a-f]{{64}})".format(label) |
| matches = re.findall(pattern, text) |
| if digest not in [value.lower() for value in matches]: |
| return False |
| return True |
|
|
|
|
| CHILD_SOURCE = r''' |
| import builtins |
| import json |
| import math |
| import os |
| import pathlib |
| import re |
| import sys |
| import traceback |
| |
| builtins.pythonopen = open |
| |
| import FreeCAD as App |
| import Part |
| import Path.Post.Command as PathPostCommand |
| from Path.Post.Processor import PostProcessor |
| |
| VERSION = ("0", "21", "2", "33771 (Git)") |
| COMMIT = "b9bfa5c5507506e4515816414cd27f4851d00489" |
| POCKETS = ( |
| ("Pocket1", -55.0, 15.0, 34.0, 24.0, 4.0, 4.0), |
| ("Pocket2", 0.0, 15.0, 34.0, 24.0, 4.0, 6.0), |
| ("Pocket3", 55.0, 15.0, 34.0, 24.0, 4.0, 8.0), |
| ) |
| HOLES = tuple((x, y) for y in (-32.0, -16.0) for x in (-70.0, -50.0, -30.0, -10.0, 10.0, 30.0, 50.0, 70.0)) + ((-78.0, 38.0), (78.0, 38.0)) |
| FIXTURES = ( |
| (-112.0, -102.0, -40.0, -20.0, -2.0, 4.0), |
| (-112.0, -102.0, 20.0, 40.0, -2.0, 4.0), |
| (102.0, 112.0, -40.0, -20.0, -2.0, 4.0), |
| (102.0, 112.0, 20.0, 40.0, -2.0, 4.0), |
| ) |
| NUMBER = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)" |
| WORD_RE = re.compile(r"([A-Z])\s*(" + NUMBER + r")", re.ASCII) |
| |
| |
| def check(condition, message): |
| if not condition: |
| raise RuntimeError(message) |
| |
| |
| def close(a, b, tolerance=1e-6): |
| try: |
| left, right = float(a), float(b) |
| except (TypeError, ValueError): |
| return False |
| return math.isfinite(left) and math.isfinite(right) and abs(left - right) <= tolerance |
| |
| |
| def module(obj): |
| proxy = getattr(obj, "Proxy", None) |
| return type(proxy).__module__ if proxy is not None else "" |
| |
| |
| def bounds(shape): |
| box = shape.BoundBox |
| return (box.XMin, box.XMax, box.YMin, box.YMax, box.ZMin, box.ZMax) |
| |
| |
| def same_shape(left, right, tolerance=1e-4): |
| try: |
| return left.isValid() and right.isValid() and len(left.Solids) == len(right.Solids) == 1 and left.cut(right).Volume <= tolerance and right.cut(left).Volume <= tolerance |
| except Exception: |
| return False |
| |
| |
| def rounded_prism(cx, cy, length, width, radius, zmin, height): |
| pieces = [ |
| Part.makeBox(length - 2 * radius, width, height, App.Vector(cx - length / 2 + radius, cy - width / 2, zmin)), |
| Part.makeBox(length, width - 2 * radius, height, App.Vector(cx - length / 2, cy - width / 2 + radius, zmin)), |
| ] |
| for sx in (-1.0, 1.0): |
| for sy in (-1.0, 1.0): |
| pieces.append(Part.makeCylinder(radius, height, App.Vector(cx + sx * (length / 2 - radius), cy + sy * (width / 2 - radius), zmin))) |
| result = pieces[0] |
| for piece in pieces[1:]: |
| result = result.fuse(piece) |
| return result.removeSplitter() |
| |
| |
| def expected_shape(): |
| shape = Part.makeBox(180.0, 100.0, 18.0, App.Vector(-90.0, -50.0, -18.0)) |
| for _, cx, cy, length, width, radius, depth in POCKETS: |
| shape = shape.cut(rounded_prism(cx, cy, length, width, radius, -depth, depth)) |
| for x, y in HOLES: |
| shape = shape.cut(Part.makeCylinder(2.5, 20.0, App.Vector(x, y, -19.0))) |
| for x, y in ((-78.0, 38.0), (78.0, 38.0)): |
| shape = shape.cut(Part.makeCylinder(6.0, 4.0, App.Vector(x, y, -4.0))) |
| shape = shape.cut(Part.makeBox(44.0, 10.0, 0.5, App.Vector(-22.0, 33.0, -0.5))) |
| return shape.removeSplitter() |
| |
| |
| def selected_face(op): |
| try: |
| base = list(op.Base) |
| if len(base) != 1 or len(base[0][1]) != 1: |
| return None |
| obj, names = base[0] |
| name = names[0] |
| if obj is None or not name.startswith("Face"): |
| return None |
| return obj.Shape.getElement(name) |
| except Exception: |
| return None |
| |
| |
| def motion_records(op): |
| position = {"X": None, "Y": None, "Z": None} |
| records = [] |
| for command in op.Path.Commands: |
| name = str(command.Name).upper().replace(" ", "") |
| before = dict(position) |
| for axis in position: |
| if axis in command.Parameters: |
| position[axis] = float(command.Parameters[axis]) |
| if name in {"G0", "G1", "G2", "G3", "G81", "G82", "G83"}: |
| records.append((name, before, dict(position), {key: float(value) for key, value in command.Parameters.items()})) |
| return records |
| |
| |
| def operation_signature(op): |
| result = [] |
| for command in op.Path.Commands: |
| params = tuple(sorted((str(key), 0.0 if abs(float(value)) < 0.0000005 else round(float(value), 6)) for key, value in command.Parameters.items())) |
| result.append((str(command.Name).upper().replace(" ", ""), params)) |
| return tuple(result) |
| |
| |
| def path_bounds(op, names={"G0", "G1", "G2", "G3", "G81", "G82", "G83"}): |
| points = [record[2] for record in motion_records(op) if record[0] in names and all(record[2][axis] is not None for axis in ("X", "Y", "Z"))] |
| check(points, op.Name + " has no motion points") |
| return tuple((min(point[axis] for point in points), max(point[axis] for point in points)) for axis in ("X", "Y", "Z")) |
| |
| |
| def strip_comments(text): |
| result = [] |
| active = False |
| for line in text.replace("\r\n", "\n").replace("\r", "\n").split("\n"): |
| code = [] |
| for char in line: |
| if active: |
| if char == "(": |
| return None |
| if char == ")": |
| active = False |
| elif char == "(": |
| active = True |
| elif char == ")": |
| return None |
| elif char == ";": |
| break |
| else: |
| code.append(char) |
| result.append("".join(code)) |
| return None if active else "\n".join(result) |
| |
| |
| def code_signature(path): |
| try: |
| text = strip_comments(pathlib.Path(path).read_text(encoding="utf-8")) |
| except (OSError, UnicodeError): |
| return None |
| if text is None: |
| return None |
| result = [] |
| for raw in text.splitlines(): |
| line = raw.strip().upper() |
| if not line or line == "%": |
| continue |
| words = [] |
| cursor = 0 |
| for match in WORD_RE.finditer(line): |
| if line[cursor:match.start()].strip(): |
| return None |
| if match.group(1) != "N": |
| value = float(match.group(2)) |
| value = 0.0 if abs(value) < 0.0000005 else round(value, 6) |
| words.append((match.group(1), value)) |
| cursor = match.end() |
| if line[cursor:].strip() or not words: |
| return None |
| if words == [("M", 30.0)]: |
| words = [("M", 2.0)] |
| result.append(tuple(words)) |
| return tuple(result) |
| |
| |
| def point_rect_distance(point, rect): |
| x, y = point |
| xmin, xmax, ymin, ymax = rect |
| dx = max(xmin - x, 0.0, x - xmax) |
| dy = max(ymin - y, 0.0, y - ymax) |
| return math.hypot(dx, dy) |
| |
| |
| def point_segment_distance(point, a, b): |
| px, py = point |
| ax, ay = a |
| bx, by = b |
| dx, dy = bx - ax, by - ay |
| if dx * dx + dy * dy <= 1e-18: |
| return math.hypot(px - ax, py - ay) |
| t = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy))) |
| return math.hypot(px - (ax + t * dx), py - (ay + t * dy)) |
| |
| |
| def segment_rect_distance(a, b, rect): |
| xmin, xmax, ymin, ymax = rect |
| if (min(a[0], b[0]) <= xmax and max(a[0], b[0]) >= xmin and min(a[1], b[1]) <= ymax and max(a[1], b[1]) >= ymin): |
| # Exact clipping for an axis-aligned rectangle. |
| t0, t1 = 0.0, 1.0 |
| dx, dy = b[0] - a[0], b[1] - a[1] |
| for p, q in ((-dx, a[0] - xmin), (dx, xmax - a[0]), (-dy, a[1] - ymin), (dy, ymax - a[1])): |
| if abs(p) < 1e-15: |
| if q < 0: |
| break |
| else: |
| r = q / p |
| if p < 0: |
| t0 = max(t0, r) |
| else: |
| t1 = min(t1, r) |
| else: |
| if t0 <= t1: |
| return 0.0 |
| corners = ((xmin, ymin), (xmin, ymax), (xmax, ymin), (xmax, ymax)) |
| return min(point_rect_distance(a, rect), point_rect_distance(b, rect), *(point_segment_distance(corner, a, b) for corner in corners)) |
| |
| |
| def validate(step_path, fcstd_path, nc_path, log_path, repost_a, repost_b, resaved): |
| check(tuple(App.Version()[:4]) == VERSION and App.Version()[-1] == COMMIT, "wrong FreeCAD version") |
| expected = expected_shape() |
| check(expected.isValid() and len(expected.Solids) == 1 and close(expected.Volume, 310244.0 - 2551.0 * math.pi, 1e-4), "internal expected shape failed") |
| submitted_step = Part.read(str(step_path)) |
| check(same_shape(submitted_step, expected), "STEP BRep mismatch") |
| check(all(close(a, b) for a, b in zip(bounds(submitted_step), (-90, 90, -50, 50, -18, 0))), "STEP bounds mismatch") |
| |
| doc = App.openDocument(str(fcstd_path)) |
| try: |
| jobs = [obj for obj in doc.Objects if module(obj) == "Path.Main.Job"] |
| controllers = [obj for obj in doc.Objects if module(obj) == "Path.Tool.Controller"] |
| tools = [obj for obj in doc.Objects if module(obj) == "Path.Tool.Bit"] |
| check(len(jobs) == 1 and len(controllers) == 5 and len(tools) == 5, "Job/tool count mismatch") |
| job = jobs[0] |
| operations = list(job.Operations.Group) |
| expected_modules = ["Path.Op.MillFace", "Path.Op.PocketShape", "Path.Op.PocketShape", "Path.Op.PocketShape", "Path.Op.Drilling", "Path.Op.Helix", "Path.Op.Surface", "Path.Op.Profile"] |
| check([module(op) for op in operations] == expected_modules, "operation order/type mismatch") |
| check([int(op.ToolController.ToolNumber) for op in operations] == [1, 2, 2, 2, 3, 4, 5, 2], "operation/tool mapping mismatch") |
| log_text = pathlib.Path(log_path).read_text(encoding="utf-8") |
| remaining_log_lines = list(log_text.splitlines()) |
| for op in operations: |
| expected_module = module(op).lower() |
| expected_tool = "t%d" % int(op.ToolController.ToolNumber) |
| expected_commands = str(len(op.Path.Commands)) |
| matching_indexes = [ |
| index |
| for index, line in enumerate(remaining_log_lines) |
| if expected_module in line.lower() |
| and re.search(r"\b" + re.escape(expected_tool) + r"\b", line, re.IGNORECASE) |
| and "up-to-date" in line.lower() |
| and re.search(r"(?:command(?:s|_count| count)?)\D{0,12}" + re.escape(expected_commands) + r"\b", line, re.IGNORECASE) |
| ] |
| check(matching_indexes, "post log does not match native operation " + op.Name) |
| remaining_log_lines.pop(matching_indexes[0]) |
| check(not any( |
| re.search(r"\bPath\.Op\.[A-Za-z0-9_]+\b", line, re.IGNORECASE) |
| and re.search(r"\bT[1-5]\b", line, re.IGNORECASE) |
| and "up-to-date" in line.lower() |
| and re.search(r"(?:command(?:s|_count| count)?)\D{0,12}\d+\b", line, re.IGNORECASE) |
| for line in remaining_log_lines |
| ), "post log contains an extra operation row") |
| check(len(job.Model.Group) == 1 and list(job.Fixtures) == ["G54"] and str(job.PostProcessor).lower() == "linuxcnc" and not bool(job.SplitOutput), "Job setup mismatch") |
| check(os.path.normpath(str(job.PostProcessorOutputFile)) == "/home/user/Desktop/task-20.nc", "post output path mismatch") |
| model = job.Model.Group[0] |
| check(module(model) == "draftobjects.clone" and same_shape(model.Shape, expected), "Job model mismatch") |
| check(all(close(a, b) for a, b in zip(bounds(model.Shape), (-90, 90, -50, 50, -18, 0))), "Job model moved") |
| check(same_shape(job.Stock.Shape, Part.makeBox(190, 110, 19, App.Vector(-95, -55, -18))), "stock shape mismatch") |
| check(all(close(a, b) for a, b in zip(bounds(job.Stock.Shape), (-95, 95, -55, 55, -18, 1))), "stock bounds mismatch") |
| by_number = {int(tc.ToolNumber): tc for tc in controllers} |
| specs = {1: ("endmill", 20.0), 2: ("endmill", 8.0), 3: ("drill", 5.0), 4: ("endmill", 10.0), 5: ("ballend", 6.0)} |
| check(set(by_number) == set(specs), "tool numbers mismatch") |
| for number, (shape_name, diameter) in specs.items(): |
| controller = by_number[number] |
| tool = controller.Tool |
| check(tool in tools and sum(other.Tool == tool for other in controllers) == 1, "shared/missing tool") |
| check(close(tool.Diameter, diameter) and str(tool.ShapeName).lower() == shape_name and os.path.basename(str(tool.BitShape)).lower() == shape_name + ".fcstd", "tool geometry fields mismatch") |
| check(close(controller.SpindleSpeed, 7000) and str(controller.SpindleDir) == "Forward", "controller spindle mismatch") |
| check(close(controller.HorizFeed.getValueAs("mm/min").Value, 500) and close(controller.VertFeed.getValueAs("mm/min").Value, 500), "controller feed mismatch") |
| if shape_name == "drill": |
| check(close(tool.TipAngle, 118), "drill angle mismatch") |
| tool.touch() |
| doc.recompute() |
| check(all(tool.Shape.isValid() and len(tool.Shape.Solids) == 1 and tool.Shape.Volume > 0 for tool in tools), "invalid ToolBit shape") |
| |
| expected_fixture_bounds = sorted(FIXTURES) |
| fixture_objects = [] |
| for obj in doc.Objects: |
| shape = getattr(obj, "Shape", None) |
| try: |
| actual = tuple(round(value, 6) for value in bounds(shape)) |
| if actual in expected_fixture_bounds: |
| xmin, xmax, ymin, ymax, zmin, zmax = actual |
| expected_fixture = Part.makeBox( |
| xmax - xmin, |
| ymax - ymin, |
| zmax - zmin, |
| App.Vector(xmin, ymin, zmin), |
| ) |
| else: |
| expected_fixture = None |
| if expected_fixture is not None and same_shape(shape, expected_fixture): |
| fixture_objects.append(obj) |
| except Exception: |
| pass |
| check(len(fixture_objects) == 4, "fixture count mismatch") |
| actual_fixture_bounds = sorted(tuple(round(v, 6) for v in bounds(obj.Shape)) for obj in fixture_objects) |
| check(actual_fixture_bounds == expected_fixture_bounds, "fixture geometry mismatch") |
| |
| face, pocket1, pocket2, pocket3, drilling, helix, surface, profile = operations |
| top = selected_face(face) |
| check(top is not None and type(top.Surface).__name__ == "Plane" and close(top.BoundBox.ZMin, 0) and close(face.StartDepth, 1) and close(face.FinalDepth, 0), "Face setup mismatch") |
| check(close(face.StepDown, 1) and close(face.StepOver, 60), "Face parameters mismatch") |
| fb = path_bounds(face) |
| check(fb[0][0] <= -90.1 and fb[0][1] >= 90.1 and fb[1][0] <= -50.1 and fb[1][1] >= 50.1 and fb[2][0] >= -0.001, "Face path coverage mismatch") |
| |
| for op, spec in zip((pocket1, pocket2, pocket3), POCKETS): |
| _, cx, cy, length, width, radius, depth = spec |
| floor = selected_face(op) |
| check(floor is not None and type(floor.Surface).__name__ == "Plane" and close(floor.CenterOfMass.x, cx, 1e-4) and close(floor.CenterOfMass.y, cy, 1e-4) and close(floor.BoundBox.ZMin, -depth), "pocket Base mismatch") |
| check(close(op.StartDepth, 0) and close(op.FinalDepth, -depth) and close(op.StepDown, 2) and close(op.StepOver, 50), "pocket parameters mismatch") |
| pb = path_bounds(op) |
| check(close(pb[2][0], -depth, 0.01) and pb[0][0] <= cx - 12.9 and pb[0][1] >= cx + 12.9 and pb[1][0] <= 7.01 and pb[1][1] >= 22.99, "pocket path mismatch") |
| |
| check(close(drilling.StartDepth, 0) and close(drilling.FinalDepth, -20) and close(drilling.RetractHeight, 2) and str(drilling.ExtraOffset) == "Drill Tip" and not bool(drilling.KeepToolDown), "drilling parameters mismatch") |
| location_set = {(round(v.x, 4), round(v.y, 4)) for v in drilling.Locations} |
| check(len(drilling.Locations) == 18 and location_set == set(HOLES), "drilling Locations mismatch") |
| drill_records = [record for record in motion_records(drilling) if record[0] in {"G81", "G82", "G83"}] |
| check(len(drill_records) == 18 and {(round(r[2]["X"], 4), round(r[2]["Y"], 4)) for r in drill_records} == set(HOLES), "drilling cycle mismatch") |
| expected_tip_z = -20.0 - 2.5 / math.tan(math.radians(59.0)) |
| check(all(close(record[3].get("Z"), expected_tip_z, 1e-5) and close(record[3].get("R"), 2, 1e-5) for record in drill_records), "drill tip depth mismatch") |
| |
| check(close(helix.StartDepth, 0) and close(helix.FinalDepth, -4) and close(helix.StepDown, 2), "Helix parameters mismatch") |
| hbase = list(helix.Base) |
| selected_helix_edges = [] |
| for base_object, names in hbase: |
| for name in names: |
| try: |
| edge = base_object.Shape.getElement(name) |
| curve = edge.Curve |
| selected_helix_edges.append((round(curve.Center.x, 4), round(curve.Center.y, 4), float(curve.Radius))) |
| except Exception: |
| selected_helix_edges.append((None, None, None)) |
| check( |
| len(selected_helix_edges) == 2 |
| and {(x, y) for x, y, _ in selected_helix_edges} == {(-78.0, 38.0), (78.0, 38.0)} |
| and all(close(radius, 6.0, 1e-5) for _, _, radius in selected_helix_edges), |
| "Helix Base mismatch", |
| ) |
| arcs = [record for record in motion_records(helix) if record[0] in {"G2", "G3"}] |
| centers = [] |
| for name, before, after, params in arcs: |
| if before["X"] is not None and before["Y"] is not None and "I" in params and "J" in params: |
| centers.append((round(before["X"] + params["I"], 4), round(before["Y"] + params["J"], 4), after["Z"], before["Z"], math.hypot(params["I"], params["J"]))) |
| helix_centers = {(-78.0, 38.0), (78.0, 38.0)} |
| check(len(arcs) >= 12 and {(x, y) for x, y, _, _, _ in centers} == helix_centers, "Helix path centers mismatch") |
| for center in helix_centers: |
| records = [record for record in centers if record[:2] == center] |
| check( |
| records |
| and all(close(record[4], 1.0, 0.01) for record in records) |
| and min(record[2] for record in records) <= -4 + 1e-6 |
| and any(record[3] is not None and record[2] < record[3] - 1e-6 for record in records), |
| "Helix radius/depth mismatch", |
| ) |
| |
| sf = selected_face(surface) |
| check(sf is not None and type(sf.Surface).__name__ == "Plane" and all(close(a, b, 1e-5) for a, b in zip(bounds(sf), (-22, 22, 33, 43, -0.5, -0.5))), "Surface Base mismatch") |
| check(str(surface.ScanType) == "Planar" and str(surface.CutPattern) == "ZigZag" and str(surface.LayerMode) == "Single-pass", "Surface mode mismatch") |
| check(close(surface.StartDepth, 0) and close(surface.SampleInterval, 1) and close(surface.DepthOffset, 0) and close(surface.StepOver, 25) and close(surface.FinalDepth, -0.5), "Surface parameters mismatch") |
| sb = path_bounds(surface) |
| check(close(sb[2][0], -0.5, 0.01) and -22.01 <= sb[0][0] <= -18 and 18 <= sb[0][1] <= 22.01 and 32.99 <= sb[1][0] <= 36.51 and 39.49 <= sb[1][1] <= 43.01, "Surface path mismatch") |
| |
| check(str(profile.Side) == "Outside" and str(profile.Direction) == "CW" and bool(profile.UseComp) and bool(profile.processPerimeter) and not bool(profile.processHoles) and not bool(profile.processCircles), "Profile mode mismatch") |
| check(close(profile.StartDepth, 0) and close(profile.FinalDepth, -18) and close(profile.StepDown, 3), "Profile depth mismatch") |
| profile_records = motion_records(profile) |
| final_points = [r[2] for r in profile_records if r[0] in {"G1", "G2", "G3"} and r[2]["Z"] is not None and close(r[2]["Z"], -18, 0.01)] |
| check(len(final_points) >= 8 and close(min(p["X"] for p in final_points), -94, 0.05) and close(max(p["X"] for p in final_points), 94, 0.05) and close(min(p["Y"] for p in final_points), -54, 0.05) and close(max(p["Y"] for p in final_points), 54, 0.05), "Profile path mismatch") |
| segments = [] |
| for name, before, after, params in profile_records: |
| if name == "G1" and before["X"] is not None and before["Y"] is not None and after["X"] is not None and after["Y"] is not None and math.hypot(after["X"] - before["X"], after["Y"] - before["Y"]) > 1e-7: |
| segments.append(((before["X"], before["Y"]), (after["X"], after["Y"]))) |
| clearances = [] |
| for fixture in FIXTURES: |
| rect = fixture[:4] |
| centerline = min(segment_rect_distance(a, b, rect) for a, b in segments) |
| clearances.append(centerline - 4.0) |
| check(all(close(value, 4.0, 0.02) and value >= 3.0 - 1e-6 for value in clearances), "fixture swept clearance mismatch") |
| check(all(close(op.SafeHeight, 5) and close(op.ClearanceHeight, 8) for op in operations), "operation safe/clearance heights mismatch") |
| check(all(float(op.ClearanceHeight.Value) - 4.0 >= 3.0 for op in operations), "vertical fixture clearance mismatch") |
| |
| before_signatures = [operation_signature(op) for op in operations] |
| check(all(list(op.State) == ["Up-to-date"] and len(op.Path.Commands) > 0 for op in operations), "pre-recompute state/path mismatch") |
| for obj in controllers + operations + [job]: |
| obj.touch() |
| doc.recompute() |
| doc.recompute() |
| after_signatures = [operation_signature(op) for op in operations] |
| check(before_signatures == after_signatures and all(list(op.State) == ["Up-to-date"] for op in operations), "recompute changed paths") |
| sections = PathPostCommand.buildPostList(job) |
| check(len(sections) == 1, "split post output") |
| PostProcessor.load("linuxcnc").export(sections[0][1], str(repost_a), job.PostProcessorArgs) |
| doc.saveAs(str(resaved)) |
| finally: |
| App.closeDocument(doc.Name) |
| |
| reopened = App.openDocument(str(resaved)) |
| try: |
| reopened.recompute() |
| reopened.recompute() |
| job = next(obj for obj in reopened.Objects if module(obj) == "Path.Main.Job") |
| operations = list(job.Operations.Group) |
| check([module(op) for op in operations] == ["Path.Op.MillFace", "Path.Op.PocketShape", "Path.Op.PocketShape", "Path.Op.PocketShape", "Path.Op.Drilling", "Path.Op.Helix", "Path.Op.Surface", "Path.Op.Profile"], "reopen operation mismatch") |
| check(all(list(op.State) == ["Up-to-date"] and len(op.Path.Commands) > 0 for op in operations), "reopen path state mismatch") |
| sections = PathPostCommand.buildPostList(job) |
| check(len(sections) == 1, "reopen split post") |
| PostProcessor.load("linuxcnc").export(sections[0][1], str(repost_b), job.PostProcessorArgs) |
| finally: |
| App.closeDocument(reopened.Name) |
| submitted = code_signature(nc_path) |
| check(submitted is not None and submitted == code_signature(repost_a) == code_signature(repost_b), "fresh repost mismatch") |
| return True |
| |
| |
| ok = False |
| try: |
| ok = validate( |
| pathlib.Path(os.environ["TASK20_STEP"]), |
| pathlib.Path(os.environ["TASK20_FCSTD"]), |
| pathlib.Path(os.environ["TASK20_NC"]), |
| pathlib.Path(os.environ["TASK20_LOG"]), |
| pathlib.Path(os.environ["TASK20_REPOST_A"]), |
| pathlib.Path(os.environ["TASK20_REPOST_B"]), |
| pathlib.Path(os.environ["TASK20_RESAVED"]), |
| ) |
| except Exception as error: |
| print("task-20 child: %s" % error, file=sys.stderr) |
| traceback.print_exc() |
| pathlib.Path(os.environ["TASK20_RESULT"]).write_text(json.dumps({"ok": bool(ok)}, sort_keys=True), encoding="utf-8") |
| raise SystemExit(0 if ok else 1) |
| ''' |
|
|
|
|
| def validate_freecad(step_path, fcstd_path, nc_path, log_path, workdir): |
| child = workdir / "validate_task20.py" |
| result_file = workdir / "result.json" |
| child.write_text(CHILD_SOURCE, encoding="utf-8") |
| child.chmod(0o600) |
| env = { |
| "HOME": str(workdir), "LANG": "C.UTF-8", "LC_ALL": "C.UTF-8", "PATH": "/usr/bin:/bin", "TMPDIR": str(workdir), |
| "TASK20_STEP": str(step_path), "TASK20_FCSTD": str(fcstd_path), "TASK20_NC": str(nc_path), |
| "TASK20_LOG": str(log_path), |
| "TASK20_REPOST_A": str(workdir / "repost-a.nc"), "TASK20_REPOST_B": str(workdir / "repost-b.nc"), |
| "TASK20_RESAVED": str(workdir / "resaved.FCStd"), "TASK20_RESULT": str(result_file), |
| } |
| try: |
| result = subprocess.run( |
| [str(FREECADCMD), str(child)], cwd=workdir, stdin=subprocess.DEVNULL, |
| stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=300, |
| check=False, env=env, |
| ) |
| except (OSError, subprocess.TimeoutExpired): |
| return False |
| try: |
| payload = json.loads(result_file.read_text(encoding="utf-8")) |
| except (OSError, UnicodeError, json.JSONDecodeError): |
| payload = None |
| if result.returncode != 0 or payload != {"ok": True}: |
| if result.stderr: |
| print(result.stderr[-6000:], file=sys.stderr) |
| return False |
| return all(regular_file(workdir / name, 8_000 if name.endswith(".nc") else 20_000, 20_000_000) for name in ("repost-a.nc", "repost-b.nc", "resaved.FCStd")) |
|
|
|
|
| def main(): |
| if not FREECADCMD.is_file(): |
| return fail("freecadcmd missing") |
| if not regular_file(STEP, 10_000, 5_000_000) or normalized_text_sha256(STEP) != EXPECTED_STEP_SHA256: |
| return fail("wrong init STEP") |
| if not validate_params(PARAMS): |
| return fail("wrong params.json") |
| if not validate_archive(FCSTD): |
| return fail("invalid FCStd archive") |
| if not validate_nc(NC): |
| return fail("invalid NC semantics") |
| if not validate_post_log(POST_LOG, STEP, FCSTD, NC): |
| return fail("invalid post log") |
| with tempfile.TemporaryDirectory(prefix="task-20-eval-") as directory: |
| workdir = Path(directory) |
| frozen = { |
| "step": (STEP, workdir / "final_benchmark.step", 10_000, 5_000_000), |
| "params": (PARAMS, workdir / "params.json", 1_000, 100_000), |
| "fcstd": (FCSTD, workdir / "task-20.FCStd", 20_000, 20_000_000), |
| "nc": (NC, workdir / "task-20.nc", 8_000, 2_000_000), |
| "log": (POST_LOG, workdir / "post_log.txt", 800, 100_000), |
| } |
| for name, (source, target, minimum, maximum) in frozen.items(): |
| if not freeze_file(source, target, minimum, maximum): |
| return fail("could not freeze " + name) |
| if normalized_text_sha256(frozen["step"][1]) != EXPECTED_STEP_SHA256 or not validate_params(frozen["params"][1]): |
| return fail("init changed during evaluation") |
| if not validate_archive(frozen["fcstd"][1]) or not validate_nc(frozen["nc"][1]): |
| return fail("GT changed during evaluation") |
| if not validate_post_log(frozen["log"][1], frozen["step"][1], frozen["fcstd"][1], frozen["nc"][1]): |
| return fail("log changed during evaluation") |
| if not validate_freecad(frozen["step"][1], frozen["fcstd"][1], frozen["nc"][1], frozen["log"][1], workdir): |
| return fail("FreeCAD validation failed") |
| return True |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| result = main() |
| except Exception as error: |
| print("task-20 evaluator exception: " + str(error), file=sys.stderr) |
| result = False |
| print(True if result else False) |
|
|
