| from __future__ import annotations |
|
|
| import base64 |
| import csv |
| 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 / "complex_pockets.step" |
| CSV_FILE = TARGET / "tool_candidates.csv" |
| FCSTD = TARGET / "task-19.FCStd" |
| NC = TARGET / "task-19.nc" |
| FREECADCMD = Path("/usr/bin/freecadcmd") |
| EXPECTED_CSV_SHA256 = "1fe9ef157b2642a50dd0140e50acb6f889f226fff1b9b54078eb5f3ff698c366" |
| EXPECTED_STEP_SHA256 = "a013a4fe398f51898129934d04c3024f4c01b9c48abf50a1f526c91e7845775e" |
| EXPECTED_VERSION = ("0", "21", "2", "33771 (Git)") |
| EXPECTED_COMMIT = "b9bfa5c5507506e4515816414cd27f4851d00489" |
| EXPECTED_TOOLS = { |
| 1: ("end mill", 16.0, 7000.0, 500.0, 4), |
| 2: ("drill", 14.0, 7000.0, 500.0, 4), |
| 3: ("drill", 12.0, 7000.0, 500.0, 4), |
| 4: ("end mill", 10.0, 7000.0, 500.0, 4), |
| 5: ("end mill", 8.0, 7000.0, 500.0, 4), |
| } |
| 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} |
| G_MODAL_GROUPS = ( |
| {0, 1, 2, 3, 80, 81, 82, 83}, |
| {17}, |
| {21}, |
| {40}, |
| {43, 49}, |
| {54}, |
| {90}, |
| {94}, |
| {98, 99}, |
| ) |
| REQUIRED_PROXIES = Counter( |
| { |
| ("Path.Main.Job", "ObjectJob"): 1, |
| ("Path.Base.SetupSheet", "SetupSheet"): 1, |
| ("Path.Main.Stock", "StockFromBase"): 1, |
| ("draftobjects.clone", "Clone"): 1, |
| ("Path.Tool.Controller", "ToolController"): 5, |
| ("Path.Tool.Bit", "ToolBit"): 5, |
| ("Path.Op.PocketShape", "ObjectPocket"): 5, |
| ("Path.Op.Drilling", "ObjectDrilling"): 2, |
| ("Path.Op.Profile", "ObjectProfile"): 1, |
| } |
| ) |
| POCKET_NC_SPECS = ( |
| (-48.0, 18.0, 18.0, -4.0, 1), |
| (-24.0, 18.0, 16.0, -5.0, 4), |
| (0.0, 18.0, 14.0, -6.0, 4), |
| (24.0, 18.0, 12.0, -7.0, 4), |
| (48.0, 18.0, 10.0, -8.0, 5), |
| ) |
| EXPECTED_HOLES = { |
| 2: {(x, 27.0) for x in (-50.0, -30.0, -10.0, 10.0, 30.0, 50.0)}, |
| 3: {(x, -27.0) for x in (-50.0, -30.0, -10.0, 10.0, 30.0, 50.0)}, |
| } |
|
|
|
|
| def fail(message): |
| print("task-19 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_csv(path): |
| if not regular_file(path, 100, 10_000) or normalized_text_sha256(path) != EXPECTED_CSV_SHA256: |
| return False |
| try: |
| with path.open("r", encoding="utf-8", newline="") as stream: |
| reader = csv.DictReader(stream) |
| if reader.fieldnames != [ |
| "tool_number", "type", "diameter", "spindle", "feed", "operation_count" |
| ]: |
| return False |
| rows = list(reader) |
| except (OSError, UnicodeError, csv.Error): |
| return False |
| if len(rows) != 5: |
| return False |
| found = {} |
| try: |
| for row in rows: |
| if set(row) != set(reader.fieldnames) or any(value is None for value in row.values()): |
| return False |
| number = int(row["tool_number"]) |
| if number in found: |
| return False |
| found[number] = ( |
| row["type"].strip().lower(), |
| float(row["diameter"]), |
| float(row["spindle"]), |
| float(row["feed"]), |
| int(row["operation_count"]), |
| ) |
| except (TypeError, ValueError): |
| return False |
| return found == EXPECTED_TOOLS |
|
|
|
|
| def allowed_property_file(value): |
| if value in {"", "/home/user/Desktop/task-19.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 = 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, class_name) == ("draftobjects.clone", "Clone"): |
| if not isinstance(payload, str): |
| return False |
| elif payload is not None and not isinstance(payload, dict): |
| return False |
| proxies[(module, class_name)] += 1 |
| 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, 5_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, |
| "motion": None, |
| "cycle": None, |
| "cycle_z": None, |
| "cycle_r": None, |
| "retract": None, |
| "tool": None, |
| "changed": False, |
| "speed": None, |
| "feed": None, |
| "spindle": False, |
| "X": None, |
| "Y": None, |
| "Z": None, |
| } |
| ended = False |
| saw_m5 = False |
| changed_tools = [] |
| spindle_tools = set() |
| cutting_tools = set() |
| cycles = [] |
| cuts = {number: [] for number in EXPECTED_TOOLS} |
| 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: |
| return False |
| if any(code is None or code not in ALLOWED_G for code in gs): |
| return False |
| if any(code is None or code not in ALLOWED_M for code in ms): |
| return False |
| if any(sum(code in group for code in gs) > 1 for group in G_MODAL_GROUPS): |
| return False |
| terminators = [code for code in ms if code in {2, 30}] |
| if ( |
| len(ms) != len(set(ms)) |
| or len(terminators) > 1 |
| or (terminators and len(ms) != 1) |
| ): |
| 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 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 |
| if code in {81, 82, 83}: |
| state["cycle"] = code |
| elif code == 80: |
| state["cycle"] = None |
| state["cycle_z"] = None |
| state["cycle_r"] = None |
| if "T" in words: |
| tool = integral(words["T"]) |
| if tool not in EXPECTED_TOOLS: |
| return False |
| if tool != state["tool"]: |
| state["changed"] = False |
| state["tool"] = tool |
| 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 ( |
| len(ms) != 1 |
| or not saw_m5 |
| or state["spindle"] |
| or state["tool"] not in EXPECTED_TOOLS |
| or state["cycle"] is not None |
| ): |
| return False |
| state["changed"] = True |
| changed_tools.append(state["tool"]) |
| saw_m5 = False |
| if 3 in ms: |
| if ( |
| state["tool"] not in EXPECTED_TOOLS |
| or not state["changed"] |
| or state["speed"] is None |
| ): |
| return False |
| state["spindle"] = True |
| spindle_tools.add(state["tool"]) |
|
|
| before = (state["X"], state["Y"], state["Z"]) |
| for axis in ("X", "Y", "Z"): |
| if axis in words: |
| state[axis] = words[axis] |
| explicit_motion = next((code for code in gs if code in {0, 1, 2, 3}), None) |
| explicit_cycle = next((code for code in gs if code in {81, 82, 83}), None) |
| has_axis = any(axis in words for axis in ("X", "Y", "Z")) |
| if explicit_motion == 0 and ("X" in words or "Y" in words): |
| if state["Z"] is None or state["Z"] < 2.0 - 1e-6: |
| return False |
| if explicit_cycle is not None: |
| if "Z" not in words or "R" not in words: |
| return False |
| state["cycle_z"] = words["Z"] |
| state["cycle_r"] = words["R"] |
| if explicit_cycle == 82 and ("P" not in words or words["P"] < 0): |
| return False |
| if explicit_cycle == 83 and ("Q" not in words or words["Q"] <= 0): |
| return False |
| cycle_visit = ( |
| state["cycle"] in {81, 82, 83} |
| and state["tool"] in {2, 3} |
| and (explicit_cycle is not None or "X" in words or "Y" in words) |
| and explicit_motion is None |
| and 80 not in gs |
| ) |
| if cycle_visit: |
| if ( |
| not state["spindle"] |
| or not state["changed"] |
| or state["feed"] is None |
| or state["units"] != "mm" |
| or not state["absolute"] |
| or state["plane"] != "XY" |
| or state["wcs"] != 54 |
| or state["X"] is None |
| or state["Y"] is None |
| or state["cycle_z"] is None |
| or state["cycle_r"] is None |
| or state["retract"] != 98 |
| or state["cycle_z"] > -19.0 + 1e-6 |
| or not 1.9 <= state["cycle_r"] <= 5.1 |
| ): |
| return False |
| cycles.append( |
| ( |
| state["tool"], |
| round(state["X"], 4), |
| round(state["Y"], 4), |
| round(state["cycle_z"], 4), |
| ) |
| ) |
| cutting_tools.add(state["tool"]) |
| state["Z"] = before[2] if state["retract"] == 98 else state["cycle_r"] |
| elif has_axis and state["motion"] in {1, 2, 3} and explicit_motion != 0: |
| if state["cycle"] is not None: |
| return False |
| if ( |
| state["tool"] not in {1, 4, 5} |
| or not state["spindle"] |
| or not state["changed"] |
| or state["feed"] is None |
| or state["units"] != "mm" |
| or not state["absolute"] |
| or state["plane"] != "XY" |
| or state["wcs"] != 54 |
| or any(state[axis] is None for axis in ("X", "Y", "Z")) |
| or not (-68.1 <= state["X"] <= 68.1) |
| or not (-48.1 <= state["Y"] <= 48.1) |
| or not (-18.001 <= state["Z"] <= 5.001) |
| ): |
| return False |
| if state["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"], state["motion"], before) |
| ) |
| cutting_tools.add(state["tool"]) |
| 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 set(changed_tools) != set(EXPECTED_TOOLS): |
| return False |
| if spindle_tools != set(EXPECTED_TOOLS) or cutting_tools != set(EXPECTED_TOOLS): |
| return False |
| if len(cycles) != 12: |
| return False |
| for tool in (2, 3): |
| tool_cycles = [item for item in cycles if item[0] == tool] |
| if len(tool_cycles) != 6: |
| return False |
| if {(item[1], item[2]) for item in tool_cycles} != EXPECTED_HOLES[tool]: |
| return False |
| depths = {item[3] for item in tool_cycles} |
| if len(depths) != 1 or not -25.0 <= next(iter(depths)) <= -19.0: |
| return False |
| for cx, length, width, floor, tool in POCKET_NC_SPECS: |
| hits = [ |
| point |
| for point in cuts[tool] |
| if close(point[2], floor, 0.01) |
| and cx - length / 2.0 - 0.05 <= point[0] <= cx + length / 2.0 + 0.05 |
| and -width / 2.0 - 0.05 <= point[1] <= width / 2.0 + 0.05 |
| ] |
| if len(hits) < 2: |
| return False |
| profile = [point for point in cuts[1] if close(point[2], -18.0, 0.01)] |
| if len(profile) < 8: |
| return False |
| px = [point[0] for point in profile] |
| py = [point[1] for point in profile] |
| if not ( |
| close(min(px), -68.0, 0.05) |
| and close(max(px), 68.0, 0.05) |
| and close(min(py), -48.0, 0.05) |
| and close(max(py), 48.0, 0.05) |
| ): |
| return False |
| return True |
|
|
|
|
| CHILD_SOURCE = r''' |
| import builtins |
| import json |
| import math |
| import os |
| import pathlib |
| import re |
| import sys |
| import traceback |
| from collections import Counter |
| |
| builtins.pythonopen = open |
| |
| import FreeCAD as App |
| import Import |
| import Part |
| import Path.Post.Command as PathPostCommand |
| import Path.Tool.Bit as PathToolBit |
| from Path.Post.Processor import PostProcessor |
| |
| EXPECTED_VERSION = ("0", "21", "2", "33771 (Git)") |
| EXPECTED_COMMIT = "b9bfa5c5507506e4515816414cd27f4851d00489" |
| POCKETS = ( |
| ("P1", -48.0, 18.0, 18.0, 8.5, 4.0, 1, 16.0), |
| ("P2", -24.0, 18.0, 16.0, 6.0, 5.0, 4, 10.0), |
| ("P3", 0.0, 18.0, 14.0, 6.0, 6.0, 4, 10.0), |
| ("P4", 24.0, 18.0, 12.0, 5.5, 7.0, 4, 10.0), |
| ("P5", 48.0, 18.0, 10.0, 4.5, 8.0, 5, 8.0), |
| ) |
| HOLE_X = (-50.0, -30.0, -10.0, 10.0, 30.0, 50.0) |
| EXPECTED_HOLES = {2: {(x, 27.0) for x in HOLE_X}, 3: {(x, -27.0) for x in HOLE_X}} |
| CODE_WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))") |
| |
| |
| 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): |
| return getattr(getattr(obj, "Proxy", None).__class__, "__module__", "") |
| |
| |
| def same_shape(left, right, tolerance=1e-4): |
| return ( |
| left.isValid() |
| and right.isValid() |
| and left.cut(right).Volume <= tolerance |
| and right.cut(left).Volume <= tolerance |
| ) |
| |
| |
| def rounded_prism(cx, cy, length, width, radius, zmin, height): |
| parts = [] |
| if length - 2.0 * radius > 1e-9: |
| parts.append( |
| Part.makeBox( |
| length - 2.0 * radius, |
| width, |
| height, |
| App.Vector(cx - length / 2.0 + radius, cy - width / 2.0, zmin), |
| ) |
| ) |
| if width - 2.0 * radius > 1e-9: |
| parts.append( |
| Part.makeBox( |
| length, |
| width - 2.0 * radius, |
| height, |
| App.Vector(cx - length / 2.0, cy - width / 2.0 + radius, zmin), |
| ) |
| ) |
| centers = { |
| (cx + sx * (length / 2.0 - radius), cy + sy * (width / 2.0 - radius)) |
| for sx in (-1.0, 1.0) |
| for sy in (-1.0, 1.0) |
| } |
| parts.extend( |
| Part.makeCylinder(radius, height, App.Vector(x, y, zmin)) |
| for x, y in sorted(centers) |
| ) |
| result = parts[0] |
| for part in parts[1:]: |
| result = result.fuse(part) |
| return result.removeSplitter() |
| |
| |
| def expected_source_shape(): |
| shape = Part.makeBox(120.0, 80.0, 18.0, App.Vector(-60.0, -40.0, 0.0)) |
| for _, x, length, width, radius, depth, _, _ in POCKETS: |
| shape = shape.cut(rounded_prism(x, 0.0, length, width, radius, 18.0 - depth, depth)) |
| for x in HOLE_X: |
| shape = shape.cut(Part.makeCylinder(7.0, 18.0, App.Vector(x, 27.0, 0.0))) |
| shape = shape.cut(Part.makeCylinder(6.0, 18.0, App.Vector(x, -27.0, 0.0))) |
| return shape.removeSplitter() |
| |
| |
| def translated(shape, z): |
| result = shape.copy() |
| result.translate(App.Vector(0.0, 0.0, z)) |
| return result |
| |
| |
| def horizontal_floor(op, model): |
| try: |
| base = list(op.Base) |
| if len(base) != 1 or base[0][0] != model: |
| return None |
| names = list(base[0][1]) |
| if len(names) != 1 or not re.fullmatch(r"Face\d+", str(names[0])): |
| return None |
| face = getattr(model.Shape, str(names[0])) |
| if type(face.Surface).__name__ != "Plane": |
| return None |
| box = face.BoundBox |
| if not close(box.ZMin, box.ZMax): |
| return None |
| return face |
| except (AttributeError, TypeError, ValueError): |
| return None |
| |
| |
| def rounded_contains(x, y, cx, length, width, radius, shrink=0.0, tolerance=1e-6): |
| hx = length / 2.0 - shrink |
| hy = width / 2.0 - shrink |
| rr = radius - shrink |
| if hx <= 0.0 or hy <= 0.0 or rr < -tolerance: |
| return False |
| rr = max(0.0, rr) |
| qx = max(abs(x - cx) - max(0.0, hx - rr), 0.0) |
| qy = max(abs(y) - max(0.0, hy - rr), 0.0) |
| return qx * qx + qy * qy <= (rr + tolerance) * (rr + tolerance) |
| |
| |
| def sample_motion(op, spacing=0.35): |
| position = {"X": None, "Y": None, "Z": None} |
| samples = [] |
| motions = 0 |
| 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 not in {"G0", "G1", "G2", "G3"}: |
| continue |
| motions += 1 |
| if name == "G0": |
| if any(axis in command.Parameters for axis in ("X", "Y")): |
| effective_z = position["Z"] |
| if effective_z is None or effective_z < 2.0 - 1e-6: |
| return None |
| continue |
| if not all(before[axis] is not None and position[axis] is not None for axis in position): |
| continue |
| if name == "G1": |
| distance = math.sqrt( |
| sum((position[axis] - before[axis]) ** 2 for axis in ("X", "Y", "Z")) |
| ) |
| count = max(1, int(math.ceil(distance / spacing))) |
| for index in range(1, count + 1): |
| fraction = index / float(count) |
| samples.append( |
| ( |
| before["X"] + (position["X"] - before["X"]) * fraction, |
| before["Y"] + (position["Y"] - before["Y"]) * fraction, |
| before["Z"] + (position["Z"] - before["Z"]) * fraction, |
| ) |
| ) |
| continue |
| if "I" not in command.Parameters or "J" not in command.Parameters: |
| return None |
| center_x = before["X"] + float(command.Parameters["I"]) |
| center_y = before["Y"] + float(command.Parameters["J"]) |
| radius = math.hypot(before["X"] - center_x, before["Y"] - center_y) |
| if radius <= 1e-9: |
| return None |
| start = math.atan2(before["Y"] - center_y, before["X"] - center_x) |
| finish = math.atan2(position["Y"] - center_y, position["X"] - center_x) |
| if name == "G2": |
| while finish >= start: |
| finish -= 2.0 * math.pi |
| else: |
| while finish <= start: |
| finish += 2.0 * math.pi |
| sweep = finish - start |
| count = max(4, int(math.ceil(abs(sweep) * radius / spacing))) |
| for index in range(1, count + 1): |
| fraction = index / float(count) |
| angle = start + sweep * fraction |
| samples.append( |
| ( |
| center_x + radius * math.cos(angle), |
| center_y + radius * math.sin(angle), |
| before["Z"] + (position["Z"] - before["Z"]) * fraction, |
| ) |
| ) |
| return motions, samples |
| |
| |
| def validate_pocket_path(op, spec): |
| _, cx, length, width, radius, depth, _, diameter = spec |
| result = sample_motion(op) |
| if result is None: |
| return False |
| motions, samples = result |
| if motions < 5 or not samples: |
| return False |
| final_z = -depth |
| cutting = [point for point in samples if point[2] <= 1e-5] |
| if not cutting or min(point[2] for point in cutting) < final_z - 1e-4: |
| return False |
| tool_radius = diameter / 2.0 |
| if any( |
| not rounded_contains( |
| point[0], point[1], cx, length, width, radius, tool_radius, tolerance=0.03 |
| ) |
| for point in cutting |
| ): |
| return False |
| floor_samples = [point for point in cutting if close(point[2], final_z, 0.01)] |
| if len(floor_samples) < 3: |
| return False |
| grid = 0.75 |
| x = cx - length / 2.0 |
| targets = [] |
| while x <= cx + length / 2.0 + 1e-9: |
| y = -width / 2.0 |
| while y <= width / 2.0 + 1e-9: |
| if rounded_contains(x, y, cx, length, width, radius, tolerance=0.01): |
| targets.append((x, y)) |
| y += grid |
| x += grid |
| reach = tool_radius + 0.85 |
| for target_x, target_y in targets: |
| if min(math.hypot(target_x - px, target_y - py) for px, py, _ in floor_samples) > reach: |
| return False |
| return True |
| |
| |
| def drilling_cycles(op): |
| position = {"X": None, "Y": None, "Z": None} |
| active = False |
| cycle_z = None |
| cycle_r = None |
| records = [] |
| saw_cancel = False |
| retract = None |
| 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 {"G1", "G2", "G3"}: |
| return None |
| if name == "G98": |
| retract = 98 |
| elif name == "G99": |
| retract = 99 |
| if name == "G0" and any(axis in command.Parameters for axis in ("X", "Y")): |
| if position["Z"] is None or position["Z"] < 2.0 - 1e-6: |
| return None |
| if name in {"G81", "G82", "G83"}: |
| active = True |
| if "Z" in command.Parameters: |
| cycle_z = float(command.Parameters["Z"]) |
| if "R" in command.Parameters: |
| cycle_r = float(command.Parameters["R"]) |
| if ( |
| position["X"] is None |
| or position["Y"] is None |
| or cycle_z is None |
| or cycle_r is None |
| or retract != 98 |
| ): |
| return None |
| if name == "G82" and ("P" not in command.Parameters or float(command.Parameters["P"]) < 0): |
| return None |
| if name == "G83" and ("Q" not in command.Parameters or float(command.Parameters["Q"]) <= 0): |
| return None |
| records.append((position["X"], position["Y"], cycle_z, cycle_r)) |
| position["Z"] = before["Z"] if retract == 98 else cycle_r |
| elif active and name == "G80": |
| active = False |
| saw_cancel = True |
| elif active and name != "G0" and any( |
| axis in command.Parameters for axis in ("X", "Y") |
| ): |
| if position["X"] is None or position["Y"] is None or retract != 98: |
| return None |
| records.append((position["X"], position["Y"], cycle_z, cycle_r)) |
| position["Z"] = before["Z"] if retract == 98 else cycle_r |
| elif active and name not in {"G0", "G98", "G99"} and any( |
| axis in command.Parameters for axis in ("X", "Y", "Z") |
| ): |
| return None |
| if active or not saw_cancel: |
| return None |
| return records |
| |
| |
| def validate_profile_path(op): |
| result = sample_motion(op) |
| if result is None: |
| return False |
| motions, samples = result |
| if motions < 20 or not samples: |
| return False |
| cutting = [point for point in samples if point[2] <= 1e-5] |
| if not cutting or min(point[2] for point in cutting) < -18.0001: |
| return False |
| final = [point for point in cutting if close(point[2], -18.0, 0.01)] |
| if len(final) < 100: |
| return False |
| if any(not (-68.05 <= x <= 68.05 and -48.05 <= y <= 48.05) for x, y, _ in final): |
| return False |
| xs = [point[0] for point in final] |
| ys = [point[1] for point in final] |
| if not ( |
| close(min(xs), -68.0, 0.05) |
| and close(max(xs), 68.0, 0.05) |
| and close(min(ys), -48.0, 0.05) |
| and close(max(ys), 48.0, 0.05) |
| ): |
| return False |
| for target in ((-68.0, 0.0), (68.0, 0.0), (0.0, -48.0), (0.0, 48.0)): |
| if min(math.hypot(x - target[0], y - target[1]) for x, y, _ in final) > 0.75: |
| return False |
| return True |
| |
| |
| def expected_tool(doc, number, kind, diameter): |
| attrs = { |
| "version": 2, |
| "name": "Evaluator T%d" % number, |
| "shape": "drill.fcstd" if kind == "drill" else "endmill.fcstd", |
| "parameter": { |
| "Diameter": "%g mm" % diameter, |
| "Length": "60 mm", |
| }, |
| "attribute": {}, |
| } |
| if kind == "drill": |
| attrs["parameter"]["TipAngle"] = "118 deg" |
| else: |
| attrs["parameter"]["ShankDiameter"] = "%g mm" % diameter |
| attrs["parameter"]["CuttingEdgeHeight"] = "24 mm" |
| return PathToolBit.Factory.CreateFromAttrs(attrs, "EvaluatorTool%d" % number) |
| |
| |
| 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 code_signature(path): |
| try: |
| executable = strip_comments(pathlib.Path(path).read_text(encoding="utf-8")) |
| except (OSError, UnicodeError): |
| return None |
| if executable is None: |
| return None |
| result = [] |
| for raw in executable.splitlines(): |
| line = raw.strip().upper() |
| if not line or line == "%": |
| continue |
| words = [] |
| cursor = 0 |
| for match in CODE_WORD_RE.finditer(line): |
| if line[cursor : match.start()].strip(): |
| return None |
| if match.group(1) != "N": |
| value = float(match.group(2)) |
| if not math.isfinite(value): |
| return None |
| 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 validate(step_path, fcstd_path, nc_path, repost_path): |
| if tuple(App.Version()[:4]) != EXPECTED_VERSION or App.Version()[-1] != EXPECTED_COMMIT: |
| return False |
| expected_source = expected_source_shape() |
| if ( |
| not expected_source.isValid() |
| or len(expected_source.Solids) != 1 |
| or not close(expected_source.Volume, 137669.0182180575, 1e-4) |
| ): |
| return False |
| source_doc = App.newDocument("Task19SourceCheck") |
| try: |
| Import.insert(str(step_path), source_doc.Name) |
| source_doc.recompute() |
| source_shapes = [ |
| obj.Shape |
| for obj in source_doc.Objects |
| if hasattr(obj, "Shape") and not obj.Shape.isNull() |
| ] |
| if len(source_shapes) != 1: |
| return False |
| source_shape = source_shapes[0] |
| bounds = source_shape.BoundBox |
| if ( |
| len(source_shape.Solids) != 1 |
| or not same_shape(source_shape, expected_source) |
| or not all( |
| close(actual, wanted) |
| for actual, wanted in zip( |
| (bounds.XMin, bounds.XMax, bounds.YMin, bounds.YMax, bounds.ZMin, bounds.ZMax), |
| (-60.0, 60.0, -40.0, 40.0, 0.0, 18.0), |
| ) |
| ) |
| ): |
| return False |
| finally: |
| App.closeDocument(source_doc.Name) |
| |
| doc = App.openDocument(str(fcstd_path)) |
| try: |
| jobs = [obj for obj in doc.Objects if module(obj) == "Path.Main.Job"] |
| pockets = [obj for obj in doc.Objects if module(obj) == "Path.Op.PocketShape"] |
| drills = [obj for obj in doc.Objects if module(obj) == "Path.Op.Drilling"] |
| profiles = [obj for obj in doc.Objects if module(obj) == "Path.Op.Profile"] |
| 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"] |
| if not ( |
| len(jobs) == 1 |
| and len(pockets) == 5 |
| and len(drills) == 2 |
| and len(profiles) == 1 |
| and len(controllers) == 5 |
| and len(tools) == 5 |
| ): |
| return False |
| job = jobs[0] |
| operations = list(job.Operations.Group) |
| if len(operations) != 8 or set(operations) != set(pockets + drills + profiles): |
| return False |
| if ( |
| len(job.Model.Group) != 1 |
| or str(job.PostProcessor).strip().lower() != "linuxcnc" |
| or list(job.Fixtures) != ["G54"] |
| or bool(job.SplitOutput) |
| or os.path.normpath(str(job.PostProcessorOutputFile)) |
| != "/home/user/Desktop/task-19.nc" |
| ): |
| return False |
| model = job.Model.Group[0] |
| expected_model = translated(expected_source, -18.0) |
| if module(model) != "draftobjects.clone" or not same_shape(model.Shape, expected_model): |
| return False |
| source_links = list(getattr(model, "Objects", [])) |
| if len(source_links) != 1 or not same_shape(source_links[0].Shape, expected_source): |
| return False |
| stock = job.Stock |
| expected_stock = Part.makeBox(124.0, 84.0, 18.0, App.Vector(-62.0, -42.0, -18.0)) |
| if ( |
| module(stock) != "Path.Main.Stock" |
| or not same_shape(stock.Shape, expected_stock) |
| or not close(stock.ExtXneg, 2.0) |
| or not close(stock.ExtXpos, 2.0) |
| or not close(stock.ExtYneg, 2.0) |
| or not close(stock.ExtYpos, 2.0) |
| or not close(stock.ExtZneg, 0.0) |
| or not close(stock.ExtZpos, 0.0) |
| ): |
| return False |
| by_number = {int(controller.ToolNumber): controller for controller in controllers} |
| if set(by_number) != {1, 2, 3, 4, 5}: |
| return False |
| if [int(controller.ToolNumber) for controller in job.Tools.Group] != [1, 2, 3, 4, 5]: |
| return False |
| tool_specs = { |
| 1: ("end mill", 16.0), |
| 2: ("drill", 14.0), |
| 3: ("drill", 12.0), |
| 4: ("end mill", 10.0), |
| 5: ("end mill", 8.0), |
| } |
| temporary = [] |
| for number, (kind, diameter) in tool_specs.items(): |
| controller = by_number[number] |
| tool = controller.Tool |
| if tool not in tools or any(other.Tool == tool for n, other in by_number.items() if n != number): |
| return False |
| shape_name = "drill" if kind == "drill" else "endmill" |
| if ( |
| not close(tool.Diameter, diameter) |
| or str(tool.ShapeName).strip().lower() != shape_name |
| or os.path.basename(str(tool.BitShape)).lower() != shape_name + ".fcstd" |
| or tool.Shape.isNull() |
| or len(tool.Shape.Solids) != 1 |
| or not close(tool.Length, 60.0) |
| 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) |
| ): |
| return False |
| if kind == "drill": |
| if not close(tool.TipAngle, 118.0): |
| return False |
| elif not close(tool.ShankDiameter, diameter) or not close(tool.CuttingEdgeHeight, 24.0): |
| return False |
| reference = expected_tool(doc, number, kind, diameter) |
| temporary.append(reference) |
| doc.recompute() |
| if not same_shape(tool.Shape, reference.Shape): |
| return False |
| for reference in temporary: |
| doc.removeObject(reference.Name) |
| doc.recompute() |
| |
| matched = {} |
| for pocket in pockets: |
| if not bool(pocket.Active) or pocket.ToolController not in controllers: |
| return False |
| face = horizontal_floor(pocket, model) |
| if face is None: |
| return False |
| box = face.BoundBox |
| candidates = [ |
| spec |
| for spec in POCKETS |
| if close(face.CenterOfMass.x, spec[1], 1e-4) |
| and close(face.CenterOfMass.y, 0.0, 1e-4) |
| and close(box.ZMin, -spec[5], 1e-5) |
| ] |
| if len(candidates) != 1: |
| return False |
| spec = candidates[0] |
| if spec[0] in matched: |
| return False |
| matched[spec[0]] = pocket |
| if ( |
| pocket.ToolController != by_number[spec[6]] |
| or pocket.ToolController.Tool.Diameter.Value > min(spec[2], spec[3]) + 1e-7 |
| or not close(pocket.StartDepth, 0.0) |
| or not close(pocket.FinalDepth, -spec[5]) |
| or not close(pocket.StepDown.Value, 2.0) |
| or not close(float(pocket.StepOver), 50.0) |
| or not close(pocket.SafeHeight.Value, 3.0) |
| or not close(pocket.ClearanceHeight.Value, 5.0) |
| or bool(pocket.UseOutline) |
| or not validate_pocket_path(pocket, spec) |
| ): |
| return False |
| if set(matched) != {spec[0] for spec in POCKETS}: |
| return False |
| |
| drill_by_tool = {} |
| for drill in drills: |
| controller = drill.ToolController |
| if controller not in controllers or int(controller.ToolNumber) not in {2, 3}: |
| return False |
| number = int(controller.ToolNumber) |
| if number in drill_by_tool: |
| return False |
| drill_by_tool[number] = drill |
| records = drilling_cycles(drill) |
| if records is None or len(records) != 6: |
| return False |
| if {(round(x, 4), round(y, 4)) for x, y, _, _ in records} != EXPECTED_HOLES[number]: |
| return False |
| depths = {round(z, 4) for _, _, z, _ in records} |
| retracts = {round(r, 4) for _, _, _, r in records} |
| if ( |
| len(depths) != 1 |
| or not -25.0 <= next(iter(depths)) <= -19.0 |
| or len(retracts) != 1 |
| or not 1.9 <= next(iter(retracts)) <= 5.1 |
| or not bool(drill.Active) |
| or not close(drill.StartDepth, 0.0) |
| or not close(drill.FinalDepth, -19.0) |
| or not close(drill.RetractHeight, 2.0) |
| or str(drill.RetractMode) != "G98" |
| or str(drill.ExtraOffset) != "Drill Tip" |
| or not close(drill.SafeHeight.Value, 3.0) |
| or not close(drill.ClearanceHeight.Value, 5.0) |
| or bool(drill.KeepToolDown) |
| ): |
| return False |
| if set(drill_by_tool) != {2, 3}: |
| return False |
| |
| profile = profiles[0] |
| if ( |
| profile.ToolController != by_number[1] |
| or not bool(profile.Active) |
| or str(profile.Side) != "Outside" |
| or not bool(profile.UseComp) |
| or not bool(profile.processPerimeter) |
| or bool(profile.processHoles) |
| or bool(profile.processCircles) |
| or not close(profile.StartDepth, 0.0) |
| or not close(profile.FinalDepth, -18.0) |
| or not close(profile.StepDown.Value, 3.0) |
| or str(profile.Direction) != "CW" |
| or not close(profile.SafeHeight.Value, 3.0) |
| or not close(profile.ClearanceHeight.Value, 5.0) |
| or not validate_profile_path(profile) |
| ): |
| return False |
| |
| expected_operations = [ |
| matched["P1"], |
| drill_by_tool[2], |
| drill_by_tool[3], |
| matched["P2"], |
| matched["P3"], |
| matched["P4"], |
| matched["P5"], |
| profile, |
| ] |
| if operations != expected_operations: |
| return False |
| |
| operation_tools = Counter(int(op.ToolController.ToolNumber) for op in operations) |
| if operation_tools != Counter({1: 2, 2: 1, 3: 1, 4: 3, 5: 1}): |
| return False |
| if any(count > 4 for count in operation_tools.values()): |
| return False |
| for obj in controllers + operations + [job]: |
| obj.touch() |
| doc.recompute() |
| doc.recompute() |
| if any(list(op.State) != ["Up-to-date"] or len(op.Path.Commands) == 0 for op in operations): |
| return False |
| for pocket in pockets: |
| spec = next(spec for spec in POCKETS if matched[spec[0]] == pocket) |
| if not validate_pocket_path(pocket, spec): |
| return False |
| if any(drilling_cycles(drill) is None for drill in drills) or not validate_profile_path(profile): |
| return False |
| sections = PathPostCommand.buildPostList(job) |
| if len(sections) != 1: |
| return False |
| PostProcessor.load("linuxcnc").export( |
| sections[0][1], str(repost_path), job.PostProcessorArgs |
| ) |
| repost_signature = code_signature(repost_path) |
| submitted_signature = code_signature(nc_path) |
| return repost_signature is not None and repost_signature == submitted_signature |
| finally: |
| App.closeDocument(doc.Name) |
| |
| |
| ok = False |
| try: |
| ok = validate( |
| pathlib.Path(os.environ["TASK19_STEP"]), |
| pathlib.Path(os.environ["TASK19_FCSTD"]), |
| pathlib.Path(os.environ["TASK19_NC"]), |
| pathlib.Path(os.environ["TASK19_REPOST"]), |
| ) |
| except Exception as error: |
| print("task-19 child: %s" % error, file=sys.stderr) |
| traceback.print_exc() |
| pathlib.Path(os.environ["TASK19_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, workdir): |
| child = workdir / "validate_task19.py" |
| repost = workdir / "repost.nc" |
| result_file = workdir / "result.json" |
| child.write_text(CHILD_SOURCE, encoding="utf-8") |
| child.chmod(0o600) |
| 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={ |
| "HOME": str(workdir), |
| "LANG": "C.UTF-8", |
| "LC_ALL": "C.UTF-8", |
| "PATH": "/usr/bin:/bin", |
| "TMPDIR": str(workdir), |
| "TASK19_STEP": str(step_path), |
| "TASK19_FCSTD": str(fcstd_path), |
| "TASK19_NC": str(nc_path), |
| "TASK19_REPOST": str(repost), |
| "TASK19_RESULT": str(result_file), |
| }, |
| ) |
| 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[-5000:], file=sys.stderr) |
| return False |
| return regular_file(repost, 5_000, 2_000_000) |
|
|
|
|
| def main(): |
| if not FREECADCMD.is_file(): |
| return fail("freecadcmd missing") |
| if not validate_csv(CSV_FILE): |
| return fail("wrong tool_candidates.csv") |
| if not regular_file(STEP, 5_000, 5_000_000): |
| return fail("invalid STEP file") |
| if normalized_text_sha256(STEP) != EXPECTED_STEP_SHA256: |
| return fail("wrong init STEP") |
| if not validate_archive(FCSTD): |
| return fail("invalid FCStd archive") |
| if not validate_nc(NC): |
| return fail("invalid NC semantics") |
| with tempfile.TemporaryDirectory(prefix="task-19-eval-") as directory: |
| workdir = Path(directory) |
| frozen_step = workdir / "complex_pockets.step" |
| frozen_csv = workdir / "tool_candidates.csv" |
| frozen_fcstd = workdir / "task-19.FCStd" |
| frozen_nc = workdir / "task-19.nc" |
| if not freeze_file(STEP, frozen_step, 5_000, 5_000_000): |
| return fail("could not freeze STEP") |
| if not freeze_file(CSV_FILE, frozen_csv, 100, 10_000): |
| return fail("could not freeze CSV") |
| if not freeze_file(FCSTD, frozen_fcstd, 20_000, 20_000_000): |
| return fail("could not freeze FCStd") |
| if not freeze_file(NC, frozen_nc, 5_000, 2_000_000): |
| return fail("could not freeze NC") |
| if not validate_csv(frozen_csv): |
| return fail("CSV changed during evaluation") |
| if normalized_text_sha256(frozen_step) != EXPECTED_STEP_SHA256: |
| return fail("STEP changed during evaluation") |
| if not validate_freecad(frozen_step, frozen_fcstd, frozen_nc, workdir): |
| return fail("FreeCAD validation failed") |
| return True |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| result = main() |
| except Exception as error: |
| print("task-19 evaluator exception: " + str(error), file=sys.stderr) |
| result = False |
| print(True if result else False) |
|
|
