From 3a034e2ed947d6ab6f2010b21c92b7efd03fe038 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Tue, 6 Oct 2026 18:41:17 +0000 Subject: [PATCH 1/5] Recover scale after optional section drop and nest PMI datum ladder --- src/draftwright/annotations/_axial_render.py | 66 ++++++++++ .../annotations/_pmi_dimensions.py | 7 +- src/draftwright/annotations/_step_lengths.py | 1 + src/draftwright/builder.py | 59 +++++++++ ...t_optional_section_scale_and_pmi_ladder.py | 117 ++++++++++++++++++ 5 files changed, 247 insertions(+), 3 deletions(-) create mode 100644 tests/test_optional_section_scale_and_pmi_ladder.py diff --git a/src/draftwright/annotations/_axial_render.py b/src/draftwright/annotations/_axial_render.py index a50c69fa..3586318d 100644 --- a/src/draftwright/annotations/_axial_render.py +++ b/src/draftwright/annotations/_axial_render.py @@ -31,11 +31,13 @@ from draftwright.annotations._common import ( _LOC_SUBCHAIN, CROSSABLE_TYPES, + PRIORITY, CorridorCandidate, Escalation, PlacementContext, _anno_box, _geom_box, + dim_footprint, prevent_dimension_label_ink, register_corridor, strip_obstacles, @@ -148,6 +150,7 @@ def _draw_step_chain( start=0, profile_bounds=None, placement_bounds=None, + baseline_positions=False, ) -> int: """Place a turned step-length chain in *view* from structured *segs*, each already projected to *view*'s page coords in axis order. Orientation is @@ -183,6 +186,69 @@ def _draw_step_chain( else _step_value_text(seg) + _tol_suffix(seg.tolerance, draft) for seg in segs ] + if baseline_positions and not horizontal: + # A datum-to-shoulder run is not a contiguous step chain. Register its + # vertical dimensions with PMI before the common corridor drain, so an + # authored intermediate station can be nested between the generated + # shoulder and overall spans. The old immediate batch had already + # consumed the near tiers by the time PMI arrived. + analysis = dwg._analysis + zones = getattr(analysis, {"front": "fv_zones", "side": "sv_zones"}.get(view, ""), None) + strip = getattr(zones, "right", None) if zones is not None else None + if strip is not None: + base_x = x1 + 2.0 + tier = draft.font_size + 2 * draft.pad_around_text + for i, (seg, label) in enumerate(zip(segs, labels, strict=True)): + name = f"{name_prefix}{start + i}" + low, high = sorted((seg.pa[1], seg.pb[1])) + + def _build(pos, low=low, high=high, label=label): + return _dim( + (base_x, low, 0), + (base_x, high, 0), + "right", + pos - base_x, + draft, + label=label, + ) + + def _footprint(pos, low=low, high=high, label=label): + return dim_footprint( + (base_x, low, 0), + (base_x, high, 0), + "right", + pos - base_x, + draft, + label, + ) + + def _drop(_name, measurements=seg.measurements): + _record_step_chain_drop( + "right-hand datum ladder has no clear tier", + ctx=ctx, + measurement=measurements, + ) + + register_corridor( + ctx, + (view, "right"), + strip, + view, + "x", + tier, + CorridorCandidate( + name=name, + build=_build, + order=(_LOC_SUBCHAIN, abs(high - low), name), + on_place=lambda _name: None, + on_drop=_drop, + force=True, + priority=PRIORITY.PRINCIPAL, + measurement=seg.measurements, + footprint=_footprint, + ), + ) + return len(segs) mean_v = sum(vals) / len(vals) explicit_display = any(seg.display_decimals is not None for seg in segs) tier_step = draft.font_size + 2 * draft.pad_around_text diff --git a/src/draftwright/annotations/_pmi_dimensions.py b/src/draftwright/annotations/_pmi_dimensions.py index 7dae0e65..f1f27cac 100644 --- a/src/draftwright/annotations/_pmi_dimensions.py +++ b/src/draftwright/annotations/_pmi_dimensions.py @@ -32,6 +32,7 @@ _segments_cross_or_overlap, ) from draftwright.annotations._common import ( + _LOC_SUBCHAIN, CROSSABLE_TYPES, PRIORITY, CorridorCandidate, @@ -154,7 +155,8 @@ def _bore_span_offsets(pmi_kind: str, value: float) -> tuple[float, float]: # PMI is pre-authored manufacturing intent from the STEP file. When a strip is over # capacity it should survive ahead of auto-generated dims (priority 0), like declared -# GD&T. It still lives in the outer run so it does not land between size/location dims. +# GD&T. Linear PMI shares the location ladder when its witness spans that axis; +# other authored PMI retains the outer run. _PMI_SUBCHAIN = 3 _PMI_CORRIDOR_PRIORITY = PRIORITY.AUTHORED _PMI_SLOT = 10.0 # mm — slot size for PMI dim lines in the strip @@ -502,7 +504,6 @@ def _pmi_dim_spec( if side in ("below", "left") and lo >= witness: return None - order_coord = min(perp) spec = { "name": name, "build": _PmiDimensionBuild(q1, q2, side, witness, label, draft, basic), @@ -511,7 +512,7 @@ def _pmi_dim_spec( "side": side, "axis": axis, "perp": perp, - "order": (_PMI_SUBCHAIN, order_coord, name), + "order": (_LOC_SUBCHAIN, abs(perp[1] - perp[0]), name), } if leader_fallback: diff --git a/src/draftwright/annotations/_step_lengths.py b/src/draftwright/annotations/_step_lengths.py index f0244d60..37cea327 100644 --- a/src/draftwright/annotations/_step_lengths.py +++ b/src/draftwright/annotations/_step_lengths.py @@ -529,6 +529,7 @@ def _render_single_profile( start=start, profile_bounds=profile_bounds, placement_bounds=_profile_bounds_hint, + baseline_positions=True, ) y_result = _render_y_profile( diff --git a/src/draftwright/builder.py b/src/draftwright/builder.py index 1b2a5093..375c7b80 100644 --- a/src/draftwright/builder.py +++ b/src/draftwright/builder.py @@ -2367,6 +2367,64 @@ def recover_required_no_iso(self): self.settled_issues = recovered_issues self.replanned = True + def recover_scale_from_dropped_section(self): + """Do not let an unrealised optional section cap the principal-view scale. + + The initial estimate must reserve a planned section (it may really fit), + but a section that was ultimately dropped is no longer a reason to keep + the smaller scale. Probe only the next standard scale on the same sheet, + and only when removing that reservation makes the estimate fit. The + complete rebuilt drawing still has to pass the ordinary qualification. + """ + if not (self.dimensions_are_automatic and self.views_are_automatic): + return + if not any( + issue.code == "section_dropped" + for issue in self.context.placement_issues(self.drawing) + ): + return + analysis = self.context.latest_analysis + if analysis is None or not analysis.layout_section: + return + larger = sorted(value for value in _SCALES if value > self.drawing.scale) + if not larger: + return + candidate_scale = larger[0] + page_w, page_h = self.original_page + geometry = _layout_geometry( + analysis.x_size, + analysis.y_size, + analysis.z_size, + candidate_scale, + page_w, + page_h, + analysis.TB_W, + analysis.layout_strips, + analysis.layout_n_steps, + section=False, + table_sizes=analysis.layout_table_sizes, + required_tables=analysis.layout_required_tables, + warn_no_iso=False, + title_block_margins=analysis.title_block_margins, + margin=_analysis_margins(analysis), + arrangement=self.settled_arrangement, + views=self.settled_principal_views, + include_iso=analysis.planned_iso, + iso_scale_factor=analysis.planned_iso_scale, + convention=analysis.projection_convention, + ) + if not geometry.auto_fits: + return + recovered, recovered_issues = self.trials.try_scales_on_selected_page( + (candidate_scale,), + reason="optional_section_scale_recovery", + require_axial_coverage=False, + ) + if recovered is not None: + self.drawing = recovered + self.settled_issues = recovered_issues + self.replanned = True + def recover_optional_iso(self): # A pictorial view is useful context, but it cannot outrank the # dimensions or other required annotations needed to manufacture a part. @@ -2654,6 +2712,7 @@ def run(self) -> Drawing: self.settle_arrangement() self.prepare_trials() self.recover_detail() + self.recover_scale_from_dropped_section() self.recover_hard_layout() self.recover_required_no_iso() self.recover_optional_iso() diff --git a/tests/test_optional_section_scale_and_pmi_ladder.py b/tests/test_optional_section_scale_and_pmi_ladder.py new file mode 100644 index 00000000..78a746ee --- /dev/null +++ b/tests/test_optional_section_scale_and_pmi_ladder.py @@ -0,0 +1,117 @@ +"""Optional section scale recovery and a shared authored/generated datum ladder.""" + +from types import SimpleNamespace + +from draftwright._core import Strip +from draftwright.annotations._axial_render import _draw_step_chain, _StepChainSegment +from draftwright.annotations._common import PlacementContext +from draftwright.annotations._pmi_dimensions import _pmi_dim_spec +from draftwright.builder import _AutomaticResolution + + +def test_vertical_baseline_steps_and_imported_pmi_share_span_order(): + draft = SimpleNamespace(font_size=3.0, pad_around_text=1.0) + strip = Strip(anchor=105.0, outer_limit=160.0) + drawing = SimpleNamespace( + draft=draft, + _analysis=SimpleNamespace(fv_zones=SimpleNamespace(right=strip)), + view_bounds=lambda _view: (80.0, 50.0, 103.0, 160.0), + ) + ctx = PlacementContext() + segments = [ + _StepChainSegment((100.0, 50.0, 0), (100.0, 74.0, 0), 12.0), + _StepChainSegment((100.0, 50.0, 0), (100.0, 154.0, 0), 52.0), + ] + + assert ( + _draw_step_chain(drawing, "front", segments, "m_steplen", ctx=ctx, baseline_positions=True) + == 2 + ) + pmi = _pmi_dim_spec( + (100.0, 50.0, 0), + (100.0, 118.0, 0), + strip, + "34 ±0.05", + "pmi_z_0", + "front", + "right", + draft, + ) + assert pmi is not None + queued = ctx.corridor_batch[("front", "right")]["cands"] + orders = [(candidate.name, candidate.order) for candidate in queued] + orders.append((pmi["name"], pmi["order"])) + assert [name for name, _order in sorted(orders, key=lambda item: item[1])] == [ + "m_steplen0", + "pmi_z_0", + "m_steplen1", + ] + + +def test_dropped_optional_section_can_recover_next_scale_without_larger_sheet(monkeypatch): + import draftwright.builder as builder + + analysis = SimpleNamespace( + layout_section=1, + x_size=24.0, + y_size=24.0, + z_size=52.0, + TB_W=150.0, + layout_strips=None, + layout_n_steps=2, + layout_table_sizes=(), + layout_required_tables=(), + title_block_margins=None, + margin=5.0, + planned_iso=True, + planned_iso_scale=None, + projection_convention="third", + ) + context = SimpleNamespace( + latest_analysis=analysis, + placement_issues=lambda _drawing: (SimpleNamespace(code="section_dropped"),), + ) + recovery = _AutomaticResolution(context=context, views_are_automatic=True) + recovery.dimensions_are_automatic = True + recovery.drawing = SimpleNamespace(scale=1.0) + recovery.original_page = (420.0, 297.0) + recovery.settled_principal_views = ("front", "plan", "side") + calls = [] + winner = SimpleNamespace(scale=2.0) + recovery.trials = SimpleNamespace( + try_scales_on_selected_page=lambda scales, **kwargs: ( + calls.append((scales, kwargs)) or winner, + (), + ) + ) + monkeypatch.setattr( + builder, "_layout_geometry", lambda *args, **kwargs: SimpleNamespace(auto_fits=True) + ) + + recovery.recover_scale_from_dropped_section() + + assert recovery.drawing is winner + assert recovery.replanned + assert calls == [ + ( + (2.0,), + { + "reason": "optional_section_scale_recovery", + "require_axial_coverage": False, + }, + ) + ] + + # An optional section is not a license to try an enlarged principal layout + # that still cannot fit after its reservation is removed. + recovery.drawing = SimpleNamespace(scale=1.0) + recovery.replanned = False + monkeypatch.setattr( + builder, + "_layout_geometry", + lambda *args, **kwargs: SimpleNamespace(auto_fits=False), + ) + recovery.recover_scale_from_dropped_section() + assert recovery.drawing.scale == 1.0 + assert not recovery.replanned + assert len(calls) == 1 From eb72fbcf26047c67298fc9dc7d1126af97ed4c84 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Tue, 6 Oct 2026 19:04:30 +0000 Subject: [PATCH 2/5] Address scale recovery review blockers --- docs/architecture.md | 2 + src/draftwright/annotations/_axial_render.py | 154 +++++++----------- .../annotations/_baseline_step_ladder.py | 71 ++++++++ src/draftwright/builder.py | 74 ++------- src/draftwright/section_scale_recovery.py | 108 ++++++++++++ tests/_complexity_baseline.json | 1 - tests/test_import_boundaries.py | 1 + ...t_optional_section_scale_and_pmi_ladder.py | 71 +++++++- 8 files changed, 319 insertions(+), 163 deletions(-) create mode 100644 src/draftwright/annotations/_baseline_step_ladder.py create mode 100644 src/draftwright/section_scale_recovery.py diff --git a/docs/architecture.md b/docs/architecture.md index b84a7097..53c94b83 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -116,6 +116,8 @@ and re-exports the existing private helper names. - **`build_policy.py`** — rank-6 finished-drawing scale and arrangement decisions: required-outcome blockers, structural validity, candidate quality, and stable decision records. `builder.py` keeps the automatic retry ladder and its constants. + - **`section_scale_recovery.py`** — rank-6 bounded same-sheet scale recovery after an + optional section drops, including a finished requirement comparison. - **`explicit_scale.py`** — rank-6 resolution of a caller-requested scale: automatic-view veto, strict and permissive decisions, and bounded standard-scale fallback. The builder supplies its build and critique seams and current scale ladder. diff --git a/src/draftwright/annotations/_axial_render.py b/src/draftwright/annotations/_axial_render.py index 3586318d..da178eb5 100644 --- a/src/draftwright/annotations/_axial_render.py +++ b/src/draftwright/annotations/_axial_render.py @@ -28,16 +28,15 @@ _tol_suffix, supported_secondary_crop, ) +from draftwright.annotations._baseline_step_ladder import register_vertical_baseline_steps from draftwright.annotations._common import ( _LOC_SUBCHAIN, CROSSABLE_TYPES, - PRIORITY, CorridorCandidate, Escalation, PlacementContext, _anno_box, _geom_box, - dim_footprint, prevent_dimension_label_ink, register_corridor, strip_obstacles, @@ -138,6 +137,42 @@ def _record_step_chain_drop(why: str, *, ctx, measurement=()) -> None: ) +def _horizontal_step_tiers(segments, labels, draft): + centres_and_widths = [ + ( + (segment.pa[0] + segment.pb[0]) / 2, + len(label) * draft.font_size * _EST_CHAR_WIDTH_EM, + ) + for segment, label in zip(segments, labels, strict=True) + ] + + def clear(items): + return all( + second_centre - first_centre + >= (first_width + second_width) / 2 + draft.pad_around_text + for (first_centre, first_width), (second_centre, second_width) in zip( + items, items[1:], strict=False + ) + ) + + if clear(centres_and_widths): + return [0] * len(segments) + if clear(centres_and_widths[0::2]) and clear(centres_and_widths[1::2]): + return [index % 2 for index in range(len(segments))] + return None + + +def _drop_dense_step_chain(ctx, segments, event, prefix): + _log.info("step-length chain skipped: too dense even when staggered") + _record_step_chain_drop( + "shoulders too dense to dimension even when staggered", + ctx=ctx, + measurement=_step_measurements(segments), + ) + if event is not None: + event["items"].append({"name": prefix, "outcome": "dropped", "reason": "too_dense"}) + + def _draw_step_chain( dwg, view, @@ -187,68 +222,23 @@ def _draw_step_chain( for seg in segs ] if baseline_positions and not horizontal: - # A datum-to-shoulder run is not a contiguous step chain. Register its - # vertical dimensions with PMI before the common corridor drain, so an - # authored intermediate station can be nested between the generated - # shoulder and overall spans. The old immediate batch had already - # consumed the near tiers by the time PMI arrived. - analysis = dwg._analysis - zones = getattr(analysis, {"front": "fv_zones", "side": "sv_zones"}.get(view, ""), None) - strip = getattr(zones, "right", None) if zones is not None else None - if strip is not None: - base_x = x1 + 2.0 - tier = draft.font_size + 2 * draft.pad_around_text - for i, (seg, label) in enumerate(zip(segs, labels, strict=True)): - name = f"{name_prefix}{start + i}" - low, high = sorted((seg.pa[1], seg.pb[1])) - - def _build(pos, low=low, high=high, label=label): - return _dim( - (base_x, low, 0), - (base_x, high, 0), - "right", - pos - base_x, - draft, - label=label, - ) - - def _footprint(pos, low=low, high=high, label=label): - return dim_footprint( - (base_x, low, 0), - (base_x, high, 0), - "right", - pos - base_x, - draft, - label, - ) - - def _drop(_name, measurements=seg.measurements): - _record_step_chain_drop( - "right-hand datum ladder has no clear tier", - ctx=ctx, - measurement=measurements, - ) - - register_corridor( - ctx, - (view, "right"), - strip, - view, - "x", - tier, - CorridorCandidate( - name=name, - build=_build, - order=(_LOC_SUBCHAIN, abs(high - low), name), - on_place=lambda _name: None, - on_drop=_drop, - force=True, - priority=PRIORITY.PRINCIPAL, - measurement=seg.measurements, - footprint=_footprint, - ), - ) - return len(segs) + registered = register_vertical_baseline_steps( + dwg, + view, + segs, + labels, + name_prefix, + start, + vb, + ctx, + lambda measurements: _record_step_chain_drop( + "right-hand datum ladder has no clear tier", + ctx=ctx, + measurement=measurements, + ), + ) + if registered is not None: + return registered mean_v = sum(vals) / len(vals) explicit_display = any(seg.display_decimals is not None for seg in segs) tier_step = draft.font_size + 2 * draft.pad_around_text @@ -275,38 +265,10 @@ def _drop(_name, measurements=seg.measurements): typ_name = f"{name_prefix}_typ" if start == 0 else f"{name_prefix}_typ{start}" candidates = [(typ_name, dim, _step_measurements(segs))] else: - tiers = [0] * len(segs) - if horizontal: - cw = [ - ( - (seg.pa[0] + seg.pb[0]) / 2, - len(labels[i]) * draft.font_size * _EST_CHAR_WIDTH_EM, - ) - for i, seg in enumerate(segs) - ] - - def _clear(items): - return all( - c2 - c1 >= (w1 + w2) / 2 + draft.pad_around_text - for (c1, w1), (c2, w2) in zip(items, items[1:], strict=False) - ) - - if _clear(cw): - pass - elif _clear(cw[0::2]) and _clear(cw[1::2]): - tiers = [i % 2 for i in range(len(segs))] - else: - _log.info("step-length chain skipped: too dense even when staggered") - _record_step_chain_drop( - "shoulders too dense to dimension even when staggered", - ctx=ctx, - measurement=_step_measurements(segs), - ) - if ev is not None: - ev["items"].append( - {"name": name_prefix, "outcome": "dropped", "reason": "too_dense"} - ) - return 0 + tiers = _horizontal_step_tiers(segs, labels, draft) if horizontal else [0] * len(segs) + if tiers is None: + _drop_dense_step_chain(ctx, segs, ev, name_prefix) + return 0 # A short vertical shoulder is not a density test for the whole chain. # Helpers can draw outside arrows, and the shared batch solver below # checks actual labels/ink and offers the same far tier on either axis. diff --git a/src/draftwright/annotations/_baseline_step_ladder.py b/src/draftwright/annotations/_baseline_step_ladder.py new file mode 100644 index 00000000..e45fbfdf --- /dev/null +++ b/src/draftwright/annotations/_baseline_step_ladder.py @@ -0,0 +1,71 @@ +"""Datum-referenced turned steps in the shared vertical dimension corridor.""" + +from draftwright._core import _dim +from draftwright.annotations._common import ( + _LOC_SUBCHAIN, + PRIORITY, + CorridorCandidate, + dim_footprint, + register_corridor, +) + + +def register_vertical_baseline_steps( + dwg, view, segments, labels, prefix, start, bounds, ctx, report_drop +): + analysis = dwg._analysis + zones = getattr(analysis, {"front": "fv_zones", "side": "sv_zones"}.get(view, ""), None) + strip = getattr(zones, "right", None) if zones is not None else None + if strip is None: + return None + + draft = dwg.draft + base_x = bounds[2] + 2.0 + tier = draft.font_size + 2 * draft.pad_around_text + for index, (segment, label) in enumerate(zip(segments, labels, strict=True)): + name = f"{prefix}{start + index}" + low, high = sorted((segment.pa[1], segment.pb[1])) + + def build(position, low=low, high=high, label=label): + return _dim( + (base_x, low, 0), + (base_x, high, 0), + "right", + position - base_x, + draft, + label=label, + ) + + def footprint(position, low=low, high=high, label=label): + return dim_footprint( + (base_x, low, 0), + (base_x, high, 0), + "right", + position - base_x, + draft, + label, + ) + + def drop(_name, measurements=segment.measurements): + report_drop(measurements) + + register_corridor( + ctx, + (view, "right"), + strip, + view, + "x", + tier, + CorridorCandidate( + name=name, + build=build, + order=(_LOC_SUBCHAIN, abs(high - low), name), + on_place=lambda _name: None, + on_drop=drop, + force=True, + priority=PRIORITY.PRINCIPAL, + measurement=segment.measurements, + footprint=footprint, + ), + ) + return len(segments) diff --git a/src/draftwright/builder.py b/src/draftwright/builder.py index 375c7b80..97557d63 100644 --- a/src/draftwright/builder.py +++ b/src/draftwright/builder.py @@ -149,6 +149,10 @@ _project_iso, ) from draftwright.recognition_cache import RecognitionCache +from draftwright.section_scale_recovery import ( + preserves_recognized_requirements, + recover_dropped_section_scale, +) from draftwright.view_plan import ( ARRANGEMENTS, PRINCIPAL_VIEW_NAMES, @@ -1706,7 +1710,9 @@ def try_larger_standard_pages( ) return None, None - def try_scales_on_selected_page(self, candidate_scales, *, reason, require_axial_coverage): + def try_scales_on_selected_page( + self, candidate_scales, *, reason, require_axial_coverage, requirement_floor=None + ): """Try a bounded scale sequence on the already selected sheet.""" for candidate_scale in candidate_scales: analysis = self.latest_analysis() @@ -1769,6 +1775,12 @@ def try_scales_on_selected_page(self, candidate_scales, *, reason, require_axial candidate_drawing, require_axial_coverage=require_axial_coverage, ) + if ( + rejection is None + and requirement_floor is not None + and not preserves_recognized_requirements(requirement_floor, candidate_drawing) + ): + rejection = "recognized_requirement_regression" if rejection is None: self.record_attempt( candidate_scale, "complete", reason=reason, candidate=candidate_drawing @@ -2367,64 +2379,6 @@ def recover_required_no_iso(self): self.settled_issues = recovered_issues self.replanned = True - def recover_scale_from_dropped_section(self): - """Do not let an unrealised optional section cap the principal-view scale. - - The initial estimate must reserve a planned section (it may really fit), - but a section that was ultimately dropped is no longer a reason to keep - the smaller scale. Probe only the next standard scale on the same sheet, - and only when removing that reservation makes the estimate fit. The - complete rebuilt drawing still has to pass the ordinary qualification. - """ - if not (self.dimensions_are_automatic and self.views_are_automatic): - return - if not any( - issue.code == "section_dropped" - for issue in self.context.placement_issues(self.drawing) - ): - return - analysis = self.context.latest_analysis - if analysis is None or not analysis.layout_section: - return - larger = sorted(value for value in _SCALES if value > self.drawing.scale) - if not larger: - return - candidate_scale = larger[0] - page_w, page_h = self.original_page - geometry = _layout_geometry( - analysis.x_size, - analysis.y_size, - analysis.z_size, - candidate_scale, - page_w, - page_h, - analysis.TB_W, - analysis.layout_strips, - analysis.layout_n_steps, - section=False, - table_sizes=analysis.layout_table_sizes, - required_tables=analysis.layout_required_tables, - warn_no_iso=False, - title_block_margins=analysis.title_block_margins, - margin=_analysis_margins(analysis), - arrangement=self.settled_arrangement, - views=self.settled_principal_views, - include_iso=analysis.planned_iso, - iso_scale_factor=analysis.planned_iso_scale, - convention=analysis.projection_convention, - ) - if not geometry.auto_fits: - return - recovered, recovered_issues = self.trials.try_scales_on_selected_page( - (candidate_scale,), - reason="optional_section_scale_recovery", - require_axial_coverage=False, - ) - if recovered is not None: - self.drawing = recovered - self.settled_issues = recovered_issues - self.replanned = True - def recover_optional_iso(self): # A pictorial view is useful context, but it cannot outrank the # dimensions or other required annotations needed to manufacture a part. @@ -2712,7 +2666,7 @@ def run(self) -> Drawing: self.settle_arrangement() self.prepare_trials() self.recover_detail() - self.recover_scale_from_dropped_section() + recover_dropped_section_scale(self) self.recover_hard_layout() self.recover_required_no_iso() self.recover_optional_iso() diff --git a/src/draftwright/section_scale_recovery.py b/src/draftwright/section_scale_recovery.py new file mode 100644 index 00000000..de3477ff --- /dev/null +++ b/src/draftwright/section_scale_recovery.py @@ -0,0 +1,108 @@ +"""Same-sheet scale recovery when a planned optional section did not render.""" + +from draftwright._core import _SCALES, _analysis_margins +from draftwright.compose import _layout_geometry +from draftwright.reporting import ReportUnavailableError + +_PLACED_STATES = frozenset({"placed", "satisfied_by_structured_note"}) + + +def next_scale_without_section(analysis, current_scale, page, arrangement, views): + larger = sorted(value for value in _SCALES if value > current_scale) + if not larger: + return None + candidate_scale = larger[0] + page_width, page_height = page + geometry = _layout_geometry( + analysis.x_size, + analysis.y_size, + analysis.z_size, + candidate_scale, + page_width, + page_height, + analysis.TB_W, + analysis.layout_strips, + analysis.layout_n_steps, + section=False, + table_sizes=analysis.layout_table_sizes, + required_tables=analysis.layout_required_tables, + warn_no_iso=False, + title_block_margins=analysis.title_block_margins, + margin=_analysis_margins(analysis), + arrangement=arrangement, + views=views, + include_iso=analysis.planned_iso, + iso_scale_factor=analysis.planned_iso_scale, + convention=analysis.projection_convention, + ) + return candidate_scale if geometry.auto_fits else None + + +def preserves_recognized_requirements(original, candidate): + """Keep every recognized requirement satisfied by the smaller drawing.""" + try: + original_rows = original.report()["recognition"]["requirements"] + candidate_rows = candidate.report()["recognition"]["requirements"] + except (ReportUnavailableError, KeyError, TypeError): + return False + if not isinstance(original_rows, list) or not isinstance(candidate_rows, list): + return False + + def identity(row): + return ( + row["id"], + row["family"], + row["parameter_id"], + tuple(row["occurrence_ids"]), + tuple(row["owner_ids"]), + ) + + try: + previous = {identity(row): row["state"] for row in original_rows} + proposed = {identity(row): row["state"] for row in candidate_rows} + except (KeyError, TypeError): + return False + if ( + len(previous) != len(original_rows) + or len(proposed) != len(candidate_rows) + or previous.keys() != proposed.keys() + ): + return False + return all( + (state not in _PLACED_STATES or proposed[key] in _PLACED_STATES) + and (state != "inapplicable" or proposed[key] == "inapplicable") + for key, state in previous.items() + ) + + +def recover_dropped_section_scale(resolution): + """Try one larger same-sheet scale after an optional section actually drops.""" + if not (resolution.dimensions_are_automatic and resolution.views_are_automatic): + return + if not any( + issue.code == "section_dropped" + for issue in resolution.context.placement_issues(resolution.drawing) + ): + return + analysis = resolution.context.latest_analysis + if analysis is None or not analysis.layout_section: + return + candidate_scale = next_scale_without_section( + analysis, + resolution.drawing.scale, + resolution.original_page, + resolution.settled_arrangement, + resolution.settled_principal_views, + ) + if candidate_scale is None: + return + recovered, recovered_issues = resolution.trials.try_scales_on_selected_page( + (candidate_scale,), + reason="optional_section_scale_recovery", + require_axial_coverage=False, + requirement_floor=resolution.drawing, + ) + if recovered is not None: + resolution.drawing = recovered + resolution.settled_issues = recovered_issues + resolution.replanned = True diff --git a/tests/_complexity_baseline.json b/tests/_complexity_baseline.json index 97584806..bfd3b98d 100644 --- a/tests/_complexity_baseline.json +++ b/tests/_complexity_baseline.json @@ -7,7 +7,6 @@ "_pmi_part21.py:read_dimension_display_facts": 23, "_pmi_part21.py:read_dimension_length_factor": 16, "_pmi_part21.py:read_surface_labels": 23, - "annotations/_axial_render.py:_draw_step_chain": 17, "annotations/_axial_render.py:render_rotational": 16, "annotations/_common.py:_adjust_strip_candidate_labels": 20, "annotations/_common.py:_drain_interior_dimensions": 24, diff --git a/tests/test_import_boundaries.py b/tests/test_import_boundaries.py index f14a1569..bc386832 100644 --- a/tests/test_import_boundaries.py +++ b/tests/test_import_boundaries.py @@ -188,6 +188,7 @@ def _tree(path: Path) -> ast.Module: "drawing": 5, # 6 — build orchestration "builder": 6, + "section_scale_recovery": 6, "build_once": 6, "build_policy": 6, "explicit_scale": 6, diff --git a/tests/test_optional_section_scale_and_pmi_ladder.py b/tests/test_optional_section_scale_and_pmi_ladder.py index 78a746ee..fe5987b7 100644 --- a/tests/test_optional_section_scale_and_pmi_ladder.py +++ b/tests/test_optional_section_scale_and_pmi_ladder.py @@ -6,7 +6,11 @@ from draftwright.annotations._axial_render import _draw_step_chain, _StepChainSegment from draftwright.annotations._common import PlacementContext from draftwright.annotations._pmi_dimensions import _pmi_dim_spec -from draftwright.builder import _AutomaticResolution +from draftwright.builder import _AutomaticResolution, _AutomaticScaleTrials +from draftwright.section_scale_recovery import ( + preserves_recognized_requirements, + recover_dropped_section_scale, +) def test_vertical_baseline_steps_and_imported_pmi_share_span_order(): @@ -49,7 +53,7 @@ def test_vertical_baseline_steps_and_imported_pmi_share_span_order(): def test_dropped_optional_section_can_recover_next_scale_without_larger_sheet(monkeypatch): - import draftwright.builder as builder + import draftwright.section_scale_recovery as recovery_module analysis = SimpleNamespace( layout_section=1, @@ -85,10 +89,13 @@ def test_dropped_optional_section_can_recover_next_scale_without_larger_sheet(mo ) ) monkeypatch.setattr( - builder, "_layout_geometry", lambda *args, **kwargs: SimpleNamespace(auto_fits=True) + recovery_module, + "_layout_geometry", + lambda *args, **kwargs: SimpleNamespace(auto_fits=True), ) - recovery.recover_scale_from_dropped_section() + original = recovery.drawing + recover_dropped_section_scale(recovery) assert recovery.drawing is winner assert recovery.replanned @@ -98,6 +105,7 @@ def test_dropped_optional_section_can_recover_next_scale_without_larger_sheet(mo { "reason": "optional_section_scale_recovery", "require_axial_coverage": False, + "requirement_floor": original, }, ) ] @@ -107,11 +115,62 @@ def test_dropped_optional_section_can_recover_next_scale_without_larger_sheet(mo recovery.drawing = SimpleNamespace(scale=1.0) recovery.replanned = False monkeypatch.setattr( - builder, + recovery_module, "_layout_geometry", lambda *args, **kwargs: SimpleNamespace(auto_fits=False), ) - recovery.recover_scale_from_dropped_section() + recover_dropped_section_scale(recovery) assert recovery.drawing.scale == 1.0 assert not recovery.replanned assert len(calls) == 1 + + +def test_section_scale_trial_rejects_a_newly_missing_recognized_requirement(): + def drawing(scale, states): + rows = [ + { + "id": f"requirement:{index}", + "family": "turned_steps", + "parameter_id": "step.length", + "occurrence_ids": [f"turned_steps:{index}"], + "owner_ids": [f"step:{index}"], + "state": state, + } + for index, state in enumerate(states, start=1) + ] + return SimpleNamespace( + scale=scale, + page_w=420.0, + page_h=297.0, + views={"front": object()}, + report=lambda: {"recognition": {"requirements": rows}}, + ) + + original = drawing(1.0, ("placed", "missing")) + worse = drawing(2.0, ("missing", "missing")) + equal = drawing(2.0, ("placed", "missing")) + better = drawing(2.0, ("placed", "placed")) + assert not preserves_recognized_requirements(original, worse) + assert preserves_recognized_requirements(original, equal) + assert preserves_recognized_requirements(original, better) + + attempts = [] + trial = _AutomaticScaleTrials( + build=lambda *_args, **_kwargs: worse, + record_attempt=lambda *args, **kwargs: attempts.append((args, kwargs)), + qualify=lambda *_args, **_kwargs: ((), (), None), + retain_arrangement=lambda candidate: candidate, + current_drawing=lambda: original, + latest_analysis=lambda: None, + settled_arrangement="columns", + settled_principal_views=("front",), + original_page=(420.0, 297.0), + ) + result, _issues = trial.try_scales_on_selected_page( + (2.0,), + reason="optional_section_scale_recovery", + require_axial_coverage=False, + requirement_floor=original, + ) + assert result is None + assert attempts[-1][1]["rejection"] == "recognized_requirement_regression" From 877d09d48c9ff6e98fe69fc91cc0ac9d93032edd Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Tue, 6 Oct 2026 19:42:59 +0000 Subject: [PATCH 3/5] Thread baseline ladder analysis through placement context --- src/draftwright/annotations/_baseline_step_ladder.py | 4 ++-- src/draftwright/annotations/_common.py | 3 +++ src/draftwright/annotations/orchestrator.py | 1 + tests/test_optional_section_scale_and_pmi_ladder.py | 3 +-- 4 files changed, 7 insertions(+), 4 deletions(-) diff --git a/src/draftwright/annotations/_baseline_step_ladder.py b/src/draftwright/annotations/_baseline_step_ladder.py index e45fbfdf..43bb7a55 100644 --- a/src/draftwright/annotations/_baseline_step_ladder.py +++ b/src/draftwright/annotations/_baseline_step_ladder.py @@ -12,8 +12,8 @@ def register_vertical_baseline_steps( dwg, view, segments, labels, prefix, start, bounds, ctx, report_drop -): - analysis = dwg._analysis +) -> int | None: + analysis = ctx.analysis zones = getattr(analysis, {"front": "fv_zones", "side": "sv_zones"}.get(view, ""), None) strip = getattr(zones, "right", None) if zones is not None else None if strip is None: diff --git a/src/draftwright/annotations/_common.py b/src/draftwright/annotations/_common.py index 8f7d8317..de599de3 100644 --- a/src/draftwright/annotations/_common.py +++ b/src/draftwright/annotations/_common.py @@ -1347,6 +1347,9 @@ class PlacementContext: # The drawing's render list: :meth:`place` appends here, so a render pass places an # annotation through the ctx seam (``ctx.place(...)``) instead of reaching into the drawing. items: Any = None + # Build analysis is passed to render passes explicitly, never read from a + # Drawing private. The baseline step ladder uses its shared view strips. + analysis: Any = None # The ensured PartModel (ADR 1 (was 0008) IR) the run's passes read, threaded off the drawing so # they do not reach into ``dwg._part_model``. Both entry paths set it from the # PUBLIC ``dwg.model()`` after the model is ensured/attached. diff --git a/src/draftwright/annotations/orchestrator.py b/src/draftwright/annotations/orchestrator.py index ebac8176..16d1dd98 100644 --- a/src/draftwright/annotations/orchestrator.py +++ b/src/draftwright/annotations/orchestrator.py @@ -1058,6 +1058,7 @@ def _auto_annotate(dwg: DrawingPort, a: Analysis, *, detail_view: bool = False): registry=dwg.registry, coverage=dwg.coverage, items=dwg.items, # passes place via ctx.place, not dwg.add + analysis=a, # The opt-in solve-trace recorder is attached to the drawing's build state # by the builder; getattr because dwg is duck-typed in tests. None = off. trace=getattr(dwg, "solve_trace", None), diff --git a/tests/test_optional_section_scale_and_pmi_ladder.py b/tests/test_optional_section_scale_and_pmi_ladder.py index fe5987b7..62248804 100644 --- a/tests/test_optional_section_scale_and_pmi_ladder.py +++ b/tests/test_optional_section_scale_and_pmi_ladder.py @@ -18,10 +18,9 @@ def test_vertical_baseline_steps_and_imported_pmi_share_span_order(): strip = Strip(anchor=105.0, outer_limit=160.0) drawing = SimpleNamespace( draft=draft, - _analysis=SimpleNamespace(fv_zones=SimpleNamespace(right=strip)), view_bounds=lambda _view: (80.0, 50.0, 103.0, 160.0), ) - ctx = PlacementContext() + ctx = PlacementContext(analysis=SimpleNamespace(fv_zones=SimpleNamespace(right=strip))) segments = [ _StepChainSegment((100.0, 50.0, 0), (100.0, 74.0, 0), 12.0), _StepChainSegment((100.0, 50.0, 0), (100.0, 154.0, 0), 52.0), From ecc73001b41527b11cb959e9dcb628764ddd3506 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Tue, 6 Oct 2026 20:30:55 +0000 Subject: [PATCH 4/5] Route new layout tests and respect source shape budget --- src/draftwright/annotations/orchestrator.py | 1 - tests/_tier_manifest.py | 7 +++++++ tests/test_tier_manifest.py | 1 + 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/draftwright/annotations/orchestrator.py b/src/draftwright/annotations/orchestrator.py index 16d1dd98..ae91fc31 100644 --- a/src/draftwright/annotations/orchestrator.py +++ b/src/draftwright/annotations/orchestrator.py @@ -1071,7 +1071,6 @@ def _auto_annotate(dwg: DrawingPort, a: Analysis, *, detail_view: bool = False): # not accumulate duplicate drop records. ctx.reset_issues() ctx.coverage.reset_dropped() - # Tighten right-strip outer_limits to the actual iso view left edge now # that the iso has been projected and fitted. Always apply so that any # future allocations are bounded; warn when the cursor has already passed diff --git a/tests/_tier_manifest.py b/tests/_tier_manifest.py index 14289ab6..09a5fb3b 100644 --- a/tests/_tier_manifest.py +++ b/tests/_tier_manifest.py @@ -162,6 +162,13 @@ class ContractGroup: "test_issue_1357_plural_turned_profiles.py", ), ), + "optional_section_scale_and_pmi_ladder": ContractGroup( + ( + "src/draftwright/section_scale_recovery.py", + "src/draftwright/annotations/_baseline_step_ladder.py", + ), + ("test_optional_section_scale_and_pmi_ladder.py",), + ), "height_ladder": ContractGroup( ( "src/draftwright/annotations/_height_ladder.py", diff --git a/tests/test_tier_manifest.py b/tests/test_tier_manifest.py index 896f0c2f..7766a607 100644 --- a/tests/test_tier_manifest.py +++ b/tests/test_tier_manifest.py @@ -175,6 +175,7 @@ def test_each_named_contract_group_resolves_to_existing_modules(): "hole_family_evidence": "src/draftwright/evaluation/_hole_family_evidence.py", "step_observers": "src/draftwright/evaluation/step_analysis.py", "through_step_placement": "src/draftwright/annotations/from_model.py", + "optional_section_scale_and_pmi_ladder": "src/draftwright/section_scale_recovery.py", "height_ladder": "src/draftwright/annotations/_height_ladder.py", "solve_trace": "src/draftwright/annotations/solve_trace.py", "angular_ink": "src/draftwright/annotations/angular.py", From 9dd05cc5259e32296c0be00150e2ad57b3365f75 Mon Sep 17 00:00:00 2001 From: Paul Fremantle Date: Tue, 6 Oct 2026 21:00:35 +0000 Subject: [PATCH 5/5] Cover optional section scale and datum ladder edge cases --- ...t_optional_section_scale_and_pmi_ladder.py | 110 ++++++++++++++++++ 1 file changed, 110 insertions(+) diff --git a/tests/test_optional_section_scale_and_pmi_ladder.py b/tests/test_optional_section_scale_and_pmi_ladder.py index 62248804..958c71a2 100644 --- a/tests/test_optional_section_scale_and_pmi_ladder.py +++ b/tests/test_optional_section_scale_and_pmi_ladder.py @@ -4,6 +4,7 @@ from draftwright._core import Strip from draftwright.annotations._axial_render import _draw_step_chain, _StepChainSegment +from draftwright.annotations._baseline_step_ladder import register_vertical_baseline_steps from draftwright.annotations._common import PlacementContext from draftwright.annotations._pmi_dimensions import _pmi_dim_spec from draftwright.builder import _AutomaticResolution, _AutomaticScaleTrials @@ -51,6 +52,73 @@ def test_vertical_baseline_steps_and_imported_pmi_share_span_order(): ] +def test_vertical_baseline_callbacks_keep_witnesses_and_report_a_drop(monkeypatch): + import draftwright.annotations._baseline_step_ladder as ladder + + draft = SimpleNamespace(font_size=3.0, pad_around_text=1.0) + strip = Strip(anchor=105.0, outer_limit=160.0) + ctx = PlacementContext(analysis=SimpleNamespace(fv_zones=SimpleNamespace(right=strip))) + segment = _StepChainSegment((100.0, 74.0, 0), (100.0, 50.0, 0), 12.0, measurements=("step:1",)) + calls = [] + monkeypatch.setattr(ladder, "_dim", lambda *args, **kwargs: calls.append((args, kwargs))) + monkeypatch.setattr(ladder, "dim_footprint", lambda *args: calls.append((args, {}))) + drawing = SimpleNamespace(draft=draft) + assert ( + register_vertical_baseline_steps( + drawing, + "front", + [segment], + ["12"], + "step", + 0, + (80.0, 50.0, 103.0, 160.0), + ctx, + lambda ids: calls.append(ids), + ) + == 1 + ) + candidate = ctx.corridor_batch[("front", "right")]["cands"][0] + candidate.build(110.0) + candidate.footprint(110.0) + candidate.on_drop(candidate.name) + assert calls[0][0][0:4] == ((105.0, 50.0, 0), (105.0, 74.0, 0), "right", 5.0) + assert calls[1][0][0:4] == calls[0][0][0:4] + assert calls[2] == ("step:1",) + + no_analysis = PlacementContext() + assert ( + register_vertical_baseline_steps( + drawing, + "front", + [segment], + ["12"], + "step", + 0, + (80.0, 50.0, 103.0, 160.0), + no_analysis, + lambda _ids: None, + ) + is None + ) + + +def test_overcrowded_horizontal_steps_drop_with_a_trace_event(): + draft = SimpleNamespace(font_size=3.0, pad_around_text=1.0) + drawing = SimpleNamespace(draft=draft, view_bounds=lambda _view: (0.0, 0.0, 5.0, 10.0)) + segments = [_StepChainSegment((x, 0.0, 0), (x + 1.0, 0.0, 0), 1.0) for x in (0.0, 1.0, 2.0)] + event = {"items": []} + issues = [] + ctx = SimpleNamespace( + trace=SimpleNamespace(pass_event=lambda *_args, **_kwargs: event), + record_issue=lambda *args, **kwargs: issues.append((args, kwargs)), + ) + assert ( + _draw_step_chain(drawing, "front", segments, "dense", ctx=ctx, allow_collapse=False) == 0 + ) + assert event["items"] == [{"name": "dense", "outcome": "dropped", "reason": "too_dense"}] + assert issues[0][0][1] == "step_dim_dropped" + + def test_dropped_optional_section_can_recover_next_scale_without_larger_sheet(monkeypatch): import draftwright.section_scale_recovery as recovery_module @@ -173,3 +241,45 @@ def drawing(scale, states): ) assert result is None assert attempts[-1][1]["rejection"] == "recognized_requirement_regression" + + +def test_section_scale_recovery_rejects_unavailable_or_changed_source_evidence(monkeypatch): + import draftwright.section_scale_recovery as recovery_module + + def drawing(rows): + return SimpleNamespace(report=lambda: {"recognition": {"requirements": rows}}) + + valid = { + "id": "step:1", + "family": "turned_steps", + "parameter_id": "step.length", + "occurrence_ids": ["step:1"], + "owner_ids": ["shaft"], + "state": "placed", + } + assert not preserves_recognized_requirements( + SimpleNamespace(report=lambda: {}), drawing([valid]) + ) + assert not preserves_recognized_requirements(drawing({}), drawing([valid])) + assert not preserves_recognized_requirements(drawing([{}]), drawing([valid])) + assert not preserves_recognized_requirements( + drawing([valid]), drawing([{**valid, "id": "step:2"}]) + ) + + monkeypatch.setattr(recovery_module, "_SCALES", (1.0, 2.0)) + assert ( + recovery_module.next_scale_without_section( + SimpleNamespace(), 2.0, (420.0, 297.0), "columns", ("front",) + ) + is None + ) + resolution = SimpleNamespace( + dimensions_are_automatic=True, + views_are_automatic=True, + drawing=object(), + context=SimpleNamespace( + latest_analysis=None, + placement_issues=lambda _drawing: [SimpleNamespace(code="section_dropped")], + ), + ) + assert recover_dropped_section_scale(resolution) is None