pycentauri 0.6.0__tar.gz → 0.6.1__tar.gz

{pycentauri-0.6.0 → pycentauri-0.6.1}/CHANGELOG.md

@@ -6,6 +6,25 @@ Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.6.1] - 2026-07-05
+
+### Fixed
+- **CC2: the user's speed mode now survives Canvas filament switches.**
+  The firmware resets `speed_mode` to balanced on every mid-print
+  switch and leaves it there (verified 2026-07-05: mode stayed reset
+  after the switch completed). `CC2Printer` now snapshots the mode in
+  effect when a switch begins and re-applies it once printing resumes —
+  regardless of whether the mode was set via pycentauri or the
+  touchscreen. Requires `enable_control`; read-only sessions log the
+  reset instead. The restore baseline is debounced (a mode must hold
+  15 s to count) because the firmware fires its reset several seconds
+  *before* the head parks — without the debounce, that transient
+  poisoned the snapshot. Verified across two hands-free switch cycles
+  with journal-logged restores ~3 s after each resume.
+- `centauri server` now surfaces pycentauri's own log lines (speed-mode
+  restores, reconnects) in its output — previously only uvicorn's
+  loggers were configured and library INFO logs were invisible.
+
 ## [0.6.0] - 2026-07-05
 
 ### Added

{pycentauri-0.6.0 → pycentauri-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycentauri
-Version: 0.6.0
+Version: 0.6.1
 Summary: Local-network toolkit for Elegoo Centauri Carbon 3D printers: async Python client, CLI, MCP server, REST/SSE HTTP server, web UI, and RTSP bridge
 Project-URL: Homepage, https://github.com/bjan/pycentauri
 Project-URL: Repository, https://github.com/bjan/pycentauri
@@ -407,6 +407,10 @@ reports code 27 the entire time the head is parked there mid-print.
   cooldown of a few seconds during which the broker silently drops
   responses. pycentauri's polling cadence stays under it; your scripts
   should too.
+- **Canvas filament switches reset the speed mode.** Every mid-print
+  switch silently drops the printer back to balanced. pycentauri
+  detects the switch ending and re-applies whatever mode was active
+  before it (needs `--enable-control`).
 - **Registrations expire without an app-level PING.** The printer
   forgets a registered client after several quiet minutes and silently
   stops answering that session's requests — the MQTT connection itself

{pycentauri-0.6.0 → pycentauri-0.6.1}/README.md

@@ -357,6 +357,10 @@ reports code 27 the entire time the head is parked there mid-print.
   cooldown of a few seconds during which the broker silently drops
   responses. pycentauri's polling cadence stays under it; your scripts
   should too.
+- **Canvas filament switches reset the speed mode.** Every mid-print
+  switch silently drops the printer back to balanced. pycentauri
+  detects the switch ending and re-applies whatever mode was active
+  before it (needs `--enable-control`).
 - **Registrations expire without an app-level PING.** The printer
   forgets a registered client after several quiet minutes and silently
   stops answering that session's requests — the MQTT connection itself

{pycentauri-0.6.0 → pycentauri-0.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pycentauri"
-version = "0.6.0"
+version = "0.6.1"
 description = "Local-network toolkit for Elegoo Centauri Carbon 3D printers: async Python client, CLI, MCP server, REST/SSE HTTP server, web UI, and RTSP bridge"
 readme = "README.md"
 license = "Apache-2.0"

{pycentauri-0.6.0 → pycentauri-0.6.1}/src/pycentauri/__init__.py

@@ -39,4 +39,4 @@ __all__ = [
     "discover",
 ]
 
-__version__ = "0.6.0"
+__version__ = "0.6.1"

{pycentauri-0.6.0 → pycentauri-0.6.1}/src/pycentauri/cc2.py

@@ -17,6 +17,7 @@ import contextlib
 import json
 import logging
 import random
+import time
 from collections.abc import AsyncIterator
 from typing import Any, ClassVar
 
@@ -39,6 +40,11 @@ log = logging.getLogger(__name__)
 MQTT_PORT = 1883
 CC2_USERNAME = "elegoo"
 PING_INTERVAL_S = 30.0
+# A speed mode must hold this long before it becomes the restore baseline —
+# the firmware resets speed_mode several seconds BEFORE the head parks for a
+# filament switch (observed 2026-07-05: reset at T-6s), and without the hold
+# that transient poisons the baseline.
+BASELINE_HOLD_S = 15.0
 # Lifecycle commands (start/pause/stop/resume) are answered only after the
 # firmware finishes the mechanical sequence — a resume reheats and unparks
 # before responding, easily exceeding the default 15 s request timeout
@@ -264,6 +270,15 @@ class CC2Printer(Printer):
         self._last_full_result: dict[str, Any] | None = None
         self._connect_error: str | None = None
         self._ping_task: asyncio.Task[None] | None = None
+        # Speed-mode restore across Canvas filament switches: the firmware
+        # resets speed_mode to balanced (1) on every mid-print switch
+        # (verified 2026-07-05 — mode stays 1 after the switch completes).
+        self._speed_mode_during_print: int | None = None
+        self._speed_mode_to_restore: int | None = None
+        self._restore_task: asyncio.Task[None] | None = None
+        self._mode_candidate: int | None = None
+        self._mode_candidate_since: float = 0.0
+        self._now = time.monotonic  # overridable for tests
 
     @classmethod
     async def connect(
@@ -352,6 +367,7 @@ class CC2Printer(Printer):
         result = await self._cc2_request(1002, {}, timeout=timeout)
         self._last_full_result = result
         payload = _cc2_status_to_cc1(result)
+        self._track_speed_mode(payload)
         st = Status.from_payload(payload)
         self._latest_status = st
         self._latest_status_event.set()
@@ -447,6 +463,12 @@ class CC2Printer(Printer):
                     f"{sorted(self.PRINT_SPEED_MODES.values())}"
                 )
         result = await self._cc2_request(1031, {"mode": value})
+        # The user's explicit choice supersedes any pending post-switch
+        # restore and becomes the new baseline.
+        self._speed_mode_during_print = value
+        self._mode_candidate = None
+        if self._speed_mode_to_restore is not None:
+            self._speed_mode_to_restore = value
         return self._wrap_result(1031, result)
 
     async def set_fan_speed(
@@ -512,10 +534,11 @@ class CC2Printer(Printer):
         if self._closed:
             return
         self._closed = True
-        if self._ping_task is not None and not self._ping_task.done():
-            self._ping_task.cancel()
-            with contextlib.suppress(asyncio.CancelledError, Exception):
-                await self._ping_task
+        for task in (self._ping_task, self._restore_task):
+            if task is not None and not task.done():
+                task.cancel()
+                with contextlib.suppress(asyncio.CancelledError, Exception):
+                    await task
         if self._mqtt is not None:
             self._mqtt.disconnect()  # flush DISCONNECT before stopping the loop
             self._mqtt.loop_stop()
@@ -623,6 +646,7 @@ class CC2Printer(Printer):
                 return
             _deep_merge(self._last_full_result, result)
             payload = _cc2_status_to_cc1(self._last_full_result)
+            self._track_speed_mode(payload)
             st = Status.from_payload(payload)
             self._latest_status = st
             self._latest_status_event.set()
@@ -632,6 +656,75 @@ class CC2Printer(Printer):
         except Exception:
             log.exception("failed to handle CC2 status push")
 
+    def _track_speed_mode(self, payload: dict[str, Any]) -> None:
+        """Restore the speed mode after a Canvas filament switch.
+
+        The firmware resets ``speed_mode`` to balanced on every mid-print
+        filament switch (verified 2026-07-05). We snapshot the mode in
+        effect when a switch starts (print_status 27) and re-apply it once
+        printing resumes, so the user's selection — made from any surface,
+        including the touchscreen — survives the switch. Requires
+        ``enable_control``; read-only sessions just log the reset.
+        """
+        print_status = payload.get("PrintInfo", {}).get("Status")
+        speed_mode = payload.get("_cc2", {}).get("speed_mode")
+        if not isinstance(speed_mode, int) or print_status is None:
+            return
+        if print_status == 27:
+            if self._speed_mode_to_restore is None and self._speed_mode_during_print is not None:
+                self._speed_mode_to_restore = self._speed_mode_during_print
+            return
+        if print_status != 13:
+            return
+        want = self._speed_mode_to_restore
+        if want is not None:
+            self._speed_mode_to_restore = None
+            if want != speed_mode:
+                if self.enable_control:
+                    self._restore_task = asyncio.create_task(
+                        self._restore_speed_mode(want),
+                        name=f"pycentauri-cc2-speedrestore-{self.host}",
+                    )
+                else:
+                    log.warning(
+                        "filament switch reset speed_mode %d -> %d; "
+                        "enable_control is off so it will not be restored",
+                        want,
+                        speed_mode,
+                    )
+                return
+        # Track the running mode, but not while a restore is in flight —
+        # the firmware still reports the reset value for a poll or two.
+        if self._restore_task is not None and not self._restore_task.done():
+            return
+        if self._speed_mode_during_print is None:
+            # Bootstrap: first observation is the baseline.
+            self._speed_mode_during_print = speed_mode
+            return
+        if speed_mode == self._speed_mode_during_print:
+            self._mode_candidate = None
+            return
+        # Debounce: a changed mode must hold BASELINE_HOLD_S before it
+        # becomes the restore baseline, so the firmware's pre-switch reset
+        # (which fires seconds before the head parks) never gets adopted.
+        now = self._now()
+        if speed_mode != self._mode_candidate:
+            self._mode_candidate = speed_mode
+            self._mode_candidate_since = now
+        elif now - self._mode_candidate_since >= BASELINE_HOLD_S:
+            self._speed_mode_during_print = speed_mode
+            self._mode_candidate = None
+
+    async def _restore_speed_mode(self, mode: int) -> None:
+        await asyncio.sleep(2.0)  # let the firmware settle after the switch
+        try:
+            await self._cc2_request(1031, {"mode": mode})
+            log.info("restored speed_mode %d after filament switch", mode)
+        except Exception:
+            log.warning(
+                "could not restore speed_mode %d after filament switch", mode, exc_info=True
+            )
+
     def _publish_register(self) -> None:
         topic = f"elegoo/{self._serial_number}/api_register"
         payload = json.dumps({"client_id": self._client_id, "request_id": self._request_id_prefix})

{pycentauri-0.6.0 → pycentauri-0.6.1}/src/pycentauri/server.py

@@ -747,6 +747,11 @@ def run(
     """
     import uvicorn
 
+    # Surface pycentauri's own log lines (reconnects, speed-mode restores)
+    # in the journal — uvicorn only configures its own loggers, and the
+    # root logger's lastResort handler hides INFO.
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s:%(name)s: %(message)s")
+
     app = create_app(
         host,
         enable_control=enable_control,

{pycentauri-0.6.0 → pycentauri-0.6.1}/tests/test_cc2_mapping.py

@@ -270,3 +270,92 @@ def test_canvas_parse_survives_malformed_payloads() -> None:
         == 0
     )
     assert CanvasStatus.from_payload({"canvas_info": {"canvas_list": "bogus"}}).tray_count == 0
+
+
+# --- speed-mode restore across filament switches -------------------------------
+
+
+def _payload(status: int, mode: int) -> dict[str, Any]:
+    return {"PrintInfo": {"Status": status}, "_cc2": {"speed_mode": mode}}
+
+
+def _printer(enable_control: bool = False) -> Any:
+    from pycentauri.cc2 import CC2Printer
+
+    return CC2Printer("127.0.0.1", access_code="x", enable_control=enable_control)
+
+
+def test_switch_snapshots_and_flags_restore(monkeypatch: Any) -> None:
+    p = _printer(enable_control=False)
+    # Printing at sport (2)
+    p._track_speed_mode(_payload(13, 2))
+    assert p._speed_mode_during_print == 2
+    # Switch begins — snapshot taken
+    p._track_speed_mode(_payload(27, 1))
+    assert p._speed_mode_to_restore == 2
+    # Switch ends with the firmware reset to balanced; control off → no
+    # restore task, but the pending snapshot is consumed.
+    p._track_speed_mode(_payload(13, 1))
+    assert p._speed_mode_to_restore is None
+
+
+def test_no_restore_when_mode_survives_switch() -> None:
+    p = _printer()
+    p._track_speed_mode(_payload(13, 3))
+    p._track_speed_mode(_payload(27, 3))
+    assert p._speed_mode_to_restore == 3
+    # Firmware kept the mode: nothing to do, baseline continues
+    p._track_speed_mode(_payload(13, 3))
+    assert p._speed_mode_to_restore is None
+    assert p._speed_mode_during_print == 3
+
+
+def test_snapshot_not_overwritten_mid_switch() -> None:
+    p = _printer()
+    p._track_speed_mode(_payload(13, 2))
+    p._track_speed_mode(_payload(27, 1))
+    p._track_speed_mode(_payload(27, 1))  # more switch polls
+    assert p._speed_mode_to_restore == 2
+
+
+def test_idle_states_do_not_touch_tracking() -> None:
+    p = _printer()
+    p._track_speed_mode(_payload(13, 2))
+    p._track_speed_mode(_payload(0, 1))  # idle
+    p._track_speed_mode(_payload(6, 1))  # paused
+    assert p._speed_mode_during_print == 2
+    assert p._speed_mode_to_restore is None
+
+
+def test_pre_switch_reset_does_not_poison_baseline() -> None:
+    """Replicates the live trace from 2026-07-05 14:10: the firmware
+    resets speed_mode ~6 s BEFORE the head parks for the switch."""
+    p = _printer()
+    t = [0.0]
+    p._now = lambda: t[0]
+    p._track_speed_mode(_payload(13, 2))  # printing at sport (bootstrap)
+    t[0] = 120.0
+    p._track_speed_mode(_payload(13, 2))  # still sport
+    # Pre-switch reset: mode drops while status is still 13
+    t[0] = 126.0
+    p._track_speed_mode(_payload(13, 1))
+    t[0] = 129.0
+    p._track_speed_mode(_payload(13, 1))  # held only 3 s — not promoted
+    assert p._speed_mode_during_print == 2
+    # Head parks, switch state
+    t[0] = 132.0
+    p._track_speed_mode(_payload(27, 1))
+    assert p._speed_mode_to_restore == 2  # snapshot is the REAL baseline
+
+
+def test_sustained_mode_change_becomes_baseline() -> None:
+    p = _printer()
+    t = [0.0]
+    p._now = lambda: t[0]
+    p._track_speed_mode(_payload(13, 1))  # bootstrap balanced
+    t[0] = 10.0
+    p._track_speed_mode(_payload(13, 3))  # user sets ludicrous on screen
+    assert p._speed_mode_during_print == 1  # not yet promoted
+    t[0] = 26.0
+    p._track_speed_mode(_payload(13, 3))  # held 16 s → promoted
+    assert p._speed_mode_during_print == 3