draftwright 0.2.10__tar.gz → 0.2.11__tar.gz

{draftwright-0.2.10 → draftwright-0.2.11}/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## v0.2.11 — 2026-07-08
+
+**Automatic layout now has one authority.** Page/scale selection, section placement,
+furniture footprints, and table/balloon escalation now negotiate through the same layout
+fitness model instead of using separate fixed offsets or first-fit policies after the main
+solve.
+
+### Fixed
+
+- **Solver placement paths are more consistent.** STEP PMI dimensions now queue into
+  the shared ADR 0009 corridor solve instead of carving after the drain; front-view
+  hole callouts use the strip solver instead of fixed row stepping; pitch-dimension
+  fallback searches bounded, obstacle-aware positions; repair no longer hides
+  `annotation_overlap` with a fixed-step nudge; and step-count sizing now handles
+  non-convergence conservatively. (#524)
+- **Page/scale fitness is shared across initial selection and repack.** Later layout
+  passes now compare candidates with the same model as the page chooser, preventing a
+  nominally "better" repack from invalidating the original layout decision. (#519)
+- **Section A-A participates in layout selection.** Section placement is measured as
+  part of page/scale fitness, so a section view is no longer a fixed-offset afterthought
+  that can disappear on dense sheets. (#515)
+- **Furniture placement reserves full rendered footprints.** Section arrows, detail
+  views, balloons, hole/data tables, and other furniture now reserve/check their true
+  rendered footprint instead of just their labels. (#518)
+- **Hole/data tables and balloon rings escalate through the layout model.** Dense table
+  and balloon outputs can move or negotiate for available room rather than dropping from
+  greedy first-fit placement when a small adjustment would fit. (#516, #517)
+
 ## v0.2.10 — 2026-07-07
 
 **Declarative-surface fidelity and layout-engine unification.** Editing and re-running a

{draftwright-0.2.10 → draftwright-0.2.11}/PKG-INFO

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

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

{draftwright-0.2.10 → draftwright-0.2.11}/src/draftwright/_core.py

@@ -21,6 +21,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from draftwright.recognition import TurnedProfile
+    from draftwright.sheet import StripDepths
 
 from build123d import Align, BoundBox, Location, Mode, Shape, Text
 from build123d_drafting.helpers import (
@@ -338,7 +339,7 @@ def _legible_locations(positions, scale):
     return kept, n_too_close
 
 
-def _largest_empty_rect(drawable, obstacles):
+def _largest_empty_rect(drawable, obstacles, *, warn: bool = True):
     """Largest axis-aligned empty rectangle in *drawable* avoiding *obstacles*.
 
     *drawable* and each obstacle are ``(x0, y0, x1, y1)`` page-mm boxes.  Returns
@@ -376,10 +377,11 @@ def _largest_empty_rect(drawable, obstacles):
         # is unreachable in practice — choose_scale always leaves a gap — but
         # if it ever happens the iso would render over the other views, so flag
         # it rather than fail silently.
-        _log.warning(
-            "No empty rectangle found for the iso view; obstacles fill the "
-            "drawable area — iso may overlap other views"
-        )
+        if warn:
+            _log.warning(
+                "No empty rectangle found for the iso view; obstacles fill the "
+                "drawable area — iso may overlap other views"
+            )
         return drawable
     return best
 
@@ -514,6 +516,10 @@ class Analysis:
     is_rotational: bool
     od_axis: str  # rotation/turning axis of a rotational part ("z" default; "x"/"y" #222)
     step_zs: list[float]
+    layout_strips: StripDepths
+    layout_n_steps: int
+    layout_section: bool
+    layout_table_sizes: tuple[tuple[float, float], ...]
     sv_right: float
     iso_right_limit: float
     SCALE: float

{draftwright-0.2.10 → draftwright-0.2.11}/src/draftwright/analysis.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 import logging
 import math
 import warnings
+from collections.abc import Callable
 
 from build123d import Compound, Shape
 from build123d_drafting.helpers import draft_preset
@@ -20,6 +21,7 @@ from OCP.IFSelect import IFSelect_ReturnStatus
 from OCP.STEPControl import STEPControl_Reader
 
 from draftwright._core import (
+    _CONCENTRIC_TOL_MM,
     _DIM_PAD,
     _FONT_SIZE,
     _MARGIN,
@@ -40,9 +42,12 @@ from draftwright.recognition import (
     full_cylinders,
 )
 from draftwright.sheet import (
+    StripDepths,
     _build_zones,
+    _est_hole_table_sizes,
     _layout_geometry,
     _measure_strips,
+    _will_section,
     choose_scale,
 )
 
@@ -54,6 +59,41 @@ _log = logging.getLogger(__name__)
 _SQUARENESS_TOL = 0.05
 _OD_FILL_MIN = 0.8
 _OD_AXIS_TOL = 0.05
+_ScalePick = tuple[float, float, float, float]
+
+
+def _declared_will_section(model, *, is_rotational=False, cx=0.0, cy=0.0) -> bool:
+    """True when a caller-supplied IR model contains a section-driving Z hole.
+
+    Detection-based layout uses recogniser holes; declared-model builds may
+    intentionally supply features detection missed. Inspect the public IR shape
+    duck-typed here so declared sections get the same page/scale reservation.
+    """
+
+    if model is None:
+        return False
+    features = getattr(model, "features", model)
+
+    def feature_member(pt) -> bool:
+        return not (is_rotational and math.hypot(pt[0] - cx, pt[1] - cy) <= _CONCENTRIC_TOL_MM)
+
+    for feat in features:
+        if getattr(feat, "kind", None) not in ("hole", "pattern"):
+            continue
+        frame = getattr(feat, "frame", None)
+        if frame is None or frame.axis != "z":
+            continue
+        members = getattr(feat, "members", ()) or (frame.origin,)
+        if not any(feature_member(m) for m in members):
+            continue
+        bore = getattr(feat, "member", feat)
+        if (
+            getattr(bore, "cbore", None) is not None
+            or getattr(bore, "spotface", None) is not None
+            or not getattr(bore, "through", True)
+        ):
+            return True
+    return False
 
 
 def _import_step(path) -> Compound:
@@ -106,6 +146,53 @@ def _is_rotational(x_size, y_size, od_diam, od_axis_offset) -> bool:
     )
 
 
+def _converge_step_sizing(
+    initial_steps: int,
+    measure_strips: Callable[[int], StripDepths],
+    pick_scale: Callable[[int, StripDepths], _ScalePick],
+    count_legible: Callable[[float], int],
+) -> tuple[_ScalePick, StripDepths, int]:
+    """Choose scale/page with a step-corridor count that matches legibility.
+
+    The right-side step ladder is reserved before the scale is known, but the
+    actual step list is filtered by the chosen scale. Iterate that dependency
+    until it reaches a fixed point; if it cycles, reserve the largest count seen
+    so the sheet is sized conservatively instead of silently accepting whichever
+    value happened to appear on a fixed iteration budget (#520).
+    """
+    n_for_sizing = initial_steps
+    seen: set[int] = set()
+    attempted: list[int] = []
+    max_iter = max(4, initial_steps + 2)
+
+    for _ in range(max_iter):
+        if n_for_sizing in seen:
+            break
+        seen.add(n_for_sizing)
+        attempted.append(n_for_sizing)
+
+        strips = measure_strips(n_for_sizing)
+        scale_pick = pick_scale(n_for_sizing, strips)
+        n_next = count_legible(scale_pick[0])
+        if n_next == n_for_sizing:
+            return scale_pick, strips, n_for_sizing
+        if n_next in seen:
+            n_for_sizing = n_next
+            break
+        n_for_sizing = n_next
+
+    conservative_n = max(attempted + [n_for_sizing], default=initial_steps)
+    strips = measure_strips(conservative_n)
+    scale_pick = pick_scale(conservative_n, strips)
+    _log.warning(
+        "Step-corridor sizing did not converge from %d steps (tried %s); reserving %d steps",
+        initial_steps,
+        attempted,
+        conservative_n,
+    )
+    return scale_pick, strips, conservative_n
+
+
 # A hole is "concentric" with a turned part's rotation axis when its drilling
 # axis is the Z (OD) axis and its opening sits on the part centreline.  Such
 # bores are already dimensioned by the ldr_z bore leaders, so they must not
@@ -202,7 +289,16 @@ def _solids_body(part, src: str = "part"):
 
 
 def _analyse(
-    step_file, title, number, tolerance, drawn_by, out, scale=None, page=None, pmi="off"
+    step_file,
+    title,
+    number,
+    tolerance,
+    drawn_by,
+    out,
+    scale=None,
+    page=None,
+    pmi="off",
+    model=None,
 ) -> Analysis:
     """Load STEP or use a build123d Shape, analyse geometry, compute layout.
 
@@ -317,6 +413,20 @@ def _analyse(
     patterns = find_hole_patterns(holes)
     bosses = find_bosses(part, cyls=(z_cyls, cross_cyls))  # detect once — the one inventory (#264)
     slots = find_slots(part)
+    layout_section = _will_section(
+        holes,
+        patterns,
+        is_rotational=is_rotational,
+        cx=cx,
+        cy=cy,
+    ) or _declared_will_section(model, is_rotational=is_rotational, cx=cx, cy=cy)
+    layout_table_sizes = _est_hole_table_sizes(
+        holes,
+        patterns,
+        bb,
+        font_size=_FONT_SIZE,
+        pad_around_text=_pad_around_text,
+    )
 
     # Choose scale/page, iterating so the reserved step corridor matches the
     # number of steps the legibility gate will actually place (#1) — not the raw
@@ -324,24 +434,35 @@ def _analyse(
     # with 15 tiny treads) reserves a phantom step ladder that blocks a larger
     # scale. Seed conservatively (all faces), then re-gate at the chosen scale;
     # converges in a couple of rounds.
-    n_for_sizing = len(step_zs)
-    strips_i = None
-    for _ in range(3):
-        strips_i = _measure_strips(
+    def _measure_for_step_count(n_steps_i: int) -> StripDepths:
+        return _measure_strips(
             holes,
             patterns,
-            n_for_sizing,
+            n_steps_i,
             bb,
             arrow_length=_arrow_length,
             pad_around_text=_pad_around_text,
         )
-        SCALE, PAGE_W, PAGE_H, TB_W = choose_scale(
-            x_size, y_size, z_size, n_steps=n_for_sizing, scale=scale, page=page, strips=strips_i
+
+    def _pick_for_step_count(n_steps_i: int, strips_i: StripDepths) -> _ScalePick:
+        return choose_scale(
+            x_size,
+            y_size,
+            z_size,
+            n_steps=n_steps_i,
+            scale=scale,
+            page=page,
+            strips=strips_i,
+            section=layout_section,
+            table_sizes=layout_table_sizes,
         )
-        n_next = len(_legible_steps(step_zs, bb.min.Z, SCALE)[0])
-        if n_next == n_for_sizing:
-            break
-        n_for_sizing = n_next
+
+    (SCALE, PAGE_W, PAGE_H, TB_W), strips_i, n_for_sizing = _converge_step_sizing(
+        len(step_zs),
+        _measure_for_step_count,
+        _pick_for_step_count,
+        lambda scale_i: len(_legible_steps(step_zs, bb.min.Z, scale_i)[0]),
+    )
     if scale is not None:
         # An explicit scale is the user's call — honour it (#489). Two floors apply:
         #  - _MIN_RENDER_MM: a hard geometry limit; below it OCCT's annotation arcs degenerate
@@ -362,7 +483,15 @@ def _analyse(
                 f"Use scale ≥ {safe:.3g} or omit the scale for automatic selection."
             )
         auto_scale, _, _, _ = choose_scale(
-            x_size, y_size, z_size, n_steps=n_for_sizing, scale=None, page=page, strips=strips_i
+            x_size,
+            y_size,
+            z_size,
+            n_steps=n_for_sizing,
+            scale=None,
+            page=page,
+            strips=strips_i,
+            section=layout_section,
+            table_sizes=layout_table_sizes,
         )
         # Warn only when omitting the scale would truly give a legible fit (auto scale itself is
         # legible) but the requested scale is below the floor. A part illegible at every
@@ -393,7 +522,19 @@ def _analyse(
     # View positions + iso empty-rectangle, shared with scale selection (_fits)
     # via _layout_geometry so placement and fit never diverge (#11).  _fit_iso_view
     # later scales the iso to fill its rectangle.
-    _g = _layout_geometry(x_size, y_size, z_size, SCALE, PAGE_W, PAGE_H, TB_W, strips, n_steps)
+    _g = _layout_geometry(
+        x_size,
+        y_size,
+        z_size,
+        SCALE,
+        PAGE_W,
+        PAGE_H,
+        TB_W,
+        strips,
+        n_steps,
+        section=layout_section,
+        table_sizes=layout_table_sizes,
+    )
     fv_hw = _g.fv_hw
     fv_hh = _g.fv_hh
     pv_hh = _g.pv_hh
@@ -461,6 +602,10 @@ def _analyse(
         is_rotational=is_rotational,
         od_axis=od_axis,
         step_zs=step_zs,
+        layout_strips=strips,
+        layout_n_steps=n_steps,
+        layout_section=layout_section,
+        layout_table_sizes=layout_table_sizes,
         sv_right=sv_right,
         iso_right_limit=iso_right_limit,
         SCALE=SCALE,

{draftwright-0.2.10 → draftwright-0.2.11}/src/draftwright/annotations/_common.py

@@ -537,11 +537,30 @@ def place_strip_candidates(
     # Fill innermost-first (nearest the view), matching the old cursor's stack order.
     segs.sort(key=lambda s: abs((s[0] if inner == lo else s[1]) - inner))
     todo = list(cands)
-    for seg_lo, seg_hi in segs:
-        if not todo:
-            break
-        cap = int((seg_hi - seg_lo) / pad) + 1
-        take, todo = todo[:cap], todo[cap:]
+
+    def _take_for_segment(items, n):
+        if len(items) <= n:
+            return items, []
+        # Do not let segment-cap slicing preempt the ranked selection step (#357/#393).
+        # `plan_strip` drops the lowest (priority, generated-key), but a narrow segment
+        # can only see the candidates we hand it. Preselect the highest-priority members
+        # for this segment, preserving their original order for crossing-free placement;
+        # ties mirror the generated key below (inner=lo keeps later candidates, inner=hi
+        # keeps earlier candidates).
+        ranked = sorted(
+            enumerate(items),
+            key=lambda item: (
+                (priorities or {}).get(item[1][0], 0.0),
+                item[0] if inner == lo else -item[0],
+            ),
+            reverse=True,
+        )
+        chosen = {i for i, _ in ranked[:n]}
+        take = [nb for i, nb in enumerate(items) if i in chosen]
+        rest = [nb for i, nb in enumerate(items) if i not in chosen]
+        return take, rest
+
+    def _evaluate_segment(take, seg_lo, seg_hi):
         nat = seg_lo if inner == lo else seg_hi
         anch = (0.0, nat) if axis == "y" else (nat, 0.0)
         # Keys order the tiers so the FIRST candidate lands on the inner tier: for an
@@ -560,14 +579,16 @@ def place_strip_candidates(
             for k, nb in enumerate(take)
         ]
         res = plan_strip([sc for sc, _ in triples], seg_lo, seg_hi, pad, axis=axis)
+        accepted = []
+        rejected = []
         for sc, (name, build) in triples:
             pos = res.placed.get(sc.key)
             if pos is None:  # segment over its estimated capacity (shouldn't occur)
-                todo.append((name, build))
+                rejected.append((name, build))
                 continue
             dim = build(pos)
             if not force and _box_hits(_geom_box(dim), blockers):  # corridor crosses a leader
-                todo.append((name, build))
+                rejected.append((name, build))
                 continue
             # A forbidden box (the title block, #481) is rejected even under force — it is
             # placed after the drain, so the strip carve can't see it; a force-kept GD&T frame
@@ -575,8 +596,27 @@ def place_strip_candidates(
             # so dims are byte-identical). Returned unplaced → the caller's on_drop fallthrough.
             fb = (forbid or {}).get(name)
             if fb is not None and _box_hits(_geom_box(dim), (fb,)):
-                todo.append((name, build))
+                rejected.append((name, build))
                 continue
+            accepted.append(((name, build), dim))
+        return accepted, rejected
+
+    for seg_lo, seg_hi in segs:
+        if not todo:
+            break
+        cap = int((seg_hi - seg_lo) / pad) + 1
+        take, todo = _take_for_segment(todo, cap)
+        rejected_total = []
+        while take:
+            accepted, rejected = _evaluate_segment(take, seg_lo, seg_hi)
+            rejected_total.extend(rejected)
+            vacancies = cap - len(accepted)
+            if vacancies <= 0 or not todo:
+                break
+            fill, todo = _take_for_segment(todo, vacancies)
+            take = [nb for nb, _dim in accepted] + fill
+        todo = todo + rejected_total
+        for (name, _build), dim in accepted:
             # Record feature provenance (ADR 0010): the drain-time seam for corridor-placed
             # dims — `features` maps this batch's names to their source IR feature.
             dwg.add(dim, name, view=view, feature=(features or {}).get(name))