| from __future__ import annotations |
|
|
| import hashlib |
| import json |
| import math |
| import os |
| import re |
| import secrets |
| import shlex |
| import stat |
| import subprocess |
| import sys |
| import tempfile |
| import traceback |
| from pathlib import Path |
|
|
|
|
| ROOT = Path("/home/user/Desktop") |
| FCSTD_PATH = ROOT / "task-07.FCStd" |
| STEP_PATH = ROOT / "variant_template.step" |
| VARIANTS_PATH = ROOT / "variants.json" |
| EXPECTED_STEP_SHA256 = "b6e7de627bdf86ec3d576c2da9980f949c7bc5451d96783fb6c2bebb56266097" |
| EXPECTED_VARIANTS_SHA256 = "9a5d0ed08ccc5622b7c35a517937afbd4d4e92a2b3d9e00461b19f333737b32c" |
| EXPECTED_FREECAD_COMMIT = "b9bfa5c5507506e4515816414cd27f4851d00489" |
| FREECADCMD = Path("/usr/bin/freecadcmd") |
| INNER_ENV = "ENGIWORLD_TASK07_FREECAD" |
| MARKER_ENV = "ENGIWORLD_TASK07_MARKER" |
| NUMBER = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)" |
| WORD_RE = re.compile(rf"([A-Z])\s*({NUMBER})", re.IGNORECASE) |
|
|
|
|
| def regular_file(path: Path, maximum_size: int) -> bool: |
| try: |
| info = path.lstat() |
| except OSError: |
| return False |
| return ( |
| stat.S_ISREG(info.st_mode) |
| and not path.is_symlink() |
| and 0 < info.st_size <= maximum_size |
| ) |
|
|
|
|
| def sha256(path: Path) -> str: |
| digest = hashlib.sha256() |
| with path.open("rb") as stream: |
| for chunk in iter(lambda: stream.read(1024 * 1024), b""): |
| digest.update(chunk) |
| return digest.hexdigest() |
|
|
|
|
| def normalized_text_sha256(path: Path) -> str: |
| data = path.read_bytes().replace(b"\r\n", b"\n").replace(b"\r", b"\n") |
| return hashlib.sha256(data).hexdigest() |
|
|
|
|
| def close(a, b, tolerance: float = 1e-5) -> bool: |
| return abs(float(a) - float(b)) <= tolerance |
|
|
|
|
| def proxy_module(obj) -> str: |
| proxy = getattr(obj, "Proxy", None) |
| return getattr(proxy.__class__, "__module__", "") if proxy is not None else "" |
|
|
|
|
| def shapes_equal(first, second, tolerance: float = 1e-5) -> bool: |
| try: |
| return ( |
| first.isValid() |
| and second.isValid() |
| and first.cut(second).Volume <= tolerance |
| and second.cut(first).Volume <= tolerance |
| ) |
| except Exception: |
| return False |
|
|
|
|
| def normalize_program_comment(value: str) -> str: |
| return re.sub(r"\s+", " ", value.strip()).upper() |
|
|
|
|
| def rectangle_frame(face, Part, expected_length: float, expected_width: float): |
| if len(face.Wires) != 1: |
| return None |
| if not isinstance(face.Surface, Part.Plane): |
| return None |
| normal = face.normalAt(0.5, 0.5) |
| if abs(abs(float(normal.z)) - 1.0) > 1e-5: |
| return None |
| points = [] |
| for vertex in face.Wires[0].OrderedVertexes: |
| point = vertex.Point |
| if not points or (point - points[-1]).Length > 1e-6: |
| points.append(point) |
| if len(points) > 1 and (points[0] - points[-1]).Length <= 1e-6: |
| points.pop() |
| changed = True |
| while changed and len(points) > 4: |
| changed = False |
| for index in range(len(points)): |
| before = points[index - 1] |
| current = points[index] |
| after = points[(index + 1) % len(points)] |
| incoming = current - before |
| outgoing = after - current |
| incoming.z = 0.0 |
| outgoing.z = 0.0 |
| if incoming.Length <= 1e-8 or outgoing.Length <= 1e-8: |
| points.pop(index) |
| changed = True |
| break |
| cross = abs(incoming.x * outgoing.y - incoming.y * outgoing.x) |
| if cross <= 1e-7 * incoming.Length * outgoing.Length and incoming.dot(outgoing) > 0: |
| points.pop(index) |
| changed = True |
| break |
| if len(points) != 4: |
| return None |
| origin = points[0] |
| first = points[1] - origin |
| second = points[-1] - origin |
| first.z = 0.0 |
| second.z = 0.0 |
| first_length = first.Length |
| second_length = second.Length |
| if first_length <= 0 or second_length <= 0: |
| return None |
| first.normalize() |
| second.normalize() |
| if abs(first.dot(second)) > 1e-5: |
| return None |
| actual = sorted((first_length, second_length)) |
| expected = sorted((expected_length, expected_width)) |
| if not all(close(a, b, 1e-4) for a, b in zip(actual, expected)): |
| return None |
| if not close(face.Area, expected_length * expected_width, 1e-3): |
| return None |
| return origin, first, second, first_length, second_length, points |
|
|
|
|
| def local_xy(point, frame): |
| origin, first, second, _, _, _ = frame |
| delta = point - origin |
| return delta.dot(first), delta.dot(second) |
|
|
|
|
| def removal_rectangle_frame(pocket, Part, expected_length: float, expected_width: float, model_top: float): |
| try: |
| removal = pocket.removalshape |
| except Exception: |
| return None |
| if removal is None or removal.isNull() or not removal.isValid(): |
| return None |
| top_faces = [ |
| face |
| for face in removal.Faces |
| if isinstance(face.Surface, Part.Plane) |
| and abs(face.BoundBox.ZMin - model_top) <= 1e-4 |
| and abs(face.BoundBox.ZMax - model_top) <= 1e-4 |
| ] |
| if not top_faces: |
| return None |
| fused = top_faces[0] |
| for face in top_faces[1:]: |
| fused = fused.fuse(face) |
| try: |
| fused = fused.removeSplitter() |
| except Exception: |
| pass |
| for face in fused.Faces: |
| frame = rectangle_frame(face, Part, expected_length, expected_width) |
| if frame is not None: |
| return frame |
| return None |
|
|
|
|
| def distance_to_segment(px: float, py: float, start, end) -> float: |
| ax, ay = start |
| bx, by = end |
| dx = bx - ax |
| dy = by - ay |
| denominator = dx * dx + dy * dy |
| if denominator <= 1e-16: |
| return math.hypot(px - ax, py - ay) |
| scale = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / denominator)) |
| return math.hypot(px - (ax + scale * dx), py - (ay + scale * dy)) |
|
|
|
|
| def path_motions(commands): |
| current = {"X": None, "Y": None, "Z": None} |
| motions = [] |
| for command in commands: |
| before = dict(current) |
| parameters = command.Parameters |
| for axis in ("X", "Y", "Z"): |
| if axis in parameters: |
| current[axis] = float(parameters[axis]) |
| name = str(command.Name).upper().replace(" ", "") |
| if name in {"G0", "G00", "G1", "G01"} and all( |
| before[axis] is not None and current[axis] is not None |
| for axis in ("X", "Y", "Z") |
| ): |
| motions.append(("G0" if name in {"G0", "G00"} else "G1", before, dict(current))) |
| elif name in {"G2", "G02", "G3", "G03"} and all( |
| before[axis] is not None and current[axis] is not None |
| for axis in ("X", "Y", "Z") |
| ): |
| if "I" not in parameters and "J" not in parameters: |
| raise ValueError("unsupported arc without I/J center offsets") |
| center_x = before["X"] + float(parameters.get("I", 0.0)) |
| center_y = before["Y"] + float(parameters.get("J", 0.0)) |
| start_angle = math.atan2(before["Y"] - center_y, before["X"] - center_x) |
| end_angle = math.atan2(current["Y"] - center_y, current["X"] - center_x) |
| radius = math.hypot(before["X"] - center_x, before["Y"] - center_y) |
| end_radius = math.hypot(current["X"] - center_x, current["Y"] - center_y) |
| if radius <= 1e-8 or abs(radius - end_radius) > 1e-4: |
| raise ValueError("invalid arc radius") |
| clockwise = name in {"G2", "G02"} |
| sweep = (start_angle - end_angle) % (2.0 * math.pi) if clockwise else (end_angle - start_angle) % (2.0 * math.pi) |
| if sweep <= 1e-10: |
| sweep = 2.0 * math.pi |
| steps = max(2, int(math.ceil(radius * sweep / 0.25))) |
| previous = dict(before) |
| direction = -1.0 if clockwise else 1.0 |
| for step in range(1, steps + 1): |
| fraction = step / steps |
| angle = start_angle + direction * sweep * fraction |
| point = { |
| "X": center_x + radius * math.cos(angle), |
| "Y": center_y + radius * math.sin(angle), |
| "Z": before["Z"] + (current["Z"] - before["Z"]) * fraction, |
| } |
| if step == steps: |
| point = dict(current) |
| motions.append(("G1", previous, point)) |
| previous = point |
| return motions |
|
|
|
|
| def rounded_rectangle_contains( |
| x: float, |
| y: float, |
| length: float, |
| width: float, |
| radius: float, |
| ) -> bool: |
| center_x = min(max(x, radius), length - radius) |
| center_y = min(max(y, radius), width - radius) |
| return math.hypot(x - center_x, y - center_y) <= radius + 1e-8 |
|
|
|
|
| def validate_pocket_path(pocket, frame, bottom_z: float, diameter: float) -> bool: |
| _, _, _, length, width, _ = frame |
| radius = diameter / 2.0 |
| if length <= diameter or width <= diameter: |
| return False |
| motions = path_motions(list(pocket.Path.Commands)) |
| if len(motions) < 8: |
| return False |
| final_segments = [] |
| reached_bottom = False |
| for mode, before, after in motions: |
| if min(before["Z"], after["Z"]) < bottom_z - 1e-4: |
| return False |
| if mode == "G0": |
| if after["Z"] <= pocket.StartDepth.Value + 1e-4: |
| return False |
| continue |
| for point_data in (before, after): |
| if point_data["Z"] <= pocket.StartDepth.Value + 1e-4: |
| point = __import__("FreeCAD").Vector(point_data["X"], point_data["Y"], point_data["Z"]) |
| local_x, local_y = local_xy(point, frame) |
| if not ( |
| radius - 0.01 <= local_x <= length - radius + 0.01 |
| and radius - 0.01 <= local_y <= width - radius + 0.01 |
| ): |
| return False |
| if abs(after["Z"] - bottom_z) <= 1e-4: |
| reached_bottom = True |
| if abs(before["Z"] - bottom_z) <= 1e-4 and abs(after["Z"] - bottom_z) <= 1e-4: |
| first_point = __import__("FreeCAD").Vector(before["X"], before["Y"], bottom_z) |
| second_point = __import__("FreeCAD").Vector(after["X"], after["Y"], bottom_z) |
| final_segments.append((local_xy(first_point, frame), local_xy(second_point, frame))) |
| if not reached_bottom or len(final_segments) < 4: |
| return False |
|
|
| sample_step = 0.5 |
| x = 0.0 |
| samples = 0 |
| while x <= length + 1e-8: |
| y = 0.0 |
| while y <= width + 1e-8: |
| if rounded_rectangle_contains(x, y, length, width, radius): |
| samples += 1 |
| if min(distance_to_segment(x, y, a, b) for a, b in final_segments) > radius + 0.01: |
| return False |
| y += sample_step |
| x += sample_step |
| return samples >= 100 |
|
|
|
|
| def strip_comments(text: str): |
| comments = [] |
| output = [] |
| index = 0 |
| while index < len(text): |
| char = text[index] |
| if char == "(": |
| end = text.find(")", index + 1) |
| if end < 0 or "(" in text[index + 1 : end]: |
| raise ValueError("malformed parenthesis comment") |
| comments.append(text[index + 1 : end]) |
| output.extend(" " for _ in range(index, end + 1)) |
| index = end + 1 |
| elif char == ")": |
| raise ValueError("unmatched parenthesis") |
| elif char == ";": |
| end = text.find("\n", index) |
| if end < 0: |
| end = len(text) |
| comments.append(text[index + 1 : end]) |
| output.extend(" " for _ in range(index, end)) |
| index = end |
| else: |
| output.append(char) |
| index += 1 |
| return "".join(output), comments |
|
|
|
|
| def parse_nc(text: str): |
| executable, comments = strip_comments(text) |
| raw_lines = executable.splitlines() |
| percent_lines = [index for index, line in enumerate(raw_lines) if line.strip() == "%"] |
| nonempty = [index for index, line in enumerate(raw_lines) if line.strip()] |
| if percent_lines: |
| if len(percent_lines) != 2 or percent_lines != [nonempty[0], nonempty[-1]]: |
| raise ValueError("illegal percent wrapper") |
| blocks = [] |
| for raw_line in raw_lines: |
| line = raw_line.strip().upper() |
| if not line or line == "%": |
| continue |
| tokens = [] |
| cursor = 0 |
| for match in WORD_RE.finditer(line): |
| if line[cursor : match.start()].strip(): |
| raise ValueError("unparsed NC text") |
| tokens.append((match.group(1).upper(), float(match.group(2)))) |
| cursor = match.end() |
| if line[cursor:].strip() or not tokens: |
| raise ValueError("unparsed NC line") |
| blocks.append(tokens) |
| if not blocks: |
| raise ValueError("empty NC") |
| return blocks, comments |
|
|
|
|
| def canonical_blocks(text: str): |
| blocks, _ = parse_nc(text) |
| result = [] |
| for block in blocks: |
| normalized = [] |
| for letter, number in block: |
| if letter == "N": |
| continue |
| if letter in {"G", "M", "T", "H", "O"} and close(number, round(number), 1e-9): |
| value = str(int(round(number))) |
| else: |
| value = f"{number:.9f}".rstrip("0").rstrip(".") |
| if value in {"-0", "+0"}: |
| value = "0" |
| if letter == "M" and value == "30": |
| value = "2" |
| normalized.append(letter + value) |
| result.append(tuple(sorted(normalized))) |
| return result |
|
|
|
|
| def validate_nc_safety(text: str, program: int, model_top: float, bottom_z: float) -> bool: |
| try: |
| blocks, comments = parse_nc(text) |
| except Exception: |
| return False |
| expected_comment = f"PROGRAM NUMBER {program}" |
| exact_program_comments = [ |
| comment.strip() |
| for comment in comments |
| if re.fullmatch(r"PROGRAM NUMBER [+-]?\d+", comment.strip()) |
| ] |
| mentioned_programs = [ |
| int(match.group(1)) |
| for comment in comments |
| for match in [ |
| re.fullmatch( |
| r"PROGRAM(?:\s+|[-_])NUMBER\s*(?:[:=#-]\s*)?([+-]?\d+)", |
| comment.strip(), |
| re.IGNORECASE, |
| ) |
| ] |
| if match is not None |
| ] |
| if exact_program_comments != [expected_comment] or any(value != program for value in mentioned_programs): |
| return False |
|
|
| state = { |
| "units_mm": False, |
| "absolute": False, |
| "motion": None, |
| "feed": None, |
| "speed": None, |
| "tool": None, |
| "spindle": False, |
| "tool_changed": False, |
| "X": None, |
| "Y": None, |
| "Z": None, |
| } |
| saw_g21 = saw_g90 = saw_tool_change = saw_spindle = saw_cut = saw_bottom = False |
| ended = False |
| for block_index, block in enumerate(blocks): |
| words = {} |
| g_codes = [] |
| m_codes = [] |
| for letter, number in block: |
| if letter == "G": |
| if not close(number, round(number), 1e-9): |
| return False |
| g_codes.append(int(round(number))) |
| elif letter == "M": |
| if not close(number, round(number), 1e-9): |
| return False |
| m_codes.append(int(round(number))) |
| else: |
| if letter in words: |
| return False |
| words[letter] = number |
| if any(code not in {0, 1, 2, 3, 17, 21, 40, 43, 49, 54, 55, 56, 57, 58, 59, 80, 90, 94} for code in g_codes): |
| return False |
| if any(code not in {2, 3, 4, 5, 6, 7, 8, 9, 30} for code in m_codes): |
| return False |
| if 21 in g_codes: |
| state["units_mm"] = True |
| saw_g21 = True |
| if 90 in g_codes: |
| state["absolute"] = True |
| saw_g90 = True |
| for code in g_codes: |
| if code in (0, 1, 2, 3): |
| state["motion"] = code |
| if "T" in words: |
| if not close(words["T"], 1, 1e-9): |
| return False |
| state["tool"] = 1 |
| if "H" in words and not close(words["H"], 1, 1e-9): |
| return False |
| if "S" in words: |
| if not close(words["S"], 7000, 1e-6): |
| return False |
| state["speed"] = words["S"] |
| if "F" in words: |
| if not close(words["F"], 500, 1e-5): |
| return False |
| state["feed"] = words["F"] |
| if 5 in m_codes: |
| state["spindle"] = False |
| if 6 in m_codes: |
| if state["spindle"] or state["tool"] != 1: |
| return False |
| state["tool_changed"] = True |
| saw_tool_change = True |
| if 3 in m_codes and 4 in m_codes: |
| return False |
| if 3 in m_codes or 4 in m_codes: |
| if state["speed"] is None or not close(state["speed"], 7000, 1e-6): |
| return False |
| state["spindle"] = True |
| saw_spindle = True |
| before = {axis: state[axis] for axis in ("X", "Y", "Z")} |
| moved = False |
| for axis in ("X", "Y", "Z"): |
| if axis in words: |
| state[axis] = words[axis] |
| moved = True |
| if moved and state["motion"] in (0, 1, 2, 3): |
| if not state["units_mm"] or not state["absolute"]: |
| return False |
| if state["motion"] == 0: |
| xy_changed = any( |
| axis in words and before[axis] is not None and not close(before[axis], state[axis]) |
| for axis in ("X", "Y") |
| ) |
| if state["Z"] is not None and state["Z"] <= model_top + 1e-4: |
| return False |
| if xy_changed and (before["Z"] is None or before["Z"] <= model_top + 1e-4): |
| return False |
| else: |
| if not state["tool_changed"] or not state["spindle"] or state["feed"] is None: |
| return False |
| if state["Z"] is not None and state["Z"] < bottom_z - 1e-4: |
| return False |
| saw_cut = True |
| if state["Z"] is not None and abs(state["Z"] - bottom_z) <= 1e-4: |
| saw_bottom = True |
| if 2 in m_codes or 30 in m_codes: |
| if block_index != len(blocks) - 1 or state["spindle"]: |
| return False |
| ended = True |
| return all( |
| (saw_g21, saw_g90, saw_tool_change, saw_spindle, saw_cut, saw_bottom, ended) |
| ) |
|
|
|
|
| def valid_postprocessor_args(value: str) -> bool: |
| try: |
| arguments = shlex.split(value) |
| except ValueError: |
| return False |
| flags = {"--no-header", "--line-numbers", "--no-show-editor", "--modal", "--axis-modal", "--no-tlo"} |
| index = 0 |
| while index < len(arguments): |
| argument = arguments[index] |
| if argument in flags: |
| index += 1 |
| continue |
| if argument == "--precision": |
| index += 1 |
| if index >= len(arguments) or not re.fullmatch(r"[3-9]", arguments[index]): |
| return False |
| index += 1 |
| continue |
| match = re.fullmatch(r"--precision=([3-9])", argument) |
| if match is not None: |
| index += 1 |
| continue |
| return False |
| return True |
|
|
|
|
| def object_state_clean(obj) -> bool: |
| try: |
| states = {str(value) for value in obj.State} |
| except Exception: |
| return False |
| return not states.intersection({"Touched", "Invalid", "Error"}) |
|
|
|
|
| def validate_variants(data) -> list[dict] | None: |
| if not isinstance(data, dict) or data.get("task") != "task-07" or data.get("unit") != "mm": |
| return None |
| variants = data.get("variants") |
| if not isinstance(variants, list) or len(variants) != 5: |
| return None |
| seen_names = set() |
| seen_programs = set() |
| for variant in variants: |
| if set(variant) != {"name", "pocket_size", "bottom_z", "tool_diameter", "program"}: |
| return None |
| name = variant["name"] |
| size = variant["pocket_size"] |
| if not isinstance(name, str) or not re.fullmatch(r"variant_0[1-5]", name): |
| return None |
| if not isinstance(size, list) or len(size) != 2: |
| return None |
| try: |
| length, width = map(float, size) |
| bottom = float(variant["bottom_z"]) |
| diameter = float(variant["tool_diameter"]) |
| program = int(variant["program"]) |
| except (TypeError, ValueError): |
| return None |
| if name in seen_names or program in seen_programs: |
| return None |
| if length <= diameter or width <= diameter or diameter <= 0 or not (0 < bottom < 18): |
| return None |
| seen_names.add(name) |
| seen_programs.add(program) |
| return variants |
|
|
|
|
| def evaluate_in_freecad() -> bool: |
| import builtins |
|
|
| builtins.pythonopen = open |
| import FreeCAD as App |
| import Part |
| import Path.Post.Command as PathPostCommand |
| from Path.Post.Processor import PostProcessor |
|
|
| if App.Version()[:4] != ["0", "21", "2", "33771 (Git)"]: |
| return False |
| if App.Version()[-1] != EXPECTED_FREECAD_COMMIT: |
| return False |
| required = [FCSTD_PATH, STEP_PATH, VARIANTS_PATH] + [ |
| ROOT / f"variant_{index:02d}.nc" for index in range(1, 6) |
| ] |
| if not all(regular_file(path, 20 * 1024 * 1024 if path.suffix == ".FCStd" else 5 * 1024 * 1024) for path in required): |
| return False |
| if ( |
| normalized_text_sha256(STEP_PATH) != EXPECTED_STEP_SHA256 |
| or normalized_text_sha256(VARIANTS_PATH) != EXPECTED_VARIANTS_SHA256 |
| ): |
| return False |
| try: |
| variants = validate_variants(json.loads(VARIANTS_PATH.read_text(encoding="utf-8"))) |
| except Exception: |
| return False |
| if variants is None: |
| return False |
|
|
| input_shape = Part.read(str(STEP_PATH)) |
| if ( |
| input_shape.ShapeType != "Solid" |
| or len(input_shape.Solids) != 1 |
| or not input_shape.isValid() |
| or not close(input_shape.Volume, 172800.0, 1e-3) |
| ): |
| return False |
| document = App.openDocument(str(FCSTD_PATH)) |
| if document is None: |
| return False |
| jobs = [obj for obj in document.Objects if proxy_module(obj) == "Path.Main.Job"] |
| if len(jobs) != 5: |
| return False |
|
|
| jobs_by_program = {} |
| for job in jobs: |
| if len(job.Operations.Group) != 2: |
| return False |
| custom_ops = [obj for obj in job.Operations.Group if proxy_module(obj) == "Path.Op.Custom"] |
| pockets = [obj for obj in job.Operations.Group if proxy_module(obj) == "Path.Op.PocketShape"] |
| if len(custom_ops) != 1 or len(pockets) != 1: |
| return False |
| lines = [str(line).strip() for line in custom_ops[0].Gcode] |
| matches = [re.fullmatch(r"\(PROGRAM NUMBER (\d+)\)", line) for line in lines] |
| programs = [int(match.group(1)) for match in matches if match] |
| if len(programs) != 1 or programs[0] in jobs_by_program: |
| return False |
| jobs_by_program[programs[0]] = (job, custom_ops[0], pockets[0]) |
| if set(jobs_by_program) != {int(variant["program"]) for variant in variants}: |
| return False |
|
|
| for job, custom, pocket in jobs_by_program.values(): |
| for obj in list(job.Tools.Group) + [custom, pocket, job]: |
| obj.touch() |
| document.recompute() |
|
|
| with tempfile.TemporaryDirectory(prefix="engiworld-task07-eval-") as temporary: |
| for variant in variants: |
| name = variant["name"] |
| length, width = map(float, variant["pocket_size"]) |
| bottom_z = float(variant["bottom_z"]) |
| diameter = float(variant["tool_diameter"]) |
| program = int(variant["program"]) |
| job, custom, pocket = jobs_by_program[program] |
| if str(job.PostProcessor).strip().lower() != "linuxcnc" or bool(job.SplitOutput): |
| return False |
| if os.path.normpath(str(job.PostProcessorOutputFile)) != str(ROOT / f"{name}.nc"): |
| return False |
| if not valid_postprocessor_args(str(job.PostProcessorArgs)): |
| return False |
| fixtures = [str(fixture).strip().upper() for fixture in job.Fixtures] |
| if len(fixtures) != 1 or not re.fullmatch(r"G5[4-9]", fixtures[0]): |
| return False |
| if len(job.Model.Group) != 1 or not shapes_equal(job.Model.Group[0].Shape, input_shape): |
| return False |
| model = job.Model.Group[0] |
| stock = job.Stock |
| if ( |
| not stock.Shape.isValid() |
| or len(stock.Shape.Solids) != 1 |
| or model.Shape.cut(stock.Shape).Volume > 1e-5 |
| ): |
| return False |
| if len(job.Tools.Group) != 1: |
| return False |
| controller = job.Tools.Group[0] |
| if proxy_module(controller) != "Path.Tool.Controller" or proxy_module(controller.Tool) != "Path.Tool.Bit": |
| return False |
| if ( |
| int(controller.ToolNumber) != 1 |
| or not close(controller.Tool.Diameter.Value, diameter) |
| or not close(controller.SpindleSpeed, 7000) |
| or str(controller.SpindleDir) not in {"Forward", "Reverse"} |
| or not close(controller.HorizFeed.getValueAs("mm/min").Value, 500) |
| or not close(controller.VertFeed.getValueAs("mm/min").Value, 500) |
| ): |
| return False |
| if custom.ToolController != controller or pocket.ToolController != controller: |
| return False |
| if [str(line).strip() for line in custom.Gcode] != [f"(PROGRAM NUMBER {program})"]: |
| return False |
| if ( |
| not close(pocket.StartDepth.Value, input_shape.BoundBox.ZMax) |
| or not close(pocket.FinalDepth.Value, bottom_z) |
| or pocket.StepDown.Value <= 0 |
| or pocket.ClearanceHeight.Value <= pocket.SafeHeight.Value |
| or pocket.SafeHeight.Value <= input_shape.BoundBox.ZMax |
| or not pocket.Base |
| ): |
| return False |
| for boundary, subelements in pocket.Base: |
| if boundary.Document != document or not subelements: |
| return False |
| for subelement in subelements: |
| if not str(subelement).startswith("Face"): |
| return False |
| try: |
| boundary.Shape.getElement(str(subelement)) |
| except Exception: |
| return False |
| tracked_objects = [job, model, stock, controller, controller.Tool, custom, pocket] |
| tracked_objects.extend(boundary for boundary, _ in pocket.Base) |
| if not all(object_state_clean(obj) for obj in tracked_objects): |
| return False |
| frame = removal_rectangle_frame( |
| pocket, |
| Part, |
| length, |
| width, |
| input_shape.BoundBox.ZMax, |
| ) |
| if frame is None: |
| return False |
| _, _, _, _, _, points = frame |
| if any( |
| point.z < input_shape.BoundBox.ZMax - 1e-5 |
| or point.z > input_shape.BoundBox.ZMax + 1e-5 |
| or point.x < input_shape.BoundBox.XMin - 1e-5 |
| or point.x > input_shape.BoundBox.XMax + 1e-5 |
| or point.y < input_shape.BoundBox.YMin - 1e-5 |
| or point.y > input_shape.BoundBox.YMax + 1e-5 |
| for point in points |
| ): |
| return False |
| if not validate_pocket_path(pocket, frame, bottom_z, diameter): |
| return False |
|
|
| submitted_path = ROOT / f"{name}.nc" |
| try: |
| submitted_text = submitted_path.read_text(encoding="utf-8") |
| except Exception: |
| return False |
| if not validate_nc_safety(submitted_text, program, input_shape.BoundBox.ZMax, bottom_z): |
| return False |
| sections = PathPostCommand.buildPostList(job) |
| if len(sections) != 1: |
| return False |
| repost_path = Path(temporary) / f"{name}.nc" |
| try: |
| PostProcessor.load("linuxcnc").export( |
| sections[0][1], |
| str(repost_path), |
| str(job.PostProcessorArgs), |
| ) |
| repost_text = repost_path.read_text(encoding="utf-8") |
| except BaseException: |
| return False |
| if canonical_blocks(submitted_text) != canonical_blocks(repost_text): |
| return False |
| return True |
|
|
|
|
| def run_outer() -> bool: |
| 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 & 0o022: |
| return False |
| marker = "TASK07_RESULT_" + secrets.token_hex(16) |
| evaluator = str(Path(__file__).resolve()) |
| command = ( |
| "import builtins; builtins.pythonopen=open; " |
| f"exec(compile(open({evaluator!r}, encoding='utf-8').read(), {evaluator!r}, 'exec'))" |
| ) |
| try: |
| with tempfile.TemporaryDirectory(prefix="engiworld-task07-home-") as isolated_home: |
| environment = { |
| "HOME": isolated_home, |
| "LANG": "C.UTF-8", |
| "LC_ALL": "C.UTF-8", |
| "LOGNAME": "user", |
| "PATH": "/usr/bin:/bin", |
| "USER": "user", |
| "XDG_CACHE_HOME": str(Path(isolated_home) / ".cache"), |
| "XDG_CONFIG_HOME": str(Path(isolated_home) / ".config"), |
| INNER_ENV: "1", |
| MARKER_ENV: marker, |
| } |
| completed = subprocess.run( |
| [str(executable), "-c", command], |
| capture_output=True, |
| text=True, |
| timeout=240, |
| env=environment, |
| check=False, |
| ) |
| except Exception: |
| return False |
| marker_lines = [line.strip() for line in completed.stdout.splitlines() if line.strip().startswith(marker + "=")] |
| return completed.returncode == 0 and marker_lines == [marker + "=True"] |
|
|
|
|
| if __name__ == "__main__": |
| if os.environ.get(INNER_ENV) == "1": |
| marker = os.environ.get(MARKER_ENV, "") |
| ok = False |
| try: |
| ok = evaluate_in_freecad() |
| except BaseException: |
| traceback.print_exc(file=sys.stderr) |
| ok = False |
| print(f"{marker}={bool(ok)}") |
| else: |
| print(True if run_outer() else False) |
|
|
