Umut CANandClaude Opus 5
3ef316d520
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
82 lines
2.8 KiB
Python
82 lines
2.8 KiB
Python
"""Parts-list rows to a file: CSV always, XLSX when openpyxl is installed.
|
|
|
|
CSV needs nothing but the standard library, so the deliverable is never blocked
|
|
-- which is exactly why `xlsx_write` can be a capability rather than a hard
|
|
dependency. The refusal names both the missing package and the format that
|
|
always works.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import csv
|
|
from importlib.util import find_spec
|
|
from pathlib import Path
|
|
|
|
from backends.capability import UnsupportedCapabilityError
|
|
from engineering.sheet.bom import BOM_COLUMNS, COLUMN_LABELS, DEFAULT_COLUMNS
|
|
|
|
__all__ = ["EXTRACT_FORMATS", "write_rows", "xlsx_available"]
|
|
|
|
EXTRACT_FORMATS = ("csv", "xlsx")
|
|
|
|
|
|
def xlsx_available() -> bool:
|
|
"""Is openpyxl importable right now? Re-evaluated per call, so installing
|
|
the package changes the answer without a restart."""
|
|
return find_spec("openpyxl") is not None
|
|
|
|
|
|
def _prepare(rows, columns):
|
|
chosen = tuple(DEFAULT_COLUMNS if columns is None else columns)
|
|
unknown = [c for c in chosen if c not in BOM_COLUMNS]
|
|
if unknown:
|
|
raise ValueError(
|
|
f"unknown parts-list column(s) {', '.join(unknown)}; "
|
|
f"available: {', '.join(BOM_COLUMNS)}"
|
|
)
|
|
body = [[str(row.get(column, "")) for column in chosen] for row in rows]
|
|
if not body:
|
|
raise ValueError("data_extract: there are no parts-list rows to write")
|
|
return chosen, [COLUMN_LABELS[c] for c in chosen], body
|
|
|
|
|
|
def write_rows(rows, path: str, *, columns=None, fmt: str = "csv") -> dict:
|
|
"""Write the rows to `path`. Refuses before the file is created."""
|
|
if fmt not in EXTRACT_FORMATS:
|
|
raise ValueError(f"format must be one of {', '.join(EXTRACT_FORMATS)}; got {fmt!r}")
|
|
chosen, heading, body = _prepare(rows, columns)
|
|
if fmt == "xlsx" and not xlsx_available():
|
|
raise UnsupportedCapabilityError(
|
|
"xlsx_write",
|
|
"data_extract(format='xlsx') needs openpyxl, which is not installed. "
|
|
'Install it with: pip install openpyxl (or pip install -e ".[full]"), '
|
|
"or ask for format='csv', which always works and carries the same rows.",
|
|
)
|
|
|
|
target = Path(path)
|
|
target.parent.mkdir(parents=True, exist_ok=True)
|
|
if fmt == "csv":
|
|
with open(target, "w", newline="", encoding="utf-8") as handle:
|
|
writer = csv.writer(handle)
|
|
writer.writerow(heading)
|
|
writer.writerows(body)
|
|
else:
|
|
from openpyxl import Workbook
|
|
|
|
book = Workbook()
|
|
sheet = book.active
|
|
sheet.title = "Parts list"
|
|
sheet.append(heading)
|
|
for row in body:
|
|
sheet.append(row)
|
|
book.save(target)
|
|
|
|
return {
|
|
"ok": True,
|
|
"path": str(target),
|
|
"format": fmt,
|
|
"columns": list(chosen),
|
|
"rows": len(body),
|
|
"bytes": target.stat().st_size,
|
|
}
|