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 a50c69fa..da178eb5 100644 --- a/src/draftwright/annotations/_axial_render.py +++ b/src/draftwright/annotations/_axial_render.py @@ -28,6 +28,7 @@ _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, @@ -136,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, @@ -148,6 +185,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 +221,24 @@ def _draw_step_chain( else _step_value_text(seg) + _tol_suffix(seg.tolerance, draft) for seg in segs ] + if baseline_positions and not horizontal: + 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 @@ -209,38 +265,10 @@ def _draw_step_chain( 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..43bb7a55 --- /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 +) -> 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: + 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/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/_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/annotations/orchestrator.py b/src/draftwright/annotations/orchestrator.py index ebac8176..ae91fc31 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), @@ -1070,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/src/draftwright/builder.py b/src/draftwright/builder.py index 1b2a5093..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 @@ -2654,6 +2666,7 @@ def run(self) -> Drawing: self.settle_arrangement() self.prepare_trials() self.recover_detail() + 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/_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_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 new file mode 100644 index 00000000..958c71a2 --- /dev/null +++ b/tests/test_optional_section_scale_and_pmi_ladder.py @@ -0,0 +1,285 @@ +"""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._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 +from draftwright.section_scale_recovery import ( + preserves_recognized_requirements, + recover_dropped_section_scale, +) + + +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, + view_bounds=lambda _view: (80.0, 50.0, 103.0, 160.0), + ) + 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), + ] + + 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_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 + + 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( + recovery_module, + "_layout_geometry", + lambda *args, **kwargs: SimpleNamespace(auto_fits=True), + ) + + original = recovery.drawing + recover_dropped_section_scale(recovery) + + assert recovery.drawing is winner + assert recovery.replanned + assert calls == [ + ( + (2.0,), + { + "reason": "optional_section_scale_recovery", + "require_axial_coverage": False, + "requirement_floor": original, + }, + ) + ] + + # 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( + recovery_module, + "_layout_geometry", + lambda *args, **kwargs: SimpleNamespace(auto_fits=False), + ) + 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" + + +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 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",