draftwright 0.2.7__tar.gz → 0.2.8__tar.gz

{draftwright-0.2.7 → draftwright-0.2.8}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## v0.2.8 — 2026-07-06
+
+**`--script` now defaults to the declarative `Sheet` DSL.** The editable script the CLI
+writes is the beautiful-Python surface — one commentable line per feature — for both STEP and
+build123d-object input.
+
+### Changed
+
+- **`draftwright … --script` now emits the declarative `Sheet` script by default** (was the
+  imperative edit-verb reconstruction). The imperative reconstruction is still available via
+  `--script --style imperative`. For prismatic parts the generated script reproduces the same
+  drawing as a direct build; a turned shaft's centre lines and base-diameter style are not yet
+  identical (the remaining validity gap, tracked separately). `--style imperative` now errors
+  clearly on a `module:attr` object spec (it reads a STEP file; use the default `sheet`).
+  The Sheet DSL doesn't yet model the title-block / layout aspects the imperative script
+  embeds, so `--script --style sheet` **warns** when `--drawn-by`, `--tolerance`, `--scale`
+  or `--page` is set rather than silently ignoring it (use `--style imperative` to embed them).
+
 ## v0.2.7 — 2026-07-05
 
 **The three authoring modes (ADR 0011 Amendment 1).** Naming how you drive draftwright —

{draftwright-0.2.7 → draftwright-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.7
+Version: 0.2.8
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -678,10 +678,13 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: <3.15,>=3.10
 Requires-Dist: build123d-drafting-helpers>=0.13.0
-Requires-Dist: build123d>=0.9.0
+Requires-Dist: build123d<0.11,>=0.9.0; python_full_version < '3.13'
+Requires-Dist: build123d<0.12,>=0.11; python_full_version >= '3.13'
 Requires-Dist: kiwisolver<2,>=1.4
 Requires-Dist: numpy>=1.24
 Requires-Dist: reportlab>=4.0
@@ -729,7 +732,7 @@ Choose formats, scale, and page; or emit an editable drawing script:
 ```
 draftwright my_part.step --format pdf,dxf     # also: svg, all
 draftwright my_part.step --scale 2 --page A3  # override the auto scale / page
-draftwright my_part.step --script             # write an editable .py drawing script
+draftwright my_part.step --script             # write an editable declarative Sheet script
 ```
 
 `draftwright --help` lists every flag; `--version` prints the version.

{draftwright-0.2.7 → draftwright-0.2.8}/README.md

@@ -38,7 +38,7 @@ Choose formats, scale, and page; or emit an editable drawing script:
 ```
 draftwright my_part.step --format pdf,dxf     # also: svg, all
 draftwright my_part.step --scale 2 --page A3  # override the auto scale / page
-draftwright my_part.step --script             # write an editable .py drawing script
+draftwright my_part.step --script             # write an editable declarative Sheet script
 ```
 
 `draftwright --help` lists every flag; `--version` prints the version.

{draftwright-0.2.7 → draftwright-0.2.8}/pyproject.toml

@@ -4,14 +4,19 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.2.7"
+version = "0.2.8"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
 authors = [{ name = "Paul Fremantle", email = "pzfreo@gmail.com" }]
 requires-python = ">=3.10,<3.15"
 dependencies = [
-    "build123d>=0.9.0",
+    # build123d ≤0.10 pulls cadquery-ocp (VTK), whose VTK caps at Python 3.12; 0.11 switched to
+    # cadquery-ocp-novtk, which ships 3.13/3.14 wheels and drops VTK entirely (draftwright is
+    # headless — it never imports VTK). Split by Python: keep the proven ≤3.12 stack, use 0.11 on
+    # 3.13+. Mirrors pzfreo/build123d-mcp's dependency handling.
+    "build123d>=0.9.0,<0.11 ; python_full_version < '3.13'",
+    "build123d>=0.11,<0.12 ; python_full_version >= '3.13'",
     "build123d-drafting-helpers>=0.13.0",
     "kiwisolver>=1.4,<2",
     "numpy>=1.24",
@@ -30,6 +35,8 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
 
 [project.scripts]
@@ -112,3 +119,12 @@ dev = [
     "pytest-xdist>=3",
     "ruff>=0.4",
 ]
+
+[tool.uv]
+# On Python 3.13/3.14, build123d resolves to 0.11, whose OCP kernel is
+# cadquery-ocp-novtk (VTK dropped from the transitive tree — fine here, draftwright
+# renders headless and never imports VTK). Its 7.9.3.1.1 release ships a broken macOS
+# wheel (no OCP.GccEnt module → build123d fails to import), so pin it out. Only bites
+# when novtk is actually resolved (build123d 0.11); harmless on 0.10/cadquery-ocp.
+# Mirrors pzfreo/build123d-mcp. Remove once upstream fixes the wheel.
+constraint-dependencies = ["cadquery-ocp-novtk!=7.9.3.1.1"]

{draftwright-0.2.7 → draftwright-0.2.8}/src/draftwright/cli.py

@@ -73,6 +73,18 @@ def _emit(dwg, formats: list[str]) -> list[str]:
     return [paths[f] for f in formats]
 
 
+def _looks_like_object_spec(s: str) -> bool:
+    """True when *s* is a ``module:attr`` / ``file.py:attr`` object reference rather than a STEP
+    path (#469). An existing file is never a spec; a plain path — a STEP file, or a Windows
+    ``C:\\…\\part.step`` drive path — has no trailing ``:identifier``, so the pattern rejects it
+    (a Windows drive colon is followed by ``\\``, not an identifier; filenames can't contain ':')."""
+    import re
+
+    if os.path.exists(s):
+        return False
+    return re.match(r"^.+:[A-Za-z_][A-Za-z0-9_]*$", s) is not None
+
+
 def _installed_version() -> str:
     """The installed distribution version (the PyPI version once pip-installed);
     ``"unknown"`` when running from a source tree with no installed metadata."""
@@ -106,10 +118,10 @@ def main(
         False, "--script", help="Write an editable .py drawing script instead of SVG+DXF"
     ),
     style: str = typer.Option(
-        "imperative",
+        "sheet",
         "--style",
-        help="--script flavour: 'imperative' (edit-verb reconstruction) or "
-        "'sheet' (declarative Sheet DSL - one line per feature)",
+        help="--script flavour: 'sheet' (declarative Sheet DSL - one line per feature, "
+        "default) or 'imperative' (edit-verb reconstruction)",
     ),
     pmi: PmiMode = typer.Option(
         PmiMode.off,
@@ -154,12 +166,44 @@ def main(
 
     if script:
         if style == "sheet":
-            from draftwright.sheet_emit import generate_sheet_script
-
-            py_path = generate_sheet_script(
-                step_file, out=out, title=title, number=number, pmi=pmi.value
-            )
+            from draftwright.sheet_emit import generate_sheet_script, resolve_object_spec
+
+            # The Sheet DSL doesn't yet model the title-block / layout aspects the
+            # imperative script embeds. Warn rather than silently drop them so a
+            # `--script --drawn-by … --scale …` invocation isn't quietly a no-op.
+            ignored = [
+                flag
+                for flag, set_ in (
+                    ("--tolerance", tolerance != "ISO 2768-m"),
+                    ("--drawn-by", bool(drawn_by)),
+                    ("--scale", scale is not None),
+                    ("--page", page is not None),
+                )
+                if set_
+            ]
+            if ignored:
+                typer.echo(
+                    f"warning: {', '.join(ignored)} not supported by --style sheet; ignored "
+                    "(use --style imperative to embed them)",
+                    err=True,
+                )
+            if _looks_like_object_spec(step_file):
+                # STEP_FILE is a `module:attr` / `file.py:attr` spec → reference a live object
+                obj, seam = resolve_object_spec(step_file)
+                py_path = generate_sheet_script(
+                    obj, out=out, title=title, number=number, part_expr=seam
+                )
+            else:
+                py_path = generate_sheet_script(
+                    step_file, out=out, title=title, number=number, pmi=pmi.value
+                )
         else:
+            if _looks_like_object_spec(step_file):
+                raise typer.BadParameter(
+                    "the imperative reconstruction reads a STEP file; use --style sheet "
+                    "(the default) to reference a 'module:attr' object",
+                    param_hint="--style",
+                )
             py_path = generate_script(
                 step_file=step_file,
                 out=out,

{draftwright-0.2.7 → draftwright-0.2.8}/src/draftwright/sheet_dsl.py

@@ -15,9 +15,9 @@ detection is skipped and the auto-pass dimensions exactly the declared features:
 **Scope (this module):** the *feature-declaration* surface over the renderers the
 engine has today — dimensions, ⌀ callouts, holes (through / blind), turned steps,
 slots, patterns, the overall envelope, and the auto section — plus the P2a
-**``.tolerance``** aspect (a ± / limit tolerance on a diameter, a step, or a hole
-bore). The remaining #445 aspect verbs that still need new rendering — ``.fit``
-(fit-class → ISO 286 deviation), ``.thread``, ``.finish`` (surface symbols) and
+**``.tolerance``** (a ± / limit tolerance on a diameter, a step, or a hole bore) and
+**``.fit``** (fit-class → ISO 286 deviation, P2a.2) aspects. The remaining #445 aspect
+verbs that still need new rendering — ``.thread``, ``.finish`` (surface symbols) and
 ``control(...)`` (GD&T) — are the later Phase-2 items (roadmap #446) and are
 deliberately **not** stubbed here, so the surface only exposes what actually draws.
 

{draftwright-0.2.7 → draftwright-0.2.8}/src/draftwright/sheet_emit.py

@@ -11,9 +11,11 @@ detection didn't model (chamfers, fillets, turned profiles) yet reads as authori
 *has* the objects (mode 3b) wires their real part into the seam and swaps the number lines for
 ``sheet.hole(obj)`` references — the emitter's numbers are a starting point, not a ceiling.
 
-Kinds with no declarative verb yet (``step_level``/``rotational``/``pmi``) are flagged inline as
-auto-dimensioned — never silently dropped. Fidelity: the script reproduces a lint-clean drawing of
-the same features (the auto-pass runs over the declared model), not a byte copy of the detected sheet.
+Kinds with no declarative verb yet (``step_level``/``rotational``/``pmi``) are flagged inline —
+never silently dropped — and left to the auto-pass that runs over the declared model on re-run.
+Fidelity: the script reproduces a lint-clean drawing of the same features, not a byte copy of the
+detected sheet; some aspects a declarative verb would pin are not yet reproduced faithfully — a
+turned shaft drops its centre lines and renders the base ⌀ as a leader (the #472 validity gap).
 """
 
 from __future__ import annotations
@@ -112,10 +114,17 @@ def _feature_line(f) -> str:
 
 
 def _needs_section(model) -> bool:
-    return any(
-        f.kind == "hole" and f.frame.axis == "z" and (f.cbore or f.spotface or not f.through)
-        for f in model.features
-    )
+    """Mirror planner.plan_sections' trigger so the emitted comment matches what the drawing
+    actually does: any Z-axis hole/pattern whose bore has a counterbore, spotface, or blind
+    bottom. A pattern carries the bore on its ``member`` hole, so a counterbored bolt circle
+    counts too (checking only top-level holes missed it)."""
+    for f in model.features:
+        if f.kind not in ("hole", "pattern") or f.frame.axis != "z":
+            continue
+        bore = f.member if f.kind == "pattern" else f
+        if bore.cbore or bore.spotface or not bore.through:
+            return True
+    return False
 
 
 _HEADER = '''"""Editable drawing — generated by draftwright (declarative Sheet DSL).
@@ -156,6 +165,87 @@ def emit_sheet_script(model, part_expr: str, stem: str, *, title: str, number: s
     return "\n".join(lines) + "\n"
 
 
+def resolve_object_spec(spec: str) -> tuple[Shape, str]:
+    """Resolve a ``module:attr`` (or ``path/to/file.py:attr``) spec into ``(build123d object,
+    import seam)`` (ADR 0011, #469). The attribute is imported; a zero-argument callable (a
+    ``make_part()`` factory) is called. The returned seam is the Python that re-binds ``part``
+    in the generated script, so the drawing references your **live parametric source**, not a
+    frozen STEP.
+
+    SECURITY: importing the target executes its module-level code — the same trust as running
+    the file yourself."""
+    import importlib
+    import importlib.util
+    import inspect
+    import os
+    import sys
+
+    mod_ref, sep, name = spec.rpartition(":")
+    if not sep or not name.isidentifier() or not mod_ref:
+        raise ValueError(f"object spec must be 'module:attr' or 'file.py:attr' (got {spec!r})")
+
+    if mod_ref.endswith(".py"):
+        path = Path(mod_ref).resolve()
+        ispec = importlib.util.spec_from_file_location(path.stem, path)
+        if ispec is None or ispec.loader is None:
+            raise ValueError(f"cannot load module from {mod_ref!r}")
+        module = importlib.util.module_from_spec(ispec)
+        # Register before exec so a self-referential target resolves (a dataclass whose
+        # forward-ref annotations get typing.get_type_hints'd, a module reading
+        # sys.modules[__name__], import-time pickling). The seam does the same on re-run.
+        sys.modules[ispec.name] = module
+        try:
+            ispec.loader.exec_module(module)
+        except Exception as e:
+            raise ValueError(f"{spec!r}: importing {mod_ref!r} failed: {e}") from e
+        seam = (
+            "import importlib.util as _ilu, sys as _sys\n"
+            f"_spec = _ilu.spec_from_file_location({path.stem!r}, {str(path)!r})\n"
+            "_mod = _ilu.module_from_spec(_spec)\n_sys.modules[_spec.name] = _mod\n"
+            "_spec.loader.exec_module(_mod)"
+        )
+        ref = f"_mod.{name}"
+    else:
+        cwd = os.getcwd()
+        if cwd not in sys.path:
+            sys.path.insert(0, cwd)  # allow a cwd-relative import
+        try:
+            module = importlib.import_module(mod_ref)
+        except ImportError as e:
+            raise ValueError(f"{spec!r}: cannot import module {mod_ref!r}: {e}") from e
+        # Record the invocation cwd (where the module resolved) on the generated script's path,
+        # so `from mod import …` works from any working directory — Python puts only the
+        # *script's* dir on sys.path, not the cwd, so a bare import would otherwise fail.
+        # (For an installed module the insert is harmless; the import works regardless.)
+        seam = (
+            f"import sys as _sys\nif {cwd!r} not in _sys.path:\n    _sys.path.insert(0, {cwd!r})\n"
+            f"from {mod_ref} import {name} as _obj"
+        )
+        ref = "_obj"
+
+    if not hasattr(module, name):  # `hasattr`, not a None sentinel: a name bound to None exists
+        raise ValueError(f"{spec!r}: {name!r} not found in {mod_ref!r}")
+    obj = getattr(module, name)
+
+    called = False
+    if callable(obj) and not isinstance(obj, Shape):
+        required = [
+            p
+            for p in inspect.signature(obj).parameters.values()
+            if p.default is p.empty and p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+        ]
+        if required:
+            raise ValueError(
+                f"{spec!r}: {name} needs arguments — reference a built object instead"
+            )
+        obj, called = obj(), True
+
+    if not isinstance(obj, Shape):
+        raise ValueError(f"{spec!r}: resolved to {type(obj).__name__}, not a build123d Shape")
+
+    return obj, f"{seam}\npart = {ref}{'()' if called else ''}"
+
+
 def generate_sheet_script(
     step_file: str | Shape,
     out: str | None = None,
@@ -163,12 +253,15 @@ def generate_sheet_script(
     title: str | None = None,
     number: str = "DWG-001",
     pmi: str = "off",
+    part_expr: str | None = None,
 ) -> str:
     """Write a declarative ``Sheet``-DSL script for *step_file* (a STEP path or a build123d
     object). Returns the path to the generated ``.py``. The mode-3 declarative counterpart of
     :func:`draftwright.builder.generate_script` (which emits the imperative reconstruction).
 
-    ``pmi`` is threaded to detection so AP242 PMI features surface (flagged inline)."""
+    ``pmi`` is threaded to detection so AP242 PMI features surface (flagged inline). *part_expr*,
+    when given, overrides the ``part = …`` seam — e.g. the import seam from
+    :func:`resolve_object_spec` so the script references a live module (#469)."""
     is_shape = isinstance(step_file, Shape)
     stem = out or ("drawing" if is_shape else Path(step_file).stem)
     for _ext in (".py", ".svg", ".dxf"):
@@ -177,7 +270,9 @@ def generate_sheet_script(
             break
     title = title or (Path(stem).name.replace("_", " ").upper() if not is_shape else "DRAWING")
 
-    if is_shape:
+    if part_expr is not None:
+        pass  # caller-supplied seam (e.g. an import of a live module, #469)
+    elif is_shape:
         part_expr = "part = ...   # ← wire in your build123d object (built above)"
     else:
         # absolute so the generated script runs from any working directory

draftwright-0.2.8/tests/_kernel.py

@@ -0,0 +1,19 @@
+"""Shared test helper: is the installed build123d ≥ 0.11?
+
+build123d 0.11 (the cadquery-ocp-novtk kernel, required for Python 3.13+ wheels) shifts the
+HLR projection very slightly for some geometries. draftwright's *exact-position* snapshot
+guards are pinned to 0.10's output; a handful are skipped on 0.11 so the byte-exact regression
+gate keeps running on the 3.10–3.12 (build123d 0.10) matrix while 3.13/3.14 run everything
+else. Every functional / feature-count / lint check passes on both kernels.
+"""
+
+import build123d
+
+
+def _minor(v: str) -> tuple[int, int]:
+    parts = [int(p) for p in v.split(".")[:2] if p.isdigit()]
+    return (parts + [0, 0])[0], (parts + [0, 0])[1]
+
+
+B123D_GE_011 = _minor(build123d.__version__) >= (0, 11)
+SKIP_011 = "0.10-pinned exact-position snapshot; build123d 0.11 (Python 3.13+) shifts projection"

{draftwright-0.2.7 → draftwright-0.2.8}/tests/test_layout_snapshot.py

@@ -27,6 +27,7 @@ import os
 from pathlib import Path
 
 import pytest
+from _kernel import B123D_GE_011, SKIP_011
 from build123d import (
     Align,
     Box,
@@ -211,6 +212,10 @@ def _signature(dwg) -> dict:
 
 @pytest.mark.parametrize("name", list(CORPUS))
 def test_layout_snapshot(name):
+    if name == "box" and B123D_GE_011:
+        pytest.skip(
+            SKIP_011
+        )  # the plain box tips a scale/layout threshold under 0.11's projection
     dwg = build_drawing(CORPUS[name]())
     sig = _signature(dwg)
     snap = _SNAP_DIR / f"{name}.json"

{draftwright-0.2.7 → draftwright-0.2.8}/tests/test_make_drawing.py

@@ -7,6 +7,7 @@ import sys
 from pathlib import Path
 
 import pytest
+from _kernel import B123D_GE_011, SKIP_011
 from build123d import Box, Compound, Cylinder, Edge, Pos, Rotation, export_step
 from build123d_drafting import HoleCallout, Leader, ViewCoordinates, view_axes
 
@@ -19,6 +20,8 @@ from draftwright.make_drawing import generate_script, lint_feature_coverage
 from draftwright.recognition import Slot, find_slots
 from draftwright.sheet import _fits, choose_scale
 
+_skip_011 = pytest.mark.skipif(B123D_GE_011, reason=SKIP_011)
+
 
 def _state_snapshot(dwg):
     """The mutable state a read-only test must not touch — annotation count,
@@ -1298,6 +1301,7 @@ class TestComposeThenPackRepack:
         assert dwg.scale == 1.0  # pin honoured, not silently rescaled
 
     @pytest.mark.timeout(120)
+    @_skip_011
     def test_repack_reduces_an_oversized_part_when_scale_is_free(self):
         # The complement: with the scale free, an oversized part is reduced to a scale
         # that fits rather than overflowing (#350) — through the full pass-1 + repack.
@@ -2091,6 +2095,7 @@ def ctc01_a3_drawing():
 
 
 @pytest.mark.timeout(120)
+@_skip_011
 def test_ctc01_iso_uses_upper_right_zone(ctc01_a3_drawing):
     # #75 updated — wide/flat part on A3: the iso is repositioned into the upper-right
     # zone (above the SV, right of FV/PV) where it fits at sheet scale.  No NTS label.
@@ -2108,6 +2113,7 @@ def test_ctc01_iso_uses_upper_right_zone(ctc01_a3_drawing):
 
 
 @pytest.mark.timeout(120)
+@_skip_011
 def test_ctc01_iso_world_to_page_mapping(ctc01_a3_drawing):
     # dwg.at("iso", ...) must map world points to page even after the iso is
     # repositioned to the upper-right zone (still projected at sheet scale).