pycentauri 0.1.0__py3-none-any.whl

pycentauri/models.py

@@ -0,0 +1,229 @@
+"""Typed views over SDCP status and attribute payloads.
+
+The printer emits JSON with ``PascalCase`` keys and temperatures as
+``[target, actual]`` pairs. These models present a Python-friendly facade
+while keeping the raw dict around (``.raw``) for forward-compatibility when
+the firmware adds fields.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class PrintInfo(BaseModel):
+    """Inner ``PrintInfo`` block describing the current print job.
+
+    The printer mixes int and float for tick/time fields across firmware
+    revisions, so the numeric fields here accept both.
+    """
+
+    model_config = ConfigDict(extra="allow", populate_by_name=True)
+
+    status: int | None = Field(default=None, alias="Status")
+    filename: str | None = Field(default=None, alias="Filename")
+    current_layer: int | None = Field(default=None, alias="CurrentLayer")
+    total_layer: int | None = Field(default=None, alias="TotalLayer")
+    current_ticks: float | None = Field(default=None, alias="CurrentTicks")
+    total_ticks: float | None = Field(default=None, alias="TotalTicks")
+    progress: int | None = Field(default=None, alias="Progress")
+    err_num: int | None = Field(default=None, alias="ErrNum")
+    print_speed: int | None = Field(default=None, alias="PrintSpeedPct")
+    task_id: str | None = Field(default=None, alias="TaskId")
+
+
+def _extract_temp(
+    payload: dict[str, Any], actual_key: str, target_key: str
+) -> tuple[float | None, float | None]:
+    """Read a temperature field.
+
+    Two wire formats exist in the wild:
+
+    * Current Centauri Carbon firmware (V1.1.x): ``TempOfNozzle`` is a scalar
+      and ``TempTargetNozzle`` is a separate scalar.
+    * Older / CentauriLink-documented firmware: ``TempOfNozzle`` is a
+      ``[target, actual]`` pair and no ``TempTarget*`` is sent.
+    """
+    raw_actual = payload.get(actual_key)
+    raw_target = payload.get(target_key)
+    actual: float | None = None
+    target: float | None = None
+    if isinstance(raw_actual, (int, float)):
+        actual = float(raw_actual)
+    elif isinstance(raw_actual, (list, tuple)) and len(raw_actual) >= 2:
+        with _suppress_convert():
+            target = float(raw_actual[0])
+        with _suppress_convert():
+            actual = float(raw_actual[1])
+    if target is None and isinstance(raw_target, (int, float)):
+        target = float(raw_target)
+    return actual, target
+
+
+class _suppress_convert:
+    def __enter__(self) -> None:
+        return None
+
+    def __exit__(self, exc_type: object, exc: object, tb: object) -> bool:
+        return isinstance(exc, (TypeError, ValueError))
+
+
+def _parse_coord(raw: Any) -> tuple[float, float, float] | None:
+    """Parse a ``"x,y,z"`` coord string into a tuple of floats."""
+    if not isinstance(raw, str):
+        return None
+    parts = raw.split(",")
+    if len(parts) != 3:
+        return None
+    try:
+        return (float(parts[0]), float(parts[1]), float(parts[2]))
+    except (TypeError, ValueError):
+        return None
+
+
+class Status(BaseModel):
+    """Normalised view of the ``Status`` payload from an SDCP push.
+
+    The raw payload is always kept on ``.raw`` — new firmware fields show up
+    there automatically even if we haven't added a typed accessor yet.
+    """
+
+    model_config = ConfigDict(extra="allow")
+
+    raw: dict[str, Any]
+    current_status: list[int] = Field(default_factory=list)
+    print_info: PrintInfo | None = None
+
+    temp_nozzle: float | None = None
+    temp_nozzle_target: float | None = None
+    temp_bed: float | None = None
+    temp_bed_target: float | None = None
+    temp_chamber: float | None = None
+    temp_chamber_target: float | None = None
+
+    coord: tuple[float, float, float] | None = None
+    z_offset: float | None = None
+    fan_speed: dict[str, int] = Field(default_factory=dict)
+    light: dict[str, Any] = Field(default_factory=dict)
+    time_lapse: int | None = None
+    platform_type: int | None = None
+
+    @classmethod
+    def from_payload(cls, payload: dict[str, Any]) -> Status:
+        pi_raw = payload.get("PrintInfo")
+        print_info = PrintInfo.model_validate(pi_raw) if isinstance(pi_raw, dict) else None
+
+        current_status_raw = payload.get("CurrentStatus") or payload.get("CurrenStatus") or []
+        current_status = (
+            [int(x) for x in current_status_raw if isinstance(x, (int, float))]
+            if isinstance(current_status_raw, list)
+            else []
+        )
+
+        noz, noz_t = _extract_temp(payload, "TempOfNozzle", "TempTargetNozzle")
+        bed, bed_t = _extract_temp(payload, "TempOfHotbed", "TempTargetHotbed")
+        box, box_t = _extract_temp(payload, "TempOfBox", "TempTargetBox")
+
+        fans_raw = payload.get("CurrentFanSpeed") or {}
+        fans = {
+            str(k): int(v)
+            for k, v in (fans_raw.items() if isinstance(fans_raw, dict) else [])
+            if isinstance(v, (int, float))
+        }
+
+        light_raw = payload.get("LightStatus") or {}
+        light = light_raw if isinstance(light_raw, dict) else {}
+
+        z_off = payload.get("ZOffset")
+        z_off_f = float(z_off) if isinstance(z_off, (int, float)) else None
+
+        return cls(
+            raw=payload,
+            current_status=current_status,
+            print_info=print_info,
+            temp_nozzle=noz,
+            temp_nozzle_target=noz_t,
+            temp_bed=bed,
+            temp_bed_target=bed_t,
+            temp_chamber=box,
+            temp_chamber_target=box_t,
+            coord=_parse_coord(payload.get("CurrenCoord") or payload.get("CurrentCoord")),
+            z_offset=z_off_f,
+            fan_speed=fans,
+            light=light,
+            time_lapse=payload.get("TimeLapseStatus"),
+            platform_type=payload.get("PlatFormType") or payload.get("PlatformType"),
+        )
+
+    @property
+    def state(self) -> int | None:
+        """Primary printer state code (first entry in ``CurrentStatus``)."""
+        return self.current_status[0] if self.current_status else None
+
+    @property
+    def progress(self) -> int | None:
+        """Convenience accessor for the current job's progress (%)."""
+        return self.print_info.progress if self.print_info else None
+
+    @property
+    def filename(self) -> str | None:
+        return self.print_info.filename if self.print_info else None
+
+    @property
+    def print_status(self) -> int | None:
+        """The ``PrintInfo.Status`` code (e.g. 13 = printing). See :class:`PrintStatus`."""
+        return self.print_info.status if self.print_info else None
+
+
+class PrintStatus:
+    """Known ``PrintInfo.Status`` codes.
+
+    Decoded from CentauriLink and the official SDK; not all codes are observed
+    on every firmware. Treat unknown codes as opaque.
+    """
+
+    IDLE = 0
+    HOMING = 1
+    DROPPING = 2
+    EXPOSING = 3
+    LIFTING = 4
+    PAUSING = 5
+    PAUSED = 6
+    STOPPING = 7
+    STOPPED = 8
+    COMPLETED = 9
+    FILE_CHECKING = 10
+    PREPARING = 12
+    PRINTING = 13
+
+
+class Attributes(BaseModel):
+    """Normalised view of the ``Attributes`` payload."""
+
+    model_config = ConfigDict(extra="allow")
+
+    raw: dict[str, Any]
+    mainboard_id: str | None = None
+    name: str | None = None
+    machine_name: str | None = None
+    brand_name: str | None = None
+    firmware_version: str | None = None
+    protocol_version: str | None = None
+    capabilities: list[str] = Field(default_factory=list)
+
+    @classmethod
+    def from_payload(cls, payload: dict[str, Any]) -> Attributes:
+        caps_raw = payload.get("Capabilities") or payload.get("SupportedFeatures") or []
+        caps = [str(c) for c in caps_raw] if isinstance(caps_raw, list) else []
+        return cls(
+            raw=payload,
+            mainboard_id=payload.get("MainboardID"),
+            name=payload.get("Name"),
+            machine_name=payload.get("MachineName"),
+            brand_name=payload.get("BrandName"),
+            firmware_version=payload.get("FirmwareVersion"),
+            protocol_version=payload.get("ProtocolVersion"),
+            capabilities=caps,
+        )

pycentauri/sdcp.py

@@ -0,0 +1,238 @@
+"""SDCP v3 wire protocol for the Elegoo Centauri Carbon.
+
+The Centauri Carbon exposes a WebSocket at ``ws://<host>:3030/websocket`` that
+speaks Elegoo's Smart Device Control Protocol (SDCP). Messages are JSON; the
+envelope wraps a command and routing topic.
+
+Reference implementations consulted:
+
+* ``ELEGOO-3D/elegoo-link`` — official C++ SDK, ``elegoo_fdm_cc_message_adapter.cpp``
+* ``CentauriLink/Centauri-Link`` — community Python/Kivy client, ``main.py``
+"""
+
+from __future__ import annotations
+
+import json
+import secrets
+import time
+import uuid
+from enum import IntEnum
+from typing import Any
+
+
+class Cmd(IntEnum):
+    """SDCP command codes for the original Centauri Carbon.
+
+    Codes confirmed against the official elegoo-link C++ SDK's
+    ``COMMAND_MAPPING_TABLE`` in ``elegoo_fdm_cc_message_adapter.cpp``. Cmd 512
+    is documented by CentauriLink and OctoEverywhere as the status-push
+    subscribe command.
+    """
+
+    GET_PRINTER_STATUS = 0
+    GET_PRINTER_ATTRIBUTES = 1
+    START_PRINT = 128
+    PAUSE_PRINT = 129
+    STOP_PRINT = 130
+    RESUME_PRINT = 131
+    GET_CANVAS_STATUS = 324
+    SUBSCRIBE = 512
+
+
+DEFAULT_PUSH_PERIOD_MS = 5000
+
+
+class MessageType(IntEnum):
+    """Parsed message categories, based on the ``Topic`` field."""
+
+    UNKNOWN = 0
+    RESPONSE = 1
+    STATUS = 2
+    ATTRIBUTES = 3
+    NOTICE = 4
+
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+def _new_request_id() -> str:
+    return secrets.token_hex(8)
+
+
+def _new_envelope_id() -> str:
+    return uuid.uuid4().hex
+
+
+def build_request(
+    cmd: int,
+    data: dict[str, Any] | None,
+    mainboard_id: str,
+    *,
+    request_id: str | None = None,
+    envelope_id: str | None = None,
+) -> dict[str, Any]:
+    """Build a fully-formed SDCP request packet.
+
+    The packet structure mirrors what ``ElegooFdmCCMessageAdapter`` emits:
+
+    .. code-block:: json
+
+        {
+          "Id": "<mainboard id or uuid>",
+          "Data": {
+            "Cmd": 0,
+            "Data": {},
+            "RequestID": "<hex>",
+            "MainboardID": "<serial>",
+            "TimeStamp": 1687069655000,
+            "From": 1
+          },
+          "Topic": "sdcp/request/<mainboard id>"
+        }
+
+    ``MainboardID`` is mandatory for every outbound command; obtain it from a
+    discovery response or from the first ``Attributes`` push the printer sends
+    after the WebSocket connects.
+    """
+    if not mainboard_id:
+        raise ValueError("mainboard_id is required for SDCP commands")
+    return {
+        "Id": envelope_id or mainboard_id,
+        "Data": {
+            "Cmd": int(cmd),
+            "Data": data or {},
+            "RequestID": request_id or _new_request_id(),
+            "MainboardID": mainboard_id,
+            "TimeStamp": _now_ms(),
+            "From": 1,
+        },
+        "Topic": f"sdcp/request/{mainboard_id}",
+    }
+
+
+def build_subscribe(mainboard_id: str, period_ms: int = DEFAULT_PUSH_PERIOD_MS) -> dict[str, Any]:
+    """Cmd 512 — request status pushes every ``period_ms`` milliseconds."""
+    return build_request(Cmd.SUBSCRIBE, {"TimePeriod": int(period_ms)}, mainboard_id)
+
+
+def encode(packet: dict[str, Any]) -> str:
+    """Serialize an envelope to JSON for transmission over the WebSocket."""
+    return json.dumps(packet, separators=(",", ":"))
+
+
+def _classify(topic: str, payload: dict[str, Any]) -> MessageType:
+    if "sdcp/status" in topic or "Status" in payload:
+        return MessageType.STATUS
+    if "sdcp/attributes" in topic or "Attributes" in payload:
+        return MessageType.ATTRIBUTES
+    if "sdcp/response" in topic:
+        return MessageType.RESPONSE
+    if "sdcp/notice" in topic:
+        return MessageType.NOTICE
+    return MessageType.UNKNOWN
+
+
+class ParsedMessage:
+    """Result of :func:`parse_message`, flattening the nested envelope.
+
+    ``raw`` is the top-level dict; ``inner`` is ``raw["Data"]`` when present
+    (command responses put the useful payload there). ``status`` and
+    ``attributes`` are non-None for the matching topics. ``request_id`` links
+    the message back to the request that triggered it.
+    """
+
+    __slots__ = ("attributes", "inner", "mainboard_id", "raw", "request_id", "status", "type")
+
+    def __init__(
+        self,
+        *,
+        type: MessageType,
+        raw: dict[str, Any],
+        inner: dict[str, Any] | None = None,
+        status: dict[str, Any] | None = None,
+        attributes: dict[str, Any] | None = None,
+        request_id: str | None = None,
+        mainboard_id: str | None = None,
+    ) -> None:
+        self.type = type
+        self.raw = raw
+        self.inner = inner
+        self.status = status
+        self.attributes = attributes
+        self.request_id = request_id
+        self.mainboard_id = mainboard_id
+
+    def __repr__(self) -> str:
+        return (
+            f"ParsedMessage(type={self.type.name}, request_id={self.request_id!r}, "
+            f"mainboard_id={self.mainboard_id!r})"
+        )
+
+
+def parse_message(raw: str | bytes | dict[str, Any]) -> ParsedMessage:
+    """Parse an incoming SDCP message from the printer.
+
+    Accepts either a raw text/bytes frame or an already-parsed dict.
+    Unrecognised or malformed payloads come back as
+    ``ParsedMessage(type=UNKNOWN)`` with ``raw`` populated so callers can log.
+    """
+    if isinstance(raw, dict):
+        obj = raw
+    else:
+        text = raw.decode("utf-8", "replace") if isinstance(raw, (bytes, bytearray)) else raw
+        # Some SDCP variants prefix messages with a decimal length.
+        text = text.lstrip()
+        if text and text[0].isdigit():
+            first_brace = text.find("{")
+            if first_brace > 0:
+                text = text[first_brace:]
+        try:
+            obj = json.loads(text)
+        except (json.JSONDecodeError, TypeError):
+            return ParsedMessage(type=MessageType.UNKNOWN, raw={"_raw": raw})
+        if not isinstance(obj, dict):
+            return ParsedMessage(type=MessageType.UNKNOWN, raw={"_raw": obj})
+
+    topic = obj.get("Topic") or ""
+    msg_type = _classify(topic if isinstance(topic, str) else "", obj)
+
+    data = obj.get("Data") if isinstance(obj.get("Data"), dict) else None
+    mainboard_id = obj.get("MainboardID")
+    if mainboard_id is None and data is not None:
+        mainboard_id = data.get("MainboardID")
+    request_id = None
+    if data is not None:
+        request_id = data.get("RequestID")
+
+    status_payload: dict[str, Any] | None = None
+    attributes_payload: dict[str, Any] | None = None
+
+    if msg_type == MessageType.STATUS:
+        if isinstance(obj.get("Status"), dict):
+            status_payload = obj["Status"]
+        elif data is not None and isinstance(data.get("Status"), dict):
+            status_payload = data["Status"]
+        elif data is not None:
+            status_payload = {k: v for k, v in data.items() if k != "MainboardID"}
+
+    if msg_type == MessageType.ATTRIBUTES:
+        if isinstance(obj.get("Attributes"), dict):
+            attributes_payload = obj["Attributes"]
+        elif data is not None and isinstance(data.get("Attributes"), dict):
+            attributes_payload = data["Attributes"]
+        elif data is not None:
+            attributes_payload = {k: v for k, v in data.items() if k != "MainboardID"}
+        # Attributes carries MainboardID too.
+        if mainboard_id is None and attributes_payload is not None:
+            mainboard_id = attributes_payload.get("MainboardID")
+
+    return ParsedMessage(
+        type=msg_type,
+        raw=obj,
+        inner=data,
+        status=status_payload,
+        attributes=attributes_payload,
+        request_id=str(request_id) if request_id is not None else None,
+        mainboard_id=str(mainboard_id) if mainboard_id is not None else None,
+    )

pycentauri-0.1.0.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: pycentauri
+Version: 0.1.0
+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
+Project-URL: Issues, https://github.com/bjan/pycentauri/issues
+Project-URL: Changelog, https://github.com/bjan/pycentauri/blob/main/CHANGELOG.md
+Author: Brandon
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: 3d-printing,centauri,centauri-carbon,elegoo,mcp,sdcp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Printing
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.7
+Requires-Dist: typer>=0.12
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: mcp
+Requires-Dist: mcp>=1.2; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# pycentauri
+
+Python client, CLI, and MCP server for the [Elegoo Centauri
+Carbon](https://www.elegoo.com/) 3D printer.
+
+`pycentauri` speaks the printer's native SDCP v3 protocol over its local
+WebSocket (port 3030) — no cloud account required. It exposes three surfaces:
+
+1. An **async Python library** for direct integration.
+2. A **`centauri` CLI** for quick status checks, snapshots, and control.
+3. An **MCP server** so AI agents (Claude Code, Claude Desktop, Cursor, any
+   MCP-compatible client) can monitor and drive the printer as a tool.
+
+> **Status:** alpha. The protocol has been reverse-engineered from the official
+> [`elegoo-link`](https://github.com/ELEGOO-3D/elegoo-link) C++ SDK and the
+> [`CentauriLink`](https://github.com/CentauriLink/Centauri-Link) project. It
+> works against the original Centauri Carbon on current firmware. The newer
+> Centauri Carbon 2 (which uses MQTT) is not supported.
+
+## Install
+
+```sh
+pip install pycentauri            # library + CLI
+pip install "pycentauri[mcp]"     # + MCP server dependencies
+```
+
+## Quick start — CLI
+
+```sh
+# Find printers on your LAN
+centauri discover
+
+# One-shot status (pretty or JSON)
+centauri status --host 192.168.1.209
+centauri status --host 192.168.1.209 --json
+
+# Stream live status updates
+centauri watch --host 192.168.1.209
+
+# Grab a webcam snapshot
+centauri snapshot --host 192.168.1.209 shot.jpg
+
+# Files on the printer
+centauri files --host 192.168.1.209
+
+# Control actions require --enable-control
+centauri print start cube.gcode --host 192.168.1.209 --enable-control
+centauri print pause              --host 192.168.1.209 --enable-control
+centauri print resume             --host 192.168.1.209 --enable-control
+centauri print stop               --host 192.168.1.209 --enable-control
+```
+
+The host can also come from `PYCENTAURI_HOST` or `~/.config/pycentauri/config.toml`.
+
+## Quick start — Python
+
+```python
+import asyncio
+from pycentauri import Printer
+
+async def main():
+    async with await Printer.connect("192.168.1.209") as printer:
+        status = await printer.status()
+        print(status.state, status.progress, status.temp_nozzle)
+
+        jpeg = await printer.snapshot()
+        with open("shot.jpg", "wb") as f:
+            f.write(jpeg)
+
+        async for update in printer.watch():
+            print(update.state, update.progress)
+
+asyncio.run(main())
+```
+
+## Quick start — MCP
+
+Register the server with your agent. With Claude Code:
+
+```sh
+claude mcp add pycentauri -- python -m pycentauri.mcp
+# or, with control actions enabled (gives the agent start/pause/stop/upload):
+claude mcp add pycentauri -- python -m pycentauri.mcp --enable-control
+```
+
+Set `PYCENTAURI_HOST` in your MCP server env so the agent can't target an
+arbitrary IP. The server exposes these tools:
+
+| Tool | Always available | Description |
+|---|---|---|
+| `get_status` | yes | State, temperatures, progress, elapsed/remaining |
+| `get_attributes` | yes | Model, firmware, mainboard ID |
+| `list_files` | yes | Files stored on the printer |
+| `get_snapshot` | yes | Webcam frame as MCP `Image` content |
+| `discover_printers` | yes | LAN scan |
+| `start_print` | only with `--enable-control` | Starts a print |
+| `pause_print` | only with `--enable-control` | Pauses the current print |
+| `resume_print` | only with `--enable-control` | Resumes a paused print |
+| `stop_print` | only with `--enable-control` | Stops the current print |
+| `upload_file` | only with `--enable-control` | Uploads a file to the printer |
+
+## Safety
+
+Control actions are gated behind an explicit `enable_control=True` (library) or
+`--enable-control` flag (CLI / MCP). Destructive MCP tools are not even
+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.
+
+## Credits & licensing
+
+- Protocol reference: [`elegoo-link`](https://github.com/ELEGOO-3D/elegoo-link)
+  (Apache-2.0) and [`CentauriLink`](https://github.com/CentauriLink/Centauri-Link).
+- `pycentauri` is licensed under Apache-2.0. See [LICENSE](LICENSE).
+- Not affiliated with or endorsed by Elegoo.

pycentauri-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+pycentauri/__init__.py,sha256=05FNMPVENQO5lkMRgcIjScodsZH-zQQUZdSYWWx6G5U,447
+pycentauri/camera.py,sha256=i4Ej4GBhUM4PnY_VdOiUdQQPaXR-mupj7tneevc5aV4,2199
+pycentauri/cli.py,sha256=6B6z7zDeMpuByVxx9r3qzZo1Y5zU57zyHn8jef54YdU,11704
+pycentauri/client.py,sha256=Cc0AuckZxOZTbUjjV-YPdIKTYtPeudBDO6BBDZQ-JK8,12302
+pycentauri/discovery.py,sha256=jjjvvj_sizvxmV5sw_-7uIxwsxIuUmyuSG8pq3sZkgI,2864
+pycentauri/models.py,sha256=bYAXb9L_NvRgQNcpSQ1yZg4JPknGzx31DDXZl2KkRqk,8077
+pycentauri/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pycentauri/sdcp.py,sha256=0nE93oZmImPGngFdPPjWseBc_72bUjwGSDUonELDGcw,7730
+pycentauri/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pycentauri/mcp/__main__.py,sha256=4V93dBkS0D2Z9iIKxlWY_GpxMHHp3I6y2vqTZDaDxvg,78
+pycentauri/mcp/server.py,sha256=gQ7ye7AEvOqVTJ1Z_GY75xIfnKlhMkvtRWarG3Wlogs,7233
+pycentauri-0.1.0.dist-info/METADATA,sha256=jSA0wQcR8rUyv28z9zAYTrS5q3w8m8wfb0YyheSOvDQ,5693
+pycentauri-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pycentauri-0.1.0.dist-info/entry_points.txt,sha256=W5EcM3mxlAKgEBdDl7aBobMq_Wd7wJRb9b6ipgb5SJM,48
+pycentauri-0.1.0.dist-info/licenses/LICENSE,sha256=s_jLy09CPmpz5rCJGiB4EF-vD_IWI8H0_2jR9bj-DiM,11325
+pycentauri-0.1.0.dist-info/RECORD,,

pycentauri-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pycentauri-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+centauri = pycentauri.cli:app