draftwright 0.4.11__tar.gz → 0.4.12__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: draftwright
-Version: 0.4.11
+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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.4.11"
+version = "0.4.12"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }

{draftwright-0.4.11 → 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.11 → draftwright-0.4.12}/src/draftwright/annotations/_common.py

@@ -1761,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``