python-cad-tools 0.1.17__tar.gz → 0.1.18__tar.gz

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18}/CHANGELOG.md

@@ -7,6 +7,30 @@ stable release is published.
 
 ## [Unreleased]
 
+## [0.1.18] - 2026-10-08
+
+### Fixed
+
+- Curved B-rep solids (spheres, `cylinder_between` cylinders and other curved
+  shapes) no longer fail `build` and `verify` with `artifact_integrity:
+  IFC/design bounds mismatch`. The design manifest records each element's
+  `body_bounds_mm` (the bounds of the body IFC actually writes: the mesh of a
+  tessellated solid, the exact shape for recipes), and the IFC check compares
+  against it at the same `1e-6` tolerance. Manifests without the field fall
+  back to `bounds_mm`. `body_bounds_mm` describes the export, not the design,
+  so it is left out of `semantic_hash`: design hashes are unchanged, and
+  `validate` does not tessellate.
+- `validate` reports a build123d `Part` (or compound) that holds one solid as
+  `solid-wrapped` with the fix (`.solid()`), instead of a bare
+  `solid-invalid`.
+
+### Changed
+
+- A build tessellates each element once and shares the mesh between the
+  design manifest, IFC and GLB (`geometry.shared_tessellation`), instead of
+  IFC and GLB each meshing it. `benge-property-cad`'s full build went from
+  106 s to 67 s on the owner's Mac.
+
 ## [0.1.16] - 2026-09-22
 
 ### Fixed

{python_cad_tools-0.1.17/src/python_cad_tools.egg-info → python_cad_tools-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cad-tools
-Version: 0.1.17
+Version: 0.1.18
 Summary: Typed, headless Python tooling for CAD/BIM models and artifacts
 Author: Brandon Benge
 License: AGPL-3.0-only

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18}/docs/public-api.md

@@ -16,13 +16,15 @@ of optional runtime imports.
   `cubic_yards`, `metres`, and `square_metres`.
 - `python_cad_tools.geometry`: `box`, `reference_line`, `cylinder_between`,
   `prism_between`, `sloped_pool`, `bounds`, `combined_bounds`, `tessellate`,
-  `is_valid_solid`, and `diagonal`. **Curved geometry that must pass the
-  build pipeline's `artifact_integrity` IFC/design-bounds check should not
-  use `cylinder_between`** -- its tessellated B-rep output cannot exactly
-  match analytic design-side bounds. Use `python_cad_tools.recipes`'
-  `CircleProfile` + `ExtrudedProfile` instead; see
-  [`cylinder_between`'s docstring](../src/python_cad_tools/geometry.py) and
-  `docs/spikes/curved-geometry-ifc-bounds.md` for the confirmed mechanism.
+  `is_valid_solid`, and `diagonal`. Curved B-rep solids (`cylinder_between`,
+  build123d spheres and other curved shapes) build and verify: IFC writes
+  them as triangle meshes, and the IFC bounds check compares that mesh with
+  the same tessellation recorded in the design manifest as `body_bounds_mm`
+  (0.1.18). Use `python_cad_tools.recipes`' `CircleProfile` +
+  `ExtrudedProfile` where an analytic IFC body is wanted instead of a mesh.
+  Pass a `Solid`: build123d algebra-mode shapes such as `Sphere(...)` are a
+  `Part` wrapping one solid, which `validate` reports as `solid-wrapped`
+  (use `.solid()`).
 - `python_cad_tools.drawings`: `Point2`, `Direction`, `DrawingStyleToken`,
   `DrawingSheet`, `Line`, `Polyline`, `Text`, `Dimension`, `SectionCallout`,
   `ElevationMarker`, `TableRow`, `Table`, `SheetAnnotations`, and

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18}/docs/spikes/curved-geometry-ifc-bounds.md

@@ -1,4 +1,21 @@
-# Curved geometry vs. the IFC/design bounds integrity check (mechanism confirmed empirically)
+# Curved geometry vs. the IFC/design bounds integrity check
+
+**Resolved in 0.1.18 (2026-10-08).** The mechanism is confirmed in source:
+elements without a recipe are written to IFC as an `IfcTriangulatedFaceSet`
+from `tessellate(geometry, 0.5, 0.25)`, the IFC report's bounds are read back
+from those mesh coordinates, and the manifest recorded only the exact B-rep
+bounds; `_reconcile_formats` compared the two at `1e-6`. The fix is candidate
+direction 1 below ("compare like with like"): the design manifest now records
+`body_bounds_mm`, the bounds of the same tessellation
+(`geometry.IFC_TESSELLATION`, shared with the exporter), and the IFC check
+compares against it, still exactly. A live hosted run on 2026-10-08 ("change
+the cube to a sphere", `Sphere(152.4).solid()`) failed with x/y short by
+0.58 mm before the fix; `tests/integration/test_curved_geometry.py` covers a
+sphere, a `cylinder_between` cylinder, a box, and a tampered IFC report.
+Approval: `specrepo/approved/2026-10-08-curved-geometry-ifc-bounds/` (workspace).
+
+The history below is kept as it was written.
+
 
 Status: **mechanism confirmed, fix known — not yet verified against this
 repo's own source.** A later sandbox-agent attempt on the same project (see

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18}/src/python_cad_tools/artifacts.py

@@ -14,7 +14,7 @@ from xml.etree import ElementTree
 
 from .determinism import semantic_hash, sha256_file
 from .exceptions import ArtifactIntegrityError, BuildExportError
-from .manifests import load_json_document, validate_json_document
+from .manifests import design_semantic_projection, load_json_document, validate_json_document
 from .validation import ValidationIssue
 
 BUILD_MANIFEST_RELATIVE = "manifests/build-manifest.json"
@@ -153,9 +153,8 @@ def verify_output_root(output_root: Path, project_root: Path | None = None) -> V
         _verify_sources(project_root, document)
     selected = _selected_formats(document)
     design = load_design_manifest(output_root / "manifests/design-manifest.json")
-    design_without_hash = dict(design)
-    recorded_design_hash = design_without_hash.pop("semantic_hash", None)
-    if recorded_design_hash != semantic_hash(design_without_hash):
+    recorded_design_hash = design.get("semantic_hash")
+    if recorded_design_hash != semantic_hash(design_semantic_projection(design)):
         raise ArtifactIntegrityError("Design manifest semantic_hash does not reproduce")
     if document["design_semantic_hash"] != design["semantic_hash"]:
         raise ArtifactIntegrityError("Build and design manifest semantic hashes disagree")
@@ -386,7 +385,11 @@ def _reconcile_formats(root: Path, formats: tuple[str, ...]) -> None:
             for item in elements
             if item["physical"] and "ifc" in item["export_formats"] and item["ifc_class"] is not None
         ]
-        _require_matching_bounds("IFC", report["bounds_mm"], _combined_manifest_bounds(expected_elements))
+        # Tessellated IFC bodies are meshes; compare them with the same mesh, recorded in the
+        # manifest as body_bounds_mm (0.1.18). Older manifests fall back to the exact bounds.
+        _require_matching_bounds(
+            "IFC", report["bounds_mm"], _combined_manifest_bounds(expected_elements, key="body_bounds_mm")
+        )
         _reconcile_ifc_extensions(root, formats, report, expected_elements)
     if "glb" in formats:
         from .exporters.glb import glb_json
@@ -536,14 +539,15 @@ def _normalized_text(value: str) -> str:
     return " ".join(value.split())
 
 
-def _combined_manifest_bounds(elements: list[dict[str, Any]]) -> list[float]:
+def _combined_manifest_bounds(elements: list[dict[str, Any]], key: str = "bounds_mm") -> list[float]:
     if not elements:
         return [0.0] * 6
+    values = [item.get(key) or item["bounds_mm"] for item in elements]
     return [
-        round(min(float(item["bounds_mm"][index]) for item in elements), 6)
+        round(min(float(value[index]) for value in values), 6)
         for index in range(3)
     ] + [
-        round(max(float(item["bounds_mm"][index]) for item in elements), 6)
+        round(max(float(value[index]) for value in values), 6)
         for index in range(3, 6)
     ]
 

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18}/src/python_cad_tools/build.py

@@ -22,6 +22,7 @@ from .determinism import semantic_hash, sha256_file, write_json
 from .exceptions import BuildExportError, ModelValidationError, ProjectConfigError, UnsafePathError
 from .exporters import GlbExporter, IfcExporter, QuantityExporter, StepExporter
 from .exporters.drawings import DrawingExporter
+from .geometry import shared_tessellation
 from .manifests import build_manifest_document, design_manifest, write_preinventory_manifests
 from .project_config import FORMAT_ORDER, load_project_config, output_path, resolve_project_root
 from .validation import ValidationIssue, fatal_issues
@@ -82,7 +83,7 @@ def build_project(options: BuildOptions) -> BuildResult:
         raise TypeError("build_project expects BuildOptions")
     requested = _validate_requested_formats(options.formats)
     root = resolve_project_root(options.project_root)
-    with project_execution():
+    with project_execution(), shared_tessellation():
         with project_lock(root):
             config = load_project_config(root)
             formats = config.default_formats if requested is None else requested
@@ -173,7 +174,7 @@ def validate_project(options: ValidationOptions) -> ValidationReport:
                 formats=formats,
                 issues=loaded.issues,
                 source_set_hash=source_set_hash,
-                design_semantic_hash=design_manifest(loaded.model)["semantic_hash"],
+                design_semantic_hash=design_manifest(loaded.model, include_body_bounds=False)["semantic_hash"],
                 annotation_provider_id=(
                     None if loaded.annotations is None else loaded.annotations.provider_id
                 ),

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18}/src/python_cad_tools/exporters/ifc.py

@@ -17,7 +17,7 @@ from ifcopenshell import ifcopenshell_wrapper
 from ..determinism import normalized_build_epoch, write_json
 from ..elements import DesignElement, Opening
 from ..exceptions import BuildExportError, ModelValidationError
-from ..geometry import bounds, tessellate
+from ..geometry import IFC_TESSELLATION, bounds, tessellate
 from ..recipes import (
     CircleProfile,
     DifferenceRecipe,
@@ -326,7 +326,7 @@ def _build_representation(file, context, element: DesignElement) -> tuple[Any, s
     BREP instead.
     """
     if element.recipe is None:
-        vertices, triangles = tessellate(element.geometry, 0.5, 0.25)
+        vertices, triangles = tessellate(element.geometry, *IFC_TESSELLATION)
         points = file.createIfcCartesianPointList3D(vertices)
         face_set = file.createIfcTriangulatedFaceSet(
             points,
@@ -482,7 +482,7 @@ def _add_opening(file, context, host_product, storey, element, opening: Opening)
     The host element's ``geometry`` stays authoritative for every other
     format; the framework does not boolean-subtract the opening.
     """
-    vertices, triangles = tessellate(opening.geometry, 0.5, 0.25)
+    vertices, triangles = tessellate(opening.geometry, *IFC_TESSELLATION)
     points = file.createIfcCartesianPointList3D(vertices)
     face_set = file.createIfcTriangulatedFaceSet(
         points, None, True, [[index + 1 for index in triangle] for triangle in triangles], None

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18}/src/python_cad_tools/geometry.py

@@ -2,6 +2,9 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
 from math import isfinite, sqrt
 from typing import Any
 
@@ -51,20 +54,14 @@ def cylinder_between(
     end: tuple[Length, Length, Length],
     radius: Length,
 ) -> Solid:
-    """Build a tessellated B-rep cylinder between two points.
-
-    The returned solid is a polygonal approximation of a true cylinder
-    (~51-gon), not exact analytic geometry. Its IFC export bounds will not
-    exactly match the analytic design-side bounds computed from ``start``/
-    ``end``/``radius`` -- this reliably fails the build pipeline's
-    ``artifact_integrity`` IFC/design-bounds check (see
-    ``docs/spikes/curved-geometry-ifc-bounds.md``). For curved geometry that
-    must survive that check, author it with ``python_cad_tools.recipes``
-    (``CircleProfile`` + ``ExtrudedProfile``) instead, which exports exact
-    analytic IFC geometry and does not have this problem. Prefer
-    ``cylinder_between`` only where an approximate B-rep solid is acceptable
-    (e.g. it is never exported to IFC, or exact bounds agreement is not
-    checked).
+    """Build a B-rep cylinder between two points.
+
+    IFC exports it as a triangle mesh; the build's IFC bounds check compares
+    that mesh with the same tessellation recorded in the design manifest
+    (``body_bounds_mm``), so it builds and verifies like any other solid
+    (0.1.18; see ``docs/spikes/curved-geometry-ifc-bounds.md``). Where an
+    analytic IFC body is wanted instead of a mesh, author it with
+    ``python_cad_tools.recipes`` (``CircleProfile`` + ``ExtrudedProfile``).
     """
     _positive_lengths((radius,), "Cylinder radius")
     start_mm = _point(start, "Cylinder start")
@@ -152,11 +149,80 @@ def combined_bounds(shapes: list[Any]) -> tuple[float, float, float, float, floa
     )
 
 
+#: The (linear, angular) deflection of every tessellated IFC body. The design manifest's
+#: ``body_bounds_mm`` uses the same values, so the IFC bounds check compares the exported
+#: mesh with that same mesh (2026-10-08 approval, curved-geometry-ifc-bounds).
+IFC_TESSELLATION: tuple[float, float] = (0.5, 0.25)
+
+
+#: One build's tessellations, keyed by shape identity and deflections. The design manifest
+#: (``body_bounds_mm``), IFC and GLB all mesh each element with the same deflections, so a
+#: build meshes each shape once instead of up to three times. The value keeps the shape alive,
+#: so its ``id`` cannot be reused while the cache exists. Results are shared: callers must not
+#: mutate them.
+_TESSELLATIONS: ContextVar[dict[tuple[int, float, float], tuple[Any, Any]] | None] = ContextVar(
+    "python_cad_tools_tessellations", default=None
+)
+
+
+@contextmanager
+def shared_tessellation() -> Iterator[None]:
+    """Reuse each shape's tessellation for the duration of one build."""
+    token = _TESSELLATIONS.set({})
+    try:
+        yield
+    finally:
+        _TESSELLATIONS.reset(token)
+
+
 def tessellate(shape: Any, linear_deflection: float, angular_deflection: float) -> tuple[list[list[float]], list[list[int]]]:
+    cache = _TESSELLATIONS.get()
+    key = (id(shape), float(linear_deflection), float(angular_deflection))
+    if cache is not None:
+        hit = cache.get(key)
+        if hit is not None and hit[0] is shape:
+            result: tuple[list[list[float]], list[list[int]]] = hit[1]
+            return result
     vertices, triangles = shape.tessellate(linear_deflection, angular_deflection)
     points = [[float(vertex.X), float(vertex.Y), float(vertex.Z)] for vertex in vertices]
     faces = [[int(index) for index in triangle] for triangle in triangles]
-    return points, faces
+    computed = (points, faces)
+    if cache is not None:
+        cache[key] = (shape, computed)
+    return computed
+
+
+def mesh_bounds(
+    shape: Any, linear_deflection: float, angular_deflection: float
+) -> tuple[float, float, float, float, float, float]:
+    """Bounds of ``shape``'s tessellation: what a mesh export of it actually contains.
+
+    A curved surface's mesh lies inside the true surface, so these can be tighter than
+    :func:`bounds`; for a flat-faced solid they are equal.
+    """
+    vertices, _ = tessellate(shape, linear_deflection, angular_deflection)
+    if not vertices:
+        return bounds(shape)
+    return (
+        min(vertex[0] for vertex in vertices),
+        min(vertex[1] for vertex in vertices),
+        min(vertex[2] for vertex in vertices),
+        max(vertex[0] for vertex in vertices),
+        max(vertex[1] for vertex in vertices),
+        max(vertex[2] for vertex in vertices),
+    )
+
+
+def single_wrapped_solid(shape: Any) -> Solid | None:
+    """The one valid solid inside a compound (such as build123d's algebra-mode ``Part``), or
+    ``None`` when ``shape`` is not such a wrapper."""
+    if isinstance(shape, Solid) or not hasattr(shape, "solids"):
+        return None
+    try:
+        solids = list(shape.solids())
+    except Exception:  # noqa: BLE001 -- any shape that cannot list solids is not a wrapper
+        return None
+    return solids[0] if len(solids) == 1 and is_valid_solid(solids[0]) else None
 
 
 def is_valid_solid(shape: Any) -> bool:

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18}/src/python_cad_tools/manifests.py

@@ -13,7 +13,7 @@ from typing import Any
 from . import __version__
 from .determinism import normalized_epoch_iso, semantic_hash, write_json
 from .exceptions import ArtifactIntegrityError
-from .geometry import bounds
+from .geometry import IFC_TESSELLATION, bounds, mesh_bounds
 from .recipes import DifferenceRecipe, ExtrudedProfile
 
 SCHEMAS: dict[str, tuple[int, frozenset[str]]] = {
@@ -68,7 +68,37 @@ _SNAKE_CASE = re.compile(r"[a-z][a-z0-9]*(?:_[a-z0-9]+)*\Z")
 _DRAWING_ID = re.compile(r"[A-Za-z0-9._-]+\Z", re.ASCII)
 
 
-def design_manifest(model: Any) -> dict[str, Any]:
+def _body_bounds(element: Any) -> tuple[float, float, float, float, float, float]:
+    """Bounds of the body the IFC exporter writes: the mesh of a tessellated solid, the exact
+    shape otherwise (recipes are exported analytically; non-solids are not meshed)."""
+    if element.recipe is None and element.geometry_kind == "solid":
+        return mesh_bounds(element.geometry, *IFC_TESSELLATION)
+    return bounds(element.geometry)
+
+
+#: Per-element manifest keys that describe an export (not the design) and so are left out of
+#: ``semantic_hash``: a project's design hash is the same with or without them, and
+#: ``validate`` (which reports the hash) need not tessellate every element.
+_EXPORT_ONLY_ELEMENT_KEYS = frozenset({"body_bounds_mm"})
+
+
+def design_semantic_projection(manifest: dict[str, Any]) -> dict[str, Any]:
+    """The design manifest as hashed: without ``semantic_hash`` and export-only element keys."""
+    projected = {key: value for key, value in manifest.items() if key != "semantic_hash"}
+    elements = projected.get("elements")
+    if isinstance(elements, list):
+        projected["elements"] = [
+            {key: value for key, value in item.items() if key not in _EXPORT_ONLY_ELEMENT_KEYS}
+            if isinstance(item, dict)
+            else item
+            for item in elements
+        ]
+    return projected
+
+
+def design_manifest(model: Any, *, include_body_bounds: bool = True) -> dict[str, Any]:
+    """The design manifest. ``include_body_bounds=False`` skips ``body_bounds_mm`` (and its
+    tessellation) when only the semantic hash is needed; the hash is the same either way."""
     elements = []
     for element in model.walk():
         elements.append(
@@ -79,6 +109,11 @@ def design_manifest(model: Any) -> dict[str, Any]:
                 "geometry_kind": element.geometry_kind,
                 "physical": element.physical,
                 "bounds_mm": [round(value, 6) for value in bounds(element.geometry)],
+                **(
+                    {"body_bounds_mm": [round(value, 6) for value in _body_bounds(element)]}
+                    if include_body_bounds
+                    else {}
+                ),
                 "placement": {
                     "translation_mm": element.placement.translation_mm,
                     "rotation_deg_xyz": element.placement.rotation_deg_xyz,
@@ -119,7 +154,7 @@ def design_manifest(model: Any) -> dict[str, Any]:
         "glb": {"site_path": f"artifacts/glb/{model.artifact_stem}.glb"},
         "elements": elements,
     }
-    value["semantic_hash"] = semantic_hash(value)
+    value["semantic_hash"] = semantic_hash(design_semantic_projection(value))
     return value
 
 

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18}/src/python_cad_tools/validation.py

@@ -15,7 +15,7 @@ from build123d import (
 
 from .elements import DesignElement, DesignModel, MaterialSpec, Opening, Placement
 from .exceptions import ModelValidationError
-from .geometry import bounds, is_valid_solid
+from .geometry import bounds, is_valid_solid, single_wrapped_solid
 from .recipes import (
     ROTATION_X_RANGE,
     ROTATION_Y_RANGE,
@@ -108,9 +108,21 @@ def _validate_element(
     if element.physical and element.geometry_kind != "solid":
         issues.append(ValidationIssue("physical-kind", "error", "Physical elements must be solids", element_id=element.id))
     if element.physical and element.geometry is not None and not is_valid_solid(element.geometry):
-        issues.append(
-            ValidationIssue("solid-invalid", "error", "Physical geometry must be a valid positive-volume solid", element_id=element.id)
-        )
+        if single_wrapped_solid(element.geometry) is not None:
+            issues.append(
+                ValidationIssue(
+                    "solid-wrapped",
+                    "error",
+                    "Geometry is a Part/Compound containing one solid; pass `.solid()` (the single Solid) instead",
+                    element_id=element.id,
+                )
+            )
+        else:
+            issues.append(
+                ValidationIssue(
+                    "solid-invalid", "error", "Physical geometry must be a valid positive-volume solid", element_id=element.id
+                )
+            )
     if not element.physical and element.geometry_kind == "solid":
         issues.append(
             ValidationIssue(

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18/src/python_cad_tools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cad-tools
-Version: 0.1.17
+Version: 0.1.18
 Summary: Typed, headless Python tooling for CAD/BIM models and artifacts
 Author: Brandon Benge
 License: AGPL-3.0-only

{python_cad_tools-0.1.17 → python_cad_tools-0.1.18}/src/python_cad_tools.egg-info/scm_file_list.json

@@ -263,6 +263,7 @@
     "src/python_cad_tools/validation.py",
     "tests/conftest.py",
     "tests/integration/test_build_transactions.py",
+    "tests/integration/test_curved_geometry.py",
     "tests/integration/test_drawing_extensions.py",
     "tests/integration/test_exports.py",
     "tests/integration/test_project_loading.py",
@@ -271,6 +272,7 @@
     "tests/packaging/test_toolchain.py",
     "tests/typing/public_project.py",
     "tests/typing/test_external_typing.py",
+    "tests/unit/test_curved_geometry_units.py",
     "tests/unit/test_drawings.py",
     "tests/unit/test_manifests.py",
     "tests/unit/test_model_contract.py",

python_cad_tools-0.1.18/src/python_cad_tools.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.1.18",
+  "distance": 0,
+  "node": "ge909d6f9394ae6f2a5ee80d99f5a8cac772d09de",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-09"
+}

python_cad_tools-0.1.17/src/python_cad_tools.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.1.17",
-  "distance": 0,
-  "node": "g96a733187ecf50a799b65f04f064a2f9a7fd3867",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-07"
-}