| from __future__ import annotations |
|
|
| import base64 |
| import hashlib |
| import json |
| import math |
| import os |
| import re |
| import secrets |
| 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 / "two_sided_part.step" |
| FCSTD = TARGET / "task-17_real.fcstd" |
| NC_A = TARGET / "task-17_A.nc" |
| NC_B = TARGET / "task-17_B.nc" |
| FREECADCMD = Path("/usr/bin/freecadcmd") |
| EXPECTED_STEP_SHA256 = "e8595d746534ccf3a477f5e6de54b09a3ebef10e4933b342311b384c97fa70e0" |
| EXPECTED_VERSION = ("0", "21", "2", "33771 (Git)") |
| EXPECTED_COMMIT = "b9bfa5c5507506e4515816414cd27f4851d00489" |
| HOLES = {(-45.0, -25.0), (45.0, -25.0), (-45.0, 25.0), (45.0, 25.0)} |
| TIMESTAMP_RE = re.compile(r"\(Output Time:[^()\r\n]*\)") |
| 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", "Q", "P"} |
| ALLOWED_G = {0, 1, 2, 3, 17, 20, 21, 40, 43, 49, 54, 55, 80, 81, 82, 83, 90, 94, 98, 99} |
| ALLOWED_M = {2, 3, 5, 6, 7, 8, 9, 30} |
| G_MODAL_GROUPS = ( |
| {0, 1, 2, 3, 80, 81, 82, 83}, |
| {17}, |
| {20, 21}, |
| {40}, |
| {43, 49}, |
| {54, 55}, |
| {90}, |
| {94}, |
| {98, 99}, |
| ) |
| M_MODAL_GROUPS = ({2, 30}, {3, 5}) |
| PROXY_RULES = { |
| ("Path.Main.Job", "ObjectJob"): 2, |
| ("Path.Base.SetupSheet", "SetupSheet"): 2, |
| ("Path.Main.Stock", "StockFromBase"): 2, |
| ("Path.Tool.Controller", "ToolController"): (3, 6), |
| ("Path.Tool.Bit", "ToolBit"): (3, 6), |
| ("Path.Op.PocketShape", "ObjectPocket"): (1, 4), |
| ("Path.Op.Drilling", "ObjectDrilling"): (1, 4), |
| ("Path.Op.Helix", "ObjectHelix"): (1, 4), |
| ("draftobjects.clone", "Clone"): 2, |
| } |
| ALLOWED_EXTERNAL_FILES = { |
| "", |
| "/usr/lib/freecad/Mod/Path/Tools/Shape/endmill.fcstd", |
| "/usr/share/freecad/Mod/Path/Tools/Shape/endmill.fcstd", |
| "/usr/share/freecad/Mod/Path/Tools/Shape/drill.fcstd", |
| "/usr/share/freecad/Mod/Path/Tools/Bit/5mm_Endmill.fctb", |
| "/usr/share/freecad/Mod/Path/Tools/Bit/5mm_Drill.fctb", |
| } |
| EXPECTED_OUTPUT_FILES = {"/home/user/Desktop/task-17_A.nc", "/home/user/Desktop/task-17_B.nc"} |
|
|
|
|
| def fail(message): |
| print("task-17 evaluator: " + message, file=sys.stderr) |
| return False |
|
|
|
|
| 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 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 or not minimum <= len(data) <= maximum: |
| return False |
| target.write_bytes(data) |
| target.chmod(0o600) |
| return True |
| except OSError: |
| return False |
|
|
|
|
| def document_manifest(document, archive_names): |
| root = ET.fromstring(document) |
| result = Counter() |
| for element in root.iter("Python"): |
| module, class_name = element.attrib.get("module"), element.attrib.get("class") |
| encoded, value = element.attrib.get("encoded"), element.attrib.get("value") |
| if encoded != "yes" or not isinstance(value, str) or len(value) > 100_000: |
| raise ValueError("invalid proxy serialization") |
| payload = json.loads(base64.b64decode(value, validate=True).decode("utf-8")) |
| if module is None and class_name is None: |
| if payload is not None: |
| raise ValueError("invalid null feature proxy") |
| elif (module, class_name) == ("draftobjects.clone", "Clone"): |
| if not isinstance(payload, str): |
| raise ValueError("invalid clone proxy") |
| elif payload is not None and not isinstance(payload, dict): |
| raise ValueError("invalid proxy payload") |
| result[(module, class_name)] += 1 |
| outputs = [] |
| for prop in root.iter("Property"): |
| if prop.attrib.get("type") != "App::PropertyFile": |
| continue |
| values = [element.attrib.get("value") for element in prop if element.tag == "String"] |
| if len(values) != 1 or values[0] is None: |
| raise ValueError("invalid file property") |
| name, value = prop.attrib.get("name"), values[0] |
| if name == "PostProcessorOutputFile": |
| outputs.append(value) |
| elif name in {"BitShape", "File"}: |
| if value not in ALLOWED_EXTERNAL_FILES: |
| raise ValueError("unsafe external tool file") |
| elif value: |
| raise ValueError("unexpected external file property") |
| if len(outputs) != 2 or set(outputs) != EXPECTED_OUTPUT_FILES: |
| raise ValueError("invalid output file properties") |
| 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 archive_names or PurePosixPath(member).suffix.lower() not in {".brp", ".nc"}: |
| raise ValueError("invalid internal archive reference") |
| return result |
|
|
|
|
| def validate_archive(path): |
| if not regular_file(path, 10_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) > 300: |
| return False |
| total = 0 |
| for entry in archive.infolist(): |
| name = entry.filename |
| pure = PurePosixPath(name) |
| unix_mode = entry.external_attr >> 16 |
| if ( |
| not name |
| or "\\" in name |
| or pure.is_absolute() |
| or ".." in pure.parts |
| or entry.flag_bits & 1 |
| or stat.S_ISLNK(unix_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 > 250) |
| or pure.suffix.lower() in {".py", ".pyc", ".pyo", ".so", ".sh", ".dll", ".dylib", ".exe"} |
| ): |
| return False |
| total += entry.file_size |
| if total > 60_000_000: |
| return False |
| proxies = document_manifest(archive.read("Document.xml"), set(names)) |
| null_count = proxies.pop((None, None), 0) |
| if not 0 <= null_count <= 20 or set(proxies) != set(PROXY_RULES): |
| return False |
| for key, requirement in PROXY_RULES.items(): |
| count = proxies[key] |
| if isinstance(requirement, tuple): |
| if not requirement[0] <= count <= requirement[1]: |
| return False |
| elif count != requirement: |
| return False |
| return True |
| except (OSError, ValueError, UnicodeError, 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, index = [], 0 |
| while index < len(line): |
| char = line[index] |
| 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) |
| index += 1 |
| 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 or any(letter not in ALLOWED_ADDRESSES for letter, _ in words): |
| return None |
| if any(sum(letter == key for letter, _ in words) > 1 for key in ALLOWED_ADDRESSES - {"G", "M"}): |
| return None |
| blocks.append(words) |
| return blocks or None |
|
|
|
|
| def arc_parts(start, end, i_value, j_value, clockwise): |
| cx, cy = start[0] + i_value, start[1] + j_value |
| radius = math.hypot(start[0] - cx, start[1] - cy) |
| if radius <= 1e-9 or not close(math.hypot(end[0] - cx, end[1] - cy), radius, 0.01): |
| return None |
| first = math.atan2(start[1] - cy, start[0] - cx) |
| last = math.atan2(end[1] - cy, end[0] - cx) |
| if clockwise: |
| while last >= first: |
| last -= 2 * math.pi |
| else: |
| while last <= first: |
| last += 2 * math.pi |
| sweep = last - first |
| count = max(12, int(abs(sweep) * max(radius, 1.0) / 0.25)) |
| points = [] |
| for index in range(count + 1): |
| fraction = index / count |
| angle = first + sweep * fraction |
| points.append((cx + radius * math.cos(angle), cy + radius * math.sin(angle), start[2] + (end[2] - start[2]) * fraction)) |
| return (cx, cy, radius, sweep, points) |
|
|
|
|
| def simulate_nc(path, side): |
| blocks = parse_nc(path) |
| if blocks is None: |
| return None |
| allowed_tools = {1} if side == "A" else {2, 3} |
| expected_wcs = 54 if side == "A" else 55 |
| state = { |
| "units": None, |
| "absolute": False, |
| "plane": None, |
| "wcs": None, |
| "motion": None, |
| "cycle": None, |
| "cycle_z": None, |
| "cycle_r": None, |
| "cycle_p": None, |
| "cycle_q": None, |
| "cycle_kind": None, |
| "retract": 98, |
| "tool": None, |
| "changed": False, |
| "speed": None, |
| "feed": None, |
| "spindle": False, |
| "X": None, |
| "Y": None, |
| "Z": None, |
| } |
| changed_tools, motions, cycles = [], [], [] |
| ended = False |
| 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 None |
| if any(sum(code in group for code in gs) > 1 for group in G_MODAL_GROUPS): |
| return None |
| if len(ms) != len(set(ms)) or any(sum(code in group for code in ms) > 1 for group in M_MODAL_GROUPS): |
| return None |
| if 21 in gs: |
| state["units"] = "mm" |
| if 20 in gs: |
| state["units"] = "inch" |
| if 17 in gs: |
| state["plane"] = "XY" |
| if 90 in gs: |
| state["absolute"] = True |
| for code in (54, 55): |
| if code in gs: |
| state["wcs"] = code |
| if state["spindle"] and state["wcs"] not in {None, expected_wcs}: |
| return None |
| if 98 in gs: |
| state["retract"] = 98 |
| if 99 in gs: |
| state["retract"] = 99 |
| for code in gs: |
| if code in {0, 1, 2, 3}: |
| state["motion"] = code |
| state["cycle"] = None |
| if code in {80, 81, 82, 83}: |
| state["cycle"] = None if code == 80 else code |
| if code == 80: |
| state["motion"] = None |
| state["cycle_z"] = state["cycle_r"] = None |
| state["cycle_p"] = state["cycle_q"] = None |
| state["cycle_kind"] = None |
| if "T" in words: |
| tool = integral(words["T"]) |
| if tool not in allowed_tools: |
| return None |
| if tool != state["tool"]: |
| state["changed"] = False |
| state["tool"] = tool |
| if "H" in words and integral(words["H"]) != state["tool"]: |
| return None |
| if "S" in words: |
| if not close(words["S"], 7000): |
| return None |
| state["speed"] = words["S"] |
| if "F" in words: |
| scale = 25.4 if state["units"] == "inch" else 1.0 |
| if state["units"] is None or not close(words["F"] * scale, 500, 0.05): |
| return None |
| state["feed"] = words["F"] * scale |
| if 5 in ms: |
| state["spindle"] = False |
| if 6 in ms: |
| if state["spindle"] or state["tool"] not in allowed_tools: |
| return None |
| state["changed"] = True |
| changed_tools.append(state["tool"]) |
| if 3 in ms: |
| if not state["changed"] or state["speed"] is None: |
| return None |
| state["spindle"] = True |
|
|
| before = (state["X"], state["Y"], state["Z"]) |
| scale = 25.4 if state["units"] == "inch" else 1.0 |
| target = tuple(words[axis] * scale if axis in words else state[axis] for axis in ("X", "Y", "Z")) |
| explicit_cycle = next((code for code in gs if code in {81, 82, 83}), None) |
| invoke_modal_cycle = explicit_cycle is None and state["cycle"] is not None and any(axis in words for axis in ("X", "Y")) and not any(code in {0, 1, 2, 3, 80} for code in gs) |
| if explicit_cycle is not None: |
| if state["cycle_kind"] != explicit_cycle: |
| state["cycle_p"] = state["cycle_q"] = None |
| state["cycle_kind"] = explicit_cycle |
| if explicit_cycle is not None or invoke_modal_cycle: |
| if "Z" in words: |
| state["cycle_z"] = words["Z"] * scale |
| if "R" in words: |
| state["cycle_r"] = words["R"] * scale |
| if "P" in words: |
| state["cycle_p"] = words["P"] |
| if "Q" in words: |
| state["cycle_q"] = words["Q"] * scale |
| code = explicit_cycle if explicit_cycle is not None else state["cycle"] |
| if ( |
| side != "B" |
| or state["tool"] != 2 |
| or state["units"] not in {"mm", "inch"} |
| or not state["absolute"] |
| or state["plane"] != "XY" |
| or state["wcs"] != 55 |
| or not state["changed"] |
| or not state["spindle"] |
| or state["feed"] is None |
| or target[0] is None |
| or target[1] is None |
| or state["cycle_z"] is None |
| or state["cycle_r"] is None |
| ): |
| return None |
| if code == 82 and (state["cycle_p"] is None or state["cycle_p"] < 0): |
| return None |
| if code == 83 and (state["cycle_q"] is None or state["cycle_q"] <= 0): |
| return None |
| cycles.append((code, target[0], target[1], state["cycle_z"], state["cycle_r"], state["tool"], state["retract"])) |
| state["X"], state["Y"] = target[0], target[1] |
| initial_z = before[2] |
| state["Z"] = initial_z if state["retract"] == 98 else state["cycle_r"] |
| else: |
| explicit_motion = next((code for code in gs if code in {0, 1, 2, 3}), None) |
| has_axes = any(axis in words for axis in ("X", "Y", "Z")) |
| if has_axes and (explicit_motion is not None or state["cycle"] is None): |
| motion = explicit_motion if explicit_motion is not None else state["motion"] |
| if motion is None: |
| return None |
| complete = all(value is not None for value in before) and all(value is not None for value in target) |
| if motion == 0: |
| present = {axis for axis in ("X", "Y", "Z") if axis in words} |
| if before[2] is None: |
| if present != {"Z"} or target[2] is None or target[2] <= 18.0: |
| return None |
| elif target[2] is None: |
| return None |
| elif "Z" in words and target[2] < before[2] - 1e-6 and target[2] < 18.0 - 1e-6: |
| return None |
| elif present & {"X", "Y"} and min(before[2], target[2]) < 18.0 - 1e-6 and not complete: |
| return None |
| elif not complete: |
| return None |
| if complete: |
| arc = None |
| if motion in {2, 3}: |
| if ("I" not in words and "J" not in words) or state["plane"] != "XY": |
| return None |
| arc = arc_parts(before, target, words.get("I", 0.0) * scale, words.get("J", 0.0) * scale, motion == 2) |
| if arc is None: |
| return None |
| motions.append((motion, before, target, state["tool"], state["wcs"], state["spindle"], state["feed"], arc)) |
| state["X"], state["Y"], state["Z"] = target |
| if 2 in ms or 30 in ms: |
| if index != len(blocks) - 1 or state["spindle"]: |
| return None |
| ended = True |
| if not ended or state["units"] not in {"mm", "inch"} or not state["absolute"] or state["plane"] != "XY": |
| return None |
| return {"tools": changed_tools, "motions": motions, "cycles": cycles} |
|
|
|
|
| def line_distance(px, py, start, end): |
| ax, ay = start[0], start[1] |
| bx, by = end[0], end[1] |
| dx, dy = bx - ax, by - ay |
| if close(dx, 0) and close(dy, 0): |
| return math.hypot(px - ax, py - ay) |
| ratio = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy))) |
| return math.hypot(px - (ax + ratio * dx), py - (ay + ratio * dy)) |
|
|
|
|
| def expanded_segments(motion): |
| code, start, end, _, _, _, _, arc = motion |
| if code in {2, 3}: |
| points = arc[4] |
| return list(zip(points, points[1:])) |
| return [(start, end)] |
|
|
|
|
| def validate_nc_a(path): |
| if not regular_file(path, 500, 2_000_000): |
| return False |
| result = simulate_nc(path, "A") |
| if result is None or result["tools"] != [1] or result["cycles"]: |
| return False |
| cutting, floor = [], [] |
| for motion in result["motions"]: |
| code, start, end, tool, wcs, spindle, feed, _ = motion |
| if code == 0 and (not close(start[0], end[0]) or not close(start[1], end[1])) and min(start[2], end[2]) < 18 - 0.01: |
| return False |
| if code not in {1, 2, 3}: |
| continue |
| if tool != 1 or wcs != 54 or not spindle or feed is None: |
| return False |
| for first, last in expanded_segments(motion): |
| if min(first[2], last[2]) < -0.02: |
| return False |
| if min(first[2], last[2]) < 18 - 1e-6: |
| if any(point[0] < -26.02 or point[0] > 26.02 or point[1] < -14.02 or point[1] > 14.02 for point in (first, last)): |
| return False |
| cutting.append((first, last)) |
| if close(first[2], 0, 0.02) and close(last[2], 0, 0.02): |
| floor.append((first, last)) |
| if not cutting or not floor or not close(min(min(a[2], b[2]) for a, b in cutting), 0, 0.02): |
| return False |
| if ( |
| min(min(first[0], last[0]) for first, last in floor) > -25.98 |
| or max(max(first[0], last[0]) for first, last in floor) < 25.98 |
| or min(min(first[1], last[1]) for first, last in floor) > -13.98 |
| or max(max(first[1], last[1]) for first, last in floor) < 13.98 |
| ): |
| return False |
| for xi in range(-52, 53): |
| for yi in range(-28, 29): |
| x, y = xi / 2.0, yi / 2.0 |
| if min(line_distance(x, y, first, last) for first, last in floor) > 4.02: |
| return False |
| return True |
|
|
|
|
| def nearest_hole(x, y, tolerance=0.01): |
| matches = [center for center in HOLES if math.hypot(x - center[0], y - center[1]) <= tolerance] |
| return matches[0] if len(matches) == 1 else None |
|
|
|
|
| def validate_nc_b(path): |
| if not regular_file(path, 700, 2_000_000): |
| return False |
| result = simulate_nc(path, "B") |
| if result is None or result["tools"] != [2, 3] or len(result["cycles"]) != 4: |
| return False |
| cycle_centers = [nearest_hole(cycle[1], cycle[2]) for cycle in result["cycles"]] |
| if None in cycle_centers or len(set(cycle_centers)) != 4 or set(cycle_centers) != HOLES: |
| return False |
| cycle_depths = [] |
| for code, _, _, z_value, r_value, tool, _ in result["cycles"]: |
| if code not in {81, 82, 83} or tool != 2 or not -4.1 <= z_value <= -0.75 or r_value <= 18: |
| return False |
| cycle_depths.append(z_value) |
| if max(cycle_depths) - min(cycle_depths) > 0.02: |
| return False |
| floor_sweep = Counter() |
| descending = set() |
| arc_count = 0 |
| for motion in result["motions"]: |
| code, start, end, tool, wcs, spindle, feed, arc = motion |
| if code == 0 and (not close(start[0], end[0]) or not close(start[1], end[1])) and min(start[2], end[2]) < 18 - 1e-6: |
| if tool != 3: |
| return False |
| centers = [center for center in HOLES if math.hypot(start[0] - center[0], start[1] - center[1]) <= 2.02 and math.hypot(end[0] - center[0], end[1] - center[1]) <= 2.02] |
| if len(centers) != 1: |
| return False |
| if code not in {1, 2, 3}: |
| continue |
| if tool == 2: |
| if min(start[2], end[2]) < 18 - 1e-6: |
| return False |
| continue |
| if tool != 3 or wcs != 55 or not spindle or feed is None: |
| return False |
| if min(start[2], end[2]) < 13.98: |
| return False |
| if code in {2, 3}: |
| cx, cy, radius, sweep, points = arc |
| center = nearest_hole(cx, cy) |
| if center is None or not close(radius, 2, 0.01): |
| return False |
| if any(math.hypot(point[0] - center[0], point[1] - center[1]) > 2.02 for point in points): |
| return False |
| arc_count += 1 |
| if min(start[2], end[2]) <= 14.02: |
| descending.add(center) |
| if close(start[2], 14, 0.02) and close(end[2], 14, 0.02): |
| floor_sweep[center] += abs(sweep) |
| elif min(start[2], end[2]) < 18 - 1e-6: |
| centers = [center for center in HOLES if math.hypot(start[0] - center[0], start[1] - center[1]) <= 2.02 and math.hypot(end[0] - center[0], end[1] - center[1]) <= 2.02] |
| if len(centers) != 1: |
| return False |
| return arc_count >= 8 and descending == HOLES and all(floor_sweep[center] >= 2 * math.pi - 1e-3 for center in HOLES) |
|
|
|
|
| def normalized_nc(path): |
| try: |
| text = path.read_text(encoding="utf-8") |
| except (OSError, UnicodeError): |
| return None |
| text = TIMESTAMP_RE.sub("(Output Time:<normalized>)", text).replace("\r\n", "\n").replace("\r", "\n") |
| return re.sub(r"(?<![\d.])-0(?:\.0+)?(?![\d.])", lambda match: match.group(0)[1:], text) |
|
|
|
|
| CHILD_SOURCE = r''' |
| import hashlib, math, os, pathlib, shlex, stat, sys |
| import FreeCAD as App |
| import Part |
| import Path.Post.Command as PathPostCommand |
| from Path.Post.Processor import PostProcessor |
| |
| EXPECTED_VERSION=("0","21","2","33771 (Git)") |
| EXPECTED_COMMIT="b9bfa5c5507506e4515816414cd27f4851d00489" |
| EXPECTED_STEP_SHA256="e8595d746534ccf3a477f5e6de54b09a3ebef10e4933b342311b384c97fa70e0" |
| ENDMILL_FILE="/usr/share/freecad/Mod/Path/Tools/Bit/5mm_Endmill.fctb" |
| DRILL_FILE="/usr/share/freecad/Mod/Path/Tools/Bit/5mm_Drill.fctb" |
| HOLES={(-45.0,-25.0),(45.0,-25.0),(-45.0,25.0),(45.0,25.0)} |
| |
| def number(value): |
| value=getattr(value,"Value",value) |
| return float(value) |
| def close(a,b,t=1e-6): |
| try: |
| left,right=number(a),number(b) |
| return math.isfinite(left) and math.isfinite(right) and abs(left-right)<=t |
| except (AttributeError,TypeError,ValueError):return False |
| 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 proxy_module(obj):return getattr(getattr(obj,"Proxy",None).__class__,"__module__","") |
| def same_volume(first,second,t=1e-4): |
| try:return first.isValid() and second.isValid() and first.cut(second).Volume<=t and second.cut(first).Volume<=t |
| except Exception:return False |
| def exact_bounds(shape,target,t=1e-5): |
| box=shape.BoundBox;actual=(box.XMin,box.XMax,box.YMin,box.YMax,box.ZMin,box.ZMax) |
| return shape.isValid() and all(close(a,b,t) for a,b in zip(actual,target)) |
| def expected_shapes(): |
| shape=Part.makeBox(120,80,18,App.Vector(-60,-40,0)).cut(Part.makeBox(60,36,18,App.Vector(-30,-18,0))) |
| for x,y in HOLES: |
| shape=shape.cut(Part.makeCylinder(3,18,App.Vector(x,y,0))) |
| shape=shape.cut(Part.makeCylinder(6,4,App.Vector(x,y,0))) |
| flipped=shape.copy();flipped.rotate(App.Vector(0,0,0),App.Vector(1,0,0),180);flipped.translate(App.Vector(0,0,18)) |
| return shape,flipped |
| def command_signature(op): |
| return tuple((str(command.Name).upper().replace(" ",""),tuple(sorted((str(key),round(float(value),6)) for key,value in command.Parameters.items()))) for command in op.Path.Commands) |
| def circle_record(shape): |
| try: |
| if shape.ShapeType!="Edge" or not isinstance(shape.Curve,Part.Circle):return None |
| curve=shape.Curve |
| if not close(shape.Length,2*math.pi*curve.Radius,1e-4):return None |
| return (round(curve.Center.x,5),round(curve.Center.y,5),round(curve.Center.z,5),round(curve.Radius,5)) |
| except (AttributeError,TypeError,ValueError):return None |
| def selected_shapes(op): |
| result=[] |
| try: |
| for obj,names in list(op.Base): |
| for name in tuple(names): |
| shape=obj.getSubObject(str(name)) |
| if shape is None or shape.isNull():return None |
| result.append((obj,str(name),shape)) |
| except Exception:return None |
| return result |
| def validate_circle_bases(ops,allowed_objects,radius,allowed_z,allow_helpers=False): |
| selected=[] |
| for op in ops: |
| values=selected_shapes(op) |
| if not values:return False |
| selected.extend(values) |
| if len(selected)!=4:return False |
| records=[];helpers=set() |
| for obj,_,shape in selected: |
| if obj not in allowed_objects: |
| if not allow_helpers or proxy_module(obj) not in {"","builtins"} or obj.TypeId not in {"PartDesign::Feature","Part::Feature"}:return False |
| helpers.add(obj) |
| record=circle_record(shape) |
| if record is None or not close(record[3],radius,1e-4) or not any(close(record[2],z,1e-4) for z in allowed_z):return False |
| records.append((record[0],record[1])) |
| for helper in helpers: |
| helper_records=[circle_record(edge) for edge in helper.Shape.Edges] |
| if not helper_records or any(record is None or not close(record[3],radius,1e-4) or not any(close(record[2],z,1e-4) for z in allowed_z) for record in helper_records):return False |
| return len(set(records))==4 and set(records)==HOLES |
| def validate_pocket_bases(ops,allowed_objects): |
| for op in ops: |
| selected=selected_shapes(op) |
| if not selected:return False |
| for obj,_,shape in selected: |
| try: |
| box=shape.BoundBox |
| if (obj not in allowed_objects and proxy_module(obj) not in {"","builtins"}) or shape.ShapeType!="Face" or len(shape.Faces)!=1 or shape.Area<=0 or box.XMin<-30.0001 or box.XMax>30.0001 or box.YMin<-18.0001 or box.YMax>18.0001 or not close(box.ZMin,box.ZMax) or not -1e-5<=box.ZMin<=19.00001:return False |
| except (AttributeError,TypeError,ValueError):return False |
| return True |
| def arc_parts(start,end,i_value,j_value,clockwise): |
| cx,cy=start[0]+i_value,start[1]+j_value;radius=math.hypot(start[0]-cx,start[1]-cy) |
| if radius<=1e-9 or not close(math.hypot(end[0]-cx,end[1]-cy),radius,2e-3):return None |
| first=math.atan2(start[1]-cy,start[0]-cx);last=math.atan2(end[1]-cy,end[0]-cx) |
| if clockwise: |
| while last>=first:last-=2*math.pi |
| else: |
| while last<=first:last+=2*math.pi |
| sweep=last-first;count=max(12,int(abs(sweep)*max(radius,1)/0.25));points=[] |
| for index in range(count+1): |
| fraction=index/count;angle=first+sweep*fraction |
| points.append((cx+radius*math.cos(angle),cy+radius*math.sin(angle),start[2]+(end[2]-start[2])*fraction)) |
| return cx,cy,radius,sweep,points |
| def path_motions(op): |
| position={"X":None,"Y":None,"Z":None};motions=[] |
| allowed={"G0","G00","G1","G01","G2","G02","G3","G03"} |
| for command in op.Path.Commands: |
| name=str(command.Name).upper().replace(" ","");before=tuple(position[a] for a in ("X","Y","Z")) |
| if name.startswith("(") and name.endswith(")") and not command.Parameters:continue |
| if name not in allowed:return None |
| for axis in position: |
| if axis in command.Parameters:position[axis]=float(command.Parameters[axis]) |
| after=tuple(position[a] for a in ("X","Y","Z")) |
| code=int(name[1:]);arc=None |
| present={axis for axis in position if axis in command.Parameters} |
| if not present:continue |
| complete=not any(v is None for v in before+after) |
| if code==0: |
| if before[2] is None: |
| if present!={"Z"} or after[2] is None or after[2]<=18:return None |
| elif after[2] is None:return None |
| elif "Z" in present and after[2]<before[2]-1e-6 and after[2]<18-1e-6:return None |
| elif present & {"X","Y"} and min(before[2],after[2])<18-1e-6 and not complete:return None |
| elif not complete:return None |
| if not complete:continue |
| if code in {2,3}: |
| if "I" not in command.Parameters and "J" not in command.Parameters:return None |
| arc=arc_parts(before,after,float(command.Parameters.get("I",0)),float(command.Parameters.get("J",0)),code==2) |
| if arc is None:return None |
| motions.append((code,before,after,arc)) |
| return motions |
| def line_distance(px,py,start,end): |
| ax,ay=start[0],start[1];bx,by=end[0],end[1];dx,dy=bx-ax,by-ay |
| if close(dx,0) and close(dy,0):return math.hypot(px-ax,py-ay) |
| ratio=max(0,min(1,((px-ax)*dx+(py-ay)*dy)/(dx*dx+dy*dy))) |
| return math.hypot(px-(ax+ratio*dx),py-(ay+ratio*dy)) |
| def expanded(motion): |
| if motion[0] in {2,3}: |
| points=motion[3][4];return list(zip(points,points[1:])) |
| return [(motion[1],motion[2])] |
| def validate_pocket_paths(ops): |
| motions=[] |
| for op in ops: |
| values=path_motions(op) |
| if not values:return False |
| motions.extend(values) |
| cutting=[];floor=[] |
| for motion in motions: |
| code,start,end,_=motion |
| if code==0 and (not close(start[0],end[0]) or not close(start[1],end[1])) and min(start[2],end[2])<18-1e-6:return False |
| if code not in {1,2,3}:continue |
| for first,last in expanded(motion): |
| if min(first[2],last[2]) < -1e-5:return False |
| if min(first[2],last[2]) < 18-1e-6: |
| if any(p[0]<-26.001 or p[0]>26.001 or p[1]<-14.001 or p[1]>14.001 for p in (first,last)):return False |
| cutting.append((first,last)) |
| if close(first[2],0,1e-4) and close(last[2],0,1e-4):floor.append((first,last)) |
| if not cutting or not floor or not close(min(min(a[2],b[2]) for a,b in cutting),0,1e-4):return False |
| if min(min(a[0],b[0]) for a,b in floor)>-25.999 or max(max(a[0],b[0]) for a,b in floor)<25.999 or min(min(a[1],b[1]) for a,b in floor)>-13.999 or max(max(a[1],b[1]) for a,b in floor)<13.999:return False |
| for xi in range(-52,53): |
| for yi in range(-28,29): |
| x,y=xi/2.0,yi/2.0 |
| if min(line_distance(x,y,a,b) for a,b in floor)>4.01:return False |
| return True |
| def drilling_signature(op): |
| position={"X":None,"Y":None,"Z":None};cycle=None;cycle_kind=None;cycle_z=None;cycle_r=None;cycle_p=None;cycle_q=None;retract=98;records=[] |
| allowed={"G0","G00","G80","G81","G82","G83","G90","G98","G99"} |
| for command in op.Path.Commands: |
| name=str(command.Name).upper().replace(" ","");before=dict(position) |
| if name.startswith("(") and name.endswith(")") and not command.Parameters:continue |
| if name not in allowed:return None |
| if name=="G98":retract=98 |
| if name=="G99":retract=99 |
| if name in {"G0","G00"}:cycle=None |
| if name=="G80":cycle=None;cycle_kind=None;cycle_z=None;cycle_r=None;cycle_p=None;cycle_q=None |
| if name in {"G81","G82","G83"}: |
| cycle=name |
| if cycle_kind!=name:cycle_p=None;cycle_q=None |
| cycle_kind=name |
| if "Z" in command.Parameters:cycle_z=float(command.Parameters["Z"]) |
| if "R" in command.Parameters:cycle_r=float(command.Parameters["R"]) |
| if "P" in command.Parameters:cycle_p=float(command.Parameters["P"]) |
| if "Q" in command.Parameters:cycle_q=float(command.Parameters["Q"]) |
| for axis in position: |
| if axis in command.Parameters:position[axis]=float(command.Parameters[axis]) |
| if name in {"G81","G82","G83"}: |
| if position["X"] is None or position["Y"] is None or cycle_z is None or cycle_r is None:return None |
| if name=="G82" and (cycle_p is None or cycle_p<0):return None |
| if name=="G83" and (cycle_q is None or cycle_q<=0):return None |
| records.append((name,round(position["X"],5),round(position["Y"],5),round(cycle_z,5),round(cycle_r,5))) |
| position["Z"]=before["Z"] if retract==98 else cycle_r |
| elif name in {"G0","G00"}: |
| present={axis for axis in position if axis in command.Parameters};effective=position["Z"] |
| if before["Z"] is None: |
| if present!={"Z"} or effective is None or effective<=18:return None |
| elif effective is None:return None |
| elif "Z" in present and effective<before["Z"]-1e-6 and effective<18-1e-6:return None |
| elif present & {"X","Y"} and min(before["Z"],effective)<18-1e-6:return None |
| return tuple(records) |
| def nearest_hole(x,y,t=1e-3): |
| matches=[center for center in HOLES if math.hypot(x-center[0],y-center[1])<=t] |
| return matches[0] if len(matches)==1 else None |
| def validate_helix_paths(ops): |
| motions=[] |
| for op in ops: |
| values=path_motions(op) |
| if not values:return False |
| motions.extend(values) |
| floor={center:0.0 for center in HOLES};descending=set();arcs=0 |
| for code,start,end,arc in motions: |
| if code==0 and (not close(start[0],end[0]) or not close(start[1],end[1])) and min(start[2],end[2])<18-1e-6: |
| centers=[c for c in HOLES if math.hypot(start[0]-c[0],start[1]-c[1])<=2.001 and math.hypot(end[0]-c[0],end[1]-c[1])<=2.001] |
| if len(centers)!=1:return False |
| if code not in {1,2,3}:continue |
| if min(start[2],end[2])<14-1e-5:return False |
| if code in {2,3}: |
| cx,cy,radius,sweep,points=arc;center=nearest_hole(cx,cy) |
| if center is None or not close(radius,2,2e-3) or any(math.hypot(p[0]-center[0],p[1]-center[1])>2.002 for p in points):return False |
| arcs+=1 |
| if min(start[2],end[2])<=14+1e-4:descending.add(center) |
| if close(start[2],14,1e-4) and close(end[2],14,1e-4):floor[center]+=abs(sweep) |
| elif min(start[2],end[2])<18-1e-6: |
| centers=[c for c in HOLES if math.hypot(start[0]-c[0],start[1]-c[1])<=2.002 and math.hypot(end[0]-c[0],end[1]-c[1])<=2.002] |
| if len(centers)!=1:return False |
| return arcs>=8 and descending==HOLES and all(floor[c]>=2*math.pi-1e-3 for c in HOLES) |
| def expected_tool_shape(doc,template,name,parameters): |
| import Path.Tool.Bit as PathToolBit |
| tool=PathToolBit.Factory.CreateFrom(template,name) |
| for key,value in parameters.items():setattr(tool,key,value) |
| tool.Proxy.loadBitBody(tool,force=True);tool.Proxy._updateBitShape(tool);tool.Proxy.unloadBitBody(tool);doc.recompute() |
| return tool |
| def secure_system_file(value,allowed,allow_empty=False): |
| try: |
| if not value:return allow_empty |
| path=pathlib.Path(str(value)).resolve(strict=True);accepted={pathlib.Path(item).resolve(strict=True) for item in allowed} |
| info=path.stat() |
| return path in accepted and stat.S_ISREG(info.st_mode) and info.st_uid==0 and not info.st_mode & (stat.S_IWGRP|stat.S_IWOTH) |
| except (OSError,RuntimeError,ValueError):return False |
| def validate_controller(doc,controller,number_value,kind,diameter): |
| try: |
| tool=controller.Tool |
| if int(controller.ToolNumber)!=number_value or tool is None or tool.Shape.isNull() or len(tool.Shape.Solids)!=1:return None |
| if not close(tool.Diameter,diameter) or not close(controller.SpindleSpeed,7000) or str(controller.SpindleDir)!="Forward" or not close(controller.HorizFeed.getValueAs("mm/min").Value,500) or not close(controller.VertFeed.getValueAs("mm/min").Value,500):return None |
| if kind=="endmill": |
| shapes={"/usr/lib/freecad/Mod/Path/Tools/Shape/endmill.fcstd","/usr/share/freecad/Mod/Path/Tools/Shape/endmill.fcstd"} |
| if str(tool.ShapeName)!="endmill" or not secure_system_file(tool.BitShape,shapes) or not secure_system_file(getattr(tool,"File",""),{ENDMILL_FILE},True) or not secure_system_file(ENDMILL_FILE,{ENDMILL_FILE}) or not 0<number(tool.ShankDiameter)<=50 or not 0<number(tool.CuttingEdgeHeight)<=number(tool.Length)<=300:return None |
| expected=expected_tool_shape(doc,ENDMILL_FILE,"ExpectedTask17Endmill%d"%number_value,{"Diameter":diameter,"ShankDiameter":number(tool.ShankDiameter),"CuttingEdgeHeight":number(tool.CuttingEdgeHeight),"Length":number(tool.Length)}) |
| else: |
| shapes={"/usr/share/freecad/Mod/Path/Tools/Shape/drill.fcstd"} |
| if str(tool.ShapeName)!="drill" or not secure_system_file(tool.BitShape,shapes) or not secure_system_file(getattr(tool,"File",""),{DRILL_FILE},True) or not secure_system_file(DRILL_FILE,{DRILL_FILE}) or not 90<=number(tool.TipAngle)<=150 or not 18<=number(tool.Length)<=300:return None |
| expected=expected_tool_shape(doc,DRILL_FILE,"ExpectedTask17Drill",{"Diameter":diameter,"TipAngle":number(tool.TipAngle),"Length":number(tool.Length)}) |
| valid=same_volume(tool.Shape,expected.Shape,1e-4);doc.removeObject(expected.Name);doc.recompute() |
| return tool if valid else None |
| except (AttributeError,TypeError,ValueError):return None |
| def valid_post_args(value): |
| try: |
| text=str(value) |
| if len(text)>1000 or any(ord(char)<32 and char not in "\t" for char in text):return False |
| tokens=shlex.split(text);flags={"--no-comments","--no-header","--line-numbers","--no-show-editor","--inches","--modal","--axis-modal","--no-tlo"};valued={"--precision","--preamble","--postamble"};seen=set();index=0 |
| while index<len(tokens): |
| token=tokens[index];option,value=(token.split("=",1)+[None])[:2] if "=" in token else (token,None) |
| if option in flags: |
| if value is not None or option in seen:return False |
| elif option in valued: |
| if option in seen:return False |
| if value is None: |
| index+=1 |
| if index>=len(tokens):return False |
| value=tokens[index] |
| if not value or len(value)>500 or "\n" in value or "\r" in value:return False |
| if option=="--precision" and (not value.isdigit() or not 0<=int(value)<=8):return False |
| else:return False |
| seen.add(option);index+=1 |
| return "--no-show-editor" in seen |
| except (TypeError,ValueError):return False |
| def clean_state(objects): |
| return all(set(map(str,obj.State))=={"Up-to-date"} for obj in objects) |
| def export_job(job,path): |
| sections=PathPostCommand.buildPostList(job) |
| if len(sections)!=1:return False |
| PostProcessor.load("linuxcnc").export(sections[0][1],str(path),str(job.PostProcessorArgs)) |
| return path.is_file() and path.stat().st_size>500 |
| def validate(step_path,fcstd_path,repost_a,repost_b,fresh_a,fresh_b): |
| if tuple(App.Version()[:4])!=EXPECTED_VERSION or App.Version()[-1]!=EXPECTED_COMMIT:return False |
| if normalized_text_sha256(step_path)!=EXPECTED_STEP_SHA256:return False |
| source=Part.read(str(step_path)) |
| if source is None or len(source.Solids)!=1 or not exact_bounds(source,(-60,60,-40,40,0,18)) or not close(source.Volume,172800,1e-3):return False |
| expected_a,expected_b=expected_shapes() |
| doc=App.openDocument(str(fcstd_path)) |
| try: |
| if not 20<=len(doc.Objects)<=100 or not clean_state(doc.Objects):return False |
| jobs=[obj for obj in doc.Objects if proxy_module(obj)=="Path.Main.Job"] |
| pockets=[obj for obj in doc.Objects if proxy_module(obj)=="Path.Op.PocketShape"] |
| drills=[obj for obj in doc.Objects if proxy_module(obj)=="Path.Op.Drilling"] |
| helices=[obj for obj in doc.Objects if proxy_module(obj)=="Path.Op.Helix"] |
| controllers=[obj for obj in doc.Objects if proxy_module(obj)=="Path.Tool.Controller"] |
| tools=[obj for obj in doc.Objects if proxy_module(obj)=="Path.Tool.Bit"] |
| clones=[obj for obj in doc.Objects if proxy_module(obj)=="draftobjects.clone"] |
| stocks=[obj for obj in doc.Objects if proxy_module(obj)=="Path.Main.Stock"] |
| if len(jobs)!=2 or not 1<=len(pockets)<=4 or not 1<=len(drills)<=4 or not 1<=len(helices)<=4 or not 3<=len(controllers)<=6 or len(tools)!=len(controllers) or len(clones)!=2 or len(stocks)!=2:return False |
| by_wcs={} |
| for job in jobs: |
| fixtures=list(job.Fixtures) |
| if len(fixtures)!=1 or fixtures[0] not in {"G54","G55"} or fixtures[0] in by_wcs:return False |
| by_wcs[fixtures[0]]=job |
| if set(by_wcs)!={"G54","G55"}:return False |
| job_a,job_b=by_wcs["G54"],by_wcs["G55"] |
| ops_a=list(job_a.Operations.Group);ops_b=list(job_b.Operations.Group) |
| if len(ops_a)!=len(pockets) or set(ops_a)!=set(pockets) or len(ops_b)!=len(drills)+len(helices) or set(ops_b)!=set(drills+helices):return False |
| seen_helix=False |
| for op in ops_b: |
| if op in helices:seen_helix=True |
| elif seen_helix:return False |
| if str(job_a.PostProcessor).lower()!="linuxcnc" or str(job_b.PostProcessor).lower()!="linuxcnc" or not valid_post_args(job_a.PostProcessorArgs) or not valid_post_args(job_b.PostProcessorArgs):return False |
| if bool(job_a.SplitOutput) or bool(job_b.SplitOutput) or os.path.normpath(str(job_a.PostProcessorOutputFile))!="/home/user/Desktop/task-17_A.nc" or os.path.normpath(str(job_b.PostProcessorOutputFile))!="/home/user/Desktop/task-17_B.nc":return False |
| if len(job_a.Model.Group)!=1 or len(job_b.Model.Group)!=1:return False |
| model_a,model_b=job_a.Model.Group[0],job_b.Model.Group[0] |
| if model_a==model_b or proxy_module(model_a)!="draftobjects.clone" or proxy_module(model_b)!="draftobjects.clone":return False |
| if len(list(model_a.Objects))!=1 or len(list(model_b.Objects))!=1:return False |
| part_a,part_b=list(model_a.Objects)[0],list(model_b.Objects)[0] |
| if part_a==part_b or not same_volume(part_a.Shape,expected_a) or not same_volume(part_b.Shape,expected_b) or not same_volume(model_a.Shape,expected_a) or not same_volume(model_b.Shape,expected_b):return False |
| stock_tops={} |
| for job,model in ((job_a,model_a),(job_b,model_b)): |
| stock=job.Stock |
| if stock not in stocks or proxy_module(stock)!="Path.Main.Stock" or stock.Base!=job.Model:return False |
| names=("ExtXneg","ExtXpos","ExtYneg","ExtYpos","ExtZneg","ExtZpos");extensions=[number(getattr(stock,name)) for name in names] |
| if any(not math.isfinite(value) or value<0 or value>20 for value in extensions):return False |
| xn,xp,yn,yp,zn,zp=extensions;stock_shape=Part.makeBox(120+xn+xp,80+yn+yp,18+zn+zp,App.Vector(-60-xn,-40-yn,-zn)) |
| if not same_volume(stock.Shape,stock_shape):return False |
| stock_tops[job]=18+zp |
| ctrls_a=list(job_a.Tools.Group);ctrls_b=list(job_b.Tools.Group) |
| if len(ctrls_a)!=1 or len(ctrls_b)!=2 or len(set(ctrls_a+ctrls_b))!=3:return False |
| if [int(controller.ToolNumber) for controller in ctrls_a]!=[1] or [int(controller.ToolNumber) for controller in ctrls_b]!=[2,3]:return False |
| tc1,tc2,tc3=ctrls_a[0],ctrls_b[0],ctrls_b[1] |
| if any(op.ToolController!=tc1 for op in pockets) or any(op.ToolController!=tc2 for op in drills) or any(op.ToolController!=tc3 for op in helices):return False |
| bit1=validate_controller(doc,tc1,1,"endmill",8);bit2=validate_controller(doc,tc2,2,"drill",6);bit3=validate_controller(doc,tc3,3,"endmill",8) |
| if bit1 is None or bit2 is None or bit3 is None or len({bit1.Name,bit2.Name,bit3.Name})!=3 or any(bit not in tools for bit in (bit1,bit2,bit3)):return False |
| for pocket in pockets: |
| if not (18-1e-5<=number(pocket.StartDepth)<=stock_tops[job_a]+1e-5 and 0-1e-5<=number(pocket.FinalDepth)<18 and number(pocket.SafeHeight)>stock_tops[job_a] and number(pocket.ClearanceHeight)>=number(pocket.SafeHeight) and 0<number(pocket.StepDown)<=18 and 0<number(pocket.StepOver)<=100):return False |
| if str(pocket.CutMode) not in {"Climb","Conventional"} or str(pocket.OffsetPattern) not in {"ZigZag","Offset","ZigZagOffset","Line","Grid"}:return False |
| if not any(close(pocket.FinalDepth,0) for pocket in pockets) or not validate_pocket_bases(pockets,{model_a,part_a}) or not validate_pocket_paths(pockets):return False |
| tip_length=3.0/math.tan(math.radians(number(bit2.TipAngle)/2.0));drill_sigs=[] |
| for drill in drills: |
| if not (18-1e-5<=number(drill.StartDepth)<=stock_tops[job_b]+1e-5 and number(drill.SafeHeight)>stock_tops[job_b] and number(drill.ClearanceHeight)>=number(drill.SafeHeight) and str(drill.RetractMode) in {"G98","G99"}):return False |
| if bool(drill.KeepToolDown)!=(str(drill.RetractMode)=="G99"):return False |
| if bool(drill.PeckEnabled) and (not math.isfinite(number(drill.PeckDepth)) or number(drill.PeckDepth)<=0):return False |
| if bool(drill.DwellEnabled) and (not math.isfinite(number(drill.DwellTime)) or number(drill.DwellTime)<0):return False |
| if bool(drill.PeckEnabled) and bool(drill.DwellEnabled):return False |
| offset=str(drill.ExtraOffset) |
| if not ((offset in {"Drill Tip","2x Drill Tip"} and close(drill.FinalDepth,0)) or (offset=="None" and -2*tip_length-0.02<=number(drill.FinalDepth)<=-tip_length+0.02)):return False |
| signature=drilling_signature(drill) |
| if not signature: return False |
| drill_sigs.append(signature) |
| drill_sig=tuple(entry for signature in drill_sigs for entry in signature) |
| if not validate_circle_bases(drills,{model_b,part_b},3,{0,18}) or len(drill_sig)!=4 or {entry[1:3] for entry in drill_sig}!=HOLES or any(entry[0] not in {"G81","G82","G83"} or not -2*tip_length-0.02<=entry[3]<=-tip_length+0.02 or entry[4]<=stock_tops[job_b] for entry in drill_sig):return False |
| for helix in helices: |
| if not (18-1e-5<=number(helix.StartDepth)<=stock_tops[job_b]+1e-5 and close(helix.FinalDepth,14) and number(helix.SafeHeight)>stock_tops[job_b] and number(helix.ClearanceHeight)>=number(helix.SafeHeight) and 0<number(helix.StepDown)<=18 and 0<number(helix.StepOver)<=100):return False |
| if not validate_circle_bases(helices,{model_b,part_b},6,{14,18},True) or not validate_helix_paths(helices):return False |
| all_ops=tuple(ops_a+ops_b);saved=tuple(command_signature(op) for op in all_ops) |
| if not export_job(job_a,repost_a) or not export_job(job_b,repost_b):return False |
| for obj in doc.Objects:obj.touch() |
| doc.recompute();doc.recompute() |
| if not clean_state(doc.Objects) or tuple(command_signature(op) for op in all_ops)!=saved:return False |
| post_drill_sig=tuple(entry for drill in drills for entry in drilling_signature(drill)) |
| stable_drill=(len(post_drill_sig)==len(drill_sig) and all(a[:3]==b[:3] and close(a[3],b[3],1e-4) and close(a[4],b[4],1e-4) for a,b in zip(post_drill_sig,drill_sig))) |
| post_checks=(same_volume(part_a.Shape,expected_a),same_volume(part_b.Shape,expected_b),validate_pocket_paths(pockets),stable_drill,validate_helix_paths(helices)) |
| if not all(post_checks):return False |
| if not export_job(job_a,fresh_a) or not export_job(job_b,fresh_b):return False |
| return True |
| finally: |
| App.closeDocument(doc.Name) |
| |
| marker,step_arg,fcstd_arg,repost_a_arg,repost_b_arg,fresh_a_arg,fresh_b_arg=sys.argv[1:8] |
| try: |
| result=validate(pathlib.Path(step_arg),pathlib.Path(fcstd_arg),pathlib.Path(repost_a_arg),pathlib.Path(repost_b_arg),pathlib.Path(fresh_a_arg),pathlib.Path(fresh_b_arg)) |
| except Exception as exc: |
| print("task-17 FreeCAD validation: %s: %s"%(type(exc).__name__,exc),file=sys.stderr);result=False |
| print(marker+"="+("True" if result else "False")) |
| ''' |
|
|
|
|
| def run_freecad_validation(step_path, fcstd_path, nc_a_path, nc_b_path): |
| 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 & (stat.S_IWGRP | stat.S_IWOTH): |
| return False |
| marker = "TASK17_" + secrets.token_hex(24) |
| with tempfile.TemporaryDirectory(prefix="engiworld-task17-") as raw: |
| temp = Path(raw) |
| script = temp / "validate.py" |
| repost_a, repost_b = temp / "repost_A.nc", temp / "repost_B.nc" |
| fresh_a, fresh_b = temp / "fresh_A.nc", temp / "fresh_B.nc" |
| script.write_text(CHILD_SOURCE, encoding="utf-8") |
| script.chmod(0o600) |
| args = [str(script), marker, str(step_path), str(fcstd_path), str(repost_a), str(repost_b), str(fresh_a), str(fresh_b)] |
| command = [ |
| str(executable), |
| "-c", |
| "import builtins,sys; sys.argv=%r; builtins.pythonopen=open; exec(compile(open(%r,encoding='utf-8').read(),%r,'exec'))" |
| % (args, str(script), str(script)), |
| ] |
| env = { |
| "PATH": "/usr/bin:/bin", |
| "HOME": str(temp), |
| "TMPDIR": str(temp), |
| "LANG": "C.UTF-8", |
| "LC_ALL": "C.UTF-8", |
| "PYTHONNOUSERSITE": "1", |
| "QT_QPA_PLATFORM": "offscreen", |
| "XDG_CACHE_HOME": str(temp / ".cache"), |
| "XDG_CONFIG_HOME": str(temp / ".config"), |
| } |
| try: |
| completed = subprocess.run( |
| command, |
| cwd=temp, |
| env=env, |
| stdin=subprocess.DEVNULL, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| text=True, |
| timeout=300, |
| check=False, |
| ) |
| except (OSError, subprocess.SubprocessError): |
| return False |
| expected = marker + "=True" |
| if completed.returncode != 0 or [line for line in completed.stdout.splitlines() if line.startswith(marker + "=")] != [expected]: |
| if completed.stderr: |
| print(completed.stderr[-4000:], file=sys.stderr) |
| return False |
| base_a, base_b = normalized_nc(nc_a_path), normalized_nc(nc_b_path) |
| checks = ( |
| base_a is not None, |
| base_b is not None, |
| base_a == normalized_nc(fresh_a), |
| base_b == normalized_nc(fresh_b), |
| validate_nc_a(repost_a), |
| validate_nc_a(fresh_a), |
| validate_nc_b(repost_b), |
| validate_nc_b(fresh_b), |
| ) |
| return all(checks) |
|
|
|
|
| def main(): |
| with tempfile.TemporaryDirectory(prefix="engiworld-task17-input-") as raw: |
| frozen = Path(raw) |
| step = frozen / STEP.name |
| fcstd = frozen / FCSTD.name |
| nc_a = frozen / NC_A.name |
| nc_b = frozen / NC_B.name |
| if not freeze_file(STEP, step, 1_000, 10_000_000) or normalized_text_sha256(step) != EXPECTED_STEP_SHA256: |
| return fail("invalid init STEP") |
| if not freeze_file(FCSTD, fcstd, 10_000, 20_000_000) or not validate_archive(fcstd): |
| return fail("invalid answer FCStd archive") |
| if not freeze_file(NC_A, nc_a, 500, 2_000_000) or not validate_nc_a(nc_a): |
| return fail("invalid Side A NC semantics") |
| if not freeze_file(NC_B, nc_b, 700, 2_000_000) or not validate_nc_b(nc_b): |
| return fail("invalid Side B NC semantics") |
| if not run_freecad_validation(step, fcstd, nc_a, nc_b): |
| return fail("native FreeCAD validation or fresh repost failed") |
| return True |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| outcome = main() |
| except Exception as exc: |
| print("task-17 evaluator: %s: %s" % (type(exc).__name__, exc), file=sys.stderr) |
| outcome = False |
| print("True" if outcome else "False") |
|
|
