draftwright 0.3.0__tar.gz → 0.3.2__tar.gz

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

@@ -1,5 +1,80 @@
 # Changelog
 
+## v0.3.2 — 2026-07-18
+
+The **performance release**: the #602 perf loop (six PRs) plus the
+build123d-drafting-helpers 0.14 upgrade. A dimension-dense drawing now builds
+roughly **14× faster** than v0.3.1 (grid-plate benchmark 40 s → 2.8 s; NIST
+CTC-02 ~107 s → well under half); the full test tier dropped ~14 min → ~3.5 min.
+
+### Performance
+
+- **Placement measures, then builds** (#678, #679): corridor/strip candidates are
+  evaluated on analytical footprints (`dim_footprint`) or a single probe box; an
+  accepted candidate builds its OCC geometry exactly once and re-validates the
+  real box. Dimension constructions on the scattered-plate benchmark: 59 → 21
+  (= the placed count).
+- **Detect once** (#682): the sizing model `_analyse` builds pre-scale is stored
+  on `Analysis.model` and reused as the render model — restoring ADR 0008
+  Amendment 5 ("one inventory, detected once"). ~13 s off CTC-02.
+- **Fillet recognition de-quadratised** (#683): edge→faces adjacency map replaces
+  the O(faces²×edges²) `IsSame` sweep (3.7 M calls on CTC-02); 10.8 s → 4.6 s,
+  byte-identical records.
+- **Lint bounding boxes memoised** (#681): `Drawing.lint()` 0.88 s → 0.07 s per
+  call (identity+location-token-checked cache beside the #143 view-edge cache).
+- **DXF viewport from the known page window** (#680): skips `ezdxf.zoom.extents`'
+  per-entity walk; ~2.4 s per DXF export.
+- **helpers 0.14** (#684): boolean-free dimension ink (upstream #177, filed and
+  fixed same-day) — ~25 ms per `Dimension`, was ~234 ms.
+
+### Changed
+
+- **Tight-span dimensions now render honestly** (helpers 0.14): ISO outside
+  arrows where 0.13 silently degraded to a bare line. Ink extents grow on such
+  dims; placement models the flip analytically. Two placement-golden fixtures
+  re-blessed (ink extent only).
+- Diameter-row leader labels space by **measured text width** and repair
+  helpers' shelf-flip collisions (crowded rows only; ordinary rows unchanged).
+- A plate-thickness dim whose home strip corner is structurally contested falls
+  through to the opposite strip / side view instead of dropping (#684; the
+  underlying one-box-occupancy artifact is tracked as #685).
+
+### Fixed
+
+- `recognise_fillets` neighbour tie-break is order-independent (#683 review).
+- Lint's annotation-box cache prunes departed objects and detects in-place
+  relocation (#681 review).
+
+## 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.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: draftwright
-Version: 0.3.0
+Version: 0.3.2
 Summary: Automated technical-drawing generation for build123d
 Project-URL: Homepage, https://github.com/pzfreo/draftwright
 Project-URL: Repository, https://github.com/pzfreo/draftwright
@@ -682,10 +682,12 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering
 Requires-Python: <3.15,>=3.10
-Requires-Dist: build123d-drafting-helpers>=0.13.1
+Requires-Dist: build123d-drafting-helpers>=0.14.0
 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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "draftwright"
-version = "0.3.0"
+version = "0.3.2"
 description = "Automated technical-drawing generation for build123d"
 readme = "README.md"
 license = { file = "LICENSE" }
@@ -17,8 +17,13 @@ dependencies = [
     # 3.13+. Mirrors pzfreo/build123d-mcp's dependency handling.
     "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.13.1",
+    "build123d-drafting-helpers>=0.14.0",
     "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.2}/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.2}/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 (
@@ -106,8 +107,10 @@ _QUOTED_RE = re.compile(r"'([^']*)'")
 
 
 @functools.lru_cache(maxsize=512)
-def _text_width(text: str, font_size: float, font_path: str = PLEX_MONO) -> float:
-    """Measured rendered width (page-mm) of *text* at *font_size*.
+def _text_size(
+    text: str, font_size: float, font_path: str | None = PLEX_MONO, font: str = "Arial"
+) -> tuple[float, float]:
+    """Measured rendered (width, height) (page-mm) of *text* at *font_size*.
 
     Uses build123d's ``Text`` — the same primitive ``Dimension``/``HoleCallout``
     stroke their labels with — so callout-width estimates use real glyph metrics
@@ -115,27 +118,63 @@ def _text_width(text: str, font_size: float, font_path: str = PLEX_MONO) -> floa
     (``font_path``), not a system font *name*: name resolution substitutes a
     different font on Linux, which makes this estimate — and the layout it feeds —
     platform-variant (#149). The default is the same face the annotations render
-    with, so estimate and render agree.  Cached because the same numeric labels
-    recur across holes and the rasterisation is the costly part.
+    with, so estimate and render agree.  *font* only matters when a caller opts out
+    of path-pinning (``font_path=None``) — then the *name* resolves through the OS
+    font stack, exactly as the renderer would.  Cached because the same numeric
+    labels recur across holes and the rasterisation is the costly part.
     """
     if not text:
-        return 0.0
-    return (
-        Text(
-            txt=text,
-            font_size=font_size,
-            font_path=font_path,
-            align=(Align.CENTER, Align.CENTER),
-            mode=Mode.PRIVATE,
-        )
-        .bounding_box()
-        .size.X
-    )
+        return (0.0, 0.0)
+    bb = Text(
+        txt=text,
+        font_size=font_size,
+        font=font,
+        font_path=font_path,
+        align=(Align.CENTER, Align.CENTER),
+        mode=Mode.PRIVATE,
+    ).bounding_box()
+    return (bb.size.X, bb.size.Y)
+
+
+def _text_width(text: str, font_size: float, font_path: str = PLEX_MONO) -> float:
+    """Measured rendered width (page-mm) of *text* — see :func:`_text_size`."""
+    return _text_size(text, font_size, font_path)[0]
+
+
+# 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 +193,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 +395,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.
@@ -520,6 +563,12 @@ class Analysis:
     out: str
     pmi: list
     pmi_mode: str
+    # The PartModel built by _analyse's pre-scale sizing pass (#584 WP1 A) — stored so
+    # the render path reuses it instead of re-running the detectors (ADR 0008 Amdt 5:
+    # one inventory, detected once; #602). Typed `object` because model/ sits above
+    # _core in the DAG. None when the caller declared a model (ADR 0011) or on a
+    # manually-built Analysis — consumers fall back to build_model(a).
+    model: object | None = None
 
 
 _greedy_strip_ys = _greedy_strip_1d
@@ -600,7 +649,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.2}/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__)
 
@@ -772,4 +772,9 @@ def _analyse(
         out=out,
         pmi=pmi_records,
         pmi_mode=pmi,
+        # The sizing model IS the render model when detection ran (identical inputs by
+        # construction — #584 WP1 A); store it so the pipeline never detects twice
+        # (ADR 0008 Amdt 5, #602). A declared model (layout_model) is NOT stored: the
+        # builder coerces + decorates the caller's model itself.
+        model=sizing_model if layout_model is None else None,
     )