py-ctrl-os 0.6.1__py3-none-any.whl

py_ctrl_os/__init__.py

@@ -0,0 +1,20 @@
+"""Python CFFI wrapper for librs_ctrl_os.so.
+
+Auto-downloads .so from GitHub release on first import.
+"""
+
+from .binding import lib, ffi, RCOS_OK, RcOsError
+from .comms import PubSubManager
+from .config import StaticConfig, load_config
+from .downloader import ensure_so
+
+__version__ = "0.6.1"
+__all__ = [
+    "PubSubManager",
+    "StaticConfig",
+    "load_config",
+    "RcOsError",
+    "ensure_so",
+    "lib",
+    "ffi",
+]

py_ctrl_os/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

py_ctrl_os/binding.py

@@ -0,0 +1,139 @@
+"""Low-level CFFI binding for librs_ctrl_os."""
+
+import os
+from pathlib import Path
+
+from cffi import FFI
+
+ffi = FFI()
+
+# C declarations matching rs_ctrl_os.h
+ffi.cdef("""
+typedef int rcos_err_t;
+
+#define RCOS_OK 0
+#define RCOS_ERR_INVALID 1
+#define RCOS_ERR_UTF8 2
+#define RCOS_ERR_CONFIG 3
+#define RCOS_ERR_COMMS 4
+#define RCOS_ERR_SERIALIZATION 6
+#define RCOS_ERR_INTERNAL 99
+
+typedef struct RcOsTimeSyncHandle RcOsTimeSyncHandle;
+typedef struct RcOsConfig RcOsConfig;
+typedef struct RcOsServiceRegistry RcOsServiceRegistry;
+typedef struct RcOsPubSub RcOsPubSub;
+
+rcos_err_t rs_ctrl_os_init_logging(void);
+rcos_err_t rs_ctrl_os_last_error(char *buf, size_t buf_len);
+void rs_ctrl_os_str_free(char *p);
+
+RcOsTimeSyncHandle *rs_ctrl_os_time_sync_new(void);
+void rs_ctrl_os_time_sync_destroy(RcOsTimeSyncHandle *p);
+uint64_t rs_ctrl_os_time_sync_now_ms(const RcOsTimeSyncHandle *p);
+int rs_ctrl_os_time_sync_is_synced(const RcOsTimeSyncHandle *p);
+
+RcOsConfig *rs_ctrl_os_config_open(const char *path_utf8);
+void rs_ctrl_os_config_destroy(RcOsConfig *p);
+rcos_err_t rs_ctrl_os_config_get_dynamic_toml(const RcOsConfig *cfg, char **out_toml);
+char *rs_ctrl_os_config_get_my_id(const RcOsConfig *cfg);
+char *rs_ctrl_os_config_get_host(const RcOsConfig *cfg);
+uint16_t rs_ctrl_os_config_get_port(const RcOsConfig *cfg);
+int rs_ctrl_os_config_get_is_master(const RcOsConfig *cfg);
+int64_t rs_ctrl_os_config_get_publish_hz(const RcOsConfig *cfg);
+int64_t rs_ctrl_os_config_get_subscribe_hz(const RcOsConfig *cfg);
+int rs_ctrl_os_config_get_dynamic_load_enable(const RcOsConfig *cfg);
+
+RcOsServiceRegistry *rs_ctrl_os_discovery_start(
+    const char *my_id, const char *my_host, uint16_t my_port,
+    int is_master, const RcOsTimeSyncHandle *time_sync);
+void rs_ctrl_os_registry_destroy(RcOsServiceRegistry *p);
+
+RcOsPubSub *rs_ctrl_os_pubsub_new(const RcOsConfig *cfg, RcOsServiceRegistry *registry);
+void rs_ctrl_os_pubsub_destroy(RcOsPubSub *p);
+void rs_ctrl_os_pubsub_set_publish_hz(RcOsPubSub *bus, int64_t hz);
+void rs_ctrl_os_pubsub_set_subscribe_hz(RcOsPubSub *bus, int64_t hz);
+
+rcos_err_t rs_ctrl_os_pubsub_publish_raw(
+    RcOsPubSub *bus, const char *topic_key, const char *sub_topic,
+    const uint8_t *payload, size_t payload_len);
+
+rcos_err_t rs_ctrl_os_pubsub_try_recv_raw(
+    RcOsPubSub *bus, const char *local_name,
+    char **sender_id_out, char **sub_topic_out,
+    uint8_t **payload_out, size_t *payload_len_out,
+    int *got_message_out);
+
+void rs_ctrl_os_payload_free(uint8_t *p, size_t len);
+
+rcos_err_t rs_ctrl_os_pubsub_set_sub_topics(
+    RcOsPubSub *bus, const char *local_name,
+    const char *const *topics, size_t topic_count);
+
+rcos_err_t rs_ctrl_os_pubsub_publish_request(
+    RcOsPubSub *bus, const char *topic_key, const char *sub_topic,
+    uint64_t request_id, const uint8_t *payload, size_t payload_len);
+
+rcos_err_t rs_ctrl_os_pubsub_publish_response(
+    RcOsPubSub *bus, const char *topic_key, const char *sub_topic,
+    uint64_t request_id, const uint8_t *payload, size_t payload_len);
+
+rcos_err_t rs_ctrl_os_pubsub_try_recv_request(
+    RcOsPubSub *bus, const char *local_name,
+    char **sender_id_out, char **sub_topic_out,
+    uint64_t *request_id_out, uint8_t **payload_out,
+    size_t *payload_len_out, int *got_message_out);
+
+rcos_err_t rs_ctrl_os_pubsub_try_recv_response(
+    RcOsPubSub *bus, const char *local_name,
+    char **sender_id_out, char **sub_topic_out,
+    uint64_t *request_id_out, uint8_t **payload_out,
+    size_t *payload_len_out, int *got_message_out);
+""")
+
+# Constants
+RCOS_OK = 0
+RCOS_ERR_INVALID = 1
+RCOS_ERR_UTF8 = 2
+RCOS_ERR_CONFIG = 3
+RCOS_ERR_COMMS = 4
+RCOS_ERR_SERIALIZATION = 6
+RCOS_ERR_INTERNAL = 99
+
+
+def _find_so() -> str:
+    """Find librs_ctrl_os.so, auto-download if needed."""
+    from .downloader import ensure_so
+    try:
+        return ensure_so()
+    except Exception as e:
+        raise FileNotFoundError(
+            f"librs_ctrl_os.so not found and auto-download failed: {e}\n"
+            f"Please download manually from https://github.com/LycanW/rs_ctrl_os/releases"
+        )
+
+
+lib = ffi.dlopen(_find_so())
+
+
+class RcOsError(Exception):
+    """rs_ctrl_os error with code and message."""
+
+    def __init__(self, code: int, msg: str = ""):
+        self.code = code
+        super().__init__(msg or f"rs_ctrl_os error {code}")
+
+
+def check(err: int) -> None:
+    """Check return code, raise RcOsError on failure."""
+    if err != RCOS_OK:
+        buf = ffi.new("char[]", 256)
+        lib.rs_ctrl_os_last_error(buf, 256)
+        msg = ffi.string(buf).decode("utf-8", errors="replace")
+        raise RcOsError(err, msg)
+
+
+def _free_str(p) -> None:
+    """Free a string returned by rs_ctrl_os."""
+    if p != ffi.NULL:
+        lib.rs_ctrl_os_str_free(p)

py_ctrl_os/cli.py

@@ -0,0 +1,19 @@
+"""CLI tool for py_ctrl_os (CFFI version)."""
+
+import sys
+from .config import load_config
+
+
+def main():
+    path = sys.argv[1] if len(sys.argv) > 1 else "config.toml"
+    static, dynamic = load_config(path)
+    print(f"Node ID:      {static.my_id}")
+    print(f"Host:         {static.host}:{static.port}")
+    print(f"Master:       {static.is_master}")
+    print(f"Publish Hz:   {static.publish_hz}")
+    print(f"Subscribe Hz: {static.subscribe_hz}")
+    print(f"Dynamic:      {dynamic}")
+
+
+if __name__ == "__main__":
+    main()

py_ctrl_os/comms.py

@@ -0,0 +1,206 @@
+"""PubSubManager - Python wrapper around rs_ctrl_os C FFI."""
+
+import json
+from typing import Optional
+
+from .binding import ffi, lib, check, _free_str, RCOS_OK
+
+
+class PubSubManager:
+    """ZMQ PUB/SUB manager backed by librs_ctrl_os.so.
+
+    Wire format: 3-frame multipart [sender_id, sub_topic, payload]
+    Identical behavior to the Rust PubSubManager.
+    """
+
+    def __init__(self, static_cfg, registry=None):
+        """
+        Args:
+            static_cfg: StaticConfig or path to TOML config file.
+            registry: Optional RcOsServiceRegistry pointer. If None, starts discovery.
+        """
+        from .config import StaticConfig
+
+        if isinstance(static_cfg, str):
+            from .config import load_config
+            static_cfg, _ = load_config(static_cfg)
+
+        self._cfg_path = static_cfg._config_path
+        self._owns_registry = registry is None
+
+        # Open config
+        self._cfg = lib.rs_ctrl_os_config_open(self._cfg_path.encode())
+        if self._cfg == ffi.NULL:
+            raise RuntimeError(f"Failed to open config: {self._cfg_path}")
+
+        # Start discovery if no registry provided
+        if registry is None:
+            my_id = lib.rs_ctrl_os_config_get_my_id(self._cfg)
+            my_host = lib.rs_ctrl_os_config_get_host(self._cfg)
+            my_port = lib.rs_ctrl_os_config_get_port(self._cfg)
+            is_master = lib.rs_ctrl_os_config_get_is_master(self._cfg)
+
+            registry = lib.rs_ctrl_os_discovery_start(
+                my_id, my_host, my_port, is_master, ffi.NULL
+            )
+            _free_str(my_id)
+            _free_str(my_host)
+
+            if registry == ffi.NULL:
+                lib.rs_ctrl_os_config_destroy(self._cfg)
+                raise RuntimeError("Failed to start discovery")
+
+        # Create PubSubManager (consumes registry on success)
+        self._bus = lib.rs_ctrl_os_pubsub_new(self._cfg, registry)
+        if self._bus == ffi.NULL:
+            # registry ownership not consumed, destroy it
+            if self._owns_registry:
+                lib.rs_ctrl_os_registry_destroy(registry)
+            lib.rs_ctrl_os_config_destroy(self._cfg)
+            raise RuntimeError("Failed to create PubSubManager")
+
+    def set_publish_hz(self, hz: int) -> None:
+        lib.rs_ctrl_os_pubsub_set_publish_hz(self._bus, hz)
+
+    def set_subscribe_hz(self, hz: int) -> None:
+        lib.rs_ctrl_os_pubsub_set_subscribe_hz(self._bus, hz)
+
+    def set_sub_topics(self, local_name: str, topics: list[str]) -> None:
+        if topics:
+            c_topics = [ffi.new("char[]", t.encode()) for t in topics]
+            topics_arr = ffi.new("const char *[]", c_topics)
+            check(lib.rs_ctrl_os_pubsub_set_sub_topics(
+                self._bus, local_name.encode(), topics_arr, len(topics)
+            ))
+        else:
+            check(lib.rs_ctrl_os_pubsub_set_sub_topics(
+                self._bus, local_name.encode(), ffi.NULL, 0
+            ))
+
+    def publish_raw(self, topic_key: str, sub_topic: str, payload: bytes) -> None:
+        check(lib.rs_ctrl_os_pubsub_publish_raw(
+            self._bus,
+            topic_key.encode(),
+            sub_topic.encode(),
+            payload,
+            len(payload),
+        ))
+
+    def publish_json(self, topic_key: str, sub_topic: str, data: dict) -> None:
+        payload = json.dumps(data).encode()
+        self.publish_raw(topic_key, sub_topic, payload)
+
+    def try_recv_raw(self, local_name: str) -> Optional[tuple[str, str, bytes]]:
+        sender_out = ffi.new("char **")
+        topic_out = ffi.new("char **")
+        payload_out = ffi.new("uint8_t **")
+        payload_len_out = ffi.new("size_t *")
+        got_out = ffi.new("int *")
+
+        check(lib.rs_ctrl_os_pubsub_try_recv_raw(
+            self._bus, local_name.encode(),
+            sender_out, topic_out, payload_out, payload_len_out, got_out,
+        ))
+
+        if got_out[0] == 0:
+            return None
+
+        sender = ffi.string(sender_out[0]).decode("utf-8", errors="replace")
+        topic = ffi.string(topic_out[0]).decode("utf-8", errors="replace")
+        payload = bytes(ffi.buffer(payload_out[0], payload_len_out[0]))
+
+        _free_str(sender_out[0])
+        _free_str(topic_out[0])
+        lib.rs_ctrl_os_payload_free(payload_out[0], payload_len_out[0])
+
+        return sender, topic, payload
+
+    def try_recv_json(self, local_name: str) -> Optional[tuple[str, str, dict]]:
+        result = self.try_recv_raw(local_name)
+        if result is None:
+            return None
+        sender, topic, payload = result
+        try:
+            data = json.loads(payload)
+        except Exception:
+            return None
+        return sender, topic, data
+
+    def publish_request(self, topic_key: str, sub_topic: str,
+                        request_id: int, payload: bytes) -> None:
+        check(lib.rs_ctrl_os_pubsub_publish_request(
+            self._bus, topic_key.encode(), sub_topic.encode(),
+            request_id, payload, len(payload),
+        ))
+
+    def publish_response(self, topic_key: str, sub_topic: str,
+                         request_id: int, payload: bytes) -> None:
+        check(lib.rs_ctrl_os_pubsub_publish_response(
+            self._bus, topic_key.encode(), sub_topic.encode(),
+            request_id, payload, len(payload),
+        ))
+
+    def try_recv_request(self, local_name: str):
+        sender_out = ffi.new("char **")
+        topic_out = ffi.new("char **")
+        rid_out = ffi.new("uint64_t *")
+        payload_out = ffi.new("uint8_t **")
+        payload_len_out = ffi.new("size_t *")
+        got_out = ffi.new("int *")
+
+        check(lib.rs_ctrl_os_pubsub_try_recv_request(
+            self._bus, local_name.encode(),
+            sender_out, topic_out, rid_out, payload_out, payload_len_out, got_out,
+        ))
+
+        if got_out[0] == 0:
+            return None
+
+        sender = ffi.string(sender_out[0]).decode("utf-8", errors="replace")
+        topic = ffi.string(topic_out[0]).decode("utf-8", errors="replace")
+        payload = bytes(ffi.buffer(payload_out[0], payload_len_out[0]))
+        rid = rid_out[0]
+
+        _free_str(sender_out[0])
+        _free_str(topic_out[0])
+        lib.rs_ctrl_os_payload_free(payload_out[0], payload_len_out[0])
+
+        return sender, rid, topic, payload
+
+    def try_recv_response(self, local_name: str):
+        sender_out = ffi.new("char **")
+        topic_out = ffi.new("char **")
+        rid_out = ffi.new("uint64_t *")
+        payload_out = ffi.new("uint8_t **")
+        payload_len_out = ffi.new("size_t *")
+        got_out = ffi.new("int *")
+
+        check(lib.rs_ctrl_os_pubsub_try_recv_response(
+            self._bus, local_name.encode(),
+            sender_out, topic_out, rid_out, payload_out, payload_len_out, got_out,
+        ))
+
+        if got_out[0] == 0:
+            return None
+
+        sender = ffi.string(sender_out[0]).decode("utf-8", errors="replace")
+        topic = ffi.string(topic_out[0]).decode("utf-8", errors="replace")
+        payload = bytes(ffi.buffer(payload_out[0], payload_len_out[0]))
+        rid = rid_out[0]
+
+        _free_str(sender_out[0])
+        _free_str(topic_out[0])
+        lib.rs_ctrl_os_payload_free(payload_out[0], payload_len_out[0])
+
+        return sender, rid, topic, payload
+
+    def close(self) -> None:
+        if hasattr(self, "_bus") and self._bus != ffi.NULL:
+            lib.rs_ctrl_os_pubsub_destroy(self._bus)
+            self._bus = ffi.NULL
+        if hasattr(self, "_cfg") and self._cfg != ffi.NULL:
+            lib.rs_ctrl_os_config_destroy(self._cfg)
+            self._cfg = ffi.NULL
+
+    def __del__(self):
+        self.close()

py_ctrl_os/config.py

@@ -0,0 +1,86 @@
+"""Config loading - wraps rs_ctrl_os C FFI config functions."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, Optional
+
+from .binding import ffi, lib, _free_str
+
+
+@dataclass
+class StaticConfig:
+    """Mirrors rs_ctrl_os::config::StaticBase."""
+
+    my_id: str
+    host: str
+    port: int
+    is_master: bool = False
+    publishers: Dict[str, str] = field(default_factory=dict)
+    subscribers: Dict[str, str] = field(default_factory=dict)
+    static_nodes: Dict[str, str] = field(default_factory=dict)
+    publish_hz: int = 0
+    subscribe_hz: int = 0
+    dynamic_load_enable: bool = True
+    _config_path: str = ""
+
+
+def load_config(path: str | Path) -> tuple[StaticConfig, dict]:
+    """Load TOML config via rs_ctrl_os C FFI.
+
+    Returns:
+        (static_config, dynamic_dict)
+    """
+    path = str(Path(path).resolve())
+
+    cfg = lib.rs_ctrl_os_config_open(path.encode())
+    if cfg == ffi.NULL:
+        raise RuntimeError(f"Failed to open config: {path}")
+
+    try:
+        # Read static fields
+        my_id_p = lib.rs_ctrl_os_config_get_my_id(cfg)
+        host_p = lib.rs_ctrl_os_config_get_host(cfg)
+
+        my_id = ffi.string(my_id_p).decode()
+        host = ffi.string(host_p).decode()
+        port = lib.rs_ctrl_os_config_get_port(cfg)
+        is_master = bool(lib.rs_ctrl_os_config_get_is_master(cfg))
+        publish_hz = lib.rs_ctrl_os_config_get_publish_hz(cfg)
+        subscribe_hz = lib.rs_ctrl_os_config_get_subscribe_hz(cfg)
+        dynamic_load_enable = bool(lib.rs_ctrl_os_config_get_dynamic_load_enable(cfg))
+
+        _free_str(my_id_p)
+        _free_str(host_p)
+
+        # Read dynamic TOML
+        dyn_out = ffi.new("char **")
+        dynamic = {}
+        if lib.rs_ctrl_os_config_get_dynamic_toml(cfg, dyn_out) == 0:
+            dyn_str = ffi.string(dyn_out[0]).decode()
+            _free_str(dyn_out[0])
+            if dyn_str.strip():
+                try:
+                    import tomli
+                    dynamic = tomli.loads(f"[dynamic]\n{dyn_str}")["dynamic"]
+                except Exception:
+                    try:
+                        import tomllib
+                        dynamic = tomllib.loads(f"[dynamic]\n{dyn_str}")["dynamic"]
+                    except Exception:
+                        dynamic = {}
+
+        static = StaticConfig(
+            my_id=my_id,
+            host=host,
+            port=port,
+            is_master=is_master,
+            publish_hz=publish_hz,
+            subscribe_hz=subscribe_hz,
+            dynamic_load_enable=dynamic_load_enable,
+            _config_path=path,
+        )
+
+        return static, dynamic
+
+    finally:
+        lib.rs_ctrl_os_config_destroy(cfg)

py_ctrl_os/downloader.py

@@ -0,0 +1,104 @@
+"""Auto-download librs_ctrl_os.so from GitHub releases."""
+
+import os
+import platform
+import shutil
+import tarfile
+from pathlib import Path
+from urllib.request import urlopen
+
+GITHUB_RELEASE = "https://github.com/LycanW/rs_ctrl_os/releases/download/v0.6.1"
+
+
+def _platform_tag() -> str:
+    """Return platform tag like 'linux-amd64' or 'linux-aarch64'."""
+    machine = platform.machine().lower()
+    if machine in ("x86_64", "amd64"):
+        return "linux-amd64"
+    elif machine in ("aarch64", "arm64"):
+        return "linux-aarch64"
+    else:
+        raise RuntimeError(f"Unsupported platform: {machine}")
+
+
+def _cache_dir() -> Path:
+    """Cache directory for downloaded .so."""
+    cache = Path.home() / ".cache" / "py_ctrl_os"
+    cache.mkdir(parents=True, exist_ok=True)
+    return cache
+
+
+def _so_path() -> Path:
+    """Path to librs_ctrl_os.so."""
+    cache = _cache_dir()
+    so = cache / "librs_ctrl_os.so"
+    return so
+
+
+def _download() -> Path:
+    """Download librs_ctrl_os.so from GitHub release."""
+    tag = _platform_tag()
+    tar_name = f"rs_ctrl_os-v0.6.1-{tag}.tar.gz"
+    url = f"{GITHUB_RELEASE}/{tar_name}"
+    cache = _cache_dir()
+    tar_path = cache / tar_name
+
+    if not tar_path.exists():
+        print(f"[py_ctrl_os] Downloading {tar_name}...")
+        with urlopen(url, timeout=60) as resp:
+            if resp.status != 200:
+                raise RuntimeError(
+                    f"Failed to download {url}: {resp.status}\n"
+                    f"Please download manually from {GITHUB_RELEASE}"
+                )
+            tar_path.write_bytes(resp.read())
+
+    # Extract
+    extract_dir = cache / f"rs_ctrl_os-v0.6.1-{tag}"
+    if not extract_dir.exists():
+        with tarfile.open(tar_path, "r:gz") as tar:
+            tar.extractall(cache)
+
+    # Copy .so to cache root
+    so_src = extract_dir / "librs_ctrl_os.so"
+    so_dst = cache / "librs_ctrl_os.so"
+    shutil.copy2(so_src, so_dst)
+
+    # Also copy .h
+    h_src = extract_dir / "rs_ctrl_os.h"
+    h_dst = cache / "rs_ctrl_os.h"
+    if h_src.exists():
+        shutil.copy2(h_src, h_dst)
+
+    print(f"[py_ctrl_os] Installed librs_ctrl_os.so to {so_dst}")
+    return so_dst
+
+
+def ensure_so() -> str:
+    """Ensure librs_ctrl_os.so is available, download if needed."""
+    # 1. Check cache
+    so = _so_path()
+    if so.exists():
+        return str(so)
+
+    # 2. Check bundled (for wheel distribution)
+    bundled = Path(__file__).parent / "librs_ctrl_os.so"
+    if bundled.exists():
+        return str(bundled)
+
+    # 3. Check LD_LIBRARY_PATH
+    for p in os.environ.get("LD_LIBRARY_PATH", "").split(":"):
+        if p:
+            candidate = Path(p) / "librs_ctrl_os.so"
+            if candidate.exists():
+                return str(candidate)
+
+    # 4. Check system paths
+    for p in ("/usr/local/lib", "/usr/lib"):
+        candidate = Path(p) / "librs_ctrl_os.so"
+        if candidate.exists():
+            return str(candidate)
+
+    # 5. Download
+    so = _download()
+    return str(so)

py_ctrl_os-0.6.1.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: py-ctrl-os
+Version: 0.6.1
+Summary: Python CFFI bindings for rs_ctrl_os - distributed ZMQ pub/sub
+Author-email: Han Wang <wanghan0410@126.com>
+License: MIT
+Project-URL: Homepage, https://github.com/LycanW/rs_ctrl_os
+Project-URL: Repository, https://github.com/LycanW/rs_ctrl_os
+Project-URL: Issues, https://github.com/LycanW/rs_ctrl_os/issues
+Keywords: zmq,pubsub,distributed,cffi,rs_ctrl_os
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: cffi>=1.16
+
+# py-ctrl-os
+
+Python CFFI bindings for `rs_ctrl_os` — a distributed ZMQ pub/sub runtime.
+
+## Install
+
+```bash
+pip install py-ctrl-os
+```
+
+On first import, the library auto-downloads `librs_ctrl_os.so` from GitHub releases.
+
+## Quick Start
+
+```python
+from py_ctrl_os import PubSubManager, load_config
+
+static, dynamic = load_config("config.toml")
+bus = PubSubManager(static)
+
+# Publish JSON
+bus.publish_json("my_node", "status", {"hello": "world"})
+
+# Receive
+result = bus.try_recv_json("from_other_node")
+if result:
+    sender, topic, data = result
+    print(f"From {sender}: {data}")
+```
+
+## Requirements
+
+- Python 3.10+
+- Linux x86_64 or aarch64
+- `libzmq` (system library, usually pre-installed)
+
+## License
+
+MIT

py_ctrl_os-0.6.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+py_ctrl_os/__init__.py,sha256=VbFpcxuFDL0Dl_vxcJmeqO3E87hkMKnSyegLFTgp3lI,423
+py_ctrl_os/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+py_ctrl_os/binding.py,sha256=xQDDpkReELvAbtAQWCniXwMyGp2kEQneBZX-Tn4M6oY,4736
+py_ctrl_os/cli.py,sha256=owccLMlXV3yTNVAfu-hFjvKzVLb_upGgoIj97io5Qp8,529
+py_ctrl_os/comms.py,sha256=zClVInnoXJhTcrQAv1HEwFKqrongUPf8oY0D5X_rt30,7606
+py_ctrl_os/config.py,sha256=VktfvkvQoMywVJhYcBau4u5Fny71huhDrFyNODWDE-M,2693
+py_ctrl_os/downloader.py,sha256=aPWtUqJINB6MvbdLX9ij-YkNhYYC9ZCKokNhmumxsVE,2990
+py_ctrl_os-0.6.1.dist-info/METADATA,sha256=c8ZXx-Ej2JAIYGFW0tVl_yB7ENvpIxzLScQCPExGhyk,1610
+py_ctrl_os-0.6.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+py_ctrl_os-0.6.1.dist-info/entry_points.txt,sha256=GouR-R7znpvEAyHKWEoKnBHlFOjsp5GsItKtZSnbZOE,56
+py_ctrl_os-0.6.1.dist-info/top_level.txt,sha256=TSx72CGZOjhCEv3oeGIozN39zkKczZnDBRwoPYuUh9A,11
+py_ctrl_os-0.6.1.dist-info/RECORD,,

py_ctrl_os-0.6.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

py_ctrl_os-0.6.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+py-ctrl-os-info = py_ctrl_os.cli:main

py_ctrl_os-0.6.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+py_ctrl_os