anycubic-cloud-api 0.4.26__tar.gz → 0.4.28__tar.gz

{anycubic_cloud_api-0.4.26/src/anycubic_cloud_api.egg-info → anycubic_cloud_api-0.4.28}/PKG-INFO

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

{anycubic_cloud_api-0.4.26 → anycubic_cloud_api-0.4.28}/pyproject.toml

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

{anycubic_cloud_api-0.4.26 → anycubic_cloud_api-0.4.28}/src/anycubic_cloud_api/data_models/printer.py

@@ -1127,7 +1127,10 @@ class AnycubicPrinter:
         state: str,
         payload: AnycubicConsumableData,
     ) -> None:
-        project_id = payload.get('data', {}).get('taskid', -1)
+        # `or {}` rather than a plain default: a present-but-null `data`
+        # hands back None from .get and the chained .get then raises
+        # AttributeError. Same trap as the null coercions, different shape.
+        project_id = (payload.get('data') or {}).get('taskid', -1)
         if action == 'start' and state == 'printing':
             data = payload['data']
             self._is_printing = 2

{anycubic_cloud_api-0.4.26 → anycubic_cloud_api-0.4.28}/src/anycubic_cloud_api/data_models/printer_properties.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import Any
 
 from ..exceptions.error_strings import ErrorsDataParsing
+from ..helpers.helpers import as_int, as_int_list, as_str
 from ..exceptions.exceptions import AnycubicDataParsingError
 
 
@@ -27,13 +28,13 @@ class AnycubicMaterialMapping:
         color_blue: int,
         paint_index: int = 0,
     ) -> None:
-        self._spool_index = int(spool_index)
+        self._spool_index = as_int(spool_index, -1)
         self._filament_used = float(filament_used)
-        self._material_type = str(material_type)
-        self._color_red = int(color_red)
-        self._color_green = int(color_green)
-        self._color_blue = int(color_blue)
-        self._paint_index = int(paint_index)
+        self._material_type = as_str(material_type)
+        self._color_red = as_int(color_red)
+        self._color_green = as_int(color_green)
+        self._color_blue = as_int(color_blue)
+        self._paint_index = as_int(paint_index, -1)
 
     @property
     def spool_index(self) -> int:
@@ -207,19 +208,22 @@ class AnycubicMachineToolInfo:
         status: int,
         show_place: int,
     ) -> None:
-        self._id = int(id)
-        self._typd_id = int(typd_id)
-        self._model_id = int(model_id)
-        self._type_function_id = int(type_function_id)
-        self._parent_id = int(parent_id)
-        self._function_name = str(function_name)
-        self._function_des = str(function_des)
-        self._control = int(control)
+        # Descriptive data about what the machine can do. Thirteen fields
+        # read straight out of the cloud's dict, any one of which arriving
+        # null used to raise and cost the caller the whole printer.
+        self._id = as_int(id, -1)
+        self._typd_id = as_int(typd_id, -1)
+        self._model_id = as_int(model_id, -1)
+        self._type_function_id = as_int(type_function_id, -1)
+        self._parent_id = as_int(parent_id, -1)
+        self._function_name = as_str(function_name)
+        self._function_des = as_str(function_des)
+        self._control = as_int(control)
         self._param = param
-        self._icon_url = str(icon_url)
-        self._function_type = int(function_type)
-        self._status = int(status)
-        self._show_place = int(show_place)
+        self._icon_url = as_str(icon_url)
+        self._function_type = as_int(function_type)
+        self._status = as_int(status)
+        self._show_place = as_int(show_place)
 
     @classmethod
     def from_json(cls, data: dict[str, Any] | None) -> AnycubicMachineToolInfo | None:
@@ -271,20 +275,47 @@ class AnycubicMachineExternalShelves:
         status_type: int,
         current_status: int,
     ) -> None:
-        self._id = int(id)
-        self._type = str(type)
-        self._color = list([
-            int(x) for x in color
-        ])
-        self._loaded = int(loaded)
-        self._status_type = int(status_type)
-        self._current_status = int(current_status)
+        # Every one of these is coerced defensively. Firmware 2.0.1.9 began
+        # sending this object with `id` and `loaded` null, and the bare
+        # int() calls that used to be here raised TypeError -- which failed
+        # the whole printer's parse and left the entry in setup_retry with
+        # every entity unavailable (#28). The holder is an accessory; not
+        # knowing its id is not a reason to lose the printer.
+        self._id = as_int(id, -1)
+        self._type = as_str(type)
+        self._color = as_int_list(color)
+        self._loaded = as_int(loaded)
+        self._status_type = as_int(status_type)
+        self._current_status = as_int(current_status)
 
     @classmethod
     def from_json(cls, data: dict[str, Any] | None) -> AnycubicMachineExternalShelves | None:
         if data is None:
             return None
 
+        # An external shelf is a distinct accessory from the ACE, and firmware
+        # 2.0.1.9 reports the field whether or not one is attached -- entirely
+        # null when it is not. Reported by the owner of the printer in #28,
+        # who had an ACE 2 Pro represented perfectly well elsewhere in the
+        # same payload and no shelf at all.
+        #
+        # Tolerating those nulls stopped the crash but would then have built a
+        # holder that does not exist, so `external_spool_loaded` would state
+        # flatly that nothing is loaded in a thing nobody owns. Absent is not
+        # empty, and an entity that is confidently wrong is worse than one
+        # that admits it does not know.
+        #
+        # Deliberately conservative: any one of an id, a material or a loaded
+        # flag is enough to accept it, because no real shelf's payload has
+        # been seen yet and a shelf that reports only some of them must still
+        # come through.
+        if (
+            data.get('id') is None
+            and not data.get('type')
+            and data.get('loaded') is None
+        ):
+            return None
+
         return cls(
             id=data['id'],
             type=data['type'],
@@ -298,14 +329,18 @@ class AnycubicMachineExternalShelves:
         if data is None:
             return None
 
-        self._type = data['type']
-        self._color = data['color']
-        self._loaded = data['loaded']
-        self._status_type = data['status_type']
-        self._current_status = data['current_status']
+        # Coerced exactly as the constructor does. This path wrote whatever
+        # arrived straight onto the slots, so a null over MQTT produced an
+        # object whose own properties then raised on read instead.
+        self._type = as_str(data.get('type'))
+        self._color = as_int_list(data.get('color'))
+        self._loaded = as_int(data.get('loaded'))
+        self._status_type = as_int(data.get('status_type'))
+        self._current_status = as_int(data.get('current_status'))
 
     @property
     def id(self) -> int:
+        """The holder's id, or -1 when the printer did not name one."""
         return self._id
 
     @property
@@ -400,10 +435,10 @@ class AnycubicFeedStatus:
         current_status: int,
         slot_index: int,
     ) -> None:
-        self._code = int(code)
-        self._type = int(type)
-        self._current_status = int(current_status)
-        self._slot_index = int(slot_index)
+        self._code = as_int(code, -1)
+        self._type = as_int(type)
+        self._current_status = as_int(current_status)
+        self._slot_index = as_int(slot_index, -1)
 
     @classmethod
     def from_json(cls, data: dict[str, Any] | None) -> AnycubicFeedStatus | None:
@@ -449,10 +484,10 @@ class AnycubicDryingStatus:
         duration: int,
         remain_time: int,
     ) -> None:
-        self._status = int(status)
-        self._target_temp = int(target_temp)
-        self._duration = int(duration)
-        self._remain_time = int(remain_time)
+        self._status = as_int(status)
+        self._target_temp = as_int(target_temp)
+        self._duration = as_int(duration)
+        self._remain_time = as_int(remain_time)
 
     @classmethod
     def from_json(cls, data: dict[str, Any] | None) -> AnycubicDryingStatus | None:
@@ -691,11 +726,14 @@ class AnycubicMultiColorBox:
         slots: list[dict[str, Any]],
         humidity: float | None = None,
     ) -> None:
+        # `id` keeps raising on purpose: it is the ACE's identity and the
+        # printer dict is keyed by it, so a box with no id cannot be placed.
+        # Everything after it is telemetry and must not be able to sink the box.
         self._id: int = int(id)
-        self._status: int = int(status)
-        self._model_id: int = int(model_id)
-        self._auto_feed: int = int(auto_feed)
-        self._loaded_slot: int = int(loaded_slot)
+        self._status: int = as_int(status)
+        self._model_id: int = as_int(model_id)
+        self._auto_feed: int = as_int(auto_feed)
+        self._loaded_slot: int = as_int(loaded_slot, -1)
         self.set_feed_status(feed_status)
         self.set_current_temperature(temp)
         self._humidity: float | None = (
@@ -712,7 +750,7 @@ class AnycubicMultiColorBox:
                 raise AnycubicDataParsingError(ErrorsDataParsing.ace.format(slots))
 
     def set_auto_feed(self, auto_feed: int) -> None:
-        self._auto_feed = int(auto_feed)
+        self._auto_feed = as_int(auto_feed)
 
     def set_drying_status(self, drying_status: dict[str, Any] | None) -> None:
         self._drying_status = AnycubicDryingStatus.from_json(drying_status)
@@ -721,10 +759,12 @@ class AnycubicMultiColorBox:
         self._feed_status = AnycubicFeedStatus.from_json(feed_status)
 
     def set_slot_loaded(self, slot_num: int) -> None:
-        self._loaded_slot = slot_num
+        self._loaded_slot = as_int(slot_num, -1)
 
     def set_current_temperature(self, temp: int) -> None:
-        self._temp = int(temp)
+        # Reached from the constructor as well as from MQTT, so a null
+        # temperature took the whole box down and not merely the reading.
+        self._temp = as_int(temp)
 
     def update_slots_with_mqtt_data(self, slot_list: list[dict[str, Any]] | None) -> None:
         if slot_list is None:

{anycubic_cloud_api-0.4.26 → anycubic_cloud_api-0.4.28}/src/anycubic_cloud_api/helpers/helpers.py

@@ -17,6 +17,59 @@ REX_GCODE_DATA_KEY_VALUE: re.Pattern[Any] = re.compile(r'; ([a-zA-Z0-9_\[\] ]+)
 REX_PRINT_TOTAL_TIME: re.Pattern[Any] = re.compile(r'^([\d]+)hour([\d]+)min$')
 
 
+def as_int(value: Any, default: int = 0) -> int:
+    """A whole number out of whatever the cloud sent, or `default`.
+
+    Anycubic adds fields and nulls them without warning: firmware 2.0.1.9
+    began sending `external_shelves` with `id` and `loaded` set to null, and
+    `int(None)` raised, which failed the parse of the whole printer and left
+    every entity unavailable behind a config entry stuck in setup_retry.
+
+    Note that `data.get("key", 0)` does NOT protect against this. The default
+    only applies when the key is ABSENT; a key that is present and null hands
+    back None and raises anyway. That is precisely how the above shipped.
+
+    A single unreadable telemetry field is never worth losing the printer
+    over, so this returns the stated fallback rather than raising.
+    """
+    if isinstance(value, bool):
+        # bool is an int subclass, so int(True) is 1 either way -- spelled out
+        # so the behaviour is a decision rather than an accident.
+        return int(value)
+
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def as_str(value: Any, default: str = "") -> str:
+    """Text out of whatever the cloud sent. `None` becomes `default`, not "None"."""
+    if value is None:
+        return default
+
+    return str(value)
+
+
+def as_int_list(value: Any) -> list[int]:
+    """A list of whole numbers, dropping anything that is not one.
+
+    Colours arrive here. A null list, or a list with a null in it, used to
+    raise from inside the comprehension and take the printer down with it.
+    """
+    if not isinstance(value, (list, tuple)):
+        return []
+
+    numbers: list[int] = []
+    for item in value:
+        try:
+            numbers.append(int(item))
+        except (TypeError, ValueError):
+            continue
+
+    return numbers
+
+
 def timedelta_to_total_minutes(
     delta: timedelta,
 ) -> float:

{anycubic_cloud_api-0.4.26 → anycubic_cloud_api-0.4.28/src/anycubic_cloud_api.egg-info}/PKG-INFO

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

{anycubic_cloud_api-0.4.26 → anycubic_cloud_api-0.4.28}/src/anycubic_cloud_api.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ 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_printer_error_codes.py
 tests/test_project_null_status.py

anycubic_cloud_api-0.4.28/tests/test_null_tolerant_parsing.py

@@ -0,0 +1,180 @@
+"""Nulls in the cloud payload must not cost the caller the printer.
+
+Reported as hass-anycubic #28: Anycubic firmware 2.0.1.9 began sending
+`external_shelves` with `id` and `loaded` set to null. `int(None)` raised,
+the whole printer failed to parse, and the config entry sat in setup_retry
+with every entity unavailable -- on a response the cloud had answered
+successfully, carrying complete telemetry.
+
+The trap is worth stating plainly, because the code looked defended:
+
+    data.get('loaded', False)
+
+only supplies the default when the key is ABSENT. A key that is present and
+null returns None, and the int() after it raises anyway. That is exactly how
+this shipped.
+"""
+
+import pytest
+
+from anycubic_cloud_api.data_models.printer_properties import (
+    AnycubicDryingStatus,
+    AnycubicFeedStatus,
+    AnycubicMachineExternalShelves,
+    AnycubicMachineToolInfo,
+    AnycubicMultiColorBox,
+)
+from anycubic_cloud_api.helpers.helpers import as_int, as_int_list, as_str
+
+# Verbatim from the issue, nulls and all.
+SHELVES_2019 = {
+    "brand_name": None,
+    "color": [255, 255, 255],
+    "current_status": 11,
+    "id": None,
+    "loaded": None,
+    "material_name": None,
+    "status_type": 2,
+    "type": "",
+}
+
+
+# A shelf that is actually attached: it names itself and what is in it.
+# Invented, because no real payload has been seen -- so it is deliberately
+# minimal and every test that uses it says what it is relying on.
+SHELF_PRESENT = {
+    "brand_name": "Anycubic",
+    "color": [240, 243, 245],
+    "current_status": 11,
+    "id": 1,
+    "loaded": 1,
+    "material_name": "PLA",
+    "status_type": 2,
+    "type": "PLA",
+}
+
+
+class TestTheReportedPayload:
+    def test_firmware_2019_reports_no_shelf_rather_than_crashing(self):
+        """The payload that took people's printers away.
+
+        It parses now -- and the right answer is that there is no shelf. The
+        reporter had an ACE 2 Pro, represented fully elsewhere in the same
+        response, and no external shelf at all: 2.0.1.9 sends this field
+        whether or not the accessory exists.
+        """
+        assert AnycubicMachineExternalShelves.from_json(SHELVES_2019) is None
+
+    def test_it_does_not_raise(self):
+        """Separate from the assertion above on purpose. The bug was a crash;
+        returning None is the judgement. Both must hold, and a later change to
+        the judgement must not be able to quietly reintroduce the crash."""
+        try:
+            AnycubicMachineExternalShelves.from_json(SHELVES_2019)
+        except Exception as err:  # noqa: BLE001 - the whole point is that nothing escapes
+            pytest.fail(f"the reported payload raised {err!r}")
+
+    @pytest.mark.parametrize("field", sorted(SHELF_PRESENT))
+    def test_a_present_shelf_survives_any_single_null(self, field):
+        """Anycubic nulls fields without warning, so each is checked on its
+        own rather than trusting the next firmware to pick the same two."""
+        payload = dict(SHELF_PRESENT)
+        payload[field] = None
+
+        # Nulling any single field still leaves at least one of id, type or
+        # loaded, so the shelf stays identifiable in every case here.
+        assert AnycubicMachineExternalShelves.from_json(payload) is not None
+
+    def test_a_shelf_known_only_by_its_material_still_counts(self):
+        """Conservative on purpose: no real shelf payload has been seen, so
+        any one of an id, a material or a loaded flag is enough."""
+        payload = dict(SHELVES_2019, type="PLA")
+
+        assert AnycubicMachineExternalShelves.from_json(payload) is not None
+
+    def test_a_shelf_known_only_by_its_id_still_counts(self):
+        payload = dict(SHELVES_2019, id=1)
+
+        shelves = AnycubicMachineExternalShelves.from_json(payload)
+        assert shelves is not None
+        assert shelves.id == 1
+
+    def test_a_null_inside_the_colour_list_is_survived(self):
+        payload = dict(SHELF_PRESENT, color=[255, None, 255])
+
+        assert AnycubicMachineExternalShelves.from_json(payload).color == [255, 255]
+
+    def test_the_mqtt_update_path_is_coerced_too(self):
+        """It wrote raw values onto the slots, so a null landed intact and
+        the object's own properties raised on read instead of on parse."""
+        shelves = AnycubicMachineExternalShelves.from_json(SHELF_PRESENT)
+
+        shelves.update_with_mqtt_data(dict(SHELF_PRESENT, loaded=None, color=None))
+
+        assert shelves.loaded is False
+        assert shelves.color == []
+
+
+class TestTheSiblingsWithTheSameShape:
+    """Every constructor fed by `.get(key, <default>)` had the same hole."""
+
+    def test_feed_status_survives_nulls(self):
+        assert AnycubicFeedStatus.from_json(
+            {"code": None, "type": None, "current_status": None, "slot_index": None}
+        ) is not None
+
+    def test_drying_status_survives_nulls(self):
+        drying = AnycubicDryingStatus.from_json(
+            {"status": None, "target_temp": None, "duration": None, "remain_time": None}
+        )
+
+        assert drying is not None
+        assert drying.is_drying is False
+
+    def test_a_multi_colour_box_survives_null_telemetry(self):
+        box = AnycubicMultiColorBox.from_json({
+            "id": 0, "status": None, "model_id": None, "auto_feed": None,
+            "loaded_slot": None, "temp": None, "slots": [],
+        })
+
+        assert box is not None
+        assert box.loaded_slot == -1
+
+    def test_but_a_box_with_no_id_still_raises(self):
+        """`id` is the ACE's identity and the printer dict is keyed by it.
+        A box that cannot be placed must not be silently invented."""
+        with pytest.raises((TypeError, ValueError, KeyError)):
+            AnycubicMultiColorBox.from_json({"id": None, "slots": []})
+
+    def test_machine_tool_info_survives_nulls(self):
+        assert AnycubicMachineToolInfo.from_json(
+            {k: None for k in (
+                "id", "typd_id", "model_id", "type_function_id", "parent_id",
+                "function_name", "function_des", "control", "param",
+                "icon_url", "function_type", "status", "show_place",
+            )}
+        ) is not None
+
+
+class TestTheCoercionHelpers:
+    @pytest.mark.parametrize(
+        ("value", "expected"),
+        [(None, 0), ("", 0), ("nonsense", 0), ([], 0), (7, 7), ("7", 7), (7.9, 7), (True, 1)],
+    )
+    def test_as_int(self, value, expected):
+        assert as_int(value) == expected
+
+    def test_as_int_uses_the_stated_fallback(self):
+        assert as_int(None, -1) == -1
+
+    def test_as_str_does_not_stringify_none(self):
+        """str(None) is "None", which would read as a filament called None."""
+        assert as_str(None) == ""
+        assert as_str("PLA") == "PLA"
+
+    @pytest.mark.parametrize(
+        ("value", "expected"),
+        [(None, []), ("nope", []), ([1, None, 3], [1, 3]), ([1, 2, 3], [1, 2, 3])],
+    )
+    def test_as_int_list(self, value, expected):
+        assert as_int_list(value) == expected