265 lines
9.8 KiB
Python
265 lines
9.8 KiB
Python
import importlib
|
|
import importlib.util
|
|
import json
|
|
import os
|
|
import sys
|
|
|
|
import FreeCAD as App
|
|
|
|
|
|
def property_metadata(obj):
|
|
def json_value(value):
|
|
if value is None or isinstance(value, (bool, int, float, str)):
|
|
return 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 str(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(document, selected_object):
|
|
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 = []
|
|
command_observations = {}
|
|
|
|
def action_enabled(command_id):
|
|
try:
|
|
command = Gui.Command.get(command_id)
|
|
if command is None:
|
|
return None
|
|
actions = command.getAction()
|
|
if not actions:
|
|
return None
|
|
return bool(actions[0].isEnabled())
|
|
except Exception as error:
|
|
return {"error": str(error)}
|
|
|
|
workbenches = []
|
|
for workbench_name in workbench_names:
|
|
try:
|
|
Gui.activateWorkbench(workbench_name)
|
|
command_ids = sorted(set(Gui.listCommands()))
|
|
Gui.Selection.clearSelection()
|
|
empty_selection = {command_id: action_enabled(command_id) for command_id in command_ids}
|
|
Gui.Selection.addSelection(document.Name, selected_object.Name)
|
|
selected_selection = {command_id: action_enabled(command_id) for command_id in command_ids}
|
|
Gui.Selection.clearSelection()
|
|
observations = {
|
|
command_id: {
|
|
"emptySelection": empty_selection.get(command_id),
|
|
"selectedPartBox": selected_selection.get(command_id),
|
|
}
|
|
for command_id in command_ids
|
|
}
|
|
for command_id, observation in observations.items():
|
|
command_observations.setdefault(command_id, []).append({"workbench": workbench_name, **observation})
|
|
workbenches.append({"name": workbench_name, "commandCount": len(command_ids), "status": "probed"})
|
|
except Exception as error:
|
|
try:
|
|
Gui.Selection.clearSelection()
|
|
except Exception:
|
|
pass
|
|
workbenches.append({"name": workbench_name, "commandCount": 0, "status": "probe-failure", "error": str(error)})
|
|
return {
|
|
"available": True,
|
|
"workbenches": workbenches,
|
|
"commands": [
|
|
{"id": command_id, "observations": observations}
|
|
for command_id, observations in sorted(command_observations.items())
|
|
],
|
|
}
|
|
|
|
|
|
document = App.newDocument("ReferenceProbe")
|
|
box_object = document.addObject("Part::Box", "CommandProbeBox")
|
|
modules = [probe_module(name) for name in ALL_REFERENCE_MODULES]
|
|
gui_commands = probe_gui_commands(document, box_object)
|
|
runtime_objects = probe_registered_objects(document)
|
|
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",
|
|
"moduleCount": len(ALL_REFERENCE_MODULES),
|
|
"modules": modules,
|
|
"objects": [probe_object(document, type_id) for type_id in [
|
|
"Part::Box", "Part::Cylinder", "Part::Sphere", "Part::Cone",
|
|
"Part::Feature", "PartDesign::Feature", "Sketcher::SketchObject",
|
|
]],
|
|
"runtimeObjects": runtime_objects,
|
|
"guiCommands": gui_commands,
|
|
}
|
|
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"]})
|
|
}
|
|
App.closeDocument(document.Name)
|
|
print("FREECAD_REFERENCE_RESULT=" + json.dumps(result, sort_keys=True, separators=(",", ":")))
|
|
sys.stdout.flush()
|
|
sys.exit(0)
|