From 9893ae3a77ab3d14560b4234ec57dd44ae095b72 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:12:31 +0000 Subject: [PATCH 1/4] Expose requested side for step diameter leaders --- docs/reference/sheet.md | 4 + src/draftwright/annotations/_diameters.py | 92 +++++++++++++++---- .../annotations/_machined_leaders.py | 45 +++++++-- src/draftwright/annotations/from_model.py | 2 + src/draftwright/model/planner.py | 15 +++ src/draftwright/sheet_layout_controls.py | 2 +- ...st_issue_1308_machined_leader_analytics.py | 27 ++++++ tests/test_layout_override_lane_issue_1757.py | 45 ++++++++- 8 files changed, 200 insertions(+), 32 deletions(-) diff --git a/docs/reference/sheet.md b/docs/reference/sheet.md index 9c85290e..b11f389b 100644 --- a/docs/reference/sheet.md +++ b/docs/reference/sheet.md @@ -363,6 +363,10 @@ 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. +For a declared step diameter, `side=` can instead select a bounded leader hemisphere: +`above`/`below` for an X-axis step, `left`/`right` for a Z-axis step, and all four +for a Y-axis end-on step. The solve may report the requested side unplaceable; it +does not silently switch sides. Dimension-side overrides currently cover native hole/pattern callouts and envelope height; unsupported renderers are not advertised as movable. The side surface accepts `above`, diff --git a/src/draftwright/annotations/_diameters.py b/src/draftwright/annotations/_diameters.py index c53085d3..e8fcfe3d 100644 --- a/src/draftwright/annotations/_diameters.py +++ b/src/draftwright/annotations/_diameters.py @@ -550,7 +550,24 @@ def _diameter_bucket_lane(entry) -> int | None: return next(iter(lanes)) if len(lanes) == 1 else None -def _render_diameter_lanes( +def _diameter_bucket_side(entry) -> str | None: + """Keep the one planner-approved side of a physical diameter bucket.""" + sides = { + dim.side + for group in entry[6] + for dim in group.dims + if dim.kind == "diameter" and dim.side is not None + } + if len(sides) > 1: + raise ValueError("one physical diameter cannot have conflicting requested sides") + return next(iter(sides)) if len(sides) == 1 else None + + +def _diameter_has_placement_control(entry) -> bool: + return _diameter_bucket_lane(entry) is not None or _diameter_bucket_side(entry) is not None + + +def _render_diameter_controls( dwg, a, indexed_buckets, @@ -563,7 +580,7 @@ def _render_diameter_lanes( place_jobs, leader_reach, ) -> int: - """Offer only the requested witness-relative rank to the shared leader solve.""" + """Offer only requested side/rank candidates to the shared leader solve.""" vb = dwg.view_bounds("front") if vb is None: return 0 @@ -571,19 +588,24 @@ def _render_diameter_lanes( jobs = [] names = set() requested_lanes = {} + requested_sides = {} 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) - if lane is None: + side = _diameter_bucket_side(entry) + if lane is None and side 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 lane is not None: + requested_lanes[name] = lane + if side is not None: + requested_sides[name] = side source_ids_by_name[name] = ( tuple( dict.fromkeys( @@ -598,8 +620,23 @@ def _render_diameter_lanes( ) if axis == "y": covers_diameters_by_name[name] = dia - reach = leader_reach(dwg.draft) + (lane - 1) * spacing + reach = ( + leader_reach(dwg.draft) + (lane - 1) * spacing + if lane is not None + else dwg.draft.font_size + 2 * dwg.draft.pad_around_text + ) if axis == "y": + directions = _END_DIAMETER_LEAD_DIRS + if side is not None: + coordinate, sign = { + "left": (0, -1), + "right": (0, 1), + "below": (1, -1), + "above": (1, 1), + }[side] + directions = tuple( + direction for direction in directions if direction[coordinate] * sign > 1e-9 + ) candidates = radial_candidates( dwg, "front", @@ -607,10 +644,20 @@ def _render_diameter_lanes( representative, reach, rim=dia / 2 * a.SCALE, - directions=_END_DIAMETER_LEAD_DIRS, + directions=directions, provenance=owner, ) else: + directions = _DIAMETER_LEAD_DIRS[axis] + if side is not None: + directions = ( + { + "above": (0, 1), + "below": (0, -1), + "left": (-1, 0), + "right": (1, 0), + }[side], + ) candidates = radial_candidates( dwg, "front", @@ -618,7 +665,7 @@ def _render_diameter_lanes( representative, reach, source_bounds=_diameter_source_bounds(dwg, "front", representative, dia), - directions=_DIAMETER_LEAD_DIRS[axis], + directions=directions, provenance=owner, ) label = f"ø{value_text}{_tol_suffix(tolerance, dwg.draft)}" @@ -639,7 +686,7 @@ def _render_diameter_lanes( dwg, a, jobs, - noun="diameter at requested lane", + noun="diameter at requested side/lane", drop_code="diameter_dropped", ctx=ctx, geom_clear=True, @@ -647,6 +694,7 @@ def _render_diameter_lanes( expand_lanes=False, straight_only_names=frozenset(names), requested_lanes=requested_lanes, + requested_sides=requested_sides, covers_diameters_by_name=covers_diameters_by_name, source_ids_by_name=source_ids_by_name, ), @@ -731,16 +779,18 @@ def typed(entry): for group in entry[6] ) - lane_entries = [(index, entry) for index, entry in indexed if _diameter_bucket_lane(entry)] + controlled_entries = [ + (index, entry) for index, entry in indexed if _diameter_has_placement_control(entry) + ] typed_entries = [ (index, entry) for index, entry in indexed - if not _diameter_bucket_lane(entry) and typed(entry) + if not _diameter_has_placement_control(entry) and typed(entry) ] plain_entries = [ (index, entry) for index, entry in indexed - if not _diameter_bucket_lane(entry) and not typed(entry) + if not _diameter_has_placement_control(entry) and not typed(entry) ] placed = 0 # A requested lane splits the otherwise unchanged contiguous legacy row. @@ -785,10 +835,10 @@ def typed(entry): place_jobs=place_jobs, leader_reach=leader_reach, ) - placed += _render_diameter_lanes( + placed += _render_diameter_controls( dwg, a, - lane_entries, + controlled_entries, axis="x", prefix="m_dia_x", start=start, @@ -817,7 +867,11 @@ def _render_z_diameter_buckets( 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)), + enumerate( + (index, entry) + for index, entry in indexed + if not _diameter_has_placement_control(entry) + ), key=lambda item: item[1][0] - item[0], ): entries = [entry for _ordinal, entry in run] @@ -829,10 +883,10 @@ def _render_z_diameter_buckets( ctx=ctx, place_what_fits=place_what_fits, ) - placed += _render_diameter_lanes( + placed += _render_diameter_controls( dwg, a, - [(index, entry) for index, entry in indexed if _diameter_bucket_lane(entry)], + [(index, entry) for index, entry in indexed if _diameter_has_placement_control(entry)], axis="z", prefix="m_dia_z", start=start, @@ -972,7 +1026,7 @@ def _next_start(prefix): jobs = [] covered_by_name = {} for i, entry in enumerate(end_buckets.values()): - if _diameter_bucket_lane(entry): + if _diameter_has_placement_control(entry): continue _anchor, dia, value_text, refs, dtol, thr, feature_groups = entry representative = feature_groups[0].facts @@ -1024,13 +1078,13 @@ def _next_start(prefix): ann = ctx.registry.named(name) if ann is not None: ann.covers_diameters = (dia,) - placed += _render_diameter_lanes( + placed += _render_diameter_controls( dwg, a, [ (index, entry) for index, entry in enumerate(end_buckets.values()) - if _diameter_bucket_lane(entry) + if _diameter_has_placement_control(entry) ], axis="y", prefix="m_dia_y", diff --git a/src/draftwright/annotations/_machined_leaders.py b/src/draftwright/annotations/_machined_leaders.py index 9a9a4c2e..5f975ed8 100644 --- a/src/draftwright/annotations/_machined_leaders.py +++ b/src/draftwright/annotations/_machined_leaders.py @@ -59,6 +59,7 @@ class _MachinedJobContext: source_ids_by_name: dict source_drop_severity: str requested_lanes: dict[str, int] + requested_sides: dict[str, str] covers_diameters_by_name: dict[str, float] straight_only_names: frozenset late_inventory: bool @@ -66,27 +67,41 @@ class _MachinedJobContext: cross_view_clearance: bool foreign_boxes_by_view: dict - def needs_drop_callback(self, source_ids, requested_lane) -> bool: + def needs_drop_callback(self, source_ids, requested_lane, requested_side) -> bool: return ( - requested_lane is not None or bool(source_ids) or self.source_drop_severity == "source" + requested_lane is not None + or requested_side 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.""" + def record_drop( + self, label, measurement, source_ids, requested_lane, requested_side, reason + ) -> None: + """Report an explicit side/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: + if requested_lane is not None or requested_side is not None: + target = ( + f"requested lane {requested_lane}" + if requested_lane is not None + else f"requested side {requested_side}" + ) + evidence = ( + f"requested_lane_unavailable:{requested_lane}:{reason}" + if requested_lane is not None + else f"requested_side_unavailable:{requested_side}:{reason}" + ) self.ctx.record_issue( "error", "placement_unsatisfiable", - f"{self.noun} callout {label} not placed " - f"(requested lane {requested_lane} unavailable: {detail})", + f"{self.noun} callout {label} not placed ({target} unavailable: {detail})", measurement=measurement, - evidence_reason=f"requested_lane_unavailable:{requested_lane}:{reason}", + evidence_reason=evidence, outcome_stage="validation" if validation else "placement", ) return @@ -225,9 +240,12 @@ def compact_candidates(anchors, policy): source_ids = tuple(self.source_ids_by_name.get(name, ())) requested_lane = self.requested_lanes.get(name) + requested_side = self.requested_sides.get(name) def on_drop(reason): - self.record_drop(label, measurement, source_ids, requested_lane, reason) + self.record_drop( + label, measurement, source_ids, requested_lane, requested_side, reason + ) if self.late_inventory: candidates = ( @@ -289,7 +307,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 self.needs_drop_callback(source_ids, requested_lane) else None, + on_drop=( + on_drop + if self.needs_drop_callback(source_ids, requested_lane, requested_side) + else None + ), recover=None if straight_only else recover, ) @@ -421,6 +443,7 @@ def place_machined_leader_jobs( source_ids_by_name=None, source_drop_severity="warning", requested_lanes=None, + requested_sides=None, covers_diameters_by_name=None, priority=0.0, straight_only_names=frozenset(), @@ -430,6 +453,7 @@ def place_machined_leader_jobs( """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 {} + requested_sides = requested_sides 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 @@ -447,6 +471,7 @@ def place_machined_leader_jobs( source_ids_by_name=source_ids_by_name, source_drop_severity=source_drop_severity, requested_lanes=requested_lanes, + requested_sides=requested_sides, covers_diameters_by_name=covers_diameters_by_name, straight_only_names=straight_only_names, late_inventory=late_inventory, diff --git a/src/draftwright/annotations/from_model.py b/src/draftwright/annotations/from_model.py index caef0cbf..07954dda 100644 --- a/src/draftwright/annotations/from_model.py +++ b/src/draftwright/annotations/from_model.py @@ -673,6 +673,7 @@ def place_machined_leader_jobs( source_ids_by_name=None, source_drop_severity="warning", requested_lanes=None, + requested_sides=None, covers_diameters_by_name=None, priority=0.0, straight_only_names=frozenset(), @@ -693,6 +694,7 @@ def place_machined_leader_jobs( source_ids_by_name=source_ids_by_name, source_drop_severity=source_drop_severity, requested_lanes=requested_lanes, + requested_sides=requested_sides, covers_diameters_by_name=covers_diameters_by_name, priority=priority, straight_only_names=straight_only_names, diff --git a/src/draftwright/model/planner.py b/src/draftwright/model/planner.py index 24f97430..33b6b6e4 100644 --- a/src/draftwright/model/planner.py +++ b/src/draftwright/model/planner.py @@ -1898,6 +1898,21 @@ def _group_placement(feature: Feature, dims: list[PlannedDimension], planned_vie f"{sorted(set().union(*(_parameter_view_preferences(feature, pd) for pd in approved)))}" ) if requested_side is not None: + if feature.kind == "step": + step_sides = { + "x": {"above", "below"}, + "y": {"above", "below", "left", "right"}, + "z": {"left", "right"}, + }.get(feature.frame.axis, set()) + if ( + all(pd.side is None or pd.param.parameter_id == "step.diameter" for pd in approved) + and requested_side in step_sides + ): + return selected_view, requested_side + raise ValueError( + "step diameter side is available only for its front-view OD leader; " + f"supported sides: {sorted(step_sides) or 'none'}" + ) supported = { "plan": {"left", "right"}, "side": {"left", "right"}, diff --git a/src/draftwright/sheet_layout_controls.py b/src/draftwright/sheet_layout_controls.py index 22d18e26..61cab999 100644 --- a/src/draftwright/sheet_layout_controls.py +++ b/src/draftwright/sheet_layout_controls.py @@ -114,7 +114,7 @@ def layout_options( } # Only advertise sides whose renderer consumes the authored corridor. Other # planner-accepted sides are not an editor actuator until that renderer uses them. - if feature.kind in {"hole", "pattern", "envelope"}: + if feature.kind in {"hole", "pattern", "envelope", "step"}: placements = sheet.dimension_options(handle, parameter)["placements"] sides = sorted( { diff --git a/tests/test_issue_1308_machined_leader_analytics.py b/tests/test_issue_1308_machined_leader_analytics.py index 402dd939..60c626eb 100644 --- a/tests/test_issue_1308_machined_leader_analytics.py +++ b/tests/test_issue_1308_machined_leader_analytics.py @@ -258,6 +258,33 @@ def test_requested_leader_lane_refusal_names_exact_rank(monkeypatch): assert kwargs["evidence_reason"] == "requested_lane_unavailable:4:no_clear_room" +def test_requested_leader_side_refusal_names_exact_side(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_sides={"step": "right"}, + ) + + (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 side right unavailable" in args[2] + assert kwargs["evidence_reason"] == "requested_side_unavailable:right: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 0c01301d..56096a84 100644 --- a/tests/test_layout_override_lane_issue_1757.py +++ b/tests/test_layout_override_lane_issue_1757.py @@ -14,7 +14,7 @@ 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._diameters import _render_diameter_controls from draftwright.annotations.from_model import _record_slot_drop from draftwright.model.ir import LayoutOverride, RequestedDimension from draftwright.registry import AnnotationRegistry @@ -190,7 +190,7 @@ def place_jobs(*_args, **kwargs): captured.update(kwargs) return 0 - _render_diameter_lanes( + _render_diameter_controls( drawing, analysis, [(0, entry)], @@ -207,6 +207,47 @@ def place_jobs(*_args, **kwargs): assert captured["requested_lanes"] == {"m_dia_y0": 2} +@pytest.mark.parametrize( + ("axis", "rotation", "sides", "coordinate"), + [ + ("x", (0, 90, 0), ("above", "below"), 1), + ("y", (90, 0, 0), ("left", "right"), 0), + ("z", (0, 0, 0), ("left", "right"), 0), + ], +) +def test_step_diameter_side_override_keeps_leader_on_requested_side( + axis, rotation, sides, coordinate +) -> None: + observed = [] + for side in sides: + 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") + side_options = sheet.layout_options("declaration:step", parameter="step.diameter")[ + "controls" + ]["side"] + assert side in side_options["supported_values"] + sheet.layout_override("declaration:step", parameter="step.diameter", side=side) + drawing = sheet.build() + mark = drawing.get_annotation(f"m_dia_{axis}0") + assert mark is not None + assert not any(issue.code == "placement_unsatisfiable" for issue in drawing.lint()) + observed.append(mark.elbow[coordinate] - mark.tip[coordinate]) + assert observed[0] * observed[1] < 0 + + +def test_step_length_does_not_advertise_diameter_callout_side() -> None: + sheet = Sheet(Rot(0, 90, 0) * Cylinder(15, 40)).authored_dimensions() + step = sheet.step(diameter=30, length=40, at=(0, 0, 0), axis="x") + step.identify("declaration:step") + sheet.dimension(step, "step.length") + result = sheet.validate_layout_override( + "declaration:step", parameter="step.length", side="above" + ) + assert result["supported"] is False + + 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 d3037e898c219040a401428593476e28849b7ac3 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:15:57 +0000 Subject: [PATCH 2/4] Keep step-side planner validation within complexity budget --- src/draftwright/model/planner.py | 66 +++++++++++----------- tests/_complexity_baseline.json | 1 - tests/test_issue_1466_dimension_options.py | 13 +++++ 3 files changed, 46 insertions(+), 34 deletions(-) diff --git a/src/draftwright/model/planner.py b/src/draftwright/model/planner.py index 33b6b6e4..f350cc28 100644 --- a/src/draftwright/model/planner.py +++ b/src/draftwright/model/planner.py @@ -1817,6 +1817,38 @@ def _check_intent_policy_conflicts(model: PartModel) -> None: seen[key] = policy +def _validate_compound_callout_side(feature, approved, selected_view, requested_side) -> None: + """Check a compound callout's requested corridor against its renderer.""" + if feature.kind == "step": + step_sides = { + "x": {"above", "below"}, + "y": {"above", "below", "left", "right"}, + "z": {"left", "right"}, + }.get(feature.frame.axis, set()) + if ( + all(pd.side is None or pd.param.parameter_id == "step.diameter" for pd in approved) + and requested_side in step_sides + ): + return + raise ValueError( + "step diameter side is available only for its front-view OD leader; " + f"supported sides: {sorted(step_sides) or 'none'}" + ) + supported = { + "plan": {"left", "right"}, + "side": {"left", "right"}, + "front": {"below"}, + "rear": {"below"}, + }.get(selected_view or "", set()) + if not isinstance(feature, HoleFeature | PatternFeature) or requested_side not in supported: + choices = sorted(supported) if isinstance(feature, HoleFeature | PatternFeature) else [] + raise ValueError( + f"{feature.kind} dimensions cannot render at " + f"{selected_view!r}/{requested_side!r}; supported sides for this renderer: " + f"{choices or 'none'}" + ) + + def _group_placement(feature: Feature, dims: list[PlannedDimension], planned_views=None): """Resolve one view/side for a compound group, or reject an unrenderable intent.""" approved = [pd for pd in dims if not pd.suppressed] @@ -1898,39 +1930,7 @@ def _group_placement(feature: Feature, dims: list[PlannedDimension], planned_vie f"{sorted(set().union(*(_parameter_view_preferences(feature, pd) for pd in approved)))}" ) if requested_side is not None: - if feature.kind == "step": - step_sides = { - "x": {"above", "below"}, - "y": {"above", "below", "left", "right"}, - "z": {"left", "right"}, - }.get(feature.frame.axis, set()) - if ( - all(pd.side is None or pd.param.parameter_id == "step.diameter" for pd in approved) - and requested_side in step_sides - ): - return selected_view, requested_side - raise ValueError( - "step diameter side is available only for its front-view OD leader; " - f"supported sides: {sorted(step_sides) or 'none'}" - ) - supported = { - "plan": {"left", "right"}, - "side": {"left", "right"}, - "front": {"below"}, - "rear": {"below"}, - }.get(selected_view or "", set()) - if ( - not isinstance(feature, HoleFeature | PatternFeature) - or requested_side not in supported - ): - choices = ( - sorted(supported) if isinstance(feature, HoleFeature | PatternFeature) else [] - ) - raise ValueError( - f"{feature.kind} dimensions cannot render at " - f"{selected_view!r}/{requested_side!r}; supported sides for this renderer: " - f"{choices or 'none'}" - ) + _validate_compound_callout_side(feature, approved, selected_view, requested_side) return selected_view, requested_side diff --git a/tests/_complexity_baseline.json b/tests/_complexity_baseline.json index dea12957..b356bd73 100644 --- a/tests/_complexity_baseline.json +++ b/tests/_complexity_baseline.json @@ -100,7 +100,6 @@ "model/ir.py:PolygonalBossFeature.__post_init__": 26, "model/oriented_slot_geometry.py:validate_feature": 16, "model/oriented_slot_geometry.py:validate_passage": 18, - "model/planner.py:_group_placement": 16, "model/planner.py:_parameter_view_preferences": 17, "model/planner.py:_uncovered_location_requirements": 21, "model/planner.py:plan_locations": 17, diff --git a/tests/test_issue_1466_dimension_options.py b/tests/test_issue_1466_dimension_options.py index 1459d76e..9d517c64 100644 --- a/tests/test_issue_1466_dimension_options.py +++ b/tests/test_issue_1466_dimension_options.py @@ -219,9 +219,22 @@ def test_step_options_match_the_view_that_actually_renders(axis, rotation, param assert sheet.features[0].frame.axis == axis expected_view = "side" if axis == "y" and parameter_id == "step.length" else "front" options = sheet.dimension_options(handle, parameter_id) + sides = ( + sorted( + { + "x": {"above", "below"}, + "y": {"above", "below", "left", "right"}, + "z": {"left", "right"}, + }[axis] + ) + if parameter_id == "step.diameter" + else [] + ) assert options["placements"] == [ {"view": None, "side": None}, + *({"view": None, "side": side} for side in sides), {"view": expected_view, "side": None}, + *({"view": expected_view, "side": side} for side in sides), ] for view in PLACEMENT_VIEWS: assert sheet.validate_dimension(handle, parameter_id, view=view)["supported"] == ( From 4d6b9c7ea52cfe906674f1b1fdd1191df4c0a88e Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:19:03 +0000 Subject: [PATCH 3/4] Cover source PMI identity for side and lane step leaders --- tests/test_layout_override_lane_issue_1757.py | 27 +++++++++++++++---- 1 file changed, 22 insertions(+), 5 deletions(-) diff --git a/tests/test_layout_override_lane_issue_1757.py b/tests/test_layout_override_lane_issue_1757.py index 56096a84..56c691ae 100644 --- a/tests/test_layout_override_lane_issue_1757.py +++ b/tests/test_layout_override_lane_issue_1757.py @@ -169,17 +169,33 @@ def test_step_lane_does_not_rename_or_duplicate_untouched_diameter() -> None: @pytest.mark.parametrize( - ("pmi_mode", "expected"), - [("annotate", ("manufacturing_requirement:#1",)), ("omit", ())], + ("control", "pmi_mode", "expected"), + [ + (control, pmi_mode, expected) + for control in ("lane", "side") + for pmi_mode, expected in ( + ("annotate", ("manufacturing_requirement:#1",)), + ("omit", ()), + ) + ], ) -def test_step_lane_preserves_visible_source_thread_identity(pmi_mode, expected) -> None: +def test_step_control_preserves_visible_source_thread_identity( + control, 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"),), + dims=( + SimpleNamespace( + kind="diameter", + lane=2 if control == "lane" else None, + side="left" if control == "side" else None, + 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)) @@ -204,7 +220,8 @@ def place_jobs(*_args, **kwargs): ) assert captured["source_ids_by_name"] == {"m_dia_y0": expected} - assert captured["requested_lanes"] == {"m_dia_y0": 2} + assert captured["requested_lanes"] == ({"m_dia_y0": 2} if control == "lane" else {}) + assert captured["requested_sides"] == ({"m_dia_y0": "left"} if control == "side" else {}) @pytest.mark.parametrize( From 8c0de7bee79fa8f0bd86998a73724f31e082415d Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:35:18 +0000 Subject: [PATCH 4/4] Keep leader adapter guard current for diameter sides --- tests/test_issue_740_leader_assignment.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/test_issue_740_leader_assignment.py b/tests/test_issue_740_leader_assignment.py index fa3b5afb..8e85476a 100644 --- a/tests/test_issue_740_leader_assignment.py +++ b/tests/test_issue_740_leader_assignment.py @@ -48,7 +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), + ("_diameters.py", "_render_diameter_controls", True), ("from_model.py", "render_chamfers", True), ("from_model.py", "_render_radius_callouts", True), ("from_model.py", "_render_circular_recesses", True),