draftwright 0.4.18__tar.gz → 0.4.19__tar.gz

{draftwright-0.4.18 → draftwright-0.4.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.18
+Version: 0.4.19
 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.18 → draftwright-0.4.19}/docs/reference/recogniser-capabilities.md

@@ -70,6 +70,36 @@ issue. The contract test derives package record outputs, converter registries, l
 and emitter branches independently, so copying a new name into the declaration alone cannot make CI
 pass.
 
+### Quiddity migration baseline
+
+The first [#1471](https://github.com/pzfreo/draftwright/issues/1471) migration slice tests the
+released Quiddity SectionRecess document against the existing authored pocket corpus. Quiddity is
+pinned in the development dependencies for this comparison. Production continues to use the
+existing recogniser dependency and capability declaration.
+
+The private pocket adapter in `model/detect.py` reads primitive schema-2 occurrence geometry and
+produces the existing `PocketFeature`. It admits principal-axis closed rectangles and open
+rectangular corner/edge chains, preserves the opening direction, and refuses unsupported shapes,
+sloped ends, invalid frames and malformed measurements. An open chain remains edge-anchored; its
+missing boundary is never reconstructed as a physical edge.
+
+`tests/test_issue_1471_section_recess_pockets.py` checks independently authored dimensions,
+opposed and side openings, disconnected bodies, topology variants, the existing drawing path,
+executed generated Sheet scripts and authored omission. The baseline tests for pocket patterns,
+channels and both blind-slot families remain the acceptance floor for their later adapters.
+
+This is preparation for adoption, not a new automatic detection mode. The adapter does not yet
+participate in the production registry, bind occurrence ownership or provide Quiddity-based lint.
+Its comparison drawings use the pinned provider for physical critique. The eventual cutover must
+validate result-local references, bind exact same-run occurrences, migrate patterns and explicit
+refusals, and update independent lint, reports and inspection together. A build already holding an
+aggregate must project it rather than invoke the document builder for a second recognition run.
+
+The comparison pins Quiddity 0.2.1, which fixes
+[Quiddity #505](https://github.com/pzfreo/quiddity/issues/505): support proofs now handle
+build123d 0.10 `ShapeList` boolean results. The pocket corpus exercises this public recognition
+path across the supported Python/build123d matrix before consumer adaptation.
+
 `bosses` is the fully consumed reference family. `repeating-radial-profiles` is the opposite
 reference: it remains geometry-only critique evidence for a separately authored gear declaration,
 with no inferred gear feature added to fill the table.

{draftwright-0.4.18 → draftwright-0.4.19}/docs/reference/sheet.md

@@ -40,6 +40,14 @@ refused at declaration and constraints are never silently relaxed. The immutable
 snapshot is available as `sheet.view_constraints`, while `drawing.view_plan` is the distinct
 resolved result.
 
+Layout advisories are also available as structured findings from `Drawing.lint()` and
+`lint(physical=False)`. `legibility_floor_breached` reports an explicit scale below the
+legibility floor when a legible automatic fit exists; `page_fit_uncertain` reports an
+unsuccessful layout fit; `layout_repack_stalled` reports unresolved measured-repack
+triggers; and `scale_fallback_applied` reports a computed scale or a completeness-driven
+scale fallback. These warnings contribute to the legibility component of `lint_summary()`.
+A successful measured fit replaces the earlier estimated fit warning.
+
 ### Taking over a detected baseline
 
 `Sheet.from_part(part)` retains the detector's feature set and starts with implicit automatic
@@ -289,3 +297,9 @@ drop, or missing ink is not hidden by the ownership choice.
 ::: draftwright.sheet._Control
     options:
       filters: public
+
+Imported AP242 nominal-diameter ownership requires absolute agreement within `1e-6`
+with the canonical feature diameter, using the same rule as planning. A larger mismatch
+keeps the original source value and identity in a blocked dimension; it does not replace
+the canonical value or crash planning. Generated Sheet scripts retain the blocker, and
+`authored_dim_source_unresolved` reports the withheld source dimension through lint.

{draftwright-0.4.18 → draftwright-0.4.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.18"
+version = "0.4.19"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -169,6 +169,8 @@ dev = [
     "pytest-split>=0.8",
     "pytest-timeout>=2",
     "pytest-xdist>=3",
+    # Released provider used by the migration parity tests; production remains on 0.4.14.
+    "quiddity==0.2.1",
     "ruff>=0.4",
     "tomli>=2; python_version < '3.11'",
 ]

{draftwright-0.4.18 → draftwright-0.4.19}/src/draftwright/_core.py

@@ -1202,6 +1202,7 @@ class Analysis:
     # Standing ISO 7200 title-block fields (#766) — defaulted, so they sit after the
     # non-default fields above. Defaults preserve the prior output: revision "A", the rest
     # blank (the TitleBlock helper's own defaults).
+    layout_advisories: tuple[tuple[str, str], ...] = ()
     material: str = ""
     date: str = ""
     revision: str = "A"

{draftwright-0.4.18 → draftwright-0.4.19}/src/draftwright/analysis.py

@@ -676,6 +676,7 @@ def _validate_explicit_scale(
     layout_required_tables=(),
     margin=_MARGIN,
     warn_advisory: bool = True,
+    advisories: list[tuple[str, str]] | None = None,
     views: tuple[str, ...] | None = None,
     include_iso: bool = True,
     iso_scale_factor: float | None = None,
@@ -701,7 +702,7 @@ def _validate_explicit_scale(
             f"below {_MIN_RENDER_MM:g} mm (OCCT arc construction fails). "
             f"Use scale ≥ {safe:.3g} or omit the scale for automatic selection."
         )
-    if not warn_advisory:
+    if not warn_advisory and advisories is None:
         return
     auto_scale, _, _, _ = choose_scale(
         x_size,
@@ -727,12 +728,16 @@ def _validate_explicit_scale(
         # No stacklevel that reaches user code: this fires deep in _analyse, and the public
         # entry points (make_drawing, Sheet.export, build_drawing) sit at different depths.
         # The message is self-contained (names the scale, the projection, and the fix).
-        warnings.warn(
+        message = (
             f"scale {SCALE!r} projects the smallest part dimension ({min_dim:.0f} mm) to "
             f"{min_view:.1f} mm, below the {_MIN_VIEW_MM:.0f} mm legibility floor — "
             f"annotations may crowd or overlap. Honouring the requested scale; use "
             f"scale ≥ {safe:.3g} or omit the scale for an automatic legible fit."
         )
+        if advisories is not None:
+            advisories.append(("legibility_floor_breached", message))
+        if warn_advisory:
+            warnings.warn(message)
 
 
 def _analyse(
@@ -1126,7 +1131,10 @@ def _analyse(
             bore_callout_width=bore_callout_width,
         )
 
+    layout_advisories: list[tuple[str, str]] = []
+
     def _pick_for_step_count(n_steps_i: int, strips_i: StripDepths) -> _ScalePick:
+        layout_advisories.clear()
         return choose_scale(
             x_size,
             y_size,
@@ -1140,6 +1148,7 @@ def _analyse(
             required_tables=layout_required_tables,
             margin=margin,
             arrangements=_arrangements,
+            advisories=layout_advisories,
             views=_views,
             include_iso=_include_iso,
             iso_scale_factor=planned_iso_scale,
@@ -1171,6 +1180,7 @@ def _analyse(
         layout_required_tables,
         margin=margin,
         warn_advisory=_reuse is None,
+        advisories=layout_advisories,
         views=_views,
         include_iso=_include_iso,
         iso_scale_factor=planned_iso_scale,
@@ -1264,6 +1274,7 @@ def _analyse(
     )
 
     return Analysis(
+        layout_advisories=tuple(layout_advisories),
         arrangement=ARRANGEMENT,
         planned_views=_views,
         planned_iso=_include_iso,

{draftwright-0.4.18 → draftwright-0.4.19}/src/draftwright/builder.py

@@ -491,6 +491,17 @@ def detect_part_model(part, *, pmi="off") -> PartModel:
     return _detect_part_model_analysis(part, pmi=pmi)[0]
 
 
+def _layout_advisory(code: str, message: str) -> LintIssue:
+    """Validate the closed layout-advisory vocabulary at the lint boundary."""
+    if code == "legibility_floor_breached":
+        return LintIssue(severity="warning", code="legibility_floor_breached", message=message)
+    if code == "page_fit_uncertain":
+        return LintIssue(severity="warning", code="page_fit_uncertain", message=message)
+    if code == "scale_fallback_applied":
+        return LintIssue(severity="warning", code="scale_fallback_applied", message=message)
+    raise ValueError(f"unknown layout advisory: {code!r}")
+
+
 def _assemble(
     a,
     out,
@@ -824,6 +835,8 @@ def _assemble(
         # produce a confident "nothing was suppressed" (#996).
         _diagnostics = compile_dimensions(dwg.model()).diagnostics
     dwg._build.omissions = tuple(_diagnostics or ())
+    for code, message in a.layout_advisories:
+        dwg.registry.record_issue(_layout_advisory(code, message))
     return dwg
 
 
@@ -882,6 +895,7 @@ def _repack(
     no view actually moves).
     """
     if not _needs_repack(dwg, a):
+        dwg.registry.drop_issues({"page_fit_uncertain"})
         return None
     blocks = _measure_blocks(dwg, a)
 
@@ -940,6 +954,7 @@ def _repack(
         return g.auto_fits if auto_search else g.fits
 
     fit = next(((c, gg) for c in candidates if _candidate_fits(gg := _geom(c))), None)
+    repack_advisories: list[tuple[str, str]] = []
     if fit is not None:
         chosen, g = fit
     else:
@@ -961,6 +976,12 @@ def _repack(
             if lo > 0.0:
                 chosen = (lo, pw0, ph0, tb0)
                 g = _geom(chosen)
+                repack_advisories.append(
+                    (
+                        "scale_fallback_applied",
+                        f"No standard scale fits the measured layout; using computed {lo:g}",
+                    )
+                )
                 _log.warning(
                     "measure-repack: no standard sheet fits the measured layout; "
                     "using computed %s",
@@ -971,6 +992,9 @@ def _repack(
             # keep the largest candidate and let lint report the overflow (as before).
             chosen = candidates[-1]
             g = _geom(chosen)
+            repack_advisories.append(
+                ("page_fit_uncertain", f"No sheet/scale fits the measured layout; using {chosen}")
+            )
             _log.warning(
                 "measure-repack: no sheet/scale fits the measured layout; using %s", chosen
             )
@@ -983,11 +1007,22 @@ def _repack(
         abs(g.SV_X - a.SV_X),
         abs(g.SV_Y - a.SV_Y),
     )
+    # Seed fit warnings yield to the measured result; retain the explicit legibility
+    # advisory only at the scale for which it was evaluated.
+    advisories = tuple(
+        (code, message)
+        for code, message in a.layout_advisories
+        if code == "legibility_floor_breached" and s == a.SCALE
+    ) + tuple(repack_advisories)
     if s == a.SCALE and pw == a.PAGE_W and ph == a.PAGE_H and moved < _REPACK_TOL:
+        dwg.registry.drop_issues({"page_fit_uncertain", "scale_fallback_applied"})
+        for code, message in repack_advisories:
+            dwg.registry.record_issue(_layout_advisory(code, message))
         return None
     fv_zones, pv_zones, sv_zones = _build_zones(g, a.margin, ph)
     a2 = replace(
         a,
+        layout_advisories=advisories,
         SCALE=s,
         PAGE_W=pw,
         PAGE_H=ph,
@@ -1080,6 +1115,13 @@ def _repack_to_fixed_point(
         )
         if repacked is None:
             if _needs_repack(cur_dwg, cur_a):
+                cur_dwg.registry.record_issue(
+                    LintIssue(
+                        severity="warning",
+                        code="layout_repack_stalled",
+                        message=f"Measured repack stalled after {i} iterations with residual layout triggers",
+                    )
+                )
                 _log.warning(
                     "measure-repack: stalled after %d iteration(s) with residual layout triggers",
                     i,
@@ -1088,6 +1130,13 @@ def _repack_to_fixed_point(
         cur_a, cur_dwg = repacked
 
     if _needs_repack(cur_dwg, cur_a):
+        cur_dwg.registry.record_issue(
+            LintIssue(
+                severity="warning",
+                code="layout_repack_stalled",
+                message=f"Measured repack reached its {_REPACK_MAX_ITER} iteration limit with residual layout triggers",
+            )
+        )
         _log.warning(
             "measure-repack: reached iteration limit (%d) with residual layout triggers",
             _REPACK_MAX_ITER,
@@ -2639,6 +2688,14 @@ def build_drawing(
             attempted=attempted,
             attempts=attempts,
         )
+        fallback.registry.record_issue(
+            LintIssue(
+                severity="warning",
+                code="scale_fallback_applied",
+                message=f"Requested scale {requested_scale:g} dropped required annotations; "
+                f"using complete fallback scale {fallback.scale:g}",
+            )
+        )
         warnings.warn(
             f"requested scale {requested_scale:g} dropped required annotation outcomes; "
             f"using complete fallback scale {fallback.scale:g}",

{draftwright-0.4.18 → draftwright-0.4.19}/src/draftwright/compose.py

@@ -689,6 +689,7 @@ def choose_scale(
     views: tuple[str, ...] | None = None,
     include_iso: bool = True,
     iso_scale_factor: float | None = None,
+    advisories: list[tuple[str, str]] | None = None,
 ) -> tuple:
     """Return (SCALE, PAGE_W, PAGE_H, TB_W) for a 4-view layout.
 
@@ -734,6 +735,13 @@ def choose_scale(
             include_iso=include_iso,
             iso_scale_factor=iso_scale_factor,
         ):
+            if advisories is not None:
+                advisories.append(
+                    (
+                        "page_fit_uncertain",
+                        f"Requested scale {scale} on {page} may not fit the requested view layout",
+                    )
+                )
             _log.warning(
                 "Requested scale %s on %s page may not fit the requested view layout",
                 scale,
@@ -867,6 +875,10 @@ def choose_scale(
             iso_scale_factor=iso_scale_factor,
         )
         if s is not None:
+            if advisories is not None:
+                advisories.append(
+                    ("scale_fallback_applied", f"No standard scale fits; using computed {s:g}")
+                )
             _log.warning(
                 "No standard scale fits %.0f × %.0f × %.0f mm; using computed %s",
                 x_size,
@@ -875,6 +887,14 @@ def choose_scale(
                 format_drawing_scale(s),
             )
             return s, _pw, _ph, _tb
+    if advisories is not None:
+        advisories.append(
+            (
+                "page_fit_uncertain",
+                f"No layout fits {x_size:g} × {y_size:g} × {z_size:g} mm; "
+                f"falling back to {candidates[-1]}",
+            )
+        )
     _log.warning(
         "No layout fits %.0f × %.0f × %.0f mm; falling back to %s",
         x_size,

{draftwright-0.4.18 → draftwright-0.4.19}/src/draftwright/drawing.py

@@ -3718,6 +3718,12 @@ class Drawing:
                 assembly=self.assembly,
                 holes=holes,
                 bosses=bosses,
+                blends=recognition.blends,
+                recognition_evidence=self._build.recognition_evidence,
+                # The same profile set `detect` used, so the boss/blend absorption decision
+                # is one decision rather than two that can disagree. `prof_kw` is empty only
+                # where detect also falls back to the aggregate.
+                **({"turned_profiles": prof_kw["profiles"]} if "profiles" in prof_kw else {}),
                 registry=self._registry,
             )
             issues += lint_axial_coverage(

{draftwright-0.4.18 → draftwright-0.4.19}/src/draftwright/linting/coverage.py

@@ -58,6 +58,11 @@ from draftwright.recognition_frame import (
     groove_owns_turned_step_band,
     profiles_owning_axial_band,
 )
+from draftwright.recognition_ownership import (
+    BOSS_BLEND_DIAMETER_TOL,
+    boss_blend_owner_pairs,
+    envelope_is_emittable,
+)
 from draftwright.view_plan import VIEW_AXES
 
 _UNSET = object()  # sentinel: distinguishes "not supplied" from a valid prof=None
@@ -269,6 +274,9 @@ def lint_feature_coverage(
     assembly=None,
     holes=None,
     bosses=None,
+    blends=None,
+    recognition_evidence=None,
+    turned_profiles=_UNSET,
     registry=None,
 ) -> list:
     """Coarse completeness check: report part diameters with no callout (#80).
@@ -303,6 +311,11 @@ def lint_feature_coverage(
     ``cyls`` accepts a precomputed ``analyse_cylinders(part)`` result so
     repeated lint runs need not re-scan the solid.
 
+    When same-run ``recognition_evidence`` proves that a recognised boss and blend share the
+    same defining face and circular value, the boss diameter is excluded from this coarse
+    physical inventory. The blend radius is the truthful callout for that face; counting its
+    equivalent diameter again would recreate the duplicate this lint is meant to detect.
+
     Counts are checked too (#92): the part's holes (via ``recognise_holes``) give
     a required count per diameter (each bore, counterbore, and spotface
     occurrence counts one), and structured callouts declare how many holes
@@ -318,6 +331,44 @@ def lint_feature_coverage(
     z_cyls, cross_cyls = cyls if cyls is not None else analyse_cylinders(part)
     if holes is None:
         holes = recognise_holes(part, cyls=(z_cyls, cross_cyls))
+    if bosses is None and recognition_evidence is not None:
+        bosses = recognition_evidence.result.bosses
+    if blends is None and recognition_evidence is not None:
+        blends = recognition_evidence.result.blends
+    # `bosses`/`blends` are inventories, so an empty one is not None. Testing `is not None`
+    # bought a `part.bounding_box()` on every lint of every part, including the great majority
+    # with no boss or blend to reconcile — a second solid measurement on the re-lint path that
+    # `test_relint_recomputes_no_annotation_boxes` budgets exactly one of. Truthiness skips it.
+    if bosses and blends and recognition_evidence is not None:
+        bbox = part.bounding_box()
+        # The BUILD's profile set, not the recognition result's. On a declared build they
+        # differ — `detect._analyse` uses the caller's `prof`/`profiles` — and detect decides
+        # absorption from its own. Re-deriving here let the IR drop a boss diameter that this
+        # lint still demanded a callout for. `_UNSET` means the caller had none to state, which
+        # is the same condition under which detect falls back to the aggregate.
+        profiles = (
+            recognition_evidence.result.turned_profiles
+            if turned_profiles is _UNSET
+            else turned_profiles
+        )
+        envelope_emittable = envelope_is_emittable(
+            bbox=bbox,
+            bosses=bosses,
+            turned_profiles=profiles,
+            polygonal_stock=recognition_evidence.result.polygonal_stock,
+        )
+        blend_owned_boss_ids = {
+            id(boss)
+            for boss, _blend in boss_blend_owner_pairs(
+                recognition_evidence,
+                tuple(bosses),
+                tuple(blends),
+                bbox=bbox,
+                envelope_emittable=envelope_emittable,
+                diameter_tolerance=BOSS_BLEND_DIAMETER_TOL,
+            )
+        }
+        bosses = tuple(boss for boss in bosses if id(boss) not in blend_owned_boss_ids)
     # Coverage inventory: the *recognised* dimensionable diameters (bores,
     # cbore/spotface steps, bosses) from feature_diameters — built via
     # recognise_holes/recognise_bosses, so slot ends and interrupted recesses (partial

{draftwright-0.4.18 → draftwright-0.4.19}/src/draftwright/linting/quality.py

@@ -53,6 +53,10 @@ _OUTCOME_STATES = (
 # distinguish validation from layout.
 _LEGIBILITY_CODES = frozenset(
     {
+        "legibility_floor_breached",
+        "page_fit_uncertain",
+        "layout_repack_stalled",
+        "scale_fallback_applied",
         "annotation_out_of_bounds",
         "annotation_overlap",
         "annotation_ink_overlap",