draftwright 0.4.10__tar.gz → 0.4.11__tar.gz

{draftwright-0.4.10 → draftwright-0.4.11}/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## Unreleased
+
+### Changed
+
+- Recogniser integration now uses only the exact `b123d-recognisers` dependency in
+  `pyproject.toml` and `uv.lock`. The separate release-evidence record, dependency-bump workflow,
+  candidate-checkout harness, and release-time capability-version rewrites have been removed;
+  ordinary compatibility tests validate the installed pinned package.
+- Automatic composition now measures the next larger preferred scale when a conservative
+  crowded-detail reservation leaves a sparse sheet. A candidate wins only on the same paper
+  size, without the recovery detail, structural errors, or required-placement loss. GRM-04 now
+  uses A4 at 5:1 instead of 2:1, re-homes its shared side-hole Y location into the plan-view
+  corridor, and retains both the Ø2.4 diameter and location requirements (#1155).
+- Closed the remaining dense-sheet leader cases as deliberate Policy-B behavior: exhaustive
+  route sweeps prove there is no route clear of both material and committed sheet ink, so the
+  required callout remains with an explicit crossing diagnostic instead of being dropped. A
+  fast synthetic release gate complements the retained exhaustive corpus characterization
+  (#1187).
+
+### Fixed
+
+- Notes and generic table cells now render U+2300 `⌀` with the established supported drafting
+  glyph instead of IBM Plex Mono's missing-glyph square. The substitution happens at the one
+  shared measurement/render seam, so source rows remain unchanged and table sizing stays exact
+  (#1275).
+- Automatic turned-part composition now gives true shoulder coverage priority over optional
+  pictorial content. GRM-03 replans to 5:1 and renders its 0.5, 2, 3, and 18 mm axial lengths;
+  `axial_length_missing` disappears because the dimensions are present, not because the
+  diagnostic was suppressed (#443).
+
 ## v0.4.10 — 2026-08-22
 
 **A view-set-aware planning and turned-edge-treatment patch.** Authored view constraints now

{draftwright-0.4.10 → draftwright-0.4.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.10
+Version: 0.4.11
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -684,7 +684,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: <3.15,>=3.10
 Requires-Dist: antlr4-python3-runtime<4.10
-Requires-Dist: b123d-recognisers==0.3.0
+Requires-Dist: b123d-recognisers==0.3.1
 Requires-Dist: build123d-drafting-helpers>=0.14.1
 Requires-Dist: build123d<0.11,>=0.9.0; python_full_version < '3.13'
 Requires-Dist: build123d<0.12,>=0.11; python_full_version >= '3.13'

{draftwright-0.4.10 → draftwright-0.4.11}/docs/reference/recogniser-capabilities.md

@@ -49,13 +49,11 @@ Validation fails closed and names the family and boundary whenever possible:
 
 ## Adding or changing a recogniser
 
-For an additive field that increments an existing record schema, first land a narrow Draftwright
-declaration accepting both the installed schema and the named candidate schema. The existing adapter
-must remain valid when the new field is ignored, and tests must prove the next schema is accepted
-only by that explicit declaration while later schemas still fail. The package canary then proves
-the real candidate wheel against that committed consumer point. After the package release, the
-Draftwright dependency/behavior PR locks the immutable artifact, adopts the field, and narrows the
-declaration to the new schema.
+For an additive field that increments an existing record schema, update the relevant Draftwright
+adapter and declaration when advancing the exact `b123d-recognisers` dependency pin. Tests must
+prove the installed schema is accepted while later schemas still fail. The package version belongs
+only in `pyproject.toml` and `uv.lock`; the capability declaration derives runtime identities from
+installed package metadata.
 
 For each applicable stage, add the adapter, declaration, emitted-Sheet round trip, drawing behavior,
 and completeness evidence; for an inapplicable or deferred stage, state why and link its tracking

{draftwright-0.4.10 → draftwright-0.4.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.10"
+version = "0.4.11"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -18,7 +18,7 @@ dependencies = [
     "build123d>=0.9.0,<0.11 ; python_full_version < '3.13'",
     "build123d>=0.11,<0.12 ; python_full_version >= '3.13'",
     "build123d-drafting-helpers>=0.14.1",
-    "b123d-recognisers==0.3.0",
+    "b123d-recognisers==0.3.1",
     "numpy>=1.24",
     # PNG raster export (SVG→PDF→PNG). Both permissively licensed (Pillow HPND; pypdfium2
     # Apache-2.0 wrapping Google PDFium BSD-3) and ship pre-built wheels with NO native system

{draftwright-0.4.10 → draftwright-0.4.11}/src/draftwright/_core.py

@@ -57,6 +57,35 @@ from draftwright.layout import _greedy_strip_1d, _solve_strip_1d
 _log = logging.getLogger(__name__)
 
 
+def _decode_hole_location_fact(fact):
+    """Decode a current or legacy ``covers_hole_locations`` fact.
+
+    Current facts carry ``(feature, parameter, point)``. Legacy/external facts
+    carry ``(measurement, point)`` and derive ownership from the measurement.
+    Invalid or incomplete riders return ``None`` so consumers can retain their
+    geometric fallback instead of treating malformed metadata as authoritative.
+    """
+    try:
+        size = len(fact)
+    except TypeError:
+        return None
+    if size == 3:
+        feature, parameter, point = fact
+    elif size == 2:
+        measurement, point = fact
+        feature = getattr(measurement, "feature", None)
+        parameter = getattr(measurement, "parameter", None)
+    else:
+        return None
+    if feature is None or not isinstance(parameter, str):
+        return None
+    try:
+        HoleRef.of(point)
+    except (AttributeError, TypeError, ValueError):
+        return None
+    return feature, parameter, point
+
+
 def place_annotation(registry, items, obj, name=None, view=None, feature=None, measurement=None):
     """The annotation-placement primitive (#817): register *obj* under *name* — replacing any
     prior object of that name (dropped from the render list *items*) so a name maps to one
@@ -168,6 +197,19 @@ def _wrap_rows(header, data, ncols):
     return wide
 
 
+def _font_safe_text(value) -> str:
+    """Return the font-safe spelling used to measure and draw user text.
+
+    IBM Plex Mono does not contain U+2300 DIAMETER SIGN, so FreeType substitutes
+    its missing-glyph box.  The drafting surface already uses U+00F8 LATIN SMALL
+    LETTER O WITH STROKE for diameter labels; use that established glyph at the
+    shared render seams as well.  Keeping the substitution here makes free notes,
+    declared notes, title blocks, BOMs, revision tables, and hole tables measure
+    exactly the text they render while preserving the caller's semantic source data.
+    """
+    return str(value).replace("⌀", "ø")
+
+
 def _table_metrics(rows, font_size, pad_around_text, block_cols=None):
     """The sizing model of a data table: per-column left/right edges (page-mm,
     block gaps inserted), total width/height, row height and effective block
@@ -186,7 +228,11 @@ def _table_metrics(rows, font_size, pad_around_text, block_cols=None):
     bc = block_cols if (block_cols and ncol % block_cols == 0 and block_cols < ncol) else ncol
     block_gap = 3 * pad  # whitespace between side-by-side blocks
     col_w = [
-        max(max(_text_width(str(r[c]), fs) for r in rows) + 2 * pad, fs * 2.5) for c in range(ncol)
+        max(
+            max(_text_width(_font_safe_text(r[c]), fs) for r in rows) + 2 * pad,
+            fs * 2.5,
+        )
+        for c in range(ncol)
     ]
     # Per-column left/right edges, inserting block_gap before each new block.
     lefts, rights, cursor = [], [], 0.0
@@ -232,11 +278,12 @@ def _build_table(rows, draft, block_cols=None):
     for ri, row in enumerate(rows):  # rows[0] (header) sits at the top
         cy = total_h - (ri + 0.5) * row_h
         for ci, cell in enumerate(row):
-            if not str(cell):
+            display = _font_safe_text(cell)
+            if not display:
                 continue
             cx = (lefts[ci] + rights[ci]) / 2
             text = Text(
-                txt=str(cell),
+                txt=display,
                 font_size=fs,
                 font_path=PLEX_MONO,
                 align=(Align.CENTER, Align.CENTER),
@@ -1158,15 +1205,15 @@ def _make_title_block(dwg, a: Analysis):
     it, last) and :func:`_title_block_box` (which measures its footprint for GD&T avoidance, #481)
     so the two never drift."""
     tb = TitleBlock(
-        a.title,
-        a.number,
+        _font_safe_text(a.title),
+        _font_safe_text(a.number),
         scale=format_drawing_scale(a.SCALE),
-        general_tolerance=a.tolerance,
-        designed_by=_attribution_author(a.drawn_by),
-        material=a.material,
-        date=a.date,
-        revision=a.revision,
-        legal_owner=a.company,
+        general_tolerance=_font_safe_text(a.tolerance),
+        designed_by=_font_safe_text(_attribution_author(a.drawn_by)),
+        material=_font_safe_text(a.material),
+        date=_font_safe_text(a.date),
+        revision=_font_safe_text(a.revision),
+        legal_owner=_font_safe_text(a.company),
         width=a.TB_W,
         # Title block renders in condensed sans (the tight ISO 7200 cells), a
         # different face from the monospace dimensions — so it carries its own

{draftwright-0.4.10 → draftwright-0.4.11}/src/draftwright/annotations/_common.py

@@ -20,6 +20,7 @@ from build123d_drafting.helpers import DEFAULT_FONT_PATH, Dimension, Note, SafeD
 
 from draftwright._core import (  # noqa: F401 — _anno_box re-exported (#700)
     _anno_box,
+    _decode_hole_location_fact,
     _text_size,
     place_annotation,
 )
@@ -129,7 +130,24 @@ def _annotation_hole_features(registry, name, annotation) -> frozenset:
         if getattr(feature, "kind", None) in {"hole", "pattern"}:
             features.add(feature)
     for fact in getattr(annotation, "covers_hole_locations", ()):
-        feature = fact[0] if len(fact) == 3 else getattr(fact[0], "feature", None)
+        decoded = _decode_hole_location_fact(fact)
+        if decoded is not None:
+            feature = decoded[0]
+        else:
+            # Replacement ownership is a broader question than whether a fact can
+            # prove axis-specific coverage.  Legacy/external riders may carry only
+            # ``(measurement, point)``; retain that measurement's semantic owner
+            # even when it has no parameter and the strict decoder rightly refuses
+            # to treat it as location evidence.
+            try:
+                candidate = fact[0]
+            except (IndexError, TypeError):
+                continue
+            feature = (
+                candidate
+                if getattr(candidate, "kind", None) in {"hole", "pattern"}
+                else getattr(candidate, "feature", None)
+            )
         if getattr(feature, "kind", None) in {"hole", "pattern"}:
             features.add(feature)
     for feature, _requirement, _count in getattr(

{draftwright-0.4.10 → draftwright-0.4.11}/src/draftwright/annotations/from_model.py

@@ -52,6 +52,7 @@ from draftwright._core import (
     _dim,
     _first_free_index,
     _fmt,
+    _font_safe_text,
     _greedy_strip_ys,
     _iso_bbox,
     _legible_locations,
@@ -5685,7 +5686,7 @@ def _gdt_glyph(item, draft):
     if item.kind == "datum_ref":
         return DatumFeature(item.letter, draft=draft)
     if item.kind == "note":  # free-text manufacturing note (#488) — a single-line text glyph
-        return TextBlock([item.text], position=(0.0, 0.0), draft=draft)
+        return TextBlock([_font_safe_text(item.text)], position=(0.0, 0.0), draft=draft)
     return SurfaceFinish(item.ra, position=(0.0, 0.0), draft=draft)
 
 

{draftwright-0.4.10 → draftwright-0.4.11}/src/draftwright/annotations/holes.py

@@ -816,6 +816,7 @@ def _locate_across(dwg, ctx, a: Analysis, off):
     _locate_off_axis_holes (#638)."""
     draft = dwg.draft
     SX, SZ = a.proj.side_x, a.proj.side_z
+    PX, PY = a.proj.plan_x, a.proj.plan_y
     dy, dz = a.bb.min.Y, a.bb.min.Z
     tier = draft.font_size + 2 * draft.pad_around_text
     yw = SZ(dz) - _WITNESS_LIFT_MM
@@ -825,6 +826,7 @@ def _locate_across(dwg, ctx, a: Analysis, off):
     loc_by_name: dict = {}  # dim name -> contributing hole locations (for provenance)
     mids_by_name: dict = {}
     coverage_by_name: dict = {}
+    plan_alternates: dict = {}
     for h in (h for h in off if h.axis == "x"):
         # The VALUE is the approved entry's; `dy` survives only as the witness anchor.
         entry = h.approved.get("y")
@@ -854,8 +856,70 @@ def _locate_across(dwg, ctx, a: Analysis, off):
                     ),
                 )
             )
+            # #1155: the same Y ordinate reads vertically in plan.  Keep the
+            # side-view location as the natural first choice, but retain this
+            # requirement-driven alternate for a full below-side corridor (GRM-04
+            # at 5:1 shares that short strip with the overall depth).  This is a
+            # view reassignment through the shared strip solver, not a raw position.
+            plan_edge = PX(a.bb.max.X)
+            plan_lo = (plan_edge, PY(dy), 0)
+            plan_hi = (plan_edge, PY(h.location[1]), 0)
+            alt_name = f"dim_loc_plan_y{round(yo * 100)}"
+            plan_alternates[name] = (
+                alt_name,
+                lambda pos, pl=plan_lo, ph=plan_hi, e=plan_edge, lb=entry.value_text, nm=name: (
+                    _with_hole_location_coverage(
+                        _dim(pl, ph, "right", pos - e, draft, label=lb),
+                        coverage_by_name[nm],
+                    )
+                ),
+            )
     feats = {nm: _off_axis_owner(ctx, locs) for nm, locs in loc_by_name.items()}
     measurements = {name: tuple(ids) for name, ids in mids_by_name.items()}
+
+    def _fallback(name):
+        # Every queued side candidate is created in the same block as its plan
+        # alternate above; a missing key is an internal invariant violation.
+        alt = plan_alternates[name]
+        alt_name = alt[0]
+
+        def _retry():
+            # A fallback is never allowed to create an annotation in a view the
+            # resolved plan omitted.  It also runs only after every shared corridor
+            # has drained, so its solitary carve cannot preempt a later candidate.
+            if "plan" not in dwg.views:
+                _off_axis_drop(
+                    dwg,
+                    "y",
+                    "side",
+                    ctx=ctx,
+                    measurement=measurements.get(name, ()),
+                )
+                return
+            if not _off_axis_emit(
+                dwg,
+                tier,
+                a.pv_zones.right,
+                "plan",
+                "x",
+                [alt],
+                force=False,
+                features={alt_name: feats.get(name)},
+                measurements={alt_name: measurements.get(name, ())},
+                ctx=ctx,
+                trace=ctx.trace,
+            ):
+                return
+            _off_axis_drop(
+                dwg,
+                "y",
+                "side",
+                ctx=ctx,
+                measurement=measurements.get(name, ()),
+            )
+
+        ctx.post_drain.append(_retry)
+
     _off_axis_queue(
         dwg,
         ctx,
@@ -867,9 +931,7 @@ def _locate_across(dwg, ctx, a: Analysis, off):
         cands,
         features=feats,
         measurements=measurements,
-        on_drop=lambda nm: _off_axis_drop(
-            dwg, "y", "side", ctx=ctx, measurement=measurements.get(nm, ())
-        ),
+        on_drop=_fallback,
         order_key=lambda nm, _i: order_y.get(nm, _i),
     )