feat(refs): xrefs, raster underlays, data extract and real DWG output
SECTION 24 completes at eleven tools with xref_attach, xref_manage,
image_attach, data_extract and drawing_export_dwg, on the four contract members
that genuinely differ per engine -- backends/contracts/refs.py. Everything else
in the sheet track composes the generic members and is written once.
The ActiveX members were read off the AutoCAD 2026 seat's own type library
(C:\Program Files\Common Files\Autodesk Shared\acax25enu.tlb, "AutoCAD 2025
Type Library" 1.0, the library the running 25.x seat registers) before a line of
the COM path was written, and the measurement is in the code beside the calls:
IAcadModelSpace.AttachExternalReference(PathName, Name, InsertionPoint,
Xscale, Yscale, Zscale, Rotation, bOverlay, Password)
IAcadModelSpace.AddRaster(imageFileName, InsertionPoint, ScaleFactor,
RotationAngle)
IAcadBlock: IsXRef (get), Path (get AND put -- so the repath is an assignment,
not a method), Reload(), Unload(), Bind(bPrefixName), Detach(),
XRefDatabase (get)
IAcadDocument.SaveAs(FullFileName, SaveAsType, vSecurityParams)
AcSaveAsType: ac2000_dwg=12 ac2004_dwg=24 ac2007_dwg=36 ac2010_dwg=48
ac2013_dwg=60 ac2018_dwg=64 (=acNative)
The running seat itself was not answering COM while this landed (its window was
Not Responding and GetActiveObject never returned), so the type library -- which
is the same seat's declared surface and reads without a call into the process --
is what the members are measured from; no document of the operator's was opened
or touched. This repository has been bitten four times by a fake that invented a
member, so the COM fakes in the tests model those names and nothing else.
ActiveX angles are radians, so the degree-to-radian conversion happens at that
boundary and nowhere else.
Headlessly, ezdxf.xref.attach carries the attachment (measured on ezdxf 1.4.4:
block flags 20 for an attachment and 24 for an overlay, so "is this an xref" is
flags & (BLK_XREF | BLK_XREF_OVERLAY) -- masking BLK_XREF alone misses every
overlay), add_image_def + add_image the raster, with Pillow reading the pixel
size so the placed image keeps the file's aspect.
Three capability keys, declared in both maps:
dwg_write -- measured absent here (odafc.is_installed() is False), so the
ezdxf entry is a runtime re-evaluation like viewport_render's
matplotlib check rather than a hardcoded False: installing the
ODA File Converter starts the call working with no edit to the
map. The refusal names the install route and drawing_export_dxf.
xref_live -- reload and bind need a live seat's xref manager and are refused
headlessly; list, detach and path are headless and are not
behind the key.
xlsx_write -- openpyxl is optional and absent here; CSV is always available,
so the refusal never blocks the deliverable and says so.
Two numbers the plan predicted wrongly are corrected to what the registry
actually does. `block` outranks `drawing` in _GROUP_TAG_PRIORITY, so the two
xref tools file under `blocks` (9 -> 11) beside block_insert -- which is where
an xref belongs, being a block definition that lives in another file -- and
`drawing` moves 11 -> 12, not 11 -> 14. And `data_extract` must not say "parts
list" in its own text: that is the golden discovery query for
entity_create_table, and a file writer outranking the tool that draws the thing
is a regression the tuning bar catches. It is described by its destination --
a file -- instead.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FKFStjEFzpGyLq5bMpWxTd
This commit is contained in:
Umut CAN
co-authored by
Claude Opus 5
Claude Opus 5
parent
de8dc8f813
commit
3ef316d520
@@ -16,6 +16,7 @@ import time
|
||||
import uuid
|
||||
from collections.abc import Callable
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from importlib.util import find_spec
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
@@ -157,6 +158,28 @@ def _apoint(x: float, y: float, z: float = 0.0):
|
||||
)
|
||||
|
||||
|
||||
def _image_pixels(path: str) -> tuple[int, int]:
|
||||
"""Pixel size of a raster; the placed size is pixels x scale on both engines.
|
||||
|
||||
Copied from the ezdxf backend rather than imported: the two backends must
|
||||
not depend on each other.
|
||||
"""
|
||||
try:
|
||||
from PIL import Image
|
||||
except ImportError as exc: # pragma: no cover - Pillow ships with [pdf]
|
||||
raise ValueError(
|
||||
"image_attach needs Pillow to read the image's pixel size; "
|
||||
'install it with: pip install -e ".[pdf]"'
|
||||
) from exc
|
||||
try:
|
||||
with Image.open(path) as image:
|
||||
return int(image.width), int(image.height)
|
||||
except Exception as exc:
|
||||
raise ValueError(
|
||||
f"image_attach: {path} is not an image this server can read ({exc})"
|
||||
) from exc
|
||||
|
||||
|
||||
def _av(values: list[float]):
|
||||
"""Create a VARIANT double-array from a flat list."""
|
||||
return win32com.client.VARIANT(
|
||||
@@ -1536,6 +1559,16 @@ class ComBackend(AutoCADBackend):
|
||||
"interactive_prompt": FeatureCapability(
|
||||
True, "native", reason="cancel_returns_cancelled_true;timeout_returns_timed_out"
|
||||
),
|
||||
# Track G keys.
|
||||
"dwg_write": FeatureCapability(True, "native", reason="document_saveas"),
|
||||
"xref_live": FeatureCapability(
|
||||
True, "native", reason="block_reload_bind_detach_on_the_live_seat"
|
||||
),
|
||||
"xlsx_write": (
|
||||
FeatureCapability(True, "openpyxl")
|
||||
if find_spec("openpyxl") is not None
|
||||
else FeatureCapability(False, reason="optional_dependency_missing:openpyxl")
|
||||
),
|
||||
},
|
||||
)
|
||||
|
||||
@@ -1805,6 +1838,176 @@ class ComBackend(AutoCADBackend):
|
||||
async def drawing_export_dxf(self, path: str) -> dict:
|
||||
return await self.drawing_save_as(path, "dxf")
|
||||
|
||||
# ── external references, rasters and DWG (v1.6 track G) ──────────────────
|
||||
#
|
||||
# Measured on AutoCAD 2026 (AutoCAD.Application 25.1s), from the live
|
||||
# seat's type library:
|
||||
# ModelSpace.AttachExternalReference(PathName, Name, InsertionPoint,
|
||||
# Xscale, Yscale, Zscale, Rotation, bOverlay, Password)
|
||||
# ModelSpace.AddRaster(imageFileName, InsertionPoint, ScaleFactor,
|
||||
# RotationAngle)
|
||||
# Block: IsXRef, Path, Name, Reload(), Unload(), Bind(bPrefixName),
|
||||
# Detach(), XRefDatabase
|
||||
# Document.SaveAs(FullFileName, SaveAsType, vSecurityParams)
|
||||
# ActiveX angles are radians; the tool boundary is degrees, so every
|
||||
# rotation crosses here and nowhere else.
|
||||
|
||||
#: AcSaveAsType, read off the same type library.
|
||||
_DWG_SAVE_AS = {
|
||||
"R2000": 12,
|
||||
"R2004": 24,
|
||||
"R2007": 36,
|
||||
"R2010": 48,
|
||||
"R2013": 60,
|
||||
"R2018": 64,
|
||||
}
|
||||
|
||||
async def xref_attach(self, path, at, scale=1.0, rotation=0.0, kind="attach") -> dict:
|
||||
from backends.contracts.refs import XREF_KINDS
|
||||
|
||||
if kind not in XREF_KINDS:
|
||||
raise ValueError(f"xref kind must be one of {XREF_KINDS}, got {kind!r}")
|
||||
source = Path(path)
|
||||
if not source.is_file():
|
||||
raise ValueError(f"xref_attach: {path} does not exist")
|
||||
x, y = float(at[0]), float(at[1])
|
||||
for label, value in (("at.x", x), ("at.y", y), ("scale", scale), ("rotation", rotation)):
|
||||
if not math.isfinite(float(value)):
|
||||
raise ValueError(f"xref_attach: {label} must be finite, got {value!r}")
|
||||
if float(scale) <= 0:
|
||||
raise ValueError(f"xref_attach: scale must be positive, got {scale!r}")
|
||||
name = source.stem.upper()
|
||||
factor = float(scale)
|
||||
radians = math.radians(float(rotation))
|
||||
|
||||
def _sync():
|
||||
doc = _acad_doc()
|
||||
reference = doc.ModelSpace.AttachExternalReference(
|
||||
str(source),
|
||||
name,
|
||||
_apoint(x, y),
|
||||
factor,
|
||||
factor,
|
||||
factor,
|
||||
radians,
|
||||
kind == "overlay",
|
||||
)
|
||||
return {
|
||||
"ok": True,
|
||||
"name": name,
|
||||
"path": str(source),
|
||||
"kind": kind,
|
||||
"handle": reference.Handle,
|
||||
"at": [x, y],
|
||||
"scale": factor,
|
||||
"rotation": float(rotation),
|
||||
"backend": self.name,
|
||||
}
|
||||
|
||||
return await self._run(_sync)
|
||||
|
||||
async def xref_manage(self, name, action, new_path=None) -> dict:
|
||||
from backends.contracts.refs import XREF_ACTIONS
|
||||
|
||||
if action not in XREF_ACTIONS:
|
||||
raise ValueError(f"xref action must be one of {XREF_ACTIONS}, got {action!r}")
|
||||
if action == "path" and not (new_path or "").strip():
|
||||
raise ValueError("xref_manage(action='path') needs new_path")
|
||||
|
||||
def _sync():
|
||||
doc = _acad_doc()
|
||||
|
||||
def _xref_blocks():
|
||||
found = []
|
||||
for index in range(doc.Blocks.Count):
|
||||
block = doc.Blocks.Item(index)
|
||||
try:
|
||||
if block.IsXRef:
|
||||
found.append(block)
|
||||
except Exception: # noqa: BLE001 - a block that cannot answer is not an xref
|
||||
continue
|
||||
return found
|
||||
|
||||
if action == "list":
|
||||
rows = [
|
||||
{"name": b.Name, "path": str(b.Path or ""), "kind": "attach", "inserts": None}
|
||||
for b in _xref_blocks()
|
||||
]
|
||||
rows.sort(key=lambda row: row["name"])
|
||||
return {"ok": True, "xrefs": rows, "backend": self.name}
|
||||
|
||||
key = str(name).strip()
|
||||
block = next((b for b in _xref_blocks() if b.Name == key), None)
|
||||
if block is None:
|
||||
raise ValueError(
|
||||
f"xref_manage: {key!r} is not an external reference in this drawing"
|
||||
)
|
||||
if action == "reload":
|
||||
block.Reload()
|
||||
return {"ok": True, "name": key, "action": action, "backend": self.name}
|
||||
if action == "bind":
|
||||
block.Bind(False)
|
||||
return {"ok": True, "name": key, "action": action, "backend": self.name}
|
||||
if action == "detach":
|
||||
block.Detach()
|
||||
return {"ok": True, "name": key, "inserts_removed": None, "backend": self.name}
|
||||
block.Path = str(new_path)
|
||||
return {"ok": True, "name": key, "path": str(new_path), "backend": self.name}
|
||||
|
||||
return await self._run(_sync)
|
||||
|
||||
async def image_attach(self, path, at, scale=1.0, rotation=0.0) -> dict:
|
||||
source = Path(path)
|
||||
if not source.is_file():
|
||||
raise ValueError(f"image_attach: {path} does not exist")
|
||||
x, y = float(at[0]), float(at[1])
|
||||
for label, value in (("at.x", x), ("at.y", y), ("scale", scale), ("rotation", rotation)):
|
||||
if not math.isfinite(float(value)):
|
||||
raise ValueError(f"image_attach: {label} must be finite, got {value!r}")
|
||||
if float(scale) <= 0:
|
||||
raise ValueError(f"image_attach: scale must be positive, got {scale!r}")
|
||||
px, py = _image_pixels(str(source))
|
||||
factor = float(scale)
|
||||
radians = math.radians(float(rotation))
|
||||
|
||||
def _sync():
|
||||
doc = _acad_doc()
|
||||
raster = doc.ModelSpace.AddRaster(str(source), _apoint(x, y), factor, radians)
|
||||
return {
|
||||
"ok": True,
|
||||
"path": str(source),
|
||||
"handle": raster.Handle,
|
||||
"at": [x, y],
|
||||
"scale": factor,
|
||||
"rotation": float(rotation),
|
||||
"pixels": [px, py],
|
||||
"size_mm": [px * factor, py * factor],
|
||||
"backend": self.name,
|
||||
}
|
||||
|
||||
return await self._run(_sync)
|
||||
|
||||
async def drawing_export_dwg(self, path, version="R2018") -> dict:
|
||||
from backends.contracts.refs import DWG_VERSIONS
|
||||
|
||||
if version not in DWG_VERSIONS:
|
||||
raise ValueError(f"DWG version must be one of {DWG_VERSIONS}, got {version!r}")
|
||||
save_as_type = self._DWG_SAVE_AS[version]
|
||||
|
||||
def _sync():
|
||||
doc = _acad_doc()
|
||||
doc.SaveAs(path, save_as_type)
|
||||
target = Path(path)
|
||||
return {
|
||||
"ok": True,
|
||||
"path": path,
|
||||
"version": version,
|
||||
"bytes": target.stat().st_size if target.exists() else None,
|
||||
"backend": self.name,
|
||||
}
|
||||
|
||||
return await self._run(_sync)
|
||||
|
||||
async def drawing_export_pdf(self, path: str, layout: str | None = None) -> dict:
|
||||
"""Plot one layout to PDF through ``Plot.PlotToFile`` and confirm the file.
|
||||
|
||||
|
||||
Reference in New Issue
Block a user