solidsmith 0.2.0__tar.gz

solidsmith-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Scott Shamansky
+
+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.

solidsmith-0.2.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: solidsmith
+Version: 0.2.0
+Summary: Forge watertight, print-ready 3D parts from Python: robust booleans, colored 3MF export, and multi-view previews.
+Author: Scott Shamansky
+License: MIT
+Project-URL: Homepage, https://github.com/scottshamansky/solidsmith
+Project-URL: Issues, https://github.com/scottshamansky/solidsmith/issues
+Keywords: 3d-printing,parametric,stl,3mf,trimesh,cad,maker
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Manufacturing
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: scipy>=1.10
+Requires-Dist: trimesh>=4.10
+Requires-Dist: manifold3d>=2.5
+Requires-Dist: matplotlib>=3.7
+Requires-Dist: networkx>=2.8
+Requires-Dist: lxml>=4.9
+Requires-Dist: scikit-image>=0.22
+Requires-Dist: rtree>=1.0
+Dynamic: license-file
+
+# solidsmith
+
+[![CI](https://github.com/scottshamansky/solidsmith/actions/workflows/ci.yml/badge.svg)](https://github.com/scottshamansky/solidsmith/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue)
+
+**Forge watertight, print-ready 3D parts from Python.**
+
+solidsmith is the missing glue between [trimesh](https://trimesh.org) and your
+printer: booleans that don't fall over, 3MF export that keeps its colors, a
+printability report, and quick multi-view renders to iterate against — the
+scaffolding every scripted-CAD project ends up reinventing, packaged once.
+
+![parametric honeycomb bin rendered from three angles](docs/images/honeycomb_bin.png)
+
+## Why script your models?
+
+Parametric code beats mouse-driven CAD when you make things repeatedly:
+
+- **Every dimension is a variable.** Resize a bin, thicken a wall, or regenerate
+  a whole family of sizes by editing constants, not dragging faces.
+- **Geometry you authored is geometry you own.** Marketplaces increasingly
+  require sellers of printed goods to use their own original designs. A model
+  built from your own code is original by construction, and generic patterns
+  (honeycombs, gears, chamfers) stay free for everyone.
+- **Designs diff, review, and version like any other code.**
+
+## What trimesh leaves to you (and solidsmith does)
+
+| Pain | What solidsmith does |
+| --- | --- |
+| Booleans fail on real-world meshes | `union` / `difference` / `intersection` run the robust manifold engine with mesh hygiene (`clean`) before and after |
+| 3MF export silently drops color | `write_3mf` injects real `<basematerials>` and tags each body, so multi-color models open in the slicer with filaments already assigned |
+| "Will it print?" found out the hard way | `check` reports watertightness per body, bed fit, plate contact, walls too thin for the nozzle, and stray debris bodies — against a named printer profile (`printer="bambu_a1_mini"`) or your own `Printer` |
+| Seeing your part means opening a slicer | `render_views` renders shaded PNGs from named camera angles in about a second, no GUI or GPU |
+
+## Quickstart
+
+```python
+from solidsmith import Part, check, difference, rounded_prism, render_views, write_3mf
+
+shell = rounded_prism((80, 50, 30), radius=8)
+cavity = rounded_prism((74, 44, 30), radius=5)
+cavity.apply_translation((0, 0, 3))
+tray = difference(shell, cavity)
+
+print(check(tray))                     # watertight? fits the bed? on the plate?
+write_3mf(Part(tray, color=(226, 122, 40), name="tray"), "tray.3mf")
+render_views(tray, "tray.png")         # shaded views, one PNG
+```
+
+```
+✔ watertight (1 body)
+✔ 80.0 × 50.0 × 30.0 mm on a 256 × 256 × 256 bed (Bambu X1C / P1S)
+✔ first layer on the plate (z=0)
+  31.0 cm³ · 564 triangles
+```
+
+Multi-color is just more `Part`s — one per filament — exported together:
+
+```python
+write_3mf([Part(body, (30, 120, 220), "body"),
+           Part(cap,  (240, 200, 40), "cap")], "model.3mf")
+```
+
+## Examples
+
+| Model | Run it |
+| --- | --- |
+| Honeycomb storage bin — vented walls, supports-free label tab, every dimension a parameter | `python examples/honeycomb_bin.py` |
+| Pebble planter — SDF-sculpted organic form, hollow with a drainage hole, split into two filament colors | `python examples/pebble_planter.py` |
+| Hex bit organizer — 16 slide-fit sockets for 1/4" bits, built on `workflow.main` with preview/final modes | `python examples/bit_organizer.py preview` |
+| Two-tone phone stand — angled boolean cuts, a charging-cable channel, one AMS color swap, checked against a named printer profile | `python examples/phone_stand.py preview` |
+
+![two-color SDF pebble planter](docs/images/pebble_planter.png)
+
+Each example writes STL + colored 3MF + a rendered preview into `out/` and
+prints its printability report. Add `--fast` while you iterate.
+
+## Install
+
+```bash
+git clone https://github.com/scottshamansky/solidsmith
+cd solidsmith
+pip install -e .
+```
+
+Requires Python 3.9+. Dimensions are millimeters throughout; the default bed
+is a 256 mm cube (Bambu P1/P2/X1 class) and every check takes your own `bed=`.
+
+## Sculpting (SDF)
+
+Alongside the hard-edged boolean toolkit, `solidsmith.sdf` models organic
+shapes as blended signed distance fields — functional primitives, smooth
+unions that read as clay fillets, `offset`/`shell` for hollowing, and
+marching-cubes meshing with Taubin smoothing:
+
+```python
+from solidsmith import sdf
+
+body = sdf.smooth_union(12, sdf.sphere((0, 0, 30), 25),
+                            sdf.ellipsoid((0, 18, 22), (20, 26, 16)))
+solid = sdf.intersect(body, sdf.plane())          # flat print base at z=0
+mesh = sdf.mesh(solid, bounds=((-30, -30, 0), (30, 50, 50)), pitch=0.5)
+```
+
+## The iteration loop
+
+`workflow.main` wraps the loop every scripted model settles into: `preview`
+builds coarse and renders a PNG in seconds; `final` cuts the print-quality
+files; and every preview is archived to `previews/` — script included — so
+each iteration's look and the code that produced it stay side by side.
+
+```python
+from solidsmith import workflow
+
+def build(fast: bool):
+    ...
+    return parts        # a mesh, a Part, or a list of them
+
+if __name__ == "__main__":
+    workflow.main(build, name="widget")
+```
+
+`python widget.py preview`, tweak, repeat — `python widget.py final` once
+the design is locked.
+
+## Roadmap
+
+- More examples and an overhang/support-need check
+- PyPI release
+
+## License
+
+[MIT](LICENSE)

solidsmith-0.2.0/README.md

@@ -0,0 +1,135 @@
+# solidsmith
+
+[![CI](https://github.com/scottshamansky/solidsmith/actions/workflows/ci.yml/badge.svg)](https://github.com/scottshamansky/solidsmith/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue)
+
+**Forge watertight, print-ready 3D parts from Python.**
+
+solidsmith is the missing glue between [trimesh](https://trimesh.org) and your
+printer: booleans that don't fall over, 3MF export that keeps its colors, a
+printability report, and quick multi-view renders to iterate against — the
+scaffolding every scripted-CAD project ends up reinventing, packaged once.
+
+![parametric honeycomb bin rendered from three angles](docs/images/honeycomb_bin.png)
+
+## Why script your models?
+
+Parametric code beats mouse-driven CAD when you make things repeatedly:
+
+- **Every dimension is a variable.** Resize a bin, thicken a wall, or regenerate
+  a whole family of sizes by editing constants, not dragging faces.
+- **Geometry you authored is geometry you own.** Marketplaces increasingly
+  require sellers of printed goods to use their own original designs. A model
+  built from your own code is original by construction, and generic patterns
+  (honeycombs, gears, chamfers) stay free for everyone.
+- **Designs diff, review, and version like any other code.**
+
+## What trimesh leaves to you (and solidsmith does)
+
+| Pain | What solidsmith does |
+| --- | --- |
+| Booleans fail on real-world meshes | `union` / `difference` / `intersection` run the robust manifold engine with mesh hygiene (`clean`) before and after |
+| 3MF export silently drops color | `write_3mf` injects real `<basematerials>` and tags each body, so multi-color models open in the slicer with filaments already assigned |
+| "Will it print?" found out the hard way | `check` reports watertightness per body, bed fit, plate contact, walls too thin for the nozzle, and stray debris bodies — against a named printer profile (`printer="bambu_a1_mini"`) or your own `Printer` |
+| Seeing your part means opening a slicer | `render_views` renders shaded PNGs from named camera angles in about a second, no GUI or GPU |
+
+## Quickstart
+
+```python
+from solidsmith import Part, check, difference, rounded_prism, render_views, write_3mf
+
+shell = rounded_prism((80, 50, 30), radius=8)
+cavity = rounded_prism((74, 44, 30), radius=5)
+cavity.apply_translation((0, 0, 3))
+tray = difference(shell, cavity)
+
+print(check(tray))                     # watertight? fits the bed? on the plate?
+write_3mf(Part(tray, color=(226, 122, 40), name="tray"), "tray.3mf")
+render_views(tray, "tray.png")         # shaded views, one PNG
+```
+
+```
+✔ watertight (1 body)
+✔ 80.0 × 50.0 × 30.0 mm on a 256 × 256 × 256 bed (Bambu X1C / P1S)
+✔ first layer on the plate (z=0)
+  31.0 cm³ · 564 triangles
+```
+
+Multi-color is just more `Part`s — one per filament — exported together:
+
+```python
+write_3mf([Part(body, (30, 120, 220), "body"),
+           Part(cap,  (240, 200, 40), "cap")], "model.3mf")
+```
+
+## Examples
+
+| Model | Run it |
+| --- | --- |
+| Honeycomb storage bin — vented walls, supports-free label tab, every dimension a parameter | `python examples/honeycomb_bin.py` |
+| Pebble planter — SDF-sculpted organic form, hollow with a drainage hole, split into two filament colors | `python examples/pebble_planter.py` |
+| Hex bit organizer — 16 slide-fit sockets for 1/4" bits, built on `workflow.main` with preview/final modes | `python examples/bit_organizer.py preview` |
+| Two-tone phone stand — angled boolean cuts, a charging-cable channel, one AMS color swap, checked against a named printer profile | `python examples/phone_stand.py preview` |
+
+![two-color SDF pebble planter](docs/images/pebble_planter.png)
+
+Each example writes STL + colored 3MF + a rendered preview into `out/` and
+prints its printability report. Add `--fast` while you iterate.
+
+## Install
+
+```bash
+git clone https://github.com/scottshamansky/solidsmith
+cd solidsmith
+pip install -e .
+```
+
+Requires Python 3.9+. Dimensions are millimeters throughout; the default bed
+is a 256 mm cube (Bambu P1/P2/X1 class) and every check takes your own `bed=`.
+
+## Sculpting (SDF)
+
+Alongside the hard-edged boolean toolkit, `solidsmith.sdf` models organic
+shapes as blended signed distance fields — functional primitives, smooth
+unions that read as clay fillets, `offset`/`shell` for hollowing, and
+marching-cubes meshing with Taubin smoothing:
+
+```python
+from solidsmith import sdf
+
+body = sdf.smooth_union(12, sdf.sphere((0, 0, 30), 25),
+                            sdf.ellipsoid((0, 18, 22), (20, 26, 16)))
+solid = sdf.intersect(body, sdf.plane())          # flat print base at z=0
+mesh = sdf.mesh(solid, bounds=((-30, -30, 0), (30, 50, 50)), pitch=0.5)
+```
+
+## The iteration loop
+
+`workflow.main` wraps the loop every scripted model settles into: `preview`
+builds coarse and renders a PNG in seconds; `final` cuts the print-quality
+files; and every preview is archived to `previews/` — script included — so
+each iteration's look and the code that produced it stay side by side.
+
+```python
+from solidsmith import workflow
+
+def build(fast: bool):
+    ...
+    return parts        # a mesh, a Part, or a list of them
+
+if __name__ == "__main__":
+    workflow.main(build, name="widget")
+```
+
+`python widget.py preview`, tweak, repeat — `python widget.py final` once
+the design is locked.
+
+## Roadmap
+
+- More examples and an overhang/support-need check
+- PyPI release
+
+## License
+
+[MIT](LICENSE)

solidsmith-0.2.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "solidsmith"
+version = "0.2.0"
+description = "Forge watertight, print-ready 3D parts from Python: robust booleans, colored 3MF export, and multi-view previews."
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Scott Shamansky" }]
+requires-python = ">=3.9"
+dependencies = [
+    "numpy>=1.24",
+    "scipy>=1.10",
+    "trimesh>=4.10",
+    "manifold3d>=2.5",
+    "matplotlib>=3.7",
+    "networkx>=2.8",
+    "lxml>=4.9",
+    "scikit-image>=0.22",
+    "rtree>=1.0",
+]
+keywords = [
+    "3d-printing",
+    "parametric",
+    "stl",
+    "3mf",
+    "trimesh",
+    "cad",
+    "maker",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Manufacturing",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Multimedia :: Graphics :: 3D Modeling",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.urls]
+Homepage = "https://github.com/scottshamansky/solidsmith"
+Issues = "https://github.com/scottshamansky/solidsmith/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+solidsmith = ["py.typed"]

solidsmith-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

solidsmith-0.2.0/src/solidsmith/__init__.py

@@ -0,0 +1,47 @@
+"""solidsmith — forge watertight, print-ready 3D parts from Python.
+
+The missing glue between trimesh and your printer: booleans that don't fall
+over, 3MF export that keeps its colors, a printability report, and quick
+multi-view renders to iterate against.
+"""
+
+from solidsmith import printers, sdf, workflow
+from solidsmith.export import write_3mf, write_stl
+from solidsmith.ops import (
+    clean,
+    concat,
+    difference,
+    hex_prism,
+    intersection,
+    rounded_prism,
+    union,
+)
+from solidsmith.part import Part
+from solidsmith.printers import Printer
+from solidsmith.preview import DEFAULT_VIEWS, render_views
+from solidsmith.report import DEFAULT_BED, PrintReport, check
+
+__version__ = "0.2.0"
+
+__all__ = [
+    "DEFAULT_BED",
+    "DEFAULT_VIEWS",
+    "Part",
+    "PrintReport",
+    "Printer",
+    "printers",
+    "check",
+    "clean",
+    "concat",
+    "difference",
+    "hex_prism",
+    "intersection",
+    "render_views",
+    "rounded_prism",
+    "sdf",
+    "union",
+    "workflow",
+    "write_3mf",
+    "write_stl",
+    "__version__",
+]

solidsmith-0.2.0/src/solidsmith/export.py

@@ -0,0 +1,92 @@
+"""Export meshes to print-ready files.
+
+STL is the easy half. 3MF is the interesting one: trimesh writes valid 3MF
+geometry but silently drops color, so every body opens gray in the slicer.
+`write_3mf` post-processes the archive it writes — injecting a real
+``<basematerials>`` resource and tagging each body with a material index —
+so a multi-color model opens with its filament assignments already in place.
+"""
+
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+import zipfile
+from pathlib import Path
+
+import trimesh
+
+from solidsmith.ops import concat
+from solidsmith.part import Part, as_parts
+
+_CORE_NS = "http://schemas.microsoft.com/3dmanufacturing/core/2015/02"
+_MODEL_ENTRY = "3D/3dmodel.model"
+
+
+def write_stl(parts, path) -> Path:
+    """Write one binary STL. Multiple parts are concatenated (STL has no color)."""
+    path = Path(path)
+    parts = as_parts(parts)
+    mesh = parts[0].mesh if len(parts) == 1 else concat(*(p.mesh for p in parts))
+    mesh.export(path)
+    return path
+
+
+def write_3mf(parts, path) -> Path:
+    """Write a single 3MF containing every part as a separately colored body."""
+    path = Path(path)
+    parts = as_parts(parts)
+
+    scene = trimesh.Scene()
+    for i, part in enumerate(parts):
+        # zero-padded prefix pins a stable object order in the archive
+        scene.add_geometry(part.mesh, geom_name=f"{i:03d}_{part.name}")
+    scene.export(path)
+
+    _inject_materials(path, parts)
+    return path
+
+
+def _inject_materials(path: Path, parts: "list[Part]") -> None:
+    """Rewrite the 3MF's model XML with basematerials + per-object material refs."""
+    with zipfile.ZipFile(path, "r") as zf:
+        entries = {info.filename: zf.read(info.filename) for info in zf.infolist()}
+    if _MODEL_ENTRY not in entries:
+        raise ValueError(f"{path} has no {_MODEL_ENTRY}; not a 3MF written by trimesh?")
+
+    ET.register_namespace("", _CORE_NS)
+    root = ET.fromstring(entries[_MODEL_ENTRY])
+    ns = {"m": _CORE_NS}
+    resources = root.find("m:resources", ns)
+    if resources is None:
+        raise ValueError("3MF model has no <resources> element")
+
+    objects = [
+        obj for obj in resources.findall("m:object", ns)
+        if obj.find("m:mesh", ns) is not None
+    ]
+    if len(objects) != len(parts):
+        raise ValueError(
+            f"expected {len(parts)} mesh objects in the 3MF, found {len(objects)}"
+        )
+
+    used_ids = [int(obj.get("id")) for obj in resources.findall("m:object", ns)]
+    material_id = str(max(used_ids) + 1)
+
+    materials = ET.Element(f"{{{_CORE_NS}}}basematerials", {"id": material_id})
+    for part in parts:
+        r, g, b = (int(c) for c in part.color)
+        ET.SubElement(
+            materials,
+            f"{{{_CORE_NS}}}base",
+            {"name": part.name, "displaycolor": f"#{r:02X}{g:02X}{b:02X}"},
+        )
+    resources.insert(0, materials)
+
+    for index, obj in enumerate(objects):
+        obj.set("pid", material_id)
+        obj.set("pindex", str(index))
+
+    entries[_MODEL_ENTRY] = ET.tostring(root, encoding="UTF-8", xml_declaration=True)
+    with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as zf:
+        for name, data in entries.items():
+            zf.writestr(name, data)

solidsmith-0.2.0/src/solidsmith/ops.py

@@ -0,0 +1,96 @@
+"""Boolean modeling that stays watertight.
+
+trimesh's default boolean backend rejects meshes that are fine in practice;
+the manifold engine is far more robust but still rewards mesh hygiene on the
+way in and out. These wrappers bake both in, so `difference(a, b)` is a thing
+you can stop thinking about.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import trimesh
+
+
+def clean(mesh: trimesh.Trimesh) -> trimesh.Trimesh:
+    """Scrub a mesh in place: weld vertices, drop degenerate faces, fix winding.
+
+    Marching-cubes and heavily boolean'd meshes accumulate slivers that make
+    later booleans fail; running this between operations keeps them reliable.
+    """
+    mesh.merge_vertices()
+    mesh.update_faces(mesh.nondegenerate_faces())
+    mesh.remove_unreferenced_vertices()
+    mesh.fix_normals()
+    return mesh
+
+
+def _boolean(kind: str, meshes: "list[trimesh.Trimesh]") -> trimesh.Trimesh:
+    prepared = [clean(m.copy()) for m in meshes]
+    result = getattr(trimesh.boolean, kind)(prepared, engine="manifold")
+    return clean(result)
+
+
+def union(*meshes: trimesh.Trimesh) -> trimesh.Trimesh:
+    """Fuse meshes into one solid."""
+    if len(meshes) == 1:
+        return clean(meshes[0].copy())
+    return _boolean("union", list(meshes))
+
+
+def difference(base: trimesh.Trimesh, *cutters: trimesh.Trimesh) -> trimesh.Trimesh:
+    """Subtract every cutter from base."""
+    if not cutters:
+        return clean(base.copy())
+    return _boolean("difference", [base, *cutters])
+
+
+def intersection(*meshes: trimesh.Trimesh) -> trimesh.Trimesh:
+    """Keep only the volume common to all meshes."""
+    return _boolean("intersection", list(meshes))
+
+
+def concat(*meshes: trimesh.Trimesh) -> trimesh.Trimesh:
+    """Append meshes without any boolean (touching bodies that print as one)."""
+    return trimesh.util.concatenate(list(meshes))
+
+
+def rounded_prism(
+    extents,
+    radius: float,
+    sections: int = 64,
+) -> trimesh.Trimesh:
+    """Rectangular prism with rounded vertical corners, sitting on z=0.
+
+    extents is (x, y, z) in mm; radius rounds the four vertical edges. Built
+    from boxes plus corner cylinders so it needs no 2D triangulation deps,
+    and clamps the radius rather than erroring when it exceeds the footprint.
+    """
+    x, y, z = (float(v) for v in extents)
+    if min(x, y, z) <= 0:
+        raise ValueError(f"extents must be positive, got {extents}")
+    radius = max(0.0, min(float(radius), x / 2 - 1e-3, y / 2 - 1e-3))
+
+    if radius < 1e-6:
+        prism = trimesh.creation.box((x, y, z))
+    else:
+        core_x = trimesh.creation.box((x, y - 2 * radius, z))
+        core_y = trimesh.creation.box((x - 2 * radius, y, z))
+        corners = []
+        for sx in (-1.0, 1.0):
+            for sy in (-1.0, 1.0):
+                cyl = trimesh.creation.cylinder(radius=radius, height=z, sections=sections)
+                cyl.apply_translation((sx * (x / 2 - radius), sy * (y / 2 - radius), 0))
+                corners.append(cyl)
+        prism = union(core_x, core_y, *corners)
+
+    prism.apply_translation((0, 0, z / 2))
+    return prism
+
+
+def hex_prism(circumradius: float, height: float, point_up: bool = True) -> trimesh.Trimesh:
+    """Hexagonal prism along z, centered at the origin (honeycomb building block)."""
+    hexagon = trimesh.creation.cylinder(radius=circumradius, height=height, sections=6)
+    if point_up:
+        hexagon.apply_transform(trimesh.transformations.rotation_matrix(np.pi / 6, (0, 0, 1)))
+    return hexagon

solidsmith-0.2.0/src/solidsmith/part.py

@@ -0,0 +1,41 @@
+"""A mesh plus how it should appear when exported or rendered."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Tuple
+
+import trimesh
+
+
+@dataclass
+class Part:
+    """One printable body: a mesh, a display color, and a name.
+
+    Color is sRGB 0-255. A multi-color model is just a list of Parts (one
+    per filament); exported together they become a single 3MF that opens in
+    the slicer with every body already assigned its color.
+    """
+
+    mesh: trimesh.Trimesh
+    color: Tuple[int, int, int] = (140, 140, 145)
+    name: str = "part"
+
+
+def as_parts(obj) -> "list[Part]":
+    """Normalize a Part, a mesh, or a sequence of either into a list of Parts."""
+    if isinstance(obj, Part):
+        return [obj]
+    if isinstance(obj, trimesh.Trimesh):
+        return [Part(obj)]
+    parts = []
+    for i, item in enumerate(obj):
+        if isinstance(item, Part):
+            parts.append(item)
+        elif isinstance(item, trimesh.Trimesh):
+            parts.append(Part(item, name=f"part_{i}"))
+        else:
+            raise TypeError(f"expected Part or Trimesh, got {type(item).__name__}")
+    if not parts:
+        raise ValueError("no parts given")
+    return parts