From 6bdf2cb588e38347eb5a6bc760cee6f6e45d6473 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 00:34:56 +0000 Subject: [PATCH 1/4] Expose exact location lanes for declared hole components --- .../draftwright-report-v8.schema.json | 2 + docs/reference/reports.md | 3 +- docs/reference/sheet.md | 15 ++- src/draftwright/annotations/_locations.py | 120 ++++++++++++++---- src/draftwright/model/compiled.py | 8 ++ src/draftwright/model/ir.py | 44 +++++-- src/draftwright/model/planner.py | 46 ++++++- src/draftwright/reporting.py | 27 ++-- src/draftwright/sheet.py | 55 +++++++- src/draftwright/sheet_emit.py | 10 +- src/draftwright/sheet_layout_controls.py | 73 ++++++++--- tests/_function_length_baseline.json | 2 +- tests/test_layout_override_lane_issue_1757.py | 99 ++++++++++++++- 13 files changed, 421 insertions(+), 83 deletions(-) diff --git a/docs/reference/draftwright-report-v8.schema.json b/docs/reference/draftwright-report-v8.schema.json index 85f2506d..58ca8606 100644 --- a/docs/reference/draftwright-report-v8.schema.json +++ b/docs/reference/draftwright-report-v8.schema.json @@ -198,6 +198,8 @@ "properties": { "declaration_id": { "type": "string", "minLength": 1 }, "parameter_id": { "type": "string", "minLength": 1 }, + "axis": { "enum": ["x", "y"] }, + "member": { "oneOf": [{ "type": "integer", "minimum": 0 }, { "const": "centre" }] }, "control": { "enum": ["side", "lane"] }, "authored_value": {}, "resolved_value": {}, diff --git a/docs/reference/reports.md b/docs/reference/reports.md index a72bdfb1..731b6a3e 100644 --- a/docs/reference/reports.md +++ b/docs/reference/reports.md @@ -49,7 +49,8 @@ When a generated or hand-authored sheet uses `sheet.layout_override(...)`, `intent_class: "layout-only"`. The corresponding feature still carries its complete semantic content and the ordinary shared placement solve still owns coordinates and feasibility. The side form records a corridor; a dimension-targeted side or lane additionally records the exact -`parameter_id`, and a lane records its one-based feature-relative rank. The field is emitted as an empty array when no override +`parameter_id`, and a lane records its one-based feature-relative rank. Exact location overrides +also record `axis` and `member`, so X and Y locations remain distinct. The field is emitted as an empty array when no override exists; it is optional in the version-8 schema so previously written version-8 documents remain valid. diff --git a/docs/reference/sheet.md b/docs/reference/sheet.md index 8aa8d364..8b4c7af3 100644 --- a/docs/reference/sheet.md +++ b/docs/reference/sheet.md @@ -350,6 +350,15 @@ if side_check["supported"]: sheet.layout_override( "declaration:hole", parameter="bore.diameter", side="left" ) + +# A location needs both its axis and pattern/hole member to select one component. +location_check = sheet.validate_layout_override( + "declaration:hole", parameter="location", axis="x", member=0, lane=2 +) +if location_check["supported"]: + sheet.layout_override( + "declaration:hole", parameter="location", axis="x", member=0, lane=2 + ) ``` Without `parameter=`, `layout_options()` reports the declaration's current side and supported @@ -360,7 +369,9 @@ witness, not a distance. The shared measured-candidate solve may resolve it into 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 rectangular pockets, the overall OD diameter of a rotational feature, step diameter leaders, and the -overall width/depth/height dimensions of an envelope. Capability is +overall width/depth/height dimensions of an envelope, plus exact X/Y locations on +Z-normal holes and patterns. For a location, `axis` and `member` are required and +X and Y can have independent lanes. 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 or boss diameter, `side=` can instead select a bounded leader hemisphere: @@ -391,6 +402,8 @@ other engineering semantics. Generated scripts emit the override as a separate line after the identity-bearing declarations. A declared report records the requested and resolved value under `layout.overrides` with `intent_class: "layout-only"`; dimension-targeted rows also retain `parameter_id`. An infeasible lane drops +with a `location_ref_dropped` issue for exact locations, retaining the requested lane and blockers. +Other infeasible lanes drop honestly with the requested lane in the lint message. Omitting the override retains the existing placement behaviour. diff --git a/src/draftwright/annotations/_locations.py b/src/draftwright/annotations/_locations.py index 45ffece1..d1aa824a 100644 --- a/src/draftwright/annotations/_locations.py +++ b/src/draftwright/annotations/_locations.py @@ -9,6 +9,7 @@ from build123d_drafting.helpers import CenterMark from draftwright._core import ( + _STRIP_SPACING, Analysis, _concentric_with_axis, _first_free_index, @@ -20,6 +21,7 @@ PRIORITY, CorridorCandidate, Escalation, + InteriorDimensionJob, _hole_location_coverage_fact, _same_location_ordinate, _with_hole_location_coverage, @@ -276,6 +278,69 @@ def _drop(nm): ) +def _submit_location( + dwg, + ctx, + register, + key, + strip, + view, + axis, + tier, + candidate, + *, + lane, + witness, + side, + hole_requirements=(), +): + """Route an exact declared lane through the shared whole-dimension solve.""" + if lane is None: + register(ctx, key, strip, view, axis, tier, candidate) + return + rejections: list[str] = [] + + def drop(name): + blockers = sorted(set(rejections)) or ["no_admissible_candidate"] + ctx.record_issue( + "warning", + "location_ref_dropped", + f"{name} not placed (requested lane {lane} unavailable beside the {view}; " + f"blockers: {', '.join(blockers)})", + measurement=candidate.measurement, + hole_requirements=hole_requirements, + evidence_reason=f"requested_lane_unavailable:{lane}:{','.join(blockers)}", + ) + ctx.escalations.append(Escalation("location", view, name, "requested_lane_unavailable")) + + jobs = ctx.interior_dimensions + if jobs is None: + rejections.append("measured_lane_solve_unavailable") + drop(candidate.name) + return + lane_step = tier + (strip.spacing if strip is not None else _STRIP_SPACING) + direction = 1 if side in {"above", "right"} else -1 + position = witness + direction * (2 * dwg.draft.extension_gap + lane * lane_step) + jobs.append( + InteriorDimensionJob( + name=candidate.name, + view=view, + side=side, + build=candidate.build, + on_place=candidate.on_place, + on_drop=drop, + lane_step=lane_step, + priority=candidate.priority, + feature=candidate.feature, + measurement=candidate.measurement, + interior_build=candidate.build, + explicit_position=position, + requested_lane=lane, + rejection_reasons=rejections, + ) + ) + + def _circular_channel_axis_marks(dwg, ctx, dimensions): """Give approved axis coordinates a visible natural reference in each projection.""" existing = { @@ -525,7 +590,7 @@ def _discard_short_refs(refs, coordinate, datum, view): if r[4] not in (None, "x"): continue for u in x_refs: - if _same_location_ordinate(r[0], u[0]): + if _same_location_ordinate(r[0], u[0]) and r[6].lane == u[6][0].lane: u[6].append(r[6]) u[3] = u[3] or r[2] in pinned_set # Collapsing coincident Xs into one dim must ACCUMULATE what it draws @@ -568,11 +633,7 @@ def _discard_short_refs(refs, coordinate, datum, view): ) ctx.escalations.append(Escalation("location", "plan", None, "illegible")) x_refs = [r for r in x_refs if r[0] not in _x_drawable or r[0] in _kept_x_set] - # Register X locations with slot dimensions in the shared plan-above corridor; - # this dedups coincident slot positions and orders the whole ladder instead - # of passes carving around each other. A plan-X location has no alternate - # view, so Policy B force-keeps a blocked dim; only a physically full strip - # drops (location_ref_dropped) and escalates the hole table. + # Share the plan corridor with slots; blocked dimensions escalate to a hole table. for i, (rx, ry, feat, pin_ref, mids, location_facts, location_entries) in enumerate( sorted(x_refs, key=lambda r: abs(r[0] - datum_x)) ): @@ -583,25 +644,17 @@ def _discard_short_refs(refs, coordinate, datum, view): label_offset = short_dimension_label_offset( (PX(datum_x), PY(ry), 0), (PX(rx), PY(ry), 0), draft, label ) - # A single X-location dim shared by two *distinct* features at this X belongs to - # neither exclusively — leave it unowned so drop cannot over-strip a sibling's - # dimension and annotations_of never over-claims it (ADR 5 (was 0010)). + # Shared dimensions have no single feature owner (ADR 5). _shared_x = any( - o[4] in (None, "x") and _same_location_ordinate(o[0], rx) and o[2] != feat + o[4] in (None, "x") + and _same_location_ordinate(o[0], rx) + and o[2] != feat + and o[6].lane == location_entries[0].lane for o in refs ) _xfeat = None if _shared_x else feat - # The measurement does NOT follow the feature. Feature-unowned is an - # ADR 5 (was 0010) *ownership* rule — it stops drop(feature) stripping a sibling's dim. It - # says nothing about what the dim measures, and a shared dim measures BOTH features' - # X location. Record every approved measurement in the tuple-valued - # channel (ADR 4 (was 0016)) so audit can credit all owners. - # One ADR 4 (was 0016) feature-level location identity per collapsed owner; the structured - # location facts below carry that this particular visible member is X. _xmid = tuple(mids) - # On the experimental staggered layout the plan can abut the top sheet margin. - # The farther X stations may use the free exterior strip below the plan while - # the nearest station keeps its established tier. Both are solver-owned strips. + # A staggered plan may route farther X stations into the free lower strip. x_below = ( layout_flag("plan_x_below", "DRAFTWRIGHT_EXPERIMENTAL_PLAN_X_BELOW") and i > 0 @@ -613,8 +666,10 @@ def _discard_short_refs(refs, coordinate, datum, view): geometry = _XLocationGeometry( PX, PY, datum_x, rx, ry, x_side, label, label_offset, draft, dim_builder ) - register( + _submit_location( + dwg, ctx, + register, ("plan", x_side), x_zone, "plan", @@ -640,6 +695,12 @@ def _discard_short_refs(refs, coordinate, datum, view): interior_build=geometry.interior_build, interior_geometry=geometry.interior_geometry, ), + lane=location_entries[0].lane, + witness=PY(ry), + side=x_side, + hole_requirements=tuple( + (feature, parameter) for feature, parameter, _point in location_facts + ), ) return _register_y_locations( @@ -698,7 +759,7 @@ def _register_y_locations( if r[4] not in (None, "y"): continue for u in y_refs: - if _same_location_ordinate(r[1], u[1]): + if _same_location_ordinate(r[1], u[1]) and r[6].lane == u[6][0].lane: u[6].append(r[6]) u[3] = u[3] or r[2] in pinned_set if r[4] in (None, "y") and r[3] is not None and r[3] not in u[4]: @@ -762,7 +823,10 @@ def _register_y_locations( n += 1 # A shared Y location is unowned for the same reason as shared X. _shared_y = any( - o[4] in (None, "y") and _same_location_ordinate(o[1], ry) and o[2] != feat + o[4] in (None, "y") + and _same_location_ordinate(o[1], ry) + and o[2] != feat + and o[6].lane == location_entries[0].lane for o in refs ) _yfeat = None if _shared_y else feat @@ -797,8 +861,10 @@ def _register_y_locations( geometry = _YLocationGeometry( pa, pb, direction, interior_direction, edge, label, label_offset, draft, dim_builder ) - register( + _submit_location( + dwg, ctx, + register, (view, direction), strip, view, @@ -825,5 +891,11 @@ def _register_y_locations( interior_build=geometry.interior_build, interior_geometry=geometry.interior_geometry, ), + lane=location_entries[0].lane, + witness=edge, + side=direction, + hole_requirements=tuple( + (feature, parameter) for feature, parameter, _point in location_facts + ), ) return n diff --git a/src/draftwright/model/compiled.py b/src/draftwright/model/compiled.py index 8c3ceaeb..8dbae417 100644 --- a/src/draftwright/model/compiled.py +++ b/src/draftwright/model/compiled.py @@ -106,6 +106,7 @@ authored_location_omitted, hole_location_parameter_id, hole_location_references, + location_component_lane, location_datum, location_display_decimals, plan_dimensions, @@ -1564,6 +1565,13 @@ def _compile_locations(model: PartModel) -> tuple[list[ApprovedDimension], list[ ) if isinstance(feature, HoleFeature | PatternFeature) else None, + lane=( + location_component_lane( + model, feature, pd.location_member, measured_axis + ) + if isinstance(feature, HoleFeature | PatternFeature) + else None + ), ) ) continue diff --git a/src/draftwright/model/ir.py b/src/draftwright/model/ir.py index aaddf10d..4dc15917 100644 --- a/src/draftwright/model/ir.py +++ b/src/draftwright/model/ir.py @@ -2659,10 +2659,19 @@ def __post_init__(self) -> None: "placement intent is unavailable for location dimensions: one location " "may compile into multiple directional values" ) - if self.role == "location" and self.lane is not None: + if ( + self.role == "location" + and self.lane is not None + and not ( + isinstance(self.feature, HoleFeature | PatternFeature) + and self.feature.frame.axis == "z" + and self.discriminator in {"x", "y"} + and self.member is not None + ) + ): raise ValueError( - "lane intent is unavailable for location dimensions: one location may " - "compile into multiple directional values" + "location lane requires one Z-normal hole or pattern component " + "selected by both axis and member" ) decimals = self.display_decimals if decimals is None: @@ -2715,19 +2724,14 @@ def __post_init__(self) -> None: @dataclass(frozen=True) class LayoutOverride: - """One append-only layout-only edit against a build-scoped declaration. - - The record carries a feature corridor side, one exact dimension's corridor side, - or one exact dimension's relative lane, never page coordinates. The matching feature/request in :class:`PartModel` - contains the resolved value used by the renderer; retaining this separate intent - record makes generated replay and assessment evidence explicit without turning layout - policy into engineering meaning. - """ + """Append-only, coordinate-free layout edit against a build-scoped declaration.""" declaration_id: str side: str | None = None parameter_id: str | None = None lane: int | None = None + axis: str | None = None + member: int | Literal["centre"] | None = None def __post_init__(self) -> None: if ( @@ -2741,6 +2745,17 @@ def __post_init__(self) -> None: ) if (self.side is None) == (self.lane is None): raise ValueError("layout override requires exactly one of side or lane") + if self.parameter_id != "location" and (self.axis is not None or self.member is not None): + raise ValueError("layout override axis and member select only location") + if self.parameter_id == "location" and ( + self.axis not in {"x", "y"} or self.member is None + ): + raise ValueError("location layout override requires exact axis and member") + valid_member = self.member == "centre" or ( + isinstance(self.member, int) and not isinstance(self.member, bool) and self.member >= 0 + ) + if self.parameter_id == "location" and (self.side is not None or not valid_member): + raise ValueError("location layout override requires a valid member and lane") if self.side is not None: if self.parameter_id is not None and ( not isinstance(self.parameter_id, str) @@ -2887,7 +2902,8 @@ def __post_init__(self) -> None: ): raise ValueError("PartModel.layout_overrides requires LayoutOverride entries") override_targets = [ - (override.declaration_id, override.parameter_id) for override in self.layout_overrides + (override.declaration_id, override.parameter_id, override.axis, override.member) + for override in self.layout_overrides ] if len(set(override_targets)) != len(override_targets): raise ValueError("PartModel.layout_overrides requires unique layout targets") @@ -2914,6 +2930,8 @@ def __post_init__(self) -> None: ) if request.feature is feature and request.role == override.parameter_id + and request.discriminator == override.axis + and request.member == override.member and request.side == override.side ] if len(matching_side) != 1: @@ -2935,6 +2953,8 @@ def __post_init__(self) -> None: for request in (*self.requested_dimensions, *(self.authored_dimensions or ())) if request.feature is feature and request.role == override.parameter_id + and request.discriminator == override.axis + and request.member == override.member and request.lane == override.lane ] if len(matching) != 1: diff --git a/src/draftwright/model/planner.py b/src/draftwright/model/planner.py index d4698511..b1f60e2f 100644 --- a/src/draftwright/model/planner.py +++ b/src/draftwright/model/planner.py @@ -623,6 +623,17 @@ def dimension_lane_supported(feature: Feature, parameter_id: str) -> bool: return (feature.kind, parameter_id) in _DIMENSION_LANE_PARAMETERS +def location_lane_supported(feature: Feature, axis: str | None, member: object) -> bool: + """A location lane must name one Z-normal hole/pattern component exactly.""" + + return ( + isinstance(feature, HoleFeature | PatternFeature) + and feature.frame.axis == "z" + and axis in {"x", "y"} + and member is not None + ) + + def _validate_dimension_lane( feature: Feature, parameters: tuple[DimParameter, ...] | list[DimParameter], @@ -1510,6 +1521,22 @@ def location_display_decimals(model: PartModel, feature) -> int | None: return next((request.display_decimals for request in _location_requests(model, feature)), None) +def location_component_lane( + model: PartModel, feature: Feature, member: int | None, axis: str +) -> int | None: + """Return the lane only for the exact approved hole/pattern location component.""" + + selected_member = "centre" if member is None else member + return next( + ( + request.lane + for request in _location_requests(model, feature) + if request.member == selected_member and request.discriminator == axis + ), + None, + ) + + def authored_location_axis_omitted(model: PartModel, feature, axis: str) -> bool: """An authored location set deliberately selects no component on this axis.""" requests = _location_requests(model, feature) @@ -1790,10 +1817,20 @@ def _check_intent_policy_conflicts(model: PartModel) -> None: if model.authored_dimensions is not None else model.requested_dimensions ) - seen: dict[tuple[int, str], tuple[int | None, str | None, str | None, int | None]] = {} + seen: dict[ + tuple[int, str, object, str | None], tuple[int | None, str | None, str | None, int | None] + ] = {} + location_decimals: dict[int, int | None] = {} for request in requests: targets: tuple[str, ...] if request.role == LOCATION_ROLE: + feature_id = id(request.feature) + previous_decimals = location_decimals.setdefault(feature_id, request.display_decimals) + if previous_decimals != request.display_decimals: + raise ValueError( + f"conflicting display precision for location: " + f"{previous_decimals!r} and {request.display_decimals!r}" + ) targets = (LOCATION_ROLE,) else: parameters = tuple( @@ -1804,7 +1841,12 @@ def _check_intent_policy_conflicts(model: PartModel) -> None: _validate_dimension_lane(request.feature, parameters, request.lane) targets = tuple(parameter.parameter_id for parameter in parameters) for parameter_id in targets: - key = (id(request.feature), parameter_id) + key = ( + id(request.feature), + parameter_id, + request.member if request.role == LOCATION_ROLE else None, + request.discriminator if request.role == LOCATION_ROLE else None, + ) policy = (request.display_decimals, request.view, request.side, request.lane) previous = seen.get(key, policy) if key in seen and previous != policy: diff --git a/src/draftwright/reporting.py b/src/draftwright/reporting.py index f827b3db..c56a06ae 100644 --- a/src/draftwright/reporting.py +++ b/src/draftwright/reporting.py @@ -2196,18 +2196,18 @@ def _declared_layout( f"layout override {override.declaration_id!r} has no final declaration" ) feature = model.features[feature_index] + matches = [ + request + for request in (*model.requested_dimensions, *(model.authored_dimensions or ())) + if request.feature is feature + and request.role == override.parameter_id + and request.discriminator == override.axis + and request.member == override.member + ] if override.side is not None: if override.parameter_id is None: resolved = getattr(feature, "side", None) else: - matches = [ - request - for request in ( - *model.requested_dimensions, - *(model.authored_dimensions or ()), - ) - if request.feature is feature and request.role == override.parameter_id - ] resolved = matches[0].side if len(matches) == 1 else None if resolved != override.side: raise ReportUnavailableError( @@ -2223,12 +2223,10 @@ def _declared_layout( } if override.parameter_id is not None: row["parameter_id"] = override.parameter_id + if override.parameter_id == "location": + row["axis"] = override.axis + row["member"] = override.member else: - matches = [ - request - for request in (*model.requested_dimensions, *(model.authored_dimensions or ())) - if request.feature is feature and request.role == override.parameter_id - ] if len(matches) != 1 or matches[0].lane != override.lane: raise ReportUnavailableError( f"layout override {override.declaration_id!r} did not resolve lane " @@ -2243,6 +2241,9 @@ def _declared_layout( "intent_class": "layout-only", "status": "applied", } + if override.parameter_id == "location": + row["axis"] = override.axis + row["member"] = override.member overrides.append(row) page_w, page_h = float(drawing.page_w), float(drawing.page_h) left, bottom, right, top = drawing.drawable_bounds diff --git a/src/draftwright/sheet.py b/src/draftwright/sheet.py index cb027e0b..3e576f22 100644 --- a/src/draftwright/sheet.py +++ b/src/draftwright/sheet.py @@ -139,6 +139,7 @@ dimension_lane_supported, dimension_placement_options, location_components, + location_lane_supported, schedule_row_dimensions, validate_dimension_placement, ) @@ -675,7 +676,14 @@ def place(self, *, lane: int) -> DimensionIntent: self._sheet._index_of_token(cast(int, self._entry["token"])) ] parameter_id = cast(str, self._entry["role"]) - if not dimension_lane_supported(feature, parameter_id): + supported = ( + location_lane_supported( + feature, self._entry.get("discriminator"), self._entry.get("member") + ) + if parameter_id == "location" + else dimension_lane_supported(feature, parameter_id) + ) + if not supported: raise ValueError( f"dimension {parameter_id!r} on {feature.kind} does not expose a lane control" ) @@ -1606,14 +1614,23 @@ def _declaration_token(self, declaration_id: str) -> int: return _layout_declaration_token(self, declaration_id) def _dimension_entry_for_layout( - self, token: int, parameter_id: str + self, + token: int, + parameter_id: str, + axis: str | None = None, + member: int | Literal["centre"] | None = None, ) -> tuple[dict, str] | None: """Return the one declared dimension entry addressed by a lane override.""" - return _layout_dimension_entry_for_layout(self, token, parameter_id) + return _layout_dimension_entry_for_layout(self, token, parameter_id, axis, member) def layout_options( - self, declaration_id: str, *, parameter: DimensionParameterId | None = None + self, + declaration_id: str, + *, + parameter: DimensionParameterId | None = None, + axis: str | None = None, + member: int | Literal["centre"] | None = None, ) -> dict[str, object]: """Describe the bounded layout-only controls supported by one declaration. @@ -1621,7 +1638,14 @@ def layout_options( solve still decides whether the requested corridor can be used on the final sheet. """ - return _layout_options(self, declaration_id, parameter=parameter, handle_factory=_Params) + return _layout_options( + self, + declaration_id, + parameter=parameter, + axis=axis, + member=member, + handle_factory=_Params, + ) def validate_layout_override( self, @@ -1630,6 +1654,8 @@ def validate_layout_override( side: str | None = None, parameter: DimensionParameterId | None = None, lane: int | None = None, + axis: str | None = None, + member: int | Literal["centre"] | None = None, **unsupported_controls, ) -> dict[str, object]: """Preflight a layout override without mutating the sheet. @@ -1639,7 +1665,14 @@ def validate_layout_override( """ return _layout_validate_layout_override( - self, declaration_id, side=side, parameter=parameter, lane=lane, **unsupported_controls + self, + declaration_id, + side=side, + parameter=parameter, + lane=lane, + axis=axis, + member=member, + **unsupported_controls, ) def layout_override( @@ -1649,6 +1682,8 @@ def layout_override( side: str | None = None, parameter: DimensionParameterId | None = None, lane: int | None = None, + axis: str | None = None, + member: int | Literal["centre"] | None = None, ) -> Sheet: """Append one bounded declaration-scoped layout override. @@ -1659,7 +1694,13 @@ def layout_override( """ return _layout_apply_layout_override( - self, declaration_id, side=side, parameter=parameter, lane=lane + self, + declaration_id, + side=side, + parameter=parameter, + lane=lane, + axis=axis, + member=member, ) def _declared_token(self, ref, *, verb: str) -> int | None: diff --git a/src/draftwright/sheet_emit.py b/src/draftwright/sheet_emit.py index 09fee349..ff98e495 100644 --- a/src/draftwright/sheet_emit.py +++ b/src/draftwright/sheet_emit.py @@ -948,6 +948,11 @@ def _layout_override_block(model) -> list[str]: return [] lines = [] for override in model.layout_overrides: + selector = ( + f"axis={json.dumps(override.axis)}, member={json.dumps(override.member)}, " + if override.parameter_id == "location" + else "" + ) if override.side is not None: parameter = ( f"parameter={json.dumps(override.parameter_id)}, " @@ -956,13 +961,14 @@ def _layout_override_block(model) -> list[str]: ) lines.append( "sheet.layout_override(" - f"{json.dumps(override.declaration_id)}, {parameter}side={json.dumps(override.side)})" + f"{json.dumps(override.declaration_id)}, {parameter}{selector}" + f"side={json.dumps(override.side)})" ) else: lines.append( "sheet.layout_override(" f"{json.dumps(override.declaration_id)}, " - f"parameter={json.dumps(override.parameter_id)}, lane={override.lane})" + f"parameter={json.dumps(override.parameter_id)}, {selector}lane={override.lane})" ) return [ "# ── Layout-only declaration overrides ──────────────────────────────────────────", diff --git a/src/draftwright/sheet_layout_controls.py b/src/draftwright/sheet_layout_controls.py index d50d0771..1e5b4dc3 100644 --- a/src/draftwright/sheet_layout_controls.py +++ b/src/draftwright/sheet_layout_controls.py @@ -4,7 +4,7 @@ from collections.abc import Callable from dataclasses import replace -from typing import TYPE_CHECKING, cast +from typing import TYPE_CHECKING, Literal, cast from draftwright.model.ir import ( PLACEMENT_SIDES, @@ -12,7 +12,7 @@ DimensionParameterId, LayoutOverride, ) -from draftwright.model.planner import dimension_lane_supported +from draftwright.model.planner import dimension_lane_supported, location_lane_supported if TYPE_CHECKING: from draftwright.sheet import Sheet @@ -51,13 +51,22 @@ def _declaration_token(sheet: Sheet, declaration_id: str) -> int: def _dimension_entry_for_layout( - sheet: Sheet, token: int, parameter_id: str + sheet: Sheet, + token: int, + parameter_id: str, + axis: str | None = None, + member: int | Literal["centre"] | None = None, ) -> tuple[dict, str] | None: """Return the one declared dimension entry addressed by a lane override.""" for entries in (sheet._authored, sheet._added_dimensions): matches = [ - entry for entry in entries if entry["token"] == token and entry["role"] == parameter_id + entry + for entry in entries + if entry["token"] == token + and entry["role"] == parameter_id + and entry.get("discriminator") == axis + and entry.get("member") == member ] if len(matches) > 1: raise ValueError( @@ -74,6 +83,8 @@ def layout_options( declaration_id: str, *, parameter: DimensionParameterId | None = None, + axis: str | None = None, + member: int | Literal["centre"] | None = None, handle_factory: Callable[[Sheet, int], object], ) -> dict[str, object]: """Describe the bounded layout-only controls supported by one declaration. @@ -84,10 +95,12 @@ def layout_options( token = sheet._declaration_token(declaration_id) feature = sheet._features[sheet._index_of_token(token)] + if parameter is None and (axis is not None or member is not None): + raise ValueError("axis and member require an exact location parameter selector") if parameter is not None: handle = handle_factory(sheet, sheet._index_of_token(token)) _resolved_token, target, discriminator, canonical = sheet._resolve_measurement( - handle, parameter, None, "layout_options" + handle, parameter, axis, "layout_options", member=member ) parameter_id = next( ( @@ -98,14 +111,16 @@ def layout_options( ), canonical, ) - entry = sheet._dimension_entry_for_layout(token, parameter_id) + entry = sheet._dimension_entry_for_layout(token, parameter_id, axis, member) if entry is None: raise ValueError( f"declaration {declaration_id!r} has no declared dimension " f"{parameter_id!r} to override" ) controls: dict[str, object] = {} - if dimension_lane_supported(feature, parameter_id): + if dimension_lane_supported(feature, parameter_id) or ( + parameter_id == "location" and location_lane_supported(feature, axis, member) + ): controls["lane"] = { "current": entry[0].get("lane"), "minimum": 1, @@ -114,7 +129,9 @@ 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", "step", "boss", "pocket", "slot"}: + if parameter_id != "location" and feature.kind in { + "hole", "pattern", "envelope", "step", "boss", "pocket", "slot" + }: placements = sheet.dimension_options(handle, parameter)["placements"] sides = sorted( { @@ -130,7 +147,7 @@ def layout_options( raise ValueError( f"dimension {parameter_id!r} on {feature.kind} does not expose a layout control" ) - return { + result = { "schema": "draftwright.layout-options", "schema_version": 1, "scope": "single-dimension-layout-controls", @@ -140,6 +157,10 @@ def layout_options( "parameter_id": parameter_id, "controls": controls, } + if parameter_id == "location": + result["axis"] = axis + result["member"] = member + return result side = getattr(feature, "side", None) if feature.kind == "authored_dimension": supported_sides = sorted( @@ -192,6 +213,8 @@ def validate_layout_override( side: str | None = None, parameter: DimensionParameterId | None = None, lane: int | None = None, + axis: str | None = None, + member: int | Literal["centre"] | None = None, **unsupported_controls, ) -> dict[str, object]: """Preflight a layout override without mutating the sheet. @@ -245,9 +268,16 @@ def validate_layout_override( } ] return result + if (axis is not None or member is not None) and parameter != "location": + result["issues"] = [ + {"code": "invalid_selector", "message": "axis and member select only location"} + ] + return result feature = sheet._features[sheet._index_of_token(token)] try: - options = sheet.layout_options(declaration_id, parameter=parameter) + options = sheet.layout_options( + declaration_id, parameter=parameter, axis=axis, member=member + ) except (TypeError, ValueError, IndexError) as error: result["issues"] = [ { @@ -314,6 +344,8 @@ def layout_override( side: str | None = None, parameter: DimensionParameterId | None = None, lane: int | None = None, + axis: str | None = None, + member: int | Literal["centre"] | None = None, ) -> Sheet: """Append one bounded declaration-scoped layout override. @@ -323,15 +355,18 @@ def layout_override( """ validation = sheet.validate_layout_override( - declaration_id, side=side, parameter=parameter, lane=lane + declaration_id, side=side, parameter=parameter, lane=lane, axis=axis, member=member ) if not validation["supported"]: issues = cast(list[dict[str, object]], validation["issues"]) raise ValueError(str(issues[0]["message"])) options = cast(dict[str, object], validation["options"]) parameter_id = cast(str | None, options.get("parameter_id")) - key = (declaration_id, parameter_id) - if any((row.declaration_id, row.parameter_id) == key for row in sheet._layout_overrides): + key = (declaration_id, parameter_id, axis, member) + if any( + (row.declaration_id, row.parameter_id, row.axis, row.member) == key + for row in sheet._layout_overrides + ): raise ValueError(f"layout target {key!r} already has a layout override") token = sheet._declaration_token(declaration_id) if side is not None: @@ -341,18 +376,22 @@ def layout_override( sheet._layout_overrides.append(LayoutOverride(declaration_id, side)) else: assert parameter_id is not None - entry = sheet._dimension_entry_for_layout(token, parameter_id) + entry = sheet._dimension_entry_for_layout(token, parameter_id, axis, member) assert entry is not None entry[0]["side"] = side sheet._layout_overrides.append( - LayoutOverride(declaration_id, side=side, parameter_id=parameter_id) + LayoutOverride( + declaration_id, side=side, parameter_id=parameter_id, axis=axis, member=member + ) ) else: assert parameter_id is not None - entry = sheet._dimension_entry_for_layout(token, parameter_id) + entry = sheet._dimension_entry_for_layout(token, parameter_id, axis, member) assert entry is not None and lane is not None entry[0]["lane"] = lane sheet._layout_overrides.append( - LayoutOverride(declaration_id, parameter_id=parameter_id, lane=lane) + LayoutOverride( + declaration_id, parameter_id=parameter_id, lane=lane, axis=axis, member=member + ) ) return sheet diff --git a/tests/_function_length_baseline.json b/tests/_function_length_baseline.json index 47f62071..2beb3451 100644 --- a/tests/_function_length_baseline.json +++ b/tests/_function_length_baseline.json @@ -4,7 +4,7 @@ "analysis.py:_prepare_source": 216, "annotations/_common.py:solve_corridor": 265, "annotations/_diameters.py:render_diameters": 204, - "annotations/_locations.py:render_locations": 258, + "annotations/_locations.py:render_locations": 254, "annotations/_pmi_dimensions.py:_place_pmi_record": 258, "annotations/_pmi_dimensions.py:_sheet_leader_fallback": 240, "annotations/_slots.py:_place_slot_dimension": 213, diff --git a/tests/test_layout_override_lane_issue_1757.py b/tests/test_layout_override_lane_issue_1757.py index 2a551b06..bafbfdd2 100644 --- a/tests/test_layout_override_lane_issue_1757.py +++ b/tests/test_layout_override_lane_issue_1757.py @@ -606,7 +606,7 @@ def test_lane_field_preserves_requested_dimension_positional_member_abi() -> Non assert request.lane is None -def test_requested_dimension_rejects_invalid_and_location_lanes() -> None: +def test_requested_dimension_rejects_invalid_and_ambiguous_location_lanes() -> None: sheet = Sheet(Box(100, 80, 10), title="lane").auto_dimensions() sheet.slot( width=20, @@ -623,8 +623,96 @@ def test_requested_dimension_rejects_invalid_and_location_lanes() -> None: with pytest.raises(ValueError, match="integer from 1 to 8"): RequestedDimension(slot_feature, "slot_width.length", lane=0) - with pytest.raises(ValueError, match="unavailable for location dimensions"): - RequestedDimension(hole_feature, "location", "x", member=0, lane=2) + with pytest.raises(ValueError, match="selected by both axis and member"): + RequestedDimension(hole_feature, "location", lane=2) + assert RequestedDimension(hole_feature, "location", "x", member=0, lane=2).lane == 2 + + +def test_exact_location_lanes_reach_independent_approved_components() -> None: + sheet = Sheet(Box(100, 80, 10)).authored_dimensions() + hole = sheet.hole(diameter=10, at=(10, 5, 5), axis="z") + sheet.dimension(hole, "location", axis="x", member=0).place(lane=1) + sheet.dimension(hole, "location", axis="y", member=0).place(lane=2) + + locations = compile_dimensions(sheet.model()).locations + assert {(entry.discriminator, entry.lane) for entry in locations} == { + ("x", 1), + ("y", 2), + } + + +def test_location_lane_override_targets_one_component_and_replays() -> None: + part = Box(100, 80, 10) - Pos(10, 5, 0) * Cylinder(10, 10) + sheet = Sheet(part).authored_dimensions() + hole = sheet.hole(diameter=10, at=(10, 5, 5), axis="z").identify("hole:0") + sheet.dimension(hole, "location", axis="x", member=0) + sheet.dimension(hole, "location", axis="y", member=0) + + assert ( + "lane" + in sheet.layout_options("hole:0", parameter="location", axis="x", member=0)["controls"] + ) + assert sheet.validate_layout_override( + "hole:0", parameter="location", axis="x", member=0, lane=2 + )["supported"] + sheet.layout_override("hole:0", parameter="location", axis="x", member=0, lane=2) + sheet.layout_override("hole:0", parameter="location", axis="y", member=0, lane=1) + + model = sheet.model() + assert { + (request.discriminator, request.lane) for request in model.authored_dimensions or () + } == { + ("x", 2), + ("y", 1), + } + source = emit_sheet_script(model, "part", "location", title="location", number="L") + assert 'parameter="location", axis="x", member=0, lane=2' in source + namespace = {"part": part} + exec( # noqa: S102 - execute this generated replay surface + compile(source[: source.index("drawing = sheet.build()")], "", "exec"), + namespace, + ) + assert namespace["sheet"].model().layout_overrides == model.layout_overrides + drawing = sheet.build() + location_names = [ + name + for name in drawing.annotations() + if any("location" in key["parameter_id"] for key in drawing.measurement_keys(name)) + ] + assert len(location_names) == 2 + assert not any(issue.code == "location_ref_dropped" for issue in drawing.lint()) + report = drawing.report() + assert { + (row["axis"], row["member"], row["resolved_value"]) + for row in report["layout"]["overrides"] + } == { + ("x", 0, 2), + ("y", 0, 1), + } + schema = json.loads( + ( + Path(__file__).parents[1] / "docs/reference/draftwright-report-v8.schema.json" + ).read_text() + ) + validator_for(schema)(schema).validate(report) + + +def test_equal_location_ordinates_in_different_lanes_keep_distinct_owners() -> None: + part = Box(100, 80, 10) + for y in (-10, 10): + part -= Pos(10, y, 0) * Cylinder(10, 10) + sheet = Sheet(part, scale=1).authored_dimensions() + first = sheet.hole(diameter=10, at=(10, -10, 5), axis="z") + second = sheet.hole(diameter=10, at=(10, 10, 5), axis="z") + sheet.dimension(first, "location", axis="x", member=0).place(lane=1) + sheet.dimension(second, "location", axis="x", member=0).place(lane=2) + + drawing = sheet.build() + first_feature, second_feature = sheet.model().features + first_names = set(drawing.annotations_of(first_feature)) + second_names = set(drawing.annotations_of(second_feature)) + assert first_names and second_names + assert first_names.isdisjoint(second_names) @pytest.mark.parametrize( @@ -635,6 +723,11 @@ def test_requested_dimension_rejects_invalid_and_location_lanes() -> None: ({"lane": 2}, "non-empty parameter_id"), ({"parameter_id": " slot_width.length ", "lane": 2}, "surrounding whitespace"), ({"parameter_id": "slot_width.length", "lane": 9}, "integer from 1 to 8"), + ({"parameter_id": "location", "lane": 2}, "exact axis and member"), + ( + {"parameter_id": "location", "axis": "x", "member": "wrong", "lane": 2}, + "valid member and lane", + ), ], ) def test_layout_override_record_rejects_ambiguous_or_unbounded_state(kwargs, message) -> None: From bf950c5c27adfaf0d27202a58b0958146bcc3820 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:09:06 +0000 Subject: [PATCH 2/4] Refresh layout override signature guard for location selectors --- tests/test_layout_override_side_issue_1757.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tests/test_layout_override_side_issue_1757.py b/tests/test_layout_override_side_issue_1757.py index 22cd6a15..04be9628 100644 --- a/tests/test_layout_override_side_issue_1757.py +++ b/tests/test_layout_override_side_issue_1757.py @@ -268,6 +268,8 @@ def test_invalid_or_duplicate_override_fails_before_build_and_accepts_no_coordin "side", "parameter", "lane", + "axis", + "member", ) with pytest.raises(TypeError): sheet.layout_override("declaration:63", side="below", x=10) # type: ignore[call-arg] From 6a9f0141fda4cff93159c6e3d471b64266ea6fdf Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 01:51:50 +0000 Subject: [PATCH 3/4] Cover unavailable shared solve for requested location lane --- tests/test_layout_override_lane_issue_1757.py | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/tests/test_layout_override_lane_issue_1757.py b/tests/test_layout_override_lane_issue_1757.py index bafbfdd2..2e21e5a0 100644 --- a/tests/test_layout_override_lane_issue_1757.py +++ b/tests/test_layout_override_lane_issue_1757.py @@ -17,6 +17,7 @@ from draftwright.annotations._diameters import _render_diameter_controls from draftwright.annotations._envelope import _EnvelopeLaneDrop, _queue_declared_envelope_lane from draftwright.annotations._height_ladder import _queue_declared_height_lane +from draftwright.annotations._locations import _submit_location from draftwright.annotations.from_model import _record_slot_drop from draftwright.model.compiled import compile_dimensions from draftwright.model.ir import LayoutOverride, RequestedDimension @@ -833,6 +834,31 @@ def test_height_lane_without_batch_solve_reports_refusal() -> None: assert issue.evidence_reason == "requested_lane_unavailable:2:measured_lane_solve_unavailable" +def test_location_lane_without_shared_solve_reports_the_exact_requested_measurement() -> None: + context = PlacementContext(registry=AnnotationRegistry()) + measurement = object() + _submit_location( + dwg=None, + ctx=context, + register=None, + key=("plan", "above"), + strip=None, + view="plan", + axis="y", + tier=4, + candidate=SimpleNamespace(name="m_location", measurement=measurement), + lane=3, + witness=0, + side="above", + ) + + (issue,) = context.registry.issues + assert issue.code == "location_ref_dropped" + assert issue.measurement_ids == (measurement,) + assert issue.evidence_reason == "requested_lane_unavailable:3:measured_lane_solve_unavailable" + assert context.escalations[0].reason == "requested_lane_unavailable" + + def test_lane_override_round_trips_and_reports_layout_only_evidence() -> None: sheet = _slot_sheet() sheet.layout_override("declaration:slot", parameter="slot_width.length", lane=4) From a380bb5be8616ea28093e20aad9904fe1519e851 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Wed, 7 Oct 2026 03:50:30 +0000 Subject: [PATCH 4/4] Format combined layout-control side registry --- src/draftwright/sheet_layout_controls.py | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/draftwright/sheet_layout_controls.py b/src/draftwright/sheet_layout_controls.py index 1e5b4dc3..ed910839 100644 --- a/src/draftwright/sheet_layout_controls.py +++ b/src/draftwright/sheet_layout_controls.py @@ -130,7 +130,13 @@ 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 parameter_id != "location" and feature.kind in { - "hole", "pattern", "envelope", "step", "boss", "pocket", "slot" + "hole", + "pattern", + "envelope", + "step", + "boss", + "pocket", + "slot", }: placements = sheet.dimension_options(handle, parameter)["placements"] sides = sorted(