draftwright 0.4.23__tar.gz → 0.4.24__tar.gz

{draftwright-0.4.23 → draftwright-0.4.24}/CHANGELOG.md

@@ -478,6 +478,10 @@
 
 ### Fixed
 
+- Overall height and envelope width remain dimensioned when approved turned-step lengths
+  cover only part of the respective extent. Redundancy suppression now requires adjoining
+  measurements on one profile to reach both overall endpoints; STC618 retains its missing
+  62 mm height (#1509).
 - Non-1:1 orthographic and isometric projection now scales extracted solids about the world
   origin, matching the view-coordinate mapper and solver zones. Solids carrying a non-zero
   build123d `Location` no longer shift their silhouette away from dimensions and callouts.

{draftwright-0.4.23 → draftwright-0.4.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.23
+Version: 0.4.24
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright

{draftwright-0.4.23 → draftwright-0.4.24}/pyproject.toml

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

{draftwright-0.4.23 → draftwright-0.4.24}/src/draftwright/annotations/from_model.py

@@ -1790,7 +1790,8 @@ def render_diameters(dwg, plan, a, *, ctx, only=None) -> int:
     # to the clear side (the margin the feature sits at). Auto-pass only: the finalize
     # (only=) path replays recorded verbs and must not disturb pinned user dims.
     if only is None:
-        _reroute_crossing_diameters(dwg, ctx=ctx)
+        # Rerouting must see the principal dimensions that registered before this pass.
+        ctx.post_drain.append(lambda: _reroute_crossing_diameters(dwg, ctx=ctx))
     return placed
 
 
@@ -4123,9 +4124,7 @@ def render_polygonal_stock(dwg, plan, a, *, ctx) -> int:
 
 
 def render_boss_heights(dwg, plan, a, *, ctx) -> int:
-    """Queue prismatic boss heights and polygonal-stock lengths in a profile corridor."""
-    if a.is_rotational or a.profiles:
-        return 0
+    """Queue approved boss heights and polygonal-stock lengths in a profile corridor."""
     tier = dwg.draft.font_size + 2 * dwg.draft.pad_around_text
     specs = {
         "z": ("front", "right", a.fv_zones.right, "x"),

{draftwright-0.4.23 → draftwright-0.4.24}/src/draftwright/compose.py

@@ -96,13 +96,9 @@ def _n_right_strip_boss_heights(model) -> int:
     declared path (#1022) removed that accident — a declared model that states a boss but no
     height ladder reserved one slot, needed two, and the height was dropped silently.
 
-    Mirrors ``render_boss_heights``' own guards: a turned model (any declared step) renders no
-    boss heights at all, and only the Z-axis ones land right — X/Y bosses go to the *above*
-    strips.  A rotational part that declares a Z boss over-reserves by one slot; that is the
-    conservative direction, and the same call the authored-Z-dim branch below makes.
+    Z-axis boss heights share this corridor even when a turned step chain is present.
+    X/Y heights reserve their profile-view above strips in ``_compose_anno_boxes``.
     """
-    if any(getattr(f, "kind", None) == "step" for f in model.features):
-        return 0
     occupants = [
         f
         for f in model.features
@@ -448,6 +444,14 @@ def _compose_anno_boxes(
     n_boss_h = _n_right_strip_boss_heights(model)
     # FV right dim ladder + the boss heights that share the strip with it
     boxes = [AnnoBox("right", _est_right_strip_depth(n_steps, n_boss_h))]
+    if any(
+        feature.kind in ("boss", "step") and feature.frame.axis == "y"
+        for feature in model.features
+    ):
+        # The end-on radial fan needs clearance alongside the overall-height slot.
+        # This is a minimum band; deeper ladder/bore reservations still win by max.
+        radial_reach = font_size + 6 * pad_around_text
+        boxes.append(AnnoBox("right", _est_right_strip_depth(0) + radial_reach))
     requests = (
         model.authored_dimensions
         if model.authored_dimensions is not None
@@ -597,6 +601,37 @@ def _compose_anno_boxes(
             _reserve(view, "above")
             _reserve(view, "right")
 
+    # Axial boss sizes occupy the same profile corridors on detected and declared parts.
+    # Include them before view packing; a turned chain does not convey its end caps.
+    axial_corridors = set()
+    axial_features = [
+        feature
+        for feature in model.features
+        if feature.kind in ("boss", "polygonal_boss", "polygonal_stock")
+        and feature.frame.axis in ("x", "y")
+    ]
+    for group in plan_dimensions(model) if axial_features else ():
+        feature = group.feature
+        if feature.kind not in ("boss", "polygonal_boss", "polygonal_stock"):
+            continue
+        if feature.frame.axis not in ("x", "y"):
+            continue
+        view = "front" if feature.frame.axis == "x" else "side"
+        for dimension in group.dims:
+            if not dimension.suppressed and dimension.param.role in (
+                "boss_height",
+                "stock_length",
+            ):
+                _reserve(view, "above")
+                axial_corridors.add(view)
+    # The existing axial step chain already consumes one row in these corridors.
+    for view in sorted(axial_corridors):
+        axis = "x" if view == "front" else "y"
+        if any(
+            feature.kind == "step" and feature.frame.axis == axis for feature in model.features
+        ):
+            _reserve(view, "above")
+
     slot = _SLOT_DIM_STEP + _STRIP_SPACING
     # Front and plan occupy disjoint vertical ranges, so their left/right tiers are
     # reusable. Reserve the deepest one-view stack, not the sum of independent corridors.

{draftwright-0.4.23 → draftwright-0.4.24}/src/draftwright/drawing.py

@@ -3985,9 +3985,7 @@ class Drawing:
                 issues += lint_claimed_representations(self._registry, dimension_plan)
             else:
                 dimension_plan = None
-            # Turned bosses/bands remain in the OD + axial-step policy; this check is
-            # specifically for a prismatic boss's independent projection height.
-            if model is not None and (a is None or (not a.is_rotational and not a.profiles)):
+            if model is not None:
                 issues += lint_boss_height_coverage(
                     working_part,
                     self,

{draftwright-0.4.23 → draftwright-0.4.24}/src/draftwright/model/compiled.py

@@ -72,9 +72,14 @@ from draftwright.model.ir import (
 )
 from draftwright.model.planner import (
     _AUTHORED_OMISSION,
+    _CONSOLIDATED,
     DimensionId,
+    _authored_for,
     _decorated,
+    _extent_can_convey,
     _is_zero_step_position,
+    _request_for,
+    _selected_chain_covers_extent,
     angular_pattern_label,
     authored_location_axis_omitted,
     authored_location_omitted,
@@ -1049,6 +1054,21 @@ def _compile_step_ladders(model: PartModel, marked) -> tuple[list[ApprovedLadder
     return approved, omissions
 
 
+def _step_chain_covers_extent(
+    model: PartModel, groups: list[ApprovedGroup], axis: Literal["x", "z"]
+) -> bool:
+    return _selected_chain_covers_extent(
+        model,
+        [
+            (resolve_feature(group.ref), length)
+            for group in groups
+            if group.feature_kind in ("step", "groove")
+            and (length := group.dim(kind="length")) is not None
+        ],
+        axis,
+    )
+
+
 def _compile_overall_height(
     model: PartModel, marked, *, planned, include_overall: bool, step_chain_approved: bool
 ) -> tuple[ApprovedLadder | None, ApprovedContingency | None, list[Omission]]:
@@ -1585,7 +1605,22 @@ def _compile_slot_positions(model: PartModel) -> tuple[list[ApprovedDimension],
     return approved, omissions
 
 
-def _compile_groups(planned) -> tuple[list[ApprovedGroup], list[Omission]]:
+def _dimension_witness_span(feature, parameter):
+    """Carry a boss's axial stations at its cylindrical silhouette, even without a diameter mark."""
+    span = parameter.span
+    if feature.kind != "boss" or parameter.parameter_id != "boss_height.length" or span is None:
+        return span
+    radial = 0 if feature.frame.axis == "z" else 2
+    rim = feature.frame.origin[radial] + feature.diameter / 2
+    return tuple(
+        tuple(rim if index == radial else value for index, value in enumerate(point))
+        for point in span
+    )
+
+
+def _compile_groups(
+    planned, *, restore_width: bool = False
+) -> tuple[list[ApprovedGroup], list[Omission]]:
     """Every planned group, reduced to what the compiler approved, plus what it withheld.
 
     The general path all remaining renderers migrate onto: same per-feature shape they
@@ -1602,6 +1637,17 @@ def _compile_groups(planned) -> tuple[list[ApprovedGroup], list[Omission]]:
     out: list[ApprovedGroup] = []
     omissions: list[Omission] = []
     for g in planned:
+        # The planner's X-chain redundancy decision precedes chain approval.
+        # Restore only that reason, preserving authored and unrelated omissions.
+        dims = tuple(
+            replace(pd, suppressed=False, reason=None)
+            if restore_width
+            and isinstance(g.feature, EnvelopeFeature)
+            and pd.param.parameter_id == "width.length"
+            and pd.reason == "X-turned (step-length chain conveys the length)"
+            else pd
+            for pd in g.dims
+        )
         omissions.extend(
             Omission(
                 g.feature,
@@ -1610,7 +1656,7 @@ def _compile_groups(planned) -> tuple[list[ApprovedGroup], list[Omission]]:
                 pd.reason or "suppressed",
                 conveyed_by=pd.conveyed_by,
             )
-            for pd in g.dims
+            for pd in dims
             if pd.suppressed
         )
         approved = tuple(
@@ -1620,7 +1666,7 @@ def _compile_groups(planned) -> tuple[list[ApprovedGroup], list[Omission]]:
                 # the boundary instead of implying a nullable state renderers cannot handle.
                 value_text=_fmt(pd.param.value, pd.display_decimals),
                 value=float(pd.param.value),
-                span=pd.param.span,
+                span=_dimension_witness_span(g.feature, pd.param),
                 ref=FeatureRef(g.feature),
                 kind=pd.param.kind,
                 role=pd.param.role,
@@ -1636,7 +1682,7 @@ def _compile_groups(planned) -> tuple[list[ApprovedGroup], list[Omission]]:
                 view=pd.view,
                 side=pd.side,
             )
-            for pd in g.dims
+            for pd in dims
             if not pd.suppressed
             # A datum-coincident shoulder is not a zero-valued dimension the general group
             # may keep after the dedicated ladder rejected its identical endpoints. It is
@@ -1709,13 +1755,10 @@ def compile_dimensions(
     marked = _suppressed_dims(model, planned)
     ladders, omissions = _compile_step_ladders(model, marked)
     groups_out, group_omissions = _compile_groups(planned)
+    if model.orientation == "x" and not _step_chain_covers_extent(model, groups_out, "x"):
+        groups_out, group_omissions = _compile_groups(planned, restore_width=True)
     groups_out = _share_unique_outer_diameter(groups_out, planned)
-    step_chain_approved = any(
-        group.feature_kind == "step"
-        and group.facts.frame.axis == "z"
-        and group.dim(kind="length") is not None
-        for group in groups_out
-    )
+    step_chain_approved = _step_chain_covers_extent(model, groups_out, "z")
     overall, contingency, height_omissions = _compile_overall_height(
         model,
         marked,
@@ -1737,6 +1780,9 @@ def compile_dimensions(
                 omission.feature is overall_feature and omission.parameter_id == "height.length"
             )
         ]
+    groups_out, group_omissions = _consolidate_boss_heights(
+        model, planned, groups_out, group_omissions, overall
+    )
     if overall is not None:
         ladders.append(overall)
     locations, location_omissions = _compile_locations(model)
@@ -1757,6 +1803,78 @@ def compile_dimensions(
     )
 
 
+def _consolidate_boss_heights(model, planned, groups, omissions, overall):
+    """Reconcile boss heights with active extent owners, including synthetic and restored ones."""
+    owners = [
+        dimension
+        for group in groups
+        if group.feature_kind == "envelope"
+        for dimension in group.dims
+        if dimension.kind == "length" and dimension.role in ("width", "depth")
+    ]
+    if overall is not None:
+        owners.extend(overall.rungs)
+    extents = []
+    for owner in owners:
+        assert owner.id is not None
+        extent = replace(
+            next(
+                parameter
+                for parameter in owner.id.feature.parameters()
+                if parameter.parameter_id == owner.id.parameter
+            ),
+            value=owner.value,
+            span=owner.span,
+        )
+        extents.append((extent, owner.id))
+    shared = {}
+    for group in planned:
+        if group.feature.kind != "boss":
+            continue
+        for dimension in group.dims:
+            parameter = dimension.param
+            if (
+                parameter.parameter_id != "boss_height.length"
+                or _request_for(model, group.feature, parameter) is not None
+                or _authored_for(model, group.feature, parameter) is not None
+            ):
+                continue
+            for extent, owner_id in extents:
+                if _extent_can_convey(extent, parameter):
+                    shared[DimensionId(group.feature, parameter.parameter_id)] = (
+                        parameter,
+                        owner_id,
+                    )
+                    break
+    if not shared:
+        return groups, omissions
+    retained = []
+    for group in groups:
+        dims = tuple(dimension for dimension in group.dims if dimension.id not in shared)
+        if dims:
+            retained.append(replace(group, dims=dims))
+    updated = []
+    recorded = set()
+    for omission in omissions:
+        identity = _dim_id(omission.feature, omission.parameter_id)
+        if identity in shared:
+            omission = replace(omission, conveyed_by=shared[identity][1])
+            recorded.add(identity)
+        updated.append(omission)
+    for identity, (parameter, owner_id) in shared.items():
+        if identity not in recorded:
+            updated.append(
+                Omission(
+                    identity.feature,
+                    identity.parameter,
+                    parameter.value,
+                    _CONSOLIDATED,
+                    conveyed_by=owner_id,
+                )
+            )
+    return retained, updated
+
+
 def _share_unique_outer_diameter(groups: list[ApprovedGroup], planned) -> list[ApprovedGroup]:
     """Let a global OD carry one unique coaxial maximum band's approved identity.
 

{draftwright-0.4.23 → draftwright-0.4.24}/src/draftwright/model/planner.py

@@ -474,6 +474,17 @@ def polygonal_stock_conveys_height(model: PartModel) -> bool:
     return any(f.kind == "polygonal_stock" for f in model.features)
 
 
+def _extent_can_convey(extent: DimParameter, parameter: DimParameter) -> bool:
+    """An overall extent may replace an untoleranced local measurement of the same planes.
+
+    A tolerance on the owner is acceptable; a toleranced local requirement stays explicit.
+    Owner availability is decided by the caller, not by geometric coincidence.
+    """
+    return parameter.tolerance is None and _same_support_planes(
+        _support_planes(extent), _support_planes(parameter)
+    )
+
+
 def rotational_od_conveys_height(model: PartModel) -> bool:
     """An X/Y rotational OD conveys the overall height, so it is not drawn separately."""
     rot = next((f for f in model.features if f.kind == "rotational"), None)
@@ -586,31 +597,10 @@ def _consolidated_owner(model: PartModel, feature: Feature, param: DimParameter)
         if envelope.kind != "envelope":
             continue
         for extent in envelope.parameters():
-            if not _same_support_planes(_support_planes(extent), planes):
+            if not _extent_can_convey(extent, param):
                 continue
             if not _owner_drawn(model, envelope, extent):
                 continue
-            if param.tolerance is not None:
-                # A toleranced dimension and an untoleranced one are not the same
-                # requirement, so the overall extent cannot state this fact on its behalf.
-                # Consolidating anyway DELETED a ±0.05 the author had written, silently and
-                # with nothing in lint (#1154 review) — the one case where the feature-local
-                # dimension is the one a machinist needs.
-                #
-                # ASYMMETRIC, and about the YIELDER alone. A tolerance on the OWNER is not a
-                # problem — it is the same two faces, so it is the same requirement and one
-                # dimension states it. The first cut refused whenever the two DIFFERED, which
-                # brought the duplicate `8` back for anyone who toleranced the overall
-                # thickness: this issue's own defect, re-opened by its fix (review r2).
-                #
-                # The correction then went one step too far and admitted "equal tolerances on
-                # both sides", on the premise that the receiving extent states the same
-                # requirement. It does not, ever: measured, an envelope decoration is not
-                # rendered on any axis, while `render_boss_heights` appends `_tol_suffix`, so
-                # a boss height toleranced identically to its envelope lost its ± anyway
-                # (review r3). Whether the owner happens to print a tolerance is not this
-                # rule's business — a toleranced measurement is simply never handed over.
-                continue
             return DimensionId(envelope, extent.parameter_id)
     return None
 
@@ -1659,6 +1649,101 @@ def angular_pattern_label(group: DimensionGroup) -> str | None:
     return f"{len(dimensions)}× {next(iter(labels))}"
 
 
+def _selected_chain_covers_extent(model, selected, axis) -> bool:
+    """Require adjoining approved measurements between both overall ends of one profile."""
+    axis_index = "xyz".index(axis)
+    intervals: dict[tuple[tuple[float, ...], object], list[tuple[float, float]]] = {}
+    step_profiles = set()
+    for feature, length in selected:
+        if feature.kind not in ("step", "groove") or feature.frame.axis != axis:
+            continue
+        frame = feature.frame
+        key = (
+            tuple(
+                round(float(value), 6) for i, value in enumerate(frame.origin) if i != axis_index
+            ),
+            feature.profile or feature.profile_group,
+        )
+        if feature.kind == "step":
+            if length.span is None:
+                continue
+            lo, hi = sorted(float(point[axis_index]) for point in length.span)
+            step_profiles.add(key)
+        else:
+            centre = float(frame.origin[axis_index])
+            lo, hi = centre - length.value / 2, centre + length.value / 2
+        intervals.setdefault(key, []).append((lo, hi))
+
+    # Emitted declarations round supports to 0.001 mm. Keep that numerical seam
+    # tolerance, but do not join different bodies or merely overlapping spans:
+    # 0..40 and 20..60 do not tell the reader the overall length.
+    tolerance = 1e-3 + 1e-9
+    bb = model.bbox
+    for key in step_profiles:
+        reachable = [float(tuple(bb.min)[axis_index])]
+        for lo, hi in sorted(intervals[key]):
+            if any(abs(lo - station) <= tolerance for station in reachable):
+                reachable.append(hi)
+        if any(
+            abs(station - float(tuple(bb.max)[axis_index])) <= tolerance for station in reachable
+        ):
+            return True
+    return False
+
+
+def _restore_uncovered_x_extent(model, groups):
+    """Settle X-width ownership after the complete selected chain is known, before sizing."""
+    if model.orientation != "x" or not any(group.feature.kind == "envelope" for group in groups):
+        return groups
+    if _selected_chain_covers_extent(
+        model,
+        [
+            (group.feature, dimension.param)
+            for group in groups
+            if group.feature.kind in ("step", "groove")
+            for dimension in group.dims
+            if not dimension.suppressed and dimension.param.kind == "length"
+        ],
+        "x",
+    ):
+        return groups
+    restored = []
+    widths = []
+    for group in groups:
+        dimensions = []
+        for dimension in group.dims:
+            if group.feature.kind == "envelope" and dimension.param.parameter_id == "width.length":
+                if dimension.reason == "X-turned (step-length chain conveys the length)":
+                    dimension = replace(dimension, suppressed=False, reason=None)
+                if not dimension.suppressed:
+                    widths.append((dimension.param, DimensionId(group.feature, "width.length")))
+            dimensions.append(dimension)
+        restored.append(replace(group, units=_addressable(group.feature, dimensions)))
+    result = []
+    for group in restored:
+        dimensions = []
+        for dimension in group.dims:
+            parameter = dimension.param
+            if (
+                group.feature.kind == "boss"
+                and parameter.parameter_id == "boss_height.length"
+                and _request_for(model, group.feature, parameter) is None
+                and _authored_for(model, group.feature, parameter) is None
+            ):
+                for extent, owner in widths:
+                    if _extent_can_convey(extent, parameter):
+                        dimension = replace(
+                            dimension,
+                            suppressed=True,
+                            reason=dimension.reason if dimension.suppressed else _CONSOLIDATED,
+                            conveyed_by=owner,
+                        )
+                        break
+            dimensions.append(dimension)
+        result.append(replace(group, units=_addressable(group.feature, dimensions)))
+    return result
+
+
 def plan_dimensions(model: PartModel, *, planned_views=None) -> list[DimensionGroup]:
     """Plan each feature's parameters into one `DimensionGroup` (anchor + single
     view + planned dims, each carrying its render intent — convention, model-level
@@ -1725,18 +1810,25 @@ def plan_dimensions(model: PartModel, *, planned_views=None) -> list[DimensionGr
                 )
             )
         if dims:
-            selected_view, selected_side = _group_placement(feature, dims, planned_views)
             groups.append(
                 DimensionGroup(
                     feature=feature,
-                    # Preserve a total internal record while collecting every uncovered
-                    # identity below.  The exception prevents this preferred fallback from
-                    # crossing the planner boundary when it is not actually selected.
-                    view=selected_view or _preferred_group_view(feature),
+                    view=_preferred_group_view(feature),
                     units=_addressable(feature, dims),
-                    side=selected_side,
                 )
             )
+    groups = _restore_uncovered_x_extent(model, groups)
+    for index, group in enumerate(groups):
+        # Validate the final content: a consolidated height must not reject a
+        # supported end-on view requested for the remaining diameter.
+        selected_view, selected_side = _group_placement(
+            group.feature, list(group.dims), planned_views
+        )
+        groups[index] = replace(
+            group,
+            view=selected_view or _preferred_group_view(group.feature),
+            side=selected_side,
+        )
     if planned_views is not None:
         uncovered = _uncovered_group_requirements(model, groups, planned_views)
         uncovered.extend(_uncovered_location_requirements(model, planned_views))

{draftwright-0.4.23 → draftwright-0.4.24}/tests/test_declared_recognition_gate.py

@@ -333,9 +333,8 @@ def test_only_the_bosses_that_land_right_are_counted(declare, expected, why):
     assert _n_right_strip_boss_heights(model) == expected, why
 
 
-def test_a_turned_model_reserves_no_boss_height_slots():
-    """``render_boss_heights`` returns early for a turned part, so reserving for one there
-    would be dead page space."""
+def test_a_turned_model_without_bosses_reserves_no_boss_height_slots():
+    """A declared step chain without bosses needs no additional boss-height slots."""
     a, b, c = _turned_shaft_parts()
     sheet = Sheet(a + b + c).auto_dimensions()
     sheet.step(a)