390 lines
16 KiB
Python
390 lines
16 KiB
Python
import importlib
|
|
import importlib.util
|
|
import faulthandler
|
|
import hashlib
|
|
import json
|
|
import os
|
|
import re
|
|
import sys
|
|
|
|
import FreeCAD as App
|
|
|
|
|
|
PROBE_SCOPE = os.environ.get("FREECAD_REFERENCE_SCOPE", "full")
|
|
if PROBE_SCOPE not in {"full", "gui-commands"}:
|
|
raise RuntimeError("Unknown FreeCAD reference probe scope: " + PROBE_SCOPE)
|
|
TRACEBACK_SECONDS = int(os.environ.get("FREECAD_REFERENCE_TRACEBACK_SECONDS", "0"))
|
|
if TRACEBACK_SECONDS > 0:
|
|
faulthandler.dump_traceback_later(TRACEBACK_SECONDS, repeat=True, file=2)
|
|
ISOLATED_GUI_CONFIG = os.environ.get("FREECAD_ORACLE_ISOLATED_CONFIG") == "1"
|
|
if PROBE_SCOPE == "gui-commands" and ISOLATED_GUI_CONFIG:
|
|
App.ParamGet("User parameter:BaseApp/Preferences/Mod/BIM").SetBool("FirstTime", False)
|
|
|
|
|
|
def probe_progress(message):
|
|
print("FREECAD_REFERENCE_PROGRESS=" + message, file=sys.stderr, flush=True)
|
|
|
|
|
|
def property_metadata(obj):
|
|
def stable_text(value):
|
|
text = re.sub(r"0x[0-9a-fA-F]+", "<address>", str(value))
|
|
text = re.sub(r"[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}", "<uuid>", text)
|
|
return re.sub(r"(FreeCAD_Doc_<uuid>_[^/_]+_)\d+", r"\1<run>", text)
|
|
|
|
def json_value(value):
|
|
if value is None or isinstance(value, (bool, int, float)):
|
|
return value
|
|
if isinstance(value, str):
|
|
return stable_text(value)
|
|
if isinstance(value, (list, tuple)):
|
|
return [json_value(item) for item in value]
|
|
if isinstance(value, dict):
|
|
return {str(key): json_value(item) for key, item in value.items()}
|
|
# FreeCAD quantities and placements keep a stable textual form while
|
|
# the report remains valid JSON for every registered property type.
|
|
try:
|
|
return stable_text(value)
|
|
except Exception:
|
|
return "<unserializable>"
|
|
|
|
properties = []
|
|
for name in obj.PropertiesList:
|
|
try:
|
|
type_id = obj.getTypeIdOfProperty(name)
|
|
except Exception:
|
|
type_id = "unknown"
|
|
try:
|
|
group = obj.getGroupOfProperty(name)
|
|
except Exception:
|
|
group = ""
|
|
try:
|
|
status = list(obj.getPropertyStatus(name))
|
|
except Exception:
|
|
status = []
|
|
try:
|
|
default = json_value(getattr(obj, name))
|
|
except Exception:
|
|
default = "<unreadable>"
|
|
properties.append({"name": name, "typeId": type_id, "group": group, "status": status, "default": default})
|
|
return properties
|
|
|
|
|
|
def probe_object(document, type_id):
|
|
object_name = "Reference" + type_id.replace(":", "_")
|
|
try:
|
|
obj = document.addObject(type_id, object_name)
|
|
except Exception as error:
|
|
return {"typeId": type_id, "available": False, "probeStatus": "unavailable", "error": str(error)}
|
|
return {
|
|
"typeId": type_id,
|
|
"available": True,
|
|
"probeStatus": "available",
|
|
"name": obj.Name,
|
|
"runtimeTypeId": obj.TypeId,
|
|
"properties": property_metadata(obj),
|
|
}
|
|
|
|
|
|
def probe_registered_objects(document):
|
|
try:
|
|
registered = sorted(set(str(type_id) for type_id in document.supportedTypes()))
|
|
except Exception as error:
|
|
return {"available": False, "types": [], "error": str(error)}
|
|
|
|
records = []
|
|
for index, type_id in enumerate(registered):
|
|
record = probe_object(document, type_id)
|
|
record["candidateIndex"] = index
|
|
record["candidateSource"] = "Document.supportedTypes"
|
|
records.append(record)
|
|
# A few GUI-only TechDraw providers dereference their view during
|
|
# removeObject(). Keep those instances alive until FreeCAD exits so a
|
|
# probe cannot turn a valid metadata observation into a process crash.
|
|
if not bool(getattr(App, "GuiUp", False)) and record.get("available") and record.get("name"):
|
|
try:
|
|
document.removeObject(record["name"])
|
|
except Exception as error:
|
|
record["cleanupError"] = str(error)
|
|
|
|
return {
|
|
"available": True,
|
|
"candidateSource": "Document.supportedTypes",
|
|
"candidateCount": len(records),
|
|
"availableCount": sum(1 for record in records if record.get("available")),
|
|
"unavailableCount": sum(1 for record in records if not record.get("available")),
|
|
"types": records,
|
|
}
|
|
|
|
|
|
ALL_REFERENCE_MODULES = [
|
|
"AddonManager", "Assembly", "BIM", "CAM", "Cloud", "Draft", "Fem", "Help",
|
|
"Idf", "Import", "Inspection", "JtReader", "Material", "Measure", "Mesh",
|
|
"MeshPart", "OpenSCAD", "Part", "PartDesign", "Plot", "Points",
|
|
"ReverseEngineering", "Robot", "Sandbox", "Show", "Sketcher", "Spreadsheet",
|
|
"Start", "Surface", "TechDraw", "TemplatePyMod", "Test", "Tux", "Web",
|
|
]
|
|
|
|
GUI_REQUIRED_MODULES = {
|
|
"AddonManager", "Assembly", "BIM", "CAM", "Draft", "Fem", "Help", "Idf",
|
|
"Import", "Inspection", "JtReader", "Material", "Measure", "Mesh", "MeshPart",
|
|
"OpenSCAD", "Part", "PartDesign", "Plot", "Points", "ReverseEngineering", "Robot",
|
|
"Sandbox", "Show", "Sketcher", "Spreadsheet", "Start", "Surface", "TechDraw", "Tux",
|
|
"Web",
|
|
}
|
|
|
|
|
|
def module_is_installed(name):
|
|
suffixes = ("", ".py", ".so", ".pyd", ".dll", ".dylib")
|
|
roots = [path for path in sys.path if path]
|
|
try:
|
|
resource_dir = App.getResourceDir()
|
|
roots.extend([resource_dir, os.path.join(resource_dir, "Mod")])
|
|
except Exception:
|
|
pass
|
|
for root in roots:
|
|
for suffix in suffixes:
|
|
if os.path.exists(os.path.join(root, name + suffix)):
|
|
return True
|
|
if os.path.exists(os.path.join(root, name, "__init__" + suffix)):
|
|
return True
|
|
if os.path.exists(os.path.join(root, "Mod", name + suffix)):
|
|
return True
|
|
return False
|
|
|
|
|
|
def probe_module(name):
|
|
gui_required = name in GUI_REQUIRED_MODULES
|
|
installed = module_is_installed(name)
|
|
spec = None
|
|
try:
|
|
spec = importlib.util.find_spec(name)
|
|
except Exception:
|
|
spec = None
|
|
try:
|
|
module = importlib.import_module(name)
|
|
importable = True
|
|
import_error = None
|
|
file = getattr(module, "__file__", None)
|
|
except Exception as caught_error:
|
|
importable = False
|
|
import_error = caught_error
|
|
file = getattr(spec, "origin", None) if spec else None
|
|
compiled = bool(installed or spec)
|
|
if importable and gui_required and not bool(getattr(App, "GuiUp", False)):
|
|
runtime_status = "gui-only-unprobeable"
|
|
elif importable:
|
|
runtime_status = "compiled-importable"
|
|
elif compiled:
|
|
runtime_status = "compiled-import-failure"
|
|
else:
|
|
runtime_status = "not-built"
|
|
result = {
|
|
"name": name,
|
|
"available": importable,
|
|
"compiled": compiled,
|
|
"importable": importable,
|
|
"guiRequired": gui_required,
|
|
"guiAvailable": bool(getattr(App, "GuiUp", False)),
|
|
"runtimeStatus": runtime_status,
|
|
"file": file,
|
|
}
|
|
if import_error is not None:
|
|
result["error"] = str(import_error)
|
|
return result
|
|
|
|
|
|
def probe_gui_commands():
|
|
if not bool(getattr(App, "GuiUp", False)):
|
|
return {"available": False, "workbenches": [], "commands": []}
|
|
try:
|
|
import FreeCADGui as Gui
|
|
except Exception as error:
|
|
return {"available": False, "workbenches": [], "commands": [], "error": str(error)}
|
|
|
|
try:
|
|
workbench_names = sorted(Gui.listWorkbenches().keys())
|
|
except Exception:
|
|
workbench_names = []
|
|
workbench_filter = os.environ.get("FREECAD_GUI_WORKBENCH_FILTER")
|
|
if workbench_filter:
|
|
if workbench_filter not in workbench_names:
|
|
raise RuntimeError("Unknown GUI workbench filter: " + workbench_filter)
|
|
workbench_names = [workbench_filter]
|
|
command_registrations = {}
|
|
|
|
def command_active(command_id):
|
|
try:
|
|
command = Gui.Command.get(command_id)
|
|
if command is None:
|
|
return None
|
|
# StdCmdExpression dereferences its private QAction in isActive().
|
|
# Other commands must use their native predicate; QAction enabled
|
|
# state is only a cached presentation value and misses context changes.
|
|
if command_id == "Std_Expressions":
|
|
actions = command.getAction()
|
|
return bool(actions[0].isEnabled()) if actions else None
|
|
return bool(command.isActive())
|
|
except Exception as error:
|
|
return {"error": str(error)}
|
|
|
|
workbenches = []
|
|
for workbench_name in workbench_names:
|
|
probe_progress("workbench:start:" + workbench_name)
|
|
try:
|
|
Gui.activateWorkbench(workbench_name)
|
|
Gui.updateGui()
|
|
command_ids = sorted(set(Gui.listCommands()))
|
|
for command_id in command_ids:
|
|
command_registrations.setdefault(command_id, []).append(workbench_name)
|
|
workbenches.append({"name": workbench_name, "commandCount": len(command_ids), "status": "probed"})
|
|
probe_progress("workbench:done:" + workbench_name)
|
|
except Exception as error:
|
|
try:
|
|
Gui.Selection.clearSelection()
|
|
except Exception:
|
|
pass
|
|
workbenches.append({"name": workbench_name, "commandCount": 0, "status": "probe-failure", "error": str(error)})
|
|
probe_progress("workbench:failed:" + workbench_name)
|
|
|
|
# Command registration is workbench-scoped, but document/selection state is
|
|
# intrinsic to each command. Probe the state matrix once after all providers
|
|
# are loaded instead of repeating the cumulative command set per workbench.
|
|
for document_name in list(App.listDocuments().keys()):
|
|
App.closeDocument(document_name)
|
|
command_ids = sorted(command_registrations.keys())
|
|
command_universe_sha256 = hashlib.sha256("\n".join(command_ids).encode("utf-8")).hexdigest()
|
|
if os.environ.get("FREECAD_GUI_REGISTRATION_ONLY") == "1":
|
|
return {
|
|
"available": True,
|
|
"probeMode": "registration-only",
|
|
"stateProbe": "not-probed",
|
|
"stateCases": [],
|
|
"directIsActiveBoundary": "not-applicable",
|
|
"commandUniverseCount": len(command_ids),
|
|
"commandUniverseSha256": command_universe_sha256,
|
|
"stateCommandCount": 0,
|
|
"shard": None,
|
|
"workbenches": workbenches,
|
|
"commands": [
|
|
{
|
|
"id": command_id,
|
|
"registeredWorkbenches": command_registrations[command_id],
|
|
}
|
|
for command_id in command_ids
|
|
],
|
|
}
|
|
shard = None
|
|
state_command_ids = command_ids
|
|
shard_spec = os.environ.get("FREECAD_GUI_COMMAND_SHARD")
|
|
if shard_spec:
|
|
try:
|
|
shard_index, shard_count = [int(value) for value in shard_spec.split("/", 1)]
|
|
except Exception:
|
|
raise RuntimeError("FREECAD_GUI_COMMAND_SHARD must use zero-based INDEX/COUNT syntax")
|
|
if shard_count < 1 or shard_index < 0 or shard_index >= shard_count:
|
|
raise RuntimeError("FREECAD_GUI_COMMAND_SHARD is outside its declared range")
|
|
shard_start = len(command_ids) * shard_index // shard_count
|
|
shard_end = len(command_ids) * (shard_index + 1) // shard_count
|
|
state_command_ids = command_ids[shard_start:shard_end]
|
|
shard = {
|
|
"index": shard_index,
|
|
"count": shard_count,
|
|
"start": shard_start,
|
|
"end": shard_end,
|
|
}
|
|
Gui.Selection.clearSelection()
|
|
Gui.updateGui()
|
|
probe_progress("state:start:noDocument")
|
|
no_document = {command_id: command_active(command_id) for command_id in state_command_ids}
|
|
probe_progress("state:done:noDocument")
|
|
context_document = App.newDocument("CommandContext")
|
|
selected_object = context_document.addObject("Part::Box", "CommandProbeBox")
|
|
Gui.updateGui()
|
|
probe_progress("state:start:documentNoSelection")
|
|
document_no_selection = {command_id: command_active(command_id) for command_id in state_command_ids}
|
|
probe_progress("state:done:documentNoSelection")
|
|
Gui.Selection.addSelection(context_document.Name, selected_object.Name)
|
|
Gui.updateGui()
|
|
probe_progress("state:start:selectedPartBox")
|
|
selected_selection = {command_id: command_active(command_id) for command_id in state_command_ids}
|
|
probe_progress("state:done:selectedPartBox")
|
|
Gui.Selection.clearSelection()
|
|
App.closeDocument(context_document.Name)
|
|
return {
|
|
"available": True,
|
|
"probeMode": "state-matrix",
|
|
"stateProbe": "native-is-active-after-workbench-registration-with-Std_Expressions-qaction-guard",
|
|
"stateCases": ["noDocument", "documentNoSelection", "selectedPartBox"],
|
|
"directIsActiveBoundary": "Std_Expressions-only-qaction-guard-for-locked-1.1.1-null-qaction-crash",
|
|
"commandUniverseCount": len(command_ids),
|
|
"commandUniverseSha256": command_universe_sha256,
|
|
"stateCommandCount": len(state_command_ids),
|
|
"shard": shard,
|
|
"workbenches": workbenches,
|
|
"commands": [
|
|
{
|
|
"id": command_id,
|
|
"registeredWorkbenches": command_registrations[command_id],
|
|
"observations": [{
|
|
"workbench": "all-registered-runtime-context",
|
|
"noDocument": no_document.get(command_id),
|
|
"documentNoSelection": document_no_selection.get(command_id),
|
|
"selectedPartBox": selected_selection.get(command_id),
|
|
}],
|
|
}
|
|
for command_id in state_command_ids
|
|
],
|
|
}
|
|
|
|
|
|
modules = []
|
|
if PROBE_SCOPE == "full":
|
|
document = App.newDocument("ReferenceProbe")
|
|
# Creating one native Part object loads the same runtime type registry used
|
|
# by the locked desktop baseline before supportedTypes() is enumerated.
|
|
document.addObject("Part::Box", "TypeRegistryProbeBox")
|
|
modules = [probe_module(name) for name in ALL_REFERENCE_MODULES]
|
|
App.closeDocument(document.Name)
|
|
gui_commands = probe_gui_commands()
|
|
version = App.Version()
|
|
result = {
|
|
"schemaVersion": 1,
|
|
"baselineId": "freecad-1.1.1",
|
|
"freecadVersion": ".".join(str(value) for value in version[:3]),
|
|
"revision": str(version[3]),
|
|
"gitBranch": str(version[6]) if len(version) > 6 else "",
|
|
"gitCommit": str(version[7]) if len(version) > 7 else "",
|
|
"guiUp": bool(getattr(App, "GuiUp", False)),
|
|
"buildPurpose": "desktop-reference-oracle" if bool(getattr(App, "GuiUp", False)) else "headless-reference-oracle",
|
|
"probeScope": PROBE_SCOPE,
|
|
"oracleSetup": {
|
|
"isolatedConfig": ISOLATED_GUI_CONFIG,
|
|
"bimFirstTimeWelcome": "suppressed-before-workbench-activation" if ISOLATED_GUI_CONFIG else "native-user-config",
|
|
},
|
|
"determinism": {
|
|
"schemaVersion": 1,
|
|
"normalizedProcessFields": ["pointer-address", "uuid", "freecad-document-cache-run"],
|
|
},
|
|
"moduleCount": len(modules),
|
|
"modules": modules,
|
|
"guiCommands": gui_commands,
|
|
}
|
|
if PROBE_SCOPE == "full":
|
|
# Workbench activation registers additional GUI-owned document types.
|
|
# Enumerate them only in the independent object/property scope.
|
|
document = App.newDocument("RuntimeObjectProbe")
|
|
document.addObject("Part::Box", "TypeRegistryProbeBox")
|
|
result["runtimeObjects"] = probe_registered_objects(document)
|
|
result["objects"] = [probe_object(document, type_id) for type_id in [
|
|
"Part::Box", "Part::Cylinder", "Part::Sphere", "Part::Cone",
|
|
"Part::Feature", "PartDesign::Feature", "Sketcher::SketchObject",
|
|
]]
|
|
App.closeDocument(document.Name)
|
|
result["moduleStatusSummary"] = {
|
|
status: sum(1 for module in result["modules"] if module["runtimeStatus"] == status)
|
|
for status in sorted({module["runtimeStatus"] for module in result["modules"]})
|
|
}
|
|
print("FREECAD_REFERENCE_RESULT=" + json.dumps(result, sort_keys=True, separators=(",", ":")))
|
|
sys.stdout.flush()
|
|
sys.exit(0)
|