draftwright 0.3.0__tar.gz → 0.3.1__tar.gz

{draftwright-0.3.0 → draftwright-0.3.1}/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## v0.3.1 — 2026-07-17
+
+Also lands the **#635 consolidation epic** (P1–P6, all six children closed): the render
+layer's state bus is retired (`annotations/` reads zero `Drawing` privates,
+machine-enforced), the three complexity hotspots are split (nesting ≤2), the whole-package
+import DAG + a test-import ratchet are enforced, and the test suite gains a Hypothesis fuzz
+tier + relational cross-kernel placement gates. All internal / behaviour-preserving
+(byte-identical golden) — no output change.
+
+### Added
+
+- **PNG raster export** — `--format png` on the CLI, or `Drawing.export(formats=("png",))`.
+  Rendered SVG → PDF → PNG via **pypdfium2** (Apache-2.0, Google PDFium BSD-3) + **Pillow**
+  (HPND) — both permissively licensed and pure-wheel, so PNG works cross-platform with **no
+  native cairo** (ADR 0006) and keeps the render path dual-license-friendly. `dpi=` sets the
+  raster resolution.
+
+### Changed
+
+- **Unified export API** — `Drawing.export(out, *, formats=("pdf",)) → {format: path}` is now
+  the single entry point over `svg`/`dxf`/`pdf`/`png`; it returns a dict and internally handles
+  the SVG→PDF→PNG intermediate chain (writing/cleaning up intermediates it wasn't asked to keep).
+  The CLI `--format` gains `png`.
+
+### Deprecated
+
+- `Drawing.export_pdf()` — use `export(formats=("pdf",))["pdf"]`; the method now warns.
+- The legacy `export(svg=, dxf=)` boolean keywords and their `(svg_path, dxf_path)` tuple return
+  — kept for back-compat; prefer `formats=[...]` (the dict API).
+
 ## v0.3.0 — 2026-07-14
 
 **Breaking — feature-recogniser API renamed** (ADR 0013 / #568): *deliberate* breaks with

{draftwright-0.3.0 → draftwright-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.3.0
+Version: 0.3.1
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -686,6 +686,8 @@ Requires-Dist: build123d-drafting-helpers>=0.13.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'
 Requires-Dist: numpy>=1.24
+Requires-Dist: pillow>=10
+Requires-Dist: pypdfium2>=4
 Requires-Dist: reportlab>=4.0
 Requires-Dist: svglib>=1.5
 Requires-Dist: typer>=0.12

{draftwright-0.3.0 → draftwright-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.3.0"
+version = "0.3.1"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -19,6 +19,11 @@ dependencies = [
     "build123d>=0.11,<0.12 ; python_full_version >= '3.13'",
     "build123d-drafting-helpers>=0.13.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
+    # deps — so PNG works cross-platform without cairo (ADR 0006) and stays dual-license-clean.
+    "pillow>=10",
+    "pypdfium2>=4",
     "reportlab>=4.0",
     "svglib>=1.5",
     "typer>=0.12",
@@ -112,6 +117,7 @@ ignore = ["E501"]
 [dependency-groups]
 dev = [
     "codespell>=2.3.0",
+    "hypothesis>=6",
     "mypy>=2.1.0",
     "pytest>=8",
     "pytest-cov>=5",

{draftwright-0.3.0 → draftwright-0.3.1}/src/draftwright/__init__.py

@@ -30,12 +30,12 @@ _LAZY = {
     "make_drawing": "draftwright.builder",
     "Drawing": "draftwright.drawing",
     "FeatureInfo": "draftwright.drawing",
-    "Sheet": "draftwright.sheet_dsl",
+    "Sheet": "draftwright.sheet",
     "fix_svg_page_size": "draftwright.export",
     "lint_feature_coverage": "draftwright.linting",
     "PmiRecord": "draftwright.pmi",
     "extract_pmi": "draftwright.pmi",
-    "choose_scale": "draftwright.sheet",
+    "choose_scale": "draftwright.compose",
 }
 
 
@@ -74,13 +74,13 @@ _sys.modules[__name__].__class__ = _DraftwrightModule
 if TYPE_CHECKING:  # static analysers / IDEs — no runtime import, no kernel cost
     from draftwright.analysis import dedup_diams
     from draftwright.builder import build_drawing, generate_script, make_drawing
+    from draftwright.compose import choose_scale
     from draftwright.drawing import Drawing, FeatureInfo
     from draftwright.export import fix_svg_page_size
     from draftwright.linting import lint_feature_coverage
     from draftwright.pmi import PmiRecord, extract_pmi
     from draftwright.recognition import recognise_face_levels
-    from draftwright.sheet import choose_scale
-    from draftwright.sheet_dsl import Sheet
+    from draftwright.sheet import Sheet
 
 
 def __dir__():

{draftwright-0.3.0 → draftwright-0.3.1}/src/draftwright/_core.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 
 import functools
 import logging
+import math
 import re
 from collections.abc import Callable
 from dataclasses import dataclass
@@ -20,8 +21,8 @@ from types import SimpleNamespace
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
+    from draftwright.compose import StripDepths
     from draftwright.recognition import TurnedProfile
-    from draftwright.sheet import StripDepths
 
 from build123d import Align, BoundBox, Location, Mode, Shape, Text
 from build123d_drafting.helpers import (
@@ -133,9 +134,40 @@ def _text_width(text: str, font_size: float, font_path: str = PLEX_MONO) -> floa
     )
 
 
+# Cheap mean glyph advance as a fraction of the em (font size), for label-width ESTIMATES in
+# the diameter row/column capacity checks. Plex Mono is monospaced at ~0.6 em, padded a touch.
+# The exact metric is `_text_width()` above (measured per string), which the corridor/label
+# placers use; these capacity gates only need a close bound, not the metric, so they trade
+# exactness for not rasterising a text layout per candidate. The two may diverge for unusually
+# wide/narrow glyph runs.
+_EST_CHAR_WIDTH_EM = 0.62
+
+
 _CONCENTRIC_TOL_MM = 0.5
 
 
+def _first_free_index(prefix: str, taken) -> int:
+    """The lowest ``j`` for which ``f"{prefix}{j}"`` is not in *taken* (a set or any container
+    supporting ``in``). The shared kernel of the first-free annotation-name allocators
+    (``_loc_name``/``_uniq``/``_hc_name``) — used where reusing a freed gap is fine. NOTE: the
+    step-length / diameter runs deliberately use ``max+1`` instead (``_next_start`` /
+    ``_next_steplen_start``), because a contiguous run started at a gap below an occupied index
+    would wrap onto it (#432); don't fold those onto this."""
+    j = 0
+    while f"{prefix}{j}" in taken:
+        j += 1
+    return j
+
+
+def _concentric_with_axis(a, x: float, y: float) -> bool:
+    """True when the page/world point ``(x, y)`` lies on the rotational part's turned axis
+    (within :data:`_CONCENTRIC_TOL_MM`). A bore/pattern centred on the axis needs no location
+    dim — its position is the axis — so several passes filter such refs; this is the single
+    radial test they share (the perpendicular-plane distance to the axis centre ``(a.cx,
+    a.cy)``). Callers still gate on ``a.is_rotational`` / role / axis as their context needs."""
+    return math.hypot(x - a.cx, y - a.cy) <= _CONCENTRIC_TOL_MM
+
+
 def _dim(p1, p2, side, distance, draft, **kwargs):
     """Build a :class:`Dimension`, tagged with its placement spec.
 
@@ -154,11 +186,14 @@ def _dim(p1, p2, side, distance, draft, **kwargs):
 
 # Dimension-line spacing (page-mm, scale-independent), the single source of truth for
 # BOTH the ADR 0009 strip carve (via the `Strip` dataclass defaults below) and the
-# sheet.py halo/depth estimates that must reserve the same space. Per ISO 129-1 / ASME
+# compose.py halo/depth estimates that must reserve the same space. Per ISO 129-1 / ASME
 # Y14.5, the FIRST dimension line sits furthest from the outline (clears the outline +
 # extension-line origins) and subsequent parallel lines stack tighter and uniform (#347).
 _STRIP_GAP = 10.0  # clearance between the view outline and the first dimension line
 _STRIP_SPACING = 2.5  # clear gap between successive parallel dimension lines (beyond the label)
+# Small lift (page-mm) of an overall/envelope witness line off the projected silhouette edge,
+# so its extension line reads as distinct from the outline rather than sitting on top of it.
+_WITNESS_LIFT_MM = 2.0
 
 
 @dataclass
@@ -353,7 +388,8 @@ def _largest_empty_rect(drawable, obstacles, *, warn: bool = True):
 @dataclass
 class DetailRequest:
     """A renderer's request for an enlarged detail of a region it could not draw
-    legibly at sheet scale (#307). Renderers append these to ``dwg._detail_requests``
+    legibly at sheet scale (#307). Renderers append these to the run's
+    ``PlacementContext.detail_requests``
     instead of building bespoke detail views; ``_resolve_details`` resolves them all
     through one generic detailer (crop → project → place → caption → marker), then
     calls ``redraw`` to draw the feature's own dims inside the placed detail view.
@@ -600,7 +636,7 @@ def _iso_bbox(dwg):
 
 
 # --- page/scale selection + sheet-layout constants and helpers --------------
-# Relocated from make_drawing for the sheet.py split (#162). Shared by sheet.py
+# Relocated from make_drawing for the compose.py (née sheet.py) split (#162). Shared by compose.py
 # (choose_scale/_layout_geometry) and make_drawing's repack pass, so they live
 # here in the shared base to keep the DAG acyclic.
 # The base inter-view corridor: one first-line gap + one dimension tier. Tracks

{draftwright-0.3.0 → draftwright-0.3.1}/src/draftwright/analysis.py

@@ -2,10 +2,10 @@
 
 `_analyse` imports the part (STEP or Shape), runs feature detection (holes,
 patterns, cylinders, face levels), classifies it (rotational vs prismatic),
-chooses the sheet (scale/page via `sheet.choose_scale`) and lays out the view
-zones (`sheet._layout_geometry`/`_build_zones`) — returning the `Analysis`
-namespace the rest of the pipeline reads. Sits above `sheet` and below
-`make_drawing` in the DAG.
+chooses the sheet (scale/page via `compose.choose_scale`) and lays out the view
+zones (`compose._layout_geometry`/`_build_zones`) — returning the `Analysis`
+namespace the rest of the pipeline reads. Sits above `compose` (née `sheet`,
+#640) and below `builder` in the DAG.
 """
 
 from __future__ import annotations
@@ -32,6 +32,15 @@ from draftwright._core import (
     _legible_steps,
     _Projector,
 )
+from draftwright.compose import (
+    StripDepths,
+    _build_zones,
+    _est_hole_table_sizes,
+    _est_planned_bore_callout_width,
+    _layout_geometry,
+    _measure_strips,
+    choose_scale,
+)
 from draftwright.model import build_part_model
 from draftwright.model.ir import Datum, PartModel, StepFeature
 from draftwright.model.planner import plan_dimensions
@@ -47,15 +56,6 @@ from draftwright.recognition import (
     recognise_turned_steps,
     step_level_zs,
 )
-from draftwright.sheet import (
-    StripDepths,
-    _build_zones,
-    _est_hole_table_sizes,
-    _est_planned_bore_callout_width,
-    _layout_geometry,
-    _measure_strips,
-    choose_scale,
-)
 
 _log = logging.getLogger(__name__)
 

{draftwright-0.3.0 → draftwright-0.3.1}/src/draftwright/annotations/_common.py

@@ -9,10 +9,12 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass, field
+from typing import Any
 
 from build123d_drafting.helpers import Dimension, SafeDimension
 
 from draftwright.layout import StripCandidate, plan_strip
+from draftwright.linting.issues import LintIssue
 from draftwright.linting.structural import _centerline_extent
 
 _log = logging.getLogger(__name__)
@@ -22,7 +24,8 @@ _log = logging.getLogger(__name__)
 class Escalation:
     """A first-class "could not place this here" signal (ADR 0009 Amendment 1, P5-strand-2).
 
-    Placers *collect* one of these into ``dwg._escalations`` at the point of failure —
+    Placers *collect* one of these into the run's ``PlacementContext.escalations`` at the point
+    of failure —
     instead of recording a stringly-typed ``*_dropped`` lint code and letting the escalators
     grep for it — and one later resolver pass groups them by ``(view, feature-or-pattern)``,
     picks a remedy per group (ISO pattern-grouped balloon / table / detail / drop), and emits
@@ -519,25 +522,89 @@ def solve_corridor(dwg, strip, view, axis, cands, tier):
                 _promote_losers(c)
 
 
-def register_corridor(dwg, key, strip, view, axis, tier, cand):
+@dataclass
+class PlacementContext:
+    """The per-run placement scratch a build's passes share — plus references to the drawing's
+    build-state stores (the ``registry`` build-issue sink + ``coverage`` bookkeeping) — threaded
+    to the passes explicitly instead of hung on the ``Drawing`` result object (ADR 0005 §2, #639):
+    the corridor batch
+    (:func:`register_corridor`/:func:`drain_corridors`), the escalation list (ADR 0009 Amdt 1,
+    #351), and the enlarged-detail request list (#307).
+
+    All three are per-run — both entry paths (:func:`_auto_annotate` and ``Drawing.finalize``)
+    make a fresh one each build and discard it after draining/consuming. The corridor batch is a
+    pure function of the still-present intents; escalations/detail-requests need no cross-retry
+    persistence either, because finalize is transactional (#647): a raised drain rolls the drawing
+    back and the retry re-runs from a clean slate, re-generating them."""
+
+    corridor_batch: dict = field(default_factory=dict)
+    escalations: list = field(default_factory=list)
+    detail_requests: list = field(default_factory=list)
+    # The drawing's build-state stores, referenced (not owned) by the run's passes (#639).
+    # Duck-typed as ``Any`` — matching the untyped ``Drawing._record_build_issue`` they replace —
+    # so mypy does not reject the delegating calls below.
+    registry: Any = None  # the drawing's AnnotationRegistry: build-issue sink + names
+    coverage: Any = None  # the drawing's CoverageState
+    # The ensured PartModel (ADR 0008 IR) the run's passes read, threaded off the drawing so
+    # they no longer reach into ``dwg._part_model`` (#639). Both entry paths set it from the
+    # PUBLIC ``dwg.model()`` after the model is ensured/attached.
+    part_model: Any = None
+    # Whether the model was DECLARED (vs detected) — the ADR 0011 gate the orchestrator reads,
+    # threaded off ``getattr(dwg, "_model_declared")`` (#639).
+    model_declared: bool = False
+    # Per-run cache for :meth:`feature_of_hole_at` — the model is fixed after build, so a
+    # per-ctx (per-run) index is correct (mirrors the old ``Drawing._hole_feature_index``).
+    _hole_feature_index: Any = field(default=None, repr=False)
+
+    def feature_of_hole_at(self, location):
+        """The IR hole/pattern feature whose member sits at model-space *location*, or ``None``
+        (#408/#639). Attributes a balloon (which carries a recognition hole, not the IR feature)
+        to its feature so :meth:`Drawing.drop` clears it. Cached on the run's ctx — the model is
+        fixed after build."""
+        m = self.part_model
+        if m is None:
+            return None
+        if self._hole_feature_index is None:
+            idx: dict = {}
+            for f in getattr(m, "features", []):
+                if getattr(f, "kind", None) in ("hole", "pattern"):
+                    for loc in getattr(f, "members", None) or (f.frame.origin,):
+                        idx[tuple(round(c, 3) for c in loc)] = f
+            self._hole_feature_index = idx
+        return self._hole_feature_index.get(tuple(round(c, 3) for c in location))
+
+    def record_issue(self, severity, code, message) -> None:
+        """Record a build-time lint issue on the run's registry (#639). Replaces the passes'
+        old `dwg._record_build_issue`."""
+        self.registry.record_issue(LintIssue(severity=severity, code=code, message=message))
+
+    def reset_issues(self) -> None:
+        self.registry.reset_issues()
+
+    def drop_issues(self, *codes) -> None:
+        self.registry.drop_issues(codes)
+
+
+def register_corridor(ctx, key, strip, view, axis, tier, cand):
     """Queue a :class:`CorridorCandidate` under a shared corridor *key* so one
     :func:`drain_corridors` places the whole cross-pass set together (ADR 0009 end state).
     The first registration for a key fixes its ``(strip, view, axis)``; mixed producers on
     the same corridor use the largest requested tier so spacing is not registration-order
     dependent."""
-    b = dwg._corridor_batch.setdefault(
+    b = ctx.corridor_batch.setdefault(
         key, {"strip": strip, "view": view, "axis": axis, "tier": tier, "cands": []}
     )
     b["tier"] = max(b["tier"], tier)
     b["cands"].append(cand)
 
 
-def drain_corridors(dwg):
+def drain_corridors(ctx, dwg):
     """Solve every registered corridor (one :func:`solve_corridor` per strip), then clear
-    the batch. Called once, after all corridor-feeding passes have registered."""
-    for b in dwg._corridor_batch.values():
+    the batch. Called once, after all corridor-feeding passes have registered. Takes both the
+    scratch *ctx* (the batch) and *dwg* (the drawing :func:`solve_corridor` places onto)."""
+    for b in ctx.corridor_batch.values():
         solve_corridor(dwg, b["strip"], b["view"], b["axis"], b["cands"], b["tier"])
-    dwg._corridor_batch = {}
+    ctx.corridor_batch = {}
 
 
 def place_strip_candidates(