solid123d 0.1.0__py3-none-any.whl

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/_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/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/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

solid123d/fonts.py

@@ -0,0 +1,100 @@
+"""Resolve font family names to font files, fontconfig-style.
+
+OpenSCAD finds fonts via fontconfig, which matches on the family name in
+the font's name table. build123d delegates to OCCT's Font_FontMgr, which
+registers fonts with nonstandard subfamilies (e.g. "Plain") under a
+combined name, so lookups by plain family name silently fall back to
+Arial. This module scans the system font directories with fontTools and
+resolves an OpenSCAD-style ``"Family"`` or ``"Family:style=Style"`` spec
+to a concrete font file path.
+"""
+
+import sys
+from functools import lru_cache
+from pathlib import Path
+
+from fontTools.ttLib import TTCollection, TTFont
+
+_FONT_SUFFIXES = (".ttf", ".otf", ".ttc", ".otc")
+_DEFAULT_STYLES = ("regular", "plain", "normal", "book", "roman", "medium")
+
+
+def _font_dirs() -> list[Path]:
+    home = Path.home()
+    if sys.platform == "darwin":
+        return [
+            Path("/System/Library/Fonts"),
+            Path("/Library/Fonts"),
+            home / "Library" / "Fonts",
+        ]
+    if sys.platform.startswith("win"):
+        dirs = [Path(r"C:\Windows\Fonts")]
+        local = home / "AppData" / "Local" / "Microsoft" / "Windows" / "Fonts"
+        return dirs + [local]
+    return [
+        Path("/usr/share/fonts"),
+        Path("/usr/local/share/fonts"),
+        home / ".local" / "share" / "fonts",
+        home / ".fonts",
+    ]
+
+
+def _faces_in_file(path: Path) -> list[tuple[str, str]]:
+    """Return (family, subfamily) for each face in a font file."""
+    faces: list[tuple[str, str]] = []
+    try:
+        if path.suffix.lower() in (".ttc", ".otc"):
+            fonts = TTCollection(path, lazy=True).fonts
+        else:
+            fonts = [TTFont(path, lazy=True)]
+        for font in fonts:
+            family = font["name"].getDebugName(1)
+            subfamily = font["name"].getDebugName(2) or ""
+            if family:
+                faces.append((family, subfamily))
+            font.close()
+    except Exception:
+        pass
+    return faces
+
+
+@lru_cache(maxsize=1)
+def _font_index() -> dict[str, dict[str, Path]]:
+    """Map lowercase family name -> {lowercase style: file path}."""
+    index: dict[str, dict[str, Path]] = {}
+    for directory in _font_dirs():
+        if not directory.is_dir():
+            continue
+        for path in sorted(directory.rglob("*")):
+            if path.suffix.lower() not in _FONT_SUFFIXES:
+                continue
+            for family, subfamily in _faces_in_file(path):
+                styles = index.setdefault(family.lower(), {})
+                styles.setdefault(subfamily.lower(), path)
+    return index
+
+
+def parse_font_spec(spec: str) -> tuple[str, str | None]:
+    """Split OpenSCAD's ``"Family:style=Style"`` syntax."""
+    family, _, rest = spec.partition(":")
+    style: str | None = None
+    for part in rest.split(":"):
+        key, _, value = part.partition("=")
+        if key.strip().lower() == "style" and value.strip():
+            style = value.strip()
+    return family.strip(), style
+
+
+def find_font_path(spec: str) -> str | None:
+    """Resolve a font spec to a file path, or None if no family matches."""
+    family, style = parse_font_spec(spec)
+    styles = _font_index().get(family.lower())
+    if not styles:
+        return None
+    if style is not None:
+        path = styles.get(style.lower())
+        return str(path) if path is not None else None
+    for preferred in _DEFAULT_STYLES:
+        if preferred in styles:
+            return str(styles[preferred])
+    return str(next(iter(styles.values())))

solid123d/primitives.py

@@ -0,0 +1,133 @@
+"""OpenSCAD primitive shapes, emitted as build123d objects.
+
+``segments`` / ``$fn`` style arguments are accepted and ignored:
+build123d is a BRep kernel, so curves are exact.
+"""
+
+from collections.abc import Sequence
+
+from build123d import Align, Box, Cone, Cylinder, FontStyle, Rectangle, Shape
+from build123d import Circle as _BdCircle
+from build123d import Polygon as _BdPolygon
+from build123d import Sphere as _BdSphere
+from build123d import Text as _BdText
+
+from ._common import group, vec3
+from .fonts import find_font_path, parse_font_spec
+
+_CENTERED = (Align.CENTER, Align.CENTER, Align.CENTER)
+_CORNER = (Align.MIN, Align.MIN, Align.MIN)
+
+
+def cube(size: float | Sequence[float] = 1, center: bool = False) -> Shape:
+    x, y, z = vec3(size)
+    return Box(x, y, z, align=_CENTERED if center else _CORNER)
+
+
+def sphere(
+    r: float | None = None,
+    d: float | None = None,
+    segments: int | None = None,
+) -> Shape:
+    radius = r if r is not None else (d / 2 if d is not None else 1.0)
+    return _BdSphere(radius)
+
+
+def cylinder(
+    r: float | None = None,
+    h: float | None = None,
+    r1: float | None = None,
+    r2: float | None = None,
+    center: bool = False,
+    d: float | None = None,
+    d1: float | None = None,
+    d2: float | None = None,
+    segments: int | None = None,
+) -> Shape:
+    base = r if r is not None else (d / 2 if d is not None else None)
+    bottom = r1 if r1 is not None else (d1 / 2 if d1 is not None else base)
+    top = r2 if r2 is not None else (d2 / 2 if d2 is not None else base)
+    bottom = 1.0 if bottom is None else float(bottom)
+    top = 1.0 if top is None else float(top)
+    height = 1.0 if h is None else float(h)
+    z_align = Align.CENTER if center else Align.MIN
+    align = (Align.CENTER, Align.CENTER, z_align)
+    if bottom == top:
+        return Cylinder(bottom, height, align=align)
+    return Cone(bottom_radius=bottom, top_radius=top, height=height, align=align)
+
+
+def square(size: float | Sequence[float] = 1, center: bool = False) -> Shape:
+    x, y, _ = vec3(size)
+    align = (Align.CENTER, Align.CENTER) if center else (Align.MIN, Align.MIN)
+    return Rectangle(x, y, align=align)
+
+
+def circle(
+    r: float | None = None,
+    d: float | None = None,
+    segments: int | None = None,
+) -> Shape:
+    radius = r if r is not None else (d / 2 if d is not None else 1.0)
+    return _BdCircle(radius)
+
+
+def polygon(
+    points: Sequence[Sequence[float]],
+    paths: Sequence[Sequence[int]] | None = None,
+    convexity: int | None = None,
+) -> Shape:
+    pts = [(float(p[0]), float(p[1])) for p in points]
+    if paths is None:
+        return _BdPolygon(*pts, align=None)
+    faces = [
+        _BdPolygon(*[pts[i] for i in path], align=None) for path in paths
+    ]
+    outer = faces[0]
+    for hole in faces[1:]:
+        outer -= hole
+    return outer
+
+
+_FONT_STYLES = {
+    "bold": FontStyle.BOLD,
+    "italic": FontStyle.ITALIC,
+    "bold italic": FontStyle.BOLDITALIC,
+}
+
+_HALIGN = {"left": Align.MIN, "center": Align.CENTER, "right": Align.MAX}
+_VALIGN = {
+    "baseline": Align.MIN,
+    "bottom": Align.MIN,
+    "center": Align.CENTER,
+    "top": Align.MAX,
+}
+
+
+def text(
+    text: str,
+    size: float = 10,
+    font: str | None = None,
+    halign: str = "left",
+    valign: str = "baseline",
+    spacing: float = 1,
+    direction: str = "ltr",
+    language: str | None = None,
+    script: str | None = None,
+    segments: int | None = None,
+) -> Shape:
+    kwargs: dict[str, object] = {
+        "align": (_HALIGN[halign], _VALIGN[valign]),
+    }
+    if font is not None:
+        font_path = find_font_path(font)
+        if font_path is not None:
+            kwargs["font_path"] = font_path
+        else:
+            family, style = parse_font_spec(font)
+            kwargs["font"] = family
+            if style is not None:
+                kwargs["font_style"] = _FONT_STYLES.get(
+                    style.lower(), FontStyle.REGULAR
+                )
+    return _BdText(text, font_size=size, **kwargs)

solid123d/render.py

@@ -0,0 +1,53 @@
+"""Drop-in replacements for SolidPython's render functions.
+
+There is no OpenSCAD source to render, so ``scad_render_to_file`` exports
+real geometry instead: a ``.scad`` filename is transparently rewritten to
+``.step``. ``.step``/``.stp``/``.stl`` filenames are exported as-is.
+"""
+
+import warnings
+from pathlib import Path
+
+from build123d import Shape
+from build123d import export_step as _export_step
+from build123d import export_stl as _export_stl
+
+
+def scad_render_to_file(
+    scad_object: Shape,
+    filepath: str | Path | None = None,
+    out_dir: str | Path = "",
+    file_header: str = "",
+    include_orig_code: bool = True,
+    filename: str | Path | None = None,
+    **kwargs: object,
+) -> str:
+    path = Path(filepath if filepath is not None else (filename or "output.step"))
+    if out_dir:
+        path = Path(out_dir) / path
+    suffix = path.suffix.lower()
+    if suffix == ".scad":
+        path = path.with_suffix(".step")
+        warnings.warn(
+            f"solid123d cannot write OpenSCAD source; exporting STEP to "
+            f"{path} instead",
+            stacklevel=2,
+        )
+        suffix = ".step"
+    if path.parent != Path("."):
+        path.parent.mkdir(parents=True, exist_ok=True)
+    if suffix == ".stl":
+        _export_stl(scad_object, str(path))
+    elif suffix in (".step", ".stp"):
+        _export_step(scad_object, str(path))
+    else:
+        raise ValueError(f"unsupported export format: {path.suffix}")
+    return str(path)
+
+
+def scad_render(scad_object: Shape, file_header: str = "") -> str:
+    raise NotImplementedError(
+        "solid123d builds real geometry, not OpenSCAD source; use "
+        "scad_render_to_file() to export STEP/STL, or pass the object to "
+        "build123d viewers/exporters directly"
+    )

solid123d/transforms.py

@@ -0,0 +1,128 @@
+"""OpenSCAD transformations as callables: ``translate(v)(shape, ...)``.
+
+Each function returns a callable that accepts one or more shapes
+(children are implicitly unioned, as in an OpenSCAD block) and returns
+a transformed build123d shape.
+"""
+
+from collections.abc import Callable, Sequence
+
+from build123d import Axis, Color, Kind, Plane, Pos, Shape
+from build123d import mirror as _bd_mirror
+from build123d import offset as _bd_offset
+from build123d import scale as _bd_scale
+
+from ._common import group, vec3
+
+Applier = Callable[..., Shape]
+
+
+def translate(v: Sequence[float]) -> Applier:
+    x, y, z = vec3(v)
+
+    def apply(*children: Shape) -> Shape:
+        return Pos(x, y, z) * group(children)
+
+    return apply
+
+
+def rotate(
+    a: float | Sequence[float] | None = None,
+    v: Sequence[float] | None = None,
+) -> Applier:
+    def apply(*children: Shape) -> Shape:
+        shape = group(children)
+        if a is not None and not isinstance(a, (int, float)):
+            # rotate([x, y, z]): about global X, then Y, then Z (OpenSCAD order)
+            ax, ay, az = vec3(a)
+            for axis, angle in ((Axis.X, ax), (Axis.Y, ay), (Axis.Z, az)):
+                if angle:
+                    shape = shape.rotate(axis, angle)
+            return shape
+        angle = float(a) if a is not None else 0.0
+        if v is not None:
+            return shape.rotate(Axis((0, 0, 0), tuple(vec3(v))), angle)
+        return shape.rotate(Axis.Z, angle)
+
+    return apply
+
+
+def scale(v: float | Sequence[float]) -> Applier:
+    # OpenSCAD pads a short scale vector with 1 (identity), not 0
+    factors = vec3(v, default=1.0)
+
+    def apply(*children: Shape) -> Shape:
+        return _bd_scale(group(children), by=factors)
+
+    return apply
+
+
+def mirror(v: Sequence[float]) -> Applier:
+    normal = vec3(v)
+
+    def apply(*children: Shape) -> Shape:
+        return _bd_mirror(
+            group(children), about=Plane(origin=(0, 0, 0), z_dir=normal)
+        )
+
+    return apply
+
+
+def resize(
+    newsize: Sequence[float],
+    auto: bool | Sequence[bool] = False,
+) -> Applier:
+    target = vec3(newsize)
+
+    def apply(*children: Shape) -> Shape:
+        shape = group(children)
+        bbox = shape.bounding_box()
+        current = (bbox.size.X, bbox.size.Y, bbox.size.Z)
+        autos = (
+            (auto, auto, auto) if isinstance(auto, bool) else tuple(auto)
+        )
+        factors = [
+            t / c if t != 0 and c != 0 else 0.0
+            for t, c in zip(target, current)
+        ]
+        first = next((f for f in factors if f != 0), 1.0)
+        resolved = tuple(
+            f if f != 0 else (first if autos[i] else 1.0)
+            for i, f in enumerate(factors)
+        )
+        return _bd_scale(shape, by=resolved)
+
+    return apply
+
+
+def color(c: str | Sequence[float], alpha: float = 1.0) -> Applier:
+    if isinstance(c, str):
+        col = Color(c, alpha=alpha)
+    else:
+        vals = [float(x) for x in c]
+        if len(vals) == 3:
+            vals.append(alpha)
+        col = Color(*vals)
+
+    def apply(*children: Shape) -> Shape:
+        shape = group(children)
+        shape.color = col
+        return shape
+
+    return apply
+
+
+def offset(
+    r: float | None = None,
+    delta: float | None = None,
+    chamfer: bool = False,
+) -> Applier:
+    amount = r if r is not None else delta
+    if amount is None:
+        raise ValueError("offset() requires r= or delta=")
+    kind = Kind.ARC if r is not None else Kind.INTERSECTION
+
+    def apply(*children: Shape) -> Shape:
+        return _bd_offset(group(children), float(amount), kind=kind)
+
+    return apply

solid123d/utils.py

@@ -0,0 +1,33 @@
+"""Equivalents of the common ``solid.utils`` directional helpers."""
+
+from collections.abc import Callable
+
+from build123d import Shape
+
+from .transforms import translate
+
+Applier = Callable[..., Shape]
+
+
+def up(z: float) -> Applier:
+    return translate([0, 0, z])
+
+
+def down(z: float) -> Applier:
+    return translate([0, 0, -z])
+
+
+def right(x: float) -> Applier:
+    return translate([x, 0, 0])
+
+
+def left(x: float) -> Applier:
+    return translate([-x, 0, 0])
+
+
+def forward(y: float) -> Applier:
+    return translate([0, y, 0])
+
+
+def back(y: float) -> Applier:
+    return translate([0, -y, 0])

solid123d-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,13 @@
+solid123d/__init__.py,sha256=NZd_91C_UWjEVaaZxdhg8RJI8Obm1nYLl98oNvWqrcY,1316
+solid123d/_common.py,sha256=rB9calVf6avQziTmiwRk64JDm-B0NGaBm6GJgSqTIqs,1282
+solid123d/booleans.py,sha256=NKH_YbGkieXLcYtuL5P0VwD-0-QQooKU78g67S187PM,1714
+solid123d/extrusions.py,sha256=acr6zcuTivfYj6ZXfHD4oXc7y1gosfOaq0UCxWZmN0A,1821
+solid123d/fonts.py,sha256=zxPjPRcVPvh4nDqPOmQ1Q3iIsj-EtHBTLBVut1Voi58,3519
+solid123d/primitives.py,sha256=mkmwPfkLai6v-m3R_M7Qf8WgFdTnG1iKzF8CbEf0Q1M,3986
+solid123d/render.py,sha256=kFyxcURTuh_6y63oQItFX79GZALCyij6vQRqX6loC-g,1768
+solid123d/transforms.py,sha256=cabcGBNDWJ7nhl4Hz8RYYZTU9ydBW7k0vKni00geho8,3592
+solid123d/utils.py,sha256=lJV0zJUty968N6dJmadB4O6Lixb0I1c92ldAWRZrEgY,598
+solid123d-0.1.0.dist-info/METADATA,sha256=EyYeTYzssMZgVZkaouXe-kYz6g5Qyy0QucHzJijYopU,3906
+solid123d-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+solid123d-0.1.0.dist-info/licenses/LICENSE,sha256=rKfFnDmiHmGemb3Gk1_n_a-oCJYLysQuALeK3lmGn94,1067
+solid123d-0.1.0.dist-info/RECORD,,

solid123d-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

solid123d-0.1.0.dist-info/licenses/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.