draftwright 0.2.1__tar.gz → 0.2.3__tar.gz

{draftwright-0.2.1 → draftwright-0.2.3}/CHANGELOG.md

@@ -2,6 +2,78 @@
 
 ## Unreleased
 
+## v0.2.3 — 2026-07-03
+
+A large patch release: the **annotation-placement engine was rebuilt** as a
+collect-then-solve *boundary-labeling* stage (ADR 0009). Placement is now
+deterministic and minimises total leader length, and the recurring class of
+overlaps where a label was drawn on top of an "invisible" occupant — a leader
+shaft, a witness/extension line, the section hatch — is removed by construction.
+Drawing output changes for many turned, cross-drilled, and multi-feature parts.
+
+### Changed
+
+- **Every annotation in a view's margin is now placed by one collect-then-solve
+  pass** (ADR 0009, #317–#323). Dimensions, hole callouts, turned-diameter
+  leaders, and the section hatch share a single occupancy model instead of several
+  independent passes each blind to the others. When a strip is over capacity it now
+  drops the *lowest-priority* annotation (smallest bore first) rather than whichever
+  pass happened to run last. The legacy strip cursor is retired.
+- **Leader placement minimises total leader length, deterministically** (P4,
+  #318). A per-strip solve places each label at the shortest-leader position that
+  keeps the labels in order and clear of keep-out rows (a view centre-line, a
+  dimension's extension line); central/coaxial callouts are anchored to the
+  view-centre row. Output is reproducible across platforms and Python versions.
+- **`scipy` is no longer a dependency** — the leader solve is a small deterministic
+  algorithm (weighted-median isotonic regression), not a linear program.
+- **Output changes** for turned, cross-drilled, and multi-feature parts whose
+  margin annotations are now positioned by the unified solver.
+
+### Fixed
+
+- **A PMI bore-diameter dimension spans the bore radius, not the full diameter**
+  (#360). A `pmi="annotate"` diameter callout drew its witness lines at ±diameter
+  from the centre — twice too wide, missing the bore edges.
+- **A bore coaxial with a rotational part's turning axis is no longer
+  over-dimensioned** (#309). It carried a redundant offset *and* height location
+  dimension even though its centre mark already locates it.
+- **A dropped turned step-length chain is no longer silent** (#362). When a turned
+  head's shoulders are too crowded to dimension, the drop is now reported
+  (`step_dim_dropped`) instead of vanishing with no lint or on-sheet signal.
+- **A diameter callout can no longer overprint a bore callout's leader shaft**
+  (#358). The turned-diameter column now avoids the *full* footprint of existing
+  annotations, not just their text boxes.
+- **The balloon ring hugs its dimensions on a cramped sheet** (#349) — its band
+  depth is clamped to the drawable area.
+- **Dimension detection is robust to `SafeDimension`** (#335/#349) — the corridor
+  and balloon-ring filters test the dimension *type*, not a class-name string, so a
+  future dimension subclass can't slip through.
+
+## v0.2.2 — 2026-06-30
+
+A patch release of turned-part dimension-placement fixes and a CLI start-up
+speed-up. Drawing output changes for the affected turned/cross-drilled parts.
+
+### Fixed
+
+- **A coaxial bore callout on a *stepped* turned shaft is now lifted off the round
+  view's centre axis** (#305). The earlier fix only triggered for a uniform
+  (`is_rotational`) cylinder; a stepped shaft (e.g. the gramel GRM-03 drive screw)
+  has a turned step profile but isn't classified rotational, so its `⌀… ↓…` bore
+  callout was still leadered straight along the centreline, with the centre mark
+  running through the text. The lift now also fires for a turned-profile part.
+- **A side-drilled hole's location dimension now stacks *inside* the overall
+  envelope dimension** (ISO order — overall dim outermost, feature/location dims
+  nearer the view). It was placed *outside* the envelope, which forced the shorter
+  location dim's arrowheads to flip outward and clash (seen on GRM-01 and GRM-02).
+  The mandatory overall dimension is still guaranteed placement.
+
+### Changed
+
+- **CLI shell completion and `--help` are fast again** (#313). The Typer CLI and
+  the heavy CAD engine are now imported lazily, so tab-completion and `--help` no
+  longer pay a ~6 s engine-import cost; a real drawing run is unaffected.
+
 ## v0.2.1 — 2026-06-30
 
 A patch release focused on **turned-part dimensioning legibility**: crowded

{draftwright-0.2.1 → draftwright-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.1
+Version: 0.2.3
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright

{draftwright-0.2.1 → draftwright-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.2.1"
+version = "0.2.3"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }

draftwright-0.2.3/src/draftwright/__init__.py

@@ -0,0 +1,103 @@
+"""draftwright — automated technical-drawing generation for build123d.
+
+Takes a build123d solid and produces a fully-annotated multi-view technical
+drawing (orthographic views, dimensions, section A–A, title block) ready for
+DXF/SVG export::
+
+    from draftwright import make_drawing
+    make_drawing(my_part, out="drawing")
+
+Requires build123d-drafting-helpers for annotation primitives.
+Licensed under the GNU Affero General Public License v3 (AGPL-3.0).
+"""
+
+import importlib as _importlib
+import sys as _sys
+import types as _types
+from typing import TYPE_CHECKING
+
+# Public API resolved lazily (PEP 562): `import draftwright` — and, crucially,
+# `import draftwright.cli` (which runs this __init__ first) — must NOT eagerly
+# pull in the engine. The engine drags build123d/OCP, ~5 s of CAD-kernel import.
+# The CLI's shell completion, --help and --version import this package but touch
+# none of these names, so they stay sub-second instead of paying for the kernel
+# on every TAB press (#313). Each name maps to the submodule that provides it.
+_LAZY = {
+    "analyse_face_levels": "draftwright.analysis",
+    "dedup_diams": "draftwright.analysis",
+    "build_drawing": "draftwright.builder",
+    "generate_script": "draftwright.builder",
+    "make_drawing": "draftwright.builder",
+    "Drawing": "draftwright.drawing",
+    "FeatureInfo": "draftwright.drawing",
+    "fix_svg_page_size": "draftwright.export",
+    "lint_feature_coverage": "draftwright.linting",
+    "PmiRecord": "draftwright.pmi",
+    "extract_pmi": "draftwright.pmi",
+    "choose_scale": "draftwright.sheet",
+}
+
+
+def _resolve(name):
+    """Import the providing submodule and cache the public object on the package."""
+    value = getattr(_importlib.import_module(_LAZY[name]), name)
+    _types.ModuleType.__setattr__(_sys.modules[__name__], name, value)
+    return value
+
+
+class _DraftwrightModule(_types.ModuleType):
+    def __getattr__(self, name):
+        # PEP 562 miss handler: resolve a public name on first access.
+        if name in _LAZY:
+            return _resolve(name)
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    def __getattribute__(self, name):
+        # `draftwright.make_drawing` must be the FUNCTION even after the compat
+        # SUBMODULE of the same name is imported and shadows it as a package
+        # attribute (importing draftwright.make_drawing binds the module here).
+        if name == "make_drawing":
+            namespace = _types.ModuleType.__getattribute__(self, "__dict__")
+            value = namespace.get("make_drawing")
+            if (
+                isinstance(value, _types.ModuleType)
+                and value.__name__ == "draftwright.make_drawing"
+            ):
+                return _resolve("make_drawing")
+        return _types.ModuleType.__getattribute__(self, name)
+
+
+_sys.modules[__name__].__class__ = _DraftwrightModule
+
+
+if TYPE_CHECKING:  # static analysers / IDEs — no runtime import, no kernel cost
+    from draftwright.analysis import analyse_face_levels, dedup_diams
+    from draftwright.builder import build_drawing, generate_script, make_drawing
+    from draftwright.drawing import Drawing, FeatureInfo
+    from draftwright.export import fix_svg_page_size
+    from draftwright.linting import lint_feature_coverage
+    from draftwright.pmi import PmiRecord, extract_pmi
+    from draftwright.sheet import choose_scale
+
+
+def __dir__():
+    # Surface the lazy public names (not in __dict__ until first accessed)
+    # *alongside* the normal module contents — dunders, imported submodules — so
+    # introspection / REPL completion sees the full surface, not a subset.
+    return sorted(set(globals()) | set(__all__))
+
+
+__all__ = [
+    "Drawing",
+    "FeatureInfo",
+    "PmiRecord",
+    "analyse_face_levels",
+    "build_drawing",
+    "choose_scale",
+    "dedup_diams",
+    "extract_pmi",
+    "fix_svg_page_size",
+    "generate_script",
+    "lint_feature_coverage",
+    "make_drawing",
+]

{draftwright-0.2.1 → draftwright-0.2.3}/src/draftwright/_core.py

@@ -14,7 +14,7 @@ import functools
 import logging
 import re
 from collections.abc import Callable
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from pathlib import Path
 from types import SimpleNamespace
 from typing import TYPE_CHECKING
@@ -166,16 +166,17 @@ def _dim(p1, p2, side, distance, draft, **kwargs):
 class Strip:
     """A one-dimensional annotation band adjacent to an orthographic view.
 
-    Annotations are stacked outward from the view edge by calling
-    :meth:`allocate`.  The cursor starts at ``anchor + direction * gap`` and
-    advances after each successful allocation.
+    A plain geometry record: the collect-then-solve placers (ADR 0009) read its
+    bounds (:func:`~draftwright.annotations._common.strip_free_span`) and carve
+    around the placed annotations. The mutable ``allocate``/``peek`` cursor was
+    retired once every placer moved to the carve (#150).
 
     Attributes:
         anchor:      Page coordinate of the view edge this strip starts from.
         outer_limit: Page coordinate at which the strip ends (page margin,
                      neighbouring view, or title-block boundary).
-        direction:   ``+1`` — cursor moves away from anchor (right/above);
-                     ``-1`` — cursor retreats from anchor (left/below).
+        direction:   ``+1`` — stacks away from anchor (right/above);
+                     ``-1`` — stacks back toward smaller coords (left/below).
         gap:         Clearance between the view edge and the first annotation.
         spacing:     Clearance between successive annotations.
     """
@@ -185,56 +186,12 @@ class Strip:
     direction: float = 1.0
     gap: float = 8.0
     spacing: float = 4.0
-    _cursor: float = field(init=False, compare=False, repr=False)
-
-    def __post_init__(self):
-        self._cursor = self.anchor + self.direction * self.gap
-
-    # ------------------------------------------------------------------
-    # Public API
 
     @property
     def available(self) -> float:
         """Total space available in this strip (mm)."""
         return abs(self.outer_limit - self.anchor)
 
-    @property
-    def depth_used(self) -> float:
-        """How far the cursor has advanced from the anchor (mm)."""
-        return abs(self._cursor - self.anchor)
-
-    def peek(self, size: float) -> float | None:
-        """Return what ``allocate(size)`` would return without advancing the cursor."""
-        if self.direction == 1:
-            start = self._cursor
-            return start if (start + size) <= self.outer_limit else None
-        else:
-            end = self._cursor
-            return end if (end - size) >= self.outer_limit else None
-
-    def allocate(self, size: float) -> float | None:
-        """Reserve *size* mm; return the near-edge page coordinate, or ``None`` if full.
-
-        The returned value is the page coordinate of the annotation's
-        dimension line (or leader elbow).  Convert to a relative offset with::
-
-            distance = abs(page_coord - strip.anchor)
-        """
-        if self.direction == 1:
-            start = self._cursor
-            end = start + size
-            if end > self.outer_limit:
-                return None
-            self._cursor = end + self.spacing
-            return start
-        else:
-            end = self._cursor
-            start = end - size
-            if start < self.outer_limit:
-                return None
-            self._cursor = start - self.spacing
-            return end
-
 
 @dataclass
 class ViewZones: