| from __future__ import annotations |
|
|
| import json |
| import hashlib |
| 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 |
|
|
|
|
| TARGET = Path("/home/user/Desktop") |
| FREECADCMD = Path("/usr/bin/freecadcmd") |
| EXPECTED_VERSION = ("0", "21", "2", "33771 (Git)") |
| EXPECTED_COMMIT = "b9bfa5c5507506e4515816414cd27f4851d00489" |
| EXPECTED_STEP_SHA256 = "08326459e03c3a8bc2d6f9b20ae795f797f4d269552398c8158bb90ee3863be1" |
| EXPECTED_CONFIG = { |
| "task": "task-12", |
| "unit": "mm", |
| "coordinate_system": "G54", |
| "postprocessor": "linuxcnc", |
| "post_arguments": ["--line-numbers", "--no-show-editor"], |
| "sequence_numbers": True, |
| "sequence_start": 110, |
| "sequence_increment": 10, |
| "program_number": None, |
| "program_end": "M2", |
| "part": { |
| "stock_size": [120, 80, 18], |
| "stock_bounds": {"x": [-60, 60], "y": [-40, 40], "z": [0, 18]}, |
| "pocket": { |
| "center": [0, 0], |
| "size": [40, 24], |
| "top_z": 18, |
| "bottom_z": 13, |
| "depth": 5, |
| }, |
| "holes": { |
| "diameter": 5, |
| "top_z": 18, |
| "bottom_z": 10, |
| "depth": 8, |
| "centers": [[-40, -25], [-40, 25], [40, -25], [40, 25]], |
| }, |
| }, |
| "tools": [ |
| { |
| "tool": 1, |
| "name": "flat end mill", |
| "diameter": 6, |
| "spindle": 7000, |
| "feed": 600, |
| "operations": ["pocket_shape"], |
| }, |
| { |
| "tool": 2, |
| "name": "drill", |
| "diameter": 5, |
| "spindle": 7000, |
| "feed": 600, |
| "operations": ["drilling"], |
| }, |
| ], |
| "operations": ["PocketShape", "Drilling"], |
| "operation_settings": { |
| "pocket_shape": { |
| "step_down": 5, |
| "step_over_percent": 50, |
| "safe_height": 20, |
| "clearance_height": 23, |
| "offset_pattern": "ZigZag", |
| "start_at": "Center", |
| "cut_mode": "Climb", |
| }, |
| "drilling": { |
| "cycle": "G81", |
| "safe_height": 20, |
| "clearance_height": 23, |
| "retract_height": 20, |
| "peck": False, |
| "dwell": False, |
| "keep_tool_down": False, |
| }, |
| }, |
| "outputs": [ |
| "/home/user/Desktop/task-12.FCStd", |
| "/home/user/Desktop/task-12.nc", |
| ], |
| } |
| WORD_RE = re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))", re.ASCII) |
| TIMESTAMP_RE = re.compile(r"\(Output Time:[^()\r\n]*\)") |
| HOLE_CENTERS = {(-40.0, -25.0), (-40.0, 25.0), (40.0, -25.0), (40.0, 25.0)} |
| ALLOWED_G_CODES = {0, 1, 2, 3, 17, 21, 40, 43, 49, 54, 80, 81, 90, 98} |
| ALLOWED_M_CODES = {2, 3, 5, 6} |
| REQUIRED_PROXY_RECORDS = Counter( |
| { |
| ("Path.Main.Job", "ObjectJob", "bnVsbA==", "yes"): 1, |
| ("Path.Tool.Controller", "ToolController", "e30=", "yes"): 2, |
| ("Path.Tool.Bit", "ToolBit", "bnVsbA==", "yes"): 2, |
| ("Path.Op.PocketShape", "ObjectPocket", "bnVsbA==", "yes"): 1, |
| ("Path.Op.Drilling", "ObjectDrilling", "bnVsbA==", "yes"): 1, |
| } |
| ) |
| OPTIONAL_PROXY_RECORDS = { |
| ("Path.Base.SetupSheet", "SetupSheet", "bnVsbA==", "yes"), |
| ("draftobjects.clone", "Clone", "IkNsb25lIg==", "yes"), |
| } |
| STOCK_PROXY_RECORDS = { |
| ("Path.Main.Stock", "StockFromBase", "bnVsbA==", "yes"), |
| ("Path.Main.Stock", "StockCreateBox", "bnVsbA==", "yes"), |
| ("Path.Main.Stock", "StockCreateCylinder", "bnVsbA==", "yes"), |
| } |
|
|
|
|
| def fail(message: str) -> bool: |
| print("task-12 evaluator: " + message, file=sys.stderr) |
| return False |
|
|
|
|
| def close(a: float, b: float, tolerance: float = 1e-6) -> bool: |
| return math.isfinite(a) and abs(a - b) <= tolerance |
|
|
|
|
| def ensure_regular(path: Path, minimum: int, maximum: int) -> bool: |
| 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 normalized_text_sha256(path: Path) -> str: |
| data = path.read_bytes().replace(b"\r\n", b"\n").replace(b"\r", b"\n") |
| return hashlib.sha256(data).hexdigest() |
|
|
|
|
| def strict_equal(actual: object, expected: object) -> bool: |
| if type(actual) is not type(expected): |
| return False |
| if isinstance(expected, dict): |
| return actual.keys() == expected.keys() and all( |
| strict_equal(actual[key], expected[key]) for key in expected |
| ) |
| if isinstance(expected, list): |
| return len(actual) == len(expected) and all( |
| strict_equal(left, right) for left, right in zip(actual, expected) |
| ) |
| return actual == expected |
|
|
|
|
| def reject_duplicate_keys(pairs: list[tuple[str, object]]) -> dict: |
| result = {} |
| for key, value in pairs: |
| if key in result: |
| raise ValueError("duplicate JSON key") |
| result[key] = value |
| return result |
|
|
|
|
| def load_config(path: Path) -> dict | None: |
| if not ensure_regular(path, 200, 50_000): |
| return None |
| try: |
| value = json.loads( |
| path.read_text(encoding="utf-8"), object_pairs_hook=reject_duplicate_keys |
| ) |
| except (OSError, UnicodeError, json.JSONDecodeError, ValueError): |
| return None |
| return value if strict_equal(value, EXPECTED_CONFIG) else None |
|
|
|
|
| def strip_comments(line: str) -> str | None: |
| output: list[str] = [] |
| depth = 0 |
| for character in line: |
| if depth == 0 and character == ";": |
| break |
| if character == "(": |
| depth += 1 |
| continue |
| if character == ")": |
| if depth == 0: |
| return None |
| depth -= 1 |
| continue |
| if depth == 0: |
| output.append(character) |
| if depth: |
| return None |
| return "".join(output).strip().upper() |
|
|
|
|
| def parse_words(code: str) -> list[tuple[str, float]] | None: |
| if not code: |
| return [] |
| matches = list(WORD_RE.finditer(code)) |
| residue = WORD_RE.sub("", code).replace("%", "") |
| if residue.strip(): |
| return None |
| words: list[tuple[str, float]] = [] |
| for match in matches: |
| try: |
| number = float(match.group(2)) |
| except ValueError: |
| return None |
| if not math.isfinite(number): |
| return None |
| words.append((match.group(1), number)) |
| return words |
|
|
|
|
| def integral_code(value: float) -> int | None: |
| rounded = round(value) |
| if abs(value - rounded) > 1e-9: |
| return None |
| return int(rounded) |
|
|
|
|
| def point_segment_distance( |
| px: float, py: float, segment: tuple[float, float, float, float] |
| ) -> float: |
| x1, y1, x2, y2 = segment |
| dx = x2 - x1 |
| dy = y2 - y1 |
| denominator = dx * dx + dy * dy |
| if denominator <= 1e-18: |
| return math.hypot(px - x1, py - y1) |
| factor = max(0.0, min(1.0, ((px - x1) * dx + (py - y1) * dy) / denominator)) |
| return math.hypot(px - (x1 + factor * dx), py - (y1 + factor * dy)) |
|
|
|
|
| def validate_pocket_segments( |
| segments: list[tuple[float, float, float, float]] |
| ) -> bool: |
| if len(segments) < 20: |
| return False |
| points = [(segment[0], segment[1]) for segment in segments] |
| points.extend((segment[2], segment[3]) for segment in segments) |
| if any( |
| x < -17.01 or x > 17.01 or y < -9.01 or y > 9.01 |
| for x, y in points |
| ): |
| return False |
| if not ( |
| min(x for x, _ in points) <= -16.99 |
| and max(x for x, _ in points) >= 16.99 |
| and min(y for _, y in points) <= -8.99 |
| and max(y for _, y in points) >= 8.99 |
| ): |
| return False |
| |
| |
| for grid_y in range(-9, 10, 2): |
| for grid_x in range(-17, 18, 2): |
| if min( |
| point_segment_distance(float(grid_x), float(grid_y), segment) |
| for segment in segments |
| ) > 2.2: |
| return False |
| return True |
|
|
|
|
| def validate_nc_text(text: str) -> bool: |
| if not text or "\x00" in text or len(text.encode("utf-8")) > 200_000: |
| return False |
| numbered: list[int] = [] |
| parsed_lines: list[list[tuple[str, float]]] = [] |
| for raw_line in text.splitlines(): |
| code = strip_comments(raw_line) |
| if code is None: |
| return False |
| words = parse_words(code) |
| if words is None: |
| return False |
| n_values = [number for letter, number in words if letter == "N"] |
| if len(n_values) > 1: |
| return False |
| if n_values: |
| if not code.lstrip().startswith("N"): |
| return False |
| n_code = integral_code(n_values[0]) |
| if n_code is None or n_code < 0: |
| return False |
| numbered.append(n_code) |
| executable = [(letter, value) for letter, value in words if letter != "N"] |
| if executable and not n_values: |
| |
| |
| if not ( |
| len(executable) == 2 |
| and executable[0][0] == "G" |
| and integral_code(executable[0][1]) == 43 |
| and executable[1][0] == "H" |
| and integral_code(executable[1][1]) in {1, 2} |
| ): |
| return False |
| parsed_lines.append(executable) |
|
|
| if len(numbered) < 30 or numbered[0] != 110: |
| return False |
| if any(next_number - number != 10 for number, next_number in zip(numbered, numbered[1:])): |
| return False |
|
|
| metric = False |
| absolute = False |
| current_tool: int | None = None |
| pending_tool: int | None = None |
| spindle = 0.0 |
| spindle_on = False |
| feed: float | None = None |
| motion: int | None = None |
| position: dict[str, float | None] = {"X": None, "Y": None, "Z": None} |
| pocket_segments: list[tuple[float, float, float, float]] = [] |
| drill_cycles: list[tuple[float, float, float, float]] = [] |
| g80_after_cycles = False |
| m2_count = 0 |
| seen_t1 = False |
| seen_t2 = False |
|
|
| for words in parsed_lines: |
| by_letter: dict[str, list[float]] = {} |
| for letter, value in words: |
| by_letter.setdefault(letter, []).append(value) |
| if any(letter not in {"G", "M", "T", "S", "F", "X", "Y", "Z", "R", "H"} for letter in by_letter): |
| return False |
| if "O" in by_letter: |
| return False |
| g_codes: list[int] = [] |
| for value in by_letter.get("G", []): |
| code = integral_code(value) |
| if code is None or code not in ALLOWED_G_CODES: |
| return False |
| g_codes.append(code) |
| m_codes: list[int] = [] |
| for value in by_letter.get("M", []): |
| code = integral_code(value) |
| if code is None or code not in ALLOWED_M_CODES: |
| return False |
| m_codes.append(code) |
| if 20 in g_codes or 91 in g_codes: |
| return False |
| if 21 in g_codes: |
| metric = True |
| if 90 in g_codes: |
| absolute = True |
| if any(code in {0, 1, 2, 3, 81, 82, 83, 73} for code in g_codes): |
| motion = next(code for code in g_codes if code in {0, 1, 2, 3, 81, 82, 83, 73}) |
| if "T" in by_letter: |
| if len(by_letter["T"]) != 1: |
| return False |
| pending_tool = integral_code(by_letter["T"][0]) |
| if pending_tool not in {1, 2}: |
| return False |
| if 6 in m_codes: |
| if pending_tool is None: |
| return False |
| current_tool = pending_tool |
| if current_tool == 1: |
| seen_t1 = True |
| if current_tool == 2: |
| seen_t2 = True |
| if "S" in by_letter: |
| if len(by_letter["S"]) != 1: |
| return False |
| spindle = by_letter["S"][0] |
| if 3 in m_codes: |
| spindle_on = True |
| if 5 in m_codes: |
| spindle_on = False |
| if "F" in by_letter: |
| if len(by_letter["F"]) != 1 or by_letter["F"][0] <= 0: |
| return False |
| feed = by_letter["F"][0] |
| old = position.copy() |
| for axis in ("X", "Y", "Z"): |
| if axis in by_letter: |
| if len(by_letter[axis]) != 1: |
| return False |
| position[axis] = by_letter[axis][0] |
|
|
| if motion == 0 and any(axis in by_letter for axis in ("X", "Y", "Z")): |
| if not metric or not absolute or current_tool not in {1, 2} or not spindle_on: |
| return False |
| if not close(spindle, 7000.0): |
| return False |
| if position["Z"] is None or float(position["Z"]) < 19.99: |
| return False |
| if position["X"] is not None and not (-60.01 <= float(position["X"]) <= 60.01): |
| return False |
| if position["Y"] is not None and not (-40.01 <= float(position["Y"]) <= 40.01): |
| return False |
|
|
| if motion in {1, 2, 3} and any(axis in by_letter for axis in ("X", "Y", "Z")): |
| if not metric or not absolute or current_tool not in {1, 2}: |
| return False |
| if not spindle_on or not close(spindle, 7000.0, 1e-6): |
| return False |
| if current_tool == 1: |
| if feed is None or not close(feed, 600.0, 1e-6): |
| return False |
| z_value = position["Z"] |
| if z_value is None or z_value < 12.99: |
| return False |
| if close(z_value, 13.0, 1e-6): |
| if None not in (old["X"], old["Y"], position["X"], position["Y"]): |
| pocket_segments.append( |
| ( |
| float(old["X"]), |
| float(old["Y"]), |
| float(position["X"]), |
| float(position["Y"]), |
| ) |
| ) |
| elif current_tool == 2 and motion in {1, 2, 3}: |
| |
| return False |
|
|
| if any(code in {82, 83, 73} for code in g_codes): |
| return False |
| if motion == 81 and 81 in g_codes: |
| if not metric or not absolute or current_tool != 2 or not spindle_on: |
| return False |
| if not close(spindle, 7000.0) or feed is None or not close(feed, 600.0): |
| return False |
| required = {axis: by_letter.get(axis, []) for axis in ("X", "Y", "Z", "R")} |
| if any(len(values) != 1 for values in required.values()): |
| return False |
| x_value, y_value, z_value, r_value = ( |
| required[axis][0] for axis in ("X", "Y", "Z", "R") |
| ) |
| drill_cycles.append((x_value, y_value, z_value, r_value)) |
| position["Z"] = r_value |
| g80_after_cycles = False |
| if 80 in g_codes and drill_cycles: |
| g80_after_cycles = True |
| if 30 in m_codes: |
| return False |
| if 2 in m_codes: |
| m2_count += 1 |
|
|
| if not seen_t1 or not seen_t2 or m2_count != 1 or not g80_after_cycles: |
| return False |
| if not validate_pocket_segments(pocket_segments): |
| return False |
| if len(drill_cycles) != 4: |
| return False |
| observed_centers = {(round(x, 6), round(y, 6)) for x, y, _, _ in drill_cycles} |
| if observed_centers != HOLE_CENTERS: |
| return False |
| if any(not close(z_value, 10.0) or not close(r_value, 20.0) for _, _, z_value, r_value in drill_cycles): |
| return False |
| return True |
|
|
|
|
| def validate_nc_file(path: Path) -> bool: |
| if not ensure_regular(path, 500, 200_000): |
| return False |
| try: |
| return validate_nc_text(path.read_text(encoding="utf-8")) |
| except (OSError, UnicodeError): |
| return False |
|
|
|
|
| def canonical_nc(text: str) -> str: |
| return TIMESTAMP_RE.sub("(Output Time:<TIMESTAMP>)", text).replace("\r\n", "\n") |
|
|
|
|
| def validate_fcstd_archive(path: Path) -> bool: |
| if not ensure_regular(path, 2_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(): |
| pure = Path(entry.filename) |
| if pure.is_absolute() or ".." in pure.parts: |
| return False |
| total += entry.file_size |
| if entry.file_size > 20_000_000 or total > 50_000_000: |
| return False |
| if pure.suffix.lower() in {".py", ".pyc", ".so", ".dll", ".dylib"}: |
| return False |
| document = archive.read("Document.xml") |
| if len(document) > 5_000_000: |
| return False |
| root = ET.fromstring(document) |
| proxies = Counter( |
| ( |
| element.attrib.get("module"), |
| element.attrib.get("class"), |
| element.attrib.get("value"), |
| element.attrib.get("encoded"), |
| ) |
| for element in root.iter("Python") |
| ) |
| if any(proxies[record] != count for record, count in REQUIRED_PROXY_RECORDS.items()): |
| return False |
| if sum(proxies[record] for record in STOCK_PROXY_RECORDS) != 1: |
| return False |
| allowed = set(REQUIRED_PROXY_RECORDS) | OPTIONAL_PROXY_RECORDS | STOCK_PROXY_RECORDS |
| if any(record not in allowed or count != 1 for record, count in proxies.items() if record not in REQUIRED_PROXY_RECORDS): |
| return False |
| except (OSError, zipfile.BadZipFile, RuntimeError, ET.ParseError): |
| return False |
| return True |
|
|
|
|
| CHILD_SOURCE = r''' |
| from __future__ import annotations |
| |
| import hashlib |
| import json |
| import math |
| import pathlib |
| import re |
| import 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 = "08326459e03c3a8bc2d6f9b20ae795f797f4d269552398c8158bb90ee3863be1" |
| HOLES = {(-40.0, -25.0), (-40.0, 25.0), (40.0, -25.0), (40.0, 25.0)} |
| TIMESTAMP_RE = re.compile(r"\(Output Time:[^()\r\n]*\)") |
| |
| |
| def close(a, b, tolerance=1e-6): |
| return math.isfinite(float(a)) and abs(float(a) - float(b)) <= tolerance |
| |
| |
| 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 bounds(shape): |
| box = shape.BoundBox |
| return (box.XMin, box.XMax, box.YMin, box.YMax, box.ZMin, box.ZMax) |
| |
| |
| def point_segment_distance(px, py, segment): |
| x1, y1, x2, y2 = segment |
| dx = x2 - x1 |
| dy = y2 - y1 |
| denominator = dx * dx + dy * dy |
| if denominator <= 1e-18: |
| return math.hypot(px - x1, py - y1) |
| factor = max(0.0, min(1.0, ((px - x1) * dx + (py - y1) * dy) / denominator)) |
| return math.hypot(px - (x1 + factor * dx), py - (y1 + factor * dy)) |
| |
| |
| def validate_segments(segments): |
| if len(segments) < 20: |
| return False |
| points = [(s[0], s[1]) for s in segments] + [(s[2], s[3]) for s in segments] |
| if any(x < -17.01 or x > 17.01 or y < -9.01 or y > 9.01 for x, y in points): |
| return False |
| if not (min(x for x, _ in points) <= -16.99 and max(x for x, _ in points) >= 16.99): |
| return False |
| if not (min(y for _, y in points) <= -8.99 and max(y for _, y in points) >= 8.99): |
| return False |
| for grid_y in range(-9, 10, 2): |
| for grid_x in range(-17, 18, 2): |
| if min(point_segment_distance(grid_x, grid_y, s) for s in segments) > 2.2: |
| return False |
| return True |
| |
| |
| def proxy_module(obj): |
| proxy = getattr(obj, "Proxy", None) |
| return getattr(getattr(proxy, "__class__", None), "__module__", None) |
| |
| |
| def tool_feed(controller, name): |
| return float(getattr(controller, name).getValueAs("mm/min").Value) |
| |
| |
| def safe_post_text(value): |
| text = str(value) |
| return ( |
| len(text) <= 500 |
| and text.isprintable() |
| and not any(character in text for character in "()\r\n") |
| ) |
| |
| |
| def validate_part_shape(shape): |
| if not shape.isValid() or shape.ShapeType != "Solid" or len(shape.Solids) != 1: |
| return False |
| if any(not close(a, b, 1e-6) for a, b in zip(bounds(shape), (-60, 60, -40, 40, 0, 18))): |
| return False |
| expected_volume = 120.0 * 80.0 * 18.0 - 40.0 * 24.0 * 5.0 - 4.0 * math.pi * 2.5 * 2.5 * 8.0 |
| if not close(shape.Volume, expected_volume, 1e-4): |
| return False |
| pocket_faces = [ |
| face for face in shape.Faces |
| if close(face.BoundBox.ZMin, 13.0) and close(face.BoundBox.ZMax, 13.0) |
| and close(face.Area, 960.0, 1e-4) |
| and close(face.BoundBox.XMin, -20.0) and close(face.BoundBox.XMax, 20.0) |
| and close(face.BoundBox.YMin, -12.0) and close(face.BoundBox.YMax, 12.0) |
| ] |
| if len(pocket_faces) != 1: |
| return False |
| top_holes = set() |
| bottom_holes = set() |
| for edge in shape.Edges: |
| curve = edge.Curve |
| if type(curve).__name__ != "Circle" or not close(curve.Radius, 2.5): |
| continue |
| center = (round(curve.Center.x, 6), round(curve.Center.y, 6)) |
| if close(curve.Center.z, 18.0): |
| top_holes.add(center) |
| if close(curve.Center.z, 10.0): |
| bottom_holes.add(center) |
| if top_holes != HOLES or bottom_holes != HOLES: |
| return False |
| cylindrical = [] |
| for face in shape.Faces: |
| surface = face.Surface |
| if type(surface).__name__ == "Cylinder" and close(surface.Radius, 2.5): |
| cylindrical.append(face) |
| if len(cylindrical) != 4: |
| return False |
| return True |
| |
| |
| def validate_step(path): |
| shape = Part.Shape() |
| shape.read(str(path)) |
| return shape if validate_part_shape(shape) else None |
| |
| |
| def validate_document(fcstd, step, nc, repost): |
| if tuple(App.Version()[:4]) != EXPECTED_VERSION or App.Version()[-1] != EXPECTED_COMMIT: |
| return False |
| if normalized_text_sha256(step) != EXPECTED_STEP_SHA256: |
| return False |
| step_shape = validate_step(step) |
| if step_shape is None: |
| return False |
| doc = App.openDocument(str(fcstd)) |
| try: |
| 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"] |
| drillings = [obj for obj in doc.Objects if proxy_module(obj) == "Path.Op.Drilling"] |
| if len(jobs) != 1 or len(pockets) != 1 or len(drillings) != 1: |
| return False |
| job, pocket, drilling = jobs[0], pockets[0], drillings[0] |
| if not safe_post_text(job.Label): |
| return False |
| if job.PostProcessor != "linuxcnc": |
| return False |
| if job.PostProcessorArgs.split() != ["--line-numbers", "--no-show-editor"]: |
| return False |
| if pathlib.Path(job.PostProcessorOutputFile) != pathlib.Path("/home/user/Desktop/task-12.nc"): |
| # Candidate generation uses a temporary name; only formal evaluation requires exact output. |
| return False |
| if list(job.Fixtures) != ["G54"] or job.SplitOutput: |
| return False |
| operations = list(job.Operations.Group) |
| if operations != [pocket, drilling]: |
| return False |
| models = list(job.Model.Group) |
| if len(models) != 1 or not validate_part_shape(models[0].Shape): |
| return False |
| model = models[0] |
| if model.Shape.cut(step_shape).Volume > 1e-5 or step_shape.cut(model.Shape).Volume > 1e-5: |
| return False |
| stock = job.Stock |
| if proxy_module(stock) != "Path.Main.Stock": |
| return False |
| if not stock.Shape.isValid() or len(stock.Shape.Solids) != 1: |
| return False |
| if any(not close(a, b) for a, b in zip(bounds(stock.Shape), (-60, 60, -40, 40, 0, 18))): |
| return False |
| if not close(stock.Shape.Volume, 120.0 * 80.0 * 18.0, 1e-4): |
| return False |
| extension_names = ("ExtXneg", "ExtXpos", "ExtYneg", "ExtYpos", "ExtZneg", "ExtZpos") |
| if all(hasattr(stock, name) for name in extension_names): |
| if any( |
| not close(getattr(stock, name).getValueAs("mm").Value, 0.0) |
| for name in extension_names |
| ): |
| return False |
| controllers = list(job.Tools.Group) |
| if len(controllers) != 2: |
| return False |
| by_number = {int(controller.ToolNumber): controller for controller in controllers} |
| if set(by_number) != {1, 2}: |
| return False |
| t1, t2 = by_number[1], by_number[2] |
| if proxy_module(t1) != "Path.Tool.Controller" or proxy_module(t2) != "Path.Tool.Controller": |
| return False |
| if proxy_module(t1.Tool) != "Path.Tool.Bit" or proxy_module(t2.Tool) != "Path.Tool.Bit": |
| return False |
| if not close(t1.Tool.Diameter.Value, 6.0) or not close(t2.Tool.Diameter.Value, 5.0): |
| return False |
| if t1.Tool.ShapeName != "endmill" or pathlib.Path(t1.Tool.BitShape).name != "endmill.fcstd": |
| return False |
| if t2.Tool.ShapeName != "drill" or pathlib.Path(t2.Tool.BitShape).name != "drill.fcstd": |
| return False |
| for controller in (t1, t2): |
| if not safe_post_text(controller.Label): |
| return False |
| if not safe_post_text(controller.Tool.Label): |
| return False |
| if not close(controller.SpindleSpeed, 7000.0): |
| return False |
| if controller.SpindleDir != "Forward": |
| return False |
| if not close(tool_feed(controller, "HorizFeed"), 600.0): |
| return False |
| if not close(tool_feed(controller, "VertFeed"), 600.0): |
| return False |
| if pocket.ToolController != t1 or drilling.ToolController != t2: |
| return False |
| for operation in (pocket, drilling): |
| if not safe_post_text(operation.Label) or not safe_post_text(operation.Comment): |
| return False |
| if hasattr(operation, "UserLabel") and not safe_post_text(operation.UserLabel): |
| return False |
| if not (close(pocket.StartDepth.Value, 18.0) and close(pocket.FinalDepth.Value, 13.0)): |
| return False |
| if not close(pocket.StepDown.Value, 5.0) or int(pocket.StepOver) != 50: |
| return False |
| if pocket.OffsetPattern != "ZigZag" or pocket.StartAt != "Center" or pocket.CutMode != "Climb": |
| return False |
| if not (close(pocket.SafeHeight.Value, 20.0) and close(pocket.ClearanceHeight.Value, 23.0)): |
| return False |
| if len(pocket.Base) != 1 or len(pocket.Base[0][1]) != 1: |
| return False |
| boundary = pocket.Base[0][0] |
| if len(boundary.Shape.Faces) != 1: |
| return False |
| if any(not close(a, b) for a, b in zip(bounds(boundary.Shape), (-20, 20, -12, 12, 18, 18))): |
| return False |
| if not close(boundary.Shape.Faces[0].Area, 960.0): |
| return False |
| selected = boundary.Shape.getElement(pocket.Base[0][1][0]) |
| if selected.ShapeType != "Face" or not close(selected.Area, 960.0): |
| return False |
| if not (close(drilling.StartDepth.Value, 18.0) and close(drilling.FinalDepth.Value, 10.0)): |
| return False |
| if not (close(drilling.SafeHeight.Value, 20.0) and close(drilling.ClearanceHeight.Value, 23.0)): |
| return False |
| if not close(drilling.RetractHeight.Value, 20.0): |
| return False |
| if drilling.PeckEnabled or drilling.DwellEnabled or drilling.KeepToolDown: |
| return False |
| if len(drilling.Base) != 1 or len(drilling.Base[0][1]) != 4: |
| return False |
| if drilling.Base[0][0] != model: |
| return False |
| centers = set() |
| for sub in drilling.Base[0][1]: |
| edge = model.Shape.getElement(sub) |
| curve = edge.Curve |
| if type(curve).__name__ != "Circle" or not close(curve.Radius, 2.5): |
| return False |
| centers.add((round(curve.Center.x, 6), round(curve.Center.y, 6))) |
| if centers != HOLES: |
| return False |
| for obj in doc.Objects: |
| obj.touch() |
| doc.recompute() |
| doc.recompute() |
| if any( |
| any(state in {"Touched", "Invalid", "Error"} for state in obj.State) |
| for obj in doc.Objects |
| ): |
| return False |
| |
| pocket_segments = [] |
| position = {"X": None, "Y": None, "Z": None} |
| for command in pocket.Path.Commands: |
| old = position.copy() |
| for axis in ("X", "Y", "Z"): |
| if axis in command.Parameters: |
| position[axis] = float(command.Parameters[axis]) |
| if command.Name in {"G1", "G2", "G3"} and close(position["Z"], 13.0): |
| if None not in (old["X"], old["Y"], position["X"], position["Y"]): |
| pocket_segments.append((old["X"], old["Y"], position["X"], position["Y"])) |
| if not validate_segments(pocket_segments): |
| return False |
| cycles = [] |
| for command in drilling.Path.Commands: |
| if command.Name == "G81": |
| params = command.Parameters |
| if not all(axis in params for axis in ("X", "Y", "Z", "R")): |
| return False |
| cycles.append((float(params["X"]), float(params["Y"]), float(params["Z"]), float(params["R"]))) |
| if len(cycles) != 4: |
| return False |
| if {(round(x, 6), round(y, 6)) for x, y, _, _ in cycles} != HOLES: |
| return False |
| if any(not close(z, 10.0) or not close(r, 20.0) for _, _, z, r in cycles): |
| return False |
| |
| sections = PathPostCommand.buildPostList(job) |
| if len(sections) != 1: |
| return False |
| PostProcessor.load("linuxcnc").export( |
| sections[0][1], str(repost), job.PostProcessorArgs |
| ) |
| submitted = nc.read_text(encoding="utf-8") |
| fresh = repost.read_text(encoding="utf-8") |
| canonical = lambda text: TIMESTAMP_RE.sub("(Output Time:<TIMESTAMP>)", text).replace("\r\n", "\n") |
| return canonical(submitted) == canonical(fresh) |
| finally: |
| App.closeDocument(doc.Name) |
| |
| |
| marker, fcstd_arg, step_arg, nc_arg, repost_arg = sys.argv[1:6] |
| try: |
| result = validate_document( |
| pathlib.Path(fcstd_arg), |
| pathlib.Path(step_arg), |
| pathlib.Path(nc_arg), |
| pathlib.Path(repost_arg), |
| ) |
| except Exception as exc: |
| print("task-12 FreeCAD validation: %s: %s" % (type(exc).__name__, exc), file=sys.stderr) |
| result = False |
| print(marker + "=" + ("True" if result else "False")) |
| ''' |
|
|
|
|
| def run_freecad_validation(fcstd: Path, step: Path, nc: Path) -> bool: |
| try: |
| executable = FREECADCMD.resolve(strict=True) |
| info = executable.stat() |
| except OSError: |
| return False |
| if not stat.S_ISREG(info.st_mode) or not os.access(executable, os.X_OK): |
| return False |
| if info.st_uid != 0 or info.st_mode & (stat.S_IWGRP | stat.S_IWOTH): |
| return False |
| marker = "TASK12_" + secrets.token_hex(24) |
| with tempfile.TemporaryDirectory(prefix="engiworld-task12-") as raw_temp: |
| temp = Path(raw_temp) |
| script = temp / "validate.py" |
| repost = temp / "repost.nc" |
| script.write_text(CHILD_SOURCE, encoding="utf-8") |
| script.chmod(0o600) |
| command = [ |
| str(executable), |
| "-c", |
| ( |
| "import builtins,sys; sys.argv=%r; builtins.pythonopen=open; " |
| "exec(compile(open(%r, encoding='utf-8').read(), %r, 'exec'))" |
| % ( |
| [str(script), marker, str(fcstd), str(step), str(nc), str(repost)], |
| str(script), |
| str(script), |
| ) |
| ), |
| ] |
| environment = { |
| "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", |
| } |
| try: |
| completed = subprocess.run( |
| command, |
| cwd=temp, |
| env=environment, |
| stdin=subprocess.DEVNULL, |
| stdout=subprocess.PIPE, |
| stderr=subprocess.PIPE, |
| text=True, |
| encoding="utf-8", |
| errors="replace", |
| timeout=240, |
| check=False, |
| ) |
| except (OSError, subprocess.SubprocessError): |
| return False |
| if len(completed.stdout) > 2_000_000 or len(completed.stderr) > 2_000_000: |
| return False |
| expected = marker + "=True" |
| marker_lines = [ |
| line for line in completed.stdout.splitlines() if line.startswith(marker + "=") |
| ] |
| if completed.returncode != 0 or marker_lines != [expected]: |
| if completed.stderr: |
| print(completed.stderr[-4000:], file=sys.stderr) |
| return False |
| return True |
|
|
|
|
| def main() -> bool: |
| config = TARGET / "post_config.json" |
| step = TARGET / "post_test_part.step" |
| fcstd = TARGET / "task-12.FCStd" |
| nc = TARGET / "task-12.nc" |
| if load_config(config) is None: |
| return fail("invalid post_config.json") |
| if not ensure_regular(step, 5_000, 5_000_000): |
| return fail("invalid STEP file") |
| try: |
| if normalized_text_sha256(step) != EXPECTED_STEP_SHA256: |
| return fail("unexpected STEP file") |
| except OSError: |
| return fail("unreadable STEP file") |
| if not validate_fcstd_archive(fcstd): |
| return fail("invalid FCStd archive") |
| if not validate_nc_file(nc): |
| return fail("invalid NC semantics") |
| if not run_freecad_validation(fcstd, step, nc): |
| return fail("FreeCAD validation or fresh repost failed") |
| return True |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| outcome = main() |
| except Exception as exc: |
| print("task-12 evaluator: %s: %s" % (type(exc).__name__, exc), file=sys.stderr) |
| outcome = False |
| print("True" if outcome else "False") |
|
|
