python-cad-tools 0.1.0rc1__py3-none-any.whl

python_cad_tools/exporters/ifc.py

@@ -0,0 +1,229 @@
+"""IFC4 authoring from Python CAD Tools elements using deterministic IDs."""
+
+from __future__ import annotations
+
+import re
+import uuid
+from pathlib import Path
+from typing import Any
+
+import ifcopenshell
+import ifcopenshell.guid
+import ifcopenshell.validate
+
+from ..determinism import normalized_build_epoch, write_json
+from ..exceptions import BuildExportError
+from ..geometry import tessellate
+from .base import selected_elements
+
+IFC_NAMESPACE = uuid.UUID("8ef8d46f-f692-5a1f-9966-c498829777a9")
+
+
+def global_id(stable_id: str) -> str:
+    return ifcopenshell.guid.compress(uuid.uuid5(IFC_NAMESPACE, stable_id).hex)
+
+
+class IfcExporter:
+    name = "ifc"
+
+    def export(self, model, output_dir: Path) -> list[Path]:
+        target = output_dir / "ifc"
+        target.mkdir(parents=True, exist_ok=True)
+        path = target / f"{model.artifact_stem}.ifc"
+        file = ifcopenshell.file(schema="IFC4")
+        origin = file.createIfcCartesianPoint((0.0, 0.0, 0.0))
+        z_axis = file.createIfcDirection((0.0, 0.0, 1.0))
+        x_axis = file.createIfcDirection((1.0, 0.0, 0.0))
+        world = file.createIfcAxis2Placement3D(origin, z_axis, x_axis)
+        context = file.create_entity(
+            "IfcGeometricRepresentationContext",
+            ContextIdentifier="Model",
+            ContextType="Model",
+            CoordinateSpaceDimension=3,
+            Precision=1e-5,
+            WorldCoordinateSystem=world,
+        )
+        units = file.createIfcUnitAssignment(
+            (
+                file.createIfcSIUnit(None, "LENGTHUNIT", "MILLI", "METRE"),
+                file.createIfcSIUnit(None, "AREAUNIT", None, "SQUARE_METRE"),
+                file.createIfcSIUnit(None, "VOLUMEUNIT", None, "CUBIC_METRE"),
+            )
+        )
+        project = file.create_entity(
+            "IfcProject",
+            GlobalId=global_id(f"{model.id}.ifc.project"),
+            Name=model.name,
+            RepresentationContexts=[context],
+            UnitsInContext=units,
+        )
+        site = _spatial(file, "IfcSite", f"{model.id}.ifc.site", "Default Site", None)
+        building = _spatial(file, "IfcBuilding", f"{model.id}.ifc.building", "Default Building", site.ObjectPlacement)
+        storey = _spatial(file, "IfcBuildingStorey", f"{model.id}.ifc.storey", "Default Storey", building.ObjectPlacement)
+        file.createIfcRelAggregates(global_id(f"{model.id}.rel.project-site"), None, None, None, project, [site])
+        file.createIfcRelAggregates(global_id(f"{model.id}.rel.site-building"), None, None, None, site, [building])
+        file.createIfcRelAggregates(global_id(f"{model.id}.rel.building-storey"), None, None, None, building, [storey])
+
+        products = []
+        expected_ids: list[str] = []
+        for element in selected_elements(model, "ifc", physical_only=True):
+            if element.ifc_mapping.ifc_class is None:
+                continue
+            if element.ifc_mapping.ifc_class != "IfcBuildingElementProxy":
+                raise BuildExportError(f"Unsupported starter IFC mapping: {element.ifc_mapping.ifc_class}")
+            vertices, triangles = tessellate(element.geometry, 0.5, 0.25)
+            points = file.createIfcCartesianPointList3D(vertices)
+            face_set = file.createIfcTriangulatedFaceSet(
+                points,
+                None,
+                True,
+                [[index + 1 for index in triangle] for triangle in triangles],
+                None,
+            )
+            representation = file.createIfcShapeRepresentation(context, "Body", "Tessellation", [face_set])
+            shape = file.createIfcProductDefinitionShape(None, None, [representation])
+            product = file.create_entity(
+                "IfcBuildingElementProxy",
+                GlobalId=global_id(element.id),
+                Name=element.name,
+                ObjectType=element.category,
+                ObjectPlacement=_local_placement(file, storey.ObjectPlacement),
+                Representation=shape,
+                PredefinedType=element.ifc_mapping.predefined_type or "NOTDEFINED",
+            )
+            products.append(product)
+            expected_ids.append(element.id)
+            _add_properties(file, product, element)
+            if element.material:
+                material = file.createIfcMaterial(element.material.name, element.material.category, None)
+                file.createIfcRelAssociatesMaterial(
+                    global_id(f"{element.id}.material"), None, None, None, [product], material
+                )
+                _style_item(file, face_set, element.color_rgb or element.material.color_rgb)
+        file.createIfcRelContainedInSpatialStructure(
+            global_id(f"{model.id}.rel.storey-elements"), None, None, None, products, storey
+        )
+        file.write(path)
+        _normalize_header(path)
+        reloaded = ifcopenshell.open(path)
+        actual_ids = sorted(
+            property_value(entity, "StableId")
+            for entity in reloaded.by_type("IfcBuildingElementProxy")
+        )
+        if actual_ids != sorted(expected_ids):
+            raise BuildExportError(f"IFC stable IDs did not round-trip: {actual_ids}")
+        logger = ifcopenshell.validate.json_logger()
+        # Population/schema validation is a runtime capability. EXPRESS rule
+        # execution is intentionally omitted because that optional upstream
+        # path imports pytest, which must remain a development-only dependency.
+        ifcopenshell.validate.validate(reloaded, logger, express_rules=False)
+        statements = list(logger.statements)
+        fatal = [item for item in statements if item.get("level") in {"error", "critical"}]
+        coordinate_values = [
+            coordinate
+            for point_list in reloaded.by_type("IfcCartesianPointList3D")
+            for coordinate in point_list.CoordList
+        ]
+        if coordinate_values:
+            ifc_bounds = [
+                min(point[index] for point in coordinate_values) for index in range(3)
+            ] + [max(point[index] for point in coordinate_values) for index in range(3)]
+        else:
+            ifc_bounds = [0.0] * 6
+        report = write_json(
+            target / "validation.json",
+            {
+                "schema_id": "urn:python-cad-tools:schema:ifc-validation:1",
+                "schema_version": 1,
+                "schema": reloaded.schema,
+                "valid": not fatal,
+                "fatal_count": len(fatal),
+                "issue_count": len(statements),
+                "issues": [_json_safe(item) for item in statements],
+                "bounds_mm": [round(value, 6) for value in ifc_bounds],
+                "element_global_ids": {
+                    entity.Name: entity.GlobalId
+                    for entity in sorted(reloaded.by_type("IfcBuildingElementProxy"), key=lambda item: item.Name)
+                },
+            },
+        )
+        if fatal:
+            raise BuildExportError(f"IfcOpenShell validation reported {len(fatal)} fatal issue(s); see {report}")
+        return [path, report]
+
+
+def _spatial(file, class_name: str, stable_id: str, name: str, parent_placement):
+    return file.create_entity(
+        class_name,
+        GlobalId=global_id(stable_id),
+        Name=name,
+        ObjectPlacement=_local_placement(file, parent_placement),
+        CompositionType="ELEMENT",
+    )
+
+
+def _local_placement(file, parent):
+    point = file.createIfcCartesianPoint((0.0, 0.0, 0.0))
+    axis = file.createIfcAxis2Placement3D(point, None, None)
+    return file.createIfcLocalPlacement(parent, axis)
+
+
+def _add_properties(file, product, element) -> None:
+    values: dict[str, Any] = {
+        "StableId": element.id,
+        "Category": element.category,
+        "SourceModule": element.source_module,
+        "GeometryKind": element.geometry_kind,
+    }
+    for name in ("length_mm", "width_mm", "height_mm", "radius_mm"):
+        value = getattr(element.dimensions, name)
+        if value is not None:
+            values[name.removesuffix("_mm").title() + "Mm"] = value
+    properties = []
+    for name, value in sorted(values.items()):
+        wrapped = file.createIfcReal(float(value)) if isinstance(value, (float, int)) else file.createIfcLabel(str(value))
+        properties.append(file.createIfcPropertySingleValue(name, None, wrapped, None))
+    pset = file.createIfcPropertySet(global_id(f"{element.id}.pset"), None, "Pset_PythonCadDesign", None, properties)
+    file.createIfcRelDefinesByProperties(global_id(f"{element.id}.pset-rel"), None, None, None, [product], pset)
+
+
+def _style_item(file, item, color) -> None:
+    rgb = file.createIfcColourRgb(None, *[float(channel) for channel in color])
+    shading = file.createIfcSurfaceStyleShading(rgb, None)
+    surface = file.createIfcSurfaceStyle(None, "BOTH", [shading])
+    assignment = file.createIfcPresentationStyleAssignment([surface])
+    file.createIfcStyledItem(item, [assignment], None)
+
+
+def property_value(product, name: str) -> str:
+    for relation in product.IsDefinedBy:
+        definition = relation.RelatingPropertyDefinition
+        if definition.is_a("IfcPropertySet") and definition.Name == "Pset_PythonCadDesign":
+            for prop in definition.HasProperties:
+                if prop.Name == name:
+                    return str(prop.NominalValue.wrappedValue)
+    raise BuildExportError(f"IFC product {product.GlobalId} lacks property {name}")
+
+
+def _json_safe(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {str(key): _json_safe(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [_json_safe(item) for item in value]
+    if isinstance(value, (str, int, float, bool)) or value is None:
+        return value
+    return str(value)
+
+
+def _normalize_header(path: Path) -> None:
+    text = path.read_text(encoding="utf-8")
+    timestamp = normalized_build_epoch().strftime("%Y-%m-%dT%H:%M:%S")
+    normalized, count = re.subn(
+        r"(FILE_NAME\s*\(\s*'[^']*'\s*,\s*')[^']*(')",
+        rf"\g<1>{timestamp}\2",
+        text,
+        count=1,
+    )
+    if count != 1:
+        raise BuildExportError("IFC header does not contain one normalizable FILE_NAME timestamp")
+    path.write_text(normalized, encoding="utf-8", newline="\n")

python_cad_tools/exporters/quantities.py

@@ -0,0 +1,136 @@
+"""Exact geometry-derived Python CAD Tools quantity schedules."""
+
+from __future__ import annotations
+
+import csv
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+from ..determinism import write_json
+from ..elements import DesignModel, QuantityRecord
+from .base import selected_elements
+
+
+class QuantityExporter:
+    name = "quantities"
+
+    def export(self, model: DesignModel, output_dir: Path) -> list[Path]:
+        target = output_dir / "quantities"
+        target.mkdir(parents=True, exist_ok=True)
+        records = records_for(model)
+        json_path = write_json(
+            target / "quantities.json",
+            {
+                "schema_id": "urn:python-cad-tools:schema:quantities:1",
+                "schema_version": 1,
+                "records": [record_to_dict(record) for record in records],
+            },
+        )
+        quantities_csv = target / "quantities.csv"
+        with quantities_csv.open("w", newline="", encoding="utf-8") as stream:
+            writer = csv.DictWriter(
+                stream,
+                fieldnames=list(record_to_dict(records[0]).keys()) if records else _fields(),
+                lineterminator="\n",
+            )
+            writer.writeheader()
+            writer.writerows(record_to_dict(record) for record in records)
+
+        materials = material_rows(model, records)
+        materials_csv = target / "materials.csv"
+        with materials_csv.open("w", newline="", encoding="utf-8") as stream:
+            writer = csv.DictWriter(
+                stream,
+                fieldnames=list(materials[0].keys()) if materials else _material_fields(),
+                lineterminator="\n",
+            )
+            writer.writeheader()
+            writer.writerows(materials)
+
+        summary = target / "summary.md"
+        total_volume = sum(record.volume_mm3 or 0 for record in records)
+        known_masses = [record.mass_kg for record in records if record.mass_kg is not None]
+        mass_line = f"{sum(known_masses):.3f} kg" if known_masses else "not calculated (no material density)"
+        summary.write_text(
+            "# Quantity Summary\n\n"
+            "Geometry-derived quantities from physical shared-model elements. Reference geometry is excluded.\n\n"
+            f"- Physical elements: {sum(record.count for record in records)}\n"
+            f"- Exact volume: {total_volume / 1_000_000_000:.6f} m³\n"
+            f"- Known mass: {mass_line}\n"
+            "- Waste factor: not applied\n"
+            "- Cost: not calculated\n",
+            encoding="utf-8",
+        )
+        return [json_path, quantities_csv, materials_csv, summary]
+
+
+def records_for(model: DesignModel) -> list[QuantityRecord]:
+    result: list[QuantityRecord] = []
+    for element in selected_elements(model, "quantities", physical_only=True):
+        area = float(element.geometry.area)
+        volume = float(element.geometry.volume)
+        density = element.material.density_kg_m3 if element.material else None
+        mass = volume / 1_000_000_000 * density if density is not None else None
+        result.append(
+            QuantityRecord(
+                element_id=element.id,
+                category=element.category,
+                material_id=element.material.id if element.material else None,
+                count=1,
+                area_mm2=area,
+                volume_mm3=volume,
+                mass_kg=mass,
+                provenance="exact_geometry",
+            )
+        )
+    return sorted(result, key=lambda record: record.element_id)
+
+
+def record_to_dict(record: QuantityRecord) -> dict[str, Any]:
+    return {
+        "element_id": record.element_id,
+        "category": record.category,
+        "material_id": record.material_id,
+        "count": record.count,
+        "area_mm2": round(record.area_mm2, 6) if record.area_mm2 is not None else None,
+        "volume_mm3": round(record.volume_mm3, 6) if record.volume_mm3 is not None else None,
+        "mass_kg": round(record.mass_kg, 6) if record.mass_kg is not None else None,
+        "provenance": record.provenance,
+    }
+
+
+def _fields() -> list[str]:
+    return ["element_id", "category", "material_id", "count", "area_mm2", "volume_mm3", "mass_kg", "provenance"]
+
+
+def _material_fields() -> list[str]:
+    return ["material_id", "material_name", "category", "element_count", "volume_m3", "mass_kg", "waste_factor"]
+
+
+def material_rows(model: DesignModel, records: list[QuantityRecord]) -> list[dict[str, Any]]:
+    materials = {element.material.id: element.material for element in model.walk() if element.material}
+    grouped: dict[str, list[QuantityRecord]] = defaultdict(list)
+    for record in records:
+        if record.material_id:
+            grouped[record.material_id].append(record)
+    rows = []
+    for material_id in sorted(grouped):
+        records_for_material = grouped[material_id]
+        material = materials[material_id]
+        rows.append(
+            {
+                "material_id": material_id,
+                "material_name": material.name,
+                "category": material.category,
+                "element_count": sum(record.count for record in records_for_material),
+                "volume_m3": round(sum(record.volume_mm3 or 0 for record in records_for_material) / 1_000_000_000, 9),
+                "mass_kg": (
+                    round(sum(record.mass_kg for record in records_for_material if record.mass_kg is not None), 6)
+                    if any(record.mass_kg is not None for record in records_for_material)
+                    else None
+                ),
+                "waste_factor": 0,
+            }
+        )
+    return rows

python_cad_tools/exporters/step.py

@@ -0,0 +1,117 @@
+"""Exact BREP STEP export with independent reload checks."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from build123d import Compound, import_step
+from build123d.exporters3d import _create_xde
+from OCP.IFSelect import IFSelect_ReturnStatus
+from OCP.Interface import Interface_Static
+from OCP.Message import Message, Message_Gravity
+from OCP.STEPCAFControl import STEPCAFControl_Controller, STEPCAFControl_Writer
+from OCP.STEPControl import STEPControl_Controller, STEPControl_StepModelType
+
+from ..determinism import normalized_build_epoch, write_json
+from ..exceptions import BuildExportError
+from ..geometry import combined_bounds
+from .base import selected_elements
+
+
+class StepExporter:
+    name = "step"
+
+    def export(self, model, output_dir: Path) -> list[Path]:
+        target = output_dir / "step"
+        target.mkdir(parents=True, exist_ok=True)
+        path = target / f"{model.artifact_stem}.step"
+        elements = selected_elements(model, "step", physical_only=True)
+        if not elements:
+            raise BuildExportError("STEP export requires at least one physical solid")
+        # Initialize the controllers before setting the schema. Their first initialization
+        # installs defaults and would otherwise reset this value to AP214.
+        STEPCAFControl_Controller.Init_s()
+        STEPControl_Controller.Init_s()
+        compound = Compound(children=[element.geometry for element in elements])
+        _export_ap242(compound, path)
+        _normalize_header(path)
+        if not path.exists() or path.stat().st_size == 0:
+            raise BuildExportError("STEP writer produced no artifact")
+        reloaded = import_step(path)
+        expected = combined_bounds([element.geometry for element in elements])
+        actual = combined_bounds([reloaded])
+        if any(abs(left - right) > 0.01 for left, right in zip(expected, actual, strict=True)):
+            raise BuildExportError(f"STEP reload bounds differ: expected {expected}, got {actual}")
+        if not bool(reloaded.is_valid):
+            raise BuildExportError("Reloaded STEP shape is invalid")
+        schema = step_schema(path)
+        if not schema.startswith("AP242_"):
+            raise BuildExportError(f"STEP writer did not honor the AP242 requirement: {schema}")
+        report = write_json(
+            target / "validation.json",
+            {
+                "schema_id": "urn:python-cad-tools:schema:step-validation:1",
+                "schema_version": 1,
+                "valid": True,
+                "schema": schema,
+                "requested_schema": "AP242",
+                "schema_note": "The generated file was independently reloaded and its header reports AP242.",
+                "solid_count": len(reloaded.solids()),
+                "bounds_mm": [round(value, 6) for value in actual],
+            },
+        )
+        return [path, report]
+
+
+def _export_ap242(compound: Compound, path: Path) -> None:
+    """Write an XDE assembly with OCP's default session so AP242 is honored."""
+    if not Interface_Static.SetCVal_s("write.step.schema", "AP242DIS"):
+        raise BuildExportError("OCP rejected the AP242 STEP schema setting")
+
+    document = _create_xde(compound, auto_naming=True)
+    messenger = Message.DefaultMessenger_s()
+    for printer in messenger.Printers():
+        printer.SetTraceLevel(Message_Gravity.Message_Fail)
+
+    writer = STEPCAFControl_Writer()
+    writer.SetColorMode(True)
+    writer.SetLayerMode(True)
+    writer.SetNameMode(True)
+    if not writer.Transfer(document, STEPControl_StepModelType.STEPControl_AsIs):
+        raise BuildExportError("STEP writer could not transfer the XDE assembly")
+    status = writer.Write(str(path))
+    if status != IFSelect_ReturnStatus.IFSelect_RetDone:
+        raise BuildExportError(f"STEP writer failed with status {status}")
+
+
+def step_schema(path: Path) -> str:
+    header = path.read_text(encoding="latin-1", errors="ignore")[:16000]
+    match = re.search(r"FILE_SCHEMA\s*\(\s*\(\s*'([^']+)'", header)
+    return match.group(1) if match else "unknown"
+
+
+def _normalize_header(path: Path) -> None:
+    text = path.read_text(encoding="latin-1")
+    timestamp = normalized_build_epoch().strftime("%Y-%m-%dT%H:%M:%S")
+    normalized, count = re.subn(
+        r"(FILE_NAME\s*\(\s*'[^']*'\s*,\s*')[^']*(')",
+        rf"\g<1>{timestamp}\2",
+        text,
+        count=1,
+    )
+    if count != 1:
+        raise BuildExportError("STEP header does not contain one normalizable FILE_NAME timestamp")
+    occurrence = 0
+
+    def normalize_occurrence(match: re.Match[str]) -> str:
+        nonlocal occurrence
+        occurrence += 1
+        return f"{match.group(1)}'{occurrence}'{match.group(2)}"
+
+    normalized = re.sub(
+        r"(NEXT_ASSEMBLY_USAGE_OCCURRENCE\s*\()'[^']*'(\s*,)",
+        normalize_occurrence,
+        normalized,
+    )
+    path.write_text(normalized, encoding="latin-1", newline="\n")

python_cad_tools/geometry.py

@@ -0,0 +1,187 @@
+"""Python CAD Tools geometry adapters using explicit millimetre inputs."""
+
+from __future__ import annotations
+
+from math import isfinite, sqrt
+from typing import Any
+
+from build123d import Align, Box, Edge, Face, Location, Plane, Solid, Vector, Wire
+
+from .exceptions import ModelValidationError
+from .units import Length, to_mm
+
+
+def box(
+    length: Length,
+    width: Length,
+    height: Length,
+    *,
+    origin: tuple[Length, Length, Length] | None = None,
+) -> Solid:
+    _positive_lengths((length, width, height), "Box dimensions")
+    if origin is not None:
+        _point(origin, "Box origin")
+    shape = Box(
+        to_mm(length),
+        to_mm(width),
+        to_mm(height),
+        align=(Align.MIN, Align.MIN, Align.MIN),
+    )
+    solid = shape.solid()
+    if solid is None:
+        raise RuntimeError("build123d Box did not produce a solid")
+    if origin is not None:
+        solid = solid.moved(Location(tuple(to_mm(value) for value in origin)))
+    return solid
+
+
+def reference_line(
+    start: tuple[Length, Length, Length],
+    end: tuple[Length, Length, Length],
+) -> Edge:
+    start_mm = _point(start, "Reference-line start")
+    end_mm = _point(end, "Reference-line end")
+    if start_mm == end_mm:
+        raise ModelValidationError("Reference-line endpoints must be distinct")
+    return Edge.make_line(start_mm, end_mm)
+
+
+def cylinder_between(
+    start: tuple[Length, Length, Length],
+    end: tuple[Length, Length, Length],
+    radius: Length,
+) -> Solid:
+    _positive_lengths((radius,), "Cylinder radius")
+    start_mm = _point(start, "Cylinder start")
+    end_mm = _point(end, "Cylinder end")
+    direction = tuple(end_mm[index] - start_mm[index] for index in range(3))
+    height = sqrt(sum(value * value for value in direction))
+    if height <= 0:
+        raise ModelValidationError("Cylinder endpoints must be distinct")
+    return Solid.make_cylinder(to_mm(radius), height, Plane(origin=start_mm, z_dir=direction))
+
+
+def prism_between(
+    start: tuple[Length, Length, Length],
+    end: tuple[Length, Length, Length],
+    width: Length,
+    height: Length,
+) -> Solid:
+    _positive_lengths((width, height), "Prism dimensions")
+    start_mm = _point(start, "Prism start")
+    end_mm = _point(end, "Prism end")
+    direction = tuple(end_mm[index] - start_mm[index] for index in range(3))
+    length = sqrt(sum(value * value for value in direction))
+    if length <= 0:
+        raise ModelValidationError("Prism endpoints must be distinct")
+    x_dir = tuple(value / length for value in direction)
+    horizontal = sqrt(x_dir[0] ** 2 + x_dir[1] ** 2)
+    if horizontal <= 1e-12:
+        z_dir = (1.0, 0.0, 0.0)
+    else:
+        z_dir = (-x_dir[0] * x_dir[2] / horizontal, -x_dir[1] * x_dir[2] / horizontal, horizontal)
+    return Solid.make_box(length, to_mm(width), to_mm(height), Plane(origin=start_mm, x_dir=x_dir, z_dir=z_dir))
+
+
+def sloped_pool(
+    length: Length,
+    width: Length,
+    shallow_depth: Length,
+    deep_depth: Length,
+    *,
+    origin: tuple[Length, Length, Length],
+) -> Solid:
+    _positive_lengths((length, width, shallow_depth, deep_depth), "Sloped-pool dimensions")
+    if to_mm(deep_depth) < to_mm(shallow_depth):
+        raise ModelValidationError("Sloped-pool deep depth must be at least the shallow depth")
+    length_mm = to_mm(length)
+    width_mm = to_mm(width)
+    shallow_mm = to_mm(shallow_depth)
+    deep_mm = to_mm(deep_depth)
+    origin_mm = _point(origin, "Sloped-pool origin")
+    profile = Wire.make_polygon(
+        [
+            origin_mm,
+            (origin_mm[0] + length_mm, origin_mm[1], origin_mm[2]),
+            (origin_mm[0] + length_mm, origin_mm[1], origin_mm[2] - deep_mm),
+            (origin_mm[0], origin_mm[1], origin_mm[2] - shallow_mm),
+        ],
+        close=True,
+    )
+    return Solid.extrude(Face(profile), Vector(0, width_mm, 0))
+
+
+def bounds(shape: Any) -> tuple[float, float, float, float, float, float]:
+    box_value = shape.bounding_box()
+    return (
+        float(box_value.min.X),
+        float(box_value.min.Y),
+        float(box_value.min.Z),
+        float(box_value.max.X),
+        float(box_value.max.Y),
+        float(box_value.max.Z),
+    )
+
+
+def combined_bounds(shapes: list[Any]) -> tuple[float, float, float, float, float, float]:
+    values = [bounds(shape) for shape in shapes]
+    if not values:
+        return (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+    return (
+        min(value[0] for value in values),
+        min(value[1] for value in values),
+        min(value[2] for value in values),
+        max(value[3] for value in values),
+        max(value[4] for value in values),
+        max(value[5] for value in values),
+    )
+
+
+def tessellate(shape: Any, linear_deflection: float, angular_deflection: float) -> tuple[list[list[float]], list[list[int]]]:
+    vertices, triangles = shape.tessellate(linear_deflection, angular_deflection)
+    points = [[float(vertex.X), float(vertex.Y), float(vertex.Z)] for vertex in vertices]
+    faces = [[int(index) for index in triangle] for triangle in triangles]
+    return points, faces
+
+
+def is_valid_solid(shape: Any) -> bool:
+    return isinstance(shape, Solid) and bool(shape.is_valid) and float(shape.volume) > 0
+
+
+def diagonal(bounds_value: tuple[float, float, float, float, float, float]) -> float:
+    return sqrt(sum((bounds_value[index + 3] - bounds_value[index]) ** 2 for index in range(3)))
+
+
+def _positive_lengths(values: tuple[Length, ...], label: str) -> None:
+    try:
+        converted = tuple(to_mm(value) for value in values)
+    except (TypeError, ValueError) as error:
+        raise ModelValidationError(f"{label} must be Length values") from error
+    if not all(isfinite(value) and value > 0 for value in converted):
+        raise ModelValidationError(f"{label} must be finite and strictly positive")
+
+
+def _point(values: tuple[Length, Length, Length], label: str) -> tuple[float, float, float]:
+    if not isinstance(values, tuple) or len(values) != 3:
+        raise ModelValidationError(f"{label} must be an (x, y, z) Length tuple")
+    try:
+        converted = tuple(to_mm(value) for value in values)
+    except (TypeError, ValueError) as error:
+        raise ModelValidationError(f"{label} must be an (x, y, z) Length tuple") from error
+    if not all(isfinite(value) for value in converted):
+        raise ModelValidationError(f"{label} must contain finite coordinates")
+    return converted  # type: ignore[return-value]
+
+
+__all__ = [
+    "bounds",
+    "box",
+    "combined_bounds",
+    "cylinder_between",
+    "diagonal",
+    "is_valid_solid",
+    "prism_between",
+    "reference_line",
+    "sloped_pool",
+    "tessellate",
+]