pycentauri 0.1.0__tar.gz → 0.1.1__tar.gz

pycentauri-0.1.1/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+All notable changes to this project are documented here. This project follows
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html) and [Keep a
+Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [Unreleased]
+
+## [0.1.1] - 2026-04-22
+
+### Fixed
+- `Printer.status()`, `attributes()`, and all control methods hung
+  indefinitely when the printer was in a paused or errored state. The
+  firmware doesn't push `Attributes` spontaneously outside idle/active
+  states, and every SDCP command needs a `MainboardID` in its envelope,
+  so the client would deadlock waiting for a push that never comes.
+- The CLI and MCP server now pre-discover the printer over UDP before
+  opening the WebSocket and pass the mainboard ID into `Printer.connect()`.
+
+### Added
+- `Printer.connect(..., mainboard_id=...)` — pre-seed the mainboard ID
+  (e.g. from a prior `discover()`) so the client can send commands
+  immediately, without waiting for the printer's first `Attributes` push.
+- `Printer.wait_for_mainboard()` now raises a `PrinterError` with a
+  pointer at the `mainboard_id=` workaround instead of a bare
+  `asyncio.TimeoutError`.
+
+### Changed
+- `discover()` retransmits the probe multiple times within the timeout
+  window, improving reliability on busy or lossy networks. Also binds
+  explicitly to `0.0.0.0` so loopback delivery works on macOS.
+
+### Known limits
+- Elegoo firmware accepts at most **5 concurrent WebSocket connections**
+  on port 3030. The 6th attempt is rejected at the HTTP upgrade with
+  `HTTP 500 "too many client"`. Slots release immediately on close.
+
+## [0.1.0] - 2026-04-22
+
+### Added
+- Async Python client for Elegoo Centauri Carbon printers speaking SDCP v3 over
+  WebSocket (`ws://<host>:3030/websocket`).
+- UDP broadcast discovery on port 3000 with the `M99999` probe.
+- MJPEG snapshot grabber for the built-in webcam
+  (`/network-device-manager/network/camera`).
+- `centauri` CLI with `discover`, `status`, `watch`, `snapshot`, `attributes`,
+  `files`, `print {start,pause,resume,stop}`, `upload`, `mcp`.
+- Optional MCP server (`python -m pycentauri.mcp`) with read-only tools by
+  default; control tools registered only when `--enable-control` is set.
+- Apache-2.0 license.

{pycentauri-0.1.0 → pycentauri-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycentauri
-Version: 0.1.0
+Version: 0.1.1
 Summary: Python client and MCP server for Elegoo Centauri Carbon 3D printers
 Project-URL: Homepage, https://github.com/bjan/pycentauri
 Project-URL: Repository, https://github.com/bjan/pycentauri
@@ -145,6 +145,21 @@ Control actions are gated behind an explicit `enable_control=True` (library) or
 registered when the flag is off, so an LLM never sees them. Still: leaving a
 printer running unattended with write-capable agents is your responsibility.
 
+## Known firmware quirks
+
+- **5 concurrent WebSocket connections max.** The printer's SDCP server
+  accepts up to 5 open WebSockets on port 3030; the 6th returns HTTP 500
+  with body `"too many client"`. Slots release immediately when a
+  connection closes — the CLI and MCP server each open/close one per
+  invocation, so this is almost never a problem in practice.
+- **Paused / errored states don't auto-push Attributes.** The printer only
+  sends its `Attributes` frame spontaneously while idle or printing. In
+  paused and errored states it stays silent until asked. Since every SDCP
+  command needs the printer's `MainboardID`, the client takes care of this
+  by pre-seeding the mainboard ID from a UDP discovery on every connect
+  (as of v0.1.1). If you call `Printer.connect()` directly without
+  discovery, pass `mainboard_id=` yourself.
+
 ## Credits & licensing
 
 - Protocol reference: [`elegoo-link`](https://github.com/ELEGOO-3D/elegoo-link)

{pycentauri-0.1.0 → pycentauri-0.1.1}/README.md

@@ -106,6 +106,21 @@ Control actions are gated behind an explicit `enable_control=True` (library) or
 registered when the flag is off, so an LLM never sees them. Still: leaving a
 printer running unattended with write-capable agents is your responsibility.
 
+## Known firmware quirks
+
+- **5 concurrent WebSocket connections max.** The printer's SDCP server
+  accepts up to 5 open WebSockets on port 3030; the 6th returns HTTP 500
+  with body `"too many client"`. Slots release immediately when a
+  connection closes — the CLI and MCP server each open/close one per
+  invocation, so this is almost never a problem in practice.
+- **Paused / errored states don't auto-push Attributes.** The printer only
+  sends its `Attributes` frame spontaneously while idle or printing. In
+  paused and errored states it stays silent until asked. Since every SDCP
+  command needs the printer's `MainboardID`, the client takes care of this
+  by pre-seeding the mainboard ID from a UDP discovery on every connect
+  (as of v0.1.1). If you call `Printer.connect()` directly without
+  discovery, pass `mainboard_id=` yourself.
+
 ## Credits & licensing
 
 - Protocol reference: [`elegoo-link`](https://github.com/ELEGOO-3D/elegoo-link)

{pycentauri-0.1.0 → pycentauri-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pycentauri"
-version = "0.1.0"
+version = "0.1.1"
 description = "Python client and MCP server for Elegoo Centauri Carbon 3D printers"
 readme = "README.md"
 license = "Apache-2.0"

{pycentauri-0.1.0 → pycentauri-0.1.1}/src/pycentauri/__init__.py

@@ -15,4 +15,4 @@ __all__ = [
     "discover",
 ]
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"

{pycentauri-0.1.0 → pycentauri-0.1.1}/src/pycentauri/cli.py

@@ -55,9 +55,21 @@ def _echo_err(msg: str) -> None:
     typer.echo(msg, err=True)
 
 
-async def _resolve_host(host: str | None) -> str:
+async def _resolve_target(host: str | None) -> tuple[str, str | None]:
+    """Return (host, mainboard_id). Mainboard_id may be None if discovery failed.
+
+    Always runs a brief UDP discovery so we can pre-seed the mainboard ID on
+    ``Printer.connect()`` — the printer doesn't push Attributes in paused/
+    errored states, and without a mainboard ID every command would hang.
+    """
     if host:
-        return host
+        # Short discovery to learn the mainboard; don't fail if it times out.
+        found = await discover_printers(timeout=1.0, retries=2)
+        for p in found:
+            if p.host == host and p.mainboard_id:
+                return host, p.mainboard_id
+        return host, None
+
     found = await discover_printers(timeout=2.5)
     if not found:
         _echo_err("No printers found on the LAN. Pass --host explicitly.")
@@ -67,7 +79,7 @@ async def _resolve_host(host: str | None) -> str:
         for p in found:
             _echo_err(f"  {p.host}  {p.machine_name or '?'}  {p.firmware_version or '?'}")
         raise typer.Exit(code=2)
-    return found[0].host
+    return found[0].host, found[0].mainboard_id
 
 
 def _run(coro: asyncio.coroutines.Coroutine[object, object, object]) -> object:  # type: ignore[name-defined]
@@ -128,8 +140,8 @@ def cmd_status(host: HostOpt = None, as_json: JsonOpt = False) -> None:
     """Print the printer's current status once and exit."""
 
     async def run() -> None:
-        h = await _resolve_host(host)
-        async with await Printer.connect(h) as printer:
+        h, mid = await _resolve_target(host)
+        async with await Printer.connect(h, mainboard_id=mid) as printer:
             st = await printer.status()
         if as_json:
             typer.echo(json.dumps(st.raw, indent=2, default=str))
@@ -178,8 +190,8 @@ def cmd_watch(
     """Stream live status updates until interrupted (Ctrl-C)."""
 
     async def run() -> None:
-        h = await _resolve_host(host)
-        async with await Printer.connect(h, push_period_ms=period_ms) as printer:
+        h, mid = await _resolve_target(host)
+        async with await Printer.connect(h, push_period_ms=period_ms, mainboard_id=mid) as printer:
             async for st in printer.watch():
                 if as_json:
                     typer.echo(json.dumps(st.raw, default=str))
@@ -201,8 +213,8 @@ def cmd_attributes(host: HostOpt = None, as_json: JsonOpt = False) -> None:
     """Print the printer's attributes (model, firmware, capabilities)."""
 
     async def run() -> None:
-        h = await _resolve_host(host)
-        async with await Printer.connect(h) as printer:
+        h, mid = await _resolve_target(host)
+        async with await Printer.connect(h, mainboard_id=mid) as printer:
             attrs = await printer.attributes()
         if as_json:
             typer.echo(json.dumps(attrs.raw, indent=2, default=str))
@@ -226,8 +238,8 @@ def cmd_snapshot(
     """Save a JPEG snapshot from the built-in webcam."""
 
     async def run() -> None:
-        h = await _resolve_host(host)
-        async with await Printer.connect(h) as printer:
+        h, mid = await _resolve_target(host)
+        async with await Printer.connect(h, mainboard_id=mid) as printer:
             jpeg = await printer.snapshot(timeout=timeout)
         if str(out) == "-":
             sys.stdout.buffer.write(jpeg)
@@ -266,8 +278,8 @@ def cmd_print_start(
         raise typer.Exit(code=2)
 
     async def run() -> None:
-        h = await _resolve_host(host)
-        async with await Printer.connect(h, enable_control=True) as printer:
+        h, mid = await _resolve_target(host)
+        async with await Printer.connect(h, enable_control=True, mainboard_id=mid) as printer:
             result = await printer.start_print(
                 filename, storage=storage, auto_leveling=auto_leveling, timelapse=timelapse
             )
@@ -284,8 +296,8 @@ def cmd_print_pause(host: HostOpt = None, enable_control: ControlOpt = False) ->
         raise typer.Exit(code=2)
 
     async def run() -> None:
-        h = await _resolve_host(host)
-        async with await Printer.connect(h, enable_control=True) as printer:
+        h, mid = await _resolve_target(host)
+        async with await Printer.connect(h, enable_control=True, mainboard_id=mid) as printer:
             await printer.pause()
         typer.echo("paused")
 
@@ -300,8 +312,8 @@ def cmd_print_resume(host: HostOpt = None, enable_control: ControlOpt = False) -
         raise typer.Exit(code=2)
 
     async def run() -> None:
-        h = await _resolve_host(host)
-        async with await Printer.connect(h, enable_control=True) as printer:
+        h, mid = await _resolve_target(host)
+        async with await Printer.connect(h, enable_control=True, mainboard_id=mid) as printer:
             await printer.resume()
         typer.echo("resumed")
 
@@ -316,8 +328,8 @@ def cmd_print_stop(host: HostOpt = None, enable_control: ControlOpt = False) ->
         raise typer.Exit(code=2)
 
     async def run() -> None:
-        h = await _resolve_host(host)
-        async with await Printer.connect(h, enable_control=True) as printer:
+        h, mid = await _resolve_target(host)
+        async with await Printer.connect(h, enable_control=True, mainboard_id=mid) as printer:
             await printer.stop()
         typer.echo("stop sent")
 

{pycentauri-0.1.0 → pycentauri-0.1.1}/src/pycentauri/client.py

@@ -69,6 +69,7 @@ class Printer:
         *,
         enable_control: bool = False,
         push_period_ms: int = DEFAULT_PUSH_PERIOD_MS,
+        mainboard_id: str | None = None,
     ) -> None:
         self.host = host
         self.enable_control = enable_control
@@ -76,9 +77,11 @@ class Printer:
 
         self._ws: ClientConnection | None = None
         self._reader: asyncio.Task[None] | None = None
-        self._mainboard_id: str | None = None
+        self._mainboard_id: str | None = mainboard_id or None
 
         self._mainboard_event = asyncio.Event()
+        if self._mainboard_id:
+            self._mainboard_event.set()
         self._latest_status: Status | None = None
         self._latest_status_event = asyncio.Event()
         self._latest_attributes: Attributes | None = None
@@ -96,9 +99,23 @@ class Printer:
         enable_control: bool = False,
         push_period_ms: int = DEFAULT_PUSH_PERIOD_MS,
         connect_timeout: float = DEFAULT_CONNECT_TIMEOUT,
+        mainboard_id: str | None = None,
     ) -> Self:
-        """Open a WebSocket to the printer and start the reader task."""
-        self = cls(host, enable_control=enable_control, push_period_ms=push_period_ms)
+        """Open a WebSocket to the printer and start the reader task.
+
+        ``mainboard_id`` lets callers pre-seed the printer's serial/mainboard
+        identifier (e.g. from a prior discovery). When set, the client will
+        not wait for the printer's spontaneous ``Attributes`` push before
+        sending commands — which matters in paused/error states, where the
+        firmware doesn't push Attributes until prompted, and every command
+        requires ``MainboardID`` in its envelope.
+        """
+        self = cls(
+            host,
+            enable_control=enable_control,
+            push_period_ms=push_period_ms,
+            mainboard_id=mainboard_id,
+        )
         url = f"ws://{host}:{WS_PORT}{WS_PATH}"
         self._ws = await asyncio.wait_for(connect(url, max_size=None), timeout=connect_timeout)
         self._reader = asyncio.create_task(self._read_loop(), name=f"pycentauri-reader-{host}")
@@ -125,20 +142,26 @@ class Printer:
         return self._mainboard_id
 
     async def wait_for_mainboard(self, timeout: float = 5.0) -> str:
-        """Block until the printer has reported its mainboard ID."""
+        """Block until the printer has reported its mainboard ID.
+
+        Returns immediately if ``mainboard_id=`` was passed to
+        :meth:`connect`. Otherwise waits for the first ``Attributes`` push
+        from the printer. The printer only pushes Attributes spontaneously
+        in idle/active states — when paused or errored it stays silent until
+        asked, so callers that run in those states should pass ``mainboard_id``
+        explicitly (e.g. from a prior :func:`pycentauri.discover`).
+        """
         if self._mainboard_id:
             return self._mainboard_id
-        # The printer sends an Attributes push shortly after connect; a fresh
-        # GET_PRINTER_ATTRIBUTES also triggers one. Fire one off just in case.
-        with contextlib.suppress(Exception):
-            await self._send_raw(
-                sdcp.encode(
-                    sdcp.build_request(
-                        sdcp.Cmd.GET_PRINTER_ATTRIBUTES, None, self._mainboard_id or ""
-                    )
-                )
-            )
-        await asyncio.wait_for(self._mainboard_event.wait(), timeout=timeout)
+        try:
+            await asyncio.wait_for(self._mainboard_event.wait(), timeout=timeout)
+        except asyncio.TimeoutError as err:
+            raise PrinterError(
+                "printer did not push Attributes within "
+                f"{timeout}s. Pass mainboard_id=... to Printer.connect() "
+                "(discover() provides one) — the firmware does not push "
+                "Attributes while paused or errored."
+            ) from err
         assert self._mainboard_id is not None
         return self._mainboard_id
 

{pycentauri-0.1.0 → pycentauri-0.1.1}/src/pycentauri/discovery.py

@@ -68,19 +68,22 @@ async def discover(
     timeout: float = DEFAULT_TIMEOUT,
     broadcast_address: str = "255.255.255.255",
     port: int = DISCOVERY_PORT,
+    retries: int = 3,
 ) -> list[DiscoveredPrinter]:
     """Broadcast the SDCP discovery probe and collect responders.
 
     Blocks for ``timeout`` seconds. Returns one entry per responding printer,
-    de-duplicated by source IP. Safe to call concurrently from multiple
-    tasks; each call uses its own UDP socket.
+    de-duplicated by source IP. The probe is retransmitted ``retries`` times
+    at evenly-spaced intervals within the timeout window, since UDP probes
+    can be dropped on busy or congested networks. Safe to call concurrently
+    from multiple tasks; each call uses its own UDP socket.
     """
     loop = asyncio.get_running_loop()
 
     sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
     sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    sock.bind(("", 0))
+    sock.bind(("0.0.0.0", 0))
     sock.setblocking(False)
 
     transport, protocol = await loop.create_datagram_endpoint(
@@ -88,8 +91,15 @@ async def discover(
         sock=sock,
     )
     try:
-        transport.sendto(DISCOVERY_PROBE, (broadcast_address, port))
-        await asyncio.sleep(timeout)
+        tries = max(1, retries)
+        interval = timeout / max(tries, 1) / 2
+        for _ in range(tries):
+            transport.sendto(DISCOVERY_PROBE, (broadcast_address, port))
+            await asyncio.sleep(interval)
+        # Listen for the remainder of the budget for late replies.
+        remaining = max(0.0, timeout - interval * tries)
+        if remaining:
+            await asyncio.sleep(remaining)
     finally:
         transport.close()
 

{pycentauri-0.1.0 → pycentauri-0.1.1}/src/pycentauri/mcp/server.py

@@ -40,6 +40,24 @@ def _resolve_host() -> str:
     return host
 
 
+async def _resolve_target() -> tuple[str, str | None]:
+    """Resolve (host, mainboard_id) with a brief discovery.
+
+    Caches the mainboard ID in the process env after the first successful
+    lookup so subsequent tool invocations don't each pay the discovery cost.
+    """
+    host = _resolve_host()
+    cached = os.environ.get("PYCENTAURI_MAINBOARD_ID")
+    if cached:
+        return host, cached
+    found = await _lan_discover(timeout=1.0, retries=2)
+    for p in found:
+        if p.host == host and p.mainboard_id:
+            os.environ["PYCENTAURI_MAINBOARD_ID"] = p.mainboard_id
+            return host, p.mainboard_id
+    return host, None
+
+
 def build_server(*, enable_control: bool = False) -> FastMCP:
     """Construct the FastMCP server, registering tools per the control flag.
 
@@ -55,8 +73,8 @@ def build_server(*, enable_control: bool = False) -> FastMCP:
         Includes state code, job filename, progress %, layer, temperatures
         (nozzle / bed / chamber), fan speeds, and the raw SDCP payload.
         """
-        host = _resolve_host()
-        async with await Printer.connect(host) as printer:
+        host, mid = await _resolve_target()
+        async with await Printer.connect(host, mainboard_id=mid) as printer:
             st = await printer.status()
         return {
             "host": host,
@@ -82,8 +100,8 @@ def build_server(*, enable_control: bool = False) -> FastMCP:
     @mcp.tool()
     async def get_attributes() -> dict[str, Any]:
         """Return printer attributes: model, firmware, mainboard ID, capabilities."""
-        host = _resolve_host()
-        async with await Printer.connect(host) as printer:
+        host, mid = await _resolve_target()
+        async with await Printer.connect(host, mainboard_id=mid) as printer:
             attrs = await printer.attributes()
         return {
             "host": host,
@@ -102,8 +120,8 @@ def build_server(*, enable_control: bool = False) -> FastMCP:
         The image is returned inline so the agent can see what the printer
         is currently doing (e.g. to spot layer shifts or spaghetti).
         """
-        host = _resolve_host()
-        async with await Printer.connect(host) as printer:
+        host, mid = await _resolve_target()
+        async with await Printer.connect(host, mainboard_id=mid) as printer:
             jpeg = await printer.snapshot()
         return Image(data=jpeg, format="jpeg")
 
@@ -144,8 +162,8 @@ def build_server(*, enable_control: bool = False) -> FastMCP:
         ``"local"`` (default) or ``"udisk"``. Ask the user for confirmation
         before invoking — running a print unattended is the user's risk.
         """
-        host = _resolve_host()
-        async with await Printer.connect(host, enable_control=True) as printer:
+        host, mid = await _resolve_target()
+        async with await Printer.connect(host, enable_control=True, mainboard_id=mid) as printer:
             result = await printer.start_print(
                 filename,
                 storage=storage,
@@ -157,24 +175,24 @@ def build_server(*, enable_control: bool = False) -> FastMCP:
     @mcp.tool()
     async def pause_print() -> dict[str, Any]:
         """DESTRUCTIVE. Pause the current print. Ask the user before invoking."""
-        host = _resolve_host()
-        async with await Printer.connect(host, enable_control=True) as printer:
+        host, mid = await _resolve_target()
+        async with await Printer.connect(host, enable_control=True, mainboard_id=mid) as printer:
             result = await printer.pause()
         return {"ok": True, "response": result.inner}
 
     @mcp.tool()
     async def resume_print() -> dict[str, Any]:
         """Resume a paused print."""
-        host = _resolve_host()
-        async with await Printer.connect(host, enable_control=True) as printer:
+        host, mid = await _resolve_target()
+        async with await Printer.connect(host, enable_control=True, mainboard_id=mid) as printer:
             result = await printer.resume()
         return {"ok": True, "response": result.inner}
 
     @mcp.tool()
     async def stop_print() -> dict[str, Any]:
         """DESTRUCTIVE. Stop the current print. Ask the user before invoking."""
-        host = _resolve_host()
-        async with await Printer.connect(host, enable_control=True) as printer:
+        host, mid = await _resolve_target()
+        async with await Printer.connect(host, enable_control=True, mainboard_id=mid) as printer:
             result = await printer.stop()
         return {"ok": True, "response": result.inner}
 

{pycentauri-0.1.0 → pycentauri-0.1.1}/tests/test_client.py

@@ -185,6 +185,57 @@ async def test_control_disabled_by_default(monkeypatch: pytest.MonkeyPatch) -> N
                 await printer.stop()
 
 
+async def test_preseeded_mainboard_skips_attributes_wait(monkeypatch: pytest.MonkeyPatch) -> None:
+    """When the caller passes mainboard_id=, commands work before Attributes arrive.
+
+    Simulates the paused-printer scenario: the fake server only pushes
+    Attributes after it sees a subscribe, so a client that waits for
+    Attributes before subscribing would deadlock. With mainboard_id=
+    preset, the client can subscribe immediately.
+    """
+
+    class _SilentPrinter(_FakePrinter):
+        async def _handler(self, ws) -> None:  # type: ignore[no-untyped-def,override]
+            # Do NOT push Attributes automatically — only reply to commands.
+            async for raw in ws:
+                try:
+                    msg = json.loads(raw)
+                except json.JSONDecodeError:
+                    continue
+                self.received.append(msg)
+                data = msg.get("Data") or {}
+                cmd = data.get("Cmd")
+                request_id = data.get("RequestID")
+                await ws.send(
+                    json.dumps(
+                        {
+                            "Id": MAINBOARD,
+                            "Topic": f"sdcp/response/{MAINBOARD}",
+                            "Data": {
+                                "Cmd": cmd,
+                                "RequestID": request_id,
+                                "MainboardID": MAINBOARD,
+                                "Data": {"Ack": 0},
+                            },
+                        }
+                    )
+                )
+
+    server = _SilentPrinter()
+    await server.start()
+    try:
+        monkeypatch.setattr("pycentauri.client.WS_PORT", server.port)
+        async with await Printer.connect(
+            "127.0.0.1", enable_control=True, mainboard_id=MAINBOARD
+        ) as printer:
+            # Must work without any Attributes push ever arriving.
+            result = await asyncio.wait_for(printer.pause(), timeout=3)
+            assert result.inner is not None and result.inner["Data"]["Ack"] == 0
+        assert any(m["Data"]["Cmd"] == int(Cmd.PAUSE_PRINT) for m in server.received)
+    finally:
+        await server.stop()
+
+
 async def test_control_enabled_sends_commands(monkeypatch: pytest.MonkeyPatch) -> None:
     async with _fake_printer() as server:
         monkeypatch.setattr("pycentauri.client.WS_PORT", server.port)

pycentauri-0.1.1/tests/test_discovery.py

@@ -0,0 +1,63 @@
+"""Unit tests for discovery response parsing.
+
+We test the parser against canned responses rather than exercising the full
+UDP round-trip — loopback UDP timing is flaky across CI runners (macOS and
+some Python versions drop packets sent to 127.0.0.1 from a wildcard-bound
+socket within a short window). The actual broadcast is verified live against
+a real printer.
+"""
+
+from __future__ import annotations
+
+import json
+
+from pycentauri.discovery import _parse_response
+
+
+def test_parse_response_populates_fields() -> None:
+    raw = json.dumps(
+        {
+            "Id": "fake",
+            "Data": {
+                "Name": "fake-carbon",
+                "MachineName": "Centauri Carbon",
+                "MainboardID": "ffffffff",
+                "FirmwareVersion": "V0.0.1",
+            },
+        }
+    ).encode("utf-8")
+
+    p = _parse_response(raw, "192.168.1.209")
+    assert p is not None
+    assert p.host == "192.168.1.209"
+    assert p.mainboard_id == "ffffffff"
+    assert p.name == "fake-carbon"
+    assert p.machine_name == "Centauri Carbon"
+    assert p.firmware_version == "V0.0.1"
+
+
+def test_parse_response_handles_missing_keys() -> None:
+    """Older firmware may omit some fields — parser should still return a row."""
+    raw = json.dumps({"Id": "fake", "Data": {"MainboardID": "aa"}}).encode("utf-8")
+    p = _parse_response(raw, "10.0.0.5")
+    assert p is not None
+    assert p.mainboard_id == "aa"
+    assert p.name is None
+    assert p.machine_name is None
+
+
+def test_parse_response_rejects_non_json() -> None:
+    assert _parse_response(b"M99999", "10.0.0.5") is None
+    assert _parse_response(b"\xff\xfe", "10.0.0.5") is None
+
+
+def test_parse_response_rejects_non_object() -> None:
+    assert _parse_response(b'"just a string"', "10.0.0.5") is None
+    assert _parse_response(b"[1, 2, 3]", "10.0.0.5") is None
+
+
+def test_parse_response_tolerates_missing_data_block() -> None:
+    raw = json.dumps({"Id": "fake", "MainboardID": "bb"}).encode("utf-8")
+    p = _parse_response(raw, "10.0.0.5")
+    assert p is not None
+    assert p.mainboard_id == "bb"

pycentauri-0.1.0/CHANGELOG.md

@@ -1,21 +0,0 @@
-# Changelog
-
-All notable changes to this project are documented here. This project follows
-[Semantic Versioning](https://semver.org/spec/v2.0.0.html) and [Keep a
-Changelog](https://keepachangelog.com/en/1.1.0/).
-
-## [Unreleased]
-
-## [0.1.0] - TBD
-
-### Added
-- Async Python client for Elegoo Centauri Carbon printers speaking SDCP v3 over
-  WebSocket (`ws://<host>:3030/websocket`).
-- UDP broadcast discovery on port 3000 with the `M99999` probe.
-- MJPEG snapshot grabber for the built-in webcam
-  (`/network-device-manager/network/camera`).
-- `centauri` CLI with `discover`, `status`, `watch`, `snapshot`, `attributes`,
-  `files`, `print {start,pause,resume,stop}`, `upload`, `mcp`.
-- Optional MCP server (`python -m pycentauri.mcp`) with read-only tools by
-  default; control tools registered only when `--enable-control` is set.
-- Apache-2.0 license.

pycentauri-0.1.0/tests/test_discovery.py

@@ -1,63 +0,0 @@
-"""Loopback UDP test for the discovery probe."""
-
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import json
-import socket
-
-import pytest
-
-from pycentauri.discovery import DISCOVERY_PROBE, discover
-
-
-@pytest.fixture()
-def fake_responder() -> tuple[socket.socket, int]:
-    """Bind a UDP socket on localhost that replies to the SDCP probe."""
-    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    sock.bind(("127.0.0.1", 0))
-    _, port = sock.getsockname()
-    return sock, port
-
-
-async def test_discover_parses_response(fake_responder: tuple[socket.socket, int]) -> None:
-    sock, port = fake_responder
-
-    async def responder() -> None:
-        loop = asyncio.get_running_loop()
-        sock.setblocking(False)
-        while True:
-            try:
-                data, addr = await loop.sock_recvfrom(sock, 1024)
-            except (asyncio.CancelledError, OSError):
-                break
-            if data != DISCOVERY_PROBE:
-                continue
-            reply = json.dumps(
-                {
-                    "Id": "fake",
-                    "Data": {
-                        "Name": "fake-carbon",
-                        "MachineName": "Centauri Carbon",
-                        "MainboardID": "ffffffff",
-                        "FirmwareVersion": "V0.0.1",
-                    },
-                }
-            ).encode("utf-8")
-            sock.sendto(reply, addr)
-
-    task = asyncio.create_task(responder())
-    try:
-        found = await discover(timeout=0.3, broadcast_address="127.0.0.1", port=port)
-    finally:
-        task.cancel()
-        with contextlib.suppress(asyncio.CancelledError, Exception):
-            await task
-        sock.close()
-
-    assert len(found) == 1
-    p = found[0]
-    assert p.mainboard_id == "ffffffff"
-    assert p.machine_name == "Centauri Carbon"
-    assert p.firmware_version == "V0.0.1"