anycubic-cloud-api 0.4.32__tar.gz → 0.4.34__tar.gz

{anycubic_cloud_api-0.4.32/src/anycubic_cloud_api.egg-info → anycubic_cloud_api-0.4.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anycubic-cloud-api
-Version: 0.4.32
+Version: 0.4.34
 Summary: Async client for the Anycubic Cloud API and its MQTT stream
 Author: WaresWichall, Nino Bondonno
 Maintainer: Nino Bondonno

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "anycubic-cloud-api"
-version = "0.4.32"
+version = "0.4.34"
 description = "Async client for the Anycubic Cloud API and its MQTT stream"
 readme = "README.md"
 requires-python = ">=3.12"

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34}/src/anycubic_cloud_api/__init__.py

@@ -19,6 +19,7 @@ from .data_models.project import AnycubicProject
 from .exceptions.exceptions import (
     AnycubicAPIError,
     AnycubicAPIParsingError,
+    AnycubicRateLimitError,
     AnycubicAuthError,
     AnycubicAuthTokensExpired,
     AnycubicCloudUploadError,
@@ -40,6 +41,7 @@ __all__ = [
     "AnycubicAPI",
     "AnycubicAPIError",
     "AnycubicAPIParsingError",
+    "AnycubicRateLimitError",
     "AnycubicAuthError",
     "AnycubicAuthMode",
     "AnycubicAuthTokensExpired",

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34}/src/anycubic_cloud_api/api/base.py

@@ -13,6 +13,9 @@ from ..const.api_endpoints import API_ENDPOINT
 from ..const.const import (
     ACCESS_TOKEN_LOGIN_RETRIES,
     ACCESS_TOKEN_LOGIN_RETRY_INTERVAL,
+    ACCESS_TOKEN_RATE_LIMIT_MARKERS,
+    ACCESS_TOKEN_RATE_LIMIT_RETRIES,
+    ACCESS_TOKEN_RATE_LIMIT_WAIT,
     DEFAULT_USER_AGENT,
     MAX_API_FETCH_TIME_WARN,
     WARN_INTERVAL_API_DURATION,
@@ -32,6 +35,7 @@ from ..exceptions.exceptions import (
     AnycubicAPIParsingError,
     AnycubicAuthError,
     AnycubicAuthTokensExpired,
+    AnycubicRateLimitError,
 )
 from ..models.auth import AnycubicAuthentication, AnycubicAuthMode
 from ..models.http import HTTP_METHODS, AnycubicAPIEndpoint
@@ -346,12 +350,23 @@ class AnycubicAPIBase:
 
     async def _get_user_token_with_access_token_with_retry(self) -> None:
         retries = ACCESS_TOKEN_LOGIN_RETRIES
-        for x in range(retries):
+        rate_limit_waits = ACCESS_TOKEN_RATE_LIMIT_RETRIES
+        x = 0
+        while True:
             try:
                 await self._get_user_token_with_access_token()
                 return
+            except AnycubicRateLimitError:
+                # Not a refusal: wait out the cooldown. If it persists the
+                # error propagates as transient, never as an auth failure, so
+                # it can neither trigger the web fallback nor a re-auth.
+                if rate_limit_waits <= 0:
+                    raise
+                rate_limit_waits -= 1
+                await asyncio.sleep(ACCESS_TOKEN_RATE_LIMIT_WAIT)
             except AnycubicAuthError:
-                if x < retries - 1:
+                x += 1
+                if x < retries:
                     await asyncio.sleep(ACCESS_TOKEN_LOGIN_RETRY_INTERVAL)
                 else:
                     raise
@@ -366,6 +381,12 @@ class AnycubicAPIBase:
         )
         if not resp or not resp['data']:
             server_message = resp.get('msg') if resp else None
+            if server_message and any(
+                marker in str(server_message) for marker in ACCESS_TOKEN_RATE_LIMIT_MARKERS
+            ):
+                error_message = ErrorsAuth.access_token_rate_limited.format(server_message)
+                self._log_to_debug(error_message)
+                raise AnycubicRateLimitError(error_message)
             error_message = ErrorsAuth.access_token_login_failed.format(server_message)
             self._log_to_debug(error_message)
             raise AnycubicAuthError(error_message)

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34}/src/anycubic_cloud_api/api/mqtt.py

@@ -171,8 +171,12 @@ class AnycubicMQTTAPI(AnycubicAPIFunctions):
                 printer.process_mqtt_update(topic, AnycubicConsumableData(payload))
 
             except AnycubicMQTTUnhandledData as e:
+                # The message was applied; only fields this version has no use
+                # for were left over. That is for whoever extends the parser,
+                # not something a user can act on, and at warning level it was
+                # repeated every few seconds through every print (#42).
                 redacted_topic = redact_part_from_mqtt_topic(topic, 6)
-                self._log_to_warn(
+                self._log_to_debug(
                     f"Anycubic MQTT Message unhandled data in: {e}\n"
                     f"  on MQTT topic: {redacted_topic}\n"
                     f"  with type: {e.unhandled_mqtt_type}, "

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34}/src/anycubic_cloud_api/const/const.py

@@ -41,6 +41,12 @@ WARN_INTERVAL_API_DURATION = 60 * 10
 
 ACCESS_TOKEN_LOGIN_RETRIES = 2
 ACCESS_TOKEN_LOGIN_RETRY_INTERVAL = 2
+# The token exchange is rate-limited: a second exchange within ~3 s of a
+# successful one is refused with this message (measured 2026-09-28). It is not
+# a login failure, so it is retried after a cooldown and never treated as one.
+ACCESS_TOKEN_RATE_LIMIT_MARKERS = ("请求过于频繁", "too frequent")
+ACCESS_TOKEN_RATE_LIMIT_RETRIES = 3
+ACCESS_TOKEN_RATE_LIMIT_WAIT = 6
 
 
 class AnycubicServerMessage:

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34}/src/anycubic_cloud_api/data_models/printer.py

@@ -24,6 +24,7 @@ from ..exceptions.exceptions import (
     AnycubicMQTTUnknownUpdate,
 )
 from ..helpers.helpers import (
+    as_int,
     get_part_from_mqtt_topic,
     time_duration_string_to_delta,
     timedelta_to_dhm_string,
@@ -52,6 +53,32 @@ if TYPE_CHECKING:
     from .print_response import AnycubicPrintResponse
     from .printer_properties import AnycubicDryingStatus, AnycubicMaterialMapping
 
+# Job progress a print update can carry, applied to the job it is about.
+_PRINT_PROGRESS_KEYS = (
+    'curr_layer',
+    'total_layers',
+    'filename',
+    'print_time',
+    'progress',
+    'remain_time',
+    'supplies_usage',
+)
+
+# How a printer words a refused order when it gives no code.
+_REFUSED_STATES = frozenset({'failed', 'fail', 'error', 'refused'})
+
+# What a print report says about the file being printed, which the job already
+# knows by name. Read so the report is not flagged as unhandled data on every
+# progress tick (#34, #42) -- nothing here changes what is shown.
+_PRINT_FILE_KEYS = (
+    'file_root_path',
+    'filetype',
+    'display_filename',
+    'origin3mf',
+    'source_info',
+    'temp_gcode',
+)
+
 
 def _drain(consumable: Any) -> dict[str, Any]:
     """Read every remaining key, returning them as a plain dict.
@@ -1283,6 +1310,19 @@ class AnycubicPrinter:
                     settings['target_hotbed_temp'],
                     settings['target_nozzle_temp'],
                 )
+            # The light is reported by its own message; here it only repeats.
+            settings.get('light')
+            # Read again now it is empty, which is what marks a nested block
+            # consumed; left in place it was reported as unhandled data.
+            data.get('settings')
+
+            if 'channel_no' in data:
+                self._apply_active_channel(data['channel_no'])
+
+            # A Kobra X reports progress this way between info reports, with
+            # no task id. It was logged as unhandled and dropped (#34).
+            if any(key in data for key in _PRINT_PROGRESS_KEYS):
+                self._apply_print_progress(project_id, data)
             return
         elif action in ['start', 'stop'] and state in ['failed']:
             err_msg = payload.get('msg')
@@ -1296,6 +1336,95 @@ class AnycubicPrinter:
         else:
             raise AnycubicMQTTUnknownUpdate(ErrorsMQTTUpdate.job_status)
 
+    def _apply_active_channel(self, channel_no: Any) -> None:
+        """Follow the filament channel the printer says it is printing from.
+
+        A Kobra X reports each filament change as a print update carrying
+        only ``channel_no``, and stops sending the ACE's own ``loaded_slot``
+        after the first few changes of a print -- which is why the loaded
+        slot froze for the rest of the job (#34). The channel is numbered
+        from 1 across every box in order, so channel 5 on a printer whose
+        first box has four slots is the first slot of the second box.
+        """
+        channel = as_int(channel_no, 0)
+
+        if channel < 1 or not self._multi_color_box:
+            return
+
+        index = channel - 1
+
+        for box in self._multi_color_box:
+            slot_count = len(box.slots)
+
+            if index < slot_count:
+                box.set_slot_loaded(index)
+                return
+
+            index -= slot_count
+
+    def _apply_print_progress(
+        self,
+        project_id: int,
+        data: AnycubicConsumableData,
+    ) -> None:
+        """Apply a progress-only print update to the job it is about.
+
+        Sent without a task id, it can only be about the job in hand. With
+        no job to apply it to it is dropped, as the cloud path always has.
+        """
+        if not self._check_latest_project_id_valid(project_id):
+            data.force_empty()
+            return
+
+        assert self._latest_project
+        self._latest_project.update_with_mqtt_print_status_data(None, data)
+
+    def _report_refused_drying(
+        self,
+        state: str | None,
+        payload: AnycubicConsumableData,
+    ) -> bool:
+        """Say so when the printer will not start a dry cycle.
+
+        A start the ACE refuses -- 65 C on an ACE Pro that tops out at 55 is
+        code 11505 -- came back as a setDry reply that was not a success. It
+        was thrown away as "not understood", so the button press looked like
+        it had worked and nothing in Home Assistant said otherwise (#42).
+
+        The code is kept as the printer's latest error, the same as any other
+        fault, so the last-error sensors show it too. A reply that is neither
+        a fault code nor a failed state is left to be reported as unknown.
+        """
+        data = payload.remaining_data.get('data')
+        code = payload.remaining_data.get('code')
+
+        if isinstance(data, AnycubicConsumableData) and 'code' in data:
+            code = data.remaining_data.get('code')
+
+        if not isinstance(code, int) or isinstance(code, bool) or code in PRINTER_OK_CODES:
+            code = None
+
+        if code is None and str(state or '').lower() not in _REFUSED_STATES:
+            return False
+
+        message = payload.get('msg')
+
+        if code is not None:
+            self._record_error_code(code, message)
+            reason = f"code {code}: {describe_printer_code(code)}"
+        else:
+            reason = str(message or state or 'no reason given')
+
+        self._api_parent._log_to_warn(
+            f"The printer refused to start drying on the ACE ({reason})."
+        )
+
+        payload.get('data')
+        if isinstance(data, AnycubicConsumableData):
+            data.force_empty()
+
+        return True
+
     def _process_mqtt_update_multicolorbox(
         self,
         action: str,
@@ -1340,6 +1469,8 @@ class AnycubicPrinter:
                 self._multi_color_box[box_id].set_current_temperature(box['temp'])
                 self._multi_color_box[box_id].set_drying_status(box['drying_status'])
             return
+        elif action == 'setDry' and self._report_refused_drying(state, payload):
+            return
         elif action == 'feedFilament' and state == 'done':
             data = payload['data']['multi_color_box']
             for box in data:
@@ -1734,6 +1865,10 @@ class AnycubicPrinter:
             remaining_data.get('taskid')
             remaining_data.get('localtask')
 
+            if msg_type == 'print':
+                for key in _PRINT_FILE_KEYS:
+                    remaining_data.get(key)
+
         payload.get('data')
         payload.get('msg')
         payload.get('timestamp')

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34}/src/anycubic_cloud_api/data_models/project.py

@@ -46,6 +46,15 @@ PRINT_STATES_NOT_IN_PROGRESS = frozenset({
     'stopped',
 })
 
+# The speed presets an FDM printer takes over its own network, in the shape
+# the cloud sends them. 1, 2 and 3 are what a Kobra S1 and a Kobra 4 report
+# and accept; a printer that sends its own list is never overridden.
+LAN_PRINT_SPEED_MODES: tuple[dict[str, Any], ...] = (
+    {'title': 'Silent', 'print_speed_mode': 1},
+    {'title': 'Standard', 'print_speed_mode': 2},
+    {'title': 'Sport', 'print_speed_mode': 3},
+)
+
 
 class AnycubicProject:
     __slots__ = (
@@ -305,6 +314,13 @@ class AnycubicProject:
             project_type=data.get('project_type'),
             localtask=data.get('localtask'),
             print_speed_mode=data.get('print_speed_mode'),
+            # The cloud sends the printer's speed presets with the job; the
+            # printer does not. Without a list the speed select stayed
+            # unavailable through every LAN print, though the printer takes
+            # the change locally as the slicer shows (discussion #37).
+            available_print_speed_modes=(
+                data.get('print_speed_model_des') or list(LAN_PRINT_SPEED_MODES)
+            ),
         )
 
     @classmethod

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34}/src/anycubic_cloud_api/exceptions/error_strings.py

@@ -194,6 +194,9 @@ class ErrorsAuth:
     access_token_login_failed = str(
         "Failed to login with access_token, server message: {0}"
     )
+    access_token_rate_limited = str(
+        "Anycubic rate-limited the access_token login, server message: {0}"
+    )
 
 
 class ErrorsAuthTokenExpired:

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34}/src/anycubic_cloud_api/exceptions/exceptions.py

@@ -15,6 +15,10 @@ class AnycubicAPIParsingError(AnycubicAPIError):
     pass
 
 
+class AnycubicRateLimitError(AnycubicAPIParsingError):
+    """The cloud asked us to slow down. Transient, never an auth failure."""
+
+
 class AnycubicFileNotFoundError(AnycubicAPIError):
     pass
 

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34/src/anycubic_cloud_api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: anycubic-cloud-api
-Version: 0.4.32
+Version: 0.4.34
 Summary: Async client for the Anycubic Cloud API and its MQTT stream
 Author: WaresWichall, Nino Bondonno
 Maintainer: Nino Bondonno

{anycubic_cloud_api-0.4.32 → anycubic_cloud_api-0.4.34}/src/anycubic_cloud_api.egg-info/SOURCES.txt

@@ -46,12 +46,14 @@ src/anycubic_cloud_api/resources/anycubic_mqqt_tls_client.key
 tests/test_auth_mode_fallback.py
 tests/test_axis_position.py
 tests/test_endpoint_urls.py
+tests/test_exchange_rate_limit.py
 tests/test_lan_client.py
 tests/test_lan_commands.py
 tests/test_lan_handshake.py
 tests/test_lan_reports.py
 tests/test_null_tolerant_parsing.py
 tests/test_partial_reports.py
+tests/test_print_reports_0434.py
 tests/test_printer_error_codes.py
 tests/test_project_null_status.py
 tests/test_regions.py

anycubic_cloud_api-0.4.34/tests/test_exchange_rate_limit.py

@@ -0,0 +1,94 @@
+"""The access-token exchange is rate-limited, and that is not a login failure.
+
+Measured 2026-09-28: a second exchange of the same slicer token within about
+3 s of a successful one is answered `code 0`, `msg` "请求过于频繁。请稍后再试"
+("requests too frequent, try again later") and no data; after 5 s or more it
+succeeds. The retry loop tried twice, 2 s apart -- both inside the cooldown --
+then treated it as a refused token: the web fallback ran, userInfo refused the
+access token as a web token, and the integration asked the user to
+re-authenticate with a perfectly good token.
+"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from anycubic_cloud_api import AnycubicAPI
+from anycubic_cloud_api.exceptions.exceptions import (
+    AnycubicAPIParsingError,
+    AnycubicAuthError,
+    AnycubicRateLimitError,
+)
+from anycubic_cloud_api.models.auth import AnycubicAuthMode
+
+RATE_LIMITED = {"code": 0, "msg": "请求过于频繁。请稍后再试", "data": None}
+REFUSED = {"code": 0, "msg": "User does not exist", "data": None}
+SUCCESS = {"code": 1, "msg": "Login successful", "data": {"token": "user-token"}}
+
+
+def slicer_api():
+    api = AnycubicAPI(session=MagicMock(), cookie_jar=MagicMock())
+    api.set_authentication(auth_token="eyJ.access.token", auth_mode=AnycubicAuthMode.SLICER)
+    return api
+
+
+async def run_exchange(api, answers):
+    fetch = AsyncMock(side_effect=answers)
+    sleep = AsyncMock()
+    with patch.object(api, "_fetch_api_resp", fetch), patch("asyncio.sleep", sleep):
+        await api._get_user_token_with_access_token_with_retry()
+    return fetch, sleep
+
+
+async def test_a_rate_limit_waits_out_the_cooldown_and_succeeds():
+    api = slicer_api()
+
+    fetch, sleep = await run_exchange(api, [RATE_LIMITED, RATE_LIMITED, SUCCESS])
+
+    assert fetch.await_count == 3
+    assert api.anycubic_auth._auth_token == "user-token"
+    # each wait covers the ~3 s cooldown, unlike the 2 s refusal retry
+    assert all(call.args[0] >= 5 for call in sleep.await_args_list)
+
+
+async def test_a_persistent_rate_limit_is_transient_not_an_auth_failure():
+    api = slicer_api()
+
+    with pytest.raises(AnycubicRateLimitError) as err:
+        await run_exchange(api, [RATE_LIMITED] * 10)
+
+    # The integration treats parsing errors as "try later"; it must never
+    # see this as an auth failure, which is what triggers re-authentication.
+    assert isinstance(err.value, AnycubicAPIParsingError)
+    assert not isinstance(err.value, AnycubicAuthError)
+
+
+async def test_a_rate_limit_does_not_use_up_the_refusal_retries():
+    api = slicer_api()
+
+    fetch, _ = await run_exchange(api, [RATE_LIMITED, REFUSED, SUCCESS])
+
+    assert fetch.await_count == 3
+    assert api.anycubic_auth._auth_token == "user-token"
+
+
+async def test_a_genuine_refusal_still_fails_after_two_attempts():
+    api = slicer_api()
+
+    with pytest.raises(AnycubicAuthError):
+        await run_exchange(api, [REFUSED, REFUSED])
+
+
+async def test_the_web_fallback_is_not_triggered_by_a_rate_limit():
+    """_check_can_access_api retries as a web token only on AnycubicAuthError."""
+    api = slicer_api()
+    fetch = AsyncMock(side_effect=[RATE_LIMITED] * 10)
+    with (
+        patch.object(api, "_fetch_api_resp", fetch),
+        patch("asyncio.sleep", AsyncMock()),
+        pytest.raises(AnycubicRateLimitError),
+    ):
+        await api._check_can_access_api()
+
+    assert api.anycubic_auth._auth_mode == AnycubicAuthMode.SLICER
+    assert api.anycubic_auth._auth_access_token == "eyJ.access.token"

anycubic_cloud_api-0.4.34/tests/test_print_reports_0434.py

@@ -0,0 +1,268 @@
+"""Print and ACE reports that were being dropped or misread (0.4.34).
+
+From a Kobra X (#34) and a Kobra S1 with two ACE Pro units (#42): the active
+filament channel arrived in print updates nobody read, progress-only updates
+were logged as unhandled, a refused dry cycle passed silently, and a LAN job
+had no speed presets for the speed select to offer (discussion #37).
+"""
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from anycubic_cloud_api.data_models.consumable import AnycubicConsumableData
+from anycubic_cloud_api.data_models.printer import AnycubicPrinter
+from anycubic_cloud_api.data_models.project import AnycubicProject
+from anycubic_cloud_api.exceptions.exceptions import AnycubicMQTTUnknownUpdate
+
+
+def slot(index):
+    return {
+        "index": index,
+        "sku": "",
+        "type": "PLA",
+        "color": [1, 2, 3],
+        "status": 5,
+        "edit_status": 1,
+    }
+
+
+def box(box_id, slots=4):
+    return {
+        "id": box_id,
+        "loaded_slot": -1,
+        "slots": [slot(i) for i in range(slots)],
+    }
+
+
+def make_printer(boxes, parent=None):
+    return AnycubicPrinter(
+        api_parent=parent or MagicMock(),
+        machine_type=20030,
+        machine_name="Kobra X",
+        id=1,
+        multi_color_box=boxes,
+        ignore_init_errors=True,
+    )
+
+
+def message(msg_type, action, state, data, **envelope):
+    return AnycubicConsumableData({
+        "type": msg_type,
+        "action": action,
+        "state": state,
+        "msgid": "m",
+        "timestamp": 1,
+        "data": data,
+        **envelope,
+    })
+
+
+def lan_job(task_id=42, **fields):
+    return {
+        "task_id": task_id,
+        "filename": "cube.gcode.3mf",
+        "progress": 0,
+        "print_status": 1,
+        **fields,
+    }
+
+
+TOPIC = "anycubic/anycubicCloud/v1/printer/public/20030/key/print/report"
+ACE_TOPIC = "anycubic/anycubicCloud/v1/printer/public/20030/key/multiColorBox/report"
+
+
+class TestActiveChannel:
+    def _channel(self, printer, channel_no):
+        printer.process_mqtt_update(
+            TOPIC,
+            message(
+                "print", "update", "updated",
+                {"channel_no": channel_no, "settings": {"light": 0}},
+            ),
+        )
+
+    @pytest.mark.parametrize(("channel_no", "slot_index"), [(1, 0), (3, 2), (4, 3)])
+    def test_a_channel_change_moves_the_loaded_slot(self, channel_no, slot_index):
+        printer = make_printer([box(0)])
+
+        self._channel(printer, channel_no)
+
+        assert printer.primary_multi_color_box_loaded_slot == slot_index
+
+    def test_channels_beyond_the_first_box_land_in_the_next(self):
+        """Channel 5 with four slots in the first box is the second box's first."""
+        printer = make_printer([box(0), box(1)])
+
+        self._channel(printer, 5)
+
+        assert printer.secondary_multi_color_box_loaded_slot == 0
+
+    @pytest.mark.parametrize("channel_no", [0, -1, 9, None, "x"])
+    def test_a_channel_with_no_slot_changes_nothing(self, channel_no):
+        printer = make_printer([box(0)])
+        printer._multi_color_box[0].set_slot_loaded(1)
+
+        self._channel(printer, channel_no)
+
+        assert printer.primary_multi_color_box_loaded_slot == 1
+
+    def test_a_printer_with_no_ace_ignores_it(self):
+        printer = make_printer(None)
+
+        self._channel(printer, 2)
+
+        assert printer.connected_ace_units == 0
+
+
+class TestProgressUpdates:
+    PROGRESS = {
+        "curr_layer": 23,
+        "file_root_path": "cube.gcode.3mf",
+        "filename": "cube.gcode.3mf",
+        "filetype": 0,
+        "print_time": 7,
+        "progress": 10,
+        "remain_time": 66,
+        "settings": {"light": 0},
+        "supplies_usage": 1074,
+        "total_layers": 263,
+    }
+
+    def test_progress_without_a_task_id_reaches_the_job(self):
+        printer = make_printer([box(0)])
+        printer._apply_lan_project(AnycubicConsumableData(lan_job()))
+
+        printer.process_mqtt_update(
+            TOPIC, message("print", "update", "updated", dict(self.PROGRESS))
+        )
+
+        project = printer.latest_project
+        assert project is not None
+        assert project.progress_percentage == 10
+        assert project.print_time_remaining_minutes == 66
+
+    def test_progress_with_no_job_is_dropped_quietly(self):
+        printer = make_printer([box(0)])
+
+        printer.process_mqtt_update(
+            TOPIC, message("print", "update", "updated", dict(self.PROGRESS))
+        )
+
+        assert printer.latest_project is None
+
+    def test_progress_for_another_job_is_not_applied(self):
+        printer = make_printer([box(0)])
+        printer._apply_lan_project(AnycubicConsumableData(lan_job(task_id=42)))
+
+        printer.process_mqtt_update(
+            TOPIC,
+            message("print", "update", "updated", {"taskid": 7, **self.PROGRESS}),
+        )
+
+        assert printer.latest_project.progress_percentage == 0
+
+    def test_the_s1_file_fields_are_not_left_over(self):
+        """These four were reported as unhandled every 30-60 s (#42)."""
+        printer = make_printer([box(0)])
+        printer._apply_lan_project(AnycubicConsumableData(lan_job()))
+
+        printer.process_mqtt_update(
+            TOPIC,
+            message(
+                "print", "update", "updated",
+                {
+                    "display_filename": "cube",
+                    "origin3mf": "cube.3mf",
+                    "source_info": "slicer",
+                    "temp_gcode": "/tmp/x",
+                    "progress": 50,
+                },
+            ),
+        )
+
+        assert printer.latest_project.progress_percentage == 50
+
+    def test_a_print_start_with_file_fields_is_handled(self):
+        printer = make_printer([box(0)])
+        printer._apply_lan_project(AnycubicConsumableData(lan_job()))
+
+        printer.process_mqtt_update(
+            TOPIC,
+            message(
+                "print", "start", "printing",
+                {"file_root_path": "cube.gcode.3mf", "filetype": 0},
+            ),
+        )
+
+
+class TestRefusedDrying:
+    def _printer(self):
+        parent = MagicMock()
+        logs: list[str] = []
+        parent._log_to_warn = logs.append
+        return make_printer([box(0), box(1)], parent), logs
+
+    def test_a_refusal_code_is_reported_and_kept(self):
+        printer, logs = self._printer()
+
+        printer.process_mqtt_update(
+            ACE_TOPIC,
+            message("multiColorBox", "setDry", "failed", {}, code=11505, msg="fail"),
+        )
+
+        assert len(logs) == 1
+        assert "11505" in logs[0]
+        assert "target temperature" in logs[0]
+        assert printer.latest_error_code == 11505
+
+    def test_a_code_inside_the_data_counts_too(self):
+        printer, logs = self._printer()
+
+        printer.process_mqtt_update(
+            ACE_TOPIC,
+            message("multiColorBox", "setDry", "done", {"code": 11505}, code=200),
+        )
+
+        assert "11505" in logs[0]
+        assert printer.latest_error_code == 11505
+
+    def test_a_failed_state_without_a_code_is_still_reported(self):
+        printer, logs = self._printer()
+
+        printer.process_mqtt_update(
+            ACE_TOPIC,
+            message("multiColorBox", "setDry", "failed", None, code=200, msg="busy"),
+        )
+
+        assert logs == ["The printer refused to start drying on the ACE (busy)."]
+
+    def test_an_unfamiliar_reply_is_not_called_a_refusal(self):
+        printer, logs = self._printer()
+
+        with pytest.raises(AnycubicMQTTUnknownUpdate):
+            printer.process_mqtt_update(
+                ACE_TOPIC,
+                message("multiColorBox", "setDry", "doing", {}, code=200),
+            )
+
+        assert logs == []
+
+
+class TestLanSpeedModes:
+    def test_a_lan_job_offers_the_standard_presets(self):
+        project = AnycubicProject.from_lan_project(MagicMock(), 1, lan_job())
+
+        assert project is not None
+        assert [m.mode for m in project.available_print_speed_modes] == [1, 2, 3]
+        project.validate_print_speed_mode(3)
+
+    def test_a_list_the_printer_sends_is_used_instead(self):
+        project = AnycubicProject.from_lan_project(
+            MagicMock(),
+            1,
+            lan_job(print_speed_model_des=[{"title": "Ludicrous", "print_speed_mode": 4}]),
+        )
+
+        assert project is not None
+        assert [m.title for m in project.available_print_speed_modes] == ["Ludicrous"]