Setup Required
Missing Python packages
To fix, run this command on your server:
pip install -r requirements.txt
Or if using a virtual environment:
./venv/bin/pip install -r requirements.txt
After installing, restart Bambuddy:
sudo systemctl restart bambuddy
"""
class ErrorHandler(BaseHTTPRequestHandler):
def do_GET(self):
self.send_response(503)
self.send_header("Content-type", "text/html")
self.end_headers()
self.wfile.write(html.encode())
def log_message(self, format, *args):
print(f"[Error Server] {args[0]}")
port = int(os.environ.get("PORT", 8000))
print(f"\nStarting error server on http://0.0.0.0:{port}")
print("Visit this URL in your browser to see the error details.\n")
server = HTTPServer(("0.0.0.0", port), ErrorHandler) # nosec B104
def shutdown(signum, frame):
print("\nShutting down error server...")
raise SystemExit(0)
signal.signal(signal.SIGTERM, shutdown)
signal.signal(signal.SIGINT, shutdown)
server.serve_forever()
def check_dependencies():
"""Check that all required packages are installed."""
missing = []
# Map of import name -> package name (for pip install)
required = {
"jwt": "PyJWT",
"fastapi": "fastapi",
"uvicorn": "uvicorn",
"sqlalchemy": "sqlalchemy",
"aiosqlite": "aiosqlite",
"pydantic": "pydantic",
"paho.mqtt": "paho-mqtt",
}
for module, package in required.items():
try:
__import__(module)
except ImportError:
missing.append(package)
if missing:
print("\n" + "=" * 60)
print("ERROR: Missing required Python packages!")
print("=" * 60)
print(f"\nMissing packages: {', '.join(missing)}")
print("\nTo fix, run:")
print(" pip install -r requirements.txt")
print("\nOr if using a virtual environment:")
print(" ./venv/bin/pip install -r requirements.txt")
print("=" * 60 + "\n")
_start_error_server(missing)
check_dependencies()
# =============================================================================
# Import settings first for logging configuration
# Configure logging based on settings
# DEBUG=true -> DEBUG level, else use LOG_LEVEL setting
log_level_str = "DEBUG" if app_settings.debug else app_settings.log_level.upper()
log_level = getattr(logging, log_level_str, logging.INFO)
# Trace ID column ([-] when no request scope is active — startup, MQTT
# callbacks, scheduled tasks not chained from a request — so the column
# stays visually aligned and missing values are obvious in grep). See
# backend/app/core/trace.py for the ContextVar that feeds this slot.
log_format = "%(asctime)s %(levelname)s [%(name)s] [%(trace_id)s] %(message)s"
# Create root logger
root_logger = logging.getLogger()
root_logger.setLevel(log_level)
# Trace-ID injection: this filter populates record.trace_id from the
# per-request ContextVar so the format string above can reference it.
# Attached to each HANDLER (not the root logger) because Python's
# logging semantics only invoke a logger's filters on records that
# *originated* at that logger — records propagated up from child
# loggers (every named logger in the app) never trigger root's filter.
# Putting it on the handlers means every record any handler emits gets
# trace_id injected just before the formatter runs, regardless of which
# logger created the record. Without this, the formatter raises
# KeyError on every child-logger record and the record is silently
# dropped — which is exactly the "logs/bambuddy.log only shows logs
# partially" bug we hit. See backend/app/core/trace.py for the
# ContextVar the filter reads.
from backend.app.core.trace import TraceIDFilter
_trace_id_filter = TraceIDFilter()
# Console handler - always enabled
console_handler = logging.StreamHandler()
console_handler.setLevel(log_level)
console_handler.setFormatter(logging.Formatter(log_format))
console_handler.addFilter(_trace_id_filter)
root_logger.addHandler(console_handler)
# File handler - only in production or if explicitly enabled
if app_settings.log_to_file:
log_file = app_settings.log_dir / "bambuddy.log"
file_handler = RotatingFileHandler(
log_file,
maxBytes=app_settings.log_max_bytes,
backupCount=app_settings.log_backup_count,
encoding="utf-8",
)
file_handler.setLevel(log_level)
file_handler.setFormatter(logging.Formatter(log_format))
file_handler.addFilter(_trace_id_filter)
root_logger.addHandler(file_handler)
logging.info("Logging to file: %s", log_file)
# Pipe uvicorn's HTTP access log to bambuddy.log too. Uvicorn ships its
# access logger with propagate=False by default, so without this attach
# there is no on-disk record of which endpoint triggered a server-state
# change — the rogue stop_print mystery on 2026-04-26 was untraceable
# for exactly this reason. Filtered to write methods only
# (POST/PUT/PATCH/DELETE) so the high-volume status-poll GETs from the
# frontend don't churn the rotation window faster than it's useful.
from backend.app.core.logging_filters import (
CancelledPoolNoiseFilter,
WriteRequestsOnlyFilter,
)
uvicorn_access_logger = logging.getLogger("uvicorn.access")
uvicorn_access_logger.addHandler(file_handler)
uvicorn_access_logger.addFilter(WriteRequestsOnlyFilter())
# Uvicorn's access logger has propagate=False (its own default), so the
# root-attached TraceIDFilter never sees these records. Attach a
# second instance directly so HTTP access lines carry the same trace
# ID column as the application logs they correlate with.
uvicorn_access_logger.addFilter(TraceIDFilter())
# Drop SQLAlchemy connection-pool log noise that's caused by Starlette's
# BaseHTTPMiddleware cancelling the inner task scope on client
# disconnect (#1112). The cancel-safe `get_db` already prevents the
# underlying transaction leak; this filter only suppresses the residual
# log records that pre-existing pools still emit during their cleanup.
logging.getLogger("sqlalchemy.pool").addFilter(CancelledPoolNoiseFilter())
# Reduce noise from third-party libraries in production
if not app_settings.debug:
logging.getLogger("sqlalchemy.engine").setLevel(logging.WARNING)
logging.getLogger("httpcore").setLevel(logging.WARNING)
logging.getLogger("httpx").setLevel(logging.WARNING)
logging.getLogger("paho.mqtt").setLevel(logging.WARNING)
logging.info("Bambuddy starting - debug=%s, log_level=%s", app_settings.debug, log_level_str)
# Track active prints: {(printer_id, filename): archive_id}
_active_prints: dict[tuple[int, str], int] = {}
# #1721: stage-22 pre-captured finish photo bytes per printer. on_finish_photo_moment
# fires when stg_cur enters 22 ("Filament unloading") at end-of-print — toolhead
# parked, bed not yet dropped — and grabs a single camera frame into this cache.
# `_background_finish_photo` (inside on_print_complete) consumes the cached bytes
# instead of running its own grab-now chain when present, so the finish photo
# captures the better-framed pre-bed-drop moment without us having to force
# timelapse on at dispatch (the #1397 mechanism that caused #1721's per-layer
# nozzle parking on slicer profiles with Timelapse Type = Smooth).
#
# #2708: the bytes in here are ALWAYS already rotated by the printer's
# camera_rotation. `on_finish_photo_moment` owns that, because one of its
# sources (the #1867 in-print bank) is rotated before it ever reaches the
# bank and the others are not — so the consumer can't tell them apart and
# must not rotate again.
_stage22_finish_frames: dict[int, bytes] = {}
# #1790: per-printer producer-done event. Set by `on_finish_photo_moment` in its
# `finally` block (whether it captured a frame or not). The consumer in
# `_background_finish_photo` waits on it before reading `_stage22_finish_frames`
# so the FINISH-state fallback path — where moment and completion are dispatched
# back-to-back — doesn't race past the producer with an empty pop, and the
# consumer's RTSP fallback can't collide with the producer's still-in-flight RTSP
# grab (Bambu printers allow only one RTSP client at a time).
_stage22_finish_in_flight: dict[int, asyncio.Event] = {}
# #1867: rolling "last in-print camera frame" per printer. Refreshed on
# layer-change and on print-progress advances (#2547) while the model is still
# printing, then consumed by the FINISH-state finish-photo path when the
# dispatcher recorded that it injected End G-code into this print. Bambu
# reports gcode_state=FINISH AFTER the user End G-code (e.g. SwapMod
# plate-swap) has run, so a live grab there would capture the swapped/empty
# plate.
#
# The load-bearing property: both drivers are print telemetry that stops before
# the End G-code executes — no further layer_num increases, and mc_percent
# freezes — so the last banked frame is always the finished print before the
# swap. Anything added as a third driver must hold that same property.
_inprint_frame_bank: dict[int, bytes] = {}
# Monotonic timestamp of the last banked frame per printer — throttles banking
# so tall prints don't add a camera grab on every layer.
_inprint_frame_bank_ts: dict[int, float] = {}
# Minimum seconds between banked frames, except the final object layer which
# always refreshes for the best framing.
_INPRINT_BANK_MIN_INTERVAL = 25.0
# Per-printer "connected" edge tracker. Used by `on_printer_status_change`
# to fire `reconcile_stale_active_prints` exactly once per (re)connection
# (#1542 follow-up — power-cycle ghost prints). The value is True after
# the first connected status update for that connection; transitions back
# to False whenever we observe `state.connected = False` so the next
# reconnect re-arms reconciliation. Keyed by printer_id.
_printer_reconciled_since_connect: dict[int, bool] = {}
# Track expected prints from reprint/scheduled (skip auto-archiving for these)
# {(printer_id, filename): archive_id}
_expected_prints: dict[tuple[int, str], int] = {}
# Track AMS mapping for prints: {archive_id: [global_tray_id_per_slot]}
# Used by usage tracker to map 3MF slots to physical AMS trays
_print_ams_mappings: dict[int, list[int]] = {}
# Track cost center selection for the current print run: {archive_id: cost_center_id}
_print_cost_center_ids: dict[int, int] = {}
# Track plate_id for prints from multi-plate 3MFs: {archive_id: plate_id}
# Used by usage tracker to scope 3MF parsing to the dispatched plate (#1697).
# Populated by direct-Print and queue dispatch paths; queue prints also have a
# redundant queue-item lookup in on_print_start so this dict isn't load-bearing
# for the queue path. Cleared on print completion or TTL eviction.
_print_plate_ids: dict[int, int] = {}
# Track progress milestones for notifications: {printer_id: last_milestone_notified}
# Milestones are 25, 50, 75. Value of 0 means no milestone notified yet for current print.
_last_progress_milestone: dict[int, int] = {}
# Track whether first layer complete notification has been sent for current print
_first_layer_notified: dict[int, bool] = {}
# Track whether we already sent a kill-switch stop for the current unauthorized print
_unauthorized_print_kill_sent: set[int] = set()
# The MQTT status callback is a hot path. Cache the two-setting kill-switch
# lookup briefly so an unknown active print does not query the database on
# every status frame. A short TTL keeps settings changes responsive.
_KILL_SWITCH_SETTING_CACHE_TTL_SECONDS = 5.0
_kill_switch_setting_cache: tuple[bool, float] | None = None
# Provider notification started when the kill switch stops a print. The later
# MQTT print-complete callback awaits this task and only sends its regular
# provider notification when the immediate attempt failed.
_kill_switch_notification_tasks: dict[int, asyncio.Task[bool]] = {}
# Track HMS errors that have been notified: {printer_id: set of error codes}
# This prevents sending duplicate notifications for the same error
_notified_hms_errors: dict[int, set[str]] = {}
# Track when HMS errors were last seen: {printer_id: timestamp}
# Used to debounce clearing — prevents flapping errors from re-triggering notifications
_hms_last_seen: dict[int, float] = {}
_HMS_CLEAR_GRACE_SECONDS = 30.0
# Track timelapse file baselines at print start: {printer_id: set of video filenames}
# Used for snapshot-diff detection at print completion
_timelapse_baselines: dict[int, set[str]] = {}
# Track printers waiting for bed to cool after print completion.
# Event-driven: fires when bed_temper arrives via MQTT below threshold.
# {printer_id: {"threshold": float, "filename": str, "registered_at": float}}
_bed_cool_waiters: dict[int, dict] = {}
# Track printers where the user explicitly stopped the print from the queue UI.
# When on_print_complete fires with status "failed" for these printers we treat it
# as "cancelled" (stopped by user) so the correct notification email is sent.
_user_stopped_printers: set[int] = set()
# Offline-notification edge state (#1752): fire `on_printer_offline` exactly
# once when a printer transitions connected → disconnected. `_printer_last_connected`
# holds the previous observation so we only fire on the True → False edge (a
# False → False repeat doesn't notify; an initial False at startup doesn't
# notify either, since there's no prior True). `_printer_offline_notify_tasks`
# holds the per-printer pending asyncio task that fires the notification
# after a debounce window — cancelled if the printer reconnects before the
# window elapses, so transient MQTT blips don't flood the user.
_printer_last_connected: dict[int, bool] = {}
_printer_offline_notify_tasks: dict[int, asyncio.Task] = {}
# Debounce: a printer must stay offline this long before we notify. Sized
# against the staleness path (`bambu_mqtt.py::STALE_RECONNECT_COOLDOWN = 30s`)
# so a single stale-trigger cooldown isn't enough to fire — only a real
# offline that survives one reconnect attempt notifies.
_PRINTER_OFFLINE_NOTIFY_DEBOUNCE_SECONDS = 60.0
# HMS short-code → human-readable failure reason. Used by _dispatch_archive_update
# when status="failed" to label the print's failure_reason in archives.
#
# Earlier code matched on `module` alone (e.g. "any module 0x0C HMS → Layer shift"),
# which is wrong on two counts:
# 1. Real layer-shift codes live in module 0x03 (see Bambu wiki), not 0x0C.
# 2. Module 0x0C is "Motion Controller" — broad category that also covers cameras
# and visual markers, AND the H2D firmware emits a 0x0C HMS (0C00_001B, not in
# the public wiki) as part of its user-cancel sequence. Matching on the module
# alone caused user-cancellations to be archived as "Layer shift" failures.
# We now match by full short code only — anything not in this map leaves
# failure_reason=None rather than guessing.
_HMS_FAILURE_REASONS: dict[str, str] = {
# Layer shift / step loss
"0300_4057": "Layer shift",
"0300_4068": "Layer shift",
"0300_800C": "Layer shift",
# Filament runout (printer-side & per-AMS-slot)
"0300_8004": "Filament runout",
"0700_8011": "Filament runout",
"0701_8011": "Filament runout",
"0702_8011": "Filament runout",
"0703_8011": "Filament runout",
"0704_8011": "Filament runout",
"0705_8011": "Filament runout",
"0706_8011": "Filament runout",
"0707_8011": "Filament runout",
"07FF_8011": "Filament runout",
# Clogged nozzle / extruder
"0300_4006": "Clogged nozzle",
"0300_8016": "Clogged nozzle",
"0300_801C": "Clogged nozzle",
"0700_8003": "Clogged nozzle",
"0700_8007": "Clogged nozzle",
"0700_8013": "Clogged nozzle",
"0701_8003": "Clogged nozzle",
"0701_8007": "Clogged nozzle",
"0701_8013": "Clogged nozzle",
"0702_8003": "Clogged nozzle",
}
def _hms_short_code(attr: int, code: int | str) -> str:
"""Build the canonical "MMMM_CCCC" HMS short code from raw attr/code values."""
if isinstance(code, str):
code_int = int(code.replace("0x", ""), 16) if code else 0
else:
code_int = int(code or 0)
attr_int = int(attr or 0)
return f"{(attr_int >> 16) & 0xFFFF:04X}_{code_int & 0xFFFF:04X}"
def derive_failure_reason(status: str, hms_errors: list[dict] | None) -> str | None:
"""Derive a human-readable failure_reason for an archived print.
Returns "User cancelled" for cancelled/aborted prints; for failed prints,
returns the first matching reason from _HMS_FAILURE_REASONS, or None when
no HMS code matches (don't guess — null is honest).
"""
if status in ("aborted", "cancelled"):
return "User cancelled"
if status != "failed":
return None
for err in hms_errors or []:
short_code = _hms_short_code(err.get("attr", 0), err.get("code", 0))
if short_code in _HMS_FAILURE_REASONS:
return _HMS_FAILURE_REASONS[short_code]
return None
# Track created_by_id for expected prints so the user email can be sent even when
# the archive itself doesn't have created_by_id set (e.g. library-file-based prints).
# {(printer_id, filename): created_by_id}
_expected_print_creators: dict[tuple[int, str], int] = {}
# Per-printer lock that serialises the spool-assignment side of on_ams_change
# (auto-unlink stale + auto-assign new) when MQTT bursts deliver multiple AMS
# updates for the same printer in quick succession (~30 ms apart, observed in
# the wild on H2D + dual AMS).
#
# Without this serialisation, two concurrent on_ams_change callbacks each read
# "no assignment for (printer, ams, tray)", each call auto_assign_spool, and
# the second commit hits
# IntegrityError: duplicate key value violates unique constraint
# "spool_assignment_printer_id_ams_id_tray_id_key"
# SQLite's WAL serial-write semantics had been silently swallowing the race
# until optional Postgres support landed (asyncpg allows true concurrent
# transactions and surfaces the constraint violation).
#
# Scope is intentionally narrow: only the two DB-mutating blocks (unlink +
# assign) are inside the lock. The Spoolman sync block further down stays
# concurrent because it's network-bound and idempotent.
_ams_assignment_locks: dict[int, asyncio.Lock] = {}
def _get_ams_assignment_lock(printer_id: int) -> asyncio.Lock:
"""Return the per-printer assignment lock, creating it on first use."""
lock = _ams_assignment_locks.get(printer_id)
if lock is None:
lock = asyncio.Lock()
_ams_assignment_locks[printer_id] = lock
return lock
# Per-printer dedup for unknown_tag WS broadcasts. Keyed by
# (ams_id, tray_id) -> (tag_uid, tray_uuid); we only re-broadcast when the
# tag tuple changes for the slot. Cleared when the slot is reported empty
# so remove + reinsert reliably re-prompts the UI.
_unknown_tag_last_broadcast: dict[int, dict[tuple[int, int], tuple[str, str]]] = {}
async def _broadcast_unknown_tag(
*,
printer_id: int,
ams_id: int,
tray_id: int,
tag_uid: str,
tray_uuid: str,
tray_type: str | None = None,
tray_color: str | None = None,
tray_sub_brands: str | None = None,
tray_count: int | None = None,
) -> None:
"""Broadcast unknown_tag, deduped so repeated MQTT pushes for the same slot+tag don't spam the UI."""
_logger = logging.getLogger(__name__)
slot_key = (ams_id, tray_id)
tag_key = (tag_uid or "", tray_uuid or "")
per_printer = _unknown_tag_last_broadcast.setdefault(printer_id, {})
if per_printer.get(slot_key) == tag_key:
_logger.debug(
"unknown_tag deduped for printer=%d AMS=%d slot=%d tag=%s",
printer_id,
ams_id,
tray_id,
tag_key[0][:8] or tag_key[1][:8] or "(none)",
)
return
_logger.info(
"unknown_tag broadcast: printer=%d AMS=%d slot=%d type=%r color=%r tag=%s",
printer_id,
ams_id,
tray_id,
tray_type,
tray_color,
tag_key[0][:8] or tag_key[1][:8] or "(none)",
)
# Broadcast first; only commit the dedup if the WS write succeeds.
# If broadcast raises, the next MQTT push retries instead of being
# permanently silenced by a poisoned dedup entry.
await ws_manager.broadcast(
{
"type": "unknown_tag",
"printer_id": printer_id,
"ams_id": ams_id,
"tray_id": tray_id,
"tag_uid": tag_uid,
"tray_uuid": tray_uuid,
"tray_type": tray_type,
"tray_color": tray_color,
"tray_sub_brands": tray_sub_brands,
"tray_count": tray_count,
}
)
per_printer[slot_key] = tag_key
def _clear_unknown_tag_dedup(printer_id: int, ams_id: int, tray_id: int) -> None:
"""Drop the cached last-broadcast tag for a slot (called when slot reports empty or gets matched)."""
per_printer = _unknown_tag_last_broadcast.get(printer_id)
if per_printer is None:
return
per_printer.pop((ams_id, tray_id), None)
# TTL for expected-print entries: evict registrations older than this to prevent
# unbounded growth when a print is registered but never starts (e.g. printer
# disconnect, app restart, print started from the printer panel).
_EXPECTED_PRINT_TTL_SECONDS: int = 2 * 60 * 60 # 2 hours
# Registration timestamps used for TTL eviction: {(printer_id, filename): monotonic_time}
_expected_print_registered_at: dict[tuple[int, str], float] = {}
# Cleanup loop interval
_EXPECTED_PRINT_CLEANUP_INTERVAL: int = 15 * 60 # 15 minutes
_expected_prints_cleanup_task: asyncio.Task | None = None
_ACTIVE_PRINT_STATES: set[str] = {"RUNNING", "PRINTING", "PAUSE"}
def _build_status_print_keys(printer_id: int, state: PrinterState) -> list[tuple[int, str]]:
"""Build filename keys for matching a printer status update to Bambuddy-owned jobs."""
possible_keys: list[tuple[int, str]] = []
filename = (state.gcode_file or state.current_print or "").strip()
subtask_name = (state.subtask_name or "").strip()
if subtask_name:
possible_keys.append((printer_id, subtask_name))
possible_keys.append((printer_id, f"{subtask_name}.3mf"))
possible_keys.append((printer_id, f"{subtask_name}.gcode.3mf"))
if filename:
base_name = filename.rsplit("/", 1)[-1]
if base_name.endswith(".gcode.3mf"):
root_name = base_name[: -len(".gcode.3mf")]
possible_keys.append((printer_id, root_name))
possible_keys.append((printer_id, base_name))
possible_keys.append((printer_id, f"{root_name}.gcode"))
possible_keys.append((printer_id, f"{root_name}.3mf"))
elif base_name.endswith(".3mf"):
root_name = base_name[: -len(".3mf")]
possible_keys.append((printer_id, root_name))
possible_keys.append((printer_id, base_name))
elif base_name.endswith(".gcode"):
root_name = base_name[: -len(".gcode")]
possible_keys.append((printer_id, root_name))
possible_keys.append((printer_id, f"{root_name}.3mf"))
possible_keys.append((printer_id, base_name))
else:
possible_keys.append((printer_id, base_name))
possible_keys.append((printer_id, f"{base_name}.3mf"))
return possible_keys
def _is_bambuddy_authorized_print_in_memory(printer_id: int, state: PrinterState) -> bool:
"""Check the cheap, process-local print ownership signals."""
if printer_manager.get_current_print_user(printer_id):
return True
return any(key in _expected_prints or key in _active_prints for key in _build_status_print_keys(printer_id, state))
async def _is_printer_kill_switch_enabled_cached() -> bool:
"""Return the kill-switch setting without querying on every MQTT frame."""
global _kill_switch_setting_cache
now = time.monotonic()
if _kill_switch_setting_cache is not None:
enabled, expires_at = _kill_switch_setting_cache
if now < expires_at:
return enabled
async with async_session() as db:
from backend.app.services.finance_budget import is_printer_kill_switch_enabled
enabled = await is_printer_kill_switch_enabled(db)
_kill_switch_setting_cache = (enabled, now + _KILL_SWITCH_SETTING_CACHE_TTL_SECONDS)
return enabled
async def _is_bambuddy_authorized_print(printer_id: int, state: PrinterState, db) -> bool | None:
"""Resolve whether the current print was started by Bambuddy.
``None`` means identity is not yet safe to decide. The kill switch must
defer in that case: stopping a print is irreversible, and the first status
frames after a restart may arrive before all subtask fields are populated.
"""
if _is_bambuddy_authorized_print_in_memory(printer_id, state):
return True
possible_keys = _build_status_print_keys(printer_id, state)
# In-memory ownership is lost on every Bambuddy restart, so fall back to what
# is on disk. subtask_id is minted per print and pins the answer to the job
# actually running, rather than to an unrelated one that reuses a filename.
raw_subtask_id = getattr(state, "subtask_id", None)
subtask_id = str(raw_subtask_id).strip() if raw_subtask_id is not None else ""
if subtask_id in ("", "0"):
return None
from backend.app.models.archive import PrintArchive
result = await db.execute(
select(PrintArchive)
.where(
PrintArchive.printer_id == printer_id,
PrintArchive.status == "printing",
PrintArchive.subtask_id == subtask_id,
)
.order_by(PrintArchive.created_at.desc())
.limit(1)
)
archive = result.scalar_one_or_none()
# An archive row on its own proves nothing: `on_print_start` archives every
# print it observes, including ones started from Bambu Studio or Handy, and
# stamps them with the same status and subtask_id. Authorizing on its mere
# existence would disable the kill switch the moment the 3MF finishes
# downloading. Only a dispatch marker Bambuddy writes itself counts —
# `billing_run_id` (minted per dispatch in the scheduler) or `created_by_id`
# (carried over from the queue item that started it).
if archive is not None and (archive.billing_run_id is not None or archive.created_by_id is not None):
# Rehydrate the fast in-memory path for subsequent status frames. Include
# both the archive filename and every normalized key reported by MQTT.
_active_prints[(printer_id, archive.filename)] = archive.id
for key in possible_keys:
_active_prints[key] = archive.id
return True
# No dispatch marker. Before calling this someone else's print, check whether
# Bambuddy has a job of its own running on this printer: a library-file
# dispatch has no archive at send time, and an archive created seconds later
# by `on_print_start` carries neither marker. The queue row, which the
# scheduler commits to status="printing" before the MQTT send, is the one
# durable record every Bambuddy print has. It cannot be tied to this
# subtask_id, so it is grounds to defer, never to authorize — stopping a
# print is irreversible, and refusing to act costs nothing but a log line.
from backend.app.models.print_queue import PrintQueueItem
dispatched_here = await db.scalar(
select(PrintQueueItem.id)
.where(
PrintQueueItem.printer_id == printer_id,
PrintQueueItem.status == "printing",
)
.limit(1)
)
if dispatched_here is not None:
return None
return False
async def _send_kill_switch_provider_notification(
printer_id: int,
printer_name: str,
data: dict,
) -> bool:
"""Send the immediate print-stopped provider notification.
Returning a success flag lets the normal MQTT completion path retry when
this early notification could not be delivered.
"""
logger = logging.getLogger(__name__)
try:
async with async_session() as db:
await notification_service.on_print_complete(
printer_id,
printer_name,
"stopped",
data,
db,
)
return True
except Exception as e:
logger.warning(
"[KILL SWITCH] Immediate provider notification failed for printer %s: %s",
printer_id,
e,
)
return False
async def _kill_switch_notification_already_sent(task: asyncio.Task[bool] | None) -> bool:
"""Wait for an immediate kill-switch notification, if one was scheduled."""
if task is None:
return False
try:
return await task
except Exception as e:
logging.getLogger(__name__).warning("[KILL SWITCH] Notification task failed: %s", e)
return False
async def _get_plug_energy(plug, db) -> dict | None:
"""Get energy from plug regardless of type (Tasmota, Home Assistant, MQTT, or REST).
For HA plugs, configures the service with current settings from DB.
For MQTT plugs, returns data from the subscription service.
For REST plugs, polls the status URL with JSON path extraction.
"""
if plug.plug_type == "homeassistant":
from backend.app.api.routes.settings import get_homeassistant_settings
ha_settings = await get_homeassistant_settings(db)
homeassistant_service.configure(ha_settings["ha_url"], ha_settings["ha_token"])
return await homeassistant_service.get_energy(plug)
elif plug.plug_type == "mqtt":
# MQTT plugs report "today" energy, not lifetime total
# For per-print tracking, we use "today" as the counter (resets at midnight)
mqtt_data = mqtt_relay.smart_plug_service.get_plug_data(plug.id)
if mqtt_data:
return {
"power": mqtt_data.power,
"today": mqtt_data.energy,
"total": mqtt_data.energy, # Use today as total for per-print calculations
}
return None
elif plug.plug_type == "rest":
from backend.app.services.rest_smart_plug import rest_smart_plug_service
return await rest_smart_plug_service.get_energy(plug)
else:
return await tasmota_service.get_energy(plug)
async def _record_energy_start(archive, printer_id: int, db, *, context: str = "") -> bool:
"""Capture the smart plug lifetime counter on the archive at print start.
Persists `energy_start_kwh` on the archive row (#941) so per-print energy
tracking survives a backend restart mid-print. The print-end handler reads
this value back from the DB and computes the delta against the current
plug counter.
"""
_logger = logging.getLogger(__name__)
try:
plug_result = await db.execute(select(SmartPlug).where(SmartPlug.printer_id == printer_id))
plug = plug_result.scalar_one_or_none()
if not plug:
_logger.info("[ENERGY] No smart plug for printer %s (archive %s)", printer_id, archive.id)
return False
energy = await _get_plug_energy(plug, db)
if not energy or energy.get("total") is None:
_logger.warning("[ENERGY] No 'total' in energy response for archive %s", archive.id)
return False
archive.energy_start_kwh = float(energy["total"])
await db.commit()
_logger.info(
"[ENERGY] Recorded starting energy%s for archive %s: %s kWh",
f" ({context})" if context else "",
archive.id,
energy["total"],
)
return True
except Exception as e:
_logger.warning("[ENERGY] Failed to record starting energy for archive %s: %s", archive.id, e)
return False
def register_expected_print(
printer_id: int,
filename: str,
archive_id: int,
ams_mapping: list[int] | None = None,
created_by_id: int | None = None,
cost_center_id: int | None = None,
plate_id: int | None = None,
):
"""Register an expected print from reprint/scheduled so we don't create duplicate archives."""
# Store with multiple filename variations to catch different naming patterns
_expected_prints[(printer_id, filename)] = archive_id
# Also store without .3mf extension if present
if filename.endswith(".3mf"):
base = filename[:-4]
_expected_prints[(printer_id, base)] = archive_id
_expected_prints[(printer_id, f"{base}.gcode")] = archive_id
# Store AMS mapping for usage tracking at print completion
if ams_mapping is not None:
_print_ams_mappings[archive_id] = ams_mapping
if cost_center_id is not None:
_print_cost_center_ids[archive_id] = cost_center_id
# Store plate_id for usage tracking when this is a single-plate dispatch from
# a multi-plate 3MF — without this, the direct-Print path attributes the whole
# file's filament total to the spool instead of just the printed plate (#1697).
if plate_id is not None:
_print_plate_ids[archive_id] = plate_id
# Store created_by_id so the user start email can be sent even when the archive
# itself has no created_by_id (e.g. library-file-based queue prints)
if created_by_id is not None:
_expected_print_creators[(printer_id, filename)] = created_by_id
if filename.endswith(".3mf"):
base = filename[:-4]
_expected_print_creators[(printer_id, base)] = created_by_id
_expected_print_creators[(printer_id, f"{base}.gcode")] = created_by_id
# Record registration time for TTL-based eviction
_registered_at = time.monotonic()
_expected_print_registered_at[(printer_id, filename)] = _registered_at
if filename.endswith(".3mf"):
base = filename[:-4]
_expected_print_registered_at[(printer_id, base)] = _registered_at
_expected_print_registered_at[(printer_id, f"{base}.gcode")] = _registered_at
logging.getLogger(__name__).info(
f"Registered expected print: printer={printer_id}, file={filename}, archive={archive_id}, ams_mapping={ams_mapping}, plate_id={plate_id}"
)
def unregister_expected_print(printer_id: int, filename: str, archive_id: int) -> None:
"""Undo :func:`register_expected_print` when the print never went out.
Registration has to happen *before* the MQTT print command, because the
printer can report the print before the line after the send executes. So
every path that registers and then fails to send — a cancel winning the
#1853 CAS race, a ``start_print()`` that returns False, or any exception in
between — leaves an expectation for a print that will never arrive.
The TTL sweep evicts those after two hours, which is far longer than it
takes a user to react to a failed dispatch by pressing print again: that
reprint would be folded into the *old* archive and take the stale
``ams_mapping`` / ``plate_id`` with it. Hence the explicit inverse.
Mirrors the sweep's rules, including the one that is easy to get wrong:
``_print_ams_mappings`` / ``_print_plate_ids`` are keyed by archive, not by
file, so they may only be dropped once no live key still points at that
archive.
"""
keys = [(printer_id, filename)]
if filename.endswith(".3mf"):
base = filename[:-4]
keys.append((printer_id, base))
keys.append((printer_id, f"{base}.gcode"))
removed = False
for key in keys:
if _expected_prints.pop(key, None) is not None:
removed = True
_expected_print_creators.pop(key, None)
_expected_print_registered_at.pop(key, None)
if archive_id not in set(_expected_prints.values()):
_print_ams_mappings.pop(archive_id, None)
_print_plate_ids.pop(archive_id, None)
if removed:
logging.getLogger(__name__).info(
"Unregistered expected print: printer=%s, file=%s, archive=%s (print was never sent)",
printer_id,
filename,
archive_id,
)
def _compute_run_filament_grams(
status: str,
archive_filament_used_grams: float | None,
progress: float | int | None,
usage_results: list[dict] | None,
) -> float | None:
"""Per-run filament for PrintLogEntry, partial- and tracker-aware (#1378, #1390).
Priority for every status:
1. Sum of tracked spool deltas in ``usage_results`` (AMS-measured
weight delta — same source that drives "Total Consumed" on the
Inventory page, so Stats and Inventory totals stay aligned).
2. For ``completed``: the slicer estimate (no tracker available, fall
back to the canonical "this print used X" value).
3. For partial statuses: ``estimate * progress%``.
4. ``None`` if nothing is known.
"""
tracked_grams = sum(r.get("weight_used") or 0 for r in (usage_results or []))
if tracked_grams > 0:
return round(tracked_grams, 1)
if status == "completed":
return archive_filament_used_grams
if archive_filament_used_grams:
scale = max(0.0, min(((progress or 0) / 100.0), 1.0))
if scale > 0:
return round(archive_filament_used_grams * scale, 1)
return None
def _get_start_ams_mapping(data: dict, archive_id: int | None) -> list[int] | None:
"""Resolve AMS mapping for print start without consuming stored queue/reprint state."""
stored_ams_mapping = data.get("ams_mapping")
if not stored_ams_mapping and archive_id:
stored_ams_mapping = _print_ams_mappings.get(archive_id)
return stored_ams_mapping
def _get_start_plate_id(archive_id: int | None) -> int | None:
"""Resolve plate_id for print start without consuming stored direct-Print state.
Direct-Print of a single plate from a multi-plate 3MF registers plate_id in
``_print_plate_ids`` at dispatch time; this lets the spoolman / usage tracker
read it back at print-start without popping (the entry is popped on print
completion or TTL eviction, mirroring ``_print_ams_mappings``).
"""
if archive_id is None:
return None
return _print_plate_ids.get(archive_id)
def _partial_progress_scale(progress: int | float | None) -> float:
"""Clamp ``progress / 100`` into [0.0, 1.0] for partial-print scaling.
Used by every site that multiplies a "would-have-used" slicer estimate
down to "actually-used" for failed / cancelled / stopped prints. Centralised
so the three sites in ``_background_notifications`` (and the per-plate
override helper) can't drift apart on the coercion shape.
"""
return max(0.0, min((progress or 0) / 100.0, 1.0))
def _scope_notification_archive_data_to_plate(
archive_data: dict,
archive_file_path: str | None,
plate_id: int | None,
print_status: str,
progress: int | float | None,
base_dir: Path,
) -> dict:
"""Override summed-across-plates totals in ``archive_data`` with the values
for ``plate_id`` so the completion notification reports what was actually
printed, not the whole project (#1785).
The 3MF parser at services/archive.py:200-264 sums ``prediction`` and
``weight`` across every plate of a multi-plate file (#1593) — correct for
the archive card's "whole project" headline, wrong for the completion
notification of a single-plate print. The queue UI already re-reads the
3MF per-plate at print_queue.py:272-285; this helper mirrors that for the
notification payload (filament grams, time estimate, per-slot breakdown).
No-ops when ``plate_id`` is None, the file is missing, or the 3MF carries
no per-plate values — in every fail case the original ``archive_data`` is
returned unchanged so the notification still sends.
"""
if plate_id is None or not archive_file_path:
return archive_data
from backend.app.utils.threemf_tools import (
extract_filament_usage_from_3mf,
extract_print_time_from_3mf,
)
archive_path = base_dir / archive_file_path
if not archive_path.exists():
return archive_data
plate_slots = extract_filament_usage_from_3mf(archive_path, plate_id)
plate_grams = sum(f.get("used_g", 0) for f in plate_slots)
plate_time = extract_print_time_from_3mf(archive_path, plate_id)
scale = 1.0 if print_status == "completed" else _partial_progress_scale(progress)
if plate_time:
archive_data["print_time_seconds"] = plate_time
# Gate both the grams headline AND the per-slot breakdown on the same
# `plate_grams > 0` signal: if the 3MF carries per-plate filament rows but
# they all sum to zero (slicer bug / re-slice without estimate), drop back
# to the project-level grams the archive columns already provide rather
# than ship a project-level headline next to an all-zero per-plate
# breakdown.
if plate_grams > 0:
archive_data["actual_filament_grams"] = round(plate_grams * scale, 1)
archive_data["filament_slots"] = [
{
"slot_id": s.get("slot_id"),
"used_g": round((s.get("used_g") or 0) * scale, 1),
"type": s.get("type", ""),
"color": s.get("color", ""),
}
for s in plate_slots
]
return archive_data
def _extract_filament_data_from_mqtt(data: dict, ams_mapping: list[int] | None = None) -> dict[str, str]:
"""Best-effort filament metadata from the MQTT print-start snapshot.
Used when the 3MF can't be downloaded (P1S/A1/P2S firmwares lock the
file during print, see #1533) so the fallback PrintArchive still has
enough filament info to support the inventory views and AMS-expansion
planning the operator opens it for. Returns a dict with optional
``filament_type`` and ``filament_color`` keys in the same
comma-separated format the 3MF extractor produces, so the rest of the
codebase treats the fallback archive identically to a normal one.
``ams_mapping`` is the slicer's slot-per-print-filament list captured
from the MQTT print payload (global tray IDs, possibly -1 for VT-tray
entries). When supplied, only the slots actually consumed by this
print contribute. Without it the function falls back to every loaded
AMS slot — less accurate but still useful.
Accepts both the raw inner payload (``{"ams": {"ams": [...]}, ...}``)
that the unit tests pass directly, AND the on_print_start callback
shape (``{"raw_data": {"ams": {"ams": [...]}, ...}, ...}``) the
bambu_mqtt service hands to main.py at runtime. The original
``_extract_filament_data_from_mqtt(data)`` shipped in #1533 only
handled the inner shape and silently returned ``{}`` for every real
print start, leaving fallback archives' filament fields NULL — the
exact regression the fix was meant to close. Reported with a log
proving the AMS state was right there at
``data["raw_data"]["ams"]["ams"][0]["tray"][0]`` (#1533 follow-up).
"""
result: dict[str, str] = {}
# Look at the on_print_start wrapper first, then the inner shape.
raw_data = (data or {}).get("raw_data")
ams_root = (raw_data or {}).get("ams") if isinstance(raw_data, dict) else None
if not isinstance(ams_root, dict):
ams_root = (data or {}).get("ams") or {}
ams_units = ams_root.get("ams") if isinstance(ams_root, dict) else None
if not isinstance(ams_units, list) or not ams_units:
return result
# Map global tray id (unit * 4 + tray) → (type, color).
loaded: dict[int, tuple[str, str]] = {}
for unit in ams_units:
if not isinstance(unit, dict):
continue
try:
unit_id = int(unit.get("id", 0))
except (TypeError, ValueError):
continue
for tray in unit.get("tray") or []:
if not isinstance(tray, dict):
continue
try:
tray_id = int(tray.get("id", 0))
except (TypeError, ValueError):
continue
ttype = (tray.get("tray_type") or "").strip()
tcolor = (tray.get("tray_color") or "").strip().upper()
if not ttype:
continue # Empty / unloaded slot.
loaded[unit_id * 4 + tray_id] = (ttype, tcolor)
if not loaded:
return result
if ams_mapping:
used_ids = [int(x) for x in ams_mapping if isinstance(x, (int, float)) and int(x) >= 0]
filaments = [loaded[g] for g in used_ids if g in loaded]
if not filaments:
return result # Mapping points entirely at slots we have no data for.
else:
filaments = [loaded[g] for g in sorted(loaded.keys())]
types_joined = ",".join(f[0] for f in filaments)
colors_joined = ",".join(f[1] for f in filaments if f[1])
# Column limits per backend/app/models/archive.py: filament_type=50,
# filament_color=200.
if types_joined:
result["filament_type"] = types_joined[:50]
if colors_joined:
result["filament_color"] = colors_joined[:200]
return result
def _maybe_start_layer_timelapse(printer, printer_id: int, archive_id: int) -> bool:
"""Start a layer-timelapse session for *archive_id* when the printer has
an external camera configured. Returns True if a session was started.
Three call sites in on_print_start (expected-archive promotion, fallback
archive creation, fresh-archive creation) used to inline this same
if-block; the inline copies kept drifting (#1353 fixed only one of them
on the first pass). Centralising the conditional + call here makes the
contract testable in isolation and keeps the three sites locked in step.
"""
if not (printer.external_camera_enabled and printer.external_camera_url):
return False
from backend.app.services.layer_timelapse import start_session
start_session(
printer_id,
archive_id,
printer.external_camera_url,
printer.external_camera_type or "mjpeg",
snapshot_url=printer.external_camera_snapshot_url,
rotation=getattr(printer, "camera_rotation", 0),
)
logging.getLogger(__name__).info("Started layer timelapse for printer %s, archive %s", printer_id, archive_id)
return True
def _format_hms_error_summary(hms_errors: list[dict]) -> str | None:
"""Build a human-readable failure reason from MQTT hms_errors for PrintQueueItem.error_message.
Each entry has keys: code ('0x4038'), attr (32-bit int), module, severity.
The short code used for the hms_errors.py lookup table is 'MMMM_EEEE' — module
from attr bits 16-31, error from the numeric part of code. Falls back to the raw
short code when no description is on file. Returns None for an empty list so
callers can leave error_message unset.
"""
if not hms_errors:
return None
from backend.app.services.hms_errors import get_error_description
parts: list[str] = []
for err in hms_errors:
try:
code_str = str(err.get("code", "")).replace("0x", "")
error_num = int(code_str, 16) if code_str else 0
module_num = (int(err.get("attr", 0)) >> 16) & 0xFFFF
short_code = f"{module_num:04X}_{error_num:04X}"
except (TypeError, ValueError):
continue
description = get_error_description(short_code)
parts.append(f"[{short_code}] {description}" if description else f"[{short_code}]")
return "; ".join(parts) if parts else None
async def _bump_library_file_usage_if_completed(db, item, queue_status: str) -> None:
"""Increment LibraryFile.print_count and stamp last_printed_at when a queued
print completes successfully. Gated to status=='completed': failed, cancelled
and aborted prints do not count as usage. Caller is responsible for committing
the session. No-op when the queue item has no linked library file (e.g. reprints
from an archive). See #1008."""
if queue_status != "completed" or item.library_file_id is None:
return
from backend.app.models.library import LibraryFile
lib_file = await db.scalar(select(LibraryFile).where(LibraryFile.id == item.library_file_id))
if lib_file is None:
return
lib_file.print_count = (lib_file.print_count or 0) + 1
lib_file.last_printed_at = datetime.now(timezone.utc)
def mark_printer_stopped_by_user(printer_id: int) -> None:
"""Mark that the active print on this printer was stopped by the user from the queue UI.
When on_print_complete fires with status 'failed' for a printer in this set we
reclassify it as 'cancelled' so the correct 'print stopped' notification is sent
rather than a 'print failed' notification.
"""
_user_stopped_printers.add(printer_id)
logging.getLogger(__name__).info("Marked printer %s as user-stopped from queue", printer_id)
_last_status_broadcast: dict[int, str] = {}
# Track printers where we've updated nozzle_count
_nozzle_count_updated: set[int] = set()
async def _maybe_notify_printer_offline(printer_id: int) -> None:
"""Wait the debounce window then fire `on_printer_offline` if the printer
is still offline.
Scheduled by `on_printer_status_change` on the connected → disconnected
edge (#1752). Cancelled by the same handler if the printer reconnects
before the window elapses, so a single MQTT blip + recovery doesn't
notify. Both the staleness-detector path (`bambu_mqtt.py::check_staleness`)
and the smart-plug power-off path (`printer_manager.mark_printer_offline`)
route through the same status-change callback, so this covers both.
"""
logger = logging.getLogger(__name__)
try:
await asyncio.sleep(_PRINTER_OFFLINE_NOTIFY_DEBOUNCE_SECONDS)
still_offline = not printer_manager.is_connected(printer_id)
logger.info(
"[#1752] Printer %s offline debounce elapsed: still_offline=%s",
printer_id,
still_offline,
)
if not still_offline:
return
async with async_session() as db:
from backend.app.models.printer import Printer
result = await db.execute(select(Printer).where(Printer.id == printer_id))
printer = result.scalar_one_or_none()
if not printer:
logger.warning(
"[#1752] Printer %s missing from DB at offline-notify time; skipping",
printer_id,
)
return
logger.info(
"[#1752] Dispatching on_printer_offline for printer %s (%s)",
printer_id,
printer.name,
)
await notification_service.on_printer_offline(printer_id, printer.name, db)
except asyncio.CancelledError:
raise
except Exception as e:
logger.warning("Printer offline notification failed for printer %s: %s", printer_id, e)
finally:
_printer_offline_notify_tasks.pop(printer_id, None)
async def on_printer_status_change(printer_id: int, state: PrinterState):
"""Handle printer status changes - broadcast via WebSocket."""
# Connected-edge reconciliation (#1542 follow-up). When the printer
# transitions disconnected → connected — which covers both Bambuddy
# startup (no prior connection) and a mid-session MQTT reconnect — fire
# `reconcile_stale_active_prints` exactly once for this connection so
# any archive still in `status="printing"` that can't actually be
# running anymore (printer IDLE / different subtask / empty subtask)
# gets a synthesised PRINT COMPLETE. Without this, a print that
# finished during a disconnect window + a smart-plug power cycle
# leaves the .3mf on the SD card and the firmware ghost-replays it on
# next boot. Reconciliation runs concurrently — it must not block the
# WebSocket dedup / broadcast logic below, and the connected edge is
# marked True BEFORE the await so concurrent status updates inside
# the same connection don't re-trigger reconciliation.
#
# Wait for a real push_status before reconciling (#1679): MQTT
# `_on_connect` broadcasts `state` IMMEDIATELY after the broker accepts
# the connection, BEFORE `_request_push_all` round-trips. At that
# instant the `PrinterState` is still on construction defaults — most
# importantly `state.state == "unknown"` and `state.subtask_name == ""`.
# If reconcile spawns here, every in-flight archive falls through to
# the empty-subtask_name trigger and gets synthesised `aborted`, which
# creates a duplicate archive on the real PRINT COMPLETE and
# double-counts filament. Gating on `state.state ∉ ("", "unknown")`
# keeps the #1542 mechanism intact: once the first real push_status
# updates `state.state` (RUNNING / IDLE / FINISH / …), this handler
# fires again with the flag still False — reconcile then runs against
# actual evidence.
state_known = bool(state.state) and state.state.upper() not in ("", "UNKNOWN")
if state.connected and state_known and not _printer_reconciled_since_connect.get(printer_id, False):
_printer_reconciled_since_connect[printer_id] = True
spawn_background_task(
reconcile_stale_active_prints(printer_id),
name=f"reconcile-stale-prints-{printer_id}",
)
elif not state.connected and _printer_reconciled_since_connect.get(printer_id, False):
# Re-arm so the next reconnect triggers reconciliation again.
_printer_reconciled_since_connect[printer_id] = False
# Offline-notification edge (#1752): schedule `on_printer_offline` on
# connected → disconnected. The "back online" channel is already covered
# by the print-failure notification (firmware reports gcode_state=FAILED
# on reconnect of an interrupted print), so we don't add a symmetric
# online event here.
prev_connected = _printer_last_connected.get(printer_id)
_printer_last_connected[printer_id] = state.connected
if prev_connected is True and not state.connected:
existing = _printer_offline_notify_tasks.get(printer_id)
if existing is None or existing.done():
logging.getLogger(__name__).info(
"[#1752] Printer %s connected→disconnected edge; scheduling offline notification in %.0fs",
printer_id,
_PRINTER_OFFLINE_NOTIFY_DEBOUNCE_SECONDS,
)
_printer_offline_notify_tasks[printer_id] = asyncio.create_task(
_maybe_notify_printer_offline(printer_id),
name=f"printer-offline-notify-{printer_id}",
)
elif state.connected:
pending = _printer_offline_notify_tasks.pop(printer_id, None)
if pending is not None and not pending.done():
logging.getLogger(__name__).info(
"[#1752] Printer %s reconnected before debounce; cancelling pending offline notification",
printer_id,
)
pending.cancel()
# Only broadcast if something meaningful changed (reduce WebSocket spam)
# Include rounded temperatures to detect meaningful temp changes (within 1 degree)
temps = state.temperatures or {}
nozzle_temp = round(temps.get("nozzle", 0))
bed_temp = round(temps.get("bed", 0))
nozzle_2_temp = round(temps.get("nozzle_2", 0)) if "nozzle_2" in temps else ""
chamber_temp = round(temps.get("chamber", 0)) if "chamber" in temps else ""
# Auto-detect dual-nozzle printers from MQTT temperature data
if "nozzle_2" in temps and printer_id not in _nozzle_count_updated:
_nozzle_count_updated.add(printer_id)
# Update nozzle_count in database
async with async_session() as db:
from backend.app.models.printer import Printer
result = await db.execute(select(Printer).where(Printer.id == printer_id))
printer = result.scalar_one_or_none()
if printer and printer.nozzle_count != 2:
printer.nozzle_count = 2
await db.commit()
logging.getLogger(__name__).info(
f"Auto-detected dual-nozzle printer {printer_id}, updated nozzle_count=2"
)
# Include target temps for heating phase detection
bed_target = round(temps.get("bed_target", 0))
nozzle_target = round(temps.get("nozzle_target", 0))
# Include tray_now and vt_tray hash so external spool changes trigger broadcasts
vt_tray_key = hash(str(state.raw_data.get("vt_tray", []))) if state.raw_data else 0
# Include AMS dry_time and tray state values so drying/slot changes trigger broadcasts
ams_dry_key = tuple(a.get("dry_time", 0) for a in (state.raw_data.get("ams") or [])) if state.raw_data else ()
# Include tray states so load/unload transitions (state 11→10) trigger broadcasts (#784)
#
# The filament identity fields are here because Configure Slot writes
# exactly those and nothing else. Re-configuring a slot from PLA to another
# brand or colour of PLA leaves id/tray_type/state identical, so the key
# matched, this function returned before broadcasting, and the card kept
# showing the old filament until the 30s fallback poll or a page reload —
# even though the configure route asks the printer for a fresh pushall and
# that push does carry the new values. Reset always worked, because it
# clears tray_type.
#
# These fields only change when someone configures a slot or swaps a spool,
# so unlike temperature or progress they add no broadcast traffic mid-print.
ams_tray_key = (
tuple(
(
t.get("id"),
t.get("tray_type", ""),
t.get("state"),
t.get("tray_color", ""),
t.get("tray_info_idx", ""),
t.get("tray_sub_brands", ""),
t.get("cali_idx"),
)
for a in (state.raw_data.get("ams") or [])
for t in a.get("tray", [])
)
if state.raw_data
else ()
)
status_key = (
f"{state.connected}:{state.state}:{state.progress}:{state.layer_num}:"
f"{nozzle_temp}:{bed_temp}:{nozzle_2_temp}:{chamber_temp}:"
f"{state.stg_cur}:{bed_target}:{nozzle_target}:"
f"{state.cooling_fan_speed}:{state.big_fan1_speed}:{state.big_fan2_speed}:"
f"{state.chamber_light}:{state.active_extruder}:{state.tray_now}:{vt_tray_key}:"
f"{ams_dry_key}:{ams_tray_key}:{state.door_open}:{state.ams_filament_backup}"
)
is_active_print = state.state in _ACTIVE_PRINT_STATES
if not is_active_print:
_unauthorized_print_kill_sent.discard(printer_id)
elif printer_id in _unauthorized_print_kill_sent:
# stop_print() was already sent for this print; avoid all further
# ownership and settings work until the printer leaves an active state.
pass
elif _is_bambuddy_authorized_print_in_memory(printer_id, state):
# Normal Bambuddy-started prints stay entirely on the in-memory path.
_unauthorized_print_kill_sent.discard(printer_id)
else:
kill_switch_enabled = False
authorization: bool | None = None
status_logger = logging.getLogger(__name__)
try:
kill_switch_enabled = await _is_printer_kill_switch_enabled_cached()
if kill_switch_enabled:
async with async_session() as db:
authorization = await _is_bambuddy_authorized_print(printer_id, state, db)
except Exception as e:
# Fail safe: a database/reconciliation error must never turn into an
# irreversible stop of a print whose ownership is still unknown.
authorization = None
status_logger.warning(
"[KILL SWITCH] Failed to reconcile print authorization for printer %s: %s", printer_id, e
)
if not kill_switch_enabled or authorization is True:
_unauthorized_print_kill_sent.discard(printer_id)
elif authorization is None:
_unauthorized_print_kill_sent.discard(printer_id)
status_logger.debug(
"[KILL SWITCH] Deferring authorization for printer %s until archive state is reconciled",
printer_id,
)
else:
try:
stopped = printer_manager.stop_print(printer_id)
if stopped:
_unauthorized_print_kill_sent.add(printer_id)
printer_info = printer_manager.get_printer(printer_id)
printer_name = printer_info.name if printer_info else f"Printer {printer_id}"
filename = state.subtask_name or state.gcode_file or state.current_print or "Unknown"
notification_data = {
"status": "stopped",
"filename": state.gcode_file or state.current_print or "",
"subtask_name": state.subtask_name or "",
"progress": state.progress,
"reason": "unauthorized_print",
}
status_logger.warning(
"[KILL SWITCH] Stopped unauthorized print on printer %s (state=%s)",
printer_id,
state.state,
)
try:
await ws_manager.broadcast(
{
"type": "kill_switch_triggered",
"printer_id": printer_id,
"printer_name": printer_name,
"filename": filename,
"reason": "unauthorized_print",
}
)
except Exception as e:
status_logger.warning(
"[KILL SWITCH] WebSocket notification failed for printer %s: %s", printer_id, e
)
previous_task = _kill_switch_notification_tasks.pop(printer_id, None)
if previous_task is not None and not previous_task.done():
previous_task.cancel()
_kill_switch_notification_tasks[printer_id] = spawn_background_task(
_send_kill_switch_provider_notification(printer_id, printer_name, notification_data),
name=f"kill-switch-notification-{printer_id}",
)
else:
status_logger.warning(
"[KILL SWITCH] Could not stop unauthorized print on printer %s (state=%s)",
printer_id,
state.state,
)
except Exception as e:
status_logger.warning(
"[KILL SWITCH] Failed to stop unauthorized print on printer %s: %s", printer_id, e
)
# MQTT relay - publish status (before dedup check - always publish to MQTT)
try:
printer_info = printer_manager.get_printer(printer_id)
if printer_info:
await mqtt_relay.on_printer_status(
printer_id,
state,
printer_info.name,
printer_info.serial_number,
printer_manager.is_awaiting_plate_clear(printer_id),
)
except Exception:
pass # Don't fail status callback if MQTT fails
if _last_status_broadcast.get(printer_id) == status_key:
return # No change, skip WebSocket broadcast
_last_status_broadcast[printer_id] = status_key
# Check for progress milestone notifications (25%, 50%, 75%)
progress = state.progress or 0
is_printing = state.state in ("RUNNING", "PRINTING")
if is_printing and progress > 0:
# Determine which milestone we've reached
current_milestone = 0
if progress >= 75:
current_milestone = 75
elif progress >= 50:
current_milestone = 50
elif progress >= 25:
current_milestone = 25
last_milestone = _last_progress_milestone.get(printer_id, 0)
# If we've crossed a new milestone, send notification
if current_milestone > last_milestone:
_last_progress_milestone[printer_id] = current_milestone
try:
from backend.app.models.printer import Printer
# Read the printer in a short session and release the connection
# BEFORE the ~15s camera snapshot below — holding it across the grab
# pinned a pooled connection per milestone, per printer (issue #2572).
async with async_session() as db:
result = await db.execute(select(Printer).where(Printer.id == printer_id))
printer = result.scalar_one_or_none()
printer_name = printer.name if printer else f"Printer {printer_id}"
filename = state.subtask_name or state.gcode_file or "Unknown"
# remaining_time is in minutes, convert to seconds for notification
remaining_time_seconds = state.remaining_time * 60 if state.remaining_time else None
# Capture camera snapshot for notification image attachment (no DB held).
image_data = await _capture_snapshot_for_notification(printer_id, printer, logging.getLogger(__name__))
# Notification send needs a session (provider/template lookups).
async with async_session() as db:
await notification_service.on_print_progress(
printer_id,
printer_name,
filename,
current_milestone,
db,
remaining_time_seconds,
image_data=image_data,
)
except Exception as e:
logging.getLogger(__name__).warning(f"Progress milestone notification failed: {e}")
elif progress < 5:
# Reset milestone tracking when print restarts or new print begins
_last_progress_milestone[printer_id] = 0
_first_layer_notified[printer_id] = False
# HMS error codes that should not trigger notifications even though they
# have known descriptions (e.g. user-initiated actions, not real errors).
_HMS_NOTIFICATION_SUPPRESS = {
"0500_400E", # Printing was cancelled (user action, not an error)
}
# Check for new HMS errors and send notifications
current_hms_errors = getattr(state, "hms_errors", []) or []
if current_hms_errors:
# Build set of current error codes (using attr for uniqueness)
current_error_codes = {f"{e.attr:08x}" for e in current_hms_errors}
previously_notified = _notified_hms_errors.get(printer_id, set())
# Find new errors that haven't been notified yet
new_error_codes = current_error_codes - previously_notified
# Update tracking immediately to prevent duplicate notifications from concurrent callbacks
_notified_hms_errors[printer_id] = current_error_codes
_hms_last_seen[printer_id] = time.time()
if new_error_codes:
# Get the actual new errors for the notification
# Filter to severity >= 2 (skip informational/status messages like H2D sends)
new_errors = [e for e in current_hms_errors if f"{e.attr:08x}" in new_error_codes and e.severity >= 2]
try:
from backend.app.models.printer import Printer
# Read the printer in a short session and release the connection
# BEFORE the ~15s camera snapshot below (issue #2572).
async with async_session() as db:
result = await db.execute(select(Printer).where(Printer.id == printer_id))
printer = result.scalar_one_or_none()
printer_name = printer.name if printer else f"Printer {printer_id}"
# Format error details for notification
# Module 0x07 = AMS/Filament, 0x05 = Nozzle, 0x0C = Motion Controller, etc.
module_names = {
0x03: "Print/Task",
0x05: "Nozzle/Extruder",
0x07: "AMS/Filament",
0x0C: "Motion Controller",
0x12: "Chamber",
}
from backend.app.services.hms_errors import get_error_description
# Capture camera snapshot once for all error notifications (no DB held).
error_image_data = await _capture_snapshot_for_notification(
printer_id, printer, logging.getLogger(__name__)
)
# Notification sends need a session (provider/template lookups).
async with async_session() as db:
sent_count = 0
for error in new_errors:
module_name = module_names.get(error.module, f"Module 0x{error.module:02X}")
# Build short code like "0700_8010"
# Mask to 16 bits to handle printers that send larger values
error_code_int = int(error.code.replace("0x", ""), 16) if error.code else 0
error_code_masked = error_code_int & 0xFFFF
short_code = f"{(error.attr >> 16) & 0xFFFF:04X}_{error_code_masked:04X}"
# Only notify for errors with known descriptions — printers
# send many undocumented/phantom codes that aren't real errors.
description = get_error_description(short_code)
if not description or short_code in _HMS_NOTIFICATION_SUPPRESS:
continue
error_type = f"{module_name} Error"
error_detail = description
await notification_service.on_printer_error(
printer_id, printer_name, error_type, db, error_detail, image_data=error_image_data
)
sent_count += 1
if sent_count:
logging.getLogger(__name__).info(
f"[HMS] Sent notification for {sent_count} error(s) on printer {printer_id}"
)
# Also publish to MQTT relay (no DB).
printer_info = printer_manager.get_printer(printer_id)
if printer_info:
errors_data = [
{
"code": e.code,
"attr": e.attr,
"module": e.module,
"severity": e.severity,
}
for e in new_errors
]
await mqtt_relay.on_printer_error(
printer_id, printer_info.name, printer_info.serial_number, errors_data
)
except Exception as e:
logging.getLogger(__name__).warning(f"HMS error notification failed: {e}")
else:
# No HMS errors — only clear tracking after a grace period to prevent
# flapping errors (brief hms:[] gaps) from re-triggering notifications.
# Some HMS codes (e.g. chamber temp regulation during PETG prints) toggle
# on/off every few seconds as conditions fluctuate around thresholds.
if printer_id in _notified_hms_errors:
last_seen = _hms_last_seen.get(printer_id, 0)
if time.time() - last_seen >= _HMS_CLEAR_GRACE_SECONDS:
_notified_hms_errors.pop(printer_id, None)
_hms_last_seen.pop(printer_id, None)
await ws_manager.send_printer_status(
printer_id,
printer_state_to_dict(
state,
printer_id,
printer_manager.get_model(printer_id),
printer_manager.get_drying_targets(printer_id),
),
)
def _is_bambu_uuid(tray_uuid: str) -> bool:
"""Check if a tray UUID looks like a valid Bambu Lab RFID UUID (non-empty, non-zero)."""
return bool(tray_uuid) and tray_uuid not in ("", "0" * len(tray_uuid))
async def on_ams_change(printer_id: int, ams_data: list):
"""Handle AMS data changes - sync to Spoolman if enabled and auto mode."""
logger = logging.getLogger(__name__)
# Snapshot BEFORE any await: if a print is active, skip weight sync later.
# on_print_complete may pop _active_sessions during our awaits (#880).
from backend.app.services.usage_tracker import _active_sessions
_print_active = printer_id in _active_sessions
# A slot that reports empty while a print is running is a filament runout,
# not a spool swap: the spool is still physically in the AMS, just
# consumed. Dropping either inventory backend's slot link there loses the
# only record of which spool fed the print, so the completion path can't
# charge the runout segment to anything. Both cleanup passes below consult
# this; computed once, up front, so neither depends on the other having run.
_unlink_state = printer_manager.get_status(printer_id)
printing_now = (getattr(_unlink_state, "state", "") or "").upper() in ("RUNNING", "PAUSE")
# MQTT relay - publish AMS change
try:
printer_info = printer_manager.get_printer(printer_id)
if printer_info:
await mqtt_relay.on_ams_change(printer_id, printer_info.name, printer_info.serial_number, ams_data)
except Exception:
pass # Don't fail AMS callback if MQTT fails
# Broadcast AMS change via WebSocket (bypasses status_key deduplication)
# This ensures frontend gets immediate updates when AMS slots are configured
try:
state = printer_manager.get_status(printer_id)
if state:
logger.info("[Printer %s] Broadcasting AMS change via WebSocket", printer_id)
await ws_manager.send_printer_status(
printer_id,
printer_state_to_dict(
state,
printer_id,
printer_manager.get_model(printer_id),
printer_manager.get_drying_targets(printer_id),
),
)
except Exception as e:
logger.warning("Failed to broadcast AMS change for printer %s: %s", printer_id, e)
from backend.app.utils.color_utils import colors_similar as _colors_similar
# Auto-unlink spool assignments with stale fingerprints
try:
async with async_session() as db:
from sqlalchemy.orm import selectinload
from backend.app.api.routes.inventory import _find_tray_in_ams_data
from backend.app.models.spool import Spool as _Spool
from backend.app.models.spool_assignment import SpoolAssignment as SA
result = await db.execute(
select(SA)
.where(SA.printer_id == printer_id)
.options(selectinload(SA.spool).selectinload(_Spool.k_profiles))
)
# ``printing_now`` (top of this function) keeps a runout from
# unlinking the spool that fed the print — the next idle-time pass
# unlinks it if the user really did take it out.
stale = []
for assignment in result.scalars().all():
# External spool assignments (ams_id=255) live in vt_tray, not AMS data
if assignment.ams_id == 255:
ps = printer_manager.get_status(printer_id)
vt_tray_raw = ps.raw_data.get("vt_tray", []) if ps else []
ext_id = assignment.tray_id + 254 # 0→254, 1→255
current_tray = None
for vt in vt_tray_raw:
if isinstance(vt, dict) and int(vt.get("id", 254)) == ext_id:
current_tray = vt
break
if not current_tray:
# vt_tray data may not have arrived yet — keep assignment
continue
else:
current_tray = _find_tray_in_ams_data(ams_data, assignment.ams_id, assignment.tray_id)
if not current_tray:
if printing_now:
logger.info(
"Auto-unlink skipped: spool %d AMS%d-T%d — slot empty during a running print (runout?)",
assignment.spool_id,
assignment.ams_id,
assignment.tray_id,
)
continue
logger.info(
"Auto-unlink: spool %d AMS%d-T%d — tray not found in AMS data (slot empty?)",
assignment.spool_id,
assignment.ams_id,
assignment.tray_id,
)
stale.append(assignment) # Slot empty
elif _is_bambu_uuid(current_tray.get("tray_uuid", "")):
# A Bambu Lab spool is in this slot — check if it's the same spool
# that's currently assigned. If yes, keep the assignment (avoids
# unnecessary unlink/re-assign/ams_filament_setting cycle that clears
# the printer's filament preset on every startup).
tray_uuid = current_tray.get("tray_uuid", "")
tag_uid = current_tray.get("tag_uid", "")
spool = assignment.spool
spool_matches = False
if spool:
if (spool.tray_uuid and spool.tray_uuid.upper() == tray_uuid.upper()) or (
spool.tag_uid
and tag_uid
and tag_uid != "0000000000000000"
and spool.tag_uid.upper() == tag_uid.upper()
):
spool_matches = True
if spool_matches:
# Same BL spool still in slot — keep assignment, update fingerprint if needed
cur_color = current_tray.get("tray_color", "")
cur_type = current_tray.get("tray_type", "")
fp_color = assignment.fingerprint_color or ""
fp_type = assignment.fingerprint_type or ""
if cur_color.upper() != fp_color.upper() or cur_type.upper() != fp_type.upper():
assignment.fingerprint_color = cur_color
assignment.fingerprint_type = cur_type
logger.debug(
"Auto-unlink: spool %d AMS%d-T%d — same BL spool, updated fingerprint",
assignment.spool_id,
assignment.ams_id,
assignment.tray_id,
)
continue
# Different BL spool or unrecognized — unlink so auto-assign can match
logger.info(
"Auto-unlink: spool %d AMS%d-T%d — different Bambu Lab spool detected (uuid=%s)",
assignment.spool_id,
assignment.ams_id,
assignment.tray_id,
tray_uuid,
)
stale.append(assignment)
else:
cur_color = current_tray.get("tray_color", "")
cur_type = current_tray.get("tray_type", "")
cur_state = current_tray.get("state")
fp_color = assignment.fingerprint_color or ""
fp_type = assignment.fingerprint_type or ""
# SpoolBuddy pre-config replay: fingerprint_type empty means
# the slot was empty when the user pre-assigned via SpoolBuddy
# (the firmware drops ams_filament_setting on empty slots, so
# MQTT was deferred). The moment any filament gets inserted
# — Bambu RFID, 3rd-party, or even an existing-but-now-
# reconfigured spool — fire the deferred configuration.
# The "loaded" signal is state == 11 (Bambu's "filament fed to
# extruder" code) OR, on firmwares that don't use the state
# enum meaningfully, a non-empty tray_type when state is
# NOT one of the firmware's explicit empty signals (9, 10).
# state-only was wrong for firmwares that never set 11 — A1
# Mini BMCU 01.07.02.00 and P1S Standard AMS 00.00.06.75 both
# always report state=3 — so the replay never fired for them
# (#1322). The state ∉ {9,10} guard keeps the firmware's
# explicit "empty" signals authoritative over any stale
# tray_type that might survive the relay's auto-clearing.
loaded = cur_state == 11 or (cur_state not in (9, 10) and cur_type.strip())
if not fp_type.strip() and loaded and assignment.spool:
try:
from backend.app.api.routes.inventory import (
apply_spool_to_slot_via_mqtt,
)
await apply_spool_to_slot_via_mqtt(
db=db,
current_user=None,
spool=assignment.spool,
printer_id=printer_id,
ams_id=assignment.ams_id,
tray_id=assignment.tray_id,
current_tray_info_idx=current_tray.get("tray_info_idx", ""),
current_tray_type=cur_type,
)
logger.info(
"SpoolBuddy pre-config applied on insert: spool %d → printer %d AMS%d-T%d",
assignment.spool_id,
printer_id,
assignment.ams_id,
assignment.tray_id,
)
except Exception:
logger.exception(
"Pre-config apply failed for spool %d on printer %d AMS%d-T%d",
assignment.spool_id,
printer_id,
assignment.ams_id,
assignment.tray_id,
)
assignment.fingerprint_color = cur_color
assignment.fingerprint_type = cur_type
continue
if not _colors_similar(cur_color, fp_color) or cur_type.upper() != fp_type.upper():
# Blank tray data mid-print is a runout, not a swap: the
# firmware clears colour and type when it unloads a spool
# it just emptied. Unlinking here would erase the record
# of which spool fed the print so far.
if printing_now and not cur_color.strip() and not cur_type.strip():
logger.info(
"Auto-unlink skipped: spool %d AMS%d-T%d — tray data cleared during a running print "
"(runout?)",
assignment.spool_id,
assignment.ams_id,
assignment.tray_id,
)
continue
# Fingerprint mismatch — but check if tray now matches the
# assigned spool (e.g. auto-configure changed the tray).
spool = assignment.spool
if spool:
spool_color = (spool.rgba or "FFFFFFFF").upper()
spool_type = (spool.material or "").upper()
if _colors_similar(cur_color, spool_color) and cur_type.upper() == spool_type:
logger.info(
"Auto-unlink: spool %d AMS%d-T%d — fingerprint mismatch but tray matches spool, updating fp",
assignment.spool_id,
assignment.ams_id,
assignment.tray_id,
)
assignment.fingerprint_color = cur_color
assignment.fingerprint_type = cur_type
continue
logger.info(
"Auto-unlink: spool %d AMS%d-T%d — fingerprint mismatch (cur=%s/%s fp=%s/%s spool=%s/%s)",
assignment.spool_id,
assignment.ams_id,
assignment.tray_id,
cur_color,
cur_type,
fp_color,
fp_type,
spool.rgba if spool else "?",
spool.material if spool else "?",
)
stale.append(assignment) # Spool changed
# Snapshot slots before delete — ORM attribute access after the
# commit would refresh against a deleted row.
unlinked_slots = [(a.ams_id, a.tray_id) for a in stale]
for a in stale:
await db.delete(a)
if stale:
logger.info("Auto-unlinked %d stale spool assignments for printer %d", len(stale), printer_id)
# Commit any changes (stale deletions and/or fingerprint updates)
await db.commit()
# Tell open browsers the assignment is gone (#2575). Only the manual
# REST assign/unassign endpoints broadcast this event; without it the
# frontend's spool-assignments cache keeps rendering the unlinked
# spool on the slot until an unrelated refetch — which reads exactly
# like "the fix didn't work" (reporter verified: a browser refresh
# after the swap showed the correct state all along).
for ams_id, tray_id in unlinked_slots:
await ws_manager.broadcast(
{
"type": "spool_assignment_changed",
"printer_id": printer_id,
"ams_id": ams_id,
"tray_id": tray_id,
}
)
except Exception as e:
logger.warning("Spool assignment cleanup failed: %s", e, exc_info=True)
# Auto-manage inventory spools from AMS tray data (skip if Spoolman manages AMS).
# Serialised per-printer via _ams_assignment_locks: MQTT bursts can deliver
# two AMS pushes ~30 ms apart, and without the lock both callbacks read
# "no existing assignment" for the same (printer, ams, tray) and race to
# INSERT, hitting the spool_assignment_printer_id_ams_id_tray_id_key
# unique constraint on Postgres. SQLite's WAL serialises writes so the
# bug stayed latent there. See _ams_assignment_locks comment for details.
try:
async with _get_ams_assignment_lock(printer_id), async_session() as db:
from backend.app.api.routes.settings import get_setting
from backend.app.models.spool import Spool
from backend.app.models.spool_assignment import SpoolAssignment as SA
from backend.app.services.spool_tag_matcher import (
auto_assign_spool,
create_spool_from_tray,
find_matching_untagged_spool,
get_spool_by_tag,
is_bambu_tag,
is_valid_tag,
link_tag_to_inventory_spool,
)
_spoolman_on = await get_setting(db, "spoolman_enabled")
_auto_add_raw = await get_setting(db, "auto_add_unknown_rfid")
_auto_add_unknown = _auto_add_raw is None or _auto_add_raw.lower() == "true"
if not _spoolman_on or _spoolman_on.lower() != "true":
for ams_unit in ams_data:
if not isinstance(ams_unit, dict):
continue
ams_id = int(ams_unit.get("id", 0))
for tray in ams_unit.get("tray", []):
if not isinstance(tray, dict):
continue
tray_id = int(tray.get("id", 0))
tag_uid = tray.get("tag_uid", "")
tray_uuid = tray.get("tray_uuid", "")
tray_info_idx = tray.get("tray_info_idx", "")
if not tray.get("tray_type"):
# Slot reported empty — drop any cached unknown-tag
# broadcast so reinserting the same spool re-prompts.
_clear_unknown_tag_dedup(printer_id, ams_id, tray_id)
continue # Empty slot
# Check if assignment already exists for this slot
existing = await db.execute(
select(SA)
.options(selectinload(SA.spool).selectinload(Spool.k_profiles))
.where(SA.printer_id == printer_id, SA.ams_id == ams_id, SA.tray_id == tray_id)
)
existing_assignment = existing.scalar_one_or_none()
if existing_assignment:
# Sync spool weight_used from AMS remain — only INCREASE, never decrease.
# The AMS remain% is low-resolution (integer %, i.e. 10g steps for 1kg spool)
# and must not overwrite precise values from the usage tracker (3MF/G-code).
# Skip during active prints: the usage tracker handles deduction
# precisely via 3MF data on print completion. Without this guard the
# AMS remain% SET and the usage tracker ADD both fire from the same
# MQTT message, doubling the deduction (#880).
if _print_active:
continue
remain_raw = tray.get("remain")
if (
remain_raw is not None
and existing_assignment.spool
and not existing_assignment.spool.weight_locked
):
try:
remain_val = int(remain_raw)
except (TypeError, ValueError):
remain_val = -1
if 1 <= remain_val <= 100:
lw = existing_assignment.spool.label_weight or 1000
new_used = round(lw * (100 - remain_val) / 100.0, 1)
current_used = existing_assignment.spool.weight_used or 0
if new_used > current_used + 1:
logger.info(
"Weight sync: spool %d weight_used %s -> %s (remain=%d)",
existing_assignment.spool_id,
current_used,
new_used,
remain_val,
)
existing_assignment.spool.weight_used = new_used
await db.commit()
# Re-apply stored K-profile when the live tray's
# cali_idx drifted from the spool's stored profile.
# This catches "reset slot → re-read" and any other
# path where the firmware loses the user's K-profile
# selection while the SpoolAssignment row persists.
# Per the maintainer's rule: any time a spool tag is
# identified and matches inventory, the slot must be
# configured with the spool's stored settings. Without
# this block the existing-assignment branch only ran
# weight-sync and let the firmware-default cali_idx win.
try:
spool = existing_assignment.spool
if (
spool is not None
and is_bambu_tag(tag_uid, tray_uuid, tray_info_idx)
and spool.k_profiles
):
state = printer_manager.get_status(printer_id)
nozzle_diameter = "0.4"
if state and state.nozzles:
nd = state.nozzles[0].nozzle_diameter
if nd:
nozzle_diameter = nd
slot_extruder: int | None = None
if state and state.ams_extruder_map:
if ams_id == 255:
slot_extruder = 1 - tray_id
else:
slot_extruder = state.ams_extruder_map.get(str(ams_id))
# Prefer exact extruder match, fall back to
# extruder-agnostic kp for the same printer +
# nozzle. Avoids hard-skipping when the AMS is
# mapped differently than at calibration time.
matching_kp = None
fallback_kp = None
for kp in spool.k_profiles:
if (
kp.printer_id != printer_id
or kp.nozzle_diameter != nozzle_diameter
or kp.cali_idx is None
):
continue
if (
slot_extruder is not None
and kp.extruder is not None
and kp.extruder == slot_extruder
):
matching_kp = kp
break
if fallback_kp is None:
fallback_kp = kp
chosen_kp = matching_kp or fallback_kp
if chosen_kp is not None:
live_cali_idx = tray.get("cali_idx")
# Only fire MQTT when the printer's live
# cali_idx differs from the stored value.
# Avoids spamming the broker on every
# MQTT push during steady-state operation.
if live_cali_idx != chosen_kp.cali_idx:
client = printer_manager.get_client(printer_id)
if client:
cali_filament_id = spool.slicer_filament or tray_info_idx or ""
client.extrusion_cali_sel(
ams_id=ams_id,
tray_id=tray_id,
cali_idx=chosen_kp.cali_idx,
filament_id=cali_filament_id,
nozzle_diameter=nozzle_diameter,
)
logger.info(
"Re-applied K-profile cali_idx=%d for spool %d "
"on printer %d AMS%d-T%d (live=%s drift detected)",
chosen_kp.cali_idx,
spool.id,
printer_id,
ams_id,
tray_id,
live_cali_idx,
)
except Exception:
logger.exception(
"K-profile re-apply failed for printer %d AMS%d-T%d",
printer_id,
ams_id,
tray_id,
)
continue
if is_bambu_tag(tag_uid, tray_uuid, tray_info_idx):
# BL spool with RFID tag: auto-match → inventory match → auto-create
spool = await get_spool_by_tag(db, tag_uid, tray_uuid)
if not spool:
# Try matching an untagged inventory spool (same material/color)
spool = await find_matching_untagged_spool(db, tray)
if spool:
await link_tag_to_inventory_spool(db, spool, tray)
elif _auto_add_unknown:
spool = await create_spool_from_tray(db, tray)
else:
# Auto-add disabled: surface the slot so the
# user can add it manually via the UI.
await _broadcast_unknown_tag(
printer_id=printer_id,
ams_id=ams_id,
tray_id=tray_id,
tag_uid=tag_uid,
tray_uuid=tray_uuid,
tray_type=tray.get("tray_type"),
tray_color=tray.get("tray_color"),
tray_sub_brands=tray.get("tray_sub_brands"),
tray_count=len(ams_unit.get("tray", [])),
)
continue
# Slot matched (existing tag, untagged inventory
# match, or freshly auto-created spool) — drop any
# stale dedup so a future tag swap re-prompts.
_clear_unknown_tag_dedup(printer_id, ams_id, tray_id)
await auto_assign_spool(
printer_id,
ams_id,
tray_id,
spool,
printer_manager,
db,
tray_info_idx=tray_info_idx,
)
await db.commit()
await ws_manager.broadcast(
{
"type": "spool_auto_assigned",
"printer_id": printer_id,
"ams_id": ams_id,
"tray_id": tray_id,
"spool_id": spool.id,
}
)
logger.info(
"RFID auto-assigned spool %d to printer %d AMS%d-T%d",
spool.id,
printer_id,
ams_id,
tray_id,
)
elif is_valid_tag(tag_uid, tray_uuid):
# Non-BL spool with some tag — let user choose
await _broadcast_unknown_tag(
printer_id=printer_id,
ams_id=ams_id,
tray_id=tray_id,
tag_uid=tag_uid,
tray_uuid=tray_uuid,
tray_type=tray.get("tray_type"),
tray_color=tray.get("tray_color"),
tray_sub_brands=tray.get("tray_sub_brands"),
tray_count=len(ams_unit.get("tray", [])),
)
# No-tag slots (generic non-RFID filament) are left alone:
# nothing to identify, prompting "+ Add" would just create
# ghost spools with empty tags on every confirm.
except Exception as e:
logger.warning("RFID spool auto-assign failed: %s", e, exc_info=True)
try:
async with async_session() as db:
from backend.app.api.routes.settings import get_setting
from backend.app.models.printer import Printer
# Check if Spoolman is enabled
spoolman_enabled = await get_setting(db, "spoolman_enabled")
if not spoolman_enabled or spoolman_enabled.lower() != "true":
return
# Check sync mode
sync_mode = await get_setting(db, "spoolman_sync_mode")
if sync_mode and sync_mode != "auto":
return # Only sync on auto mode
_auto_add_raw_sm = await get_setting(db, "auto_add_unknown_rfid")
auto_add_unknown_rfid = _auto_add_raw_sm is None or _auto_add_raw_sm.lower() == "true"
# `spoolman_disable_weight_sync` is deprecated (#1119) — weight is now
# always owned by per-print tracking, never by AMS auto-sync. The
# setting is still read by the settings UI for backwards compat but
# has no effect on the sync path here.
# Get Spoolman URL
spoolman_url = await get_setting(db, "spoolman_url")
if not spoolman_url:
return
# Get or create Spoolman client
client = await get_spoolman_client()
if not client:
try:
client = await init_spoolman_client(spoolman_url)
except ValueError as exc:
logger.warning("Spoolman URL %r rejected by SSRF guard: %s", spoolman_url, exc)
return
# Check if Spoolman is reachable
if not await client.health_check():
logger.warning("Spoolman not reachable at %s", spoolman_url)
return
# Get printer name for location
result = await db.execute(select(Printer).where(Printer.id == printer_id))
printer = result.scalar_one_or_none()
printer_name = printer.name if printer else f"Printer {printer_id}"
# OPTIMIZATION: Fetch all spools once before processing trays
# This eliminates redundant API calls (one per tray) when syncing multiple trays
logger.debug("[Printer %s] Fetching spools cache for AMS sync...", printer_id)
try:
cached_spools = await client.get_spools()
logger.debug("[Printer %s] Cached %d spools for batch sync", printer_id, len(cached_spools))
except Exception as e:
logger.error(
"[Printer %s] Failed to fetch spools cache after retries, aborting AMS sync: %s",
printer_id,
e,
)
return
# Load inventory weights as fallback (when AMS MQTT data lacks remain values)
from sqlalchemy.orm import selectinload
from backend.app.models.spool_assignment import SpoolAssignment
from backend.app.models.spoolman_slot_assignment import SpoolmanSlotAssignment
inventory_weights: dict[tuple[int, int], float] = {}
try:
assign_result = await db.execute(
select(SpoolAssignment)
.options(selectinload(SpoolAssignment.spool))
.where(SpoolAssignment.printer_id == printer_id)
)
for assignment in assign_result.scalars().all():
spool = assignment.spool
if spool and spool.label_weight > 0:
remaining = max(0.0, spool.label_weight - (spool.weight_used or 0))
inventory_weights[(assignment.ams_id, assignment.tray_id)] = remaining
except Exception as e:
logger.warning("Could not load inventory weights for printer %s: %s", printer_id, e)
# Load existing Spoolman slot assignments for the no-RFID fallback path
spoolman_slot_map: dict[tuple[int, int], int] = {}
try:
slot_result = await db.execute(
select(SpoolmanSlotAssignment).where(SpoolmanSlotAssignment.printer_id == printer_id)
)
for slot in slot_result.scalars().all():
spoolman_slot_map[(slot.ams_id, slot.tray_id)] = slot.spoolman_spool_id
except Exception as e:
logger.warning("Could not load Spoolman slot assignments for printer %s: %s", printer_id, e)
# Sync each AMS tray and collect slot changes for DB persistence
synced = 0
slot_changes: list[tuple[int, int, int]] = [] # (ams_id, tray_id, spoolman_spool_id) to upsert
empty_slots: list[tuple[int, int]] = [] # (ams_id, tray_id) whose tray is now empty
for ams_unit in ams_data:
if not isinstance(ams_unit, dict):
continue
ams_id = int(ams_unit.get("id", 0))
trays = ams_unit.get("tray", [])
for tray_data in trays:
if not isinstance(tray_data, dict):
continue
tray_id_raw = int(tray_data.get("id", 0))
tray = client.parse_ams_tray(ams_id, tray_data)
if not tray:
# Empty tray slot — record for local assignment cleanup
# and drop any cached unknown-tag broadcast so a
# reinserted spool re-prompts.
#
# Not during a running print: a slot that empties there
# is a filament runout, and the spool is still in the
# AMS. `spoolman_slot_assignments` is how a tag-less
# spool assigned through the Bambuddy UI is resolved at
# completion (#1459), so deleting the row mid-print
# loses the runout segment's usage — the same failure
# the internal inventory's auto-unlink had.
if not printing_now:
empty_slots.append((ams_id, tray_id_raw))
_clear_unknown_tag_dedup(printer_id, ams_id, tray_id_raw)
continue
spool_tag = (
tray.tray_uuid
if tray.tray_uuid and tray.tray_uuid != "00000000000000000000000000000000"
else tray.tag_uid
)
# Provide the hint only when no RFID is available
hint = spoolman_slot_map.get((ams_id, tray.tray_id)) if not spool_tag else None
try:
inv_remaining = inventory_weights.get((ams_id, tray.tray_id))
result = await client.sync_ams_tray(
tray,
printer_name,
# Per-print tracking is the only weight writer (#1119).
# AMS auto-sync still maintains spool metadata / slot
# assignments but no longer touches remaining_weight.
disable_weight_sync=True,
cached_spools=cached_spools,
inventory_remaining=inv_remaining,
spoolman_spool_id_hint=hint,
auto_add_unknown_rfid=auto_add_unknown_rfid,
)
if result is None and spool_tag and not auto_add_unknown_rfid:
# Spoolman skipped auto-create per user setting — surface
# the slot so the UI can offer "+ Add to inventory".
await _broadcast_unknown_tag(
printer_id=printer_id,
ams_id=ams_id,
tray_id=tray.tray_id,
tag_uid=tray.tag_uid or "",
tray_uuid=tray.tray_uuid or "",
tray_type=tray.tray_type,
tray_color=tray.tray_color,
tray_sub_brands=tray.tray_sub_brands,
tray_count=len(trays),
)
elif result:
_clear_unknown_tag_dedup(printer_id, ams_id, tray.tray_id)
if result:
synced += 1
if result.get("id"):
slot_changes.append((ams_id, tray.tray_id, result["id"]))
# If a new spool was created, add it to the cache
# so subsequent trays can find it if they reference the same tag
spool_exists = any(s.get("id") == result["id"] for s in cached_spools)
if not spool_exists:
cached_spools.append(result)
logger.debug(
"[Printer %s] Added newly created spool %s to cache",
printer_id,
result["id"],
)
# Reconcile slot_preset_mappings (the same row internal
# mode keeps in sync via inventory + spool_tag_matcher).
# Without this the slot card surfaces the previous spool's
# preset name — same bug shape, different inventory mode.
from backend.app.services.slot_preset_writer import (
upsert_slot_preset_for_spoolman_spool,
)
await upsert_slot_preset_for_spoolman_spool(
db=db,
spoolman_spool=result,
tray_info_idx=tray.tray_info_idx or "",
tray_sub_brands=tray.tray_sub_brands or "",
tray_type=tray.tray_type or "",
printer_id=printer_id,
ams_id=ams_id,
tray_id=tray.tray_id,
)
except Exception as e:
logger.error("Error syncing AMS %s tray %s: %s", ams_id, tray.tray_id, e)
if synced > 0:
logger.info("Auto-synced %s AMS trays to Spoolman for printer %s", synced, printer_id)
# Persist slot assignment changes to the local table
if slot_changes or empty_slots:
try:
for ams_id, tray_id, spool_id in slot_changes:
await db.execute(
text(
"INSERT INTO spoolman_slot_assignments"
" (printer_id, ams_id, tray_id, spoolman_spool_id)"
" VALUES (:printer_id, :ams_id, :tray_id, :spool_id)"
" ON CONFLICT(printer_id, ams_id, tray_id)"
" DO UPDATE SET spoolman_spool_id = excluded.spoolman_spool_id"
),
{
"printer_id": printer_id,
"ams_id": ams_id,
"tray_id": tray_id,
"spool_id": spool_id,
},
)
for ams_id, tray_id in empty_slots:
await db.execute(
delete(SpoolmanSlotAssignment).where(
SpoolmanSlotAssignment.printer_id == printer_id,
SpoolmanSlotAssignment.ams_id == ams_id,
SpoolmanSlotAssignment.tray_id == tray_id,
)
)
await db.commit()
except Exception as e:
await db.rollback()
logger.error("Error persisting Spoolman slot assignments for printer %s: %s", printer_id, e)
except Exception as e:
logging.getLogger(__name__).error("Spoolman AMS sync failed for printer %s: %s", printer_id, e)
async def _capture_snapshot_for_notification(printer_id: int, printer, logger) -> bytes | None:
"""Capture a camera snapshot for notification image attachment.
Returns JPEG bytes (max 2.5MB) or None if capture fails or is unavailable.
Uses: external camera > buffered frame > fresh capture.
"""
if not printer:
return None
try:
from backend.app.api.routes.settings import get_setting
async with async_session() as db:
capture_enabled = await get_setting(db, "capture_finish_photo")
if capture_enabled is not None and capture_enabled.lower() != "true":
return None
# Try external camera first
if printer.external_camera_enabled and printer.external_camera_url:
logger.info("[SNAPSHOT] Capturing from external camera for printer %s", printer_id)
from backend.app.api.routes.camera import live_frame_for_capture
from backend.app.services.external_camera import capture_frame
# An external camera allows one reader, so capturing while a viewer
# is attached fails (#2707). A None here falls through to the paths
# below exactly as a failed capture did.
defer, buffered = live_frame_for_capture(printer_id)
if defer:
frame_data = buffered
else:
frame_data = await capture_frame(
printer.external_camera_url,
printer.external_camera_type or "mjpeg",
snapshot_url=printer.external_camera_snapshot_url,
)
if frame_data and len(frame_data) <= 2_500_000:
logger.info("[SNAPSHOT] External camera frame: %s bytes", len(frame_data))
return _apply_camera_rotation(frame_data, printer, logger)
# Try buffered frame from active stream
from backend.app.api.routes.camera import _active_chamber_streams, _active_streams, get_buffered_frame
active_for_printer = [k for k in _active_streams if k.startswith(f"{printer_id}-")]
active_chamber = [k for k in _active_chamber_streams if k.startswith(f"{printer_id}-")]
buffered_frame = get_buffered_frame(printer_id)
if (active_for_printer or active_chamber) and buffered_frame:
logger.info("[SNAPSHOT] Using buffered frame for printer %s: %s bytes", printer_id, len(buffered_frame))
if len(buffered_frame) <= 2_500_000:
return _apply_camera_rotation(buffered_frame, printer, logger)
# Fresh capture from printer camera
logger.info("[SNAPSHOT] Capturing fresh frame for printer %s", printer_id)
from backend.app.services.camera import capture_camera_frame_bytes
frame_data = await capture_camera_frame_bytes(
printer.ip_address, printer.access_code, printer.model, timeout=15
)
if frame_data and len(frame_data) <= 2_500_000:
logger.info("[SNAPSHOT] Fresh camera frame: %s bytes", len(frame_data))
return _apply_camera_rotation(frame_data, printer, logger)
except Exception as e:
logger.warning("[SNAPSHOT] Failed to capture snapshot for printer %s: %s", printer_id, e)
return None
async def _maybe_bank_inprint_frame(printer_id: int, layer_num: int) -> None:
"""#1867: bank a recent in-print camera frame for the finish photo.
Called on every layer change and (#2547) on every print-progress advance.
Grabs one frame (throttled) into ``_inprint_frame_bank`` so the finish-photo
path has a pre-End-G-code image for prints that end with a plate swap.
Both drivers are print telemetry that stops the instant printing ends: no
further layers, and progress freezes before the End G-code (e.g. SwapMod
plate swap) executes. So the last banked frame is always the finished print,
never the swapped plate — that property is what the #1867 path relies on and
it must survive any change to the throttle below.
Layer changes alone were not enough: they stop when the *final* layer
begins, which on a three-minute last layer left the bank stale by the whole
length of that layer (#2547). Progress keeps ticking through it.
Best-effort: any failure just leaves the previous banked frame.
"""
logger = logging.getLogger(__name__)
client = printer_manager.get_client(printer_id)
state = client.state if client else None
if not state or state.state != "RUNNING":
return
# Only during actual extrusion — firmware ticks layer_num during the
# pre-print calibration sequence, whose sub-stages are non-zero.
if state.mc_print_sub_stage not in (None, 0):
return
# #2547: throttled uniformly, with no last-layer exemption. The old code
# bypassed the throttle on the final layer to guarantee a fresh frame there;
# now that progress advances also drive banking, that exemption would fire a
# camera grab on every percent tick of the last layer. Bambu printers accept
# one RTSP client at a time, so each grab contends with the live view.
now = time.monotonic()
last = _inprint_frame_bank_ts.get(printer_id, 0.0)
if (now - last) < _INPRINT_BANK_MIN_INTERVAL:
return
total = state.total_layers or 0
try:
async with async_session() as db:
from backend.app.models.printer import Printer
result = await db.execute(select(Printer).where(Printer.id == printer_id))
printer = result.scalar_one_or_none()
if not printer:
return
# Reuses the notification snapshot path, which honours the
# `capture_finish_photo` setting (returns None when disabled) so we
# don't bank frames the user never asked for.
frame = await _capture_snapshot_for_notification(printer_id, printer, logger)
if frame:
_inprint_frame_bank[printer_id] = frame
_inprint_frame_bank_ts[printer_id] = now
logger.debug(
"[FINISH-PHOTO-BANK] banked in-print frame for printer %s at layer %s/%s (%d bytes)",
printer_id,
layer_num,
total,
len(frame),
)
except Exception as e:
logger.debug("[FINISH-PHOTO-BANK] bank failed for printer %s: %s", printer_id, e)
def _apply_camera_rotation(image_data: bytes, printer, logger) -> bytes:
"""Apply camera rotation to snapshot image if configured."""
from backend.app.services.camera import apply_camera_rotation
return apply_camera_rotation(image_data, getattr(printer, "camera_rotation", 0), logger)
async def _send_print_start_notification(
printer_id: int,
data: dict,
archive_data: dict | None = None,
logger=None,
):
"""Helper to send print start notification with optional archive data."""
if logger is None:
logger = logging.getLogger(__name__)
try:
async with async_session() as db:
from backend.app.models.printer import Printer
result = await db.execute(select(Printer).where(Printer.id == printer_id))
printer = result.scalar_one_or_none()
printer_name = printer.name if printer else f"Printer {printer_id}"
# Capture camera snapshot for notification image attachment
image_data = await _capture_snapshot_for_notification(printer_id, printer, logger)
if image_data:
if archive_data is None:
archive_data = {}
archive_data["image_data"] = image_data
await notification_service.on_print_start(printer_id, printer_name, data, db, archive_data=archive_data)
# Send user-specific email notification for print start
if archive_data and archive_data.get("created_by_id"):
await notification_service.send_user_print_email(
event_type="user_print_start",
created_by_id=archive_data["created_by_id"],
printer_name=printer_name,
filename=data.get("subtask_name") or data.get("filename", "Unknown"),
db=db,
)
except Exception as e:
logger.warning("Notification on_print_start failed: %s", e)
async def _dispatch_user_print_email(
status: str,
created_by_id: int | None,
printer_name: str,
filename: str,
db,
) -> None:
"""Send a user-specific print-completion email based on print status.
Maps the normalised print status to the correct event type and delegates
to :meth:`NotificationService.send_user_print_email`. A single helper
avoids duplicating the ``if status == "completed" / elif "failed" / elif
"stopped"`` dispatch block at every call site.
Does nothing if *created_by_id* is ``None``.
"""
if created_by_id is None:
return
if status == "completed":
event_type = "user_print_complete"
elif status == "failed":
event_type = "user_print_failed"
elif status in ("stopped", "aborted", "cancelled"):
event_type = "user_print_stopped"
else:
return
await notification_service.send_user_print_email(
event_type=event_type,
created_by_id=created_by_id,
printer_name=printer_name,
filename=filename,
db=db,
)
def _load_objects_from_archive(archive, printer_id: int, logger) -> None:
"""Extract printable objects from an archive's 3MF file and store in printer state."""
try:
from backend.app.services.archive import extract_printable_objects_from_3mf
client = printer_manager.get_client(printer_id)
if not client:
return
file_path = app_settings.base_dir / archive.file_path
if file_path.is_file() and str(file_path).endswith(".3mf"):
with open(file_path, "rb") as f:
threemf_data = f.read()
# Extract with positions for UI overlay, scoped to the plate that
# is printing — resolve_plate_id is the same resolver /cover uses,
# so the object list can't disagree with the thumbnail it is drawn
# over (#2522).
printable_objects, bbox_all = extract_printable_objects_from_3mf(
threemf_data,
plate_number=resolve_plate_id(client.state),
include_positions=True,
)
if printable_objects:
client.state.printable_objects = printable_objects
client.state.printable_objects_bbox_all = bbox_all
client.state.skipped_objects = []
logger.info("Loaded %s printable objects for printer %s", len(printable_objects), printer_id)
except Exception as e:
logger.debug("Failed to extract printable objects from archive: %s", e)
async def on_print_start(printer_id: int, data: dict):
"""Handle print start - archive the 3MF file immediately."""
logger = logging.getLogger(__name__)
logger.info("[CALLBACK] on_print_start called for printer %s, data keys: %s", printer_id, list(data.keys()))
# Clear any stale user-stopped flag from previous print cycles
_user_stopped_printers.discard(printer_id)
_kill_switch_notification_tasks.pop(printer_id, None)
# #1721: drop any leftover pre-captured finish frame from a prior print
# so a never-consumed cache entry can't bleed into the new print's photo.
_stage22_finish_frames.pop(printer_id, None)
# #1867: same for the in-print frame bank — a queued print must not reuse
# the previous job's banked frame.
_inprint_frame_bank.pop(printer_id, None)
_inprint_frame_bank_ts.pop(printer_id, None)
# #2547: bind (or clear) the "this print ends with injected End G-code" flag.
# Unconditional, so a print Bambuddy didn't dispatch drops the previous
# print's flag instead of inheriting it.
print_dispatch_context.adopt(printer_id)
# Cancel any active bed cooldown waiter for this printer
if _bed_cool_waiters.pop(printer_id, None):
logger.info("[BED-COOL] Cancelled bed cooldown waiter for printer %s (new print started)", printer_id)
# Clear cached cover images so the new print's thumbnail is fetched fresh
from backend.app.api.routes.printers import clear_cover_cache
clear_cover_cache(printer_id)
await ws_manager.send_print_start(printer_id, data)
# Notify when the print-start AMS mapping references tray slots without spool assignments.
await notify_missing_spool_assignments_on_print_start(printer_id, data, logger)
# MQTT relay - publish print start
try:
printer_info = printer_manager.get_printer(printer_id)
if printer_info:
await mqtt_relay.on_print_start(
printer_id,
printer_info.name,
printer_info.serial_number,
data.get("filename", ""),
data.get("subtask_name", ""),
)
except Exception:
pass # Don't fail print start callback if MQTT fails
# Capture AMS tray remain%, the assignment snapshot, the dispatched plate
# and mapping, and the seeded tray-change log.
#
# Unconditional, for both inventory backends. This only *captures* — the
# writing is still split, with the internal tracker skipped at completion
# when Spoolman owns usage. Spoolman's own durable row (#1820) already
# carries its plate-scoped 3MF figures and stored mapping, but not the
# tray-change log, and that log is the only record of which spool fed
# which layers when AMS Filament Backup swaps trays mid-print. Capturing
# it on one side only would leave Spoolman users with the mid-print
# restart bug this fixes for everyone else.
try:
async with async_session() as db:
from backend.app.api.routes.settings import get_setting
from backend.app.services.usage_tracker import on_print_start as usage_on_print_start
_spoolman_on = await get_setting(db, "spoolman_enabled")
await usage_on_print_start(
printer_id,
data,
printer_manager,
db=db,
spoolman_owns_usage=bool(_spoolman_on) and _spoolman_on.lower() == "true",
)
except Exception as e:
logger.warning("Usage tracker on_print_start failed: %s", e)
# Track if notification was sent (to avoid sending twice)
notification_sent = False
# Smart plug automation: turn on plug when print starts
try:
async with async_session() as db:
await smart_plug_manager.on_print_start(printer_id, db)
except Exception as e:
logger.warning("Smart plug on_print_start failed: %s", e)
async with async_session() as db:
from backend.app.models.printer import Printer
from backend.app.services.bambu_ftp import list_files_async
result = await db.execute(select(Printer).where(Printer.id == printer_id))
printer = result.scalar_one_or_none()
# Plate detection check - pause if objects detected on build plate
logger.info(
f"[PLATE CHECK] printer_id={printer_id}, plate_detection_enabled={printer.plate_detection_enabled if printer else 'NO PRINTER'}"
)
if printer and printer.plate_detection_enabled:
logger.info("[PLATE CHECK] ENTERING plate detection code for printer %s", printer_id)
# Release the pooled DB connection before the plate-detection camera
# work (a 2.5s light-settle sleep + FTP/camera capture). Only the
# printer SELECT has run so far — nothing to persist — so this commit
# is a data-noop that ends the read transaction and returns the
# connection to the pool during the I/O (issue #2572). expire_on_commit
# =False keeps printer.* readable; on_plate_not_empty (rare) and the
# archive lookups below re-acquire a fresh connection on next execute.
await db.commit()
try:
from backend.app.services.plate_detection import check_plate_empty
# Build ROI tuple from printer settings if available
roi = None
if all(
[
printer.plate_detection_roi_x is not None,
printer.plate_detection_roi_y is not None,
printer.plate_detection_roi_w is not None,
printer.plate_detection_roi_h is not None,
]
):
roi = (
printer.plate_detection_roi_x,
printer.plate_detection_roi_y,
printer.plate_detection_roi_w,
printer.plate_detection_roi_h,
)
# Auto-turn on chamber light if it's off for better detection
light_was_off = False
client = printer_manager.get_client(printer_id)
if client and client.state:
light_was_off = not client.state.chamber_light
if light_was_off:
logger.info("[PLATE CHECK] Turning on chamber light for printer %s", printer_id)
client.set_chamber_light(True)
# Wait for light to physically turn on and camera to adjust exposure
await asyncio.sleep(2.5)
logger.info("[PLATE CHECK] Running plate detection for printer %s", printer_id)
plate_result = await check_plate_empty(
printer_id=printer_id,
ip_address=printer.ip_address,
access_code=printer.access_code,
model=printer.model,
include_debug_image=False,
external_camera_url=printer.external_camera_url,
external_camera_type=printer.external_camera_type,
use_external=printer.external_camera_enabled,
roi=roi,
external_camera_snapshot_url=printer.external_camera_snapshot_url,
)
# Restore chamber light to original state
if light_was_off and client:
logger.info("[PLATE CHECK] Restoring chamber light to off for printer %s", printer_id)
client.set_chamber_light(False)
if not plate_result.needs_calibration and not plate_result.is_empty:
# Objects detected - pause the print!
logger.warning(
f"[PLATE CHECK] Objects detected on plate for printer {printer_id}! "
f"Confidence: {plate_result.confidence:.0%}, Diff: {plate_result.difference_percent:.1f}%"
)
client = printer_manager.get_client(printer_id)
if client:
client.pause_print()
logger.info("[PLATE CHECK] Print paused for printer %s", printer_id)
# Send notification about plate not empty
await ws_manager.broadcast(
{
"type": "plate_not_empty",
"printer_id": printer_id,
"printer_name": printer.name,
"message": f"Objects detected on build plate! Print paused. (Diff: {plate_result.difference_percent:.1f}%)",
}
)
# Also send push notification
try:
await notification_service.on_plate_not_empty(
printer_id=printer_id,
printer_name=printer.name,
db=db,
difference_percent=plate_result.difference_percent,
)
except Exception as notif_err:
logger.warning("[PLATE CHECK] Failed to send notification: %s", notif_err)
else:
logger.info("[PLATE CHECK] Plate is empty for printer %s, proceeding with print", printer_id)
except Exception as plate_err:
# Don't block print on plate detection errors
logger.warning("[PLATE CHECK] Plate detection failed for printer %s: %s", printer_id, plate_err)
if not printer:
logger.info("[CALLBACK] Skipping archive - printer not found in database")
if not notification_sent:
await _send_print_start_notification(printer_id, data, logger=logger)
return
if not printer.auto_archive:
# auto-archive disabled — check if there's an expected print (dispatched
# by BamBuddy via queue/reprint) that already has an archive to promote.
# If so, fall through to the expected-print handling below so the archive
# is tracked in _active_prints and usage tracking works at completion.
_fn = data.get("filename", "")
_sn = data.get("subtask_name", "")
_check_keys: list[tuple[int, str]] = []
if _sn:
_check_keys += [
(printer_id, _sn),
(printer_id, f"{_sn}.3mf"),
(printer_id, f"{_sn}.gcode.3mf"),
]
if _fn:
_base_fn = _fn.split("/")[-1] if "/" in _fn else _fn
_check_keys.append((printer_id, _base_fn))
_no_archive_base = _base_fn.replace(".gcode", "").replace(".3mf", "")
_check_keys += [
(printer_id, _no_archive_base),
(printer_id, f"{_no_archive_base}.3mf"),
]
_has_expected = any(k in _expected_prints for k in _check_keys)
if not _has_expected:
# No expected print — truly external print (started from slicer/touchscreen)
logger.info("[CALLBACK] Skipping archive - auto_archive: False, no expected print")
if not notification_sent:
_no_archive_creator: int | None = None
for _key in _check_keys:
_expected_prints.pop(_key, None)
_expected_print_registered_at.pop(_key, None)
popped_creator = _expected_print_creators.pop(_key, None)
if _no_archive_creator is None:
_no_archive_creator = popped_creator
_creator_data = {"created_by_id": _no_archive_creator} if _no_archive_creator else None
await _send_print_start_notification(printer_id, data, _creator_data, logger)
return
else:
logger.info("[CALLBACK] auto_archive disabled but expected print found — promoting archive")
# Get the filename and subtask_name
filename = data.get("filename", "")
subtask_name = data.get("subtask_name", "")
# MQTT subtask_id uniquely identifies a print job on the printer. When
# present, it lets us match an archive across a backend restart (#972):
# same id → same print → resume the existing row instead of cancelling
# it and recreating from scratch (which loses started_at). Treat "0"
# and "" as absent — Bambu reports "0" for non-cloud / local prints.
raw_mqtt = data.get("raw_data") or {}
subtask_id = raw_mqtt.get("subtask_id")
if subtask_id is not None:
subtask_id = str(subtask_id).strip()
if subtask_id in ("", "0"):
subtask_id = None
logger.info("[CALLBACK] Print start detected - filename: %s, subtask: %s", filename, subtask_name)
# Skip calibration prints — internal printer files should not be archived
# Bambu calibration gcode lives under /usr/ (e.g. /usr/etc/print/auto_cali_for_user.gcode)
if filename and filename.startswith("/usr/"):
logger.info("[CALLBACK] Skipping archive — internal printer file detected: %s", filename)
if not notification_sent:
await _send_print_start_notification(printer_id, data, logger=logger)
return
if not filename and not subtask_name:
# Send notification without archive data (no filename)
logger.info("[CALLBACK] Skipping archive - no filename or subtask_name")
if not notification_sent:
await _send_print_start_notification(printer_id, data, logger=logger)
return
# Check if this is an expected print from reprint/scheduled
# Build list of possible keys to check
expected_keys = []
if subtask_name:
expected_keys.append((printer_id, subtask_name))
expected_keys.append((printer_id, f"{subtask_name}.3mf"))
expected_keys.append((printer_id, f"{subtask_name}.gcode.3mf"))
if filename:
fname = filename.split("/")[-1] if "/" in filename else filename
expected_keys.append((printer_id, fname))
# Strip extensions to match
base = fname.replace(".gcode", "").replace(".3mf", "")
expected_keys.append((printer_id, base))
expected_keys.append((printer_id, f"{base}.3mf"))
expected_archive_id = None
for key in expected_keys:
expected_archive_id = _expected_prints.pop(key, None)
_expected_print_registered_at.pop(key, None)
if expected_archive_id:
# Clean up other possible keys for this print
for other_key in expected_keys:
_expected_prints.pop(other_key, None)
_expected_print_registered_at.pop(other_key, None)
break
if expected_archive_id:
# This is a reprint/scheduled print - use existing archive, don't create new one
logger.info("Using expected archive %s for print (skipping duplicate)", expected_archive_id)
from backend.app.models.archive import PrintArchive
result = await db.execute(select(PrintArchive).where(PrintArchive.id == expected_archive_id))
archive = result.scalar_one_or_none()
if archive:
# Update archive status to printing
archive.status = "printing"
archive.started_at = datetime.now(timezone.utc)
# Reprint of an archive reuses the source row. Without resetting
# ``timelapse_path`` _scan_for_timelapse_with_retries early-returns
# ("already has timelapse") and _capture_finish_photo_from_timelapse
# extracts the *original* print's last frame, which then ships in
# the completion notification (#1707). Clear the path so the
# scanner runs fresh; also unlink the old video file so reprints
# don't accumulate orphans in the archive directory. Photos list
# is left alone — accumulating one finish photo per run is fine.
# The print-start baseline (#2704) is stale for the same reason:
# it describes the printer before the previous run. The capture
# below overwrites it, but clear it here too so an early failure
# can't leave the scan diffing against the wrong snapshot.
archive.timelapse_baseline = None
stale_timelapse_relpath = archive.timelapse_path
if stale_timelapse_relpath:
archive.timelapse_path = None
try:
stale_path = app_settings.base_dir / stale_timelapse_relpath
if stale_path.is_file():
stale_path.unlink()
logger.info(
"Deleted stale timelapse %s on reprint of archive %s",
stale_timelapse_relpath,
expected_archive_id,
)
except OSError as e:
logger.warning(
"Failed to delete stale timelapse %s on reprint: %s",
stale_timelapse_relpath,
e,
)
# Persist a restart-stable id so a later restart resumes this
# archive by subtask_id instead of name-matching + duplicating
# it (#1485). The printer often hasn't echoed subtask_id back
# this soon after dispatch, so fall back to the id Bambuddy
# minted when it sent the print command. Scoped to this
# expected-print branch on purpose: an expected match means
# Bambuddy dispatched this exact print in this process, so the
# client's last-dispatch id genuinely belongs to it — using it
# for an externally-started print could mis-tag the archive.
effective_subtask_id = subtask_id
if not effective_subtask_id:
_client = printer_manager.get_client(printer_id)
_dispatched = getattr(_client, "last_dispatch_subtask_id", None) if _client else None
if _dispatched:
effective_subtask_id = str(_dispatched).strip() or None
# Update on first-set OR on reprint (the queue dispatcher mints
# a fresh subtask_id per dispatch in bambu_mqtt:3647). Skipping
# the rewrite for reprints leaves the archive holding the FIRST
# run's id; if MQTT then reconnects mid-print, the reconciler
# (#1542) compares the stale stored id against the printer's
# live id, sees a mismatch, and synthesises a bogus PRINT
# COMPLETE — exactly the false-positive "Print Stopped" reported
# in #1807. Inequality check preserves the noop-on-stable-push
# behaviour the earlier `not archive.subtask_id` guard provided.
if effective_subtask_id and archive.subtask_id != effective_subtask_id:
archive.subtask_id = effective_subtask_id
# #1403 follow-up: VP-queue archives are created with
# printer_id=None at queue-add time (we don't know which
# printer will run the job yet). When the print actually
# starts on a specific printer the expected-archive lookup
# used to skip this assignment, leaving printer_id=None
# forever — which then disables the "Scan for timelapse"
# button in ArchivesPage (gated on !archive.printer_id).
if archive.printer_id != printer_id:
archive.printer_id = printer_id
await db.commit()
# Track as active print
_active_prints[(printer_id, archive.filename)] = archive.id
if subtask_name:
_active_prints[(printer_id, f"{subtask_name}.3mf")] = archive.id
# Start timelapse session if external camera is enabled (#1353).
# Queue / VP-dispatched prints land here in the expected-archive
# branch and used to skip start_session entirely — frames were
# never captured and the post-print stitch silently returned None.
_maybe_start_layer_timelapse(printer, printer_id, archive.id)
# Inject ams_mapping into usage tracker session — the session was created
# before expected-print promotion, so it may have ams_mapping=None when
# the MQTT request topic subscription failed (common on P1S/A1).
_stored_map = _print_ams_mappings.get(expected_archive_id)
_stored_plate_id = _print_plate_ids.get(expected_archive_id)
if _stored_map or _stored_plate_id is not None:
try:
from backend.app.services.usage_tracker import _active_sessions
_ut_session = _active_sessions.get(printer_id)
if _ut_session and _stored_map and not _ut_session.ams_mapping:
_ut_session.ams_mapping = _stored_map
logger.info("[CALLBACK] Injected ams_mapping into usage tracker session: %s", _stored_map)
# plate_id injection covers direct-Print of plate N of a multi-plate
# 3MF — queue prints already capture it via the on_print_start queue
# lookup, but direct-Print never goes through the queue (#1697).
if _ut_session and _stored_plate_id is not None and _ut_session.plate_id is None:
_ut_session.plate_id = _stored_plate_id
logger.info("[CALLBACK] Injected plate_id into usage tracker session: %s", _stored_plate_id)
except Exception:
pass
# Set up energy tracking (#941: persist start on archive row)
await _record_energy_start(archive, printer_id, db, context="expected-print")
await ws_manager.send_archive_updated(
{
"id": archive.id,
"status": "printing",
}
)
# Send notification with archive data (reprint/scheduled)
if not notification_sent:
# Use archive's created_by_id; fall back to the creator registered via
# register_expected_print (handles library-file-based queue items where
# the freshly-created archive has no created_by_id yet).
# Pop ALL matching keys so no stale entries remain in the dict.
fallback_creator = None
for key in expected_keys:
popped = _expected_print_creators.pop(key, None)
if fallback_creator is None:
fallback_creator = popped
archive_data = {
"print_time_seconds": archive.print_time_seconds,
"created_by_id": archive.created_by_id or fallback_creator,
}
await _send_print_start_notification(printer_id, data, archive_data, logger)
# Extract printable objects from the archived 3MF file
_load_objects_from_archive(archive, printer_id, logger)
# Store Spoolman tracking data for per-filament usage reporting
try:
await _store_spoolman_print_data(
printer_id,
archive.id,
archive.file_path,
db,
printer_manager,
ams_mapping=_get_start_ams_mapping(data, archive.id),
plate_id=_get_start_plate_id(archive.id),
)
except Exception as e:
logger.warning("[SPOOLMAN] Failed to store tracking data: %s", e)
# Capture timelapse file baseline for snapshot-diff on completion
# (mirrors the new-archive branch). Queue / VP-dispatched prints
# hit this branch — without the baseline the completion-time scan
# falls into its "take baseline now" fallback, which snapshots
# AFTER the new MP4 already exists and never matches a diff
# (#1403 follow-up — see pwostran's 2026-05-18 support bundle).
await _capture_timelapse_baseline_at_start(printer, printer_id, logger, archive_id=archive.id)
return # Skip creating a new archive
# Check if there's already a "printing" archive for this printer/file
# This prevents duplicates when backend restarts during an active print
from backend.app.models.archive import PrintArchive
existing_archive: PrintArchive | None = None
# Preferred match: subtask_id equality. MQTT reports the same subtask_id
# across a backend restart for the same print, so this is the most
# reliable way to reattach. We also accept a previously stale-cancelled
# archive here so users upgrading mid-print get revived when the row
# their earlier Bambuddy version wrongly cancelled reappears (#972).
if subtask_id:
by_id = await db.execute(
select(PrintArchive)
.where(PrintArchive.printer_id == printer_id)
.where(PrintArchive.subtask_id == subtask_id)
.where(PrintArchive.status.in_(["printing", "cancelled"]))
.order_by(PrintArchive.created_at.desc())
.limit(1)
)
candidate = by_id.scalar_one_or_none()
if candidate and (candidate.status == "printing" or (candidate.failure_reason or "").startswith("Stale")):
existing_archive = candidate
# Fallback match: name-based lookup. Kept as-is for prints whose
# subtask_id is missing ("0" / local / non-cloud prints).
if existing_archive is None:
check_name = subtask_name or filename.split("/")[-1].replace(".gcode", "").replace(".3mf", "")
existing = await db.execute(
select(PrintArchive)
.where(PrintArchive.printer_id == printer_id)
.where(PrintArchive.status == "printing")
.where(
or_(
PrintArchive.print_name == check_name,
PrintArchive.filename.in_(
[
f"{check_name}.3mf",
f"{check_name}.gcode.3mf",
]
),
)
)
.order_by(PrintArchive.created_at.desc())
.limit(1)
)
existing_archive = existing.scalar_one_or_none()
if existing_archive:
# subtask_id match → always resume, regardless of age. Same print,
# just a backend restart. Revive if it was previously stale-cancelled.
subtask_match = bool(subtask_id and existing_archive.subtask_id == subtask_id)
if subtask_match:
if existing_archive.status == "cancelled":
logger.warning(
"Reviving stale-cancelled archive %s — matching subtask_id %s confirms same print (#972)",
existing_archive.id,
subtask_id,
)
existing_archive.status = "printing"
existing_archive.failure_reason = None
await db.commit()
else:
logger.info("Resuming archive %s on subtask_id match (%s)", existing_archive.id, subtask_id)
_active_prints[(printer_id, existing_archive.filename)] = existing_archive.id
if existing_archive.energy_start_kwh is None:
await _record_energy_start(existing_archive, printer_id, db, context="subtask-resume")
if not notification_sent:
archive_data = {
"print_time_seconds": existing_archive.print_time_seconds,
"created_by_id": existing_archive.created_by_id,
}
await _send_print_start_notification(printer_id, data, archive_data, logger)
_load_objects_from_archive(existing_archive, printer_id, logger)
return
# Name-match only (no subtask_id to anchor on): decide resume vs.
# stale from the printer's *current* progress, not wall-clock age.
# A genuinely long print used to trip a blind 4h cutoff and have its
# live archive cancelled + duplicated on every backend restart
# (#1485). If the printer reports real progress, this name-matched
# 'printing' archive IS that ongoing print — resume it whatever its
# age. Only treat it as a stale leftover when the printer clearly
# shows a different, freshly-started print: near-0% progress on an
# archive far too old to still be at 0%. Unknown progress (printer
# not connected) never cancels — resuming is the safe default.
archive_age = datetime.now(timezone.utc) - existing_archive.created_at.replace(tzinfo=timezone.utc)
live_status = printer_manager.get_status(printer_id)
live_progress = getattr(live_status, "progress", None) if live_status else None
looks_stale = (
live_progress is not None and live_progress < 1.0 and archive_age.total_seconds() > 2 * 60 * 60
)
if looks_stale:
logger.warning(
f"Found stale 'printing' archive {existing_archive.id} (age: {archive_age}, "
f"printer progress {live_progress:.0f}%) — marking cancelled and creating new archive"
)
existing_archive.status = "cancelled"
existing_archive.failure_reason = "Stale - print likely cancelled or failed without status update"
await db.commit()
# Fall through to create new archive (don't return)
else:
logger.info(
f"Skipping duplicate - already have printing archive {existing_archive.id} for {check_name}"
)
# Track this as the active print
_active_prints[(printer_id, existing_archive.filename)] = existing_archive.id
# Attach subtask_id retroactively so future restarts can resume.
# Compare for inequality (not "is empty") to also pick up reprint
# dispatches that mint a fresh id — see #1807 for the bogus
# "Print Stopped" the strict-empty guard caused on reconnect.
if subtask_id and existing_archive.subtask_id != subtask_id:
existing_archive.subtask_id = subtask_id
await db.commit()
# Also set up energy tracking if not already tracked (#941: persisted column)
if existing_archive.energy_start_kwh is None:
await _record_energy_start(existing_archive, printer_id, db, context="existing-printing")
# Send notification with archive data (existing archive)
if not notification_sent:
archive_data = {
"print_time_seconds": existing_archive.print_time_seconds,
"created_by_id": existing_archive.created_by_id,
}
await _send_print_start_notification(printer_id, data, archive_data, logger)
# Extract printable objects from the archived 3MF file
_load_objects_from_archive(existing_archive, printer_id, logger)
return
# Build list of possible 3MF filenames to try
possible_names = []
# Bambu printers typically store files as "Name.gcode.3mf"
# The subtask_name is usually the best source for the filename
if subtask_name:
# Try common Bambu naming patterns
possible_names.append(f"{subtask_name}.gcode.3mf")
possible_names.append(f"{subtask_name}.3mf")
# Try original filename with .3mf extension
if filename:
# Extract just the filename part, not the full path
fname = filename.split("/")[-1] if "/" in filename else filename
if fname.endswith(".3mf"):
possible_names.append(fname)
elif fname.endswith(".gcode"):
base = fname.rsplit(".", 1)[0]
possible_names.append(f"{base}.gcode.3mf")
possible_names.append(f"{base}.3mf")
else:
possible_names.append(f"{fname}.gcode.3mf")
possible_names.append(f"{fname}.3mf")
# Also try with spaces converted to underscores (Bambu Studio may normalize filenames)
space_variants = []
for name in possible_names:
if " " in name:
space_variants.append(name.replace(" ", "_"))
possible_names.extend(space_variants)
# Remove duplicates while preserving order
seen = set()
possible_names = [x for x in possible_names if not (x in seen or seen.add(x))]
logger.info("Trying filenames: %s", possible_names)
# Release the pooled DB connection before the 3MF FTP download. Reaching
# here means none of the expected-/existing-archive write branches ran
# (they all return earlier) — only SELECTs have executed on this path, so
# this commit persists nothing; it ends the read transaction so the
# connection returns to the pool during the download. That download tries
# up to five remote paths per candidate filename with retry/backoff and
# can run for minutes under FTP contention; holding the session across it
# pinned one pooled connection idle-in-transaction (issue #2572). No DB
# work runs during the download — the new-archive writes below re-acquire
# a fresh connection, and expire_on_commit=False keeps printer.* readable.
await db.commit()
# Try to find and download the 3MF file
temp_path = None
downloaded_filename = None
# Cache check: cover endpoint may have already pulled this 3MF during
# the print (frontend opens the card and shows the thumbnail) — reuse
# that file instead of re-downloading 36MB over the same FTP link that
# just served it (#972). The cache keys on a normalized filename so
# variants like "X", "X.3mf", "X.gcode.3mf" all collapse to one entry.
for try_filename in possible_names:
if not try_filename.endswith(".3mf"):
continue
cached = get_cached_3mf(printer_id, try_filename)
if cached:
logger.info("Reusing cached 3MF from %s (avoided duplicate FTP)", cached)
temp_path = cached
downloaded_filename = try_filename
break
# Does this printer keep the sliced file somewhere FTPS can reach? On
# H2-series and P2S the answer is routinely no — the file stays on
# internal eMMC and port 990 only ever serves external storage — and
# then the whole sweep below (six filenames x five directories x four
# retries, then the directory walk) is ~110 connections that cannot
# succeed. Skip it and say why (#2780).
storage = print_file_reachable_over_ftp(printer_manager.get_status(printer_id))
if not storage.reachable and not downloaded_filename:
logger.info(
"Skipping the 3MF lookup for printer %s: %s — the print file is not on storage "
"Bambuddy can read over FTPS, so no path would find it",
printer_id,
storage.reason,
)
# Get FTP retry settings
ftp_retry_enabled, ftp_retry_count, ftp_retry_delay, ftp_timeout = await get_ftp_retry_settings()
for try_filename in possible_names if not downloaded_filename and storage.reachable else []:
if not try_filename.endswith(".3mf"):
continue
# Root (/) is where BambuStudio/OrcaSlicer uploads land on A1/P1-series
# printers, so try it first — deferring it to last cost #972's reporter
# ~48 minutes of retries on /cache//model//data//data/Metadata before
# landing on the path that actually had the file.
remote_paths = [
f"/{try_filename}",
f"/cache/{try_filename}",
f"/model/{try_filename}",
f"/data/{try_filename}",
f"/data/Metadata/{try_filename}",
]
temp_path = app_settings.archive_dir / "temp" / try_filename
temp_path.parent.mkdir(parents=True, exist_ok=True)
for remote_path in remote_paths:
if ftps_handshake_blocked(printer.ip_address):
# The printer's FTPS service is not completing a TLS
# handshake, so it has no path we could reach — walking the
# remaining candidates only re-runs the same failure
# (#2780). Fall through to the no-3MF archive now.
logger.warning(
"Giving up on the 3MF for printer %s: its file service is not answering over TLS",
printer_id,
)
break
logger.debug("Trying FTP download: %s", remote_path)
try:
if ftp_retry_enabled:
downloaded = await with_ftp_retry(
download_file_async,
printer.ip_address,
printer.access_code,
remote_path,
temp_path,
timeout=ftp_timeout,
socket_timeout=ftp_timeout,
printer_model=printer.model,
max_retries=ftp_retry_count,
retry_delay=ftp_retry_delay,
operation_name=f"Download 3MF from {remote_path}",
non_retry_exceptions=(FileNotOnPrinterError,),
)
else:
downloaded = await download_file_async(
printer.ip_address,
printer.access_code,
remote_path,
temp_path,
timeout=ftp_timeout,
socket_timeout=ftp_timeout,
printer_model=printer.model,
)
if downloaded:
downloaded_filename = try_filename
logger.info("Downloaded: %s", remote_path)
# Populate shared cache so the cover endpoint (if it
# runs next) doesn't refetch the same 36MB over FTP.
cache_3mf_download(printer_id, try_filename, temp_path)
break
except FileNotOnPrinterError:
# 550 — file isn't at this path. Advance to next candidate
# without burning the retry budget.
logger.debug("3MF not at %s (550), trying next path", remote_path)
except Exception as e:
logger.debug("FTP download failed for %s: %s", remote_path, e)
if downloaded_filename or ftps_handshake_blocked(printer.ip_address):
break
# If still not found, try listing directories to find matching file
# Different printer models use different directory structures. Skipped
# when the printer's FTPS handshake is failing — the directory walk is
# five more connections that cannot get further than the download did.
if (
not downloaded_filename
and storage.reachable
and (filename or subtask_name)
and not ftps_handshake_blocked(printer.ip_address)
):
search_term = (subtask_name or filename).lower().replace(".gcode", "").replace(".3mf", "")
logger.info("Direct FTP download failed, searching directories for '%s'", search_term)
search_dirs = ["/cache", "/model", "/data", "/data/Metadata", "/"]
for search_dir in search_dirs:
if downloaded_filename:
break
try:
dir_files = await list_files_async(
printer.ip_address, printer.access_code, search_dir, printer_model=printer.model
)
threemf_files = [f.get("name") for f in dir_files if f.get("name", "").endswith(".3mf")]
if threemf_files:
logger.info(
f"Found {len(threemf_files)} 3MF files in {search_dir}: {threemf_files[:5]}{'...' if len(threemf_files) > 5 else ''}"
)
for f in dir_files:
if f.get("is_directory"):
continue
fname = f.get("name", "")
# Normalize both for comparison (spaces and underscores are equivalent)
fname_normalized = fname.lower().replace(" ", "_")
search_normalized = search_term.replace(" ", "_")
if fname.endswith(".3mf") and search_normalized in fname_normalized:
logger.info("Found matching file in %s: %s", search_dir, fname)
temp_path = app_settings.archive_dir / "temp" / fname
temp_path.parent.mkdir(parents=True, exist_ok=True)
remote_full_path = posixpath.join(search_dir, fname)
if ftp_retry_enabled:
downloaded = await with_ftp_retry(
download_file_async,
printer.ip_address,
printer.access_code,
remote_full_path,
temp_path,
timeout=ftp_timeout,
socket_timeout=ftp_timeout,
printer_model=printer.model,
max_retries=ftp_retry_count,
retry_delay=ftp_retry_delay,
operation_name=f"Download 3MF from {remote_full_path}",
)
else:
downloaded = await download_file_async(
printer.ip_address,
printer.access_code,
remote_full_path,
temp_path,
timeout=ftp_timeout,
socket_timeout=ftp_timeout,
printer_model=printer.model,
)
if downloaded:
downloaded_filename = fname
logger.info("Found and downloaded from %s: %s", search_dir, fname)
cache_3mf_download(printer_id, fname, temp_path)
break
except Exception as e:
logger.debug("Failed to list %s: %s", search_dir, e)
# Validate the downloaded 3MF actually matches the plate that's running
# (#1204): subtask_name lags across consecutive plates of the same model,
# so the first FTP candidate (built from subtask_name) can land on the
# previous plate's still-resident upload. Cross-check the slice_info
# plate index against the plate parsed from gcode_file (always fresh —
# it's the field whose change triggered this callback).
if downloaded_filename and temp_path:
expected_plate = parse_plate_id(filename)
actual_plate = peek_plate_index_in_3mf(temp_path) if expected_plate is not None else None
if expected_plate is not None and actual_plate is not None and actual_plate != expected_plate:
logger.warning(
"[CALLBACK] 3MF plate mismatch: downloaded %s reports plate %s but printer is "
"running plate %s — subtask_name=%r appears stale, retrying with corrected name",
downloaded_filename,
actual_plate,
expected_plate,
subtask_name,
)
corrected_subtask = swap_plate_suffix(subtask_name, expected_plate)
retry_succeeded = False
if corrected_subtask and corrected_subtask != subtask_name:
for try_filename in (f"{corrected_subtask}.gcode.3mf", f"{corrected_subtask}.3mf"):
retry_temp_path = app_settings.archive_dir / "temp" / try_filename
retry_temp_path.parent.mkdir(parents=True, exist_ok=True)
for remote_path in (
f"/{try_filename}",
f"/cache/{try_filename}",
f"/model/{try_filename}",
f"/data/{try_filename}",
f"/data/Metadata/{try_filename}",
):
try:
if ftp_retry_enabled:
downloaded = await with_ftp_retry(
download_file_async,
printer.ip_address,
printer.access_code,
remote_path,
retry_temp_path,
timeout=ftp_timeout,
socket_timeout=ftp_timeout,
printer_model=printer.model,
max_retries=ftp_retry_count,
retry_delay=ftp_retry_delay,
operation_name=f"Re-download 3MF from {remote_path}",
non_retry_exceptions=(FileNotOnPrinterError,),
)
else:
downloaded = await download_file_async(
printer.ip_address,
printer.access_code,
remote_path,
retry_temp_path,
timeout=ftp_timeout,
socket_timeout=ftp_timeout,
printer_model=printer.model,
)
if downloaded and peek_plate_index_in_3mf(retry_temp_path) == expected_plate:
logger.info(
"[CALLBACK] Re-download succeeded with corrected name %s "
"(plate %s) — replacing wrong file",
try_filename,
expected_plate,
)
try:
temp_path.unlink(missing_ok=True)
except OSError:
pass
temp_path = retry_temp_path
downloaded_filename = try_filename
subtask_name = corrected_subtask
cache_3mf_download(printer_id, try_filename, temp_path)
retry_succeeded = True
break
elif downloaded:
# Wrong plate again — discard and keep trying
try:
retry_temp_path.unlink(missing_ok=True)
except OSError:
pass
except FileNotOnPrinterError:
continue
except Exception as e:
logger.debug("Re-download failed for %s: %s", remote_path, e)
if retry_succeeded:
break
# If the retry didn't find a matching file, drop the wrong 3MF
# so the no-3MF fallback below creates an archive whose name
# at least reflects the right plate.
if not retry_succeeded:
logger.warning(
"[CALLBACK] Could not re-download correct plate %s — falling back to no-3MF archive",
expected_plate,
)
try:
temp_path.unlink(missing_ok=True)
except OSError:
pass
temp_path = None
downloaded_filename = None
# Override the stale subtask_name so the fallback archive's
# print_name reflects the correct plate. Prefer the swapped
# name when we have one; otherwise let filename win.
if corrected_subtask:
subtask_name = corrected_subtask
else:
subtask_name = ""
if not downloaded_filename or not temp_path:
logger.warning("Could not find 3MF file for print: %s", filename or subtask_name)
# Create a fallback archive without 3MF data so the print is still tracked
# This commonly happens with P1S/A1 printers where FTP has file size limitations
try:
from backend.app.models.archive import PrintArchive
# Derive print name from subtask_name or filename
print_name = subtask_name or filename
if print_name:
# Clean up the name (remove extensions, path parts)
print_name = print_name.split("/")[-1]
print_name = print_name.replace(".gcode.3mf", "").replace(".gcode", "").replace(".3mf", "")
else:
print_name = "Unknown Print"
# Recover estimated print time from MQTT (best-effort for notifications)
fallback_print_time = None
mqtt_remaining = data.get("remaining_time")
if mqtt_remaining and isinstance(mqtt_remaining, (int, float)) and mqtt_remaining > 0:
fallback_print_time = int(mqtt_remaining)
if fallback_print_time is None:
mc_remaining = (data.get("raw_data") or {}).get("mc_remaining_time")
if mc_remaining and isinstance(mc_remaining, (int, float)) and mc_remaining > 0:
fallback_print_time = int(mc_remaining * 60)
# Best-effort filament metadata from MQTT — see
# _extract_filament_data_from_mqtt. Without this the fallback
# archive's filament fields stayed NULL even though the AMS
# state at print start was sitting right there in `data`.
# The slicer's ams_mapping (when present) narrows the result
# to slots actually used by the print (#1533).
mqtt_filament_meta = _extract_filament_data_from_mqtt(data, _get_start_ams_mapping(data, None))
# Create minimal archive entry
fallback_archive = PrintArchive(
printer_id=printer_id,
filename=filename or f"{print_name}.3mf",
file_path="", # Empty - no 3MF file available
file_size=0,
print_name=print_name,
print_time_seconds=fallback_print_time,
status="printing",
started_at=datetime.now(timezone.utc),
subtask_id=subtask_id,
filament_type=mqtt_filament_meta.get("filament_type"),
filament_color=mqtt_filament_meta.get("filament_color"),
extra_data={
"no_3mf_available": True,
# Why the card is empty, when we know. The banner reads
# this to stop telling H2/P2 owners to switch on a
# setting that is already on and would not help (#2780).
"no_3mf_reason": storage.reason,
"original_subtask": subtask_name,
"_print_data": data,
},
)
db.add(fallback_archive)
await db.commit()
await db.refresh(fallback_archive)
logger.info("Created fallback archive %s for %s (no 3MF available)", fallback_archive.id, print_name)
_maybe_start_layer_timelapse(printer, printer_id, fallback_archive.id)
# Track as active print
_active_prints[(printer_id, fallback_archive.filename)] = fallback_archive.id
if filename:
_active_prints[(printer_id, filename)] = fallback_archive.id
if subtask_name:
_active_prints[(printer_id, f"{subtask_name}.3mf")] = fallback_archive.id
_active_prints[(printer_id, subtask_name)] = fallback_archive.id
# Record starting energy if smart plug available (#941: persisted column)
await _record_energy_start(fallback_archive, printer_id, db, context="fallback")
# Send WebSocket notification
await ws_manager.send_archive_created(
{
"id": fallback_archive.id,
"printer_id": fallback_archive.printer_id,
"filename": fallback_archive.filename,
"print_name": fallback_archive.print_name,
"status": fallback_archive.status,
}
)
# MQTT relay - publish archive created
try:
await mqtt_relay.on_archive_created(
archive_id=fallback_archive.id,
print_name=fallback_archive.print_name,
printer_name=printer.name,
status=fallback_archive.status,
)
except Exception:
pass # Don't fail if MQTT fails
# Store Spoolman tracking data (may not work for fallback since no 3MF)
try:
await _store_spoolman_print_data(
printer_id,
fallback_archive.id,
fallback_archive.file_path,
db,
printer_manager,
ams_mapping=_get_start_ams_mapping(data, fallback_archive.id),
plate_id=_get_start_plate_id(fallback_archive.id),
)
except Exception as e:
logger.debug("[SPOOLMAN] Could not store tracking for fallback archive: %s", e)
# Send notification without archive data (file not found)
if not notification_sent:
await _send_print_start_notification(printer_id, data, logger=logger)
return
except Exception as e:
logger.error("Failed to create fallback archive: %s", e)
# Send notification without archive data (file not found)
if not notification_sent:
await _send_print_start_notification(printer_id, data, logger=logger)
return
try:
# Archive the file with status "printing"
service = ArchiveService(db)
archive = await service.archive_print(
printer_id=printer_id,
source_file=temp_path,
print_data={**data, "status": "printing"},
subtask_id=subtask_id,
)
if archive:
# Track this active print (use both original filename and downloaded filename)
_active_prints[(printer_id, downloaded_filename)] = archive.id
if filename and filename != downloaded_filename:
_active_prints[(printer_id, filename)] = archive.id
if subtask_name:
_active_prints[(printer_id, f"{subtask_name}.3mf")] = archive.id
logger.info("Created archive %s for %s", archive.id, downloaded_filename)
_maybe_start_layer_timelapse(printer, printer_id, archive.id)
# Record starting energy from smart plug if available (#941: persisted column)
await _record_energy_start(archive, printer_id, db, context="auto-archive")
await ws_manager.send_archive_created(
{
"id": archive.id,
"printer_id": archive.printer_id,
"filename": archive.filename,
"print_name": archive.print_name,
"status": archive.status,
}
)
# MQTT relay - publish archive created
try:
await mqtt_relay.on_archive_created(
archive_id=archive.id,
print_name=archive.print_name,
printer_name=printer.name,
status=archive.status,
)
except Exception:
pass # Don't fail if MQTT fails
# Send notification with archive data (new archive created)
if not notification_sent:
archive_data = {
"print_time_seconds": archive.print_time_seconds,
"created_by_id": archive.created_by_id,
}
await _send_print_start_notification(printer_id, data, archive_data, logger)
# Extract printable objects for skip object functionality
try:
from backend.app.services.archive import extract_printable_objects_from_3mf
client = printer_manager.get_client(printer_id)
if client:
with open(temp_path, "rb") as f:
threemf_data = f.read()
# Extract with positions for UI overlay, scoped to the
# plate that is printing — an all-plates 3MF carries
# every plate's objects (#2522).
printable_objects, bbox_all = extract_printable_objects_from_3mf(
threemf_data,
plate_number=resolve_plate_id(client.state),
include_positions=True,
)
if printable_objects:
# Store objects in printer state
client.state.printable_objects = printable_objects
client.state.printable_objects_bbox_all = bbox_all
client.state.skipped_objects = [] # Reset skipped objects for new print
logger.info(
"Loaded %s printable objects for printer %s", len(printable_objects), printer_id
)
except Exception as e:
logger.debug("Failed to extract printable objects: %s", e)
# Store Spoolman tracking data for per-filament usage reporting
try:
await _store_spoolman_print_data(
printer_id,
archive.id,
archive.file_path,
db,
printer_manager,
ams_mapping=_get_start_ams_mapping(data, archive.id),
plate_id=_get_start_plate_id(archive.id),
)
except Exception as e:
logger.warning("[SPOOLMAN] Failed to store tracking data: %s", e)
# Capture timelapse file baseline for snapshot-diff on completion
await _capture_timelapse_baseline_at_start(printer, printer_id, logger, archive_id=archive.id)
finally:
# Keep temp_path around until print completes so the cover endpoint
# can reuse it (#972). Cache eviction in on_print_complete deletes
# the file. If the cache entry was evicted early (file vanished),
# clean up any stragglers here to avoid leaking disk on retries.
cached_now = get_cached_3mf(printer_id, downloaded_filename) if downloaded_filename else None
if temp_path and temp_path.exists() and cached_now != temp_path:
temp_path.unlink()
_TIMELAPSE_VIDEO_EXTENSIONS = (".mp4", ".avi")
# Poll schedule for the post-print timelapse scan (#2704). Module-level so
# tests can shrink them without waiting out real delays.
#
# This replaced a fixed [5, 10, 20, 30] retry ladder, i.e. roughly 65 s of
# looking. Across 247 support bundles the attempt that found the video was #1
# 272 times, then 17 / 13 / 13 — a flat tail against the cutoff rather than a
# decaying one, which is the signature of a budget that expires while files are
# still arriving. 457 scans were scheduled and only 262 ever attached. Big
# prints make big videos and the printer writes them after the print ends, so
# the poll now runs for minutes and costs one FTP LIST per round.
_TIMELAPSE_SCAN_FIRST_DELAY_SECONDS: float = 5.0
_TIMELAPSE_SCAN_POLL_INTERVAL_SECONDS: float = 30.0
_TIMELAPSE_SCAN_TIMEOUT_SECONDS: float = 900.0
def _timelapse_scan_max_attempts() -> int:
"""Round cap for the poll, derived from the wall-clock budget.
The deadline alone is not a sufficient bound: it assumes each round really
waits, which stops being true the moment ``asyncio.sleep`` is patched out,
and an FTP list that fails immediately would otherwise spin against the
printer at full speed for the whole window. Whichever bound is reached
first ends the poll.
"""
if _TIMELAPSE_SCAN_POLL_INTERVAL_SECONDS <= 0:
# A zero interval makes the wall-clock budget meaningless; fall back to
# the round count the production interval would have given.
return 32
return max(1, int(_TIMELAPSE_SCAN_TIMEOUT_SECONDS // _TIMELAPSE_SCAN_POLL_INTERVAL_SECONDS) + 1)
async def _claimed_timelapse_names(db, printer_id: int, exclude_archive_id: int) -> set[str]:
"""Video filenames already attached to some other archive of this printer.
Used to disambiguate when more than one file is new since the baseline —
which happens when a previous print's video landed after this print's
baseline was taken. Ordering the candidates would be the obvious fix and is
the wrong one: it can only be done on mtime or on the filename timestamp,
both of which come from the printer's own clock, and a LAN-only printer
can't reach Bambu's NTP server. Exclusion needs no clock at all.
``attach_timelapse`` saves the video into the archive directory under the
printer's original filename, and the later MP4 conversion keeps the stem,
so the stem of ``timelapse_path`` recovers what was claimed.
"""
from backend.app.models.archive import PrintArchive
rows = await db.execute(
select(PrintArchive.timelapse_path).where(
PrintArchive.printer_id == printer_id,
PrintArchive.id != exclude_archive_id,
PrintArchive.timelapse_path.is_not(None),
)
)
return {Path(p).stem for p in rows.scalars().all() if p}
async def _list_timelapse_videos(printer) -> tuple[list[dict], str | None]:
"""List video files from printer's timelapse directory.
Finds MP4 (X1/A1 series) and AVI (P1 series) timelapse files.
Returns (video_files, found_path) where video_files is a list of file dicts
and found_path is the directory where they were found, or ([], None).
"""
from backend.app.services.bambu_ftp import list_files_async
logger = logging.getLogger(__name__)
# No card in the slot means no /timelapse to walk — four connections that
# can only fail, on a path whose failures are swallowed and so would go on
# costing time silently forever (#2780).
#
# ``getattr`` rather than ``printer.id``: every dereference below happens
# inside the loop's own try/except, so a caller that passed something
# unexpected used to get an empty listing rather than an exception. Keep
# that, instead of making this gate the first thing that can raise here.
printer_id = getattr(printer, "id", None)
if printer_id is not None and not external_storage_present(printer_manager.get_status(printer_id)):
logger.debug("[TIMELAPSE] Skipping the scan for printer %s: it reports no external storage", printer_id)
return [], None
for timelapse_path in ["/timelapse", "/timelapse/video", "/record", "/recording"]:
try:
found_files = await list_files_async(
printer.ip_address, printer.access_code, timelapse_path, printer_model=printer.model
)
if found_files:
video_files = [
f
for f in found_files
if not f.get("is_directory") and f.get("name", "").lower().endswith(_TIMELAPSE_VIDEO_EXTENSIONS)
]
if video_files:
return video_files, timelapse_path
except Exception as e:
logger.debug("[TIMELAPSE] Path %s failed: %s", timelapse_path, e)
continue
return [], None
async def _capture_timelapse_baseline_at_start(
printer, printer_id: int, logger: logging.Logger, archive_id: int | None = None
) -> None:
"""Snapshot the printer's timelapse directory at print start so the
completion-time scan can pick the new file by set-difference.
Must be called from every on_print_start path that proceeds to a real
print — both the new-archive branch and the expected-archive branch (which
queue / VP-dispatched prints take). Without a baseline,
_scan_for_timelapse_with_retries falls into its "take baseline now"
fallback that runs AFTER the new MP4 has already landed on the SD card,
so the new file ends up in the "baseline" set and no diff ever matches.
Bambu printers in LAN-only mode don't sync NTP, so mtime ordering is
unreliable — the snapshot-diff approach sidesteps that entirely.
When ``archive_id`` is known the baseline is also written to the archive
row, so it survives a restart and the manual "Scan for Timelapse" button
can run the same diff instead of falling back to clock-based matching
(#2704). Only baselines taken at print start are persisted — one taken at
completion already contains the new video and would poison a later scan.
"""
names: set[str] | None = None
try:
baseline_files, _ = await _list_timelapse_videos(printer)
names = {f.get("name", "") for f in baseline_files}
_timelapse_baselines[printer_id] = names
logger.info(
"[TIMELAPSE] Baseline at print start: %s video files for printer %s",
len(names),
printer_id,
)
except Exception as e:
logger.warning("[TIMELAPSE] Failed to capture baseline at print start: %s", e)
if archive_id is None:
return
try:
async with async_session() as db:
from backend.app.models.archive import PrintArchive
archive = await db.get(PrintArchive, archive_id)
if archive is not None:
# Written even when the listing failed, and then as NULL. A
# reprint reuses the archive row, so leaving the previous run's
# baseline in place would have the scan diff this print against
# the state of the printer before the *last* one — and a stale
# baseline reads as authoritative, where NULL correctly falls
# back to a fresh snapshot.
archive.timelapse_baseline = sorted(names) if names is not None else None
await db.commit()
except Exception as e:
# In-memory baseline still covers the normal completion path.
logger.warning("[TIMELAPSE] Failed to persist baseline for archive %s: %s", archive_id, e)
async def _scan_for_timelapse_with_retries(archive_id: int, baseline_names: set[str] | None = None):
"""Poll the printer for this print's timelapse and attach it.
Snapshot diff, not timestamp matching: a printer in LAN-only mode cannot
reach Bambu's NTP server, so the clock behind both the filename and the FTP
mtime is arbitrarily wrong — one reporter's P1S was six and a half days out
(#2704). Comparing the current listing against the set of filenames that
existed when the print started needs no clock at all, because the printer
writes the video only once the print has ended.
Baseline precedence: the caller's in-memory set, then the one persisted on
the archive at print start, then a snapshot taken now. The last of those is
a poor substitute — by completion the new video may already be on the card,
in which case it lands in the "baseline" and no diff can ever match — but it
is all that is available for a print that began before Bambuddy started.
On success the video is deleted from the printer, which keeps ``/timelapse``
down to the unclaimed files and makes the next diff unambiguous.
"""
logger = logging.getLogger(__name__)
# --- Phase 1: establish the baseline -------------------------------------
try:
async with async_session() as db:
from backend.app.models.printer import Printer
service = ArchiveService(db)
archive = await service.get_archive(archive_id)
if not archive:
logger.warning("[TIMELAPSE] Archive %s not found, aborting", archive_id)
return
if archive.timelapse_path:
logger.info("[TIMELAPSE] Archive %s already has timelapse attached", archive_id)
return
if not archive.printer_id:
logger.warning("[TIMELAPSE] Archive %s has no printer, aborting", archive_id)
return
if baseline_names is not None:
logger.info(
"[TIMELAPSE] Using print-start baseline: %s existing video files for archive %s",
len(baseline_names),
archive_id,
)
elif archive.timelapse_baseline is not None:
# Persisted at print start — survives a restart mid-print.
baseline_names = set(archive.timelapse_baseline)
logger.info(
"[TIMELAPSE] Using stored baseline: %s existing video files for archive %s",
len(baseline_names),
archive_id,
)
else:
result = await db.execute(select(Printer).where(Printer.id == archive.printer_id))
printer = result.scalar_one_or_none()
if not printer:
logger.warning("[TIMELAPSE] Printer not found for archive %s, aborting", archive_id)
return
baseline_files, _ = await _list_timelapse_videos(printer)
baseline_names = {f.get("name", "") for f in baseline_files}
logger.info(
"[TIMELAPSE] Baseline snapshot (fallback): %s existing video files for archive %s",
len(baseline_names),
archive_id,
)
except Exception as e:
logger.warning("[TIMELAPSE] Failed to take baseline snapshot for archive %s: %s", archive_id, e)
return
# --- Phase 2: poll for a file that was not there when the print began -----
deadline = time.monotonic() + _TIMELAPSE_SCAN_TIMEOUT_SECONDS
max_attempts = _timelapse_scan_max_attempts()
seen_names: set[str] = set()
delay = _TIMELAPSE_SCAN_FIRST_DELAY_SECONDS
attempt = 0
while True:
await asyncio.sleep(delay)
delay = _TIMELAPSE_SCAN_POLL_INTERVAL_SECONDS
attempt += 1
try:
from backend.app.models.printer import Printer
# Read phase: fetch archive + printer in a short session and release
# the pooled connection BEFORE the FTP list/download below. Holding it
# across the FTP round-trips left one connection idle-in-transaction per
# in-flight scan (issue #2572).
async with async_session() as db:
service = ArchiveService(db)
archive = await service.get_archive(archive_id)
if not archive:
logger.warning("[TIMELAPSE] Archive %s not found, stopping poll", archive_id)
return
if archive.timelapse_path:
logger.info("[TIMELAPSE] Archive %s already has timelapse attached, stopping poll", archive_id)
return
result = await db.execute(select(Printer).where(Printer.id == archive.printer_id))
printer = result.scalar_one_or_none()
if not printer:
logger.warning("[TIMELAPSE] Printer not found for archive %s, stopping poll", archive_id)
return
claimed = await _claimed_timelapse_names(db, archive.printer_id, archive_id)
# I/O phase (no DB connection held): FTP list + download.
video_files, found_path = await _list_timelapse_videos(printer)
# The poll can run for dozens of rounds, so only narrate a round
# that saw something change. Repeating the whole listing every 30 s
# would bury the one interesting line in the support bundle.
names_now = {f.get("name", "") for f in video_files}
changed = attempt == 1 or names_now != seen_names
seen_names = names_now
speak = logger.info if changed else logger.debug
if video_files:
speak("[TIMELAPSE] Attempt %s: Found %s video files in %s", attempt, len(video_files), found_path)
if changed:
for f in video_files[:5]:
logger.info("[TIMELAPSE] - %s", f.get("name"))
attached = await _attach_first_unclaimed_timelapse(
archive_id, printer, video_files, baseline_names, claimed, attempt, logger, quiet=not changed
)
if attached:
return
else:
speak("[TIMELAPSE] Attempt %s: No video files found, will retry", attempt)
except Exception as e:
logger.warning("[TIMELAPSE] Attempt %s failed with error: %s", attempt, e)
if attempt >= max_attempts or time.monotonic() >= deadline:
break
# No name-match fallback: it compared the print name against the filename,
# and Bambu firmware only ever writes "video_