File size: 30,127 Bytes
5154c4e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 | from __future__ import annotations
import base64
import hashlib
import json
import math
import os
import re
import secrets
import stat
import subprocess
import sys
import tempfile
import zipfile
import xml.etree.ElementTree as ET
from collections import Counter
from pathlib import Path
TARGET = Path("/home/user/Desktop")
REV_A = TARGET / "revision_A.FCStd"
REV_B = TARGET / "revision_B.FCStd"
FCSTD = TARGET / "task-16_B.FCStd"
NC = TARGET / "task-16_B.nc"
FREECADCMD = Path("/usr/bin/freecadcmd")
EXPECTED_A_SHA256 = "b57967bf2111f32cf46af5a7ad3dc40681ac531ef4e85aa590c93898e4c32526"
EXPECTED_B_SHA256 = "57a44df014456db5ca83832c6f7d52596c1c80e460ba9b4a2dc3dd3262950ca4"
EXPECTED_VERSION = ("0", "21", "2", "33771 (Git)")
EXPECTED_COMMIT = "b9bfa5c5507506e4515816414cd27f4851d00489"
TIMESTAMP_RE = re.compile(r"\(Output Time:[^()\r\n]*\)")
NUMBER = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)"
WORD_RE = re.compile(rf"([A-Z])\s*({NUMBER})", re.ASCII)
ALLOWED_ADDRESSES = {"N", "G", "M", "T", "H", "S", "F", "X", "Y", "Z", "I", "J", "R", "Q", "P"}
ALLOWED_G = {0, 1, 2, 3, 17, 21, 40, 43, 49, 54, 80, 81, 82, 83, 90, 94, 98, 99}
ALLOWED_M = {2, 3, 4, 5, 6, 7, 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,
("Path.Tool.Controller", "ToolController"): 2,
("Path.Tool.Bit", "ToolBit"): 2,
("Path.Op.PocketShape", "ObjectPocket"): 1,
("Path.Op.Drilling", "ObjectDrilling"): 1,
("draftobjects.clone", "Clone"): 1,
})
OPTIONAL_PROXIES = {}
def fail(message):
print("task-16 evaluator: " + message, file=sys.stderr)
return False
def close(a, b, tolerance=1e-6):
try:
left, right = float(a), float(b)
except (TypeError, ValueError):
return False
return math.isfinite(left) and math.isfinite(right) and abs(left - right) <= tolerance
def regular_file(path, minimum, maximum):
try:
info = path.lstat()
except OSError:
return False
return stat.S_ISREG(info.st_mode) and not path.is_symlink() and minimum <= info.st_size <= maximum
def sha256(path):
digest = hashlib.sha256()
with path.open("rb") as stream:
for chunk in iter(lambda: stream.read(1024 * 1024), b""):
digest.update(chunk)
return digest.hexdigest()
def proxy_manifest(document):
root = ET.fromstring(document)
result = Counter()
for element in root.iter("Python"):
module, class_name = element.attrib.get("module"), element.attrib.get("class")
encoded, value = element.attrib.get("encoded"), element.attrib.get("value")
if encoded != "yes" or not isinstance(value, str) or len(value) > 100_000:
raise ValueError("invalid proxy serialization")
payload = json.loads(base64.b64decode(value, validate=True).decode("utf-8"))
if module is None and class_name is None:
if payload is not None:
raise ValueError("invalid null feature proxy")
elif (module, class_name) == ("draftobjects.clone", "Clone"):
if not isinstance(payload, str):
raise ValueError("invalid clone proxy")
elif payload is not None and not isinstance(payload, dict):
raise ValueError("invalid proxy payload")
result[(module, class_name)] += 1
return result
def validate_archive(path, expected, null_features):
if not regular_file(path, 2_000 if expected is None else 10_000, 20_000_000):
return False
try:
with zipfile.ZipFile(path) as archive:
names = archive.namelist()
if "Document.xml" not in names or len(names) != len(set(names)) or len(names) > 300:
return False
total = 0
for entry in archive.infolist():
pure = Path(entry.filename)
if pure.is_absolute() or ".." in pure.parts or entry.file_size > 20_000_000:
return False
total += entry.file_size
if total > 60_000_000 or pure.suffix.lower() in {".py", ".pyc", ".so", ".sh", ".dll"}:
return False
proxies = proxy_manifest(archive.read("Document.xml"))
null_count = proxies.pop((None, None), 0)
if (isinstance(null_features, tuple) and not null_features[0] <= null_count <= null_features[1]) or (not isinstance(null_features, tuple) and null_count != null_features):
return False
if expected is None:
return not proxies
if any(proxies[key] != count for key, count in expected.items()):
return False
if any(proxies[key] > count for key, count in OPTIONAL_PROXIES.items()):
return False
return not (set(proxies) - set(expected) - set(OPTIONAL_PROXIES))
except (OSError, ValueError, UnicodeError, zipfile.BadZipFile, ET.ParseError, json.JSONDecodeError):
return False
def strip_comments(text):
output, in_comment = [], False
for line in text.replace("\r\n", "\n").replace("\r", "\n").split("\n"):
code, index = [], 0
while index < len(line):
char = line[index]
if in_comment:
if char == "(": return None
if char == ")": in_comment = False
elif char == "(": in_comment = True
elif char == ")": return None
elif char == ";": break
else: code.append(char)
index += 1
output.append("".join(code))
return None if in_comment else "\n".join(output)
def integral(value):
rounded = round(value)
return int(rounded) if math.isfinite(value) and abs(value - rounded) <= 1e-9 else None
def parse_nc(path):
try:
executable = strip_comments(path.read_text(encoding="utf-8"))
except (OSError, UnicodeError):
return None
if executable is None:
return None
blocks = []
for raw in executable.splitlines():
line = raw.strip().upper()
if not line or line == "%": continue
words, cursor = [], 0
for match in WORD_RE.finditer(line):
if line[cursor:match.start()].strip(): return None
value = float(match.group(2))
if not math.isfinite(value): return None
words.append((match.group(1), value)); cursor = match.end()
if line[cursor:].strip() or not words or any(letter not in ALLOWED_ADDRESSES for letter, _ in words):
return None
if any(sum(letter == key for letter, _ in words) > 1 for key in ALLOWED_ADDRESSES - {"G", "M"}):
return None
blocks.append(words)
return blocks or None
def validate_nc(path):
if not regular_file(path, 2_000, 2_000_000): return False
blocks = parse_nc(path)
if blocks is None: return False
state = {"units": None, "absolute": False, "motion": None, "cycle": None, "tool": None,
"changed": False, "speed": None, "feed": None, "spindle": False, "retract": None,
"X": None, "Y": None, "Z": None}
changed_tools, cycles, ended, saw_g54 = [], [], False, False
t1_cut_z = []
for index, block in enumerate(blocks):
words = dict(block)
gs = [integral(value) for letter, value in block if letter == "G"]
ms = [integral(value) for letter, value in block if letter == "M"]
if ended or any(code is None or code not in ALLOWED_G for code in gs) or any(code is None or code not in ALLOWED_M for code in ms): return False
if any(sum(code in group for code in gs) > 1 for group in G_MODAL_GROUPS): return False
if len(ms) != len(set(ms)) or (3 in ms and 4 in ms): return False
if 21 in gs: state["units"] = "mm"
if 90 in gs: state["absolute"] = True
if 54 in gs: saw_g54 = True
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 {80, 81, 82, 83}: state["cycle"] = None if code == 80 else code
if "T" in words:
tool = integral(words["T"])
if tool not in {1, 2}: 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): return False
state["speed"] = words["S"]
if "F" in words:
if not close(words["F"], 500, 1e-4): return False
state["feed"] = words["F"]
if 5 in ms: state["spindle"] = False
if 6 in ms:
if state["spindle"] or state["tool"] not in {1, 2}: return False
state["changed"] = True; changed_tools.append(state["tool"])
if 4 in ms: return False
if 3 in ms:
if not state["changed"] or state["speed"] is None: return False
state["spindle"] = True
explicit_motion = next((code for code in gs if code in {0, 1, 2, 3}), None)
if state["tool"] == 2 and explicit_motion in {1, 2, 3}: return False
if explicit_motion == 0 and ("X" in words or "Y" in words):
rapid_z = words.get("Z", state["Z"])
if rapid_z is None or rapid_z <= 18: return False
cycle_initial_z = state["Z"]
for axis in ("X", "Y", "Z"):
if axis in words: state[axis] = words[axis]
explicit_cycle = next((code for code in gs if code in {81, 82, 83}), None)
if explicit_cycle is not None:
if state["tool"] != 2 or state["units"] != "mm" or not state["absolute"] or not saw_g54 or not state["changed"] or not state["spindle"] or state["feed"] is None: return False
if state["X"] is None or state["Y"] is None or "Z" not in words or "R" not in words: return False
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
if not close(words["Z"], 4) or words["R"] <= 18: return False
cycles.append((round(state["X"], 4), round(state["Y"], 4), round(words["Z"], 4)))
state["Z"] = cycle_initial_z if state["retract"] == 98 else words["R"]
elif state["tool"] == 1 and state["motion"] in {1, 2, 3} and state["Z"] is not None:
if not state["spindle"] or state["feed"] is None: return False
t1_cut_z.append(state["Z"])
if 2 in ms or 30 in ms:
if index != len(blocks) - 1 or state["spindle"]: return False
ended = True
expected_holes = {(-48.0, -28.0), (42.0, -28.0), (-48.0, 24.0), (42.0, 24.0)}
return (ended and changed_tools == [1, 2] and len(cycles) == 4 and
{value[:2] for value in cycles} == expected_holes and
t1_cut_z and close(min(t1_cut_z), 10) and min(t1_cut_z) >= 10 - 1e-6)
def normalized_nc(path):
try: text = path.read_text(encoding="utf-8")
except (OSError, UnicodeError): return None
return TIMESTAMP_RE.sub("(Output Time:<normalized>)", text).replace("\r\n", "\n").replace("\r", "\n")
CHILD_SOURCE = r'''
import hashlib, json, math, os, pathlib, 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_A_SHA256="b57967bf2111f32cf46af5a7ad3dc40681ac531ef4e85aa590c93898e4c32526"
EXPECTED_B_SHA256="57a44df014456db5ca83832c6f7d52596c1c80e460ba9b4a2dc3dd3262950ca4"
ENDMILL_FILE="/usr/share/freecad/Mod/Path/Tools/Bit/5mm_Endmill.fctb"
DRILL_FILE="/usr/share/freecad/Mod/Path/Tools/Bit/5mm_Drill.fctb"
SPECS={"A":{"pocket":(60.0,36.0),"holes":((-45.0,-26.0),(45.0,-26.0),(-45.0,26.0),(45.0,26.0))},"B":{"pocket":(72.0,44.0),"holes":((-48.0,-28.0),(42.0,-28.0),(-48.0,24.0),(42.0,24.0))}}
def close(a,b,t=1e-6):
try:return math.isfinite(float(a)) and math.isfinite(float(b)) and abs(float(a)-float(b))<=t
except (TypeError,ValueError):return False
def proxy_module(o): return getattr(getattr(o,"Proxy",None).__class__,"__module__","")
def same_volume(a,b,t=1e-5): return a.isValid() and b.isValid() and a.cut(b).Volume<=t and b.cut(a).Volume<=t
def exact_bounds(shape,target):
box=shape.BoundBox;actual=(box.XMin,box.XMax,box.YMin,box.YMax,box.ZMin,box.ZMax)
return shape.isValid() and all(close(a,b) for a,b in zip(actual,target))
def expected_shape(letter):
spec=SPECS[letter];l,w=spec["pocket"]
shape=Part.makeBox(120,80,18,App.Vector(-60,-40,0)).cut(Part.makeBox(l,w,8,App.Vector(-l/2,-w/2,10)))
for x,y in spec["holes"]:shape=shape.cut(Part.makeCylinder(3,14,App.Vector(x,y,4)))
return shape
def verify_revision(doc,letter):
part=doc.getObject("Revision%sPart"%letter);boundary=doc.getObject("Revision%sPocketBoundary"%letter)
if part is None or boundary is None or not same_volume(part.Shape,expected_shape(letter)):return None
spec=SPECS[letter];l,w=spec["pocket"]
if str(part.RevisionID)!=letter or not close(part.PocketLength,l) or not close(part.PocketWidth,w) or not close(part.PocketFloorZ,10) or not close(part.HoleDiameter,6) or not close(part.HoleFloorZ,4):return None
if boundary.Part!=part or len(boundary.Shape.Faces)!=1 or len(boundary.Shape.Edges)!=4 or len(boundary.Shape.Vertexes)!=4 or not exact_bounds(boundary.Shape,(-l/2,l/2,-w/2,w/2,18,18)) or not close(boundary.Shape.Area,l*w):return None
records=[]
for i,xy in enumerate(spec["holes"],1):
o=doc.getObject("Revision%sH%02d"%(letter,i))
if o is None or str(o.HoleID)!="H%02d"%i or not close(o.CenterX,xy[0]) or not close(o.CenterY,xy[1]) or not close(o.Diameter,6) or not close(o.TopZ,18) or not close(o.BottomZ,4):return None
records.append(o)
return part,boundary,records
def command_signature(op):
out=[]
for c in op.Path.Commands:
out.append((str(c.Name).upper().replace(" ",""),tuple(sorted((str(k),round(float(v),6)) for k,v in c.Parameters.items()))))
return tuple(out)
def segment_distance(px,py,a,b):
ax,ay=a;bx,by=b;dx=bx-ax;dy=by-ay
if close(dx,0) and close(dy,0):return math.hypot(px-ax,py-ay)
t=max(0,min(1,((px-ax)*dx+(py-ay)*dy)/(dx*dx+dy*dy)))
return math.hypot(px-(ax+t*dx),py-(ay+t*dy))
def cut_segments(op):
pos={"X":None,"Y":None,"Z":None};segments=[]
for c in op.Path.Commands:
name=str(c.Name).upper().replace(" ","");before=dict(pos)
for axis in pos:
if axis in c.Parameters:pos[axis]=float(c.Parameters[axis])
if name=="G1" and all(before[a] is not None and pos[a] is not None for a in pos):
segments.append((before["X"],before["Y"],before["Z"],pos["X"],pos["Y"],pos["Z"]))
elif name in {"G2","G3"}:
if not all(before[a] is not None and pos[a] is not None for a in pos) or "I" not in c.Parameters or "J" not in c.Parameters:return None
cx=before["X"]+float(c.Parameters["I"]);cy=before["Y"]+float(c.Parameters["J"]);r=math.hypot(before["X"]-cx,before["Y"]-cy)
a0=math.atan2(before["Y"]-cy,before["X"]-cx);a1=math.atan2(pos["Y"]-cy,pos["X"]-cx)
if name=="G2":
while a1>=a0:a1-=2*math.pi
else:
while a1<=a0:a1+=2*math.pi
sweep=a1-a0;count=max(8,int(abs(sweep)*max(r,1)/0.5));angles={a0+sweep*i/count for i in range(1,count+1)}
low,high=min(a0,a1),max(a0,a1);first=int(math.floor(low/(math.pi/2)))-1;last_cardinal=int(math.ceil(high/(math.pi/2)))+1
angles.update(k*math.pi/2 for k in range(first,last_cardinal+1) if low-1e-12<=k*math.pi/2<=high+1e-12)
ordered=sorted(angles,reverse=sweep<0);last=(before["X"],before["Y"]);previous_z=before["Z"]
for a in ordered:
fraction=(a-a0)/sweep;cur=(cx+r*math.cos(a),cy+r*math.sin(a));z=before["Z"]+(pos["Z"]-before["Z"])*fraction;segments.append((last[0],last[1],previous_z,cur[0],cur[1],z));last=cur;previous_z=z
return segments
def validate_pocket_path(op):
segments=cut_segments(op)
if not segments:return False
pos={"X":None,"Y":None,"Z":None}
for c in op.Path.Commands:
name=str(c.Name).upper().replace(" ","");before=dict(pos)
if name=="G0" and any(axis in c.Parameters for axis in ("X","Y")):
effective_z=float(c.Parameters["Z"]) if "Z" in c.Parameters else before["Z"]
if effective_z is None or effective_z<=18:return False
for axis in pos:
if axis in c.Parameters:pos[axis]=float(c.Parameters[axis])
if any(min(z1,z2)<10-1e-6 or x1<-32-1e-4 or x1>32+1e-4 or x2<-32-1e-4 or x2>32+1e-4 or y1<-18-1e-4 or y1>18+1e-4 or y2<-18-1e-4 or y2>18+1e-4 for x1,y1,z1,x2,y2,z2 in segments if min(z1,z2)<18-1e-6):return False
final=[(x1,y1,x2,y2) for x1,y1,z1,x2,y2,z2 in segments if close(z1,10) and close(z2,10)]
if not final:return False
if min(min(s[0],s[2]) for s in final)>-32+1e-4 or max(max(s[0],s[2]) for s in final)<32-1e-4 or min(min(s[1],s[3]) for s in final)>-18+1e-4 or max(max(s[1],s[3]) for s in final)<18-1e-4:return False
for x in range(-32,33,2):
for y in range(-18,19,2):
if min(segment_distance(x,y,(s[0],s[1]),(s[2],s[3])) for s in final)>4.001:return False
return True
def comparison_semantics(o,part,records):
try:
if o.TypeId!="App::FeaturePython" or proxy_module(o) not in {"","builtins"}:return False
kinds={"RecordRole":"App::PropertyString","RevisionAFile":"App::PropertyFile","RevisionBFile":"App::PropertyFile","RevisionASHA256":"App::PropertyString","RevisionBSHA256":"App::PropertyString","PocketALength":"App::PropertyLength","PocketAWidth":"App::PropertyLength","PocketBLength":"App::PropertyLength","PocketBWidth":"App::PropertyLength","PocketFloorZ":"App::PropertyLength","HoleAX":"App::PropertyStringList","HoleAY":"App::PropertyStringList","HoleBX":"App::PropertyStringList","HoleBY":"App::PropertyStringList","MachinedRevision":"App::PropertyString","RevisionBPart":"App::PropertyLink","RevisionBHoles":"App::PropertyLinkList"}
if any(prop not in o.PropertiesList or o.getTypeIdOfProperty(prop)!=kind for prop,kind in kinds.items()):return False
def values(name):return tuple(float(x) for x in o.getPropertyByName(name))
return (str(o.RecordRole).strip().upper()=="REVISIONCOMPARISON" and os.path.normpath(str(o.RevisionAFile))=="/home/user/Desktop/revision_A.FCStd" and os.path.normpath(str(o.RevisionBFile))=="/home/user/Desktop/revision_B.FCStd" and str(o.RevisionASHA256).lower()==EXPECTED_A_SHA256 and str(o.RevisionBSHA256).lower()==EXPECTED_B_SHA256 and close(o.PocketALength,60) and close(o.PocketAWidth,36) and close(o.PocketBLength,72) and close(o.PocketBWidth,44) and close(o.PocketFloorZ,10) and values("HoleAX")==(-45,45,-45,45) and values("HoleAY")==(-26,-26,26,26) and values("HoleBX")==(-48,42,-48,42) and values("HoleBY")==(-28,-28,24,24) and str(o.MachinedRevision).strip().upper() in {"B","B ONLY","REVISION B ONLY"} and o.RevisionBPart==part and set(o.RevisionBHoles)==set(records) and len(o.RevisionBHoles)==4)
except (AttributeError,TypeError,ValueError):return False
def comparison_candidate(o):
fields={"RecordRole","RevisionAFile","RevisionBFile","RevisionASHA256","RevisionBSHA256","PocketALength","PocketAWidth","PocketBLength","PocketBWidth","PocketFloorZ","HoleAX","HoleAY","HoleBX","HoleBY","MachinedRevision","RevisionBPart","RevisionBHoles"}
return o.TypeId=="App::FeaturePython" and bool(fields & set(o.PropertiesList))
def expected_tool_shape(doc,template,name,parameters):
import Path.Tool.Bit as PathToolBit
tool=PathToolBit.Factory.CreateFrom(template,name)
for key,value in parameters.items():setattr(tool,key,value)
tool.Proxy.loadBitBody(tool,force=True);tool.Proxy._updateBitShape(tool);tool.Proxy.unloadBitBody(tool);doc.recompute()
return tool
def cycle_signature(op):
out=[];pos={"X":None,"Y":None,"Z":None};cycle_active=False;retract=None
for c in op.Path.Commands:
n=str(c.Name).upper().replace(" ","");before=dict(pos)
if n=="G98":retract=98
if n=="G99":retract=99
if n in {"G1","G2","G3"}:return None
if n=="G0" and any(axis in c.Parameters for axis in ("X","Y")):
effective_z=float(c.Parameters["Z"]) if "Z" in c.Parameters else before["Z"]
if effective_z is None or effective_z<=18:return None
for axis in pos:
if axis in c.Parameters:pos[axis]=float(c.Parameters[axis])
if n in {"G73","G81","G82","G83"}:
cycle_active=True;out.append((n,round(float(c.Parameters["X"]),5),round(float(c.Parameters["Y"]),5),round(float(c.Parameters["Z"]),5),round(float(c.Parameters["R"]),5)));pos["Z"]=before["Z"] if retract==98 else float(c.Parameters["R"])
elif n=="G80":cycle_active=False
elif cycle_active and n!="G0" and any(axis in c.Parameters for axis in ("X","Y","Z")):return None
return tuple(out)
def validate(a_path,b_path,fcstd_path,repost_path,fresh_path):
if tuple(App.Version()[:4])!=EXPECTED_VERSION or App.Version()[-1]!=EXPECTED_COMMIT:return False
if hashlib.sha256(a_path.read_bytes()).hexdigest()!=EXPECTED_A_SHA256 or hashlib.sha256(b_path.read_bytes()).hexdigest()!=EXPECTED_B_SHA256:return False
a=App.openDocument(str(a_path));b=App.openDocument(str(b_path));sa=verify_revision(a,"A");sb=verify_revision(b,"B")
if len(a.Objects)!=7 or len(b.Objects)!=7 or sa is None or sb is None or sa[0].Shape.cut(sb[0].Shape).Volume<=1 or sb[0].Shape.cut(sa[0].Shape).Volume<=1:return False
doc=App.openDocument(str(fcstd_path))
try:
sdoc=verify_revision(doc,"B")
if sdoc is None or not 18<=len(doc.Objects)<=40:return False
part,boundary,records=sdoc
jobs=[o for o in doc.Objects if proxy_module(o)=="Path.Main.Job"]
pockets=[o for o in doc.Objects if proxy_module(o)=="Path.Op.PocketShape"]
drills=[o for o in doc.Objects if proxy_module(o)=="Path.Op.Drilling"]
ctrls=[o for o in doc.Objects if proxy_module(o)=="Path.Tool.Controller"]
tools=[o for o in doc.Objects if proxy_module(o)=="Path.Tool.Bit"]
comparison_candidates=[o for o in doc.Objects if comparison_candidate(o)]
if len(comparison_candidates)!=1 or not comparison_semantics(comparison_candidates[0],part,records) or len(jobs)!=1 or len(pockets)!=1 or len(drills)!=1 or len(ctrls)!=2 or len(tools)!=2:return False
job=jobs[0];pocket=pockets[0];drill=drills[0]
if job.Operations.Group!=[pocket,drill] or [int(c.ToolNumber) for c in job.Tools.Group]!=[1,2] or str(job.PostProcessor).lower()!="linuxcnc" or list(job.Fixtures)!=["G54"] or bool(job.SplitOutput):return False
if os.path.normpath(str(job.PostProcessorOutputFile))!="/home/user/Desktop/task-16_B.nc" or len(job.Model.Group)!=1:return False
model=job.Model.Group[0];stock=job.Stock
if proxy_module(model)!="draftobjects.clone" or list(model.Objects)!=[part] or not same_volume(model.Shape,sb[0].Shape):return False
if proxy_module(stock)!="Path.Main.Stock" or stock.Base!=job.Model or any(not close(getattr(stock,name),0) for name in ("ExtXneg","ExtXpos","ExtYneg","ExtYpos","ExtZneg","ExtZpos")) or not same_volume(stock.Shape,Part.makeBox(120,80,18,App.Vector(-60,-40,0))):return False
if pocket.ToolController not in ctrls or drill.ToolController not in ctrls or pocket.ToolController==drill.ToolController:return False
endmill=pocket.ToolController.Tool;drillbit=drill.ToolController.Tool
if not close(endmill.Diameter,8) or not 8<=float(endmill.CuttingEdgeHeight.Value)<=float(endmill.Length.Value)<=300 or not 0<float(endmill.ShankDiameter.Value)<=50:return False
if not close(drillbit.Diameter,6) or not close(drillbit.TipAngle,118) or not 14<=float(drillbit.Length.Value)<=300:return False
expected_endmill=expected_tool_shape(doc,ENDMILL_FILE,"ExpectedTask16Endmill",{"Diameter":8,"ShankDiameter":endmill.ShankDiameter.Value,"CuttingEdgeHeight":endmill.CuttingEdgeHeight.Value,"Length":endmill.Length.Value})
expected_drill=expected_tool_shape(doc,DRILL_FILE,"ExpectedTask16Drill",{"Diameter":6,"TipAngle":118,"Length":drillbit.Length.Value})
for op,num,diameter,shape_name,expected_shape in ((pocket,1,8,"endmill",expected_endmill.Shape),(drill,2,6,"drill",expected_drill.Shape)):
tc=op.ToolController;tool=tc.Tool
if int(tc.ToolNumber)!=num or tool not in tools or str(tool.ShapeName)!=shape_name or os.path.basename(str(tool.BitShape))!=shape_name+".fcstd" or tool.Shape.isNull() or len(tool.Shape.Solids)!=1 or not same_volume(tool.Shape,expected_shape,1e-4) or not close(tool.Diameter,diameter) or not close(tc.SpindleSpeed,7000) or str(tc.SpindleDir)!="Forward" or not close(tc.HorizFeed.getValueAs("mm/min").Value,500) or not close(tc.VertFeed.getValueAs("mm/min").Value,500):return False
doc.removeObject(expected_endmill.Name);doc.removeObject(expected_drill.Name);doc.recompute()
if not close(drill.ToolController.Tool.TipAngle,118) or not close(pocket.StartDepth,18) or not close(pocket.FinalDepth,10) or not math.isfinite(float(pocket.StepDown.Value)) or pocket.StepDown.Value<=0 or pocket.StepDown.Value>8 or not math.isfinite(float(pocket.StepOver)) or pocket.StepOver<=0 or pocket.StepOver>100 or pocket.SafeHeight.Value<=18 or pocket.ClearanceHeight.Value<=18:return False
if str(pocket.CutMode) not in {"Climb","Conventional"} or str(pocket.OffsetPattern) not in {"ZigZag","Offset","ZigZagOffset","Line","Grid"} or pocket.ToolController.Tool.Diameter.Value!=8:return False
base=list(pocket.Base)
if len(base)!=1 or base[0][0]!=boundary or set(base[0][1])!={"Face1"} or not validate_pocket_path(pocket):return False
if not close(drill.StartDepth,18) or not close(drill.FinalDepth,4) or drill.SafeHeight.Value<=18 or drill.ClearanceHeight.Value<=18 or str(drill.RetractMode) not in {"G98","G99"} or (bool(drill.KeepToolDown)!=(str(drill.RetractMode)=="G99")):return False
if bool(drill.PeckEnabled) and (not math.isfinite(float(drill.PeckDepth.Value)) or drill.PeckDepth.Value<=0):return False
if bool(drill.DwellEnabled) and (not math.isfinite(float(drill.DwellTime)) or drill.DwellTime<0):return False
if bool(drill.PeckEnabled) and bool(drill.DwellEnabled):return False
drill_base=list(drill.Base)
if not drill_base or any(obj!=model or not tuple(subs) for obj,subs in drill_base):return False
sig=cycle_signature(drill);expected=set(SPECS["B"]["holes"])
if len(sig)!=4 or {v[1:3] for v in sig}!=expected or any(not close(v[3],4) or v[4]<=18 for v in sig):return False
sections=PathPostCommand.buildPostList(job)
if len(sections)!=1:return False
PostProcessor.load("linuxcnc").export(sections[0][1],str(repost_path),str(job.PostProcessorArgs))
saved=(command_signature(pocket),command_signature(drill))
for o in doc.Objects:o.touch()
doc.recompute();doc.recompute()
if any(set(map(str,o.State)) & {"Touched","Invalid","Error"} for o in doc.Objects):return False
if (command_signature(pocket),command_signature(drill))!=saved or not validate_pocket_path(pocket) or cycle_signature(drill)!=sig:return False
sections=PathPostCommand.buildPostList(job)
if len(sections)!=1:return False
PostProcessor.load("linuxcnc").export(sections[0][1],str(fresh_path),str(job.PostProcessorArgs))
return True
finally:
App.closeDocument(doc.Name);App.closeDocument(b.Name);App.closeDocument(a.Name)
marker,a_arg,b_arg,fcstd_arg,repost_arg,fresh_arg=sys.argv[1:7]
try:result=validate(pathlib.Path(a_arg),pathlib.Path(b_arg),pathlib.Path(fcstd_arg),pathlib.Path(repost_arg),pathlib.Path(fresh_arg))
except Exception as exc:
print("task-16 FreeCAD validation: %s: %s"%(type(exc).__name__,exc),file=sys.stderr);result=False
print(marker+"="+("True" if result else "False"))
'''
def run_freecad_validation():
try:
executable = FREECADCMD.resolve(strict=True); info = executable.stat()
except OSError: return False
if not stat.S_ISREG(info.st_mode) or info.st_uid != 0 or info.st_mode & (stat.S_IWGRP | stat.S_IWOTH): return False
marker = "TASK16_" + secrets.token_hex(24)
with tempfile.TemporaryDirectory(prefix="engiworld-task16-") as raw:
temp = Path(raw); script = temp / "validate.py"; repost = temp / "repost.nc"; fresh = temp / "fresh.nc"
script.write_text(CHILD_SOURCE, encoding="utf-8"); script.chmod(0o600)
args = [str(script), marker, str(REV_A), str(REV_B), str(FCSTD), str(repost), str(fresh)]
command = [str(executable), "-c", "import builtins,sys; sys.argv=%r; builtins.pythonopen=open; exec(compile(open(%r,encoding='utf-8').read(),%r,'exec'))" % (args, str(script), str(script))]
env = {"PATH":"/usr/bin:/bin","HOME":str(temp),"TMPDIR":str(temp),"LANG":"C.UTF-8","LC_ALL":"C.UTF-8","PYTHONNOUSERSITE":"1","QT_QPA_PLATFORM":"offscreen","XDG_CACHE_HOME":str(temp/".cache"),"XDG_CONFIG_HOME":str(temp/".config")}
try: completed = subprocess.run(command,cwd=temp,env=env,stdin=subprocess.DEVNULL,stdout=subprocess.PIPE,stderr=subprocess.PIPE,text=True,timeout=300,check=False)
except (OSError, subprocess.SubprocessError): return False
expected = marker + "=True"
if completed.returncode != 0 or [line for line in completed.stdout.splitlines() if line.startswith(marker+"=")] != [expected]:
if completed.stderr: print(completed.stderr[-4000:], file=sys.stderr)
return False
base = normalized_nc(NC)
return base is not None and base == normalized_nc(repost) == normalized_nc(fresh) and validate_nc(repost) and validate_nc(fresh)
def main():
if not regular_file(REV_A, 2_000, 10_000_000) or sha256(REV_A) != EXPECTED_A_SHA256 or not validate_archive(REV_A, None, 4): return fail("invalid Revision A init")
if not regular_file(REV_B, 2_000, 10_000_000) or sha256(REV_B) != EXPECTED_B_SHA256 or not validate_archive(REV_B, None, 4): return fail("invalid Revision B init")
if not validate_archive(FCSTD, REQUIRED_PROXIES, (3, 20)): return fail("invalid answer FCStd archive")
if not validate_nc(NC): return fail("invalid NC semantics")
if not run_freecad_validation(): return fail("native FreeCAD validation or fresh repost failed")
return True
if __name__ == "__main__":
try: outcome = main()
except Exception as exc:
print("task-16 evaluator: %s: %s" % (type(exc).__name__, exc), file=sys.stderr); outcome = False
print("True" if outcome else "False")
|