| import itertools |
| import math |
| import os |
| from pathlib import Path |
| import ezdxf |
|
|
| OUTPUT_ROOT = Path(os.environ.get("OUTPUT_ROOT", "/home/user/Desktop")) |
|
|
|
|
| GUI_BYPASS_FORBIDDEN_EXTENSIONS = { |
| ".py", ".pyw", ".ipynb", ".sh", ".bash", ".zsh", ".bat", ".cmd", |
| ".ps1", ".psm1", ".psd1", ".vbs", ".js", ".mjs", ".ts", ".rb", |
| ".lua", ".tcl", ".ahk", ".scr", |
| } |
| GUI_BYPASS_ALLOWED_FILENAMES = {"eval.py"} |
| GUI_BYPASS_OUTPUT_TOKENS = ( |
| "result.ifc", "result.pdf", "result.osm", "workflow.osw", "summary.txt", |
| "report.csv", "result.csv", |
| ".dxf", ".dwg", ".step", ".stp", ".fcstd", ".scad", ".stl", ".obj", |
| ".db", ".rst", ".rth", ".wbpj", ".odb", ".cae", ".inp", |
| ".nc", ".gcode", ".slb", ".ipt", ".sldprt", ".sldasm", |
| "autocad_result", "apdl_", "wb_", |
| ) |
| GUI_BYPASS_COMMAND_TOKENS = ( |
| "python", "python3", "py ", "powershell", "pwsh", "cmd.exe", "cmd /c", |
| "bash", " sh ", "zsh", "node", "ruby", "perl", |
| "ifcopenshell", "openstudio", "energyplus", |
| "blender --background", "revitbatchprocessor", |
| "ansys", "mapdl", "fluent", "abaqus", "cae noGUI", |
| "freecad", "freecadcmd", "openscad", "librecad", |
| "ezdxf", "cadquery", "accoreconsole", "autolisp", |
| "solidworks", "solvespace", |
| ) |
|
|
|
|
| def _read_text_safe(path): |
| try: |
| return path.read_text(encoding="utf-8", errors="ignore") |
| except Exception: |
| return "" |
|
|
|
|
| def _desktop_script_artifacts(root): |
| if not root.exists() or not root.is_dir(): |
| return True |
| try: |
| candidates = list(root.iterdir()) |
| for directory in list(candidates): |
| if directory.is_dir() and directory.name not in {"__pycache__", "_runtime"}: |
| try: |
| candidates.extend(directory.iterdir()) |
| except Exception: |
| pass |
| for path in candidates: |
| if not path.is_file(): |
| continue |
| if path.name in GUI_BYPASS_ALLOWED_FILENAMES: |
| continue |
| if path.suffix.lower() in GUI_BYPASS_FORBIDDEN_EXTENSIONS: |
| return True |
| except Exception: |
| return True |
| return False |
|
|
|
|
| def _history_paths(root): |
| home = Path.home() |
| return [ |
| home / ".bash_history", |
| home / ".zsh_history", |
| home / ".python_history", |
| home / ".local/share/fish/fish_history", |
| home / "AppData/Roaming/Microsoft/Windows/PowerShell/PSReadLine/ConsoleHost_history.txt", |
| home / "AppData/Roaming/Microsoft/Windows/PowerShell/PSReadLine/Visual Studio Code Host_history.txt", |
| root / ".bash_history", |
| root / ".zsh_history", |
| ] |
|
|
|
|
| def _history_contains_bypass(root): |
| for path in _history_paths(root): |
| if not path.is_file(): |
| continue |
| text = _read_text_safe(path).lower() |
| if not text: |
| continue |
| for raw_line in text.splitlines(): |
| line = raw_line.strip() |
| if not line or "eval.py" in line: |
| continue |
| touches_output = any(token in line for token in GUI_BYPASS_OUTPUT_TOKENS) |
| runs_command = any(token in line for token in GUI_BYPASS_COMMAND_TOKENS) |
| writes_file = any( |
| token in line for token in (">", "tee ", "cat ", "set-content", "out-file", "new-item") |
| ) |
| if touches_output and (runs_command or writes_file): |
| return True |
| if ("/desktop/" in line or "\\desktop\\" in line) and any( |
| ext in line for ext in GUI_BYPASS_FORBIDDEN_EXTENSIONS |
| ) and runs_command: |
| return True |
| return False |
|
|
|
|
| def check_no_gui_bypass(root): |
| root = Path(root) |
| if _desktop_script_artifacts(root): |
| return False |
| if _history_contains_bypass(root): |
| return False |
| return True |
|
|
| TARGET = "final_ss_gui_06.dxf" |
| TOL = 0.75 |
|
|
|
|
| def _close(a, b, tol=TOL): |
| return abs(float(a) - float(b)) <= tol |
|
|
|
|
| def _point_close(a, b, tol=TOL): |
| return _close(a[0], b[0], tol) and _close(a[1], b[1], tol) |
|
|
|
|
| def _dist(a, b): |
| return math.hypot(float(a[0]) - float(b[0]), float(a[1]) - float(b[1])) |
|
|
|
|
| def _dedupe(points): |
| unique = [] |
| for point in points: |
| if not any(_point_close(point, prev) for prev in unique): |
| unique.append(point) |
| return unique |
|
|
|
|
| def _segment_points(doc): |
| points = [] |
| for entity in doc.modelspace(): |
| if entity.dxftype() == "LINE": |
| start, end = entity.dxf.start, entity.dxf.end |
| points.extend([(float(start.x), float(start.y)), (float(end.x), float(end.y))]) |
| elif entity.dxftype() == "LWPOLYLINE": |
| points.extend((float(p[0]), float(p[1])) for p in entity.get_points("xy")) |
| return _dedupe(points) |
|
|
|
|
| def _outline_segments(doc): |
| segments = [] |
| for entity in doc.modelspace(): |
| if entity.dxftype() == "LINE": |
| start, end = entity.dxf.start, entity.dxf.end |
| segments.append(((float(start.x), float(start.y)), (float(end.x), float(end.y)))) |
| elif entity.dxftype() == "LWPOLYLINE": |
| points = [(float(p[0]), float(p[1])) for p in entity.get_points("xy")] |
| segments.extend(zip(points, points[1:])) |
| if entity.closed and len(points) > 2: |
| segments.append((points[-1], points[0])) |
| return segments |
|
|
|
|
| def _edge_present(segments, start, end, tol=0.15): |
| return any( |
| (_point_close(a, start, tol) and _point_close(b, end, tol)) |
| or (_point_close(a, end, tol) and _point_close(b, start, tol)) |
| for a, b in segments |
| ) |
|
|
|
|
| def _hex_edges_present(doc, points, center): |
| ordered = sorted(points, key=lambda p: math.atan2(p[1] - center[1], p[0] - center[0])) |
| segments = _outline_segments(doc) |
| return all( |
| _edge_present(segments, ordered[index], ordered[(index + 1) % 6]) |
| for index in range(6) |
| ) |
|
|
|
|
| def _regular_hex_center(points): |
| if len(points) != 6: |
| return None |
| center = (sum(p[0] for p in points) / 6, sum(p[1] for p in points) / 6) |
| expected_top_y = 40 * math.sin(math.radians(60)) |
| if not all(_close(_dist(p, center), 40, 1.0) for p in points): |
| return None |
| rel = sorted((round(p[0] - center[0], 2), round(p[1] - center[1], 2)) for p in points) |
| has_left_right = any(_point_close((dx, dy), (-40, 0), 1.0) for dx, dy in rel) and any(_point_close((dx, dy), (40, 0), 1.0) for dx, dy in rel) |
| has_top = sum(1 for dx, dy in rel if _close(dy, expected_top_y, 1.0)) == 2 |
| has_bottom = sum(1 for dx, dy in rel if _close(dy, -expected_top_y, 1.0)) == 2 |
| if has_left_right and has_top and has_bottom: |
| return center |
| return None |
|
|
|
|
| def _hex_center(doc): |
| for entity in doc.modelspace(): |
| if entity.dxftype() != "LWPOLYLINE": |
| continue |
| pts = _dedupe([(float(p[0]), float(p[1])) for p in entity.get_points("xy")]) |
| center = _regular_hex_center(pts) |
| if center is not None and _hex_edges_present(doc, pts, center): |
| return center |
| points = _segment_points(doc) |
| for candidate in itertools.combinations(points, 6): |
| center = _regular_hex_center(candidate) |
| if center is not None and _hex_edges_present(doc, candidate, center): |
| return center |
| return None |
|
|
|
|
| def _has_circle(doc, center, radius): |
| for entity in doc.modelspace(): |
| if entity.dxftype() != "CIRCLE": |
| continue |
| c = entity.dxf.center |
| if _point_close((c.x, c.y), center) and _close(entity.dxf.radius, radius): |
| return True |
| return False |
|
|
|
|
| def evaluate(): |
| if not check_no_gui_bypass(Path(os.environ.get("OUTPUT_ROOT", "/home/user/Desktop"))): |
| return False |
| path = OUTPUT_ROOT / TARGET |
| if not path.exists() or path.stat().st_size <= 0: |
| return False |
| doc = ezdxf.readfile(path) |
| if int(doc.header.get("$INSUNITS", 0)) != 4: |
| return False |
| center = _hex_center(doc) |
| if center is None: |
| return False |
| return ( |
| _has_circle(doc, center, 10) |
| and _has_circle(doc, (center[0] - 28, center[1]), 3) |
| and _has_circle(doc, (center[0] + 28, center[1]), 3) |
| and all( |
| _has_circle( |
| doc, |
| ( |
| center[0] + 25 * math.cos(math.radians(angle)), |
| center[1] + 25 * math.sin(math.radians(angle)), |
| ), |
| 2, |
| ) |
| for angle in [0, 60, 120, 180, 240, 300] |
| ) |
| ) |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| if not check_no_gui_bypass(OUTPUT_ROOT): |
| ok = False |
| else: |
| ok = evaluate() |
| except Exception: |
| ok = False |
| print("True" if ok else "False") |
|
|
