solid123d 0.1.0__tar.gz

solid123d-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+        python-version: ["3.10", "3.13"]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --dev
+
+      - name: Run tests
+        run: uv run pytest -v

solid123d-0.1.0/.gitignore

@@ -0,0 +1,19 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.venv/
+.pytest_cache/
+
+# Build artifacts
+dist/
+build/
+
+# Generated geometry
+*.step
+*.stp
+*.stl
+*.3mf
+
+# OS
+.DS_Store

solid123d-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

solid123d-0.1.0/CONVERSATION.md

@@ -0,0 +1,100 @@
+# Conversation Log
+
+## 2026-08-13
+
+**User**: Wants to transition from OpenSCAD/SolidPython to build123d. Asked
+for a small bridge letting existing SolidPython code build build123d objects
+by only changing imports, e.g. `from solid import translate, cube,
+scad_render_to_file` → same API, build123d underneath.
+
+**Assistant**: Built the `solid123d` package (uv project, build123d 0.11.1,
+Python 3.13, branch `feature/solidpython-bridge`).
+
+Key design decisions:
+- Primitives return **native build123d `Shape` objects** (no wrapper class),
+  so bridged code interoperates directly with build123d and migration can
+  proceed file-by-file. Trade-off: SolidPython's `a * b` intersection
+  operator is unavailable (`a & b` / `intersection()(a, b)` instead).
+- Transforms are closures: `translate(v)` returns a callable applying
+  `Pos * shape`; multiple children are implicitly unioned as in OpenSCAD.
+- `rotate([x,y,z])` applies sequential global-axis rotations X→Y→Z to match
+  OpenSCAD's fixed-axis order exactly; axis-angle and scalar forms supported.
+- OpenSCAD alignment semantics preserved: `cube`/`square` corner at origin
+  unless `center=True`; `cylinder` XY-centered sitting on z=0.
+- `scad_render_to_file` exports real geometry: `.scad` filenames rewritten
+  to `.step` with a `UserWarning`; `.stl`/`.step`/`.stp` honored as-is.
+  `scad_render()` raises `NotImplementedError` (no SCAD source exists).
+- `hull`, `minkowski`, `linear_extrude(twist=)` raise `NotImplementedError`
+  (no BRep equivalent); `segments`/`$fn` accepted and ignored.
+- `linear_extrude(scale=)` implemented via loft between base and scaled top.
+- `rotate_extrude` maps the XY profile onto Plane.XZ then `revolve`s about Z.
+- `solid123d.utils` provides `up/down/left/right/forward/back`.
+
+Verification: 32 pytest tests pass (volumes/bboxes vs analytic values, e.g.
+torus volume for `rotate_extrude`); user's exact example script runs with
+only the import changed and emits a valid STEP file.
+
+## 2026-08-13 (later)
+
+**User**: OpenSCAD found "Academy Engraved LET" by name but build123d
+couldn't. How does font identification work on both systems?
+
+**Assistant**: Diagnosed on-machine: OpenSCAD uses fontconfig, which matches
+the family name (nameID 1) and treats subfamily (nameID 2) as a style with
+fuzzy best-match fallback. build123d uses OCCT `Font_FontMgr`, which only
+folds standard subfamilies (Regular/Bold/Italic/Bold Italic) into font
+aspects; this font's subfamily is "Plain", so OCCT registers it as
+"Academy Engraved LET Plain" and a lookup by family name warns on stderr and
+silently substitutes Arial. Verified: `Text(font="Academy Engraved LET
+Plain")` and `font_path=` both render correctly.
+
+**User**: Make `text()` resolve fonts by family name.
+
+**Assistant**: Added `solid123d/fonts.py`: scans platform font dirs
+(macOS/Linux/Windows) with fontTools (~0.06 s, `lru_cache`d), indexes
+family -> {subfamily -> path} incl. .ttc collections, parses OpenSCAD's
+`"Family:style=Style"` syntax, resolves to a concrete file path passed to
+build123d as `font_path`. Unknown families fall through to build123d's own
+name lookup (with standard styles mapped to `FontStyle`). Default style
+preference: regular/plain/normal/book/roman/medium, else first face.
+10 new tests (parse, resolution, end-to-end area check vs Arial fallback);
+42 total pass.
+
+## 2026-08-13 (later still)
+
+**User**: Reported unions/differences "not applying" in sollie_token.py;
+suspected linear_extrude without twist.
+
+**Assistant**: linear_extrude is exact; real bug was solid123d `scale()`
+padding a 2-vector with 0 instead of 1 (OpenSCAD identity), flattening
+extruded text to degenerate solids so engraving subtractions no-op'd or
+nulled. Fixed via `vec3(v, default=1.0)` + regression test (43 pass);
+user's script verified end-to-end (embeds seat exactly into pockets).
+
+**User**: Declined adding color-aware compound export to the bridge
+(OpenSCAD exports colorless STL anyway). Asked how to make one STEP with
+per-shape colors from two build123d Shapes.
+
+**Assistant**: Recipe: set `.color` (and optionally `.label`) on each
+Shape, group with `Compound(children=[...])` (grouping, not fusing), then
+`export_step`. Verified two-color output in combined_colored.step. Gotcha
+documented: the 8 predefined STEP colours (yellow, red, ...) are written
+as DRAUGHTING_PRE_DEFINED_COLOUR('name'), not COLOUR_RGB — grep both when
+inspecting files.
+
+**User**: Wants a typing alias in solid123d (aliasing build123d.Shape) so
+old SolidPython return-type annotations stay correct. (First asked for
+`SolidPythonObject`, then corrected: that name was a mistake.)
+
+**Assistant**: Exported `OpenSCADObject` (SolidPython's real class name)
+and `OpenSCADObjectPlus` (solid2's) as aliases of `build123d.Shape`.
+Test added; 44 pass.
+
+**User**: Chose the name `solid123d` (over solid-build123d etc., all
+verified available on PyPI); asked to replace every "solidbd" occurrence.
+
+**Assistant**: Renamed src/solidbd -> src/solid123d and
+tests/test_solidbd.py -> tests/test_solid123d.py; updated pyproject.toml,
+README, tests, sources, and CONVERSATION.md; re-locked and synced with uv;
+also updated the imports in sollie_token_aug_2026/sollie_token.py. Grep
+confirms zero remaining occurrences; 44 tests pass.

solid123d-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Evan Jones
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

solid123d-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.5
+Name: solid123d
+Version: 0.1.0
+Summary: Drop-in bridge from SolidPython to build123d: change one import, get native BRep geometry
+Project-URL: Homepage, https://github.com/etjones/solid123d
+Project-URL: Repository, https://github.com/etjones/solid123d
+Project-URL: Issues, https://github.com/etjones/solid123d/issues
+Author-email: Evan Jones <evan_t_jones@mac.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: 3d,brep,build123d,cad,openscad,solidpython,step
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Requires-Python: >=3.10
+Requires-Dist: build123d>=0.11.1
+Requires-Dist: fonttools>=4.0
+Description-Content-Type: text/markdown
+
+# solid123d
+
+A bridge that runs [SolidPython](https://github.com/SolidCode/SolidPython)
+(OpenSCAD-style) code on the [build123d](https://build123d.readthedocs.io/)
+BRep kernel. Change one import and existing code produces native build123d
+shapes instead of OpenSCAD source.
+
+```python
+# before
+from solid import translate, cube, scad_render_to_file
+# after
+from solid123d import translate, cube, scad_render_to_file
+
+c = translate([10, 0, 0])(cube(10, center=True))
+scad_render_to_file(c, filename="c.scad")  # writes c.step (real BRep geometry)
+```
+
+Every object returned is a plain build123d `Shape`, so bridged code mixes
+freely with native build123d — the intended migration path:
+
+```python
+from build123d import fillet
+from solid123d import cube
+
+part = cube(20, center=True)
+part = fillet(part.edges(), radius=2)   # native build123d from here on
+```
+
+## Supported
+
+- **Primitives**: `cube`, `sphere`, `cylinder` (incl. `r1`/`r2` cones,
+  `d`/`d1`/`d2`), `square`, `circle`, `polygon` (incl. `paths` holes), `text`
+- **Font resolution**: `text(font=...)` matches fonts by family name the way
+  fontconfig/OpenSCAD does (incl. `"Family:style=Style"` syntax), by scanning
+  system font directories with fontTools and handing build123d the resolved
+  file path. This fixes fonts with nonstandard subfamilies (e.g.
+  `"Academy Engraved LET"`, whose subfamily "Plain" makes OCCT's own lookup
+  fall back to Arial).
+- **Transforms** (callable style, `translate(v)(obj, ...)`): `translate`,
+  `rotate` (vector, scalar, and axis-angle forms with OpenSCAD ordering),
+  `scale`, `mirror`, `resize`, `color`, `offset`
+- **Booleans**: `union()`, `difference()`, `intersection()` — plus native
+  operators `a + b`, `a - b`, `a & b`
+- **2D → 3D**: `linear_extrude` (incl. `center`, `scale`; no `twist`),
+  `rotate_extrude` (incl. partial `angle`)
+- **Export**: `scad_render_to_file` writes `.step`/`.stl`; a `.scad`
+  filename is rewritten to `.step` with a warning
+- `solid123d.utils`: `up`, `down`, `left`, `right`, `forward`, `back`
+- **Typing aliases**: `OpenSCADObject` and `OpenSCADObjectPlus` are
+  aliases of `build123d.Shape`, so existing
+  annotations like `def some_obj() -> OpenSCADObject:` remain correct
+
+## Known differences
+
+- `a * b` intersection is not overloaded; use `a & b` or `intersection()(a, b)`.
+- `hull()` and `minkowski()` raise `NotImplementedError` (no BRep equivalent);
+  in build123d these are usually a `loft`, `sweep`, `offset`, or fillet.
+- `linear_extrude(twist=...)` raises `NotImplementedError`.
+- `$fn`/`segments` arguments are accepted and ignored — BRep curves are exact.
+- `scad_render()` (source string) raises `NotImplementedError`.
+- OpenSCAD modifiers (`#`, `%`, `!`) and `import()`/`surface()`/`projection()`
+  are not implemented.
+
+## Development
+
+```bash
+just test    # or: uv run pytest
+```

solid123d-0.1.0/README.md

@@ -0,0 +1,68 @@
+# solid123d
+
+A bridge that runs [SolidPython](https://github.com/SolidCode/SolidPython)
+(OpenSCAD-style) code on the [build123d](https://build123d.readthedocs.io/)
+BRep kernel. Change one import and existing code produces native build123d
+shapes instead of OpenSCAD source.
+
+```python
+# before
+from solid import translate, cube, scad_render_to_file
+# after
+from solid123d import translate, cube, scad_render_to_file
+
+c = translate([10, 0, 0])(cube(10, center=True))
+scad_render_to_file(c, filename="c.scad")  # writes c.step (real BRep geometry)
+```
+
+Every object returned is a plain build123d `Shape`, so bridged code mixes
+freely with native build123d — the intended migration path:
+
+```python
+from build123d import fillet
+from solid123d import cube
+
+part = cube(20, center=True)
+part = fillet(part.edges(), radius=2)   # native build123d from here on
+```
+
+## Supported
+
+- **Primitives**: `cube`, `sphere`, `cylinder` (incl. `r1`/`r2` cones,
+  `d`/`d1`/`d2`), `square`, `circle`, `polygon` (incl. `paths` holes), `text`
+- **Font resolution**: `text(font=...)` matches fonts by family name the way
+  fontconfig/OpenSCAD does (incl. `"Family:style=Style"` syntax), by scanning
+  system font directories with fontTools and handing build123d the resolved
+  file path. This fixes fonts with nonstandard subfamilies (e.g.
+  `"Academy Engraved LET"`, whose subfamily "Plain" makes OCCT's own lookup
+  fall back to Arial).
+- **Transforms** (callable style, `translate(v)(obj, ...)`): `translate`,
+  `rotate` (vector, scalar, and axis-angle forms with OpenSCAD ordering),
+  `scale`, `mirror`, `resize`, `color`, `offset`
+- **Booleans**: `union()`, `difference()`, `intersection()` — plus native
+  operators `a + b`, `a - b`, `a & b`
+- **2D → 3D**: `linear_extrude` (incl. `center`, `scale`; no `twist`),
+  `rotate_extrude` (incl. partial `angle`)
+- **Export**: `scad_render_to_file` writes `.step`/`.stl`; a `.scad`
+  filename is rewritten to `.step` with a warning
+- `solid123d.utils`: `up`, `down`, `left`, `right`, `forward`, `back`
+- **Typing aliases**: `OpenSCADObject` and `OpenSCADObjectPlus` are
+  aliases of `build123d.Shape`, so existing
+  annotations like `def some_obj() -> OpenSCADObject:` remain correct
+
+## Known differences
+
+- `a * b` intersection is not overloaded; use `a & b` or `intersection()(a, b)`.
+- `hull()` and `minkowski()` raise `NotImplementedError` (no BRep equivalent);
+  in build123d these are usually a `loft`, `sweep`, `offset`, or fillet.
+- `linear_extrude(twist=...)` raises `NotImplementedError`.
+- `$fn`/`segments` arguments are accepted and ignored — BRep curves are exact.
+- `scad_render()` (source string) raises `NotImplementedError`.
+- OpenSCAD modifiers (`#`, `%`, `!`) and `import()`/`surface()`/`projection()`
+  are not implemented.
+
+## Development
+
+```bash
+just test    # or: uv run pytest
+```

solid123d-0.1.0/justfile

@@ -0,0 +1,9 @@
+default: test
+
+run: test
+
+test:
+    uv run pytest -q
+
+watch:
+    uv run watchfiles 'uv run pytest -q' src tests

solid123d-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[project]
+name = "solid123d"
+version = "0.1.0"
+description = "Drop-in bridge from SolidPython to build123d: change one import, get native BRep geometry"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Evan Jones", email = "evan_t_jones@mac.com" }]
+keywords = ["openscad", "solidpython", "build123d", "cad", "3d", "step", "brep"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Manufacturing",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Topic :: Multimedia :: Graphics :: 3D Modeling",
+]
+dependencies = [
+  "build123d>=0.11.1",
+  "fonttools>=4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/etjones/solid123d"
+Repository = "https://github.com/etjones/solid123d"
+Issues = "https://github.com/etjones/solid123d/issues"
+
+[dependency-groups]
+dev = [
+  "pytest>=9.1.1",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

solid123d-0.1.0/src/solid123d/__init__.py

@@ -0,0 +1,63 @@
+"""solid123d: run SolidPython code on the build123d kernel.
+
+Change ``from solid import ...`` to ``from solid123d import ...`` and the
+same code produces native build123d shapes, which can be mixed freely
+with regular build123d code and exported to STEP/STL.
+"""
+
+from build123d import Shape
+
+from .booleans import difference, hull, intersection, minkowski, union
+from .extrusions import linear_extrude, rotate_extrude
+from .primitives import (
+    circle,
+    cube,
+    cylinder,
+    polygon,
+    sphere,
+    square,
+    text,
+)
+from .render import scad_render, scad_render_to_file
+from .transforms import (
+    color,
+    mirror,
+    offset,
+    resize,
+    rotate,
+    scale,
+    translate,
+)
+
+# Typing aliases: SolidPython signatures like `-> OpenSCADObject` stay
+# correct, since every solid123d function returns a build123d Shape.
+OpenSCADObject = Shape
+OpenSCADObjectPlus = Shape
+
+__all__ = [
+    "OpenSCADObject",
+    "OpenSCADObjectPlus",
+    "circle",
+    "color",
+    "cube",
+    "cylinder",
+    "difference",
+    "hull",
+    "intersection",
+    "linear_extrude",
+    "minkowski",
+    "mirror",
+    "offset",
+    "polygon",
+    "resize",
+    "rotate",
+    "rotate_extrude",
+    "scad_render",
+    "scad_render_to_file",
+    "scale",
+    "sphere",
+    "square",
+    "text",
+    "translate",
+    "union",
+]

solid123d-0.1.0/src/solid123d/_common.py

@@ -0,0 +1,41 @@
+"""Shared helpers for the SolidPython -> build123d bridge."""
+
+from collections.abc import Iterable, Sequence
+from functools import reduce
+from operator import add
+
+from build123d import Shape
+
+Vec3 = tuple[float, float, float]
+
+
+def vec3(v: float | Sequence[float], default: float = 0.0) -> Vec3:
+    """Expand an OpenSCAD-style scalar or vector into an (x, y, z) tuple."""
+    if isinstance(v, (int, float)):
+        return (float(v), float(v), float(v))
+    vals = [float(x) for x in v]
+    while len(vals) < 3:
+        vals.append(default)
+    return (vals[0], vals[1], vals[2])
+
+
+def flatten(children: Iterable[object]) -> list[Shape]:
+    """Flatten nested lists/tuples of shapes (SolidPython allows both
+    ``op()(a, b)`` and ``op()([a, b])``)."""
+    out: list[Shape] = []
+    for child in children:
+        if isinstance(child, (list, tuple)):
+            out.extend(flatten(child))
+        elif child is not None:
+            out.append(child)
+    return out
+
+
+def group(children: Iterable[object]) -> Shape:
+    """Combine children the way an OpenSCAD block does: implicit union."""
+    shapes = flatten(children)
+    if not shapes:
+        raise ValueError("expected at least one shape")
+    if len(shapes) == 1:
+        return shapes[0]
+    return reduce(add, shapes)

solid123d-0.1.0/src/solid123d/booleans.py

@@ -0,0 +1,64 @@
+"""OpenSCAD boolean operations: ``union()(a, b)``, ``difference()(a, b)``.
+
+Note that because primitives are native build123d shapes, the algebra
+operators also work directly: ``a + b`` (union), ``a - b`` (difference),
+``a & b`` (intersection). SolidPython's ``a * b`` intersection operator
+is NOT available — use ``a & b`` or ``intersection()(a, b)``.
+"""
+
+from collections.abc import Callable
+from functools import reduce
+from operator import and_, sub
+
+from build123d import Shape
+
+from ._common import flatten, group
+
+Applier = Callable[..., Shape]
+
+
+def union() -> Applier:
+    def apply(*children: Shape) -> Shape:
+        return group(children)
+
+    return apply
+
+
+def difference() -> Applier:
+    def apply(*children: Shape) -> Shape:
+        shapes = flatten(children)
+        if not shapes:
+            raise ValueError("difference() requires at least one shape")
+        return reduce(sub, shapes)
+
+    return apply
+
+
+def intersection() -> Applier:
+    def apply(*children: Shape) -> Shape:
+        shapes = flatten(children)
+        if not shapes:
+            raise ValueError("intersection() requires at least one shape")
+        return reduce(and_, shapes)
+
+    return apply
+
+
+def hull() -> Applier:
+    def apply(*children: Shape) -> Shape:
+        raise NotImplementedError(
+            "hull() has no direct build123d equivalent; model the shape "
+            "explicitly (e.g. loft/sweep) instead"
+        )
+
+    return apply
+
+
+def minkowski() -> Applier:
+    def apply(*children: Shape) -> Shape:
+        raise NotImplementedError(
+            "minkowski() has no build123d equivalent; use offset() or "
+            "fillet/chamfer on the build123d object instead"
+        )
+
+    return apply

solid123d-0.1.0/src/solid123d/extrusions.py

@@ -0,0 +1,61 @@
+"""OpenSCAD 2D -> 3D operations: linear_extrude and rotate_extrude."""
+
+from collections.abc import Callable
+
+from build123d import Axis, Plane, Pos, Shape
+from build123d import extrude as _bd_extrude
+from build123d import loft as _bd_loft
+from build123d import revolve as _bd_revolve
+from build123d import scale as _bd_scale
+
+from ._common import group, vec3
+
+Applier = Callable[..., Shape]
+
+
+def linear_extrude(
+    height: float = 100,
+    center: bool = False,
+    convexity: int | None = None,
+    twist: float = 0,
+    slices: int | None = None,
+    scale: float | tuple[float, float] = 1.0,
+    segments: int | None = None,
+) -> Applier:
+    if twist:
+        raise NotImplementedError(
+            "linear_extrude(twist=...) is not supported; use build123d "
+            "sweep() along a helix instead"
+        )
+    scale_xy = (
+        (float(scale), float(scale))
+        if isinstance(scale, (int, float))
+        else (float(scale[0]), float(scale[1]))
+    )
+
+    def apply(*children: Shape) -> Shape:
+        face = group(children)
+        if scale_xy == (1.0, 1.0):
+            solid = _bd_extrude(face, amount=height)
+        else:
+            top = _bd_scale(face, by=(scale_xy[0], scale_xy[1], 1.0))
+            solid = _bd_loft([face, Pos(0, 0, height) * top])
+        if center:
+            solid = Pos(0, 0, -height / 2) * solid
+        return solid
+
+    return apply
+
+
+def rotate_extrude(
+    angle: float = 360,
+    convexity: int | None = None,
+    segments: int | None = None,
+) -> Applier:
+    def apply(*children: Shape) -> Shape:
+        # OpenSCAD takes an XY profile (x >= 0) and spins it about Z;
+        # map the profile onto the XZ plane, then revolve.
+        profile = Plane.XZ * group(children)
+        return _bd_revolve(profile, axis=Axis.Z, revolution_arc=angle)
+
+    return apply