from __future__ import annotations
import builtins as _builtins import json
import os
import sys
import tempfile
import weakref
import ferrocad as _fc
backend = "ferrocad"
Document = _fc.Document
DocumentObject = _fc.DocumentObject
Quantity = _fc.Quantity
StringHasher = _fc.StringHasher
StringID = _fc.StringID
Vector = _fc.Vector
Matrix = _fc.Matrix
Placement = _fc.Placement
Rotation = _fc.Rotation
TypeId = _fc.TypeId
BoundBox = _fc.BoundBox
Material = _fc.Material
Vector2d = _fc.Vector2d
GuiUp = 0
__version__ = _fc.__version__
from . import Base, Units, Console
ScaleType = Base.ScaleType
addDocumentObserver = _fc.addDocumentObserver
removeDocumentObserver = _fc.removeDocumentObserver
def _notify_document(event, name):
gui = sys.modules.get("FerroCADGui")
dispatch = getattr(gui, "_document_event", None) if gui is not None else None
if dispatch is not None:
dispatch(event, name)
def newDocument(name=None, hidden=False, temp=False):
previous = activeDocument()
if previous is not None:
_notify_document("deactivated", previous.Name)
try:
document = _fc.newDocument(name)
except Exception:
current = activeDocument()
if previous is not None and current is not None and current.Name == previous.Name:
_notify_document("activated", previous.Name)
raise
_notify_document("created", document.Name)
_notify_document("activated", document.Name)
return document
def open(name, hidden=False, temporary=False):
return openDocument(name, hidden, temporary)
def openDocument(path, hidden=False, temporary=False):
previous = activeDocument()
if previous is not None:
_notify_document("deactivated", previous.Name)
try:
document = _fc.openDocument(path)
except Exception:
current = activeDocument()
if previous is not None and current is not None and current.Name == previous.Name:
_notify_document("activated", previous.Name)
raise
_notify_document("created", document.Name)
_notify_document("activated", document.Name)
return document
def closeDocument(name):
document = _fc.getDocument(name)
if document is None:
raise ValueError("no document named '%s'" % name)
current = activeDocument()
if current is not None and current.Name == document.Name:
_notify_document("deactivated", document.Name)
_fc.closeDocument(name)
_notify_document("closed", document.Name)
def getDocument(name):
return _fc.getDocument(name)
def setActiveDocument(name):
document = _fc.getDocument(name)
current = activeDocument()
switching = document is not None and (
current is None or current.Name != document.Name
)
if switching and current is not None:
_notify_document("deactivated", current.Name)
_fc.setActiveDocument(name)
if switching:
_notify_document("activated", document.Name)
def listDocuments():
return _fc.listDocuments()
def activeDocument():
return _fc.activeDocument()
def Version():
return __version__.split(".") + ["rust-fc", ""]
__cmake__: dict = {}
def getResourceDir():
import os
root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
return os.path.join(root, "")
__all__ = [
"Version",
"newDocument",
"closeDocument",
"getDocument",
"listDocuments",
"openDocument",
"activeDocument",
"Document",
"DocumentObject",
"ActiveDocument",
"backend",
"ParamGet",
"ParameterGrp",
"ScaleType",
"writeRecoverySnapshotToTransientDir",
]
def __getattr__(name):
if name == "ActiveDocument":
return activeDocument()
raise AttributeError("module 'FreeCAD' has no attribute '%s'" % name)
_parameter_stores = {}
_PARAM_FILE_VERSION = 1
_PARAM_FILE_KEYS = frozenset({"version", "values", "groups"})
_PARAM_FILE_EXPLICIT = None
_PARAM_FILE_STATE = {"path": None, "loaded": False, "reported": set()}
def _parameter_file_path():
if _PARAM_FILE_EXPLICIT is not None:
return _PARAM_FILE_EXPLICIT
environment = os.environ.get("FERROCAD_PARAM_FILE")
if environment:
return os.path.abspath(os.path.expanduser(environment))
if not GuiUp:
return None
base = os.environ.get("XDG_CONFIG_HOME")
if not base:
base = os.path.join(os.path.expanduser("~"), ".config")
return os.path.join(base, "ferrocad", "parameters.json")
def _configure_parameter_file(path):
if path is None or path == "":
explicit = None
else:
explicit = os.path.abspath(os.path.expanduser(os.fspath(path)))
global _PARAM_FILE_EXPLICIT
_PARAM_FILE_EXPLICIT = explicit
_PARAM_FILE_STATE["path"] = None
_PARAM_FILE_STATE["loaded"] = False
def _report_parameter_file(path, kind, detail):
key = (path, kind)
if key in _PARAM_FILE_STATE["reported"]:
return
_PARAM_FILE_STATE["reported"].add(key)
print("FreeCAD: parameter file %s: %s" % (path, detail), file=sys.stderr)
def _raw_param_store(root):
store = _parameter_stores.setdefault(root, {"values": {}, "groups": set()})
store.setdefault("handles", {})
return store
def _param_store(root):
_load_parameter_file()
return _raw_param_store(root)
def _load_parameter_file():
path = _parameter_file_path()
if path is None:
return
state = _PARAM_FILE_STATE
if state["loaded"] and state["path"] == path:
return
state["path"] = path
state["loaded"] = True
try:
with _builtins.open(path, "r", encoding="utf-8") as handle:
data = json.load(handle)
except FileNotFoundError:
return
except (OSError, ValueError) as exc:
_report_parameter_file(path, "read", "cannot read it (%s); starting empty" % exc)
return
if not isinstance(data, dict):
_report_parameter_file(path, "format", "the root is not a JSON object; starting empty")
return
extra = sorted(set(data) - _PARAM_FILE_KEYS)
if extra:
_report_parameter_file(
path, "keys", "ignoring unknown key(s): %s" % ", ".join(extra)
)
if data.get("version") != _PARAM_FILE_VERSION:
_report_parameter_file(
path,
"version",
"unsupported version %r; starting empty" % (data.get("version"),),
)
return
raw_groups = data.get("groups", [])
raw_values = data.get("values", [])
if not isinstance(raw_groups, list) or not isinstance(raw_values, list):
_report_parameter_file(
path, "format", "'groups' and 'values' must be lists; starting empty"
)
return
for entry in raw_groups:
if not isinstance(entry, dict):
_report_parameter_file(path, "groups", "ignoring malformed group entries")
continue
root, group = entry.get("root"), entry.get("path")
if not isinstance(root, str) or not isinstance(group, str):
_report_parameter_file(path, "groups", "ignoring malformed group entries")
continue
_raw_param_store(root)["groups"].add(_collapse(group))
for entry in raw_values:
if not isinstance(entry, dict):
_report_parameter_file(path, "values", "ignoring malformed value entries")
continue
root = entry.get("root")
group = entry.get("group")
name = entry.get("name")
kind = entry.get("kind")
value = entry.get("value")
if (
not isinstance(root, str)
or not isinstance(group, str)
or not isinstance(name, str)
or not isinstance(kind, str)
or not isinstance(value, (bool, int, float, str))
):
_report_parameter_file(path, "values", "ignoring malformed value entries")
continue
group = _collapse(group)
store = _raw_param_store(root)
store["values"][(group, name, kind)] = value
store["groups"].add(group)
def _save_parameter_file():
path = _parameter_file_path()
if path is None:
return
groups = []
values = []
for root, store in _parameter_stores.items():
for group in sorted(store["groups"]):
groups.append({"root": root, "path": group})
for (group, name, kind), value in store["values"].items():
values.append(
{
"root": root,
"group": group,
"name": name,
"kind": kind,
"value": value,
}
)
data = {"version": _PARAM_FILE_VERSION, "groups": groups, "values": values}
directory = os.path.dirname(path) or "."
temporary = None
try:
os.makedirs(directory, exist_ok=True)
descriptor, temporary = tempfile.mkstemp(
prefix=".parameters-", suffix=".json", dir=directory
)
with os.fdopen(descriptor, "w", encoding="utf-8") as handle:
json.dump(data, handle, ensure_ascii=False, indent=2)
handle.write("\n")
handle.flush()
os.fsync(handle.fileno())
os.replace(temporary, path)
temporary = None
except (OSError, TypeError, ValueError) as exc:
_report_parameter_file(path, "write", "cannot save it (%s)" % exc)
finally:
if temporary is not None:
try:
os.unlink(temporary)
except OSError:
pass
def _collapse(path):
return "/".join(part for part in path.split("/") if part)
class ParameterGrp:
def __init__(self, path=""):
path = path.strip("/")
if ":" in path:
root, _, rest = path.partition(":")
else:
root, rest = path, ""
self._init(root, rest.strip("/"), _param_store(root))
def _init(self, root, group, store):
self._root = root
self._group = group
self._store = store
store["groups"].add(group)
store.setdefault("handles", {}).setdefault(group, []).append(weakref.ref(self))
def _full(self, sub):
return (self._group + "/" + sub) if self._group else sub
def _get(self, name, kind, default):
return self._store["values"].get((self._group, name, kind), default)
def _set(self, name, kind, value):
self._store["groups"].add(self._group)
self._store["values"][(self._group, name, kind)] = value
_save_parameter_file()
def _rem(self, name, kind):
key = (self._group, name, kind)
if key in self._store["values"]:
del self._store["values"][key]
_save_parameter_file()
def _names(self, kind):
return [
name
for (group, name, entry_kind) in self._store["values"]
if group == self._group and entry_kind == kind
]
def GetGroup(self, name, _store=None, _group=None):
sub = _collapse(name)
if not sub:
raise ValueError("empty group name")
child = ParameterGrp.__new__(ParameterGrp)
child._init(self._root, self._full(sub), self._store)
return child
def GetGroupName(self):
return self._group.split("/")[-1] if self._group else ""
def GetGroups(self):
prefix = self._group + "/" if self._group else ""
names = set()
for group in self._store["groups"]:
if group == self._group or not group.startswith(prefix):
continue
rest = group[len(prefix) :]
if rest and "/" not in rest:
names.add(rest)
return sorted(names)
def HasGroup(self, name):
return self._full(_collapse(name)) in self._store["groups"]
def RemGroup(self, name):
target = self._full(_collapse(name))
handles = self._store.setdefault("handles", {})
referenced = False
for group, refs in list(handles.items()):
if group != target and not group.startswith(target + "/"):
continue
alive = [ref for ref in refs if ref() is not None]
handles[group] = alive
referenced = referenced or bool(alive)
if referenced:
return
values = self._store["values"]
changed = False
for key in list(values):
group = key[0]
if group == target or group.startswith(target + "/"):
del values[key]
changed = True
groups = self._store["groups"]
for group in list(groups):
if group == target or group.startswith(target + "/"):
groups.discard(group)
changed = True
if changed:
_save_parameter_file()
def Clear(self):
group = self._group
changed = False
for key in list(self._store["values"]):
if group == "" or key[0] == group or key[0].startswith(group + "/"):
del self._store["values"][key]
changed = True
if changed:
_save_parameter_file()
def GetInt(self, name, default=0):
return int(self._get(name, "int", default))
def SetInt(self, name, value):
self._set(name, "int", int(value))
def RemInt(self, name):
self._rem(name, "int")
def GetInts(self):
return self._names("int")
def GetUnsigned(self, name, default=0):
value = self._get(name, "int", None)
return default if value is None else int(value) & 0xFFFFFFFF
def GetUnsigneds(self):
return self._names("int")
def SetUnsigned(self, name, value):
self._set(name, "int", int(value) & 0xFFFFFFFF)
def RemUnsigned(self, name):
self._rem(name, "int")
def GetBool(self, name, default=False):
return bool(self._get(name, "bool", default))
def SetBool(self, name, value):
self._set(name, "bool", bool(value))
def RemBool(self, name):
self._rem(name, "bool")
def GetBools(self):
return self._names("bool")
def GetFloat(self, name, default=0.0):
return float(self._get(name, "float", default))
def SetFloat(self, name, value):
self._set(name, "float", float(value))
def RemFloat(self, name):
self._rem(name, "float")
def GetFloats(self):
return self._names("float")
def GetString(self, name, default=""):
return str(self._get(name, "string", default))
def SetString(self, name, value):
self._set(name, "string", str(value))
def RemString(self, name):
self._rem(name, "string")
def GetStrings(self):
return self._names("string")
def Export(self, path):
import json
data = {}
group = self._group
for (g, name, kind), value in self._store["values"].items():
if g == group or g.startswith(group + "/"):
rel = g[len(group):].lstrip("/")
data["%s\t%s\t%s" % (rel, name, kind)] = value
with _builtins.open(path, "w", encoding="utf-8") as handle:
json.dump(data, handle)
def Import(self, path):
import json
with _builtins.open(path, "r", encoding="utf-8") as handle:
data = json.load(handle)
group = self._group
for key, value in data.items():
rel, name, kind = key.split("\t")
target = (group + "/" + rel) if rel else group
self._store["values"][(target, name, kind)] = value
self._store["groups"].add(target)
if data:
_save_parameter_file()
def __repr__(self):
return "<ParameterGrp '%s:%s'>" % (self._root, self._group)
def ParamGet(path="", create=True):
return ParameterGrp(path)
def _xml_escape(text):
return (
str(text)
.replace("&", "&")
.replace("<", "<")
.replace(">", ">")
.replace('"', """)
.replace("'", "'")
)
def _document_xml(doc):
parts = ['<?xml version="1.0" encoding="utf-8"?>', "<Document>"]
for obj in doc.Objects:
parts.append(
' <Object name="%s" type="%s" />' % (_xml_escape(obj.Name), _xml_escape(obj.TypeId))
)
parts.append("</Document>")
return "\n".join(parts) + "\n"
def writeRecoverySnapshotToTransientDir(doc, compressed=True):
if not doc.canWriteRecoverySnapshot():
raise RuntimeError("cannot write a recovery snapshot while a transaction is open")
import os
import zipfile
transient = doc.TransientDir
os.makedirs(transient, exist_ok=True)
metadata = os.path.join(transient, "fc_recovery_file.xml")
with _builtins.open(metadata, "w", encoding="utf-8") as handle:
handle.write('<?xml version="1.0" encoding="utf-8"?>\n')
handle.write("<AutoRecovery>\n")
handle.write(" <Label>%s</Label>\n" % _xml_escape(doc.Label))
handle.write(" <FileName>%s</FileName>\n" % _xml_escape(doc.FileName))
handle.write("</AutoRecovery>\n")
document_xml = _document_xml(doc)
if compressed:
archive = os.path.join(transient, "fc_recovery_file.fcstd")
with zipfile.ZipFile(archive, "w", zipfile.ZIP_DEFLATED) as recovery:
recovery.writestr("Document.xml", document_xml)
else:
uncompressed = os.path.join(transient, "fc_recovery_files")
os.makedirs(uncompressed, exist_ok=True)
with _builtins.open(os.path.join(uncompressed, "Document.xml"), "w", encoding="utf-8") as handle:
handle.write(document_xml)
return True
class PropertyType:
Prop_None = 0
Prop_ReadOnly = 1
Prop_Transient = 2
Prop_Hidden = 4
Prop_Output = 8
Prop_NoRecompute = 16
Prop_NoPersist = 32