| 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") |
|
|
