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

{python_cad_tools-0.1.11 → python_cad_tools-0.1.16}/.github/workflows/ci.yml

@@ -1,3 +1,22 @@
+# Main CI workflow: runs the full test/quality/packaging suite on
+# every PR and on push to main, and is also the ONE place that
+# publishes to PyPI.
+#
+# Publishing happens only in the `build-publish` job, gated behind
+# every other job via `needs:` and only when the ref being tested is
+# a "v*" tag (see the `if:` on that job). release.yml creates that
+# tag but pushes it using the default GITHUB_TOKEN, and GitHub does
+# not start new workflow runs from GITHUB_TOKEN-authored pushes (its
+# anti-recursion rule) — so the tag push alone won't reach this file.
+# Instead release.yml explicitly dispatches this workflow against the
+# new tag via `workflow_dispatch` below, which IS exempt from that
+# rule. `workflow_dispatch` is included here for that purpose (and
+# lets you manually re-run CI against any existing tag/ref by hand).
+#
+# release.yml itself does not build or publish anything — it only
+# creates the tag and triggers this run. Keeping publish logic in one
+# gated place (instead of duplicating it in release.yml) avoids two
+# workflows racing to publish the same version.
 name: CI
 
 on:
@@ -5,11 +24,14 @@ on:
     branches: [main]
     tags: ['v*']
   pull_request:
+  workflow_dispatch:
 
 permissions:
   contents: read
 
 jobs:
+  # Fastest signal: static checks plus unit/typing tests, so obvious
+  # problems fail before the slower jobs below even start.
   lint-type-unit:
     name: Lint, type, unit
     runs-on: ubuntu-latest
@@ -25,6 +47,8 @@ jobs:
       - run: mypy
       - run: pytest tests/unit tests/typing -q
 
+  # Integration tests against the real CAD/BIM/mesh/drawing exporter
+  # libraries (not mocked) to catch toolchain-level breakage.
   exporter-integration:
     name: Exporter integration
     runs-on: ubuntu-latest
@@ -38,6 +62,8 @@ jobs:
       - run: pip install -e '.[dev]'
       - run: pytest tests/integration -q
 
+  # Builds the TypeScript viewer and runs its unit + headless-browser
+  # (Playwright) end-to-end tests.
   viewer-browser:
     name: Viewer and browser tests
     runs-on: ubuntu-latest
@@ -65,6 +91,9 @@ jobs:
       - working-directory: viewer
         run: npm run test:e2e
 
+  # Builds the wheel and sdist, validates them with twine, and runs
+  # packaging-specific tests — catches issues the editable install
+  # used elsewhere in CI wouldn't surface.
   wheel-sdist:
     name: Wheel and sdist inspection
     runs-on: ubuntu-latest
@@ -80,6 +109,9 @@ jobs:
       - run: python -m twine check dist/*
       - run: pytest tests/packaging -q
 
+  # Installs the built wheel into a fresh venv (non-editable, unlike
+  # the rest of CI) and runs a generic project through the CLI —
+  # catches packaging omissions an editable install would hide.
   clean-install:
     name: Clean non-editable install
     runs-on: ubuntu-latest
@@ -104,6 +136,8 @@ jobs:
           /tmp/clean-venv/bin/python-cad build --project-root /tmp/generic-project
           /tmp/clean-venv/bin/python-cad verify --project-root /tmp/generic-project
 
+  # End-to-end CLI smoke test on an editable install: init, build,
+  # verify, clean.
   generic-e2e:
     name: Generic E2E
     runs-on: ubuntu-latest
@@ -122,6 +156,7 @@ jobs:
           python-cad verify --project-root /tmp/e2e-project
           python-cad clean --project-root /tmp/e2e-project
 
+  # Guards against unintentional breaking changes to the public API.
   public-api:
     name: Public API surface
     runs-on: ubuntu-latest
@@ -135,6 +170,8 @@ jobs:
       - run: pip install -e '.[dev]'
       - run: pytest tests/unit/test_public_api.py -q
 
+  # Fails if legacy/retired naming from a prior repo migration
+  # reappears in tracked source (see EXCLUDES below for what's exempt).
   active-terminology:
     name: Active terminology scan
     runs-on: ubuntu-latest
@@ -157,6 +194,9 @@ jobs:
           fi
           echo "No active legacy concepts found."
 
+  # Enforces repository layout policy: legacy files/dirs stay absent,
+  # required symlinks (CLAUDE.md -> AGENTS.md) exist, backups stay
+  # untracked, and the expected workflow files are present.
   tree-shape:
     name: Tree shape and policy checks
     runs-on: ubuntu-latest
@@ -187,6 +227,9 @@ jobs:
           done
           echo "All tree shape checks passed."
 
+  # Confirms init/build works on Linux, macOS, and Windows. Windows
+  # skips ruff/mypy since static checks aren't part of the
+  # cross-platform contract, just the CLI behavior.
   supported-platforms:
     name: Supported platforms (${{ matrix.os }})
     strategy:
@@ -218,6 +261,9 @@ jobs:
           python-cad build --project-root C:\platform-test
         if: matrix.os == 'windows-latest'
 
+  # Generates a per-OS `pip freeze` lockfile as a downloadable
+  # artifact for reference. Informational only — not enforced or
+  # committed anywhere automatically.
   platform-locks:
     name: Platform lock generation (${{ matrix.os }})
     strategy:
@@ -250,6 +296,10 @@ jobs:
           name: ${{ matrix.lock }}
           path: ${{ matrix.lock }}
 
+  # Confirms every optional dependency group (cad, bim, mesh, ...)
+  # installs cleanly and imports across OS/Python combinations. PRs
+  # only run a fast subset (core+all on ubuntu/py3.13) via the gate
+  # step below; main and tag pushes run the full matrix.
   toolchain-matrix:
     name: Toolchain matrix (${{ matrix.os }}, py${{ matrix.python }}, ${{ matrix.group }})
     strategy:
@@ -368,9 +418,17 @@ jobs:
           name: toolchain-compatibility-${{ matrix.os }}-py${{ matrix.python }}-${{ matrix.group }}
           path: toolchain-compatibility.json
 
+  # THE publish step for this repo — only runs when the ref under
+  # test is a "v*" tag, and only after every job above has passed
+  # (see `needs:`). Checking the ref rather than the event name lets
+  # this fire both from a direct tag push and from release.yml's
+  # workflow_dispatch trigger (see the file header for why dispatch
+  # is needed). Tags are created by the separate "Release" workflow
+  # (release.yml); nothing else in this repo should build or publish
+  # to PyPI.
   build-publish:
     name: Build and publish to PyPI
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    if: startsWith(github.ref, 'refs/tags/v')
     needs:
       - lint-type-unit
       - exporter-integration
@@ -412,9 +470,11 @@ jobs:
           TWINE_USERNAME: __token__
           TWINE_PASSWORD: ${{ secrets.PYPI_API_TOKEN }}
 
+  # Generates a SLSA build provenance attestation for the artifacts
+  # build-publish just uploaded, for supply-chain verifiability.
   provenance:
     name: Generate SLSA provenance
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    if: startsWith(github.ref, 'refs/tags/v')
     needs: [build-publish]
     permissions:
       actions: read

{python_cad_tools-0.1.11 → python_cad_tools-0.1.16}/.github/workflows/downstream-compatibility.yml

@@ -1,3 +1,9 @@
+# Placeholder for testing python-cad-tools wheels against a future
+# downstream "companion repository" (not yet created). It intentionally
+# always fails (exit 1) — that's not a bug, it's a guard against this
+# check silently being treated as passing before it's actually
+# implemented. Do not run it or remove the exit 1 until a companion
+# repository exists at the URL you'd pass in.
 name: Downstream compatibility
 
 on:

{python_cad_tools-0.1.11 → python_cad_tools-0.1.16}/.github/workflows/release-candidate.yml

@@ -1,3 +1,11 @@
+# Release candidate: builds and verifies a pre-release artifact for
+# manual QA WITHOUT publishing anything to PyPI or pushing any tag.
+# Use this to sanity-check a wheel/sdist before running the real
+# "Release" workflow (release.yml), which does publish.
+#
+# To run: Actions -> Release candidate -> Run workflow, with a label
+# for this candidate (e.g. "0.1.0rc1"). Download the built artifact
+# from the "build" job's summary page to test it locally.
 name: Release candidate
 
 on:
@@ -12,6 +20,9 @@ permissions:
   contents: read
 
 jobs:
+  # Builds the wheel/sdist after lint/type/unit checks pass, and
+  # uploads them as a workflow artifact (90-day retention). Nothing
+  # is published here.
   build:
     name: Build wheel and sdist
     runs-on: ubuntu-latest
@@ -54,6 +65,9 @@ jobs:
           path: dist/
           retention-days: 90
 
+  # Re-downloads the build job's artifact, re-verifies its hashes, and
+  # installs it non-editably — catches artifact corruption or a
+  # mismatch between what "build" produced and what got uploaded.
   verify:
     name: Verify candidate hashes
     runs-on: ubuntu-latest

python_cad_tools-0.1.16/.github/workflows/release.yml

@@ -0,0 +1,61 @@
+# Release: cuts a new version by tagging `main`. Manual trigger only.
+#
+# This workflow does NOT build or publish anything itself — it only
+# creates a "v*" tag and hands off to ci.yml's `build-publish` job,
+# which is the single, test-gated path to PyPI. Keeping build/publish
+# out of this file avoids two workflows racing to publish the same
+# version.
+#
+# The hand-off can't just be "push the tag": pushes made with the
+# default GITHUB_TOKEN (used below via actions/checkout) don't start
+# other workflow runs — that's a deliberate GitHub anti-recursion
+# rule, not a bug. GitHub exempts workflow_dispatch from that rule, so
+# the last step here explicitly dispatches ci.yml against the new tag
+# using that same GITHUB_TOKEN. No extra token/secret is needed.
+#
+# To run: Actions -> Release -> Run workflow, with the version to
+# release (e.g. "0.1.13", no "v" prefix). Then watch the "CI" workflow
+# run that starts against the new tag — that run is the actual publish.
+name: Release
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to release (e.g. 0.1.2)"
+        required: true
+        type: string
+
+permissions:
+  contents: write
+  actions: write
+
+jobs:
+  release:
+    name: Tag and push release
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          fetch-depth: 0
+
+      - name: Check version is not already published
+        run: |
+          version="${{ inputs.version }}"
+          status=$(curl -s -o /dev/null -w "%{http_code}" "https://pypi.org/pypi/python-cad-tools/${version}/json")
+          if [ "$status" = "200" ]; then
+            echo "::error::python-cad-tools ${version} is already published on PyPI. This looks like a duplicate release attempt (a previous run likely already tagged and uploaded it) — choose a new version instead of re-running with the same one."
+            exit 1
+          fi
+
+      - name: Create and push tag
+        run: |
+          git config user.name "github-actions"
+          git config user.email "github-actions@github.com"
+          git tag "v${{ inputs.version }}"
+          git push origin "v${{ inputs.version }}"
+
+      - name: Trigger CI publish run for the new tag
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: gh workflow run ci.yml --repo "${{ github.repository }}" --ref "v${{ inputs.version }}"

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.11 → 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.11/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.11
+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.11 → 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