draftwright 0.4.11__tar.gz → 0.4.13__tar.gz

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

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

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

draftwright-0.4.13/src/draftwright/_build_profile.py

@@ -0,0 +1,186 @@
+"""Pytest plugin and runner support for reproducible build-cost profiles (#1307)."""
+
+from __future__ import annotations
+
+import json
+import re
+import sys
+from collections import defaultdict
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from functools import wraps
+from pathlib import Path
+from time import perf_counter
+from typing import Any
+
+_MIN_REPORT_SECONDS = 0.005
+_STATE: _ProfileState | None = None
+_CURRENT_NODEID = "<collection>"
+
+
+@dataclass
+class _ProfileState:
+    output_dir: Path
+    worker_id: str
+    collected: int | None = None
+    calls: dict[tuple[str, str], list[float]] = field(
+        default_factory=lambda: defaultdict(lambda: [0, 0.0])
+    )
+    phases: list[dict[str, Any]] = field(default_factory=list)
+
+    def record_call(self, seam: str, seconds: float) -> None:
+        aggregate = self.calls[(_CURRENT_NODEID, seam)]
+        aggregate[0] += 1
+        aggregate[1] += seconds
+
+    def write(self, exitstatus: int) -> Path:
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        safe_worker = re.sub(r"[^A-Za-z0-9_.-]", "_", self.worker_id)
+        path = self.output_dir / f"profile-{safe_worker}.json"
+        payload = {
+            "worker_id": self.worker_id,
+            "collected": self.collected,
+            "exitstatus": exitstatus,
+            "calls": [
+                {
+                    "nodeid": nodeid,
+                    "seam": seam,
+                    "count": int(values[0]),
+                    "seconds": values[1],
+                }
+                for (nodeid, seam), values in sorted(self.calls.items())
+            ],
+            "phases": self.phases,
+        }
+        path.write_text(json.dumps(payload, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+        return path
+
+
+def _timed(seam: str, function: Callable[..., Any]) -> Callable[..., Any]:
+    @wraps(function)
+    def wrapper(*args, **kwargs):
+        started = perf_counter()
+        try:
+            return function(*args, **kwargs)
+        finally:
+            assert _STATE is not None
+            _STATE.record_call(seam, perf_counter() - started)
+
+    return wrapper
+
+
+def pytest_addoption(parser) -> None:
+    group = parser.getgroup("draftwright-build-profile")
+    group.addoption(
+        "--build-profile-dir",
+        help="write one Draftwright build profile JSON file per pytest-xdist worker",
+    )
+
+
+def pytest_configure(config) -> None:
+    global _STATE
+    output = config.getoption("--build-profile-dir")
+    if not output:
+        return
+
+    worker_input = getattr(config, "workerinput", None)
+    # Under xdist the controller executes no tests; worker processes write the useful files.
+    if worker_input is None and getattr(config.option, "numprocesses", None):
+        return
+
+    worker_id = worker_input.get("workerid", "worker") if worker_input else "main"
+    _STATE = _ProfileState(Path(output).resolve(), worker_id)
+
+    import draftwright.builder as builder
+    import draftwright.sheet as sheet
+
+    draftwright = sys.modules["draftwright"]
+    builder_public = _timed("builder.build_drawing", builder.build_drawing)
+    builder.build_drawing = builder_public
+    # The public lazy package attribute and Sheet's import-time binding otherwise bypass a
+    # patch installed only on builder.py. That omission made the first #1307 census a lower
+    # bound, so all three bindings are explicit here.
+    setattr(draftwright, "build_drawing", builder_public)
+    sheet.build_drawing = _timed("sheet.build_drawing", sheet.build_drawing)
+    builder._build_drawing_once = _timed(
+        "builder._build_drawing_once", builder._build_drawing_once
+    )
+
+
+def pytest_collection_finish(session) -> None:
+    if _STATE is not None:
+        _STATE.collected = len(session.items)
+
+
+def pytest_runtest_logstart(nodeid, location) -> None:
+    del location
+    global _CURRENT_NODEID
+    _CURRENT_NODEID = nodeid
+
+
+def pytest_runtest_logfinish(nodeid, location) -> None:
+    del nodeid, location
+    global _CURRENT_NODEID
+    _CURRENT_NODEID = "<between-tests>"
+
+
+def pytest_runtest_logreport(report) -> None:
+    if _STATE is not None and report.duration >= _MIN_REPORT_SECONDS:
+        _STATE.phases.append(
+            {
+                "nodeid": report.nodeid,
+                "phase": report.when,
+                "seconds": report.duration,
+                "outcome": report.outcome,
+            }
+        )
+
+
+def pytest_sessionfinish(session, exitstatus) -> None:
+    del session
+    if _STATE is not None:
+        _STATE.write(int(exitstatus))
+
+
+def build_pytest_command(output_dir: Path, pytest_args: list[str]) -> list[str]:
+    """Return argv without joining *pytest_args* into a shell-expanded module string."""
+    return [
+        "uv",
+        "run",
+        "pytest",
+        "-p",
+        "draftwright._build_profile",
+        f"--build-profile-dir={output_dir}",
+        *pytest_args,
+    ]
+
+
+def summarise_profiles(output_dir: Path, expected_collected: int) -> dict[str, Any]:
+    paths = sorted(output_dir.glob("profile-*.json"))
+    if not paths:
+        raise ValueError(f"no worker profiles were written to {output_dir}")
+
+    by_seam: dict[str, list[float]] = defaultdict(lambda: [0, 0.0])
+    workers = []
+    for path in paths:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+        collected = payload.get("collected")
+        if collected != expected_collected:
+            raise ValueError(
+                f"{path.name} collected {collected!r}, expected {expected_collected}; "
+                "refusing to report a successful empty or partial profile"
+            )
+        workers.append(payload["worker_id"])
+        for call in payload["calls"]:
+            aggregate = by_seam[call["seam"]]
+            aggregate[0] += call["count"]
+            aggregate[1] += call["seconds"]
+
+    return {
+        "expected_collected": expected_collected,
+        "workers": workers,
+        "seams": {
+            seam: {"count": int(values[0]), "seconds": values[1]}
+            for seam, values in sorted(by_seam.items())
+        },
+    }

{draftwright-0.4.11 → draftwright-0.4.13}/src/draftwright/_geometry.py

@@ -456,6 +456,15 @@ def _convex_polygons_overlap(left, right) -> bool:
 
     if len(left) < 3 or len(right) < 3:
         return False
+    left_x, left_y = zip(*left, strict=True)
+    right_x, right_y = zip(*right, strict=True)
+    if (
+        max(left_x) <= min(right_x)
+        or max(right_x) <= min(left_x)
+        or max(left_y) <= min(right_y)
+        or max(right_y) <= min(left_y)
+    ):
+        return False
     axes: list[tuple[float, float]] = []
     for points in (left, right):
         axes.extend(

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

@@ -830,6 +830,37 @@ def leader_callout_geometry(tip, elbow, draft, *, text_side="auto", callout_box=
     return label_box, segments
 
 
+def analytical_leader_lands_clear(
+    candidate,
+    obstacles,
+    silhouette,
+    page,
+    *,
+    label,
+    geom_clear=False,
+) -> bool:
+    """Apply the producer's label/full-ink clearance floor to an unbuilt leader."""
+    label_box = candidate.label_box
+    if not label or label_box is None:
+        return False
+    check_box = label_box
+    if geom_clear:
+        xs = [label_box[0], label_box[2]]
+        ys = [label_box[1], label_box[3]]
+        for polygon in candidate.ink_polygons:
+            xs.extend(point[0] for point in polygon)
+            ys.extend(point[1] for point in polygon)
+        check_box = (min(xs), min(ys), max(xs), max(ys))
+    return not (
+        _box_hits(check_box, obstacles)
+        or _box_hits(label_box, [silhouette])
+        or label_box[0] < page[0]
+        or label_box[1] < page[1]
+        or label_box[2] > page[2]
+        or label_box[3] > page[3]
+    )
+
+
 def leader_footprint(tip, elbow, draft, *, text_side="auto", callout_box=None):
     """Analytical page-mm AABB ``(x0, y0, x1, y1)`` of the :class:`Leader` that
     ``Leader(tip, elbow, label="", draft, text_side=…, callout=…)`` would build —
@@ -1761,14 +1792,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``