From 5291e8dd7b14cda3ce31507cc1e5f8a4e442fea2 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:02:06 +0000 Subject: [PATCH 1/5] Expose bounded lanes for step diameter leaders --- docs/reference/sheet.md | 5 +- src/draftwright/annotations/_diameters.py | 162 +++++++++++++++++- .../annotations/_machined_leaders.py | 28 ++- src/draftwright/annotations/from_model.py | 4 + src/draftwright/model/planner.py | 1 + ...st_issue_1308_machined_leader_analytics.py | 27 +++ tests/test_layout_override_lane_issue_1757.py | 46 ++++- 7 files changed, 260 insertions(+), 13 deletions(-) diff --git a/docs/reference/sheet.md b/docs/reference/sheet.md index 4b32c242..9c85290e 100644 --- a/docs/reference/sheet.md +++ b/docs/reference/sheet.md @@ -358,8 +358,9 @@ the dimension renderer actually consumes. A lane is an integer from 1 through 8: a one-based drafting-spaced rank from that dimension's physical witness, not a distance. The shared measured-candidate solve may resolve it into proven whitespace inside or outside the view and records that candidate's region explicitly. The -current lane-capable slice is the linear width/length dimensions of slots and the -overall OD diameter of a rotational feature. Capability is +current lane-capable slice is the linear width/length dimensions of slots, the +overall OD diameter of a rotational feature, and step diameter leaders. +Capability is declared in one compiler-owned registry so another dimension family is added deliberately, not by teaching each renderer a private spelling. diff --git a/src/draftwright/annotations/_diameters.py b/src/draftwright/annotations/_diameters.py index 76944d8b..0f57e2f2 100644 --- a/src/draftwright/annotations/_diameters.py +++ b/src/draftwright/annotations/_diameters.py @@ -537,6 +537,97 @@ def _diameter_bucket_item(entry): ) +def _diameter_bucket_lane(entry) -> int | None: + """The planner permits one exact lane for a physical diameter bucket.""" + lanes = { + dim.lane + for group in entry[6] + for dim in group.dims + if dim.kind == "diameter" and dim.lane is not None + } + if len(lanes) > 1: + raise ValueError("one physical diameter cannot have conflicting requested lanes") + return next(iter(lanes)) if len(lanes) == 1 else None + + +def _render_diameter_lanes( + dwg, a, indexed_buckets, *, axis, prefix, start, ctx, radial_candidates, place_jobs, leader_reach +) -> int: + """Offer only the requested witness-relative rank to the shared leader solve.""" + vb = dwg.view_bounds("front") + if vb is None: + return 0 + spacing = dwg.draft.font_size + 2 * dwg.draft.pad_around_text + jobs = [] + names = set() + requested_lanes = {} + covers_diameters_by_name = {} + for index, entry in indexed_buckets: + _anchor, dia, value_text, refs, tolerance, rider, groups = entry + lane = _diameter_bucket_lane(entry) + if lane is None: + continue + representative = groups[0].facts + owner = next(iter(refs)) if len(refs) == 1 else None + name = f"{prefix}{start + index}" + names.add(name) + requested_lanes[name] = lane + if axis == "y": + covers_diameters_by_name[name] = dia + reach = leader_reach(dwg.draft) + (lane - 1) * spacing + if axis == "y": + candidates = radial_candidates( + dwg, + "front", + vb, + representative, + reach, + rim=dia / 2 * a.SCALE, + directions=_END_DIAMETER_LEAD_DIRS, + provenance=owner, + ) + else: + candidates = radial_candidates( + dwg, + "front", + vb, + representative, + reach, + source_bounds=_diameter_source_bounds(dwg, "front", representative, dia), + directions=_DIAMETER_LEAD_DIRS[axis], + provenance=owner, + ) + label = f"ø{value_text}{_tol_suffix(tolerance, dwg.draft)}" + if rider: + label += f" {rider}" + mids = tuple( + parameter.id + for group in groups + for parameter in group.dims + if parameter.kind == "diameter" + ) + jobs.append((name, "front", vb, label, candidates, mids)) + if not jobs: + return 0 + return cast( + int, + place_jobs( + dwg, + a, + jobs, + noun="diameter at requested lane", + drop_code="diameter_dropped", + ctx=ctx, + geom_clear=True, + joint=True, + expand_lanes=False, + straight_only_names=frozenset(names), + requested_lanes=requested_lanes, + covers_diameters_by_name=covers_diameters_by_name, + ), + ) + + def _counted_column_items(buckets, draft): """Share exactly two equal step labels while retaining both physical identities.""" entries = list(buckets.values()) @@ -679,8 +770,17 @@ def _typed(entry): for group in entry[6] ) - typed_entries = [(index, entry) for index, entry in indexed_row if _typed(entry)] - plain_entries = [(index, entry) for index, entry in indexed_row if not _typed(entry)] + lane_row = [(index, entry) for index, entry in indexed_row if _diameter_bucket_lane(entry)] + typed_entries = [ + (index, entry) + for index, entry in indexed_row + if not _diameter_bucket_lane(entry) and _typed(entry) + ] + plain_entries = [ + (index, entry) + for index, entry in indexed_row + if not _diameter_bucket_lane(entry) and not _typed(entry) + ] placed = 0 # Preserve the legacy tidy row for short plain diameters. Split only where a typed # bucket owns the intervening stable name; each contiguous run can then use the legacy @@ -729,13 +829,44 @@ def _typed(entry): place_jobs=place_jobs, leader_reach=leader_reach, ) - placed += _diameter_column_left( + placed += _render_diameter_lanes( dwg, - _counted_column_items(col_buckets, dwg.draft), + a, + lane_row, + axis="x", + prefix="m_dia_x", + start=start_x, + ctx=ctx, + radial_candidates=radial_candidates, + place_jobs=place_jobs, + leader_reach=leader_reach, + ) + indexed_col = list(enumerate(col_buckets.values())) + for _, run in groupby( + enumerate((index, entry) for index, entry in indexed_col if not _diameter_bucket_lane(entry)), + key=lambda item: item[1][0] - item[0], + ): + entries = [entry for _ordinal, entry in run] + run_buckets = {index: entry for index, entry in entries} + placed += _diameter_column_left( + dwg, + _counted_column_items(run_buckets, dwg.draft), + start=start_z + entries[0][0], + trace=trace, + ctx=ctx, + place_what_fits=place_what_fits, + ) + placed += _render_diameter_lanes( + dwg, + a, + [(index, entry) for index, entry in indexed_col if _diameter_bucket_lane(entry)], + axis="z", + prefix="m_dia_z", start=start_z, - trace=trace, ctx=ctx, - place_what_fits=place_what_fits, + radial_candidates=radial_candidates, + place_jobs=place_jobs, + leader_reach=leader_reach, ) # A Y-axis step is end-on in the front view, so the X/Z profile-strip @@ -760,9 +891,10 @@ def _typed(entry): hole_circles.append((px, py, diameter / 2 * a.SCALE)) jobs = [] covered_by_name = {} - for i, (_anchor, dia, value_text, refs, dtol, thr, feature_groups) in enumerate( - end_buckets.values() - ): + for i, entry in enumerate(end_buckets.values()): + if _diameter_bucket_lane(entry): + continue + _anchor, dia, value_text, refs, dtol, thr, feature_groups = entry representative = feature_groups[0].facts owner = next(iter(refs)) if len(refs) == 1 else None # Materialise now: a generator expression would close over ``owner`` @@ -812,6 +944,18 @@ def _typed(entry): ann = ctx.registry.named(name) if ann is not None: ann.covers_diameters = (dia,) + placed += _render_diameter_lanes( + dwg, + a, + [(index, entry) for index, entry in enumerate(end_buckets.values()) if _diameter_bucket_lane(entry)], + axis="y", + prefix="m_dia_y", + start=start_y, + ctx=ctx, + radial_candidates=radial_candidates, + place_jobs=place_jobs, + leader_reach=leader_reach, + ) # A ⌀ leader routed 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 diff --git a/src/draftwright/annotations/_machined_leaders.py b/src/draftwright/annotations/_machined_leaders.py index 99ad92fb..fba081be 100644 --- a/src/draftwright/annotations/_machined_leaders.py +++ b/src/draftwright/annotations/_machined_leaders.py @@ -58,6 +58,8 @@ class _MachinedJobContext: priority: float source_ids_by_name: dict source_drop_severity: str + requested_lanes: dict[str, int] + covers_diameters_by_name: dict[str, float] straight_only_names: frozenset late_inventory: bool interior_clearance_by_view: dict @@ -140,6 +142,8 @@ def decorate(leader): } if grouping_features: leader.covers_count = len(grouping_features) + if name in self.covers_diameters_by_name: + leader.covers_diameters = (self.covers_diameters_by_name[name],) return leader def build(tip, elbow, _feature): @@ -183,10 +187,22 @@ def compact_candidates(anchors, policy): yield candidate if isinstance(raw, FeatureLeaderCandidate) else raw source_ids = tuple(self.source_ids_by_name.get(name, ())) + requested_lane = self.requested_lanes.get(name) def on_drop(reason): validation = reason == "geometry_validation" detail = "rendered geometry validation failed" if validation else "no clear room" + if requested_lane is not None: + self.ctx.record_issue( + "error", + "placement_unsatisfiable", + f"{self.noun} callout {label} not placed " + f"(requested lane {requested_lane} unavailable: {detail})", + measurement=measurement, + evidence_reason=f"requested_lane_unavailable:{requested_lane}:{reason}", + outcome_stage="validation" if validation else "placement", + ) + return severity = ( ("error" if source_ids else "warning") if self.source_drop_severity == "source" @@ -261,7 +277,11 @@ def clear_foreign_label(box): interior_label_clear=interior_label_clear, foreign_label_clear=clear_foreign_label if self.cross_view_clearance else None, allow_policy_b_fixed=True, - on_drop=(on_drop if source_ids or self.source_drop_severity == "source" else None), + on_drop=( + on_drop + if requested_lane is not None or source_ids or self.source_drop_severity == "source" + else None + ), recover=None if straight_only else recover, ) @@ -392,6 +412,8 @@ def place_machined_leader_jobs( region_policy=LeaderRegionPolicy.EXTERIOR, source_ids_by_name=None, source_drop_severity="warning", + requested_lanes=None, + covers_diameters_by_name=None, priority=0.0, straight_only_names=frozenset(), cross_view_clearance=False, @@ -399,6 +421,8 @@ def place_machined_leader_jobs( ) -> int: """Lower machined callouts into the shared immediate or late leader solve.""" source_ids_by_name = source_ids_by_name or {} + requested_lanes = requested_lanes or {} + covers_diameters_by_name = covers_diameters_by_name or {} family_region_policy = LeaderRegionPolicy(region_policy) late_inventory = joint and getattr(ctx, "feature_leaders", None) is not None family = _MachinedJobContext( @@ -414,6 +438,8 @@ def place_machined_leader_jobs( priority=priority, source_ids_by_name=source_ids_by_name, source_drop_severity=source_drop_severity, + requested_lanes=requested_lanes, + covers_diameters_by_name=covers_diameters_by_name, straight_only_names=straight_only_names, late_inventory=late_inventory, interior_clearance_by_view={}, diff --git a/src/draftwright/annotations/from_model.py b/src/draftwright/annotations/from_model.py index db644e15..caef0cbf 100644 --- a/src/draftwright/annotations/from_model.py +++ b/src/draftwright/annotations/from_model.py @@ -672,6 +672,8 @@ def place_machined_leader_jobs( region_policy=LeaderRegionPolicy.EXTERIOR, source_ids_by_name=None, source_drop_severity="warning", + requested_lanes=None, + covers_diameters_by_name=None, priority=0.0, straight_only_names=frozenset(), cross_view_clearance=False, @@ -690,6 +692,8 @@ def place_machined_leader_jobs( region_policy=region_policy, source_ids_by_name=source_ids_by_name, source_drop_severity=source_drop_severity, + requested_lanes=requested_lanes, + covers_diameters_by_name=covers_diameters_by_name, priority=priority, straight_only_names=straight_only_names, cross_view_clearance=cross_view_clearance, diff --git a/src/draftwright/model/planner.py b/src/draftwright/model/planner.py index 63ed1be4..24f97430 100644 --- a/src/draftwright/model/planner.py +++ b/src/draftwright/model/planner.py @@ -607,6 +607,7 @@ def _is_zero_step_position(value: float) -> bool: ("slot", "slot_width.length"), ("slot", "slot_length.length"), ("rotational", "od.diameter"), + ("step", "step.diameter"), } ) diff --git a/tests/test_issue_1308_machined_leader_analytics.py b/tests/test_issue_1308_machined_leader_analytics.py index 4cff7229..87d3d1fc 100644 --- a/tests/test_issue_1308_machined_leader_analytics.py +++ b/tests/test_issue_1308_machined_leader_analytics.py @@ -231,6 +231,33 @@ def test_source_aware_drop_severity_preserves_unsourced_warning(monkeypatch): ] +def test_requested_leader_lane_refusal_names_exact_rank(monkeypatch): + issues = [] + ctx = SimpleNamespace( + feature_leaders=[], + record_issue=lambda *args, **kwargs: issues.append((args, kwargs)), + ) + monkeypatch.setattr(from_model, "_text_size", lambda *_args, **_kwargs: (0.0, 0.0)) + from_model.place_machined_leader_jobs( + SimpleNamespace(draft=Draft()), + None, + [("step", "front", (0.0, 0.0, 1.0, 1.0), "ø10", (), ())], + noun="diameter", + drop_code="diameter_dropped", + ctx=ctx, + joint=True, + requested_lanes={"step": 4}, + ) + + (job,) = ctx.feature_leaders + assert job.on_drop is not None + job.on_drop("no_clear_room") + (args, kwargs), = issues + assert args[0:2] == ("error", "placement_unsatisfiable") + assert "requested lane 4 unavailable" in args[2] + assert kwargs["evidence_reason"] == "requested_lane_unavailable:4:no_clear_room" + + @pytest.mark.parametrize("fixture", tuple(EXPECTED)) def test_analytical_machined_leaders_preserve_the_occ_measured_drawing(fixture, monkeypatch): from draftwright import builder as builder_module diff --git a/tests/test_layout_override_lane_issue_1757.py b/tests/test_layout_override_lane_issue_1757.py index d3f004b3..788ad037 100644 --- a/tests/test_layout_override_lane_issue_1757.py +++ b/tests/test_layout_override_lane_issue_1757.py @@ -2,11 +2,12 @@ import copy import json +import math from pathlib import Path from types import SimpleNamespace import pytest -from build123d import Box, Cylinder, Rot +from build123d import Box, Cylinder, Pos, Rot from jsonschema.validators import validator_for from draftwright import Sheet @@ -121,6 +122,49 @@ def test_od_lane_without_batch_solve_reports_refusal() -> None: assert issue.evidence_reason == "requested_lane_unavailable:2:measured_lane_solve_unavailable" +@pytest.mark.parametrize( + ("axis", "rotation"), + [("x", (0, 90, 0)), ("y", (90, 0, 0)), ("z", (0, 0, 0))], +) +def test_step_diameter_lane_moves_one_bounded_leader(axis, rotation) -> None: + elbows = [] + for lane in (1, 2): + sheet = Sheet(Rot(*rotation) * Cylinder(15, 40), page="A3", scale=2).authored_dimensions() + step = sheet.step(diameter=30, length=40, at=(0, 0, 0), axis=axis) + step.identify("declaration:step") + sheet.dimension(step, "step.diameter") + assert "lane" in sheet.layout_options( + "declaration:step", parameter="step.diameter" + )["controls"] + sheet.layout_override("declaration:step", parameter="step.diameter", lane=lane) + drawing = sheet.build() + mark = drawing.get_annotation(f"m_dia_{axis}0") + assert mark is not None + if axis == "y": + assert mark.covers_diameters == (30,) + assert not any(issue.code == "diameter_dropped" for issue in drawing.lint()) + assert drawing.report()["layout"]["overrides"][0]["resolved_value"] == lane + elbows.append(mark.elbow) + spacing = drawing.draft.font_size + 2 * drawing.draft.pad_around_text + assert math.dist(elbows[0][:2], elbows[1][:2]) == pytest.approx(spacing) + + +def test_step_lane_does_not_rename_or_duplicate_untouched_diameter() -> None: + part = Pos(-10, 0, 0) * Rot(0, 90, 0) * Cylinder(15, 20) + part += Pos(10, 0, 0) * Rot(0, 90, 0) * Cylinder(10, 20) + sheet = Sheet(part, page="A3", scale=2).authored_dimensions() + first = sheet.step(diameter=30, length=20, at=(-10, 0, 0), axis="x").identify("step:a") + second = sheet.step(diameter=20, length=20, at=(10, 0, 0), axis="x").identify("step:b") + sheet.dimension(first, "step.diameter") + sheet.dimension(second, "step.diameter") + sheet.layout_override("step:b", parameter="step.diameter", lane=2) + + drawing = sheet.build() + assert drawing.get_annotation("m_dia_x0").label == "ø30" + assert drawing.get_annotation("m_dia_x1").label == "ø20" + assert not any(issue.code == "diameter_dropped" for issue in drawing.lint()) + + def test_lane_override_changes_only_the_exact_dimension_policy() -> None: sheet = _slot_sheet() sheet.layout_override("declaration:slot", parameter="slot_width.length", lane=4) From 9d14a8fc9227d745ebe440809372c2134c731bb9 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:04:03 +0000 Subject: [PATCH 2/5] Apply repository formatting to step lane patch --- src/draftwright/annotations/_diameters.py | 22 ++++++++++++++++--- .../annotations/_machined_leaders.py | 4 +++- ...st_issue_1308_machined_leader_analytics.py | 2 +- tests/test_layout_override_lane_issue_1757.py | 7 +++--- 4 files changed, 27 insertions(+), 8 deletions(-) diff --git a/src/draftwright/annotations/_diameters.py b/src/draftwright/annotations/_diameters.py index 0f57e2f2..853af146 100644 --- a/src/draftwright/annotations/_diameters.py +++ b/src/draftwright/annotations/_diameters.py @@ -551,7 +551,17 @@ def _diameter_bucket_lane(entry) -> int | None: def _render_diameter_lanes( - dwg, a, indexed_buckets, *, axis, prefix, start, ctx, radial_candidates, place_jobs, leader_reach + dwg, + a, + indexed_buckets, + *, + axis, + prefix, + start, + ctx, + radial_candidates, + place_jobs, + leader_reach, ) -> int: """Offer only the requested witness-relative rank to the shared leader solve.""" vb = dwg.view_bounds("front") @@ -843,7 +853,9 @@ def _typed(entry): ) indexed_col = list(enumerate(col_buckets.values())) for _, run in groupby( - enumerate((index, entry) for index, entry in indexed_col if not _diameter_bucket_lane(entry)), + enumerate( + (index, entry) for index, entry in indexed_col if not _diameter_bucket_lane(entry) + ), key=lambda item: item[1][0] - item[0], ): entries = [entry for _ordinal, entry in run] @@ -947,7 +959,11 @@ def _typed(entry): placed += _render_diameter_lanes( dwg, a, - [(index, entry) for index, entry in enumerate(end_buckets.values()) if _diameter_bucket_lane(entry)], + [ + (index, entry) + for index, entry in enumerate(end_buckets.values()) + if _diameter_bucket_lane(entry) + ], axis="y", prefix="m_dia_y", start=start_y, diff --git a/src/draftwright/annotations/_machined_leaders.py b/src/draftwright/annotations/_machined_leaders.py index fba081be..282b8f38 100644 --- a/src/draftwright/annotations/_machined_leaders.py +++ b/src/draftwright/annotations/_machined_leaders.py @@ -279,7 +279,9 @@ def clear_foreign_label(box): allow_policy_b_fixed=True, on_drop=( on_drop - if requested_lane is not None or source_ids or self.source_drop_severity == "source" + if requested_lane is not None + or source_ids + or self.source_drop_severity == "source" else None ), recover=None if straight_only else recover, diff --git a/tests/test_issue_1308_machined_leader_analytics.py b/tests/test_issue_1308_machined_leader_analytics.py index 87d3d1fc..402dd939 100644 --- a/tests/test_issue_1308_machined_leader_analytics.py +++ b/tests/test_issue_1308_machined_leader_analytics.py @@ -252,7 +252,7 @@ def test_requested_leader_lane_refusal_names_exact_rank(monkeypatch): (job,) = ctx.feature_leaders assert job.on_drop is not None job.on_drop("no_clear_room") - (args, kwargs), = issues + ((args, kwargs),) = issues assert args[0:2] == ("error", "placement_unsatisfiable") assert "requested lane 4 unavailable" in args[2] assert kwargs["evidence_reason"] == "requested_lane_unavailable:4:no_clear_room" diff --git a/tests/test_layout_override_lane_issue_1757.py b/tests/test_layout_override_lane_issue_1757.py index 788ad037..9fc782c8 100644 --- a/tests/test_layout_override_lane_issue_1757.py +++ b/tests/test_layout_override_lane_issue_1757.py @@ -133,9 +133,10 @@ def test_step_diameter_lane_moves_one_bounded_leader(axis, rotation) -> None: step = sheet.step(diameter=30, length=40, at=(0, 0, 0), axis=axis) step.identify("declaration:step") sheet.dimension(step, "step.diameter") - assert "lane" in sheet.layout_options( - "declaration:step", parameter="step.diameter" - )["controls"] + assert ( + "lane" + in sheet.layout_options("declaration:step", parameter="step.diameter")["controls"] + ) sheet.layout_override("declaration:step", parameter="step.diameter", lane=lane) drawing = sheet.build() mark = drawing.get_annotation(f"m_dia_{axis}0") From aeffcc859fabd62b173a3e8d5381cfcf288bd7c9 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:12:21 +0000 Subject: [PATCH 3/5] Keep step lane routing within source-shape budgets --- src/draftwright/annotations/_diameters.py | 241 +++++++++++------- .../annotations/_machined_leaders.py | 76 +++--- tests/_complexity_baseline.json | 2 +- tests/_function_length_baseline.json | 2 +- 4 files changed, 190 insertions(+), 131 deletions(-) diff --git a/src/draftwright/annotations/_diameters.py b/src/draftwright/annotations/_diameters.py index 853af146..511260c3 100644 --- a/src/draftwright/annotations/_diameters.py +++ b/src/draftwright/annotations/_diameters.py @@ -692,6 +692,143 @@ def _matching_bore_values(bore_specs, origin): } +def _render_x_diameter_buckets( + dwg, + a, + buckets, + start, + *, + ctx, + trace, + include_source_pmi, + radial_candidates, + place_jobs, + leader_reach, + place_what_fits, +) -> int: + """Keep the ordinary X row and explicit-lane X leaders as separate owners.""" + indexed = list(enumerate(buckets.values())) + + def typed(entry): + return include_source_pmi and any( + isinstance(group.facts.get("thread"), ThreadRequirement) + or isinstance(group.facts.get("knurl"), KnurlRequirement) + for group in entry[6] + ) + + lane_entries = [(index, entry) for index, entry in indexed if _diameter_bucket_lane(entry)] + typed_entries = [ + (index, entry) + for index, entry in indexed + if not _diameter_bucket_lane(entry) and typed(entry) + ] + plain_entries = [ + (index, entry) + for index, entry in indexed + if not _diameter_bucket_lane(entry) and not typed(entry) + ] + placed = 0 + # A requested lane splits the otherwise unchanged contiguous legacy row. + for _, run in groupby(enumerate(plain_entries), key=lambda item: item[1][0] - item[0]): + entries = [entry for _ordinal, entry in run] + placed += _diameter_row_below( + dwg, + [_diameter_bucket_item(entry) for _index, entry in entries], + start=start + entries[0][0], + trace=trace, + ctx=ctx, + place_what_fits=place_what_fits, + ) + placed += _render_diameter_leaders( + dwg, + a, + typed_entries, + prefix="m_dia_x", + start=start, + ctx=ctx, + include_source_pmi=include_source_pmi, + radial_candidates=radial_candidates, + place_jobs=place_jobs, + leader_reach=leader_reach, + ) + unplaced = [ + entry + for _index, entry in plain_entries + if any( + not dwg.registry.has_measurement(group.dim(kind="diameter").id) for group in entry[6] + ) + ] + placed += _render_diameter_leaders( + dwg, + a, + list(enumerate(unplaced)), + prefix="m_dia_x", + start=start + len(buckets), + ctx=ctx, + include_source_pmi=include_source_pmi, + radial_candidates=radial_candidates, + place_jobs=place_jobs, + leader_reach=leader_reach, + ) + placed += _render_diameter_lanes( + dwg, + a, + lane_entries, + axis="x", + prefix="m_dia_x", + start=start, + ctx=ctx, + radial_candidates=radial_candidates, + place_jobs=place_jobs, + leader_reach=leader_reach, + ) + return placed + + +def _render_z_diameter_buckets( + dwg, + a, + buckets, + start, + *, + ctx, + trace, + radial_candidates, + place_jobs, + leader_reach, + place_what_fits, +) -> int: + """Keep Z column names stable when one bucket selects an explicit lane.""" + indexed = list(enumerate(buckets.values())) + placed = 0 + for _, run in groupby( + enumerate((index, entry) for index, entry in indexed if not _diameter_bucket_lane(entry)), + key=lambda item: item[1][0] - item[0], + ): + entries = [entry for _ordinal, entry in run] + placed += _diameter_column_left( + dwg, + _counted_column_items({index: entry for index, entry in entries}, dwg.draft), + start=start + entries[0][0], + trace=trace, + ctx=ctx, + place_what_fits=place_what_fits, + ) + placed += _render_diameter_lanes( + dwg, + a, + [(index, entry) for index, entry in indexed if _diameter_bucket_lane(entry)], + axis="z", + prefix="m_dia_z", + start=start, + ctx=ctx, + radial_candidates=radial_candidates, + place_jobs=place_jobs, + leader_reach=leader_reach, + ) + return placed + + def render_diameters( dwg, plan, @@ -771,114 +908,30 @@ def _next_start(prefix): start_y = _next_start("m_dia_y") 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 - indexed_row = list(enumerate(row_buckets.values())) - - def _typed(entry): - return include_source_pmi and any( - isinstance(group.facts.get("thread"), ThreadRequirement) - or isinstance(group.facts.get("knurl"), KnurlRequirement) - for group in entry[6] - ) - - lane_row = [(index, entry) for index, entry in indexed_row if _diameter_bucket_lane(entry)] - typed_entries = [ - (index, entry) - for index, entry in indexed_row - if not _diameter_bucket_lane(entry) and _typed(entry) - ] - plain_entries = [ - (index, entry) - for index, entry in indexed_row - if not _diameter_bucket_lane(entry) and not _typed(entry) - ] - placed = 0 - # Preserve the legacy tidy row for short plain diameters. Split only where a typed - # bucket owns the intervening stable name; each contiguous run can then use the legacy - # solver without renumbering a source-owned callout. - for _, run in groupby( - enumerate(plain_entries), - key=lambda item: item[1][0] - item[0], - ): - entries = [entry for _ordinal, entry in run] - placed += _diameter_row_below( - dwg, - [_diameter_bucket_item(entry) for _index, entry in entries], - start=start_x + entries[0][0], - trace=trace, - ctx=ctx, - place_what_fits=place_what_fits, - ) - placed += _render_diameter_leaders( + placed = _render_x_diameter_buckets( dwg, a, - typed_entries, - prefix="m_dia_x", - start=start_x, - ctx=ctx, - include_source_pmi=include_source_pmi, - radial_candidates=radial_candidates, - place_jobs=place_jobs, - leader_reach=leader_reach, - ) - unplaced = [ - entry - for _index, entry in plain_entries - if any( - not dwg.registry.has_measurement(group.dim(kind="diameter").id) for group in entry[6] - ) - ] - placed += _render_diameter_leaders( - dwg, - a, - list(enumerate(unplaced)), - prefix="m_dia_x", - start=start_x + len(row_buckets), + row_buckets, + start_x, ctx=ctx, + trace=trace, include_source_pmi=include_source_pmi, radial_candidates=radial_candidates, place_jobs=place_jobs, leader_reach=leader_reach, + place_what_fits=place_what_fits, ) - placed += _render_diameter_lanes( - dwg, - a, - lane_row, - axis="x", - prefix="m_dia_x", - start=start_x, - ctx=ctx, - radial_candidates=radial_candidates, - place_jobs=place_jobs, - leader_reach=leader_reach, - ) - indexed_col = list(enumerate(col_buckets.values())) - for _, run in groupby( - enumerate( - (index, entry) for index, entry in indexed_col if not _diameter_bucket_lane(entry) - ), - key=lambda item: item[1][0] - item[0], - ): - entries = [entry for _ordinal, entry in run] - run_buckets = {index: entry for index, entry in entries} - placed += _diameter_column_left( - dwg, - _counted_column_items(run_buckets, dwg.draft), - start=start_z + entries[0][0], - trace=trace, - ctx=ctx, - place_what_fits=place_what_fits, - ) - placed += _render_diameter_lanes( + placed += _render_z_diameter_buckets( dwg, a, - [(index, entry) for index, entry in indexed_col if _diameter_bucket_lane(entry)], - axis="z", - prefix="m_dia_z", - start=start_z, + col_buckets, + start_z, ctx=ctx, + trace=trace, radial_candidates=radial_candidates, place_jobs=place_jobs, leader_reach=leader_reach, + place_what_fits=place_what_fits, ) # A Y-axis step is end-on in the front view, so the X/Z profile-strip diff --git a/src/draftwright/annotations/_machined_leaders.py b/src/draftwright/annotations/_machined_leaders.py index 282b8f38..9a9a4c2e 100644 --- a/src/draftwright/annotations/_machined_leaders.py +++ b/src/draftwright/annotations/_machined_leaders.py @@ -66,6 +66,44 @@ class _MachinedJobContext: cross_view_clearance: bool foreign_boxes_by_view: dict + def needs_drop_callback(self, source_ids, requested_lane) -> bool: + return ( + requested_lane is not None or bool(source_ids) or self.source_drop_severity == "source" + ) + + def attach_diameter_coverage(self, name, leader) -> None: + if name in self.covers_diameters_by_name: + leader.covers_diameters = (self.covers_diameters_by_name[name],) + + def record_drop(self, label, measurement, source_ids, requested_lane, reason) -> None: + """Report an explicit lane refusal or the ordinary source-aware drop.""" + validation = reason == "geometry_validation" + detail = "rendered geometry validation failed" if validation else "no clear room" + if requested_lane is not None: + self.ctx.record_issue( + "error", + "placement_unsatisfiable", + f"{self.noun} callout {label} not placed " + f"(requested lane {requested_lane} unavailable: {detail})", + measurement=measurement, + evidence_reason=f"requested_lane_unavailable:{requested_lane}:{reason}", + outcome_stage="validation" if validation else "placement", + ) + return + severity = ( + ("error" if source_ids else "warning") + if self.source_drop_severity == "source" + else self.source_drop_severity + ) + self.ctx.record_issue( + severity, + self.drop_code, + f"{self.noun} callout {label} not placed ({detail})", + measurement=measurement, + source=source_ids, + outcome_stage="validation" if validation else "placement", + ) + def foreign_label_clear( self, view: str, label: tuple[float, float, float, float] | None ) -> bool: @@ -142,8 +180,7 @@ def decorate(leader): } if grouping_features: leader.covers_count = len(grouping_features) - if name in self.covers_diameters_by_name: - leader.covers_diameters = (self.covers_diameters_by_name[name],) + self.attach_diameter_coverage(name, leader) return leader def build(tip, elbow, _feature): @@ -190,32 +227,7 @@ def compact_candidates(anchors, policy): requested_lane = self.requested_lanes.get(name) def on_drop(reason): - validation = reason == "geometry_validation" - detail = "rendered geometry validation failed" if validation else "no clear room" - if requested_lane is not None: - self.ctx.record_issue( - "error", - "placement_unsatisfiable", - f"{self.noun} callout {label} not placed " - f"(requested lane {requested_lane} unavailable: {detail})", - measurement=measurement, - evidence_reason=f"requested_lane_unavailable:{requested_lane}:{reason}", - outcome_stage="validation" if validation else "placement", - ) - return - severity = ( - ("error" if source_ids else "warning") - if self.source_drop_severity == "source" - else self.source_drop_severity - ) - self.ctx.record_issue( - severity, - self.drop_code, - f"{self.noun} callout {label} not placed ({detail})", - measurement=measurement, - source=source_ids, - outcome_stage="validation" if validation else "placement", - ) + self.record_drop(label, measurement, source_ids, requested_lane, reason) if self.late_inventory: candidates = ( @@ -277,13 +289,7 @@ def clear_foreign_label(box): interior_label_clear=interior_label_clear, foreign_label_clear=clear_foreign_label if self.cross_view_clearance else None, allow_policy_b_fixed=True, - on_drop=( - on_drop - if requested_lane is not None - or source_ids - or self.source_drop_severity == "source" - else None - ), + on_drop=on_drop if self.needs_drop_callback(source_ids, requested_lane) else None, recover=None if straight_only else recover, ) diff --git a/tests/_complexity_baseline.json b/tests/_complexity_baseline.json index bfd3b98d..dea12957 100644 --- a/tests/_complexity_baseline.json +++ b/tests/_complexity_baseline.json @@ -14,7 +14,7 @@ "annotations/_common.py:solve_corridor": 29, "annotations/_diameters.py:_diameter_row_below": 22, "annotations/_diameters.py:_reroute_crossing_diameters": 18, - "annotations/_diameters.py:render_diameters": 21, + "annotations/_diameters.py:render_diameters": 20, "annotations/_dimension_ink_repair.py:_InkConflictState.conflicts": 19, "annotations/_edge_callouts.py:_surface_normal_candidates": 17, "annotations/_leader_fixed_ink.py:_annotation_fixed_ink": 27, diff --git a/tests/_function_length_baseline.json b/tests/_function_length_baseline.json index a1afec74..3a769823 100644 --- a/tests/_function_length_baseline.json +++ b/tests/_function_length_baseline.json @@ -3,7 +3,7 @@ "functions": { "analysis.py:_prepare_source": 216, "annotations/_common.py:solve_corridor": 265, - "annotations/_diameters.py:render_diameters": 229, + "annotations/_diameters.py:render_diameters": 204, "annotations/_locations.py:render_locations": 258, "annotations/_pmi_dimensions.py:_place_pmi_record": 258, "annotations/_pmi_dimensions.py:_sheet_leader_fallback": 240, From 370f4f6d7c908392641d120232d45ec8722dec43 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:17:41 +0000 Subject: [PATCH 4/5] Retain source PMI identities on controlled step diameter leaders --- src/draftwright/annotations/_diameters.py | 15 +++++++ tests/test_layout_override_lane_issue_1757.py | 41 +++++++++++++++++++ 2 files changed, 56 insertions(+) diff --git a/src/draftwright/annotations/_diameters.py b/src/draftwright/annotations/_diameters.py index 511260c3..c53085d3 100644 --- a/src/draftwright/annotations/_diameters.py +++ b/src/draftwright/annotations/_diameters.py @@ -572,6 +572,8 @@ def _render_diameter_lanes( names = set() requested_lanes = {} covers_diameters_by_name = {} + source_ids_by_name = {} + include_source_pmi = not ctx.document_member or a.pmi_mode == "annotate" for index, entry in indexed_buckets: _anchor, dia, value_text, refs, tolerance, rider, groups = entry lane = _diameter_bucket_lane(entry) @@ -582,6 +584,18 @@ def _render_diameter_lanes( name = f"{prefix}{start + index}" names.add(name) requested_lanes[name] = lane + source_ids_by_name[name] = ( + tuple( + dict.fromkeys( + source_id + for group in groups + for aspect in (group.facts.get("thread"), group.facts.get("knurl")) + for source_id in getattr(aspect, "source_ids", ()) + ) + ) + if include_source_pmi + else () + ) if axis == "y": covers_diameters_by_name[name] = dia reach = leader_reach(dwg.draft) + (lane - 1) * spacing @@ -634,6 +648,7 @@ def _render_diameter_lanes( straight_only_names=frozenset(names), requested_lanes=requested_lanes, covers_diameters_by_name=covers_diameters_by_name, + source_ids_by_name=source_ids_by_name, ), ) diff --git a/tests/test_layout_override_lane_issue_1757.py b/tests/test_layout_override_lane_issue_1757.py index 9fc782c8..0c01301d 100644 --- a/tests/test_layout_override_lane_issue_1757.py +++ b/tests/test_layout_override_lane_issue_1757.py @@ -8,11 +8,13 @@ import pytest from build123d import Box, Cylinder, Pos, Rot +from build123d_drafting.helpers import Draft from jsonschema.validators import validator_for from draftwright import Sheet from draftwright.annotations._axial_render import _place_or_queue_rotational_od from draftwright.annotations._common import PlacementContext +from draftwright.annotations._diameters import _render_diameter_lanes from draftwright.annotations.from_model import _record_slot_drop from draftwright.model.ir import LayoutOverride, RequestedDimension from draftwright.registry import AnnotationRegistry @@ -166,6 +168,45 @@ def test_step_lane_does_not_rename_or_duplicate_untouched_diameter() -> None: assert not any(issue.code == "diameter_dropped" for issue in drawing.lint()) +@pytest.mark.parametrize( + ("pmi_mode", "expected"), + [("annotate", ("manufacturing_requirement:#1",)), ("omit", ())], +) +def test_step_lane_preserves_visible_source_thread_identity(pmi_mode, expected) -> None: + aspect = SimpleNamespace(source_ids=("manufacturing_requirement:#1",)) + facts = SimpleNamespace( + frame=SimpleNamespace(axis="y"), get=lambda key: aspect if key == "thread" else None + ) + group = SimpleNamespace( + facts=facts, + dims=(SimpleNamespace(kind="diameter", lane=2, id="dimension:step"),), + ) + entry = ((0, 0, 0), 30, "30", {"step"}, None, None, [group]) + drawing = SimpleNamespace(draft=Draft(), view_bounds=lambda _view: (0, 0, 100, 100)) + analysis = SimpleNamespace(SCALE=2, pmi_mode=pmi_mode) + captured = {} + + def place_jobs(*_args, **kwargs): + captured.update(kwargs) + return 0 + + _render_diameter_lanes( + drawing, + analysis, + [(0, entry)], + axis="y", + prefix="m_dia_y", + start=0, + ctx=SimpleNamespace(document_member=True), + radial_candidates=lambda *_args, **_kwargs: [((0, 0), (1, 1, 0), None)], + place_jobs=place_jobs, + leader_reach=lambda _draft: 8, + ) + + assert captured["source_ids_by_name"] == {"m_dia_y0": expected} + assert captured["requested_lanes"] == {"m_dia_y0": 2} + + def test_lane_override_changes_only_the_exact_dimension_policy() -> None: sheet = _slot_sheet() sheet.layout_override("declaration:slot", parameter="slot_width.length", lane=4) From 300a81ab072b4249f181f3ccf26a1d86da3e1045 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:33:41 +0000 Subject: [PATCH 5/5] Keep leader adapter guard current for diameter lanes --- tests/test_issue_740_leader_assignment.py | 1 + 1 file changed, 1 insertion(+) diff --git a/tests/test_issue_740_leader_assignment.py b/tests/test_issue_740_leader_assignment.py index 9ebbfeff..fa3b5afb 100644 --- a/tests/test_issue_740_leader_assignment.py +++ b/tests/test_issue_740_leader_assignment.py @@ -48,6 +48,7 @@ def call_sites(filename, callee="place_machined_leader_jobs"): ) == { ("_diameters.py", "render_diameters", False), ("_diameters.py", "_render_diameter_leaders", True), + ("_diameters.py", "_render_diameter_lanes", True), ("from_model.py", "render_chamfers", True), ("from_model.py", "_render_radius_callouts", True), ("from_model.py", "_render_circular_recesses", True),