wled.py 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400
  1. """Optional per-printer WLED preset integration."""
  2. import asyncio
  3. import logging
  4. import time
  5. from dataclasses import dataclass
  6. import httpx
  7. from backend.app.core.tasks import spawn_background_task
  8. from backend.app.schemas.printer import WLEDConfig
  9. from backend.app.services import plate_clear
  10. from backend.app.services.bambu_mqtt import PrinterState
  11. from backend.app.services.hms_errors import hms_fault_counts
  12. logger = logging.getLogger(__name__)
  13. # While WLED does not answer, the same preset is retried at most this often
  14. # instead of on every printer status update.
  15. WLED_RETRY_SECONDS = 30.0
  16. class WLEDResponseError(ValueError):
  17. """WLED returned JSON that does not match the expected API shape."""
  18. def effective_wled_status(
  19. state: PrinterState, *, awaiting_plate_clear: bool = False, require_plate_clear: bool = False
  20. ) -> str | None:
  21. """Map Bambuddy's existing printer state to a WLED mapping key."""
  22. statuses = _applicable_wled_statuses(
  23. state, awaiting_plate_clear=awaiting_plate_clear, require_plate_clear=require_plate_clear
  24. )
  25. return statuses[0] if statuses else None
  26. def _applicable_wled_statuses(
  27. state: PrinterState, *, awaiting_plate_clear: bool = False, require_plate_clear: bool = False
  28. ) -> list[str]:
  29. """Return applicable states in priority order for mapped-preset fallback."""
  30. if not state.connected:
  31. return ["offline"]
  32. printer_state = (state.state or "").upper()
  33. statuses = []
  34. if printer_state == "PAUSE" and state.stg_cur == 6:
  35. statuses.append("filament_problem")
  36. if any(hms_fault_counts(error) for error in state.hms_errors):
  37. statuses.append("hms_error")
  38. if require_plate_clear and awaiting_plate_clear and printer_state in {"IDLE", "FINISH", "FAILED"}:
  39. statuses.append("queue_waiting")
  40. if printer_state == "FAILED":
  41. statuses.append("error")
  42. elif printer_state == "PAUSE":
  43. statuses.append("paused")
  44. elif printer_state == "FINISH":
  45. statuses.append("finished")
  46. elif printer_state in {"RUNNING", "PRINTING"}:
  47. statuses.append("printing")
  48. elif printer_state in {"PREPARE", "SLICING"}:
  49. statuses.append("prepare")
  50. elif printer_state == "IDLE":
  51. statuses.append("idle")
  52. return statuses
  53. @dataclass
  54. class _WLEDRuntime:
  55. status: str | None = None
  56. preset_id: int | None = None
  57. target: tuple[str | None, int | None] | None = None
  58. generation: int = 0
  59. confirmed_generation: int | None = None
  60. finished_timeout_expired: bool = False
  61. # Monotonic time before which a failed send is not retried, and whether
  62. # the last automatic send failed (so an outage logs once, not per retry).
  63. retry_after: float = 0.0
  64. unreachable: bool = False
  65. send_task: asyncio.Task | None = None
  66. finished_task: asyncio.Task | None = None
  67. class WLEDManager:
  68. """Own WLED HTTP calls, per-printer deduplication, and finished timers."""
  69. def __init__(self, client: httpx.AsyncClient | None = None):
  70. self._client = client
  71. self._owns_client = client is None
  72. self.require_plate_clear = False
  73. self.retry_seconds = WLED_RETRY_SECONDS
  74. self._configs: dict[int, WLEDConfig] = {}
  75. self._runtime: dict[int, _WLEDRuntime] = {}
  76. @property
  77. def client(self) -> httpx.AsyncClient:
  78. if self._client is None:
  79. self._client = httpx.AsyncClient(
  80. timeout=httpx.Timeout(3.0, connect=2.0),
  81. follow_redirects=False,
  82. )
  83. return self._client
  84. def configure_printer(self, printer_id: int, config: dict | WLEDConfig | None) -> None:
  85. self._cancel_runtime(printer_id, remove=True)
  86. try:
  87. self._configs[printer_id] = WLEDConfig.model_validate(config or {})
  88. except ValueError:
  89. self._configs[printer_id] = WLEDConfig()
  90. logger.warning("Ignoring invalid WLED configuration for printer %d", printer_id)
  91. def remove_printer(self, printer_id: int) -> None:
  92. self._configs.pop(printer_id, None)
  93. self._cancel_runtime(printer_id, remove=True)
  94. def handle_status(
  95. self,
  96. printer_id: int,
  97. state: PrinterState,
  98. *,
  99. awaiting_plate_clear: bool = False,
  100. ) -> None:
  101. """Schedule any needed WLED work without delaying printer handling."""
  102. config = self._configs.get(printer_id)
  103. if not config or not config.enabled or not config.base_url:
  104. self._cancel_runtime(printer_id)
  105. return
  106. status = next(
  107. (
  108. candidate
  109. for candidate in _applicable_wled_statuses(
  110. state,
  111. awaiting_plate_clear=awaiting_plate_clear,
  112. # The printer's own setting, or the app's (#2860)
  113. require_plate_clear=plate_clear.applies(printer_id, self.require_plate_clear),
  114. )
  115. if getattr(config.presets, candidate) is not None
  116. ),
  117. None,
  118. )
  119. preset_id = getattr(config.presets, status, None) if status else None
  120. if state.connected and (state.state or "").upper() in {"PREPARE", "SLICING", "RUNNING", "PRINTING"}:
  121. self._runtime.setdefault(printer_id, _WLEDRuntime()).finished_timeout_expired = False
  122. self._apply_status(printer_id, config, status, preset_id)
  123. def handle_offline(self, printer_id: int) -> None:
  124. """Apply the offline mapping for an explicit printer lifecycle transition."""
  125. config = self._configs.get(printer_id)
  126. if not config or not config.enabled or not config.base_url:
  127. return
  128. preset_id = config.presets.offline
  129. self._apply_status(printer_id, config, "offline" if preset_id is not None else None, preset_id)
  130. def _apply_status(self, printer_id: int, config: WLEDConfig, status: str | None, preset_id: int | None) -> None:
  131. base_url = config.base_url
  132. if not base_url:
  133. return
  134. idle_preset_id = config.presets.idle
  135. runtime = self._runtime.setdefault(printer_id, _WLEDRuntime())
  136. expired_finished = runtime.finished_timeout_expired and status == "finished" and idle_preset_id is not None
  137. target = (status, preset_id)
  138. if runtime.target == target:
  139. if expired_finished:
  140. if runtime.finished_task is not None and not runtime.finished_task.done():
  141. return
  142. elif (
  143. preset_id is None
  144. or runtime.confirmed_generation == runtime.generation
  145. or (runtime.send_task is not None and not runtime.send_task.done())
  146. ):
  147. return
  148. if time.monotonic() < runtime.retry_after:
  149. return
  150. else:
  151. runtime.generation += 1
  152. self._cancel_task(runtime.finished_task)
  153. runtime.finished_task = None
  154. self._cancel_task(runtime.send_task)
  155. runtime.target = target
  156. generation = runtime.generation
  157. if expired_finished and idle_preset_id is not None:
  158. if runtime.status == "idle" and runtime.preset_id == idle_preset_id:
  159. return
  160. runtime.finished_task = spawn_background_task(
  161. self._send_finished_idle(printer_id, generation, base_url, idle_preset_id),
  162. name=f"wled-finished-idle-{printer_id}",
  163. )
  164. return
  165. if preset_id is not None:
  166. runtime.send_task = spawn_background_task(
  167. self._send_status(printer_id, base_url, status, preset_id, generation),
  168. name=f"wled-preset-{printer_id}",
  169. )
  170. if (
  171. status == "finished"
  172. and config.finished_timeout_seconds
  173. and idle_preset_id is not None
  174. and runtime.finished_task is None
  175. ):
  176. runtime.finished_task = spawn_background_task(
  177. self._finish_timeout(
  178. printer_id,
  179. generation,
  180. base_url,
  181. idle_preset_id,
  182. config.finished_timeout_seconds,
  183. ),
  184. name=f"wled-finished-timeout-{printer_id}",
  185. )
  186. async def _send_status(
  187. self, printer_id: int, base_url: str, status: str | None, preset_id: int, generation: int
  188. ) -> None:
  189. ok = await self._send_automatic(printer_id, base_url, preset_id, status)
  190. if ok:
  191. runtime = self._runtime.get(printer_id)
  192. if (
  193. runtime
  194. and runtime.generation == generation
  195. and runtime.target == (status, preset_id)
  196. and runtime.send_task is asyncio.current_task()
  197. ):
  198. runtime.status = status
  199. runtime.preset_id = preset_id
  200. runtime.confirmed_generation = generation
  201. async def _send_finished_idle(self, printer_id: int, generation: int, base_url: str, idle_preset_id: int) -> None:
  202. if await self._send_automatic(printer_id, base_url, idle_preset_id, "idle"):
  203. runtime = self._runtime.get(printer_id)
  204. if (
  205. runtime
  206. and runtime.generation == generation
  207. and runtime.finished_timeout_expired
  208. and runtime.target
  209. and runtime.target[0] == "finished"
  210. ):
  211. runtime.status = "idle"
  212. runtime.preset_id = idle_preset_id
  213. runtime.confirmed_generation = generation
  214. async def _send_automatic(self, printer_id: int, base_url: str, preset_id: int, status: str | None) -> bool:
  215. """Send a mapped preset; on failure hold retries back and log once per outage."""
  216. runtime = self._runtime.get(printer_id)
  217. quiet = runtime is not None and runtime.unreachable
  218. ok = await self.send_preset(printer_id, base_url, preset_id, status=status, quiet=quiet)
  219. if runtime is None or self._runtime.get(printer_id) is not runtime:
  220. return ok
  221. if ok:
  222. runtime.retry_after = 0.0
  223. if runtime.unreachable:
  224. runtime.unreachable = False
  225. logger.info("[WLED] Printer %d: WLED answers again", printer_id)
  226. else:
  227. runtime.retry_after = time.monotonic() + self.retry_seconds
  228. if not runtime.unreachable:
  229. runtime.unreachable = True
  230. logger.info(
  231. "[WLED] Printer %d: retrying every %ds until WLED answers", printer_id, int(self.retry_seconds)
  232. )
  233. return ok
  234. async def test_preset(self, printer_id: int, base_url: str, preset_id: int) -> bool:
  235. """Test a preset while forcing the next status update to restore automatic control."""
  236. self._invalidate_automatic(printer_id)
  237. try:
  238. return await self.send_preset(printer_id, base_url, preset_id)
  239. finally:
  240. self._invalidate_automatic(printer_id)
  241. def _invalidate_automatic(self, printer_id: int) -> None:
  242. runtime = self._runtime.get(printer_id)
  243. if runtime:
  244. self._cancel_task(runtime.send_task)
  245. runtime.send_task = None
  246. runtime.status = None
  247. runtime.preset_id = None
  248. runtime.confirmed_generation = None
  249. async def send_preset(
  250. self, printer_id: int, base_url: str, preset_id: int, *, status: str | None = None, quiet: bool = False
  251. ) -> bool:
  252. """Activate a preset. Failures are isolated from all printer work.
  253. ``quiet`` logs a failure at debug level: a retry during an outage that
  254. was already reported.
  255. """
  256. log_failure = logger.debug if quiet else logger.warning
  257. try:
  258. response = await self.client.post(f"{base_url}/json/state", json={"ps": preset_id})
  259. response.raise_for_status()
  260. if not isinstance(response.json(), dict):
  261. raise WLEDResponseError("state response must be a JSON object")
  262. logger.info("[WLED] Printer %d state=%s -> preset=%d", printer_id, status or "manual", preset_id)
  263. return True
  264. except asyncio.CancelledError:
  265. raise
  266. except httpx.HTTPStatusError as exc:
  267. log_failure(
  268. "[WLED] Printer %d state=%s -> preset=%d failed (HTTP %d)",
  269. printer_id,
  270. status or "manual",
  271. preset_id,
  272. exc.response.status_code,
  273. )
  274. except (httpx.HTTPError, ValueError):
  275. log_failure("[WLED] Printer %d state=%s -> preset=%d failed", printer_id, status or "manual", preset_id)
  276. return False
  277. async def list_presets(self, base_url: str) -> list[dict[str, int | str]]:
  278. """Return WLED preset names and IDs without modifying WLED state."""
  279. response = await self.client.get(f"{base_url}/presets.json")
  280. response.raise_for_status()
  281. try:
  282. payload = response.json()
  283. except ValueError as exc:
  284. raise WLEDResponseError("presets response is not valid JSON") from exc
  285. if not isinstance(payload, dict):
  286. raise WLEDResponseError("presets response must be a JSON object")
  287. presets = []
  288. for raw_id, value in payload.items():
  289. try:
  290. preset_id = int(raw_id)
  291. except (TypeError, ValueError):
  292. continue
  293. if not 1 <= preset_id <= 250 or not isinstance(value, dict):
  294. continue
  295. name = value.get("n")
  296. presets.append(
  297. {"id": preset_id, "name": name.strip() if isinstance(name, str) and name.strip() else str(preset_id)}
  298. )
  299. return sorted(presets, key=lambda item: int(item["id"]))
  300. async def get_info(self, base_url: str) -> dict[str, str | None]:
  301. """Return the optional name and version reported by WLED."""
  302. response = await self.client.get(f"{base_url}/json/info")
  303. response.raise_for_status()
  304. try:
  305. payload = response.json()
  306. except ValueError as exc:
  307. raise WLEDResponseError("info response is not valid JSON") from exc
  308. if not isinstance(payload, dict):
  309. raise WLEDResponseError("info response must be a JSON object")
  310. def clean(value) -> str | None:
  311. return value.strip() if isinstance(value, str) and value.strip() else None
  312. return {"name": clean(payload.get("name")), "version": clean(payload.get("ver"))}
  313. async def shutdown(self) -> None:
  314. tasks: list[asyncio.Task] = []
  315. for runtime in self._runtime.values():
  316. for task in (runtime.send_task, runtime.finished_task):
  317. if task and not task.done():
  318. task.cancel()
  319. tasks.append(task)
  320. if tasks:
  321. await asyncio.gather(*tasks, return_exceptions=True)
  322. self._runtime.clear()
  323. self._configs.clear()
  324. if self._owns_client and self._client is not None:
  325. await self._client.aclose()
  326. self._client = None
  327. async def _finish_timeout(
  328. self,
  329. printer_id: int,
  330. generation: int,
  331. base_url: str,
  332. idle_preset_id: int,
  333. timeout_seconds: int,
  334. ) -> None:
  335. try:
  336. await asyncio.sleep(timeout_seconds)
  337. runtime = self._runtime.get(printer_id)
  338. if not runtime or runtime.generation != generation or not runtime.target or runtime.target[0] != "finished":
  339. return
  340. runtime.finished_timeout_expired = True
  341. await self._send_finished_idle(printer_id, generation, base_url, idle_preset_id)
  342. except asyncio.CancelledError:
  343. return
  344. def _cancel_runtime(self, printer_id: int, *, remove: bool = False) -> None:
  345. runtime = self._runtime.get(printer_id)
  346. if runtime:
  347. runtime.generation += 1
  348. self._cancel_task(runtime.send_task)
  349. self._cancel_task(runtime.finished_task)
  350. if remove:
  351. self._runtime.pop(printer_id, None)
  352. @staticmethod
  353. def _cancel_task(task: asyncio.Task | None) -> None:
  354. if task and not task.done():
  355. task.cancel()
  356. wled_manager = WLEDManager()