draftwright 0.2.1__tar.gz → 0.2.2__tar.gz

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

@@ -2,6 +2,31 @@
 
 ## Unreleased
 
+## 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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.1
+Version: 0.2.2
 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.2}/pyproject.toml

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

draftwright-0.2.2/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.2}/src/draftwright/annotations/from_model.py

@@ -532,6 +532,20 @@ def _env_pd(group, role):
     return next((pd for pd in group.dims if pd.param.role == role), None)
 
 
+def envelope_group(groups):
+    """The envelope `DimensionGroup` in *groups*, or None."""
+    return next((g for g in groups if g.feature_kind == "envelope"), None)
+
+
+def env_dim_placed(pd) -> bool:
+    """Whether :func:`render_envelope` will actually place an envelope dim for the
+    PlannedDimension *pd* — present, not suppressed by the planner (square footprint /
+    X-turned, #250), and carrying a span. The single source of truth for that
+    decision, shared with the orchestrator's side-below tier reservation so the two
+    can never drift (#316 review)."""
+    return pd is not None and not pd.suppressed and pd.param.span is not None
+
+
 def render_envelope(dwg, groups, a) -> int:
     """Overall width (plan, below) + depth (side, below) envelope dims via the IR,
     placed through the engine's below-strip zone allocators (the zone-aware render
@@ -539,12 +553,12 @@ def render_envelope(dwg, groups, a) -> int:
     those strips). The **planner** decides suppression (square footprint / X-turned;
     #250); this renderer just skips suppressed dims and places the rest. Returns the
     count placed."""
-    env = next((g for g in groups if g.feature_kind == "envelope"), None)
+    env = envelope_group(groups)
     if env is None:
         return 0
     n = 0
     width = _env_pd(env, "width")
-    if width is not None and not width.suppressed and width.param.span is not None:
+    if env_dim_placed(width):
         (x0, y0, z0), (x1, _, _) = width.param.span
         p1, p2 = dwg.at("plan", x0, y0, z0), dwg.at("plan", x1, y0, z0)
         witness = p1[1] - 2
@@ -564,7 +578,7 @@ def render_envelope(dwg, groups, a) -> int:
             )
             n += 1
     depth = _env_pd(env, "depth")
-    if depth is not None and not depth.suppressed and depth.param.span is not None:
+    if env_dim_placed(depth):
         (x0, y0, z0), (_, y1, _) = depth.param.span
         p1, p2 = dwg.at("side", x0, y0, z0), dwg.at("side", x0, y1, z0)
         witness = p1[1] - 2

{draftwright-0.2.1 → draftwright-0.2.2}/src/draftwright/annotations/holes.py

@@ -73,17 +73,29 @@ def _record_callout_drop(dwg, view, diam, reason):
     )
 
 
-def _locate_off_axis_holes(dwg, a: Analysis, holes_in=None):
+def _locate_off_axis_holes(dwg, a: Analysis, holes_in=None, *, which):
     """Location dimensions for side-drilled holes (#133).
 
     An X-axis hole is a circle in the SIDE view (locate its Y below the view and
     its Z to the right — the side view has no left strip); a Y-axis hole is a
     circle in the FRONT view (locate its X below and its Z to the right). Each
-    offset is allocated from the view's strip so dims stack without overlap, and
-    this pass runs AFTER the envelope and turned-diameter passes so it can never
-    evict an overall dimension. A tier with no room is dropped and recorded as
-    ``off_axis_location_dropped`` — never force-stacked. Holes already covered by
-    a pattern callout are skipped, as in the plan path.
+    offset is allocated from the view's strip so dims stack without overlap. A tier
+    with no room is dropped and recorded as ``off_axis_location_dropped`` — never
+    force-stacked. Holes already covered by a pattern callout are skipped.
+
+    Run in two phases (``which`` is ``"across"`` or ``"along"``) so each dim stacks in
+    the ISO order — overall dim OUTERMOST, feature/location dims nearer the view:
+
+    - ``"across"`` — an X-axis hole's in-plane (Y, side-below) location, placed BEFORE
+      the envelope so the overall depth dim lands outside it (the side-view
+      counterpart of the plan view, where location dims already precede the
+      envelope). Fixes the inverted stack where the overall dim sat innermost and
+      forced the shorter location dim's arrows outside. The orchestrator reserves the
+      envelope's tier first, so these best-effort dims can't starve it.
+    - ``"along"`` — a Y-axis hole's X (front-below) location and every hole's height
+      (Z, right-strip), placed AFTER the envelope and the turned-diameter passes so
+      they never evict those overall dims from the contended front-below / right
+      strips (#133).
     """
     draft = dwg.draft
     all_holes = a.holes if holes_in is None else holes_in
@@ -150,17 +162,35 @@ def _locate_off_axis_holes(dwg, a: Analysis, holes_in=None):
         ):
             _drop(axis, view)
 
-    # In-plane offset: X-axis hole -> Y below the side view; Y-axis hole -> X
-    # below the front view (each view's below strip is its own, uncontended).
-    yw, xw = SZ(dz) - 2, FZ(dz) - 2
-    seen_y, seen_x = set(), set()
-    for h in (h for h in off if _axis_letter(h) == "x"):
-        yo = round(abs(h.location[1] - dy), 2)
-        if yo * a.SCALE >= 1.0 and yo not in seen_y:
-            seen_y.add(yo)
-            _below(
-                a.sv_zones.below, "side", (SX(dy), yw, 0), (SX(h.location[1]), yw, 0), yw, yo, "y"
-            )
+    # "across" phase — an X-axis hole's Y position below the SIDE view, placed BEFORE
+    # the envelope so the overall depth dim stacks outside it (ISO order). Confined to
+    # the side view: a Y-axis hole's X position contends the FRONT-below strip with the
+    # turned-diameter ø-row, so it stays in the "along" phase (after the diameter pass),
+    # preserving the #133 priority. The orchestrator reserves one sv_zones.below tier
+    # for the mandatory envelope depth before calling this, so these best-effort
+    # location dims can never starve it.
+    if which == "across":
+        yw = SZ(dz) - 2
+        seen_y: set = set()
+        for h in (h for h in off if _axis_letter(h) == "x"):
+            yo = round(abs(h.location[1] - dy), 2)
+            if yo * a.SCALE >= 1.0 and yo not in seen_y:
+                seen_y.add(yo)
+                _below(
+                    a.sv_zones.below,
+                    "side",
+                    (SX(dy), yw, 0),
+                    (SX(h.location[1]), yw, 0),
+                    yw,
+                    yo,
+                    "y",
+                )
+        return
+
+    # "along" phase (after the envelope + turned-diameter passes): a Y-axis hole's X
+    # position below the FRONT view, then every hole's height (Z) to the right.
+    xw = FZ(dz) - 2
+    seen_x: set = set()
     for h in (h for h in off if _axis_letter(h) == "y"):
         xo = round(abs(h.location[0] - dx), 2)
         if xo * a.SCALE >= 1.0 and xo not in seen_x:
@@ -520,21 +550,26 @@ def _annotate_holes(dwg, a: Analysis, view_of_axis, groups, feature_keys):
 
         A bore on the turning axis is led out along the view's horizontal centre
         axis, so the centre mark / centreline runs straight through the "⌀… ↓…"
-        callout text. Detect that one bore — a rotational part, hole at the view
-        centre — and lift its row a clearance off the axis (an angled leader to a
-        central feature is standard practice), toward the roomier side. Off-axis
+        callout text. Detect that one bore — a **turned/rotational** part, hole at
+        the view centre — and lift its row a clearance off the axis (an angled leader
+        to a central feature is standard practice), toward the roomier side. Off-axis
         holes and every prismatic-part hole are untouched (front-view round parts
         place coaxial bores as vertical shafts below the view, not along an axis,
         so they can't hit this and are exempt by construction).
 
+        The "turned/rotational" gate is ``is_rotational OR prof`` — a *stepped*
+        turned shaft (e.g. the GRM-03 drive screw) has a turned step profile but is
+        not ``is_rotational`` (its varying OD doesn't fill a square cross-section),
+        yet its coaxial bore hits exactly this defect. A prismatic part has neither,
+        so it stays excluded (the regression the original gate guarded against, #305).
+
         Tactical: the principled fix is to not draw the crossing line at all — a
         centred bore is located by the axis, so its linear location dims are
         redundant (#309) — or to make this a layout-solver separation constraint
         (ADR 0003). This nudge becomes dead code once either lands."""
         tol = draft.font_size  # "hole at the view centre" tolerance (page mm)
-        if not (
-            a.is_rotational and abs(centre[0] - view_cx) < tol and abs(centre[1] - view_cy) < tol
-        ):
+        turned = a.is_rotational or a.prof is not None
+        if not (turned and abs(centre[0] - view_cx) < tol and abs(centre[1] - view_cy) < tol):
             return ny
         # Lift the row a full text height + padding clear of the axis: enough for
         # the text box (half a font tall) to sit wholly off the centre line with a

{draftwright-0.2.1 → draftwright-0.2.2}/src/draftwright/annotations/orchestrator.py

@@ -19,6 +19,7 @@ import math
 
 from draftwright._core import (
     _CONCENTRIC_TOL_MM,
+    _SLOT_DIM_DEPTH,
     _TABULATE_MIN_HOLES,
     Analysis,
     HoleRef,
@@ -30,6 +31,9 @@ from draftwright._core import (
     _tag_sequence,
 )
 from draftwright.annotations.from_model import (
+    _env_pd,
+    env_dim_placed,
+    envelope_group,
     render_centermarks,
     render_diameters,
     render_envelope,
@@ -213,6 +217,29 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
     # turned parts, and a Z-turned overall height is suppressed there (ISO 129).
     render_height_ladder(dwg, _model, a)
 
+    # Side-drilled holes' in-plane (side-below) locations FIRST, so the overall
+    # envelope depth lands OUTSIDE them — ISO stacks the overall dim outermost,
+    # feature/location dims nearer the view (matches the plan view, where location
+    # dims precede the envelope). To keep the #133 guarantee that the MANDATORY
+    # envelope dim is never starved, reserve its tier in the side-below strip first
+    # (shrink the strip by one depth slot for the location pass, then restore) — so
+    # the best-effort locations fill inner tiers and the envelope always gets the
+    # outermost. The height (right-strip) locations stay in the "along" phase.
+    if feature_holes:
+        # Only reserve when render_envelope will actually place the depth dim — the
+        # planner suppresses it for a square footprint / X-turned part (#250); reserving
+        # a tier it never claims would needlessly shrink the strip and drop a location
+        # dim that would otherwise fit (#316 review). Uses render_envelope's own
+        # place-predicate (env_dim_placed) so the two can never drift.
+        _env_g = envelope_group(_groups)
+        _reserve = _env_g is not None and env_dim_placed(_env_pd(_env_g, "depth"))
+        _below = a.sv_zones.below
+        _saved_limit = _below.outer_limit
+        if _reserve:
+            _below.outer_limit -= _below.direction * (_SLOT_DIM_DEPTH + _below.spacing)
+        _locate_off_axis_holes(dwg, a, holes_in=feature_holes, which="across")
+        _below.outer_limit = _saved_limit
+
     # Overall width (plan, below) + depth (side, below) envelope dims — IR renderer,
     # placed through the same below-strip zone allocators the engine used (zone-aware
     # render stage, ADR 0008). Suppression (square footprint / X-turned width) is now
@@ -245,10 +272,11 @@ def _auto_annotate(dwg, a: Analysis, *, detail_view: bool = False):
     if a.prof is not None:
         render_step_lengths(dwg, _groups)
 
-    # Side-drilled (X/Y-axis) hole locations — last, so the envelope and
-    # turned-diameter dims claim their strip space first and are never evicted (#133).
+    # Side-drilled (X/Y-axis) hole HEIGHT locations — last, so the envelope and
+    # turned-diameter dims claim their (contended right) strip space first and are
+    # never evicted (#133). The in-plane locations were placed before the envelope.
     if feature_holes:
-        _locate_off_axis_holes(dwg, a, holes_in=feature_holes)
+        _locate_off_axis_holes(dwg, a, holes_in=feature_holes, which="along")
 
     # Non-cylindrical machined features: slots / reduced across-flats sections
     # (#135) — IR renderer, placed through the zone strips (shared infra). Runs

{draftwright-0.2.1 → draftwright-0.2.2}/src/draftwright/cli.py

@@ -17,8 +17,6 @@ from importlib.metadata import version as _pkg_version
 
 import typer
 
-from draftwright.builder import build_drawing, generate_script
-
 app = typer.Typer(
     add_completion=True,
     # Plain tracebacks on an engine error, matching the old argparse CLI — a rich
@@ -144,6 +142,12 @@ def main(
 
     formats = _parse_formats(output_format)
 
+    # Import the engine lazily, only on the build path: it pulls in build123d/OCP
+    # (~5 s of CAD-kernel import). Keeping it out of module scope means shell
+    # completion, --help and --version (which import this module but never call
+    # the command) stay sub-second instead of paying for the kernel every time.
+    from draftwright.builder import build_drawing, generate_script
+
     if script:
         py_path = generate_script(
             step_file=step_file,

{draftwright-0.2.1 → draftwright-0.2.2}/tests/test_make_drawing.py

@@ -1648,6 +1648,42 @@ def test_cli_version_reports_installed_version():
     assert result.stdout.strip() == f"draftwright {_pkg_version('draftwright')}"
 
 
+def test_cli_import_does_not_load_the_engine():
+    """Importing the CLI must not pull in build123d/OCP (#313). Shell completion,
+    --help and --version import this module on every invocation; loading the
+    ~5 s CAD kernel there made each TAB press take ~6 s. Guard the lazy boundary:
+    the engine is imported only on the actual build path, in a fresh process so
+    other tests' imports can't mask a regression."""
+    code = (
+        "import sys, draftwright.cli; "
+        "heavy = [m for m in ('build123d', 'OCP') if m in sys.modules]; "
+        "print(','.join(heavy)); sys.exit(1 if heavy else 0)"
+    )
+    result = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True)
+    assert result.returncode == 0, (
+        f"`import draftwright.cli` eagerly loaded: {result.stdout.strip()}"
+    )
+
+
+def test_lazy_public_api_preserves_make_drawing_identity():
+    """The lazy package __init__ (#313) must still expose the public API, and
+    `draftwright.make_drawing` must stay the FUNCTION even after the compat
+    submodule of the same name is imported and would otherwise shadow it."""
+    code = (
+        "import types, draftwright as d; "
+        "from draftwright import make_drawing, build_drawing, Drawing, choose_scale; "
+        "assert callable(make_drawing) and not isinstance(make_drawing, types.ModuleType); "
+        "assert d.make_drawing is make_drawing; "
+        "import draftwright.make_drawing; "  # provoke the shadowing path
+        "assert callable(d.make_drawing) and not isinstance(d.make_drawing, types.ModuleType); "
+        "print('ok')"
+    )
+    result = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True)
+    assert result.returncode == 0 and result.stdout.strip() == "ok", (
+        f"stdout:\n{result.stdout}\nstderr:\n{result.stderr}"
+    )
+
+
 # ---------------------------------------------------------------------------
 # --format selector (#288) — pure logic, no OCP build needed
 # ---------------------------------------------------------------------------
@@ -2294,6 +2330,68 @@ class TestPrismaticClassification:
         # the right strips — the sheet stays lint-clean (#133 rework).
         assert [i for i in dwg.lint() if i.severity != "info"] == []
 
+    def test_side_view_location_dim_stacks_inside_the_envelope(self):
+        # ISO stacking: the overall (envelope) dim sits OUTERMOST, the feature/location
+        # dim nearer the view. A side-drilled hole's in-plane location must therefore
+        # be CLOSER to the side view than the envelope-depth dim. The inverted stack
+        # (envelope innermost) forced the shorter location dim's arrows to flip outward
+        # and clash with the envelope (GRM-01 / GRM-02).
+        from build123d import Rot
+
+        # Off-centre hole (y=2, not the centreline) so the location dim is real, not a
+        # redundant centred one — this isolates the stacking order.
+        part = Box(12, 11, 40) - Pos(0, 2, 6) * Rot(0, 90, 0) * Cylinder(3, 12)
+        dwg = build_drawing(part)
+        env = dwg._named.get("m_env_depth")
+        loc = [o for n, o in dwg._named.items() if n.startswith("dim_loc_side_y")]
+        assert env is not None and loc, "expected an envelope-depth dim and a side location dim"
+
+        def ymid(o):
+            bb = o.bounding_box()
+            return (bb.min.Y + bb.max.Y) / 2
+
+        # The below strip extends downward from the side view, so nearer the view =
+        # higher Y. The location dim must sit nearer the view than the overall dim.
+        assert min(ymid(o) for o in loc) > ymid(env), "location must stack inside the envelope"
+        assert [i for i in dwg.lint() if i.severity != "info"] == []
+
+    def test_envelope_depth_survives_many_side_location_dims(self):
+        # The mandatory overall depth dim must always be placed, even when several
+        # side-drilled holes fill the side-below strip with location dims. The
+        # location pass now runs before the envelope (for ISO stacking), so the
+        # orchestrator reserves the envelope's tier first — best-effort location dims
+        # can never starve it (the #316-review regression).
+        from build123d import Cylinder, Pos, Rot
+
+        part = Box(12, 24, 60)
+        for y, z in [(-9, -20), (-5, -8), (7, 4), (10, 16)]:
+            part -= Pos(0, y, z) * Rot(0, 90, 0) * Cylinder(1.5, 12)
+        dwg = build_drawing(part)
+        ylocs = [n for n in dwg._named if n.startswith("dim_loc_side_y")]
+        assert len(ylocs) >= 2, "expected several side-below location dims for strip pressure"
+        assert "m_env_depth" in dwg._named, "the mandatory overall depth dim was starved"
+        assert dwg.lint_summary()["by_code"].get("missing_principal_dimension", 0) == 0
+
+        def ymid(o):
+            bb = o.bounding_box()
+            return (bb.min.Y + bb.max.Y) / 2
+
+        env = dwg._named["m_env_depth"]
+        assert all(ymid(dwg._named[n]) > ymid(env) for n in ylocs), "locations must stack inside"
+
+    def test_square_footprint_does_not_reserve_a_suppressed_envelope_tier(self):
+        # When the planner suppresses the depth dim (square footprint / X-turned),
+        # the side-below envelope-tier reservation must NOT fire — reserving a tier
+        # render_envelope never claims would needlessly shrink the strip and drop a
+        # side location that otherwise fits (#316 review).
+        from build123d import Cylinder, Pos, Rot
+
+        part = Box(20, 20, 40) - Pos(0, 4, 0) * Rot(0, 90, 0) * Cylinder(2, 20)
+        dwg = build_drawing(part)
+        assert "m_env_depth" not in dwg._named  # square footprint → depth suppressed
+        assert [n for n in dwg._named if n.startswith("dim_loc_side_y")], "location was dropped"
+        assert dwg.lint_summary()["by_code"].get("off_axis_location_dropped", 0) == 0
+
     @pytest.mark.timeout(60)
     def test_locates_every_side_drilled_hole_not_just_the_first(self):
         # Two side-drilled (Y-axis) holes at distinct x: each must get its own
@@ -3687,6 +3785,32 @@ class TestLintSummaryAndDrops:
 
 
 class TestLayoutGeneralisation:
+    @staticmethod
+    def _lines_crossing_label(dwg, callout_name, label_bbox):
+        """Horizontal lines (other than the callout's own shelf) that cross the
+        callout's text box — the #305 'line through the callout text' defect. Shared
+        by the coaxial-bore tests."""
+        tx0, ty0, tx1, ty1 = label_bbox
+        crossings = []
+        for n, o in dwg._named.items():
+            if n == callout_name:
+                continue
+            try:
+                edges = list(o.edges())
+            except Exception:
+                continue
+            for e in edges:
+                vs = e.vertices()
+                if len(vs) != 2:
+                    continue
+                (x0, y0), (x1, y1) = (vs[0].X, vs[0].Y), (vs[1].X, vs[1].Y)
+                if abs(y0 - y1) < 0.05 and abs(x0 - x1) > 1.0:  # a horizontal line
+                    ym = (y0 + y1) / 2
+                    xa, xb = min(x0, x1), max(x0, x1)
+                    if ty0 + 0.3 < ym < ty1 - 0.3 and xb > tx0 + 0.3 and xa < tx1 - 0.3:
+                        crossings.append((n, round(ym, 2)))
+        return crossings
+
     @pytest.mark.timeout(120)
     def test_turned_flange_gets_both_od_and_hole_furniture(self):
         # A turned-and-drilled flange (cylinder OD + centre bore + bolt circle)
@@ -3756,26 +3880,32 @@ class TestLayoutGeneralisation:
         hc = [(n, o) for n, o in dwg._named.items() if n.startswith("hc_side")]
         assert hc, "expected a bore callout on the round (side) view"
         name, leader = hc[0]
-        tx0, ty0, tx1, ty1 = leader.label_bbox
+        crossings = self._lines_crossing_label(dwg, name, leader.label_bbox)
+        assert not crossings, f"line(s) cross the bore callout text: {crossings}"
 
-        crossings = []
-        for n, o in dwg._named.items():
-            if n == name:
-                continue  # the callout's own shelf ends before its text
-            try:
-                edges = list(o.edges())
-            except Exception:
-                continue
-            for e in edges:
-                vs = e.vertices()
-                if len(vs) != 2:
-                    continue
-                (x0, y0), (x1, y1) = (vs[0].X, vs[0].Y), (vs[1].X, vs[1].Y)
-                if abs(y0 - y1) < 0.05 and abs(x0 - x1) > 1.0:  # a horizontal line
-                    ym = (y0 + y1) / 2
-                    xa, xb = min(x0, x1), max(x0, x1)
-                    if ty0 + 0.3 < ym < ty1 - 0.3 and xb > tx0 + 0.3 and xa < tx1 - 0.3:
-                        crossings.append((n, round(ym, 2)))
+    def test_coaxial_bore_callout_clears_centre_axis_on_stepped_shaft(self):
+        # #305 regression: the lift must also fire for a *stepped* turned shaft (the
+        # GRM-03 drive screw), which has a turned step profile but is NOT
+        # is_rotational (its varying OD doesn't fill a square cross-section) — the
+        # original is_rotational-only gate missed it, leaving the bore callout led
+        # straight along the centre axis. Assert no horizontal line crosses the text.
+        from build123d import Align, Cylinder, Pos, Rotation
+
+        from draftwright import build_drawing
+
+        b = Align.MIN
+        part = (
+            Cylinder(6, 12, align=(Align.CENTER, Align.CENTER, b))
+            + Pos(0, 0, 12) * Cylinder(4, 12, align=(Align.CENTER, Align.CENTER, b))
+            - Cylinder(0.8, 8, align=(Align.CENTER, Align.CENTER, b))
+        )
+        dwg = build_drawing(Rotation(0, 90, 0) * part, scale=2.0)
+        assert dwg._analysis.prof is not None and not dwg._analysis.is_rotational
+
+        hc = [(n, o) for n, o in dwg._named.items() if n.startswith("hc_side")]
+        assert hc, "expected a bore callout on the round (side) view"
+        name, leader = hc[0]
+        crossings = self._lines_crossing_label(dwg, name, leader.label_bbox)
         assert not crossings, f"line(s) cross the bore callout text: {crossings}"
 
     def test_prismatic_central_hole_callout_not_lifted(self):

draftwright-0.2.1/src/draftwright/__init__.py

@@ -1,62 +0,0 @@
-"""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 sys as _sys
-import types as _types
-
-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
-
-_make_drawing_function = make_drawing
-
-
-class _DraftwrightModule(_types.ModuleType):
-    def __getattribute__(self, name):
-        if name == "make_drawing":
-            namespace = _types.ModuleType.__getattribute__(self, "__dict__")
-            value = namespace.get(name)
-            if (
-                isinstance(value, _types.ModuleType)
-                and value.__name__ == "draftwright.make_drawing"
-            ):
-                public = namespace["_make_drawing_function"]
-                _types.ModuleType.__setattr__(self, name, public)
-                return public
-        return _types.ModuleType.__getattribute__(self, name)
-
-
-_sys.modules[__name__].__class__ = _DraftwrightModule
-
-__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",
-]