weldbox 0.1.0__py3-none-any.whl

weldbox/__init__.py

@@ -0,0 +1,3 @@
+"""weldbox — generate vendor-ready tube laser cut lists for welded box frames."""
+
+__version__ = "0.1.0"

weldbox/blocking.py

@@ -0,0 +1,188 @@
+"""Expand blocking primitives (level / supports / spanner) into frame members.
+
+See frame.py module docstring for the placement conventions.
+"""
+
+from __future__ import annotations
+
+from .frame import FrameBuilder, Layer, Member
+from .spec import BlockingItem, LevelSpec, SpannerSpec, SupportsSpec
+
+
+def expand_blocking(b: FrameBuilder, items: list[BlockingItem]) -> None:
+    spanner_counts = {"top": 0, "bottom": 0}
+    for item in items:
+        if isinstance(item, LevelSpec):
+            _expand_level(b, item)
+        elif isinstance(item, SupportsSpec):
+            _expand_supports(b, item)
+        elif isinstance(item, SpannerSpec):
+            _expand_spanner(b, item, spanner_counts)
+        else:  # pragma: no cover
+            raise TypeError(f"unknown blocking item {item!r}")
+
+
+def _level_z_center(b: FrameBuilder, item: LevelSpec) -> float:
+    half = b.s / 2
+    if item.height_ref == "top_face":
+        return item.height - half
+    if item.height_ref == "bottom_face":
+        return item.height + half
+    return item.height  # centerline
+
+
+def _validate_level_height(b: FrameBuilder, item: LevelSpec, name: str, z_center: float) -> None:
+    """A level's rails must clear both the base and top layers. Report the
+    violation in the user's own terms (their height + height_ref) with the
+    valid range for this box."""
+    lo_center, hi_center = 1.5 * b.s, b.H - 1.5 * b.s
+    if lo_center <= z_center <= hi_center:
+        return
+    ref_offset = {"top_face": b.s / 2, "centerline": 0.0, "bottom_face": -b.s / 2}[
+        item.height_ref
+    ]
+    lo, hi = lo_center + ref_offset, hi_center + ref_offset
+    where = (
+        f"is above the box (exterior height {b.H:g}mm)"
+        if item.height > b.H
+        else "collides with the base or top frame"
+    )
+    hint = (
+        " The top frame already provides a surface at the exterior height."
+        if z_center > hi_center
+        else ""
+    )
+    raise ValueError(
+        f"level {name!r}: height {item.height:g}mm ({item.height_ref}) {where}. "
+        f"With {b.s:g}mm tube and a {b.H:g}mm tall box, a level's height "
+        f"({item.height_ref}) must be between {lo:g}mm and {hi:g}mm.{hint}"
+    )
+
+
+def _expand_level(b: FrameBuilder, item: LevelSpec) -> None:
+    name = item.name or f"level@{item.height:g}"
+    z_center = _level_z_center(b, item)
+    _validate_level_height(b, item, name, z_center)
+    layer = b.build_layer(name, z_center, "tee")
+
+    if item.cross_members is None:
+        return
+    n = item.cross_members.count
+    s, wg = b.s, b.wg
+    if item.cross_members.axis == "depth":
+        # members along Y, butted between the layer's front and back rails,
+        # evenly spaced across the exterior width
+        for k in range(1, n + 1):
+            x = b.W * k / (n + 1)
+            m = b.add_member(
+                Member(
+                    id=f"{name}-cross-{k}",
+                    role="cross",
+                    profile=b.profile,
+                    axis="y",
+                    origin=(x, s + wg, z_center),
+                    length=b.D - 2 * s - 2 * wg,
+                )
+            )
+            b._butt("tee", m.id, 0, layer.rails["front"], "+y", x)
+            b._butt("tee", m.id, 1, layer.rails["back"], "-y", x)
+    else:  # axis == "width": members along X between left and right rails
+        for k in range(1, n + 1):
+            y = b.D * k / (n + 1)
+            m = b.add_member(
+                Member(
+                    id=f"{name}-cross-{k}",
+                    role="cross",
+                    profile=b.profile,
+                    axis="x",
+                    origin=(s + wg, y, z_center),
+                    length=b.W - 2 * s - 2 * wg,
+                )
+            )
+            b._butt("tee", m.id, 0, layer.rails["left"], "+x", y)
+            b._butt("tee", m.id, 1, layer.rails["right"], "-x", y)
+
+
+def _resolve_layer(b: FrameBuilder, ref: str) -> Layer:
+    if ref in b.layers:
+        return b.layers[ref]
+    raise LookupError(
+        f"unknown layer {ref!r} in supports.between; "
+        f"available: {', '.join(sorted(b.layers))}"
+    )
+
+
+def _expand_supports(b: FrameBuilder, item: SupportsSpec) -> None:
+    lo, hi = sorted((_resolve_layer(b, r) for r in item.between), key=lambda l: l.z_center)
+    s, wg = b.s, b.wg
+    z0 = lo.z_center + s / 2 + wg  # top face of lower rails
+    z1 = hi.z_center - s / 2 - wg  # bottom face of upper rails
+    length = z1 - z0
+    if length <= 0:
+        raise ValueError(f"supports between {lo.name!r} and {hi.name!r} have no span")
+
+    # one support at the midpoint of each of the 4 rail pairs
+    half = s / 2
+    positions = {
+        "front": (b.W / 2, half),
+        "back": (b.W / 2, b.D - half),
+        "left": (half, b.D / 2),
+        "right": (b.W - half, b.D / 2),
+    }
+    for key, (x, y) in positions.items():
+        m = b.add_member(
+            Member(
+                id=f"support-{lo.name}-{hi.name}-{key}",
+                role="support",
+                profile=b.profile,
+                axis="z",
+                origin=(x, y, z0),
+                length=length,
+            )
+        )
+        mid = b.W / 2 if key in ("front", "back") else b.D / 2
+        b._butt("tee", m.id, 0, lo.rails[key], "+z", mid)
+        b._butt("tee", m.id, 1, hi.rails[key], "-z", mid)
+
+
+def _expand_spanner(b: FrameBuilder, item: SpannerSpec, counts: dict[str, int]) -> None:
+    s, wg = b.s, b.wg
+    fractions = (
+        [item.position]
+        if item.count == 1
+        else [k / (item.count + 1) for k in range(1, item.count + 1)]
+    )
+    for face in item.face:
+        layer = _resolve_layer(b, {"top": "top", "bottom": "base"}[face])
+        for fraction in fractions:
+            counts[face] += 1
+            name = f"{face}-spanner-{counts[face]}"
+            if item.axis == "width":
+                # along X at a fraction of the depth, between left/right rails
+                y = b.D * fraction
+                m = b.add_member(
+                    Member(
+                        id=name,
+                        role="spanner",
+                        profile=b.profile,
+                        axis="x",
+                        origin=(s + wg, y, layer.z_center),
+                        length=b.W - 2 * s - 2 * wg,
+                    )
+                )
+                b._butt("tee", m.id, 0, layer.rails["left"], "+x", y)
+                b._butt("tee", m.id, 1, layer.rails["right"], "-x", y)
+            else:  # axis == "depth": along Y between front/back rails
+                x = b.W * fraction
+                m = b.add_member(
+                    Member(
+                        id=name,
+                        role="spanner",
+                        profile=b.profile,
+                        axis="y",
+                        origin=(x, s + wg, layer.z_center),
+                        length=b.D - 2 * s - 2 * wg,
+                    )
+                )
+                b._butt("tee", m.id, 0, layer.rails["front"], "+y", x)
+                b._butt("tee", m.id, 1, layer.rails["back"], "-y", x)

weldbox/catalog.py

@@ -0,0 +1,153 @@
+"""Vendor tube material catalogs.
+
+Profiles are loaded from per-vendor YAML files (see vendors/data/*.yaml),
+hand-encoded from each vendor's published material list. Dimensions in the
+YAML are inches (as published); they are converted to mm on load.
+
+Corner radius: some vendor tables (e.g. RFMG stainless and aluminum) omit
+the outside corner radius. Where missing on a square/rect profile we fall
+back to 2 x wall, which matches every steel row RFMG does publish.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+import yaml
+
+from .units import MM_PER_INCH
+
+MATCH_TOL_MM = 0.02
+
+
+@dataclass(frozen=True)
+class TubeProfile:
+    id: str
+    shape: str  # "square" | "rect" | "round" | "pipe"
+    outer_w_mm: float  # width (or OD for round)
+    outer_h_mm: float  # height (== width for square/round)
+    wall_mm: float
+    corner_r_mm: float | None  # outside corner radius; None for round
+    material_family: str  # e.g. "A500", "304", "6061 T6"
+    display_name: str
+
+    @property
+    def corner_r_resolved_mm(self) -> float:
+        """Outside corner radius, falling back to 2 x wall when unpublished."""
+        if self.shape == "round":
+            return 0.0
+        if self.corner_r_mm is not None:
+            return self.corner_r_mm
+        return 2.0 * self.wall_mm
+
+    @property
+    def section_area_mm2(self) -> float:
+        """Analytic hollow-section area (used for weight estimates)."""
+        from math import pi
+
+        w, h, t = self.outer_w_mm, self.outer_h_mm, self.wall_mm
+        if self.shape == "round":
+            return pi / 4 * (w**2 - (w - 2 * t) ** 2)
+        r_out = self.corner_r_resolved_mm if self.corner_r_resolved_mm > 0.01 else 0.0
+        r_in = max(r_out - t, 0.0)
+        outer = w * h - (4 - pi) * r_out**2
+        inner = (w - 2 * t) * (h - 2 * t) - (4 - pi) * r_in**2
+        return outer - inner
+
+    @property
+    def density_g_cm3(self) -> float:
+        return density_for(self.material_family)
+
+
+def density_for(material_family: str) -> float:
+    fam = material_family.lower()
+    if "6061" in fam or "6063" in fam:
+        return 2.70  # aluminum
+    if "304" in fam or "stainless" in fam:
+        return 8.00  # stainless
+    return 7.85  # carbon/alloy steel (A500, 4130, DOM)
+
+
+@dataclass(frozen=True)
+class SheetMaterial:
+    alloy: str
+    thickness_mm: float
+
+
+@dataclass
+class Catalog:
+    vendor: str
+    profiles: list[TubeProfile] = field(default_factory=list)
+
+    def find(
+        self,
+        shape: str,
+        outer_w_mm: float,
+        outer_h_mm: float,
+        wall_mm: float,
+        material_family: str | None = None,
+    ) -> TubeProfile:
+        shape = _normalize_shape(shape)
+        matches = [
+            p
+            for p in self.profiles
+            if _normalize_shape(p.shape) == shape
+            and _close(p.wall_mm, wall_mm)
+            and (
+                (_close(p.outer_w_mm, outer_w_mm) and _close(p.outer_h_mm, outer_h_mm))
+                or (_close(p.outer_w_mm, outer_h_mm) and _close(p.outer_h_mm, outer_w_mm))
+            )
+        ]
+        if material_family:
+            fam = material_family.lower()
+            matches = [p for p in matches if fam in p.material_family.lower()]
+        if not matches:
+            raise LookupError(
+                f"no {shape} profile {outer_w_mm:g}x{outer_h_mm:g}mm wall {wall_mm:g}mm"
+                f"{' (' + material_family + ')' if material_family else ''}"
+                f" in {self.vendor} catalog"
+            )
+        if len(matches) > 1:
+            names = ", ".join(p.display_name for p in matches)
+            raise LookupError(
+                f"ambiguous profile match in {self.vendor} catalog ({names}); "
+                "specify material family to disambiguate"
+            )
+        return matches[0]
+
+
+def _close(a: float, b: float, tol: float = MATCH_TOL_MM) -> bool:
+    return abs(a - b) <= tol
+
+
+def _normalize_shape(shape: str) -> str:
+    s = shape.lower()
+    return {"rectangular": "rect", "rectangle": "rect"}.get(s, s)
+
+
+def load_catalog(path: Path, vendor: str) -> Catalog:
+    """Load a vendor catalog YAML (dimensions in inches) into mm profiles."""
+    data = yaml.safe_load(path.read_text()) or {}
+    profiles = []
+    for row in data.get("profiles", []):
+        shape = _normalize_shape(row["shape"])
+        outer = row["outer_in"]
+        if isinstance(outer, (int, float)):
+            outer_w = outer_h = float(outer)
+        else:
+            outer_w, outer_h = (float(v) for v in outer)
+        corner = row.get("corner_r_in")
+        profiles.append(
+            TubeProfile(
+                id=row["id"],
+                shape=shape,
+                outer_w_mm=outer_w * MM_PER_INCH,
+                outer_h_mm=outer_h * MM_PER_INCH,
+                wall_mm=float(row["wall_in"]) * MM_PER_INCH,
+                corner_r_mm=None if corner is None else float(corner) * MM_PER_INCH,
+                material_family=str(row["family"]),
+                display_name=row["name"],
+            )
+        )
+    return Catalog(vendor=vendor, profiles=profiles)

weldbox/cli.py

@@ -0,0 +1,98 @@
+"""weldbox CLI: generate / wizard / catalog."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from .units import inches
+from .vendors import VENDORS, get_vendor
+
+app = typer.Typer(help="Generate vendor-ready tube laser cut lists for welded boxes.")
+catalog_app = typer.Typer(help="Browse vendor material catalogs.")
+app.add_typer(catalog_app, name="catalog")
+
+console = Console()
+
+
+@catalog_app.command("list")
+def catalog_list(
+    vendor: str = typer.Option("rfmg", help=f"Vendor: {', '.join(sorted(VENDORS))}"),
+    shape: str = typer.Option(None, help="Filter by shape: square, rect, round"),
+) -> None:
+    """List tube profiles available from a vendor."""
+    v = get_vendor(vendor)
+    cat = v.catalog()
+    profiles = cat.profiles
+    if shape:
+        profiles = [p for p in profiles if p.shape == shape.lower().replace("rectangular", "rect")]
+    if not profiles:
+        console.print(
+            f"[yellow]No profiles for vendor '{v.display_name}'"
+            f"{f' with shape {shape}' if shape else ''}."
+            + (" Catalog not yet encoded." if not cat.profiles else "")
+        )
+        raise typer.Exit(1)
+
+    table = Table(title=f"{v.display_name} tube profiles ({len(profiles)})")
+    table.add_column("Profile")
+    table.add_column("Shape")
+    table.add_column("Outer (in)", justify="right")
+    table.add_column("Wall (in)", justify="right")
+    table.add_column("Corner R (in)", justify="right")
+    table.add_column("Family")
+    for p in profiles:
+        outer = (
+            f"{inches(p.outer_w_mm):g}"
+            if p.outer_w_mm == p.outer_h_mm
+            else f"{inches(p.outer_w_mm):g} x {inches(p.outer_h_mm):g}"
+        )
+        corner = "—" if p.shape == "round" else (
+            f"{inches(p.corner_r_mm):g}" if p.corner_r_mm is not None
+            else f"{inches(p.corner_r_resolved_mm):g}*"
+        )
+        table.add_row(p.display_name, p.shape, outer, f"{inches(p.wall_mm):g}", corner, p.material_family)
+    console.print(table)
+    console.print("[dim]* corner radius not published; 2 x wall assumed[/dim]")
+
+
+@app.command()
+def generate(
+    spec_path: Path = typer.Argument(..., help="Path to a box spec YAML file"),
+    out: Path = typer.Option(Path("out"), "-o", "--out", help="Output directory"),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Print cut list only, no CAD"),
+    skip_assembly: bool = typer.Option(False, help="Skip the combined assembly STEP"),
+) -> None:
+    """Generate the cut list (STEP files, panel DXFs, manifest) from a spec."""
+    from pydantic import ValidationError
+
+    from .generate import run_generate
+
+    try:
+        run_generate(spec_path, out, dry_run=dry_run, skip_assembly=skip_assembly, console=console)
+    except ValidationError as exc:
+        console.print(f"[red]error:[/red] invalid spec {spec_path}:")
+        for err in exc.errors():
+            loc = ".".join(str(p) for p in err["loc"])
+            console.print(f"  [red]•[/red] {loc}: {err['msg']}")
+        raise typer.Exit(1) from None
+    except (ValueError, LookupError, NotImplementedError) as exc:
+        console.print(f"[red]error:[/red] {exc}")
+        raise typer.Exit(1) from None
+
+
+@app.command()
+def wizard(
+    spec_path: Path = typer.Argument(None, help="Existing spec YAML to edit"),
+) -> None:
+    """Interactively author a box spec YAML."""
+    from .wizard import run_wizard
+
+    run_wizard(spec_path, console=console)
+
+
+if __name__ == "__main__":
+    app()

weldbox/consolidate.py

@@ -0,0 +1,116 @@
+"""Part-count consolidation: add sacrificial slots/holes so near-identical
+members become the SAME stock part.
+
+Members that share a profile and cut length often differ only in which
+faces carry slots or rivet holes (e.g. the two front posts lack the
+front-face rivet holes the back posts have). For each (profile, length)
+group this pass aligns every member to a reference via the square-tube
+symmetry group, unions the feature sets, and writes the union back to each
+member — so all of them collapse to one part in dedupe. The extra features
+are cosmetic through-wall cuts (unused slots or holes); they never remove a
+tab and never overlap an existing feature.
+
+Alignment is chosen greedily to minimize the union size. A member whose
+best alignment would still create overlapping features is left out of the
+group and keeps its own part.
+"""
+
+from __future__ import annotations
+
+from .features import (
+    Feature,
+    RivetHole,
+    SlotFeature,
+    TabFeature,
+    feature_key,
+    inverse_transform,
+    transform_feature,
+)
+from .frame import FrameGraph, Member
+
+# minimum web of material left between neighboring features
+_CLEARANCE = 0.5
+
+
+def consolidate_parts(frame: FrameGraph) -> dict[str, int]:
+    """Union features across same-profile/same-length members. Returns
+    {member_id: number_of_added_features} for reporting."""
+    from .dedupe import ALL_TRANSFORMS
+
+    groups: dict[tuple, list[Member]] = {}
+    for m in frame.members:
+        groups.setdefault((m.profile.id, round(m.length, 2)), []).append(m)
+
+    added: dict[str, int] = {}
+    for members in groups.values():
+        if len(members) < 2:
+            continue
+        # richest feature set first: it anchors the reference frame
+        members = sorted(members, key=lambda m: len(m.features), reverse=True)
+        ref = members[0]
+        part_feats: dict[tuple, Feature] = {
+            feature_key(f): f for f in ref.features
+        }
+        placements: list[tuple[Member, int, bool]] = [(ref, 0, False)]
+
+        for m in members[1:]:
+            best = None  # (union_size, q, flipped, mapped_feats)
+            for q, flipped in ALL_TRANSFORMS:
+                mapped = {
+                    feature_key(tf): tf
+                    for tf in (
+                        transform_feature(f, m.length, q, flipped) for f in m.features
+                    )
+                }
+                union = {**part_feats, **mapped}
+                if _has_conflict(union.values()):
+                    continue
+                if best is None or len(union) < best[0]:
+                    best = (len(union), q, flipped, union)
+            if best is None:
+                continue  # keeps its own part
+            _, q, flipped, union = best
+            part_feats = union
+            placements.append((m, q, flipped))
+
+        for m, q, flipped in placements:
+            iq, iflip = inverse_transform(q, flipped)
+            new_features = [
+                transform_feature(f, m.length, iq, iflip) for f in part_feats.values()
+            ]
+            n_added = len(new_features) - len(m.features)
+            if n_added:
+                added[m.id] = n_added
+            m.features = new_features
+    return added
+
+
+def _footprint(f: Feature) -> tuple[str, float, float, float, float] | None:
+    """(face, z_min, z_max, lat_min, lat_max) of a cut feature, or None for
+    tabs (tabs live on end planes; identical tabs merge by key)."""
+    if isinstance(f, SlotFeature):
+        dz = f.width / 2 + f.dogbone_r
+        dl = f.length / 2 + f.dogbone_r
+        return (f.face, f.z - dz, f.z + dz, f.lateral - dl, f.lateral + dl)
+    if isinstance(f, RivetHole):
+        r = f.dia / 2
+        return (f.face, f.z - r, f.z + r, f.lateral - r, f.lateral + r)
+    return None
+
+
+def _has_conflict(features) -> bool:
+    """True if any two distinct cut features on the same face overlap (with
+    a small clearance web), or a cut crosses a tab's protruding wall."""
+    boxes = [fp for f in features if (fp := _footprint(f)) is not None]
+    for i, a in enumerate(boxes):
+        for b in boxes[i + 1:]:
+            if a[0] != b[0]:
+                continue
+            if (
+                a[1] < b[2] + _CLEARANCE
+                and b[1] < a[2] + _CLEARANCE
+                and a[3] < b[4] + _CLEARANCE
+                and b[3] < a[4] + _CLEARANCE
+            ):
+                return True
+    return False

weldbox/dedupe.py

@@ -0,0 +1,73 @@
+"""Group physically identical members into unique parts.
+
+Two members are the same stock part when one can be mapped onto the other
+by a symmetry of the square tube: rotation about the member axis in 90
+degree steps (4) x end-for-end flip (2) = 8 transforms. The signature is
+the minimum over all 8 transforms of the transformed feature set — so a
+part and its end-swapped or rotated twin collapse together.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .features import feature_key, transform_feature
+from .frame import FrameGraph, Member
+
+_ROUND = 2  # mm decimals in signatures
+
+ALL_TRANSFORMS: list[tuple[int, bool]] = [
+    (q, flipped) for flipped in (False, True) for q in (0, 1, 2, 3)
+]
+
+
+def transformed_keys(member: Member, quarter_turns: int, flipped: bool) -> tuple:
+    return tuple(
+        sorted(
+            feature_key(transform_feature(f, member.length, quarter_turns, flipped))
+            for f in member.features
+        )
+    )
+
+
+def part_signature(member: Member) -> tuple:
+    variants = [transformed_keys(member, q, flipped) for q, flipped in ALL_TRANSFORMS]
+    return (member.profile.id, round(member.length, _ROUND), min(variants))
+
+
+@dataclass
+class UniquePart:
+    signature: tuple
+    exemplar: Member
+    member_ids: list[str] = field(default_factory=list)
+    name: str = ""
+
+    @property
+    def qty(self) -> int:
+        return len(self.member_ids)
+
+
+def group_parts(frame: FrameGraph) -> list[UniquePart]:
+    groups: dict[tuple, UniquePart] = {}
+    for m in frame.members:
+        sig = part_signature(m)
+        part = groups.get(sig)
+        if part is None:
+            part = groups[sig] = UniquePart(signature=sig, exemplar=m)
+        part.member_ids.append(m.id)
+
+    parts = sorted(groups.values(), key=lambda p: (-p.exemplar.length, p.exemplar.id))
+    # name each part by its member role (or "member-<length>" when a part is
+    # used across several roles); number repeats (rail vs rail-2)
+    base_names: list[str] = []
+    for part in parts:
+        roles = {frame.member(mid).role for mid in part.member_ids}
+        if len(roles) == 1:
+            base_names.append(next(iter(roles)))
+        else:
+            base_names.append(f"member-{part.exemplar.length:.0f}mm")
+    seen: dict[str, int] = {}
+    for part, base in zip(parts, base_names):
+        seen[base] = seen.get(base, 0) + 1
+        part.name = base if base_names.count(base) == 1 else f"{base}-{seen[base]}"
+    return parts