anycubic-cloud-api 0.2.0__tar.gz → 0.3.0__tar.gz

{anycubic_cloud_api-0.2.0/src/anycubic_cloud_api.egg-info → anycubic_cloud_api-0.3.0}/PKG-INFO

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

{anycubic_cloud_api-0.2.0 → anycubic_cloud_api-0.3.0}/pyproject.toml

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

{anycubic_cloud_api-0.2.0 → anycubic_cloud_api-0.3.0}/src/anycubic_cloud_api/data_models/printer.py

@@ -49,8 +49,34 @@ if TYPE_CHECKING:
     from .printer_properties import AnycubicDryingStatus, AnycubicMaterialMapping
 
 
+def _drain(consumable: Any) -> dict[str, Any]:
+    """Read every remaining key, returning them as a plain dict.
+
+    Reading is what marks a key consumed, and the payload contract fails loudly
+    on anything left behind -- so blocks whose keys vary by model are taken
+    wholesale rather than named one by one.
+    """
+    if not consumable:
+        return {}
+
+    drained = dict(consumable.remaining_data)
+
+    for key in list(drained):
+        consumable.get(key)
+
+    return drained
+
+
 class AnycubicPrinter:
     __slots__ = (
+        "_camera_stream_url",
+        "_file_upload_url",
+        "_features",
+        "_ai_settings",
+        "_chamber_temp",
+        "_target_chamber_temp",
+        "_local_firmware_version",
+        "_local_ip",
         "_ignore_init_errors",
         "_initialisation_error",
         "_api_parent",
@@ -1188,6 +1214,134 @@ class AnycubicPrinter:
                 'brightness': int(light.get('brightness') or 0),
             }
 
+
+    def _process_mqtt_update_info(
+        self,
+        action: str,
+        state: str,
+        payload: AnycubicConsumableData,
+    ) -> None:
+        """A whole-printer snapshot.
+
+        Only the local connection sends this; over the cloud the same ground is
+        covered by the separate status, temperature and fan reports. It is the
+        only place the printer names its own stream and upload endpoints, and
+        the only place it lists which features it physically has.
+        """
+        data = payload['data']
+
+        if not data:
+            return
+
+        urls = data.get('urls')
+
+        if urls:
+            self._camera_stream_url = urls.get('rtspUrl')
+            self._file_upload_url = urls.get('fileUploadurl')
+
+        self._features = _drain(data.get('features')) or self.features
+
+        temp = data.get('temp')
+
+        if temp:
+            if self.parameter:
+                self.parameter.update_current_temps(
+                    temp.get('curr_hotbed_temp'),
+                    temp.get('curr_nozzle_temp'),
+                )
+            # A Kobra S1 reports chamber temperatures of zero because it has no
+            # chamber sensor, so they are kept raw rather than turned into an
+            # always-zero entity.
+            self._chamber_temp = temp.get('curr_chamber_temp')
+            self._target_chamber_temp = temp.get('target_chamber_temp')
+            _drain(temp)
+
+        if 'fan_speed_pct' in data:
+            self._fan_speed = int(data['fan_speed_pct'])
+        if 'print_speed_mode' in data:
+            self._print_speed_mode = int(data['print_speed_mode'])
+
+        self._local_firmware_version = data.get('version')
+        self._local_ip = data.get('ip')
+
+        # Consumed but not modelled: the printer's own name and model strings
+        # duplicate what the device already carries, and the project blocks are
+        # covered by the print report.
+        data.get('printerName')
+        data.get('model')
+        data.get('state')
+        data.get('project')
+        data.get('last_project')
+        data.get('aux_fan_speed_pct')
+        data.get('box_fan_level')
+        _drain(data)
+
+    def _process_mqtt_update_ai_settings(
+        self,
+        action: str,
+        state: str,
+        payload: AnycubicConsumableData,
+    ) -> None:
+        """Foreign-object and first-layer detection settings."""
+        data = payload['data']
+
+        if not data:
+            return
+
+        self._ai_settings = _drain(data.get('ai_settings')) or self.ai_settings
+
+        _drain(data)
+
+
+    @property
+    def camera_stream_url(self) -> str | None:
+        """Where the printer serves its camera, when it says.
+
+        Only reported over the local connection.
+        """
+        return getattr(self, '_camera_stream_url', None)
+
+    @property
+    def file_upload_url(self) -> str | None:
+        """Signed endpoint for uploading gcode straight to the printer."""
+        return getattr(self, '_file_upload_url', None)
+
+    @property
+    def features(self) -> dict[str, Any]:
+        """What this model says it can physically do.
+
+        Reported only over the local connection, and the most reliable way to
+        tell models apart without owning one.
+        """
+        return dict(getattr(self, '_features', {}) or {})
+
+    @property
+    def ai_settings(self) -> dict[str, Any]:
+        """Foreign-object / first-layer detection settings."""
+        return dict(getattr(self, '_ai_settings', {}) or {})
+
+    @property
+    def ai_detection_enabled(self) -> bool | None:
+        settings = self.ai_settings
+        return bool(settings['status']) if 'status' in settings else None
+
+    @property
+    def local_firmware_version(self) -> str | None:
+        return getattr(self, '_local_firmware_version', None)
+
+    @property
+    def chamber_temperature(self) -> float | None:
+        """Chamber temperature, where the printer has a sensor for it.
+
+        An open-frame or unsensored machine reports zero here, which is why
+        this is not turned into an entity without checking it first.
+        """
+        return getattr(self, '_chamber_temp', None)
+
+    @property
+    def target_chamber_temperature(self) -> float | None:
+        return getattr(self, '_target_chamber_temp', None)
+
     def process_mqtt_update(
         self,
         topic: str,
@@ -1242,6 +1396,12 @@ class AnycubicPrinter:
         elif msg_type == 'light':
             self._process_mqtt_update_light(action, state, payload)
 
+        elif msg_type == 'info':
+            self._process_mqtt_update_info(action, state, payload)
+
+        elif msg_type == 'aiSettings':
+            self._process_mqtt_update_ai_settings(action, state, payload)
+
         else:
             raise AnycubicMQTTUnknownUpdate(ErrorsMQTTUpdate.unknown.format(msg_type))
 

{anycubic_cloud_api-0.2.0 → anycubic_cloud_api-0.3.0/src/anycubic_cloud_api.egg-info}/PKG-INFO

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

{anycubic_cloud_api-0.2.0 → anycubic_cloud_api-0.3.0}/src/anycubic_cloud_api.egg-info/SOURCES.txt

@@ -41,4 +41,5 @@ src/anycubic_cloud_api/resources/anycubic_mqqt_tls_client.key
 tests/test_axis_position.py
 tests/test_lan_client.py
 tests/test_lan_handshake.py
+tests/test_lan_reports.py
 tests/test_partial_reports.py

anycubic_cloud_api-0.3.0/tests/test_lan_reports.py

@@ -0,0 +1,214 @@
+"""Parsing the reports only the local connection sends.
+
+The payloads here are captured verbatim from a Kobra S1 on firmware 2.7.2.7 in
+LAN Mode. The payload contract fails loudly on any key left unread, so these
+double as a check that nothing in a real report goes unhandled.
+"""
+
+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
+
+INFO_REPORT = {
+    "type": "info",
+    "action": "report",
+    "timestamp": 244516,
+    "msgid": "b85ca099-9792-4e2d-83df-cdd6f1a7296d",
+    "state": "done",
+    "code": 200,
+    "msg": "done",
+    "data": {
+        "printerName": "Anycubic Kobra S1",
+        "urls": {
+            "fileUploadurl": "http://10.0.66.28:18910/gcode_upload?s=SIGNED",
+            "rtspUrl": "http://10.0.66.28:18088/flv",
+        },
+        "project": None,
+        "last_project": None,
+        "model": "Anycubic Kobra S1",
+        "ip": "10.0.66.28",
+        "version": "2.7.2.7",
+        "state": "free",
+        "temp": {
+            "curr_hotbed_temp": 31,
+            "curr_nozzle_temp": 34,
+            "target_hotbed_temp": 0,
+            "target_nozzle_temp": 0,
+        },
+        "print_speed_mode": 2,
+        "fan_speed_pct": 0,
+        "aux_fan_speed_pct": 0,
+        "box_fan_level": 0,
+        "features": {
+            "auto_leveling_support": True,
+            "vibration_compensation_support": True,
+            "flow_calibration_support": True,
+            "drying_first_support": True,
+            "camera_timelapse_support": True,
+            "gcode_3mf_support": True,
+            "delete_batch_support": True,
+            "preheating_support": True,
+            "fod_support": True,
+            "shengwang_rtc_support": True,
+            "pre_cancel_support": True,
+            "shengwang_rdt_support": True,
+        },
+    },
+}
+
+AI_SETTINGS_REPORT = {
+    "type": "aiSettings",
+    "action": "query",
+    "timestamp": 248130,
+    "msgid": "21af7a88-0205-421f-8f21-3a355bd7e9ff",
+    "state": "done",
+    "code": 200,
+    "msg": "done",
+    "data": {
+        "ai_settings": {
+            "status": 0,
+            "type": 2,
+            "count": 60,
+            "notice_type": [0, 1],
+            "sensitivity_level": [1, 1],
+        }
+    },
+}
+
+TOPIC = "anycubic/anycubicCloud/v1/printer/public/20025/DEVICE/info"
+
+
+def make_printer():
+    return AnycubicPrinter(
+        api_parent=MagicMock(),
+        machine_type=20025,
+        machine_name="Anycubic Kobra S1",
+        id=1,
+        ignore_init_errors=True,
+    )
+
+
+def apply(printer, report):
+    printer.process_mqtt_update(TOPIC, AnycubicConsumableData(report))
+
+
+class TestInfoReport:
+    def test_the_real_report_is_fully_consumed(self):
+        """Anything unread raises -- so this passing means nothing was missed."""
+        apply(make_printer(), INFO_REPORT)
+
+    def test_the_camera_url_is_picked_up(self):
+        printer = make_printer()
+
+        apply(printer, INFO_REPORT)
+
+        assert printer.camera_stream_url == "http://10.0.66.28:18088/flv"
+
+    def test_the_upload_endpoint_is_picked_up(self):
+        printer = make_printer()
+
+        apply(printer, INFO_REPORT)
+
+        assert printer.file_upload_url.endswith("/gcode_upload?s=SIGNED")
+
+    def test_the_capability_map_is_kept(self):
+        """The most reliable way to tell models apart without owning one."""
+        printer = make_printer()
+
+        apply(printer, INFO_REPORT)
+
+        assert printer.features["fod_support"] is True
+        assert printer.features["camera_timelapse_support"] is True
+        assert len(printer.features) == 12
+
+    def test_the_firmware_version_is_kept(self):
+        printer = make_printer()
+
+        apply(printer, INFO_REPORT)
+
+        assert printer.local_firmware_version == "2.7.2.7"
+
+    def test_fan_and_speed_are_applied(self):
+        printer = make_printer()
+
+        apply(printer, INFO_REPORT)
+
+        assert printer._fan_speed == 0
+        assert printer._print_speed_mode == 2
+
+    def test_a_chamberless_printer_reports_nothing_for_it(self):
+        """A Kobra S1 has no chamber sensor and simply omits the fields."""
+        printer = make_printer()
+
+        apply(printer, INFO_REPORT)
+
+        assert printer.chamber_temperature is None
+
+    def test_a_chamber_reading_is_kept_when_present(self):
+        printer = make_printer()
+        report = {**INFO_REPORT, "data": {**INFO_REPORT["data"]}}
+        report["data"]["temp"] = {**report["data"]["temp"], "curr_chamber_temp": 41}
+
+        apply(printer, report)
+
+        assert printer.chamber_temperature == 41
+
+    @pytest.mark.parametrize(
+        "missing", ["urls", "features", "temp", "version", "print_speed_mode"]
+    )
+    def test_a_report_missing_a_block_still_parses(self, missing):
+        """Other models will not send all of these."""
+        report = {**INFO_REPORT, "data": {**INFO_REPORT["data"]}}
+        del report["data"][missing]
+
+        apply(make_printer(), report)
+
+    def test_an_empty_report_is_harmless(self):
+        apply(make_printer(), {**INFO_REPORT, "data": {}})
+
+    def test_a_later_report_without_features_keeps_the_known_ones(self):
+        printer = make_printer()
+        apply(printer, INFO_REPORT)
+
+        stripped = {**INFO_REPORT, "data": {**INFO_REPORT["data"]}}
+        del stripped["data"]["features"]
+        apply(printer, stripped)
+
+        assert len(printer.features) == 12
+
+
+class TestAiSettings:
+    def test_the_real_report_is_fully_consumed(self):
+        apply(make_printer(), AI_SETTINGS_REPORT)
+
+    def test_the_settings_are_kept(self):
+        printer = make_printer()
+
+        apply(printer, AI_SETTINGS_REPORT)
+
+        assert printer.ai_settings["count"] == 60
+        assert printer.ai_settings["sensitivity_level"] == [1, 1]
+
+    def test_detection_off_reads_false_not_none(self):
+        printer = make_printer()
+
+        apply(printer, AI_SETTINGS_REPORT)
+
+        assert printer.ai_detection_enabled is False
+
+    def test_detection_on_reads_true(self):
+        printer = make_printer()
+        report = {"data": {"ai_settings": {"status": 1}}, **{
+            k: v for k, v in AI_SETTINGS_REPORT.items() if k != "data"
+        }}
+
+        apply(printer, report)
+
+        assert printer.ai_detection_enabled is True
+
+    def test_an_unseen_printer_reports_nothing(self):
+        assert make_printer().ai_detection_enabled is None
+        assert make_printer().ai_settings == {}