layer-rescue 1.0.1__py3-none-any.whl

layer_rescue/__init__.py

@@ -0,0 +1,34 @@
+"""Layer Rescue: conservative G-code recovery for interrupted FDM prints."""
+
+from ._version import __version__
+from .core import (
+    Analysis,
+    LayerInfo,
+    ResumeError,
+    ResumeOptions,
+    ResumeReport,
+    ZReferenceMode,
+    analyze_gcode,
+    build_resume_gcode,
+    rewrite_gcode_file,
+)
+from .fileio import rewrite_with
+from .insert import InsertOptions, InsertReport, build_insert_gcode, plan_insert
+
+__all__ = [
+    "__version__",
+    "Analysis",
+    "LayerInfo",
+    "ResumeError",
+    "ResumeOptions",
+    "ResumeReport",
+    "ZReferenceMode",
+    "analyze_gcode",
+    "build_resume_gcode",
+    "rewrite_gcode_file",
+    "rewrite_with",
+    "InsertOptions",
+    "InsertReport",
+    "build_insert_gcode",
+    "plan_insert",
+]

layer_rescue/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

layer_rescue/_version.py

@@ -0,0 +1 @@
+__version__ = "1.0.1"

layer_rescue/cli.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import __version__
+from .core import ResumeError, ResumeOptions, ZReferenceMode, analyze_gcode, rewrite_gcode_file
+from .fileio import rewrite_with
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="layer-rescue",
+        description="Create conservative layer-resume G-code for interrupted Bambu Lab P1S prints.",
+    )
+    parser.add_argument("gcode", nargs="?", help="G-code path; Bambu Studio appends this automatically")
+    selection = parser.add_mutually_exclusive_group()
+    selection.add_argument("--start-layer", type=int, help="first layer to print")
+    selection.add_argument("--last-layer", type=int, help="last successfully printed layer")
+    selection.add_argument(
+        "--part-height",
+        type=float,
+        help="insert mode: measured height (mm) of a loose part to seat in a printed wall and print on top of",
+    )
+    selection.add_argument("--part-layer", type=int, help="insert mode: last source layer the loose part contains")
+    parser.add_argument("--gui", action="store_true", help="open the graphical layer selector")
+    parser.add_argument("--analyze", action="store_true", help="print source information without modifying it")
+    parser.add_argument(
+        "--z-mode",
+        choices=[mode.value for mode in ZReferenceMode],
+        help="Z reference: retained after uninterrupted power, or manual after a restart",
+    )
+    parser.add_argument(
+        "--confirm-manual-z-aligned",
+        action="store_true",
+        help="confirm that the nozzle was aligned to touch the last successful layer",
+    )
+    parser.add_argument(
+        "--assume-z-known",
+        action="store_true",
+        help="deprecated alias for --z-mode retained",
+    )
+    parser.add_argument(
+        "--allow-untested",
+        action="store_true",
+        help="accept the risks and continue with a printer or multi-filament job Layer Rescue has not been tested on",
+    )
+    parser.add_argument("--no-home-corexy", action="store_true", help="do not emit the P1S G28 X CoreXY home")
+    parser.add_argument("--no-backup", action="store_true", help="do not create a sibling .bak file")
+    parser.add_argument("--nozzle-temp", type=int, help="override detected nozzle temperature")
+    parser.add_argument("--bed-temp", type=int, help="override detected bed temperature")
+    parser.add_argument("--z-lift", type=float, default=2.0, help="relative safety lift before CoreXY motion (default: 2.0)")
+    insert = parser.add_argument_group("insert mode (a loose part seated in a printed wall)")
+    insert.add_argument("--wall-height", type=float, help="holding wall height in mm (default: recommended)")
+    insert.add_argument("--clearance", type=float, default=0.25, help="gap between part and wall in mm (default: 0.25)")
+    insert.add_argument("--wall-lines", type=int, default=4, help="wall thickness in lines (default: 4)")
+    insert.add_argument("--brim", type=float, default=5.0, help="brim width around the wall in mm (default: 5)")
+    insert.add_argument("--no-chamfer", action="store_true", help="no lead-in chamfer at the wall rim")
+    insert.add_argument("--z-fine", type=float, default=0.0, help="added to the part height; negative squishes more")
+    insert.add_argument("--standby-temp", type=int, default=140, help="nozzle °C while paused, 0 = keep (default: 140)")
+    insert.add_argument("--adhesion-layers", type=int, default=2, help="hotter/slower/no-fan layers on the part (default: 2)")
+    insert.add_argument(
+        "--confirm-attended",
+        action="store_true",
+        help="confirm you will seat the part when the printer pauses and watch the first layers",
+    )
+    insert.add_argument(
+        "--no-reprint-supports",
+        action="store_true",
+        help="do not print the supports below the part height before the pause",
+    )
+    insert.add_argument("--preview-svg", help="insert mode: also write a top-view SVG of the wall to this path")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return parser
+
+
+def _analysis_json(path: Path) -> str:
+    from .machine_state import untested_setup
+
+    analysis = analyze_gcode(path.read_text(encoding="utf-8", errors="replace"))
+    return json.dumps(
+        {
+            "file": str(path),
+            "printer_model": analysis.printer_model,
+            "filament_type": analysis.filament_type,
+            "first_layer": analysis.first_layer,
+            "last_layer": analysis.last_layer,
+            "total_layers": analysis.total_layers,
+            "first_z": analysis.layers[0].z,
+            "last_z": analysis.layers[-1].z,
+            "sha256": analysis.source_sha256,
+            "warnings": analysis.warnings,
+            "untested_setup": untested_setup(analysis),
+        },
+        indent=2,
+    )
+
+
+def _run_insert(args: argparse.Namespace, path: Path) -> int:
+    from .insert import InsertOptions, build_insert_gcode, plan_insert
+
+    if not args.confirm_attended:
+        raise ResumeError(
+            "Insert mode requires --confirm-attended: you must seat the part when the printer pauses "
+            "and watch the first layers."
+        )
+    part_height = args.part_height
+    if part_height is None:
+        analysis = analyze_gcode(path.read_text(encoding="utf-8", errors="replace"))
+        part_height = analysis.layer(args.part_layer).z
+    options = InsertOptions(
+        part_height_mm=part_height,
+        wall_height_mm=args.wall_height,
+        clearance_mm=args.clearance,
+        wall_lines=args.wall_lines,
+        brim_mm=args.brim,
+        chamfer=not args.no_chamfer,
+        z_fine_mm=args.z_fine,
+        standby_temperature=args.standby_temp,
+        adhesion_layers=args.adhesion_layers,
+        reprint_supports=not args.no_reprint_supports,
+        allow_untested=args.allow_untested,
+        z_lift_mm=args.z_lift,
+        nozzle_temperature=args.nozzle_temp,
+        bed_temperature=args.bed_temp,
+    )
+    if args.preview_svg:
+        from .preview import plan_svg
+
+        plan = plan_insert(path.read_text(encoding="utf-8", errors="replace"), options)
+        Path(args.preview_svg).write_text(plan_svg(plan), encoding="utf-8")
+    report, backup = rewrite_with(
+        path, lambda text: build_insert_gcode(text, options), create_backup=not args.no_backup
+    )
+    print(
+        json.dumps(
+            {
+                "status": "converted",
+                "mode": "insert",
+                "part_height_mm": report.part_height_mm,
+                "part_layer": report.part_layer,
+                "resume_layer": report.resume_layer,
+                "total_layers": report.total_layers,
+                "z_offset_mm": report.z_offset_mm,
+                "first_layer_thickness_mm": report.first_layer_thickness_mm,
+                "wall_layers": report.wall_layers,
+                "wall_top_z": report.wall_top_z,
+                "park_z": report.park_z,
+                "wall_filament_mm": report.wall_filament_mm,
+                "support_layers": report.support_layers,
+                "last_printed_layer": report.last_printed_layer,
+                "nozzle_temperature": report.nozzle_temperature,
+                "bed_temperature": report.bed_temperature,
+                "backup": str(backup) if backup else None,
+                "output_sha256": report.output_sha256,
+                "warnings": report.warnings,
+            },
+            indent=2,
+        )
+    )
+    return 0
+
+
+def post_processing_command() -> str:
+    """The command to paste into Bambu Studio's Post-processing Scripts field."""
+    if getattr(sys, "frozen", False):
+        return f'"{sys.executable}"'
+    return f'"{sys.executable}" -m layer_rescue'
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parser().parse_args(argv)
+    if not args.gcode:
+        if getattr(sys, "frozen", False):
+            # Opened directly (double-click) instead of from Bambu Studio: explain the setup.
+            from .gui import show_setup_info
+
+            return show_setup_info(post_processing_command())
+        _parser().error("a G-code path is required")
+    path = Path(args.gcode).expanduser().resolve()
+
+    try:
+        if args.analyze:
+            print(_analysis_json(path))
+            return 0
+
+        if args.part_height is not None or args.part_layer is not None:
+            return _run_insert(args, path)
+
+        if args.gui or (args.start_layer is None and args.last_layer is None):
+            from .gui import launch
+
+            return launch(path)
+
+        if args.assume_z_known and args.z_mode not in {None, ZReferenceMode.RETAINED.value}:
+            raise ResumeError(
+                "--assume-z-known is an alias for --z-mode retained and cannot be combined with manual mode."
+            )
+        z_mode_value = args.z_mode or (ZReferenceMode.RETAINED.value if args.assume_z_known else None)
+        if z_mode_value is None:
+            raise ResumeError("Batch conversion requires --z-mode retained or --z-mode manual.")
+        z_mode = ZReferenceMode(z_mode_value)
+        if z_mode is ZReferenceMode.MANUAL and not args.confirm_manual_z_aligned:
+            raise ResumeError(
+                "Manual mode requires --confirm-manual-z-aligned after the nozzle touches the last successful layer."
+            )
+
+        start_layer = args.start_layer if args.start_layer is not None else args.last_layer + 1
+        report = rewrite_gcode_file(
+            path,
+            ResumeOptions(
+                start_layer=start_layer,
+                z_reference_mode=z_mode,
+                home_corexy=not args.no_home_corexy,
+                z_lift_mm=args.z_lift,
+                nozzle_temperature=args.nozzle_temp,
+                bed_temperature=args.bed_temp,
+                allow_untested=args.allow_untested,
+            ),
+            create_backup=not args.no_backup,
+        )
+        print(
+            json.dumps(
+                {
+                    "status": "converted",
+                    "start_layer": report.start_layer,
+                    "total_layers": report.total_layers,
+                    "start_z": report.start_z,
+                    "nozzle_temperature": report.nozzle_temperature,
+                    "bed_temperature": report.bed_temperature,
+                    "z_reference_mode": report.z_reference_mode.value,
+                    "reference_z": report.reference_z,
+                    "backup": str(report.backup_path) if report.backup_path else None,
+                    "output_sha256": report.output_sha256,
+                    "warnings": report.warnings,
+                },
+                indent=2,
+            )
+        )
+        return 0
+    except (OSError, ResumeError) as exc:
+        print(f"layer-rescue: error: {exc}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

layer_rescue/core.py

@@ -0,0 +1,29 @@
+"""Backward-compatible facade; the implementation lives in the gcode, machine_state, resume and fileio modules."""
+
+from __future__ import annotations
+
+from .fileio import _available_backup_path, rewrite_gcode_file, rewrite_with
+from .gcode import *  # noqa: F401,F403
+from .gcode import (  # noqa: F401
+    _code,
+    _command,
+    _find_layers,
+    _find_marker,
+    _first_number,
+    _format_number,
+    _next_extrusion_mode,
+    _parameter,
+    _parse_config,
+)
+from .machine_state import MachineState, _scan_machine_state, _validate_supported_source  # noqa: F401
+from .resume import *  # noqa: F401,F403
+from .resume import (  # noqa: F401
+    _first_layer_xy,
+    _format_z_delta,
+    _relative_z_move,
+    _relativize_z,
+    _resume_preamble,
+    _retraction_length,
+    _validate_output,
+    _z_reference_mode,
+)

layer_rescue/fileio.py

@@ -0,0 +1,77 @@
+"""Atomic in-place rewriting of the G-code file Bambu Studio hands to the post-processor."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+from dataclasses import replace
+from pathlib import Path
+from typing import Callable, TypeVar
+
+from .gcode import ResumeError
+from .resume import ResumeOptions, ResumeReport, build_resume_gcode
+
+R = TypeVar("R")
+
+
+def _available_backup_path(path: Path) -> Path:
+    candidate = path.with_name(path.name + ".layer-rescue.bak")
+    counter = 1
+    while candidate.exists():
+        candidate = path.with_name(path.name + f".layer-rescue.{counter}.bak")
+        counter += 1
+    return candidate
+
+
+
+def rewrite_with(
+    path: str | os.PathLike[str],
+    builder: Callable[[str], tuple[str, R]],
+    *,
+    create_backup: bool = True,
+) -> tuple[R, Path | None]:
+    """Run ``builder`` on the file's text and replace the file atomically, keeping a backup."""
+    source_path = Path(path).expanduser().resolve()
+    if not source_path.is_file():
+        raise ResumeError(f"G-code file does not exist: {source_path}")
+    if source_path.suffix.lower() not in {".gcode", ".gco"}:
+        raise ResumeError("Post-processing MVP accepts raw .gcode files only.")
+
+    text = source_path.read_text(encoding="utf-8", errors="replace")
+    output, report = builder(text)
+    backup_path: Path | None = None
+    if create_backup:
+        backup_path = _available_backup_path(source_path)
+        shutil.copy2(source_path, backup_path)
+
+    temp_name: str | None = None
+    try:
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            encoding="utf-8",
+            newline="",
+            dir=source_path.parent,
+            prefix=source_path.name + ".",
+            suffix=".tmp",
+            delete=False,
+        ) as handle:
+            temp_name = handle.name
+            handle.write(output)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(temp_name, source_path)
+    finally:
+        if temp_name and Path(temp_name).exists():
+            Path(temp_name).unlink()
+    return report, backup_path
+
+
+def rewrite_gcode_file(
+    path: str | os.PathLike[str],
+    options: ResumeOptions,
+    *,
+    create_backup: bool = True,
+) -> ResumeReport:
+    report, backup_path = rewrite_with(path, lambda text: build_resume_gcode(text, options), create_backup=create_backup)
+    return replace(report, backup_path=backup_path)

layer_rescue/flow.py

@@ -0,0 +1,108 @@
+"""Extrusion amounts and print speeds for toolpaths Layer Rescue generates itself."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Mapping
+
+from .gcode import NUMBER_RE
+
+
+def extrusion_per_mm(width: float, height: float, filament_diameter: float, flow_ratio: float = 1.0) -> float:
+    """Filament length per mm of path for a rounded-rectangle bead (the Slic3r/Bambu flow model)."""
+    if width <= 0 or height <= 0 or filament_diameter <= 0:
+        raise ValueError("width, height and filament diameter must be positive")
+    width = max(width, height)
+    bead_area = (width - height) * height + math.pi * (height / 2) ** 2
+    filament_area = math.pi * (filament_diameter / 2) ** 2
+    return bead_area / filament_area * flow_ratio
+
+
+def _number(config: Mapping[str, str], key: str, *, relative_to: float | None = None) -> float | None:
+    value = config.get(key)
+    if not value:
+        return None
+    match = NUMBER_RE.search(value)
+    if not match:
+        return None
+    number = float(match.group(0))
+    if "%" in value.split(",")[0] and relative_to is not None:
+        return number / 100 * relative_to
+    return number
+
+
+def _first(config: Mapping[str, str], *keys: str, default: float, relative_to: float | None = None) -> float:
+    for key in keys:
+        value = _number(config, key, relative_to=relative_to)
+        if value is not None and value > 0:
+            return value
+    return default
+
+
+@dataclass(frozen=True)
+class FlowSettings:
+    nozzle_diameter: float = 0.4
+    line_width: float = 0.42
+    first_layer_line_width: float = 0.5
+    filament_diameter: float = 1.75
+    flow_ratio: float = 0.98
+    wall_speed: float = 60.0  # mm/s
+    first_layer_speed: float = 30.0
+    travel_speed: float = 200.0
+    support_speed: float = 60.0
+    retraction_length: float = 0.8
+    retraction_speed: float = 30.0
+    z_hop: float = 0.4
+    min_layer_time: float = 8.0  # s
+    min_speed: float = 20.0
+
+    @property
+    def wall_feed(self) -> int:
+        return int(round(self.wall_speed * 60))
+
+    @property
+    def first_layer_feed(self) -> int:
+        return int(round(self.first_layer_speed * 60))
+
+    @property
+    def support_feed(self) -> int:
+        return int(round(self.support_speed * 60))
+
+    @property
+    def travel_feed(self) -> int:
+        return int(round(self.travel_speed * 60))
+
+    @property
+    def retraction_feed(self) -> int:
+        return int(round(self.retraction_speed * 60))
+
+
+# The wall is a fixture, not a show piece: print it at moderate speeds whatever the profile says.
+MAX_WALL_SPEED = 100.0
+MAX_FIRST_LAYER_SPEED = 40.0
+MAX_TRAVEL_SPEED = 300.0
+
+
+def flow_settings_from_config(config: Mapping[str, str]) -> FlowSettings:
+    nozzle = _first(config, "nozzle_diameter", default=0.4)
+    return FlowSettings(
+        nozzle_diameter=nozzle,
+        line_width=_first(config, "outer_wall_line_width", "line_width", default=nozzle * 1.05, relative_to=nozzle),
+        first_layer_line_width=_first(
+            config, "initial_layer_line_width", "first_layer_extrusion_width", default=nozzle * 1.25, relative_to=nozzle
+        ),
+        filament_diameter=_first(config, "filament_diameter", default=1.75),
+        flow_ratio=min(max(_first(config, "filament_flow_ratio", "extrusion_multiplier", default=1.0), 0.5), 1.5),
+        wall_speed=min(_first(config, "outer_wall_speed", "external_perimeter_speed", default=60.0), MAX_WALL_SPEED),
+        first_layer_speed=min(
+            _first(config, "initial_layer_speed", "first_layer_speed", default=30.0), MAX_FIRST_LAYER_SPEED
+        ),
+        travel_speed=min(_first(config, "travel_speed", default=200.0), MAX_TRAVEL_SPEED),
+        support_speed=min(_first(config, "support_speed", default=60.0), MAX_WALL_SPEED),
+        retraction_length=min(_first(config, "retraction_length", default=0.8), 5.0),
+        retraction_speed=min(_first(config, "retraction_speed", default=30.0), 60.0),
+        z_hop=min(_first(config, "z_hop", "retract_lift_above", default=0.4), 2.0),
+        min_layer_time=_first(config, "slow_down_layer_time", "slowdown_below_layer_time", default=8.0),
+        min_speed=_first(config, "slow_down_min_speed", "min_print_speed", default=20.0),
+    )