python-cad-tools 0.1.13__tar.gz → 0.1.16__tar.gz

python_cad_tools-0.1.16/.opencode/tools/specrepo-autocommit.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+"""Run the LangChain AutoCommit CLI for a verified SpecRepo change."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import site
+import subprocess
+import sys
+from pathlib import Path
+from typing import NoReturn
+
+AUTOCOMMIT_REPOSITORY = "git+https://github.com/brandon-benge/langchain_autocommit.git"
+CONFIGURATION_GUIDE = "https://github.com/brandon-benge/langchain_autocommit/blob/main/README.md#config-overrides"
+EX_USAGE = 64
+
+
+def print_usage() -> None:
+    print(
+        'Usage: specrepo-autocommit "<summary of what changed>" [--no-push] '
+        "[--config-file <path>] [--env-var-name <NAME>] [--base-url <URL>] "
+        "[--model <MODEL>]\n\n"
+        "Runs autocommit on the current git branch.\n"
+        "--config-file points to the YAML configuration to use; defaults to "
+        "AUTOCOMMIT_PARAMS, then to .autoconfig.yaml in this repository.\n"
+        "--no-push commits locally without pushing to the remote.\n"
+        "--env-var-name, --base-url, and --model override the LLM API key "
+        "environment variable, base URL, and model that .autoconfig.yaml "
+        "otherwise supplies, e.g. to point at the AI Settings selected in "
+        "the Mac app.",
+        file=sys.stderr,
+    )
+
+
+def fail(message: str, *, config_path: Path | None = None, code: int = 1) -> NoReturn:
+    print(message, file=sys.stderr)
+    if config_path is not None:
+        print(f"AUTOCOMMIT_PARAMS location: {config_path}", file=sys.stderr)
+        print(
+            f"Update that file as needed. Configuration guide: {CONFIGURATION_GUIDE}",
+            file=sys.stderr,
+        )
+    raise SystemExit(code)
+
+
+def get_config_path(explicit_path: str | None = None) -> Path:
+    if explicit_path:
+        config_path = Path(os.path.expandvars(explicit_path)).expanduser().resolve()
+        print(f"--config-file is set to: {config_path}", flush=True)
+    else:
+        raw_path = os.environ.get("AUTOCOMMIT_PARAMS", "").strip()
+        if raw_path:
+            config_path = Path(os.path.expandvars(raw_path)).expanduser().resolve()
+            print(f"AUTOCOMMIT_PARAMS is set to: {config_path}", flush=True)
+        else:
+            config_path = (
+                Path(__file__).resolve().parent.parent.parent / ".autoconfig.yaml"
+            )
+            print(f"AUTOCOMMIT_PARAMS not set, using local fallback: {config_path}", flush=True)
+
+    if not config_path.is_file():
+        fail(
+            "Autocommit blocked: the configuration file does not exist or is not a regular file.",
+            config_path=config_path,
+        )
+
+    return config_path
+
+
+def get_current_branch(config_path: Path) -> str:
+    try:
+        symbolic_ref = subprocess.run(
+            ["git", "symbolic-ref", "--quiet", "--short", "HEAD"],
+            check=False,
+            capture_output=True,
+            text=True,
+        )
+        branch = symbolic_ref.stdout.strip()
+
+        if not branch:
+            revision = subprocess.run(
+                ["git", "rev-parse", "--short", "HEAD"],
+                check=False,
+                capture_output=True,
+                text=True,
+            )
+            branch = revision.stdout.strip()
+    except OSError as error:
+        fail(
+            f"Autocommit blocked: could not run git: {error}",
+            config_path=config_path,
+        )
+
+    if not branch:
+        fail(
+            "Autocommit blocked: could not determine the current git branch.",
+            config_path=config_path,
+        )
+
+    return branch
+
+
+def find_autocommit() -> str | None:
+    executable = shutil.which("autocommit")
+    if executable:
+        return executable
+
+    scripts_directory = Path(site.getuserbase()) / ("Scripts" if os.name == "nt" else "bin")
+    candidate = scripts_directory / ("autocommit.exe" if os.name == "nt" else "autocommit")
+    return str(candidate) if candidate.is_file() else None
+
+
+def ensure_autocommit_installed(config_path: Path) -> str:
+    executable = find_autocommit()
+    if executable:
+        return executable
+
+    print("autocommit CLI not found. Installing it with the current Python...")
+    try:
+        installation = subprocess.run(
+            [
+                sys.executable,
+                "-m",
+                "pip",
+                "install",
+                "--user",
+                AUTOCOMMIT_REPOSITORY,
+            ],
+            check=False,
+        )
+    except OSError as error:
+        fail(
+            f"Autocommit installation failed: {error}",
+            config_path=config_path,
+        )
+
+    if installation.returncode != 0:
+        fail(
+            f"Autocommit installation failed with exit code {installation.returncode}.",
+            config_path=config_path,
+            code=installation.returncode,
+        )
+
+    executable = find_autocommit()
+    if not executable:
+        fail(
+            "Autocommit was installed but its executable could not be found.",
+            config_path=config_path,
+        )
+
+    print("autocommit installed successfully.")
+    return executable
+
+
+def run_autocommit(
+    executable: str,
+    config_path: Path,
+    summary: str,
+    branch: str,
+    no_push: bool = False,
+    env_var_name: str | None = None,
+    base_url: str | None = None,
+    model: str | None = None,
+) -> None:
+    print(f"Running autocommit on branch {branch}.")
+    command = [
+        executable,
+        "--yes",
+        "--config-file",
+        str(config_path),
+        "-c",
+        summary,
+    ]
+    if no_push:
+        command.append("--no-push")
+    if env_var_name:
+        command += ["--env-var", "--env-var-name", env_var_name]
+    if base_url:
+        command += ["--base-url", base_url]
+    if model:
+        command += ["--model", model]
+    try:
+        result = subprocess.run(command, check=False)
+    except OSError as error:
+        fail(
+            f"Autocommit failed to start: {error}",
+            config_path=config_path,
+        )
+
+    if result.returncode != 0:
+        fail(
+            f"Autocommit failed with exit code {result.returncode}.",
+            config_path=config_path,
+            code=result.returncode if result.returncode > 0 else 1,
+        )
+
+
+def main(argv: list[str]) -> int:
+    # Extract --no-push, --config-file <path>, and the LLM override flags
+    # before joining the remainder into the summary.
+    no_push = False
+    config_file: str | None = None
+    env_var_name: str | None = None
+    base_url: str | None = None
+    model: str | None = None
+    positional: list[str] = []
+    args_iter = iter(argv[1:])
+    for arg in args_iter:
+        if arg == "--no-push":
+            no_push = True
+        elif arg in ("--config-file", "--env-var-name", "--base-url", "--model"):
+            try:
+                value = next(args_iter)
+            except StopIteration:
+                print_usage()
+                fail(
+                    f"Autocommit blocked: {arg} requires a value argument.",
+                    code=EX_USAGE,
+                )
+            if arg == "--config-file":
+                config_file = value
+            elif arg == "--env-var-name":
+                env_var_name = value
+            elif arg == "--base-url":
+                base_url = value
+            else:
+                model = value
+        else:
+            positional.append(arg)
+
+    config_path = get_config_path(config_file)
+
+    if not positional or not " ".join(positional).strip():
+        print_usage()
+        fail(
+            "Autocommit blocked: a summary of what changed is required.",
+            config_path=config_path,
+            code=EX_USAGE,
+        )
+
+    summary = " ".join(positional).strip()
+    branch = get_current_branch(config_path)
+    executable = ensure_autocommit_installed(config_path)
+    run_autocommit(
+        executable,
+        config_path,
+        summary,
+        branch,
+        no_push=no_push,
+        env_var_name=env_var_name,
+        base_url=base_url,
+        model=model,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv))

{python_cad_tools-0.1.13 → python_cad_tools-0.1.16}/CHANGELOG.md

@@ -7,6 +7,66 @@ stable release is published.
 
 ## [Unreleased]
 
+## [0.1.16] - 2026-09-22
+
+### Fixed
+
+- `python-cad --version` (and every other CLI invocation) no longer requires
+  `build123d`/the rest of the CAD toolchain to be importable: `cli.py`'s
+  `ValidationIssue` import — annotation-only, never evaluated at runtime
+  under this module's `from __future__ import annotations` — moved behind
+  `TYPE_CHECKING`. This was silently blocking every release since 0.1.14:
+  `build-publish` requires `tests/packaging` to pass, and its
+  clean-install-then-`--version` check installs the wheel with `--no-deps`,
+  which cannot satisfy the transitive `build123d` import `--version` didn't
+  actually need. 0.1.14 and 0.1.15 were tagged but never reached PyPI as a
+  result; 0.1.13 remained the latest published release throughout.
+
+## [0.1.15] - 2026-09-22
+
+### Changed
+
+- `models/**/*.py` no longer needs an explicit `source-inputs` entry, at any
+  package depth and whether or not it has an `__init__.py`. `models/` is the
+  one directory a project is expected to keep adding files to over its
+  lifetime — one new module per new design object — so requiring a
+  `pyproject.toml` edit for each new file added no safety benefit: the build
+  manifest's `source_set_hash` already covers every file actually imported,
+  declared or not. `config.py`, `model.py`, `drawing_annotations.py`, and
+  `pyproject.toml` itself are unaffected and still require explicit
+  declaration, as does any other project-root Python file or data file read
+  through the public context. See `docs/project-configuration.md`.
+
+## [0.1.14] - 2026-08-13
+
+### Added
+
+- New public `python_cad_tools.recipes` module: an opt-in, declarative
+  construction-recipe vocabulary (`RectangleProfile`, `CircleProfile`,
+  `ExtrudedProfile`, `DifferenceRecipe`, `evaluate`) that lets Tier 1
+  authoring produce parametric BREP IFC geometry
+  (`IfcExtrudedAreaSolid`/`SweptSolid`, `IfcBooleanResult`/`CSG`) instead of
+  only tessellated meshes. New `DesignElement.recipe` field, appended last;
+  `geometry` may now be `None` when a recipe is present. Recipes are
+  strictly opt-in per element — a model with no recipes produces IFC output
+  byte-identical to before this change, since neither recipe type adds a
+  unit-assignment entry. See `docs/neutral-model.md#construction-recipes`.
+- The IFC validation sidecar gains additive `element_representation_types`
+  and `element_topology` keys; the design manifest gains additive
+  `recipe_kind` and `topology` per-element keys. `schema_version` is
+  unchanged on both.
+
+### Changed
+
+- The IFC sidecar's `bounds_mm` is now the union of tessellation-derived
+  bounds and evaluated-solid bounds, so BREP-only and mixed models report
+  correct bounds (a BREP element emits no `IfcCartesianPointList3D`, which
+  the previous derivation depended on exclusively).
+- `python-cad validate`'s CLI error message now includes each failing
+  issue's `element_id` (formatted as `code[element_id]: message`) when the
+  issue has one, instead of only `code: message`. Issues without an
+  element, such as `model-id`, are unaffected.
+
 ## [0.1.11] - 2026-08-11
 
 ### Added

{python_cad_tools-0.1.13/src/python_cad_tools.egg-info → python_cad_tools-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cad-tools
-Version: 0.1.13
+Version: 0.1.16
 Summary: Typed, headless Python tooling for CAD/BIM models and artifacts
 Author: Brandon Benge
 License: AGPL-3.0-only
@@ -187,6 +187,12 @@ Project code should preserve stable semantic IDs, keep geometry parametric, and
 create geometry and metadata together. Generated artifacts are outputs, never
 design inputs.
 
+`python_cad_tools.recipes` lets an element opt into parametric BREP IFC
+geometry (`IfcExtrudedAreaSolid`/`SweptSolid`, `IfcBooleanResult`/`CSG`)
+instead of the default tessellated mesh, verified by a topology round-trip
+after every build. See
+[`docs/neutral-model.md#construction-recipes`](docs/neutral-model.md#construction-recipes).
+
 Project-owned drawing annotations use the typed, renderer-independent boundary
 documented in [`docs/drawing-extensions.md`](docs/drawing-extensions.md). One
 annotation set is validated and rendered consistently to SVG, DXF, and PDF

{python_cad_tools-0.1.13 → python_cad_tools-0.1.16}/README.md

@@ -131,6 +131,12 @@ Project code should preserve stable semantic IDs, keep geometry parametric, and
 create geometry and metadata together. Generated artifacts are outputs, never
 design inputs.
 
+`python_cad_tools.recipes` lets an element opt into parametric BREP IFC
+geometry (`IfcExtrudedAreaSolid`/`SweptSolid`, `IfcBooleanResult`/`CSG`)
+instead of the default tessellated mesh, verified by a topology round-trip
+after every build. See
+[`docs/neutral-model.md#construction-recipes`](docs/neutral-model.md#construction-recipes).
+
 Project-owned drawing annotations use the typed, renderer-independent boundary
 documented in [`docs/drawing-extensions.md`](docs/drawing-extensions.md). One
 annotation set is validated and rendered consistently to SVG, DXF, and PDF

{python_cad_tools-0.1.13 → python_cad_tools-0.1.16}/docs/neutral-model.md

@@ -14,7 +14,7 @@ dimensions), and the validator invocation model. See
 | `id` | `str` | Stable, unique identifier. Used to derive every downstream IFC `GlobalId` and to key manifests. |
 | `name` | `str` | Human-readable display name. |
 | `category` | `str` | Free-text classification, exported as `ObjectType` in IFC. |
-| `geometry` | `Any` | A build123d-compatible solid, shell, wire, or edge. Required and opaque — the framework does not restrict how it was built. |
+| `geometry` | `Any` | A build123d-compatible solid, shell, wire, or edge. Required and opaque — the framework does not restrict how it was built. May be `None` when `recipe` is present; the framework materializes it. |
 | `geometry_kind` | `"solid" \| "shell" \| "wire" \| "edge" \| "reference"` | Declares the geometry's topological kind. Physical elements must be `"solid"`. |
 | `placement` | `Placement` | Translation (mm) and rotation (degrees, XYZ) applied on top of `geometry`'s own coordinates. |
 | `dimensions` | `Dimensions` | Declared, author-stated extents. Independent of the geometry's actual bounds; exported into `Pset_PythonCadDesign`. |
@@ -31,6 +31,7 @@ dimensions), and the validator invocation model. See
 | `physical` | `bool` | Physical elements must be `"solid"` and require a material; non-physical (reference) elements are excluded from IFC, quantities, and mass. |
 | `parent_id` | `str \| None` | Parent element ID, exported as an `IfcRelAggregates` relationship when both ends are IFC-exported. |
 | `openings` | `list[Opening]` | Semantic voids in this host element. See "Openings" below. |
+| `recipe` | `ConstructionRecipe \| None` | Opt-in declarative geometry. See "Construction recipes" below. |
 
 ## `IfcMapping`
 
@@ -131,8 +132,109 @@ returning a `list[ValidationIssue]`. `fatal_issues(...)` filters to
 `severity == "error"`; `python-cad build`/`validate` fail on any fatal issue
 before export begins.
 
-## Construction recipes (Phase 2)
+## Construction recipes
 
-Parametric BREP/SweptSolid IFC representation via a construction-recipe model
-(`python_cad_tools.recipes`) is scoped as a separate SpecRepo proposal and is
-not yet implemented. This section will be extended when that proposal ships.
+`python_cad_tools.recipes` lets Tier 1 authoring produce **parametric BREP**
+IFC geometry instead of only tessellated meshes, for the two shapes
+evidenced as needed by real downstream models: an extruded 2D profile, and
+one extruded profile with a second subtracted from it. Recipes are strictly
+**opt-in per element** — omitting `DesignElement.recipe` preserves today's
+tessellated output byte-for-byte.
+
+### Type vocabulary
+
+```python
+RectangleProfile(x_dim_mm: float, y_dim_mm: float, position: Placement = Placement())   # -> IfcRectangleProfileDef
+CircleProfile(radius_mm: float, position: Placement = Placement())                       # -> IfcCircleProfileDef
+Profile = RectangleProfile | CircleProfile
+
+ExtrudedProfile(profile: Profile, direction: tuple[float, float, float], depth_mm: float)  # -> IfcExtrudedAreaSolid
+DifferenceRecipe(base: ExtrudedProfile, tool: ExtrudedProfile)                             # -> IfcBooleanResult(Operator=DIFFERENCE)
+ConstructionRecipe = ExtrudedProfile | DifferenceRecipe
+```
+
+Both profile types are centered at the origin, matching IFC's own
+`IfcRectangleProfileDef`/`IfcCircleProfileDef` semantics. `direction` and
+`depth_mm` are independent fields, mirroring `IfcExtrudedAreaSolid`'s
+`ExtrudedDirection`/`Depth` split — `direction`'s magnitude is ignored, only
+its direction matters. `DifferenceRecipe.base`/`.tool` are typed as
+`ExtrudedProfile`, not `ConstructionRecipe`: nesting is structurally
+impossible, not merely unvalidated. There is no `RevolvedProfile`,
+`PolygonProfile`, or general recursive boolean type — each would be a new
+SpecRepo request; see `specrepo/rejected/2026-08-12-...-brep-recipes/` for
+why the original, broader vocabulary was withdrawn in favor of this one.
+
+### Three authoring shapes
+
+- **Recipe only** (`recipe` set, `geometry=None`) — the framework evaluates
+  the recipe through build123d and assigns the result to `geometry`.
+  Recommended: the same solid then feeds STEP, GLB, drawings, quantities,
+  bounds, and the tessellated fallback, while IFC additionally gets the
+  parametric BREP.
+- **Recipe and geometry** (both set) — the framework evaluates the recipe
+  and verifies it against the supplied `geometry` (volume relative
+  tolerance `1e-6`, bounds absolute tolerance `1e-6` mm, equal face and
+  edge counts). A mismatch is an error-severity
+  `ValidationIssue("recipe-geometry-mismatch", ...)`. The supplied
+  `geometry` object is kept — only its equivalence is asserted.
+  Evaluation for this comparison happens in `validate_model`, not the
+  loader, and does not overwrite `geometry`.
+- **No recipe** — today's behavior, unchanged in every respect.
+
+### Recipe → IFC entity map
+
+| Recipe | IFC entity | `RepresentationType` |
+| --- | --- | --- |
+| `ExtrudedProfile` | `IfcExtrudedAreaSolid` | `"SweptSolid"` |
+| `DifferenceRecipe` | `IfcBooleanResult` (`Operator=DIFFERENCE`) over two `IfcExtrudedAreaSolid` operands | `"CSG"` |
+| *(no recipe)* | `IfcTriangulatedFaceSet` | `"Tessellation"` |
+
+Neither recipe type carries an angle measure, so the IFC unit assignment is
+unchanged — no `PLANEANGLEUNIT` entry, and no existing project's IFC hash
+changes, including for projects that adopt a recipe.
+
+### Topology round-trip verification
+
+After writing the file, for each element with a recipe the exporter
+reloads it, parses the emitted representation item back into a recipe,
+asserts it is structurally equal to the authored recipe (floating-point
+precision, relative/absolute tolerance `1e-9`), re-evaluates the parsed
+recipe, and compares the result against the authored solid
+(`element.geometry`) on face count, edge count, and volume (relative
+tolerance `1e-6`), plus bounds (absolute tolerance `1e-6` mm) as a sanity
+check. Any mismatch raises `BuildExportError` naming the element and the
+differing measure. This parses-and-re-evaluates rather than reading
+topology out of the reloaded BREP directly, because the framework pins
+`cadquery-ocp-novtk` (OCP) rather than pythonocc (OCC); `ifcopenshell.geom`'s
+OCC integration is unavailable and its default iterator path triangulates,
+destroying the topology the check is meant to compare.
+
+The IFC validation sidecar records `element_representation_types` (element
+id → `"Tessellation"` / `"SweptSolid"` / `"CSG"`) and `element_topology`
+(element id → face count, edge count, volume, for recipe elements only).
+The design manifest records the same information per element as
+`recipe_kind` (`null` / `"extruded_profile"` / `"difference"`) and, for
+recipe elements, `topology`. `bounds_mm` in the sidecar is the union of
+tessellation-derived bounds and evaluated-solid bounds, since a BREP-only
+element emits no `IfcCartesianPointList3D` for the older derivation to read.
+
+### Relationship to `openings`
+
+`DesignElement.openings` (see "Openings" above) never subtracts material
+from the host's own geometry — it only declares an `IfcOpeningElement`/
+`IfcRelVoidsElement` semantic relationship on top of whatever geometry the
+host already has. `DifferenceRecipe` is what makes the host's actual solid
+have material missing where a door or window belongs — the two mechanisms
+are complementary, not alternatives. A fully-converted host wall uses both:
+`DifferenceRecipe` for the real notch, `openings` for the semantic
+annotation. A project that only wants the semantic annotation keeps that
+option without adopting a recipe at all.
+
+### Display trade-off
+
+A single `DifferenceRecipe` is a common, well-supported IFC authoring
+pattern, but any `IfcBooleanResult`/`CSG` representation may still render
+less cleanly in some BIM viewers than a plain `SweptSolid`. Prefer a bare
+`ExtrudedProfile` over `DifferenceRecipe` wherever the notch isn't actually
+needed as real geometry — falling back to `openings` alone for the semantic
+relationship.

{python_cad_tools-0.1.13 → python_cad_tools-0.1.16}/docs/project-configuration.md

@@ -24,7 +24,15 @@ duplicate inputs fail before project Python runs.
 absolute paths, backslashes, traversal components, missing files, and
 directories are rejected. It must include `pyproject.toml`. Every project-root
 Python file imported during an operation and every data file read through the
-public context must be listed. There is no recursive source guessing.
+public context must be listed, with one exception: any `models/**/*.py` file
+is always authoritative and never needs a `source-inputs` entry, at any
+package depth and whether or not it has an `__init__.py`. `models/` is the
+one directory a project is expected to keep adding files to over its
+lifetime -- one new module per new design object -- so it is exempt from
+declaration; everything else still has no recursive source guessing. The
+build manifest's `source_set_hash` still covers every file actually
+imported, declared or not, so this exemption changes only what must be
+declared up front, not what a build's determinism claim is based on.
 
 ## Entry points
 
@@ -64,9 +72,11 @@ with context.open_source("data/materials.csv") as stream:
     materials = stream.read()
 ```
 
-These paths must also appear in `source-inputs`. `BuildContext` contains only
-`project_root`, `config`, `source_revision`, and `source_dirty`; it has no output
-or staging path.
+These paths must also appear in `source-inputs` -- the `models/**/*.py`
+exemption above covers imported Python modules only, not data files read
+through this API, even when the path happens to fall under `models/`.
+`BuildContext` contains only `project_root`, `config`, `source_revision`, and
+`source_dirty`; it has no output or staging path.
 
 ## Isolation and environment
 

{python_cad_tools-0.1.13 → python_cad_tools-0.1.16}/docs/public-api.md

@@ -22,6 +22,9 @@ of optional runtime imports.
   `ElevationMarker`, `TableRow`, `Table`, `SheetAnnotations`, and
   `DrawingAnnotationSet`.
 - `python_cad_tools.validation`: `ValidationIssue`.
+- `python_cad_tools.recipes`: `RectangleProfile`, `CircleProfile`, `Profile`,
+  `ExtrudedProfile`, `DifferenceRecipe`, `ConstructionRecipe`, and
+  `evaluate`. See [Construction recipes](neutral-model.md#construction-recipes).
 - `python_cad_tools.build`: `FormatName`, `BuildOptions`, `ValidationOptions`,
   `BuildResult`, `ValidationReport`, `build_project`, `validate_project`, and
   `clean_project`.

{python_cad_tools-0.1.13 → python_cad_tools-0.1.16}/src/python_cad_tools/_project_loader.py

@@ -18,6 +18,8 @@ from pathlib import Path
 from types import ModuleType
 from typing import Any, cast
 
+from build123d import Standard_ConstructionError, Standard_Failure, StdFail_NotDone
+
 from ._project_state import authoritative_path, begin_source_tracking, end_source_tracking, record_source
 from .context import BuildContext, DrawingContext
 from .drawings import DrawingAnnotationSet, DrawingSheet
@@ -26,8 +28,20 @@ from .drawings._validation import validate_annotation_set
 from .elements import DesignModel
 from .exceptions import BuildLockedError, CadToolsError, ModelValidationError, ProjectConfigError
 from .project_config import ProjectConfig, load_project_config, split_callable_target
+from .recipes import evaluate as evaluate_recipe
 from .validation import ValidationIssue, validate_model
 
+# Recipe evaluation failures are intentionally swallowed here (geometry is
+# left None) rather than raised: validate_model's own recipe rule
+# re-evaluates and reports a proper ValidationIssue. This keeps failure
+# reporting on one path instead of having the loader partially duplicate it.
+_RECIPE_EVALUATION_EXCEPTIONS = (
+    ModelValidationError,
+    Standard_Failure,
+    Standard_ConstructionError,
+    StdFail_NotDone,
+)
+
 _PROJECT_EXECUTION_LOCK = threading.Lock()
 _PROJECT_EXECUTION_LOCAL = threading.local()
 _NAMESPACE_COUNTER = itertools.count()
@@ -144,6 +158,7 @@ def _load_project_model_locked(project_root: Path, *, include_drawings: bool) ->
             raise ModelValidationError(
                 f"Model entry point {project_config.model_target!r} returned {type(model).__name__}; expected DesignModel"
             )
+        _evaluate_recipes(model)
         issues = tuple(validate_model(model))
         drawing_sheets: tuple[DrawingSheet, ...] = ()
         annotations: DrawingAnnotationSet | None = None
@@ -169,7 +184,11 @@ def _load_project_model_locked(project_root: Path, *, include_drawings: bool) ->
         accessed.update(_project_module_sources(project_root, snapshot.modules))
         accessed.update(end_source_tracking(token))
         tracking_active = False
-        undeclared = sorted(accessed - project_config.declared_sources)
+        undeclared = sorted(
+            path
+            for path in accessed - project_config.declared_sources
+            if not _is_always_authoritative(path)
+        )
         if undeclared:
             raise ProjectConfigError(
                 "Loaded authoritative project input(s) missing from source-inputs: " + ", ".join(undeclared)
@@ -192,6 +211,39 @@ def _load_project_model_locked(project_root: Path, *, include_drawings: bool) ->
         snapshot.restore()
 
 
+def _is_always_authoritative(relative_path: str) -> bool:
+    """``models/**/*.py`` never needs an explicit ``source-inputs`` entry.
+
+    Every other authoritative input -- ``pyproject.toml``, ``config.py``, ``model.py``,
+    ``drawing-annotations`` -- is a single, fixed entry point that a project declares once
+    and rarely changes; requiring it in ``source-inputs`` catches an accidental undeclared
+    import. ``models/`` is different by design (see docs/project-configuration.md): it is
+    the one directory a project is expected to keep adding files to over its lifetime, one
+    new module per new design object, with no fixed membership to declare up front. Making
+    each new file a `source-inputs` edit before it can be imported would turn an expected,
+    routine addition into a two-file change for no safety benefit -- the manifest hash
+    already covers every accessed path regardless of declaration (`accessed`, not
+    `declared_sources`, feeds `source_inputs` on `LoadedProject` below), so this exemption
+    narrows only the *validation gate*, not what a build's determinism claim is based on.
+    """
+    return relative_path.startswith("models/") and relative_path.endswith(".py")
+
+
+def _evaluate_recipes(model: DesignModel) -> None:
+    """Materialize ``element.geometry`` from ``element.recipe`` before
+    validation, but only when ``geometry`` is not already supplied — the
+    recipe+geometry authoring shape keeps the author's object identity, and
+    its equivalence check happens independently inside ``validate_model``.
+    """
+    for element in model.walk():
+        if element.recipe is None or element.geometry is not None:
+            continue
+        try:
+            element.geometry = evaluate_recipe(element.recipe)
+        except _RECIPE_EVALUATION_EXCEPTIONS:
+            continue
+
+
 def _install_namespace(namespace: str, project_root: Path) -> None:
     package = ModuleType(namespace)
     package.__file__ = None

{python_cad_tools-0.1.13 → python_cad_tools-0.1.16}/src/python_cad_tools/artifacts.py

@@ -20,6 +20,7 @@ from .validation import ValidationIssue
 BUILD_MANIFEST_RELATIVE = "manifests/build-manifest.json"
 _HEX = re.compile(r"[0-9a-f]{64}\Z")
 _ARTIFACT_FIELDS = {"path", "size", "sha256", "media_type", "producer", "schema_id", "schema_version", "volatile"}
+_EXPECTED_REPRESENTATION_TYPE = {None: "Tessellation", "extruded_profile": "SweptSolid", "difference": "CSG"}
 
 
 @dataclass(frozen=True, slots=True)
@@ -432,6 +433,25 @@ def _reconcile_ifc_extensions(
     }
     if actual_openings != expected_openings:
         raise ArtifactIntegrityError("IFC openings do not match the design manifest")
+    expected_representation_types = {
+        item["id"]: _EXPECTED_REPRESENTATION_TYPE[item["recipe_kind"]] for item in expected_elements
+    }
+    actual_representation_types = report.get("element_representation_types", {})
+    if actual_representation_types != expected_representation_types:
+        raise ArtifactIntegrityError("IFC representation types do not match the design manifest")
+    expected_topology = {
+        item["id"]: item["topology"] for item in expected_elements if item.get("recipe_kind") is not None
+    }
+    actual_topology = report.get("element_topology", {})
+    if set(actual_topology) != set(expected_topology):
+        raise ArtifactIntegrityError("IFC topology does not match the design manifest")
+    for element_id, expected_values in expected_topology.items():
+        actual_values = actual_topology[element_id]
+        for key in ("face_count", "edge_count"):
+            if expected_values[key] != actual_values[key]:
+                raise ArtifactIntegrityError(f"IFC topology {key} mismatch for {element_id}")
+        if abs(expected_values["volume_mm3"] - actual_values["volume_mm3"]) > 1e-6:
+            raise ArtifactIntegrityError(f"IFC topology volume_mm3 mismatch for {element_id}")
     if "quantities" in formats:
         quantities = load_json_document(root / "quantities/quantities.json")
         records_by_id = {record["element_id"]: record for record in quantities["records"]}

{python_cad_tools-0.1.13 → python_cad_tools-0.1.16}/src/python_cad_tools/build-info.json

@@ -1 +1 @@
-{"distribution":"python-cad-tools","schema_id":"urn:python-cad-tools:schema:package-build-info:1","schema_version":1,"source_commit":"cc89617eb61cffaf765a1b3e89ab4be4913e5dc7","source_dirty":true,"version":"0.1.11.dev1","viewer_shell_sha256":"2dac2bfef7884c40edb8abab348d7a574cda2037b5a3bbe8808acc7662e27d54"}
+{"distribution":"python-cad-tools","schema_id":"urn:python-cad-tools:schema:package-build-info:1","schema_version":1,"source_commit":"88544bff4c35b1b804776231bf4db8aac1b5c5f1","source_dirty":true,"version":"0.1.14.dev1","viewer_shell_sha256":"2dac2bfef7884c40edb8abab348d7a574cda2037b5a3bbe8808acc7662e27d54"}