draftwright 0.3.5__tar.gz → 0.3.7__tar.gz

{draftwright-0.3.5 → draftwright-0.3.7}/CHANGELOG.md

@@ -1,6 +1,71 @@
 # Changelog
 
-## Unreleased
+## v0.3.7 — 2026-07-21
+
+### Fixed
+
+- **Turned ⌀ leaders point at the feature, not a corner or across the body**
+  (#794/#798): the diameter callouts on a turned part now centre on the step's
+  mid-length (a boss keeps its frame origin; a ⌀ shared by disjoint steps centres
+  on the longest run), so the arrow lands on the middle of the feature's edge
+  rather than a step corner. A leader that would otherwise cut diagonally through
+  the body — a nested or end feature such as a ⌀6 boss stub — is re-routed out to
+  the nearest clear margin (axis-aware: X-turned → left/right, Z-turned → top/
+  bottom), pointing straight at the feature instead of clipping the silhouette. A
+  re-route that can't be placed clear-and-safe is restored and flagged, and a
+  pinned leader is never moved.
+
+### Added
+
+- **`leader_crosses_silhouette` lint notice** (#796): an info-level structural
+  notice when a leader shaft passes *through* the projected part body (as opposed
+  to a hole callout legitimately exiting an internal hole), so the gap is
+  observable even where routing cannot clear it.
+
+## v0.3.6 — 2026-07-21
+
+### Fixed
+
+- **`Sheet.step(boss)` on a prismatic part fails loudly instead of silently
+  dropping the height** (#631): declaring a turned `.step()` at a cylinder that is
+  really an external boss set `orientation="z"`, which made `render_height_ladder`
+  suppress the overall-height dim on the assumption the OD/step chain conveyed it —
+  but on a prismatic box that chain never renders, so the height vanished and
+  nothing replaced it (11 → 10 annotations). The build now detects a `StepFeature`
+  coincident with a `BossFeature` (same axis, origin, diameter) — a combination
+  that can never be legitimate — and raises a clear `ValueError` pointing to
+  `.boss()` (which renders its own ø and height per #632). Legitimate turned shafts
+  have steps but no coincident boss, so they are unaffected.
+- **`detail_view=True` no longer a silent no-op when the detail can't be placed**
+  (#630): a part whose lint recommends a detail view (`step_dim_dropped`) but whose
+  crowded band is full-width (e.g. a shelled cover's stacked face levels) can't be
+  enlarged legibly *and* still fit alongside the main views — so `detail_view=True`
+  produced a drawing byte-identical to `False`, silently ignoring the opt-in. It
+  now records a `detail_unplaceable` warning naming the reason and an actionable
+  remedy (dimension manually / move onto its own sheet), so the opt-in is
+  observable. Parts whose detail *does* fit are unchanged.
+- **Imperative `--script` round-trips the title-block fields + sheet furniture**
+  (#775): the imperative flavour reproduced only title/number/tolerance/drawn_by/
+  scale/page, dropping the `material`/`date`/`revision`/`company` fields (#766) and
+  the `frame`/`zones`/`projection` furniture (#767/#768/#769) — so a regenerated
+  imperative script didn't match the direct CLI. They now ride the emitted script's
+  cog config block and its `build_drawing(...)` call (the Sheet flavour already
+  round-tripped them), and the CLI forwards them to `generate_script`.
+
+### Internal
+
+- **Fast-tier dense-sheet canary for the #733/#734 strip-pressure regression**
+  (#737): a synthetic contended-front-strip fixture that drops a step-height
+  principal dim on the pre-#734 commit and stays clean on `main` — closing the
+  fast-tier gap the #733 regression fell through (only the CI-only slow CTC
+  fixtures exercised real strip pressure before).
+- **Layout-hypothesis fuzz tier is now a reproducible PR gate** (#692):
+  `derandomize=True` makes every run generate the same fixed example set (with
+  `print_blob` for paste-able reproduction), so a failure recurs deterministically
+  instead of surfacing on a seed-dependent minority of runs; exploratory fuzzing
+  moves behind `DRAFTWRIGHT_FUZZ_EXPLORE=1`. The two `test_make_drawing.py` xdist
+  observations (#669) were investigated and found non-reproducible — both tests are
+  non-flaky by construction/measurement on current `main`.
 
 ## v0.3.5 — 2026-07-20
 

{draftwright-0.3.5 → draftwright-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.3.5
+Version: 0.3.7
 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.3.5 → draftwright-0.3.7}/pyproject.toml

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

{draftwright-0.3.5 → draftwright-0.3.7}/src/draftwright/annotations/from_model.py

@@ -52,6 +52,7 @@ from draftwright._core import (
     _legible_locations,
     _legible_steps,
     _log,
+    _shape_box2d,
     _solve_strip_ys,
     _text_size,
     _title_block_box,
@@ -776,8 +777,8 @@ def _diameter_row_below(dwg, items, start: int = 0, trace=None) -> int:
                 for _, d, _, _ in items
             )
         return 0
-    specs = []  # (tip_page, dia, label, feature), tip on the step's bottom silhouette
-    for anchor, dia, feat, dtol in items:
+    specs = []  # (tip_page, dia, label, feature), tip on the step's bottom silhouette,
+    for anchor, dia, feat, dtol in items:  # centred along the feature's length (not a corner)
         ax, ay, az = anchor
         tip = dwg.at("front", ax, ay, az - dia / 2)
         specs.append((tip, dia, f"ø{_fmt(dia)}{_tol_suffix(dtol, draft)}", feat))
@@ -890,8 +891,8 @@ def _diameter_column_left(dwg, items, start: int = 0, trace=None) -> int:
                 for _, d, _, _ in items
             )
         return 0
-    specs = []  # (tip_page, dia, label, feature), tip on the step's left silhouette
-    for anchor, dia, feat, dtol in items:
+    specs = []  # (tip_page, dia, label, feature), tip on the step's left silhouette,
+    for anchor, dia, feat, dtol in items:  # centred along the feature's length (not a corner)
         ax, ay, az = anchor
         tip = dwg.at("front", ax - dia / 2, ay, az)
         specs.append((tip, dia, f"ø{_fmt(dia)}{_tol_suffix(dtol, draft)}", feat))
@@ -935,6 +936,45 @@ def _diameter_column_left(dwg, items, start: int = 0, trace=None) -> int:
     return placed
 
 
+def _diameter_step_anchor(anchor, features):
+    """Anchor point for a turned ⌀ leader tip.
+
+    Centre the leader at the MID-LENGTH of the STEP carrying this diameter, rather
+    than the frame origin passed in (which for a boss or a shared ⌀'s first-bucketed
+    step can be an end corner). Only STEP spans are used: a step round-trips its
+    length + centre through the emitted Sheet script (declared ``length=``/``at=``),
+    so direct and scripted builds agree (#707 parity); a boss is re-synthesised
+    without a declared span and keeps its frame origin in both paths (``anchor``).
+
+    When a ⌀ is shared by several steps, select ONE — the longest run, leftmost on
+    ties — and use THAT step's OWN origin (radial + axial). Never the convex-hull
+    midpoint (which for disjoint ⌀A–⌀B–⌀A steps falls in the ⌀B gap, off any
+    silhouette) and never the bucket ``anchor``'s radial (which for non-coaxial
+    same-⌀ steps belongs to a different feature). The selection quantises both the
+    length and the lower end to the emitter's 3-dp values, so direct and scripted
+    pick the same run. In the #426 finalize/``only=`` path this centres over the
+    recorded subset, as the pre-#794 first-recorded-origin anchor also did.
+    """
+    steps = [
+        f for f in features if getattr(f, "kind", None) == "step" and getattr(f, "span", None)
+    ]
+    if not steps:
+        return anchor
+    idx = {"x": 0, "y": 1, "z": 2}[steps[0].frame.axis]
+
+    def _key(f):
+        ends = sorted(end[idx] for end in f.span)
+        length = round(ends[1] - ends[0], 3)  # emitter rounds step length and centre (`at`) to
+        at = round((ends[0] + ends[1]) / 2, 3)  # 3dp — quantise both so the selection round-trips
+        return (length, -(at - length / 2))
+
+    step = max(steps, key=_key)
+    ends = sorted(end[idx] for end in step.span)
+    centred = list(step.frame.origin)  # the SELECTED step's own origin (radial + axial)
+    centred[idx] = (ends[0] + ends[1]) / 2
+    return tuple(centred)
+
+
 def render_diameters(dwg, groups, tol: float = 0.15, *, ctx, only=None) -> int:
     """ø leaders for a turned part's external step/boss diameters, from the IR —
     one distinct callout per diameter, in a tidy row below the front view
@@ -978,7 +1018,8 @@ def render_diameters(dwg, groups, tol: float = 0.15, *, ctx, only=None) -> int:
 
     def _items(buckets):
         return [
-            (a, d, next(iter(fs)) if len(fs) == 1 else None, t) for a, d, fs, t in buckets.values()
+            (_diameter_step_anchor(a, fs), d, next(iter(fs)) if len(fs) == 1 else None, t)
+            for a, d, fs, t in buckets.values()
         ]
 
     # The placers name leaders m_dia_{x,z}{start+i} CONTIGUOUSLY from one start. The auto-pass
@@ -998,9 +1039,128 @@ def render_diameters(dwg, groups, tol: float = 0.15, *, ctx, only=None) -> int:
     start_x = _next_start("m_dia_x") if only is not None else 0
     start_z = _next_start("m_dia_z") if only is not None else 0
     trace = getattr(ctx, "trace", None)  # the immediate placers report to the trace too (#736)
-    return _diameter_row_below(
+    placed = _diameter_row_below(
         dwg, _items(row_buckets), start=start_x, trace=trace
     ) + _diameter_column_left(dwg, _items(col_buckets), start=start_z, trace=trace)
+    # #798: a ⌀ leader the row/column solve sent DIAGONALLY into the body — cutting
+    # the silhouette, or an end feature whose diagonal merely grazes it — is re-routed
+    # to the clear side (the margin the feature sits at). Auto-pass only: the finalize
+    # (only=) path replays recorded verbs and must not disturb pinned user dims.
+    if only is None:
+        _reroute_crossing_diameters(dwg)
+    return placed
+
+
+_REROUTE_EDGE_TOL = 2.0  # page mm: a tip this close to an axial end sits AT that end
+_REROUTE_SLACK = 1.0  # page mm: an elbow displaced this far toward the interior is "into the body"
+
+
+def _reroute_crossing_diameters(dwg) -> int:
+    """Route a turned ⌀ leader that heads INTO the part body (#798) out to the
+    nearest CLEAR margin, rather than diagonally into the body.
+
+    Two triggers, both re-routed to the clear side:
+
+    * The shaft CUTS THROUGH the body (the Phase-1 ``_leader_shaft_hits_edges``
+      discriminator) — a nested feature clipping a neighbour.
+    * An END feature (tip at the part's axial extreme, e.g. a ⌀6 boss stub) whose
+      row/column-solved elbow diagonals back INTO the body — a near-miss that reads
+      as clipping the outline even where it does not strictly cross.
+
+    Axis-aware: an ``m_dia_x`` (X-turned) leader's axial run is page-X and its clear
+    margins are left/right; an ``m_dia_z`` (Z-turned) leader's axial run is page-Y
+    and its margins are bottom/top. Candidates (near margin → straight out either way
+    along the radial axis) are kept only when the new shaft clears the outline AND the
+    rebuilt leader's LABEL stays inside the page and off every other view/annotation
+    box — so a re-route never trades an info crossing for an out-of-bounds or overlap
+    error (the shaft itself, like the row/column placers, is gated only on the
+    silhouette). If nothing is both clear and safe the leader is restored unchanged
+    (Phase-1 then flags it). A PINNED leader (ADR 0012) is never moved. Returns the
+    number re-routed."""
+    from draftwright.linting.structural import _leader_shaft_hits_edges
+
+    vs = dwg.views.get("front")
+    if not vs or vs[0] is None:
+        return 0
+    try:
+        edges = [(e, _shape_box2d(e)) for e in vs[0].edges()]
+    except Exception:  # noqa: BLE001 — an unanalysable projected shape just skips re-routing
+        return 0
+    fb = dwg.view_bounds("front")
+    if not fb:
+        return 0
+    draft = dwg.draft
+    gap = draft.font_size + 2 * draft.pad_around_text
+    page = (_MARGIN, _MARGIN, dwg.page_w - _MARGIN, dwg.page_h - _MARGIN)
+
+    def _within_page(box):
+        return box[0] >= page[0] and box[1] >= page[1] and box[2] <= page[2] and box[3] <= page[3]
+
+    rerouted = 0
+    for name in [n for n in dwg.annotations() if n.startswith(("m_dia_x", "m_dia_z"))]:
+        ldr = dwg.get_annotation(name)
+        if ldr is None or getattr(ldr, "elbow", None) is None:
+            continue
+        if dwg.registry.is_pinned(name):  # a pin is the user's "stays put" (ADR 0012)
+            continue
+        tip, elbow = ldr.tip, ldr.elbow
+        crosses = _leader_shaft_hits_edges(tip, elbow, edges)
+        ax = 0 if name.startswith("m_dia_x") else 1  # axial page axis (X row / Y column)
+        rad = 1 - ax
+        lo_b, hi_b = fb[ax], fb[ax + 2]
+        at_lo = tip[ax] - lo_b <= _REROUTE_EDGE_TOL
+        at_hi = hi_b - tip[ax] <= _REROUTE_EDGE_TOL
+        into_body = (at_lo and elbow[ax] > tip[ax] + _REROUTE_SLACK) or (
+            at_hi and elbow[ax] < tip[ax] - _REROUTE_SLACK
+        )
+        if not (crosses or into_body):
+            continue
+        # Clear-side elbows toward the CLEAR end only: the near axial margin (the end
+        # the feature sits at) first, then straight out either way along the radial
+        # axis. The far axial margin is deliberately NOT a candidate — a leader run
+        # the whole length of the part to the opposite end reads worse than the
+        # near-miss it replaces; restore-and-flag is the honest fallback instead.
+        near_a = lo_b - gap if tip[ax] - lo_b <= hi_b - tip[ax] else hi_b + gap
+
+        def _pt(a_val, r_val, _ax=ax):
+            p = [0.0, 0.0]
+            p[_ax], p[1 - _ax] = a_val, r_val
+            return (p[0], p[1])
+
+        candidates = (
+            _pt(near_a, tip[rad]),
+            _pt(tip[ax], fb[rad] - gap),
+            _pt(tip[ax], fb[rad + 2] + gap),
+        )
+        feat = dwg.registry.feature_of(name)
+        old = dwg.remove(name)  # remove first so obstacles exclude the leader being replaced
+        placed_it = False
+        try:
+            obstacles = strip_obstacles(dwg, crossable=CROSSABLE_TYPES)
+            for vis, hid in dwg.views.values():
+                for shp in (vis, hid):
+                    if shp is None:
+                        continue
+                    b = shp.bounding_box()
+                    obstacles.append((b.min.X, b.min.Y, b.max.X, b.max.Y))
+            for ex, ey in candidates:
+                if _leader_shaft_hits_edges(tip, (ex, ey), edges):
+                    continue
+                cand = Leader(
+                    tip=(tip[0], tip[1], 0), elbow=(ex, ey, 0), label=ldr.label, draft=draft
+                )
+                box = _anno_box(cand)
+                if box is None or not _within_page(box) or _box_hits(box, obstacles):
+                    continue
+                dwg.add(cand, name, view="front", feature=feat)
+                rerouted += 1
+                placed_it = True
+                break
+        except Exception:  # noqa: BLE001 — a re-route error must never lose the leader
+            placed_it = False
+        if not placed_it and dwg.get_annotation(name) is None:
+            dwg.add(old, name, view="front", feature=feat)  # restore (Phase-1 flags it)
+    return rerouted
 
 
 def _env_pd(group, role):

{draftwright-0.3.5 → draftwright-0.3.7}/src/draftwright/annotations/sections.py

@@ -597,6 +597,23 @@ def _resolve_details(dwg, a: Analysis, *, ctx) -> None:
                     dwg.pin(hname)
         if placed:
             n_placed += 1
+        elif req.kind == "prismatic-steps":
+            # (#630) The prismatic-steps request is the one queued only under the
+            # build_drawing(detail_view=True) opt-in (_request_prismatic_detail's gate),
+            # so a bail-out here means that opt-in produced nothing. Say so — with an
+            # actionable remedy — rather than returning a drawing byte-identical to
+            # detail_view=False (a full-width crowded band, e.g. a shelled cover's stacked
+            # face levels, can't be enlarged legibly and still fit alongside the main views).
+            # The automatic turned-head requests (queued unconditionally by
+            # render_step_lengths) are NOT opt-in — their bail-out is the normal path (the
+            # main view locates the head/block inline), so they stay silent.
+            ctx.record_issue(
+                "warning",
+                "detail_unplaceable",
+                f"{req.kind} detail view requested but could not be placed legibly on this "
+                "sheet (the crowded band is too wide to enlarge and still fit); dimension the "
+                "feature manually or move it onto its own sheet",
+            )
 
 
 def _overall_height_name(dwg, a: Analysis) -> str | None:

{draftwright-0.3.5 → draftwright-0.3.7}/src/draftwright/builder.py

@@ -287,6 +287,33 @@ def _assemble(
             rot = build_rotational_feature(a)
             if rot is not None:
                 pm = replace(pm, features=[*pm.features, rot])
+        # A z step declares a segment of a z-turned profile; the height ladder then suppresses
+        # the overall height on the premise the step-length chain conveys it (from_model
+        # render_height_ladder). That premise holds only if the declared steps span the part's
+        # FULL z-extent — a boss, or even a stepped boss on a plate, declared via .step()
+        # leaves the bulk unspanned, so suppression silently drops the overall height (#631).
+        # Guard on that exact condition rather than a classifier proxy (is_rotational / prof
+        # both have blind spots): raise when the z-steps don't reach both ends of the part.
+        z_steps = [f for f in pm.features if isinstance(f, StepFeature) and f.frame.axis == "z"]
+        if pm.orientation == "z" and z_steps:
+            tol = 1e-3 * max(a.z_size, 1.0)  # small absolute float epsilon, floored
+            # The step lengths convey the overall height only if the steps TILE the z-extent
+            # contiguously — a single reach to each end isn't enough (an interior gap would
+            # still leave height unconveyed). Walk the spans low→high, extending coverage.
+            spans = sorted(
+                (min(p0[2], p1[2]), max(p0[2], p1[2])) for f in z_steps for (p0, p1) in [f.span]
+            )
+            covered = a.bb.min.Z
+            for lo, hi in spans:
+                if lo <= covered + tol:
+                    covered = max(covered, hi)
+            if spans[0][0] > a.bb.min.Z + tol or covered < a.bb.max.Z - tol:
+                raise ValueError(
+                    "step() declares a segment of a turned profile, but the declared steps "
+                    "don't span this part's full height — it is not a turned (rotational) "
+                    "body. For a boss (an external cylinder on a prismatic part) use .boss() "
+                    "— it renders its own ø and height."
+                )
         # PMI (STEP AP242) is likewise detection-sourced, so a declared / emitted-script model
         # carries none. When PMI annotation is on, synthesise the same imported drafting
         # annotations detection would (render_pmi reads them off the model, gated on a.pmi_mode)
@@ -975,6 +1002,13 @@ def _write_script(
             f"NUMBER = {a.number!r}",
             f"TOLERANCE = {a.tolerance!r}",
             f"DRAWN_BY = {a.drawn_by!r}",
+            f"MATERIAL = {a.material!r}",
+            f"DATE = {a.date!r}",
+            f"REVISION = {a.revision!r}",
+            f"COMPANY = {a.company!r}",
+            f"FRAME = {a.frame!r}",
+            f"ZONES = {a.zones!r}",
+            f"PROJECTION = {a.projection!r}",
             f"PMI = {a.pmi_mode!r}",
             f"SCALE = {scale!r}",
             f"PAGE = {page!r}",
@@ -989,6 +1023,13 @@ def _write_script(
         f"_NUMBER    = {a.number!r}\n"
         f"_TOLERANCE = {a.tolerance!r}\n"
         f"_DRAWN_BY  = {a.drawn_by!r}\n"
+        f"_MATERIAL  = {a.material!r}\n"
+        f"_DATE      = {a.date!r}\n"
+        f"_REVISION  = {a.revision!r}\n"
+        f"_COMPANY   = {a.company!r}\n"
+        f"_FRAME     = {a.frame!r}   # draw a sheet border (#767)\n"
+        f"_ZONES     = {a.zones!r}   # ISO 5457 zone ruler (implies frame, #768)\n"
+        f"_PROJECTION = {a.projection!r}   # 'third' | 'first' | None (#769)\n"
         f"_PMI       = {a.pmi_mode!r}   # 'off' | 'report' | 'annotate'\n"
         f"_SCALE     = {scale!r}   # None = auto; e.g. 5 for 5:1, 0.5 for 1:2\n"
         f"_PAGE      = {page!r}   # None = auto; e.g. 'A3' or (297, 210)\n"
@@ -997,7 +1038,11 @@ def _write_script(
         "    for _k, _v in [\n"
         "        ('STEP_FILE', repr(_STEP_FILE)), ('TITLE', repr(_TITLE)),\n"
         "        ('NUMBER', repr(_NUMBER)), ('TOLERANCE', repr(_TOLERANCE)),\n"
-        "        ('DRAWN_BY', repr(_DRAWN_BY)), ('PMI', repr(_PMI)),\n"
+        "        ('DRAWN_BY', repr(_DRAWN_BY)), ('MATERIAL', repr(_MATERIAL)),\n"
+        "        ('DATE', repr(_DATE)), ('REVISION', repr(_REVISION)),\n"
+        "        ('COMPANY', repr(_COMPANY)), ('FRAME', repr(_FRAME)),\n"
+        "        ('ZONES', repr(_ZONES)), ('PROJECTION', repr(_PROJECTION)),\n"
+        "        ('PMI', repr(_PMI)),\n"
         "        ('SCALE', repr(_SCALE)), ('PAGE', repr(_PAGE)),\n"
         "    ]:\n"
         "        cog.outl(f'{_k} = {_v}')\n"
@@ -1042,6 +1087,13 @@ def _write_script(
         "    number=NUMBER,\n"
         "    tolerance=TOLERANCE,\n"
         "    drawn_by=DRAWN_BY,\n"
+        "    material=MATERIAL,\n"
+        "    date=DATE,\n"
+        "    revision=REVISION,\n"
+        "    company=COMPANY,\n"
+        "    frame=FRAME,\n"
+        "    zones=ZONES,\n"
+        "    projection=PROJECTION,\n"
         "    pmi=PMI,\n"
         "    scale=SCALE,\n"
         "    page=PAGE,\n"
@@ -1103,6 +1155,13 @@ def generate_script(
     pmi: Literal["off", "report", "annotate"] = "off",
     scale: float | None = None,
     page: str | None = None,
+    material: str = "",
+    date: str = "",
+    revision: str = "A",
+    company: str = "",
+    frame: bool = False,
+    zones: bool = False,
+    projection: str | None = None,
     formats: Sequence[str] = ("pdf",),
 ) -> str:
     """Generate an editable Cog-enabled drawing script from a STEP file.
@@ -1131,7 +1190,22 @@ def generate_script(
     # here too would crash generation on an out-of-range value (e.g. --script --scale
     # 0.001 / --page A9) instead of writing the script and deferring — inconsistent with
     # a large unfittable scale, which already defers (review #401).
-    a = _analyse(step_file, title, number, tolerance, drawn_by, out, pmi=pmi)
+    a = _analyse(
+        step_file,
+        title,
+        number,
+        tolerance,
+        drawn_by,
+        out,
+        pmi=pmi,
+        material=material,
+        date=date,
+        revision=revision,
+        company=company,
+        frame=frame,
+        zones=zones,
+        projection=projection,
+    )
     return _write_script(a, scale=scale, page=page, formats=formats)
 
 

{draftwright-0.3.5 → draftwright-0.3.7}/src/draftwright/cli.py

@@ -235,6 +235,13 @@ def main(
                 number=number,
                 tolerance=tolerance,
                 drawn_by=drawn_by,
+                material=material,
+                date=date,
+                revision=revision,
+                company=company,
+                frame=frame,
+                zones=zones,
+                projection=projection or None,
                 pmi=pmi.value,
                 scale=scale,
                 page=page,

{draftwright-0.3.5 → draftwright-0.3.7}/src/draftwright/linting/structural.py

@@ -454,6 +454,89 @@ def _edges_intersect_rect(edge_entries, rect) -> bool:
     return False
 
 
+def _seg_seg_point(a, b, c, d):
+    """Intersection point of segments *a*-*b* and *c*-*d*, or ``None`` (parallel,
+    collinear, or no overlap). Collinear returns ``None`` on purpose — a shaft
+    running ALONG an edge does not cut across it."""
+    rx, ry = b[0] - a[0], b[1] - a[1]
+    sx, sy = d[0] - c[0], d[1] - c[1]
+    denom = rx * sy - ry * sx
+    if abs(denom) < 1e-12:
+        return None
+    qpx, qpy = c[0] - a[0], c[1] - a[1]
+    t = (qpx * sy - qpy * sx) / denom
+    u = (qpx * ry - qpy * rx) / denom
+    if 0.0 <= t <= 1.0 and 0.0 <= u <= 1.0:
+        return (a[0] + t * rx, a[1] + t * ry)
+    return None
+
+
+def _leader_shaft_hits_edges(tip, elbow, edge_entries, skip_mm=0.5) -> bool:
+    """True if the leader shaft *tip*→*elbow* cuts THROUGH the projected view
+    silhouette *edge_entries* (``(edge, bbox2d)`` pairs, #796).
+
+    The discriminator is the count of DISTINCT crossing points, past a *skip_mm*
+    step off the tip:
+
+    * A leader that legitimately EXITS the outline — a hole/feature callout whose
+      tip is at an internal point, or a ⌀ callout whose tip is on the surface and
+      whose shaft runs outward — crosses the outline **once** (or not at all).
+    * A shaft that cuts THROUGH a body — a ⌀ leader clipping a neighbouring step,
+      a groove leader crossing a flange — **enters and exits**, crossing **twice**.
+
+    Genuine crossing POINTS are computed (not edge-bbox hits) and deduped within
+    0.5 mm, so a shaft merely grazing a shared vertex, or a doubled/coincident
+    projected edge, counts once — not two (review of #799). Straight edges use an
+    exact segment intersection; a curved edge is sampled ~1 mm; an edge whose
+    geometry THROWS during analysis counts as one crossing (conservative). A cut
+    is **two or more** distinct crossings beyond the tip's on-outline touch, which
+    the skip removes (the tip's own edge crosses at t<0 of the skipped shaft).
+
+    The 0.5 mm dedup radius is a page-space resolution floor: a shaft cutting a
+    feature narrower than ~0.5 mm ON THE PAGE merges to one crossing and is not
+    flagged — acceptable for a Phase-1 observability notice (#798 owns the robust
+    filled-region test)."""
+    tx, ty = tip[0], tip[1]
+    ex, ey = elbow[0], elbow[1]
+    length = ((ex - tx) ** 2 + (ey - ty) ** 2) ** 0.5
+    if length < 1e-9:
+        return False
+    t = min(0.5, skip_mm / length)  # step off the tip; never past the shaft midpoint
+    a = (tx + t * (ex - tx), ty + t * (ey - ty))
+    b = (ex, ey)
+    points: list[tuple[float, float]] = []
+    opaque = 0
+    for e, eb in edge_entries:
+        if eb is None:
+            continue
+        if not _segment_clips_box(a, b, eb):  # cheap bbox prefilter
+            continue
+        try:
+            if e.geom_type == GeomType.LINE:
+                s, d = e.start_point(), e.end_point()
+                p = _seg_seg_point(a, b, (s.X, s.Y), (d.X, d.Y))
+                if p is not None:
+                    points.append(p)
+            else:
+                n = min(200, max(8, int(e.length) + 1))
+                prev = e.position_at(0)
+                for i in range(1, n + 1):
+                    cur = e.position_at(i / n)
+                    p = _seg_seg_point(a, b, (prev.X, prev.Y), (cur.X, cur.Y))
+                    if p is not None:
+                        points.append(p)
+                    prev = cur
+        except Exception:
+            opaque += 1
+    distinct = 0
+    seen: list[tuple[float, float]] = []
+    for p in points:
+        if not any(abs(p[0] - q[0]) < 0.5 and abs(p[1] - q[1]) < 0.5 for q in seen):
+            seen.append(p)
+            distinct += 1
+    return (distinct + opaque) >= 2
+
+
 def _view_edge_entries(vs, cache):
     """Per-edge ``(edge, bbox2d)`` list for view shape *vs*, memoised in *cache*.
 
@@ -548,6 +631,51 @@ def _lint_view_shapes(
                     )
                 )
 
+    # #796 — leader shaft crosses the view silhouette. A leader that routes its
+    # shaft THROUGH the part body to reach its label reads as clipping the
+    # outline; the tip-on-silhouette touch is excluded (see _leader_shaft_hits_edges).
+    # Only tested where the shaft's own bbox overlaps the view (a leader far from a
+    # view can't cross it), reusing the shared edge cache.
+    for vname, vbb, vs in named_views:
+        for ann in ann_items:
+            if id(ann) in view_shape_ids:
+                continue
+            if getattr(ann, "elbow", None) is None:
+                continue
+            if getattr(ann, "is_centerline", False) or getattr(ann, "is_section_hatch", False):
+                continue
+            if getattr(ann, "covers_diameters", None):
+                continue  # a hole/bore callout legitimately exits the part from an internal hole
+            try:
+                tip, elbow = ann.tip, ann.elbow
+                shaft_bb = (
+                    min(tip[0], elbow[0]),
+                    min(tip[1], elbow[1]),
+                    max(tip[0], elbow[0]),
+                    max(tip[1], elbow[1]),
+                )
+            except Exception:
+                continue
+            if not _boxes_overlap(vbb, shaft_bb):
+                continue
+            edges = _view_edge_entries(vs, cache)
+            if edges is None:
+                continue
+            if _leader_shaft_hits_edges(tip, elbow, edges):
+                albl = getattr(ann, "label", None) or getattr(ann, "name", None) or "leader"
+                issues.append(
+                    LintIssue(
+                        severity="info",
+                        message=(
+                            f"leader '{albl}' shaft crosses view '{vname}' silhouette "
+                            f"— route it clear of the outline, or dimension the feature "
+                            f"in a detail view"
+                        ),
+                        location=(elbow[0], elbow[1]),
+                        code="leader_crosses_silhouette",
+                    )
+                )
+
     # #160 — view shape vs view shape bounding box overlaps
     for i, (aname, abb, _) in enumerate(named_views):
         ax0, ay0, ax1, ay1 = abb