draftwright 0.2.5__tar.gz → 0.2.7__tar.gz

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

@@ -1,15 +1,96 @@
 # Changelog
 
-## Unreleased
+## v0.2.7 — 2026-07-05
+
+**The three authoring modes (ADR 0011 Amendment 1).** Naming how you drive draftwright —
+*just do it* / *auto then tweak* / *generate an editable script* — and filling in the third:
+a declarative `Sheet`-DSL generator, and number-free authoring against the build123d objects
+you built.
+
+### Added
+
+- **`draftwright part.step --script --style sheet`** — generate an **editable declarative
+  `Sheet` script** from a detected part: one commentable line per feature (hole / diameter /
+  step / slot / pattern / envelope), views noted, the auto-section flagged. Comment a line out
+  to drop that feature; the script re-runs to the drawing. The existing `--script` (imperative
+  edit-verb reconstruction) stays the default (#461).
+- **Object-reading `.cbore(tool)` / `.spotface(tool)`** on a declared hole — read the
+  counterbore/spotface's ⌀ **and** depth off the tool object + part (depth measured from the
+  local open face, so a rib/wall elsewhere doesn't skew it). A `Sheet`-declared drawing can now
+  carry **zero magic numbers** and track the geometry parametrically (#462).
+- **`Sheet.of(feature)`** — a fluent handle onto an **existing / detection-seeded** feature (by
+  the build123d object, an index, or the `Feature` itself), so you can `.fit(...)` /
+  `.tolerance(...)` a feature from `Sheet.from_part()` without re-declaring it (#463).
+
+### Docs
+
+- **ADR 0011 Amendment 1** — the three authoring modes and the mode-3 generation surface;
+  records the decision to emit **honest detected numbers** for a detected part rather than
+  fabricate a build123d reconstruction that misrepresents the geometry (#464).
+
+## v0.2.6 — 2026-07-05
+
+**ADR 0011 — the IR as a public input: declare features, don't only detect them.**
+Detection stays the default, but the caller can now *supply* the feature model, so a
+part you built parametrically reads as its own drawing and misdetection becomes
+recoverable by construction. Plus the first Phase-2 aspect layer (tolerances + fits).
+
+### Added
+
+- **`build_drawing(part, model=…)`** accepts a caller-supplied `PartModel` (or a
+  `Sequence[Feature]`); when given, **detection is skipped** and the auto-pass dimensions
+  the declared features. Detection and declaration are two producers of the same IR (#447,
+  ADR 0011 Phase 0).
+- **Object → feature constructors** `draftwright.model.hole` / `boss` / `step` / `slot` /
+  `pattern` / `envelope` — read a feature's geometry off the build123d object you built (⌀
+  from the cylindrical face, axis/location from the bbox), or supply explicit values (#447).
+- **The fluent `Sheet` façade** (`draftwright.Sheet`) — reference the objects you built,
+  declare their drawing aspects, `.build()` / `.export()`. `Sheet.from_part()` seeds the
+  hybrid override mode from detection (#447, Phase 1).
+- **Toleranced dimensions** — a `±` / limit tolerance on a diameter, step, or hole bore,
+  rendered on both the linear and ⌀-callout paths (`Sheet.tolerance(...)`, or a
+  `decorations=` side-layer) (#28, Phase 2 P2a).
+- **Fit-class deviation** — `Sheet.fit("H7")` resolves an ISO 286 fit class to its limit
+  deviation for the feature's nominal ⌀, rendered as the class code (`ø20 H7`, default) or
+  the signed deviations (`show="deviation"` → `ø20 +0.021/0`). Common classes; fails loud
+  outside its table (#29, Phase 2 P2a.2).
+
+### Changed
+
+- **Object constructors honour explicit overrides** — a passed object supplies *defaults*;
+  each explicit keyword overrides that field independently, and invalid public input fails
+  at declaration with a clear `ValueError` (#451, #452).
+- **A declared hole/pattern renders at its declared position** even where detection missed
+  it — the callout membership is sourced from the declared model, not only detection (#448).
+- **`Sheet.model()` / `Sheet.from_part()`** no longer build a full drawing just to return
+  the IR — feature inspection/seeding is now a cheap, no-render path (#453).
+
+### Fixed
+
+- A narrow diameter band hidden under a larger OD silhouette is no longer silently
+  undimensioned (the two feature inventories agreed) (#298).
+
+## v0.2.5 — 2026-07-04
+
+**The editable write API and record-then-finalize.** A detected drawing became an editable
+object, and a generated `--script` became a runnable reconstruction that reaches auto-pass
+quality.
+
+### Added
+
+- **`dwg.model()`** exposes the detected `PartModel` as a read surface, plus feature-
+  referenced add verbs `dimension()` / `callout()` / `locate()` / `furniture()` /
+  `section()` and `drop(feature)`, with a machine-checked completeness audit (#400).
+- **Record-then-finalize** (#426): the verbs record intents in deferred mode and
+  `dwg.finalize()` (auto-run by export) drains them through the auto-pass's own solvers, so
+  a reconstruction reaches auto-pass quality; `--script` now emits a runnable detect-only
+  reconstruction.
 
 ### Changed
 
-- **Dimension-line spacing now follows ISO 129-1 / ASME Y14.5 convention** (#347).
-  The first dimension line sits further from the view outline (first-line gap
-  8 → 10 mm) and successive parallel lines stack tighter and uniform (between-line
-  clear gap 4 → 2.5 mm). The inter-view corridor widens in step (`_DIM_PAD`
-  18 → 20 mm) so the wider first-line gap does not crowd the between-view
-  dimensions. Re-drifts the layout of every drawing.
+- **Dimension-line spacing now follows ISO 129-1 / ASME Y14.5 convention** (#347): a wider
+  first-line gap (8 → 10 mm) and tighter, uniform parallel stacking (between-line clear gap
+  4 → 2.5 mm), with the inter-view corridor widened in step. Re-drifts every drawing.
 
 ## v0.2.4 — 2026-07-03
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.2.5
+Version: 0.2.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.2.5 → draftwright-0.2.7}/pyproject.toml

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

{draftwright-0.2.5 → draftwright-0.2.7}/src/draftwright/__init__.py

@@ -30,6 +30,7 @@ _LAZY = {
     "make_drawing": "draftwright.builder",
     "Drawing": "draftwright.drawing",
     "FeatureInfo": "draftwright.drawing",
+    "Sheet": "draftwright.sheet_dsl",
     "fix_svg_page_size": "draftwright.export",
     "lint_feature_coverage": "draftwright.linting",
     "PmiRecord": "draftwright.pmi",
@@ -78,6 +79,7 @@ if TYPE_CHECKING:  # static analysers / IDEs — no runtime import, no kernel co
     from draftwright.linting import lint_feature_coverage
     from draftwright.pmi import PmiRecord, extract_pmi
     from draftwright.sheet import choose_scale
+    from draftwright.sheet_dsl import Sheet
 
 
 def __dir__():
@@ -91,6 +93,7 @@ __all__ = [
     "Drawing",
     "FeatureInfo",
     "PmiRecord",
+    "Sheet",
     "analyse_face_levels",
     "build_drawing",
     "choose_scale",

{draftwright-0.2.5 → draftwright-0.2.7}/src/draftwright/_core.py

@@ -30,6 +30,7 @@ from build123d_drafting.helpers import (
     format_drawing_scale,
 )
 
+from draftwright.fits import FitClass
 from draftwright.fonts import PLEX_MONO, PLEX_SANS_CONDENSED
 from draftwright.layout import _greedy_strip_1d, _solve_strip_1d
 
@@ -86,6 +87,30 @@ def _fmt(v: float) -> str:
     return str(r) if abs(v - r) < 1e-6 else f"{v:.1f}"
 
 
+def _tol_suffix(tolerance, draft) -> str:
+    """The ``±`` / limit tolerance suffix to append to a **callout** label (a ø leader
+    or a hole callout), matching byte-for-byte what ``Dimension(tolerance=…)`` renders
+    on a linear dim (helpers ``_format_label``): a symmetric ``float`` → ``" ±t"``; an
+    ``(lower, upper)`` pair → ``" +upper -lower"`` — all rounded to the draft precision.
+
+    draftwright owns this suffix ONLY because the pinned helpers' ``Leader`` /
+    ``HoleCallout`` take no ``tolerance=`` yet, so we bake it into the label string
+    ourselves. Delete this once helpers grows a first-class tolerance parameter for
+    those two (extraction tracked as #449) — ``Dimension`` formats its own (#28 / P2a).
+
+    A resolved fit (:class:`~draftwright.fits.FitClass`, P2a.2) renders its own class-code
+    or deviation suffix — it rides the same ``tolerance`` field as an aspect marker."""
+    if tolerance is None:
+        return ""
+    if isinstance(tolerance, FitClass):
+        return tolerance.suffix()
+    prec = draft.decimal_precision
+    if isinstance(tolerance, (int, float)):
+        return f" ±{round(tolerance, prec):.{prec}f}"
+    lo, hi = tolerance
+    return f" +{round(hi, prec):.{prec}f} -{round(lo, prec):.{prec}f}"
+
+
 def _tag_sequence(n):
     """``A, B, …, Z, AA, AB, …`` — deterministic hole-table tags for *n* rows."""
     tags = []

{draftwright-0.2.5 → draftwright-0.2.7}/src/draftwright/analysis.py

@@ -179,6 +179,26 @@ _STEP_MIN_AREA_FRAC = 0.01
 # ---------------------------------------------------------------------------
 
 
+def _solids_body(part, src: str = "part"):
+    """The part reduced to just its solids — the geometry the drawing is *of*.
+
+    AP242 STEP files (and hand-built Compounds) can carry non-solid geometry beside
+    the solid — PMI presentation wires, leader curves, construction edges/sketches —
+    which, left in, draw as phantom rectangles in every view and inflate the bounding
+    box, corrupting the scale choice and the envelope dimensions. Shared by
+    :func:`_analyse` and :meth:`draftwright.Sheet.model` (#453) so the model a caller
+    *inspects* is wrapped from the exact same body the engine *draws*."""
+    solids = part.solids()
+    if not solids:
+        return part
+    body = solids[0] if len(solids) == 1 else Compound(children=list(solids))
+    if body.bounding_box().size != part.bounding_box().size or len(part.edges()) != len(
+        body.edges()
+    ):
+        _log.info("Dropping non-solid geometry from %s (PMI presentation data)", src)
+    return body
+
+
 def _analyse(
     step_file, title, number, tolerance, drawn_by, out, scale=None, page=None, pmi="off"
 ) -> Analysis:
@@ -192,22 +212,7 @@ def _analyse(
     else:
         part = _import_step(step_file)
         src = str(step_file)
-    # AP242 STEP files carry PMI presentation geometry (annotation-plane
-    # border wires, leader curves) beside the solid; left in, it draws as
-    # phantom rectangles in every view and inflates the bounding box —
-    # corrupting the scale choice and the envelope dimensions. The drawing
-    # is of the solids.
-    solids = part.solids()
-    if solids:
-        body = solids[0] if len(solids) == 1 else Compound(children=list(solids))
-        if body.bounding_box().size != part.bounding_box().size or len(part.edges()) != len(
-            body.edges()
-        ):
-            _log.info(
-                "Dropping non-solid geometry from %s (PMI presentation data)",
-                src,
-            )
-        part = body
+    part = _solids_body(part, src)
 
     # Semantic PMI extraction (AP242 only; separate read-only pass).
     pmi_records: list = []

{draftwright-0.2.5 → draftwright-0.2.7}/src/draftwright/annotations/from_model.py

@@ -41,6 +41,7 @@ from draftwright._core import (
     _legible_steps,
     _log,
     _solve_strip_ys,
+    _tol_suffix,
 )
 from draftwright.annotations._common import (
     CROSSABLE_TYPES,
@@ -82,6 +83,14 @@ def hole_callout_spec(group: DimensionGroup) -> dict | None:
     bore = _first(group, "diameter", "bore")
     if bore is None:
         return None
+    bore_tol = next(
+        (
+            pd.param.tolerance
+            for pd in group.dims
+            if pd.param.kind == "diameter" and pd.param.role == "bore"
+        ),
+        None,
+    )
     depth = _first(group, "depth", "bore")
     count = feat.count
     suffix = None
@@ -99,6 +108,7 @@ def hole_callout_spec(group: DimensionGroup) -> dict | None:
         "cbore_dia": _first(group, "diameter", "counterbore", "spotface"),
         "cbore_depth": _first(group, "depth", "counterbore", "spotface"),
         "suffix": suffix,
+        "tolerance": bore_tol,  # P2a: ± on the bore ⌀, baked into the callout string below
     }
 
 
@@ -120,8 +130,14 @@ def callout_from_spec(spec, draft, count) -> HoleCallout | None:
     def f(v):  # see the #261 note above — every value crosses as a formatted string
         return _fmt(v) if v is not None else None
 
+    dia = f(spec["diameter"])
+    if dia is not None:
+        # P2a: bake the ± tolerance into the bore string (helpers' HoleCallout accepts a
+        # diameter carrying tolerance/fit text, "8 ±0.05"); no tolerance → empty suffix.
+        dia += _tol_suffix(spec.get("tolerance"), draft)
+
     return HoleCallout(
-        f(spec["diameter"]),
+        dia,
         count=count,
         through=spec["through"],
         depth=f(spec["depth"]),
@@ -578,6 +594,28 @@ def _mentioned_diameters(dwg) -> set[float]:
     return diams
 
 
+def _place_what_fits(specs, axis: int, min_gap: float, lo: float, hi: float):
+    """Fit as many ø specs as the strip ``[lo, hi]`` holds at ``min_gap`` spacing,
+    dropping the SMALLEST-diameter spec first when the full set overflows — so the
+    significant ODs survive and only the finest bands fall to ``feature_not_dimensioned``,
+    never the whole row/column (#298). ``specs`` = ``[(tip, dia, label, feat), ...]``;
+    ``axis`` selects the strip coordinate of ``tip`` (0 = page-x for the row-below, 1 =
+    page-y for the column-left). Returns ``(survivors_in_strip_order, positions)`` —
+    ``([], [])`` if not even one fits. A part whose full row already fits keeps every
+    spec in strip order, so existing output is unchanged."""
+    survivors = sorted(specs, key=lambda s: s[0][axis])
+    while survivors:
+        naturals = [s[0][axis] for s in survivors]
+        pos = _solve_strip_ys(naturals, min_gap, lo, hi) or _greedy_strip_ys(
+            naturals, min_gap, lo, hi
+        )
+        if pos is not None:
+            return survivors, pos
+        drop = min(range(len(survivors)), key=lambda i: survivors[i][1])
+        survivors.pop(drop)
+    return [], []
+
+
 def _diameter_row_below(dwg, items, start: int = 0) -> int:
     """ø-callout row BELOW the front view for X-turned step/boss diameters (#77).
     *items* is ``[(anchor, diameter), ...]``. The row is dropped clear of anything
@@ -599,28 +637,23 @@ def _diameter_row_below(dwg, items, start: int = 0) -> int:
     label_y = obstacle_bottom - (draft.font_size + 4 * draft.pad_around_text)
     if label_y < _MARGIN + draft.font_size:
         return 0
-    specs = []  # (tip_page, label, feature), tip on the step's bottom silhouette
-    for anchor, dia, feat in items:
+    specs = []  # (tip_page, dia, label, feature), tip on the step's bottom silhouette
+    for anchor, dia, feat, dtol in items:
         ax, ay, az = anchor
         tip = dwg.at("front", ax, ay, az - dia / 2)
-        specs.append((tip, f"ø{_fmt(dia)}", feat))
-    specs.sort(key=lambda s: s[0][0])
-    half_w = max(len(label) for _, label, _ in specs) * draft.font_size * 0.62 / 2
+        specs.append((tip, dia, f"ø{_fmt(dia)}{_tol_suffix(dtol, draft)}", feat))
+    half_w = max(len(label) for _, _, label, _ in specs) * draft.font_size * 0.62 / 2
     min_gap = 2 * half_w + 2 * draft.pad_around_text
-    naturals = [tip[0] for tip, _, _ in specs]
-    xs = _solve_strip_ys(naturals, min_gap, fx0 + half_w, fx1 - half_w) or _greedy_strip_ys(
-        naturals, min_gap, fx0 + half_w, fx1 - half_w
-    )
-    if xs is None:
-        return 0
-    for i, ((tip, label, feat), lx) in enumerate(zip(specs, xs, strict=True)):
+    # Place what fits; drop the smallest ø first, never the whole row (#298).
+    survivors, xs = _place_what_fits(specs, 0, min_gap, fx0 + half_w, fx1 - half_w)
+    for i, ((tip, dia, label, feat), lx) in enumerate(zip(survivors, xs, strict=True)):
         dwg.add(
             Leader(tip=(tip[0], tip[1], 0), elbow=(lx, label_y, 0), label=label, draft=draft),
             f"m_dia_x{start + i}",
             view="front",
             feature=feat,
         )
-    return len(specs)
+    return len(survivors)
 
 
 def _diameter_column_left(dwg, items, start: int = 0) -> int:
@@ -632,31 +665,30 @@ def _diameter_column_left(dwg, items, start: int = 0) -> int:
         return 0
     draft = dwg.draft
     fx0, fy0, _, fy1 = dwg.view_bounds("front")
-    label_w = max(len(f"ø{_fmt(dia)}") for _, dia, _ in items) * draft.font_size * 0.62
+    label_w = (
+        max(len(f"ø{_fmt(dia)}{_tol_suffix(dtol, draft)}") for _, dia, _, dtol in items)
+        * draft.font_size
+        * 0.62
+    )
     elbow_x = fx0 - (draft.font_size + 2 * draft.pad_around_text)
     if elbow_x - label_w < _MARGIN:
         return 0
-    specs = []  # (tip_page, label, feature), tip on the step's left silhouette
-    for anchor, dia, feat in items:
+    specs = []  # (tip_page, dia, label, feature), tip on the step's left silhouette
+    for anchor, dia, feat, dtol in items:
         ax, ay, az = anchor
         tip = dwg.at("front", ax - dia / 2, ay, az)
-        specs.append((tip, f"ø{_fmt(dia)}", feat))
-    specs.sort(key=lambda s: s[0][1])
+        specs.append((tip, dia, f"ø{_fmt(dia)}{_tol_suffix(dtol, draft)}", feat))
     half_h = draft.font_size / 2 + draft.pad_around_text
     min_gap = 2 * half_h
-    naturals = [tip[1] for tip, _, _ in specs]
-    ys = _solve_strip_ys(naturals, min_gap, fy0 + half_h, fy1 - half_h) or _greedy_strip_ys(
-        naturals, min_gap, fy0 + half_h, fy1 - half_h
-    )
-    if ys is None:
-        return 0
+    # Place what fits; drop the smallest ø first, never the whole column (#298).
+    survivors, ys = _place_what_fits(specs, 1, min_gap, fy0 + half_h, fy1 - half_h)
     # Full-footprint occupancy (leader shafts, witness/extension lines, hatch) — NOT
     # the label-box-only `_occupied_boxes`, which is blind to a bore callout's leader
     # SHAFT, so a ø label could silently overprint it (the #133/#225/#305 invisible-
     # occupant class, #358). Centre lines stay crossable (a diameter dim may cross one).
     occupied = strip_obstacles(dwg, view="front", crossable=CROSSABLE_TYPES)
     placed = 0
-    for i, ((tip, label, feat), ly) in enumerate(zip(specs, ys, strict=True)):
+    for i, ((tip, dia, label, feat), ly) in enumerate(zip(survivors, ys, strict=True)):
         ldr = Leader(tip=(tip[0], tip[1], 0), elbow=(elbow_x, ly, 0), label=label, draft=draft)
         if _box_hits(_anno_box(ldr), occupied):
             continue  # would overprint a bore leader / existing callout — drop just this one
@@ -682,24 +714,35 @@ def render_diameters(dwg, groups, tol: float = 0.15, *, only=None) -> int:
     # diameter (insertion-ordered), so provenance (#412) can tag the callout with its
     # single owner — or leave it unowned when two distinct features share the diameter
     # (the #398c/#406 shared-value rule, so drop can't over-strip a sibling).
-    row_buckets: dict = {}  # round(dia,2) -> [anchor, dia, {features}]  (X-turned)
+    row_buckets: dict = {}  # round(dia,2) -> [anchor, dia, {features}, tolerance]  (X-turned)
     col_buckets: dict = {}  # Z-turned
     for g in groups:
         if g.feature_kind not in ("step", "boss"):
             continue
         if only is not None and g.feature not in only:  # #426 finalize: recorded subset
             continue
-        dia = next((pd.param.value for pd in g.dims if pd.param.kind == "diameter"), None)
-        if dia is None or any(abs(dia - m) <= tol for m in mentioned):
+        dpd = next((pd for pd in g.dims if pd.param.kind == "diameter"), None)
+        if dpd is None:
+            continue
+        dia = dpd.param.value
+        if any(abs(dia - m) <= tol for m in mentioned):
             continue
         bucket = {"x": row_buckets, "z": col_buckets}.get(g.feature.frame.axis)
         if bucket is None:
             continue
         dkey = round(dia, 2)
-        bucket.setdefault(dkey, [g.anchor, dia, set()])[2].add(g.feature)
+        dtol = dpd.param.tolerance
+        # entry = [anchor, dia, {features}, ± tolerance]. A callout is per (axis, ⌀); the
+        # first authored tolerance on a shared ⌀ wins (P2a — a single callout, one label).
+        entry = bucket.setdefault(dkey, [g.anchor, dia, set(), dtol])
+        entry[2].add(g.feature)
+        if entry[3] is None:
+            entry[3] = dtol
 
     def _items(buckets):
-        return [(a, d, next(iter(fs)) if len(fs) == 1 else None) for a, d, fs in buckets.values()]
+        return [
+            (a, 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
     # (only None) uses start=0 — byte-identical. The finalize path (only set) may run after
@@ -867,12 +910,14 @@ def _draw_step_chain(
     draft = dwg.draft
     gap = draft.font_size + 4 * draft.pad_around_text
     horizontal = abs(segs[0][1][0] - segs[0][0][0]) >= abs(segs[0][1][1] - segs[0][0][1])
-    vals = [v for *_, v in segs]
+    vals = [s[2] for s in segs]  # value is index 2 (segs are 4-tuples: pa, pb, value, tol)
     mean_v = sum(vals) / len(vals)
     if allow_collapse and len(segs) >= 3 and (max(vals) - min(vals)) <= 0.10 * mean_v:
+        # A uniform run collapses to one "N× v" dim; a per-step ± would be a false claim on
+        # N equal steps, so the collapse carries NO tolerance (#28 / P2a).
         label = f"{len(segs)}× {_fmt(mean_v)}"
-        xs = [p[0] for pa, pb, _ in segs for p in (pa, pb)]
-        ys = [p[1] for pa, pb, _ in segs for p in (pa, pb)]
+        xs = [p[0] for pa, pb, *_ in segs for p in (pa, pb)]
+        ys = [p[1] for pa, pb, *_ in segs for p in (pa, pb)]
         if horizontal:
             dim = _dim((min(xs), y1, 0), (max(xs), y1, 0), "above", gap, draft, label=label)
         else:
@@ -884,7 +929,8 @@ def _draw_step_chain(
         tiers = [0] * len(segs)
         if horizontal:
             cw = [
-                ((pa[0] + pb[0]) / 2, len(_fmt(v)) * draft.font_size * 0.62) for pa, pb, v in segs
+                ((pa[0] + pb[0]) / 2, len(_fmt(v)) * draft.font_size * 0.62)
+                for pa, pb, v, *_ in segs
             ]
 
             def _clear(items):  # (center, width) pairs in x order — labels don't overlap
@@ -904,14 +950,14 @@ def _draw_step_chain(
                 )
                 return 0
         else:
-            shoulder_ys = sorted({c for pa, pb, _ in segs for c in (pa[1], pb[1])})
+            shoulder_ys = sorted({c for pa, pb, *_ in segs for c in (pa[1], pb[1])})
             if any(b - a < tier_step for a, b in zip(shoulder_ys, shoulder_ys[1:])):
                 _log.info("step-length chain skipped: shoulders too close to dimension")
                 _record_step_chain_drop(dwg, "turned shoulders too closely spaced to dimension")
                 return 0
 
         candidates = []
-        for i, (pa, pb, value) in enumerate(segs):
+        for i, (pa, pb, value, seg_tol) in enumerate(segs):
             if horizontal:
                 p1, p2, side = (pa[0], y1, 0), (pb[0], y1, 0), "above"
                 dist = gap + tiers[i] * tier_step
@@ -919,7 +965,10 @@ def _draw_step_chain(
                 p1, p2, side = (x1, pa[1], 0), (x1, pb[1], 0), "right"
                 dist = gap
             candidates.append(
-                (f"{name_prefix}{start + i}", _dim(p1, p2, side, dist, draft, label=_fmt(value)))
+                (
+                    f"{name_prefix}{start + i}",
+                    _dim(p1, p2, side, dist, draft, label=_fmt(value), tolerance=seg_tol),
+                )
             )
 
     # Room guard: if any dim would fall off the drawable page, place NONE.
@@ -980,14 +1029,14 @@ def render_step_lengths(dwg, groups, *, only=None) -> int:
         )
         if length is None or length.span is None:
             continue
-        rows.append((length.span[0], length.span[1], length.value))
+        rows.append((length.span[0], length.span[1], length.value, length.tolerance))
     if not rows:
         return 0
     draft = dwg.draft
     # only=None (auto-pass) → start=0, historical m_steplen naming, byte-identical. The
     # finalize path (only set) starts past existing m_steplen names (#426 naming seam).
     start = _next_steplen_start(dwg) if only is not None else 0
-    fsegs = [(dwg.at("front", *a), dwg.at("front", *b), v) for a, b, v in rows]
+    fsegs = [(dwg.at("front", *a), dwg.at("front", *b), v, t) for a, b, v, t in rows]
     horizontal = abs(fsegs[0][1][0] - fsegs[0][0][0]) >= abs(fsegs[0][1][1] - fsegs[0][0][1])
 
     # X-turned crowded-head detour (#307): split off each contiguous *run of ≥2*
@@ -997,7 +1046,7 @@ def render_step_lengths(dwg, groups, *, only=None) -> int:
     # (#307 review). The legible steps + blocks stay as the main chain.
     if horizontal:
         floor_pg = 2 * draft.arrow_length
-        sub = [i for i, (pa, pb, _) in enumerate(fsegs) if abs(pb[0] - pa[0]) < floor_pg]
+        sub = [i for i, (pa, pb, *_) in enumerate(fsegs) if abs(pb[0] - pa[0]) < floor_pg]
         runs: list[list[int]] = []
         for j in sub:
             (runs[-1].append(j) if runs and j == runs[-1][-1] + 1 else runs.append([j]))
@@ -1006,17 +1055,20 @@ def render_step_lengths(dwg, groups, *, only=None) -> int:
             blocks = []
             for run in heads:
                 ra = [rows[i] for i in run]
-                hlo = min(min(a[0], b[0]) for a, b, _ in ra)
-                hhi = max(max(a[0], b[0]) for a, b, _ in ra)
-                minlen = min(v for *_, v in ra)
+                hlo = min(min(a[0], b[0]) for a, b, *_ in ra)
+                hhi = max(max(a[0], b[0]) for a, b, *_ in ra)
+                minlen = min(r[2] for r in ra)  # value is index 2 (rows are 4-tuples: a,b,v,tol)
                 # World→page scale for the detail (no sheet factor — detail_scale is an
                 # absolute world→page scale). (#307 review)
                 scale_needed = _MIN_STEP_SEP_MM / minlen if minlen > 0 else float("inf")
-                blocks.append((dwg.at("front", hlo, 0, 0), dwg.at("front", hhi, 0, 0), hhi - hlo))
+                # A head *block* is a synthetic span, not one toleranced step — carry no ± (None).
+                blocks.append(
+                    (dwg.at("front", hlo, 0, 0), dwg.at("front", hhi, 0, 0), hhi - hlo, None)
+                )
 
                 def _redraw(dwg, view, detail_scale, _hw=ra):
                     # View-scoped name prefix so two detail views never collide (#307 review).
-                    hsegs = [(dwg.at(view, *a), dwg.at(view, *b), v) for a, b, v in _hw]
+                    hsegs = [(dwg.at(view, *a), dwg.at(view, *b), v, t) for a, b, v, t in _hw]
                     return _draw_step_chain(dwg, view, hsegs, f"dim_{view}_steplen", detail_scale)
 
                 dwg._detail_requests.append(

{draftwright-0.2.5 → draftwright-0.2.7}/src/draftwright/annotations/holes.py

@@ -388,12 +388,13 @@ def add_feature_diameter(dwg, feature) -> str:
             "pass one from dwg.model().features"
         )
     group = next((g for g in plan_dimensions(model) if g.feature is feature), None)
-    dia = (
-        next((pd.param.value for pd in group.dims if pd.param.kind == "diameter"), None)
+    dpd = (
+        next((pd for pd in group.dims if pd.param.kind == "diameter"), None)
         if group is not None
         else None
     )
-    if group is None or dia is None:
+    dia = dpd.param.value if dpd is not None else None
+    if group is None or dpd is None or dia is None:
         raise ValueError(
             f"callout(): {type(feature).__name__} exposes no step/boss diameter callout"
         )
@@ -403,7 +404,9 @@ def add_feature_diameter(dwg, feature) -> str:
             f"callout(): a {axis!r}-turned step/boss diameter is not placeable "
             "(only X- and Z-turned parts)"
         )
-    items = [(group.anchor, dia, feature)]
+    # 4-tuple (anchor, dia, feature, tolerance): a manual callout honours a declared ±
+    # tolerance too, like the auto-pass (P2a, #28).
+    items = [(group.anchor, dia, feature, dpd.param.tolerance)]
     # The row/column placers name leaders m_dia_{x,z}{start+i} — pass the first FREE
     # index so a second callout() (or a call on an already-annotated turned part) never
     # collides on m_dia_x0/z0 and clobbers an existing leader (#419 review F1).
@@ -698,7 +701,7 @@ def _add_furniture(dwg, a: Analysis, view, j, feat: PatternFeature | None, to_pa
     here) so it survives finalize's ``place_furniture=False`` (#426 Ph4c)."""
     if feat is None:
         return
-    members = feat.members
+    members = feat.members or (feat.frame.origin,)  # guard a declared pattern's empty members
     # Remember the bore-callout name AND the holes it documents (by position), so a
     # later hole-table escalation leaves the grouped pattern callout standing and
     # tabulates only the holes no *placed* pattern callout covers (#92).