draftwright 0.4.10__tar.gz → 0.4.12__tar.gz

{draftwright-0.4.10 → draftwright-0.4.12}/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.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.10
+Version: 0.4.12
 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.12}/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.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.10"
+version = "0.4.12"
 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.12}/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.12}/src/draftwright/_pmi_part21.py

@@ -1,13 +1,15 @@
 """Structured Part21 facts that OCCT's XCAF PMI transfer currently drops.
 
 This is deliberately a leaf adapter: it understands ISO 10303-21 entities and units, but
-knows nothing about XCAF labels, drafting IR, or placement.  ``pmi.py`` owns the overlay and
-may use a fact only after :func:`match_geometric_tolerance` proves exact correspondence.
+knows nothing about XCAF labels, drafting IR, or placement.  ``pmi.py`` owns the overlay.
+Geometric-tolerance facts require exact XCAF correspondence; manufacturing-requirement facts
+retain their own complete property -> representation -> shape-aspect source chain.
 """
 
 from __future__ import annotations
 
 import math
+import re
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -53,6 +55,13 @@ _SI_METRE_TO_MM: dict[str, float] = {
     ".ATTO.": 1e-15,
 }
 
+# Entity names are invariant ASCII Part21 syntax; string parameters are not.  Keying this
+# guard on the literal category text silently missed valid ``\X2\...\X0\`` encodings before
+# steputils had a chance to decode them.  A file with no property definitions cannot carry
+# the requirement chain, while any file that does is parsed conservatively (#1297).  Match
+# only the invariant token: Part 21 comments may legally separate it from the opening ``(``.
+_PROPERTY_DEFINITION_MARKER = re.compile(rb"\bPROPERTY_DEFINITION\b", re.IGNORECASE)
+
 
 @dataclass(frozen=True)
 class GeometricToleranceFact:
@@ -84,7 +93,31 @@ class DatumOccurrenceFact:
     reason: str = ""
 
 
+@dataclass(frozen=True)
+class ManufacturingRequirementFact:
+    """One authoritative semantic manufacturing requirement from Part 21.
+
+    ``entity_id`` is the ``PROPERTY_DEFINITION`` identity, while ``text`` comes from the
+    linked ``DESCRIPTIVE_REPRESENTATION_ITEM`` rather than presentation glyphs.  The
+    remaining IDs preserve the semantic-callout -> shape-aspect -> representation-item
+    association for concept lowering; this leaf adapter deliberately does not interpret
+    those items as drafting features.
+    """
+
+    entity_id: str
+    semantic_name: str
+    text: str
+    representation_id: str = ""
+    descriptive_item_id: str = ""
+    callout_ids: tuple[str, ...] = ()
+    shape_aspect_ids: tuple[str, ...] = ()
+    reference_item_ids: tuple[str, ...] = ()
+    reason: str = ""
+
+
 def _entities(instance) -> tuple:
+    if instance is None:
+        return ()
     entity = getattr(instance, "entity", None)
     if entity is not None:
         return (entity,)
@@ -158,6 +191,205 @@ def _datum_feature_items(step) -> dict[str, tuple[str, ...]]:
     return {key: tuple(dict.fromkeys(values)) for key, values in result.items()}
 
 
+def _text(value) -> str:
+    return str(value).strip() if isinstance(value, str) else ""
+
+
+def _name_tokens(value: str) -> frozenset[str]:
+    """Normalise semantic names for callout correspondence, not requirement inference."""
+    words = []
+    for raw in value.lower().replace("_", " ").replace("-", " ").split():
+        word = "".join(character for character in raw if character.isalnum())
+        if len(word) > 3 and word.endswith("s") and not word.endswith("ss"):
+            word = word[:-1]
+        if word and word != "requirement":
+            words.append(word)
+    return frozenset(words)
+
+
+def _manufacturing_graph(step):
+    """Collect the Part21 indexes shared by manufacturing-requirement facts."""
+    definitions: list[tuple[str, object]] = []
+    representations: dict[str, list[str]] = {}
+    callout_names: dict[str, str] = {}
+    callout_aspects: dict[str, list[str]] = {}
+    aspect_items: dict[str, list[str]] = {}
+
+    for section in step.data:
+        for entity_id, instance in section.instances.items():
+            definition = _entity_named(instance, "PROPERTY_DEFINITION")
+            if (
+                definition is not None
+                and len(definition.params) >= 2
+                and _text(definition.params[0]).lower() == "manufacturing requirement"
+            ):
+                definitions.append((entity_id, definition))
+
+            relationship = _entity_named(instance, "PROPERTY_DEFINITION_REPRESENTATION")
+            if relationship is not None and len(relationship.params) >= 2:
+                definition_ref, representation_ref = relationship.params[:2]
+                if isinstance(definition_ref, p21.Reference) and isinstance(
+                    representation_ref, p21.Reference
+                ):
+                    representations.setdefault(str(definition_ref), []).append(
+                        str(representation_ref)
+                    )
+
+            callout = _entity_named(instance, "DRAUGHTING_CALLOUT")
+            if callout is not None and callout.params:
+                callout_names[entity_id] = _text(callout.params[0])
+
+            association = _entity_named(instance, "DRAUGHTING_MODEL_ITEM_ASSOCIATION")
+            if association is not None and len(association.params) >= 5:
+                aspect_ref = association.params[2]
+                if isinstance(aspect_ref, p21.Reference) and _instance_is(
+                    step, str(aspect_ref), "SHAPE_ASPECT"
+                ):
+                    for callout_ref in _references(association.params[4]):
+                        if _instance_is(step, callout_ref, "DRAUGHTING_CALLOUT"):
+                            callout_aspects.setdefault(callout_ref, []).append(str(aspect_ref))
+
+            usage = _entity_named(instance, "GEOMETRIC_ITEM_SPECIFIC_USAGE")
+            if usage is not None and len(usage.params) >= 5:
+                aspect_ref = usage.params[2]
+                if isinstance(aspect_ref, p21.Reference) and _instance_is(
+                    step, str(aspect_ref), "SHAPE_ASPECT"
+                ):
+                    aspect_items.setdefault(str(aspect_ref), []).extend(
+                        _references(usage.params[4])
+                    )
+
+    return definitions, representations, callout_names, callout_aspects, aspect_items
+
+
+def read_manufacturing_requirements(
+    step_file: str | Path,
+) -> tuple[ManufacturingRequirementFact, ...]:
+    """Read authoritative semantic requirements and retain their geometry associations.
+
+    The property-definition chain owns the full requirement text.  A draughting callout
+    with the same representation name (or, where the presentation adds a qualifier such as
+    ``Straight``, the same semantic-name tokens) supplies the shape-aspect association.
+    This is correspondence between two source semantic identities; no nominal value or
+    B-rep measurement is guessed here.
+    """
+    # A file with no property-definition entity cannot carry this semantic chain, so avoid a
+    # third full Part21 parse there.  Once any property definition exists, parse
+    # conservatively: its string category may use a valid escape encoding that a byte-level
+    # literal check cannot interpret.
+    if _PROPERTY_DEFINITION_MARKER.search(Path(step_file).read_bytes()) is None:
+        return ()
+    step = p21.readfile(step_file)
+    (
+        definitions,
+        representations,
+        callout_names,
+        callout_aspects,
+        aspect_items,
+    ) = _manufacturing_graph(step)
+    facts: list[ManufacturingRequirementFact] = []
+
+    for entity_id, definition in definitions:
+        semantic_name = _text(definition.params[1])
+        reasons: list[str] = []
+        if not semantic_name:
+            reasons.append("manufacturing requirement has no semantic name")
+
+        representation_ids = tuple(dict.fromkeys(representations.get(entity_id, ())))
+        representation_id = representation_ids[0] if len(representation_ids) == 1 else ""
+        if len(representation_ids) != 1:
+            reasons.append(
+                f"manufacturing requirement has {len(representation_ids)} linked representations"
+            )
+
+        representation_name = ""
+        descriptive_ids: tuple[str, ...] = ()
+        if representation_id:
+            representation = _entity_named(step.get(representation_id), "REPRESENTATION")
+            if representation is None or len(representation.params) < 2:
+                reasons.append(
+                    f"linked representation {representation_id} is unavailable or malformed"
+                )
+            else:
+                representation_name = _text(representation.params[0])
+                descriptive_ids = tuple(
+                    dict.fromkeys(
+                        ref
+                        for ref in _references(representation.params[1])
+                        if _instance_is(step, ref, "DESCRIPTIVE_REPRESENTATION_ITEM")
+                    )
+                )
+
+        descriptive_item_id = descriptive_ids[0] if len(descriptive_ids) == 1 else ""
+        text = ""
+        if representation_id and len(descriptive_ids) != 1:
+            reasons.append(f"linked representation has {len(descriptive_ids)} descriptive items")
+        if descriptive_item_id:
+            item = _entity_named(step.get(descriptive_item_id), "DESCRIPTIVE_REPRESENTATION_ITEM")
+            if item is None or len(item.params) < 2:
+                reasons.append(f"descriptive item {descriptive_item_id} is malformed")
+            else:
+                text = _text(item.params[1])
+                if not text:
+                    reasons.append("manufacturing requirement has no authoritative text")
+
+        exact_callouts = tuple(
+            callout_id
+            for callout_id, name in callout_names.items()
+            if representation_name and name.casefold() == representation_name.casefold()
+        )
+        semantic_tokens = _name_tokens(semantic_name)
+        callout_ids = exact_callouts or tuple(
+            callout_id
+            for callout_id, name in callout_names.items()
+            if semantic_tokens and semantic_tokens <= _name_tokens(name)
+        )
+        missing_callout_associations = tuple(
+            callout_id for callout_id in callout_ids if not callout_aspects.get(callout_id)
+        )
+        if missing_callout_associations:
+            reasons.append(
+                "matched semantic callout(s) have no shape-aspect association: "
+                + ", ".join(missing_callout_associations)
+            )
+        shape_aspect_ids = tuple(
+            dict.fromkeys(
+                aspect_id
+                for callout_id in callout_ids
+                for aspect_id in callout_aspects.get(callout_id, ())
+            )
+        )
+        missing_aspect_items = tuple(
+            aspect_id for aspect_id in shape_aspect_ids if not aspect_items.get(aspect_id)
+        )
+        if missing_aspect_items:
+            reasons.append(
+                "associated shape aspect(s) have no representation items: "
+                + ", ".join(missing_aspect_items)
+            )
+        reference_item_ids = tuple(
+            dict.fromkeys(
+                item_id
+                for aspect_id in shape_aspect_ids
+                for item_id in aspect_items.get(aspect_id, ())
+            )
+        )
+        facts.append(
+            ManufacturingRequirementFact(
+                entity_id=entity_id,
+                semantic_name=semantic_name,
+                text=text,
+                representation_id=representation_id,
+                descriptive_item_id=descriptive_item_id,
+                callout_ids=tuple(dict.fromkeys(callout_ids)),
+                shape_aspect_ids=shape_aspect_ids,
+                reference_item_ids=reference_item_ids,
+                reason="; ".join(dict.fromkeys(reasons)),
+            )
+        )
+    return tuple(facts)
+
+
 def _unit_factor_mm(step, unit_ref: str) -> tuple[float | None, str]:
     unit = step.get(unit_ref)
     if unit is None:

{draftwright-0.4.10 → draftwright-0.4.12}/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(
@@ -1743,14 +1761,24 @@ class PlacementContext:
         """Place an annotation onto the drawing through this context (#817) — the render passes'
         door to the placement primitive, so a pass never reaches into the ``Drawing`` (ADR 0005
         §2). Registers *obj* under *name* (owning *view* + source *feature*) and appends it to the
-        render list. Returns *obj*."""
+        render list. Opaque compiler provenance is resolved here, at the placement boundary,
+        so public ``annotations_of(IR feature)`` / ``drop(IR feature)`` keep their value-based
+        contract for immediate passes as well as corridor-drained candidates. Returns *obj*."""
         if self.items is None:
             raise ValueError(
                 "PlacementContext.place() needs the drawing's render list — construct the context "
                 "with items=dwg.items (the orchestrator and Drawing verbs already do; a unit test "
                 "calling a render helper must pass it too)."
             )
-        return place_annotation(self.registry, self.items, obj, name, view, feature, measurement)
+        return place_annotation(
+            self.registry,
+            self.items,
+            obj,
+            name,
+            view,
+            resolve_feature(feature),
+            measurement,
+        )
 
     def feature_of_hole_at(self, location):
         """The IR hole/pattern feature whose member sits at model-space *location*, or ``None``