estampo 0.2.0__py3-none-any.whl

estampo/__init__.py

@@ -0,0 +1,24 @@
+"""estampo — Reproducible 3D print builds."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+__version__ = "0.2.0"
+
+
+class EstampoError(Exception):
+    """User-facing error — printed without a traceback."""
+
+
+# Backward-compatible alias (fabprint → estampo migration)
+FabprintError = EstampoError
+
+
+def require_file(path: Path, label: str = "File") -> None:
+    """Raise FileNotFoundError if *path* does not exist."""
+    if not path.exists():
+        raise FileNotFoundError(f"{label} not found: {path}")
+
+
+__all__ = ["EstampoError", "FabprintError", "__version__", "require_file"]

estampo/adapters.py

@@ -0,0 +1,248 @@
+"""Hamilton lifecycle adapters for pipeline observability.
+
+These adapters plug into the Hamilton driver to provide per-node timing,
+logging, and extensible hooks without modifying any pipeline node code.
+
+Usage::
+
+    from estampo.adapters import TimingAdapter, ProgressAdapter
+
+    dr = (
+        driver.Builder()
+        .with_modules(pipeline)
+        .with_adapters(ProgressAdapter())
+        .build()
+    )
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from hamilton.lifecycle import NodeExecutionHook
+
+if TYPE_CHECKING:
+    from rich.status import Status
+
+log = logging.getLogger(__name__)
+
+
+class TimingAdapter(NodeExecutionHook):
+    """Log elapsed time for every pipeline node."""
+
+    def __init__(self) -> None:
+        self._starts: dict[str, float] = {}
+
+    def run_before_node_execution(
+        self,
+        *,
+        node_name: str,
+        node_tags: dict,
+        node_kwargs: dict,
+        node_return_type: type,
+        task_id: str | None,
+        run_id: str,
+        **future_kwargs,
+    ) -> None:
+        self._starts[node_name] = time.monotonic()
+        log.debug("Starting: %s", node_name)
+
+    def run_after_node_execution(
+        self,
+        *,
+        node_name: str,
+        node_tags: dict,
+        node_kwargs: dict,
+        node_return_type: type,
+        result,
+        error: Exception | None,
+        success: bool,
+        task_id: str | None,
+        run_id: str,
+        **future_kwargs,
+    ) -> None:
+        elapsed = time.monotonic() - self._starts.pop(node_name, time.monotonic())
+        if success:
+            log.info("Completed: %s (%.2fs)", node_name, elapsed)
+        else:
+            log.warning("Failed: %s (%.2fs) — %s", node_name, elapsed, error)
+
+
+class ProgressAdapter(NodeExecutionHook):
+    """Rich spinner + checkmark progress for user-visible pipeline stages."""
+
+    # Only these Hamilton nodes get a visible spinner / checkmark line.
+    _STAGE_NODES: frozenset[str] = frozenset(
+        {
+            "loaded_parts",
+            "placements",
+            "plate_3mf_path",
+            "sliced_output_dir",
+            "gcode_stats",
+            "print_result",
+        }
+    )
+
+    _SPINNER_LABELS: dict[str, str] = {
+        "loaded_parts": "Loading parts",
+        "placements": "Arranging onto plate",
+        "plate_3mf_path": "Exporting plate",
+        "preview_path": "Exporting preview",
+        "sliced_output_dir": "Slicing",
+        "gcode_stats": "Reading gcode",
+        "print_result": "Sending to printer",
+    }
+
+    def __init__(self) -> None:
+        from rich.console import Console
+
+        self._console = Console(highlight=False)
+        self._starts: dict[str, float] = {}
+        self._status: Status | None = None
+        self._slice_version: str | None = None
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _start_spinner(self, label: str) -> None:
+        from rich.status import Status
+
+        self._status = Status(label, console=self._console, spinner="dots")
+        self._status.start()
+
+    def _stop_spinner(self) -> None:
+        if self._status is not None:
+            self._status.stop()
+            self._status = None
+
+    def _ok(self, msg: str, elapsed: float = 0, *, show_elapsed: bool = True) -> None:
+        elapsed_str = ""
+        if show_elapsed and elapsed >= 2:
+            elapsed_str = f"[dim]{elapsed:.0f}s[/dim]"
+        self._console.print(f"[green]✔[/green] {msg}  {elapsed_str}".rstrip())
+
+    def _err(self, msg: str) -> None:
+        self._console.print(f"[red]✗[/red] {msg}")
+
+    # ------------------------------------------------------------------
+    # NodeExecutionHook
+    # ------------------------------------------------------------------
+
+    def run_before_node_execution(
+        self,
+        *,
+        node_name: str,
+        node_tags: dict,
+        node_kwargs: dict,
+        node_return_type: type,
+        task_id: str | None,
+        run_id: str,
+        **future_kwargs,
+    ) -> None:
+        if node_name not in self._STAGE_NODES:
+            return
+
+        self._starts[node_name] = time.monotonic()
+        label = self._SPINNER_LABELS.get(node_name, node_name)
+
+        if node_name == "sliced_output_dir":
+            cfg = node_kwargs.get("config")
+            ver = node_kwargs.get("docker_version")
+            if not ver and cfg and cfg.slicer.version:
+                ver = cfg.slicer.version
+            if ver:
+                label = f"Slicing with OrcaSlicer {ver}"
+                self._slice_version = ver
+
+        elif node_name == "print_result":
+            cfg = node_kwargs.get("config")
+            if cfg and cfg.printer:
+                label = f'Sending to printer "{cfg.printer.name}"'
+
+        # gcode_stats is fast — skip spinner, just print the result line
+        if node_name != "gcode_stats":
+            self._start_spinner(label)
+
+    def run_after_node_execution(
+        self,
+        *,
+        node_name: str,
+        node_tags: dict,
+        node_kwargs: dict,
+        node_return_type: type,
+        result,
+        error: Exception | None,
+        success: bool,
+        task_id: str | None,
+        run_id: str,
+        **future_kwargs,
+    ) -> None:
+        if node_name not in self._STAGE_NODES:
+            return
+
+        elapsed = time.monotonic() - self._starts.pop(node_name, time.monotonic())
+        self._stop_spinner()
+
+        if not success:
+            label = self._SPINNER_LABELS.get(node_name, node_name)
+            self._err(f"{label} failed — {error}")
+            return
+
+        if node_name == "loaded_parts":
+            n = len(result.meshes)
+            self._ok(f"Loaded {n} part{'s' if n != 1 else ''}", elapsed)
+
+        elif node_name == "placements":
+            n = len(result)
+            cfg = node_kwargs.get("config")
+            plate_str = ""
+            if cfg:
+                w, d = cfg.plate.size
+                plate_str = f"[dim]({w:.0f}×{d:.0f}mm)[/dim]"
+            self._ok(
+                f"Arranged {n} part{'s' if n != 1 else ''} onto plate  {plate_str}",
+                elapsed,
+            )
+
+        elif node_name == "plate_3mf_path":
+            name = result.name if isinstance(result, Path) else "plate.3mf"
+            self._ok(f"Plate exported → [dim]{name}[/dim]", elapsed)
+
+        elif node_name == "preview_path":
+            name = result.name if isinstance(result, Path) else "plate_preview.3mf"
+            self._ok(f"Preview exported → [dim]{name}[/dim]", elapsed)
+
+        elif node_name == "sliced_output_dir":
+            ver = self._slice_version
+            ver_str = f"with OrcaSlicer {ver}" if ver else ""
+            time_str = f" in {elapsed:.0f}s" if elapsed >= 2 else ""
+            self._ok(f"Sliced {ver_str}{time_str}".rstrip(), show_elapsed=False)
+            # Show gcode filename if available
+            if isinstance(result, Path):
+                gcode_files = list(result.glob("*.gcode"))
+                if gcode_files:
+                    self._console.print(f"  [dim]→ {gcode_files[0].name}[/dim]")
+
+        elif node_name == "gcode_stats":
+            parts: list[str] = []
+            if "print_time" in result:
+                parts.append(f"Print time: {result['print_time']}")
+            if "filament_g" in result:
+                parts.append(f"{result['filament_g']:.1f}g filament")
+            elif "filament_cm3" in result:
+                parts.append(f"{result['filament_cm3']:.1f}cm³ filament")
+            if parts:
+                self._ok(", ".join(parts), elapsed)
+
+        elif node_name == "print_result":
+            cfg = node_kwargs.get("config")
+            dry_run = node_kwargs.get("dry_run", False)
+            printer_name = cfg.printer.name if cfg and cfg.printer else "printer"
+            if dry_run:
+                self._ok(f'Dry run — would send to "{printer_name}"', elapsed)
+            else:
+                self._ok(f'Sent to printer "{printer_name}"', elapsed)

estampo/arrange.py

@@ -0,0 +1,100 @@
+"""2D bin packing of parts onto a build plate via rectpack."""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+
+import rectpack
+import trimesh
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class Placement:
+    mesh: trimesh.Trimesh
+    name: str
+    x: float
+    y: float
+
+
+def arrange(
+    meshes: list[trimesh.Trimesh],
+    names: list[str],
+    plate_size: tuple[float, float],
+    padding: float = 5.0,
+) -> list[Placement]:
+    """Pack oriented meshes onto a build plate.
+
+    Returns a list of Placement objects with meshes translated to their packed positions.
+    Raises ValueError if not all parts fit on the plate.
+    """
+    if len(meshes) != len(names):
+        raise ValueError("meshes and names must have the same length")
+
+    # Compute padded XY bounding boxes (use integer mm for rectpack)
+    rects = []
+    for i, mesh in enumerate(meshes):
+        w = mesh.extents[0] + padding
+        h = mesh.extents[1] + padding
+        rects.append((i, int(w + 1), int(h + 1)))  # ceil to int
+
+    packer = rectpack.newPacker(
+        mode=rectpack.PackingMode.Offline,
+        pack_algo=rectpack.MaxRectsBssf,
+        rotation=False,
+    )
+    packer.add_bin(int(plate_size[0]), int(plate_size[1]))
+    for idx, w, h in rects:
+        packer.add_rect(w, h, rid=idx)
+
+    packer.pack()
+
+    packed = packer.rect_list()
+    if len(packed) != len(meshes):
+        raise ValueError(
+            f"Only {len(packed)}/{len(meshes)} parts fit on the "
+            f"{plate_size[0]}x{plate_size[1]}mm plate"
+        )
+
+    placements = []
+    for _bin_id, x, y, _w, _h, rid in packed:
+        mesh = meshes[rid].copy()
+        # Translate mesh: move min XY to the packed position (+ half padding offset)
+        min_x, min_y = mesh.bounds[0][0], mesh.bounds[0][1]
+        offset_x = x + padding / 2 - min_x
+        offset_y = y + padding / 2 - min_y
+        mesh.apply_translation([offset_x, offset_y, 0])
+        placements.append(Placement(mesh=mesh, name=names[rid], x=x, y=y))
+
+    # Center the packed group on the plate
+    _center_on_plate(placements, plate_size)
+
+    log.info("Packed %d parts onto plate", len(placements))
+    return placements
+
+
+def _center_on_plate(placements: list[Placement], plate_size: tuple[float, float]) -> None:
+    """Translate all placements so the group is centered on the plate."""
+    if not placements:
+        return
+
+    # Find bounding box of all placed meshes
+    all_min_x = min(p.mesh.bounds[0][0] for p in placements)
+    all_max_x = max(p.mesh.bounds[1][0] for p in placements)
+    all_min_y = min(p.mesh.bounds[0][1] for p in placements)
+    all_max_y = max(p.mesh.bounds[1][1] for p in placements)
+
+    group_cx = (all_min_x + all_max_x) / 2
+    group_cy = (all_min_y + all_max_y) / 2
+    plate_cx = plate_size[0] / 2
+    plate_cy = plate_size[1] / 2
+
+    dx = plate_cx - group_cx
+    dy = plate_cy - group_cy
+
+    for p in placements:
+        p.mesh.apply_translation([dx, dy, 0])
+        p.x += dx
+        p.y += dy

estampo/auth.py

@@ -0,0 +1,139 @@
+"""Bambu Cloud authentication — login, token caching, and device discovery."""
+
+from __future__ import annotations
+
+import json
+import logging
+
+import requests
+
+from estampo import EstampoError
+
+log = logging.getLogger(__name__)
+
+API_BASE = "https://api.bambulab.com"
+
+SLICER_HEADERS = {
+    "X-BBL-Client-Name": "OrcaSlicer",
+    "X-BBL-Client-Type": "slicer",
+    "X-BBL-Client-Version": "02.03.01.00",
+    "User-Agent": "bambu_network_agent/02.03.01.00",
+    "Content-Type": "application/json",
+}
+
+
+def _request_verification_code(email: str) -> None:
+    """Request a verification code be sent to the user's email."""
+    from estampo import ui
+
+    resp = requests.post(
+        f"{API_BASE}/v1/user-service/user/sendemail/code",
+        headers=SLICER_HEADERS,
+        json={"email": email, "type": "codeLogin"},
+    )
+    resp.raise_for_status()
+    ui.success(f"Verification code sent to {email}")
+
+
+def _login(email: str, password: str) -> tuple[str, str]:
+    """Login and return (access_token, refresh_token). Handles all auth flows."""
+
+    from estampo import ui
+
+    # Step 1: Try password login
+    ui.info("Attempting password login...")
+    resp = requests.post(
+        f"{API_BASE}/v1/user-service/user/login",
+        headers=SLICER_HEADERS,
+        json={"account": email, "password": password, "apiError": ""},
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    token = data.get("accessToken")
+    refresh_token = data.get("refreshToken", "")
+    login_type = data.get("loginType", "")
+
+    # Step 2: Handle verification code flow
+    # Always request a code — the API sometimes auto-sends one when
+    # loginType == "verifyCode", but not always (IP-based trust).
+    # Calling explicitly ensures the user always receives a code,
+    # though they may occasionally get two emails.
+    if not token and login_type == "verifyCode":
+        _request_verification_code(email)
+        code = ui.prompt_password("Enter verification code")
+        resp = requests.post(
+            f"{API_BASE}/v1/user-service/user/login",
+            headers=SLICER_HEADERS,
+            json={"account": email, "code": code},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        token = data.get("accessToken")
+        refresh_token = data.get("refreshToken", "")
+
+    # Step 3: Handle TFA flow
+    if not token and data.get("tfaKey"):
+        tfa_key = data["tfaKey"]
+        ui.info("Account requires two-factor authentication.")
+        tfa_code = ui.prompt_password("Enter 2FA code")
+        resp = requests.post(
+            f"{API_BASE}/v1/user-service/user/tfa",
+            headers=SLICER_HEADERS,
+            json={"tfaKey": tfa_key, "tfaCode": tfa_code},
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        token = data.get("accessToken")
+        refresh_token = data.get("refreshToken", "")
+
+    if not token:
+        log.debug("Login response: %s", json.dumps(data, indent=2))
+        raise EstampoError("Login failed — no access token in response")
+
+    return token, refresh_token
+
+
+def _get_user_profile(token: str) -> dict:
+    """Fetch user profile (uid, name, avatar)."""
+    resp = requests.get(
+        f"{API_BASE}/v1/design-user-service/my/preference",
+        headers={**SLICER_HEADERS, "Authorization": f"Bearer {token}"},
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    return {
+        "uid": str(data.get("uid", "")),
+        "name": data.get("name", ""),
+        "avatar": data.get("avatar", ""),
+    }
+
+
+def _get_devices(token: str) -> list[dict]:
+    """List printers bound to the account."""
+    resp = requests.get(
+        f"{API_BASE}/v1/iot-service/api/user/bind",
+        headers={**SLICER_HEADERS, "Authorization": f"Bearer {token}"},
+    )
+    resp.raise_for_status()
+    return resp.json().get("devices", [])
+
+
+def _show_devices(token: str) -> None:
+    """Print bound printers."""
+    from estampo import ui
+    from estampo.credentials import mask_serial
+
+    devices = _get_devices(token)
+    if devices:
+        ui.console.print()
+        items = []
+        for d in devices:
+            name = d.get("name", "unnamed")
+            dev_id = d.get("dev_id", "?")
+            model = d.get("dev_product_name", d.get("dev_model_name", "?"))
+            online_str = "[green]online[/green]" if d.get("online") else "[dim]offline[/dim]"
+            items.append((name, model, mask_serial(dev_id), online_str))
+        ui.choice_table(items, ["Name", "Model", "Serial", "Status"], markup=True)
+    else:
+        ui.info("No printers found")