robotrt-sdk 0.1.0__py3-none-any.whl

robotrt_sdk/__init__.py

@@ -0,0 +1,84 @@
+from ._ffi import _CORE
+from ._version import __version__
+import ctypes
+from .core import (
+    ActionClient,
+    ActionGoalHealth,
+    ActionServer,
+    BackpressureSignal,
+    CallbackGroupType,
+    BufferDescriptor,
+    BufferLease,
+    ExternalBufferRef,
+    LeaseView,
+    MissionSession,
+    Node,
+    NodeCallbackBinding,
+    Publisher,
+    CallbackExecutor,
+    MultiThreadExecutor,
+    MultiThreadExecutorStats,
+    RegisteredWork,
+    RegisteredWorkKind,
+    ServiceClient,
+    ServiceServer,
+    SimpleExecutor,
+    Subscriber,
+    TimerRegistration,
+)
+from .errors import ErrorInfo, RobotRtError
+from .lifecycle import LifecycleNode, LifecycleState
+from .logger import Logger
+from .status import StatusClient
+
+__all__ = [
+    "BufferDescriptor",
+    "BufferLease",
+    "ErrorInfo",
+    "LeaseView",
+    "LifecycleNode",
+    "LifecycleState",
+    "Logger",
+    "Node",
+    "NodeCallbackBinding",
+    "Publisher",
+    "Subscriber",
+    "ServiceClient",
+    "ServiceServer",
+    "ActionClient",
+    "ActionGoalHealth",
+    "ActionServer",
+    "BackpressureSignal",
+    "CallbackGroupType",
+    "CallbackExecutor",
+    "ExternalBufferRef",
+    "MissionSession",
+    "MultiThreadExecutor",
+    "MultiThreadExecutorStats",
+    "RobotRtError",
+    "RegisteredWork",
+    "RegisteredWorkKind",
+    "StatusClient",
+    "SimpleExecutor",
+    "TimerRegistration",
+    "__version__",
+    "abi_version",
+    "protocol_version",
+    "build_info",
+]
+
+
+def abi_version() -> int:
+    return int(_CORE.lib.robotrt_core_abi_version())
+
+
+def protocol_version() -> int:
+    return int(_CORE.lib.robotrt_core_protocol_version())
+
+
+def build_info() -> str:
+    needed = ctypes.c_uint32(0)
+    _CORE.lib.robotrt_core_build_info_copy(None, 0, ctypes.byref(needed))
+    buf = ctypes.create_string_buffer(needed.value + 1)
+    _CORE.lib.robotrt_core_build_info_copy(buf, needed.value + 1, ctypes.byref(needed))
+    return buf.value.decode("utf-8", errors="replace")

robotrt_sdk/_ffi.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from ._ffi_loader import CoreFfi, _CORE
+from ._ffi_types import (
+    RT_DURABILITY_TRANSIENT_LOCAL,
+    RT_DURABILITY_VOLATILE,
+    RT_OK,
+    RtActionGoalHealth,
+    RtBufferDescriptor,
+    RtErrorInfo,
+    RtExternalBufferRef,
+    RtTopicQosProfile,
+)
+
+__all__ = [
+    "RT_OK",
+    "CoreFfi",
+    "RT_DURABILITY_TRANSIENT_LOCAL",
+    "RT_DURABILITY_VOLATILE",
+    "RtActionGoalHealth",
+    "RtBufferDescriptor",
+    "RtErrorInfo",
+    "RtExternalBufferRef",
+    "RtTopicQosProfile",
+    "_CORE",
+]

robotrt_sdk/_ffi_loader.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import ctypes
+import os
+import platform
+from pathlib import Path
+
+from ._ffi_signatures import declare_signatures
+from ._ffi_types import RT_OK, RtErrorInfo
+from .errors import ErrorInfo, RobotRtError
+
+
+def _workspace_root() -> Path:
+    return Path(__file__).resolve().parents[3]
+
+
+def _dylib_name() -> str:
+    name = platform.system().lower()
+    if name == "darwin":
+        return "librobotrt_core_ffi.dylib"
+    if name == "windows":
+        return "robotrt_core_ffi.dll"
+    return "librobotrt_core_ffi.so"
+
+
+def _resolve_library_path() -> Path:
+    env = os.environ.get("ROBOTRT_CORE_FFI_LIB")
+    if env:
+        p = Path(env).expanduser().resolve()
+        if p.exists():
+            return p
+        raise FileNotFoundError(f"ROBOTRT_CORE_FFI_LIB does not exist: {p}")
+
+    root = _workspace_root()
+    direct = root / "target" / "debug" / _dylib_name()
+    if direct.exists():
+        return direct
+
+    deps = root / "target" / "debug" / "deps"
+    if deps.exists():
+        suffixes = {".dylib", ".so", ".dll"}
+        for candidate in sorted(deps.iterdir()):
+            if candidate.suffix not in suffixes:
+                continue
+            if candidate.name.startswith("librobotrt_core_ffi") or candidate.name == _dylib_name():
+                return candidate
+
+    raise FileNotFoundError("robotrt core ffi dynamic library not found; run cargo build -p core-ffi --lib")
+
+
+class CoreFfi:
+    def __init__(self) -> None:
+        self.library_path = _resolve_library_path()
+        self.lib = ctypes.CDLL(str(self.library_path))
+        declare_signatures(self.lib)
+
+    def last_error(self) -> ErrorInfo:
+        info = RtErrorInfo()
+        self.lib.robotrt_error_last(ctypes.byref(info))
+
+        needed = ctypes.c_uint32(0)
+        self.lib.robotrt_error_message_copy(None, 0, ctypes.byref(needed))
+        message = ""
+        if needed.value > 0:
+            buf = ctypes.create_string_buffer(needed.value)
+            self.lib.robotrt_error_message_copy(buf, needed.value, ctypes.byref(needed))
+            message = buf.value.decode("utf-8", errors="replace")
+
+        return ErrorInfo(
+            code=int(info.code),
+            domain=int(info.domain),
+            retryable=bool(info.retryable),
+            message=message,
+        )
+
+    def check(self, status: int, context: str) -> None:
+        if status == RT_OK:
+            return
+        raise RobotRtError(self.last_error(), context)
+
+
+_CORE = CoreFfi()

robotrt_sdk/_ffi_signatures.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+
+import ctypes
+
+from ._ffi_types import (
+    RtActionGoalHealth,
+    RtBufferDescriptor,
+    RtErrorInfo,
+    RtExternalBufferRef,
+    RtTopicQosProfile,
+    RtUuid,
+)
+
+
+def declare_signatures(lib: ctypes.CDLL) -> None:
+    lib.robotrt_core_abi_version.argtypes = []
+    lib.robotrt_core_abi_version.restype = ctypes.c_uint32
+
+    lib.robotrt_core_protocol_version.argtypes = []
+    lib.robotrt_core_protocol_version.restype = ctypes.c_uint32
+
+    lib.robotrt_core_build_info_copy.argtypes = [
+        ctypes.c_char_p,
+        ctypes.c_uint32,
+        ctypes.POINTER(ctypes.c_uint32),
+    ]
+    lib.robotrt_core_build_info_copy.restype = ctypes.c_int32
+
+    lib.robotrt_node_create.argtypes = [ctypes.POINTER(ctypes.c_void_p)]
+    lib.robotrt_node_create.restype = ctypes.c_int32
+
+    lib.robotrt_node_create_with_identity.argtypes = [
+        ctypes.c_char_p,
+        ctypes.c_char_p,
+        ctypes.POINTER(ctypes.c_void_p),
+    ]
+    lib.robotrt_node_create_with_identity.restype = ctypes.c_int32
+
+    lib.robotrt_node_destroy.argtypes = [ctypes.c_void_p]
+    lib.robotrt_node_destroy.restype = ctypes.c_int32
+
+    lib.robotrt_node_set_param.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p]
+    lib.robotrt_node_set_param.restype = ctypes.c_int32
+
+    lib.robotrt_node_get_param_copy.argtypes = [
+        ctypes.c_void_p,
+        ctypes.c_char_p,
+        ctypes.c_void_p,
+        ctypes.c_uint32,
+        ctypes.POINTER(ctypes.c_uint32),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_node_get_param_copy.restype = ctypes.c_int32
+
+    lib.robotrt_node_discovery_snapshot_json_copy.argtypes = [
+        ctypes.c_void_p,
+        ctypes.c_void_p,
+        ctypes.c_uint32,
+        ctypes.POINTER(ctypes.c_uint32),
+    ]
+    lib.robotrt_node_discovery_snapshot_json_copy.restype = ctypes.c_int32
+
+    lib.robotrt_node_topic_qos_ex.argtypes = [
+        ctypes.c_void_p,
+        ctypes.c_char_p,
+        ctypes.POINTER(RtTopicQosProfile),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_node_topic_qos_ex.restype = ctypes.c_int32
+
+    lib.robotrt_publisher_create.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]
+    lib.robotrt_publisher_create.restype = ctypes.c_int32
+
+    lib.robotrt_publisher_publish.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint8), ctypes.c_uint64]
+    lib.robotrt_publisher_publish.restype = ctypes.c_int32
+
+    lib.robotrt_publisher_publish_buffer.argtypes = [ctypes.c_void_p, ctypes.POINTER(RtExternalBufferRef)]
+    lib.robotrt_publisher_publish_buffer.restype = ctypes.c_int32
+
+    lib.robotrt_publisher_flush.argtypes = [ctypes.c_void_p]
+    lib.robotrt_publisher_flush.restype = ctypes.c_int32
+
+    lib.robotrt_publisher_destroy.argtypes = [ctypes.c_void_p]
+    lib.robotrt_publisher_destroy.restype = ctypes.c_int32
+
+    lib.robotrt_subscriber_create.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]
+    lib.robotrt_subscriber_create.restype = ctypes.c_int32
+
+    lib.robotrt_subscriber_recv.argtypes = [
+        ctypes.c_void_p,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint64),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_subscriber_recv.restype = ctypes.c_int32
+
+    lib.robotrt_subscriber_ack.argtypes = [ctypes.c_void_p]
+    lib.robotrt_subscriber_ack.restype = ctypes.c_int32
+
+    lib.robotrt_subscriber_pending_count.argtypes = [ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint64)]
+    lib.robotrt_subscriber_pending_count.restype = ctypes.c_int32
+
+    lib.robotrt_subscriber_destroy.argtypes = [ctypes.c_void_p]
+    lib.robotrt_subscriber_destroy.restype = ctypes.c_int32
+
+    lib.robotrt_service_client_create.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]
+    lib.robotrt_service_client_create.restype = ctypes.c_int32
+
+    lib.robotrt_service_server_create.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]
+    lib.robotrt_service_server_create.restype = ctypes.c_int32
+
+    lib.robotrt_service_client_call.argtypes = [
+        ctypes.c_void_p,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+        ctypes.POINTER(RtUuid),
+    ]
+    lib.robotrt_service_client_call.restype = ctypes.c_int32
+
+    lib.robotrt_service_client_call_with_deadline.argtypes = [
+        ctypes.c_void_p,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint64),
+    ]
+    lib.robotrt_service_client_call_with_deadline.restype = ctypes.c_int32
+
+    lib.robotrt_service_client_cancel.argtypes = [ctypes.c_void_p, RtUuid]
+    lib.robotrt_service_client_cancel.restype = ctypes.c_int32
+
+    lib.robotrt_service_server_recv_request.argtypes = [
+        ctypes.c_void_p,
+        ctypes.POINTER(RtUuid),
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint64),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_service_server_recv_request.restype = ctypes.c_int32
+
+    lib.robotrt_service_server_reply.argtypes = [
+        ctypes.c_void_p,
+        RtUuid,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+    ]
+    lib.robotrt_service_server_reply.restype = ctypes.c_int32
+
+    lib.robotrt_service_server_reply_error.argtypes = [
+        ctypes.c_void_p,
+        RtUuid,
+        ctypes.c_int32,
+        ctypes.c_int32,
+        ctypes.c_uint8,
+        ctypes.c_char_p,
+    ]
+    lib.robotrt_service_server_reply_error.restype = ctypes.c_int32
+
+    lib.robotrt_service_client_poll_response.argtypes = [
+        ctypes.c_void_p,
+        RtUuid,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint64),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_service_client_poll_response.restype = ctypes.c_int32
+
+    lib.robotrt_service_client_destroy.argtypes = [ctypes.c_void_p]
+    lib.robotrt_service_client_destroy.restype = ctypes.c_int32
+
+    lib.robotrt_service_server_destroy.argtypes = [ctypes.c_void_p]
+    lib.robotrt_service_server_destroy.restype = ctypes.c_int32
+
+    lib.robotrt_action_client_create.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]
+    lib.robotrt_action_client_create.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_create.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_void_p)]
+    lib.robotrt_action_server_create.restype = ctypes.c_int32
+
+    lib.robotrt_action_client_send_goal.argtypes = [
+        ctypes.c_void_p,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+        ctypes.POINTER(RtUuid),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_action_client_send_goal.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_recv_goal.argtypes = [
+        ctypes.c_void_p,
+        ctypes.POINTER(RtUuid),
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint64),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_action_server_recv_goal.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_accept_goal.argtypes = [ctypes.c_void_p, RtUuid]
+    lib.robotrt_action_server_accept_goal.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_reject_goal.argtypes = [ctypes.c_void_p, RtUuid, ctypes.c_char_p]
+    lib.robotrt_action_server_reject_goal.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_publish_feedback.argtypes = [
+        ctypes.c_void_p,
+        RtUuid,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+    ]
+    lib.robotrt_action_server_publish_feedback.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_heartbeat.argtypes = [ctypes.c_void_p, RtUuid]
+    lib.robotrt_action_server_heartbeat.restype = ctypes.c_int32
+
+    lib.robotrt_action_client_poll_feedback.argtypes = [
+        ctypes.c_void_p,
+        RtUuid,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint64),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_action_client_poll_feedback.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_succeed.argtypes = [
+        ctypes.c_void_p,
+        RtUuid,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+    ]
+    lib.robotrt_action_server_succeed.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_fail.argtypes = [ctypes.c_void_p, RtUuid, ctypes.c_char_p]
+    lib.robotrt_action_server_fail.restype = ctypes.c_int32
+
+    lib.robotrt_action_client_poll_result.argtypes = [
+        ctypes.c_void_p,
+        RtUuid,
+        ctypes.POINTER(ctypes.c_int32),
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint64),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_action_client_poll_result.restype = ctypes.c_int32
+
+    lib.robotrt_action_client_cancel.argtypes = [ctypes.c_void_p, RtUuid]
+    lib.robotrt_action_client_cancel.restype = ctypes.c_int32
+
+    lib.robotrt_action_client_goal_status.argtypes = [
+        ctypes.c_void_p,
+        RtUuid,
+        ctypes.POINTER(ctypes.c_int32),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_action_client_goal_status.restype = ctypes.c_int32
+
+    lib.robotrt_action_client_goal_health.argtypes = [
+        ctypes.c_void_p,
+        RtUuid,
+        ctypes.POINTER(RtActionGoalHealth),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_action_client_goal_health.restype = ctypes.c_int32
+
+    lib.robotrt_action_client_active_goal_health.argtypes = [
+        ctypes.c_void_p,
+        ctypes.POINTER(RtActionGoalHealth),
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint64),
+    ]
+    lib.robotrt_action_client_active_goal_health.restype = ctypes.c_int32
+
+    lib.robotrt_action_client_tick_timeouts.argtypes = [
+        ctypes.c_void_p,
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint32),
+    ]
+    lib.robotrt_action_client_tick_timeouts.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_poll_cancel.argtypes = [
+        ctypes.c_void_p,
+        ctypes.POINTER(ctypes.c_uint64),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_action_server_poll_cancel.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_confirm_cancel.argtypes = [ctypes.c_void_p, RtUuid]
+    lib.robotrt_action_server_confirm_cancel.restype = ctypes.c_int32
+
+    lib.robotrt_action_client_destroy.argtypes = [ctypes.c_void_p]
+    lib.robotrt_action_client_destroy.restype = ctypes.c_int32
+
+    lib.robotrt_action_server_destroy.argtypes = [ctypes.c_void_p]
+    lib.robotrt_action_server_destroy.restype = ctypes.c_int32
+
+    lib.robotrt_mission_create.argtypes = [ctypes.c_void_p, RtUuid, ctypes.POINTER(ctypes.c_void_p)]
+    lib.robotrt_mission_create.restype = ctypes.c_int32
+
+    lib.robotrt_mission_open.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    lib.robotrt_mission_open.restype = ctypes.c_int32
+
+    lib.robotrt_mission_send_command.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_uint8)]
+    lib.robotrt_mission_send_command.restype = ctypes.c_int32
+
+    lib.robotrt_mission_reconcile.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_uint32]
+    lib.robotrt_mission_reconcile.restype = ctypes.c_int32
+
+    lib.robotrt_mission_complete_replay.argtypes = [ctypes.c_void_p, ctypes.c_uint32]
+    lib.robotrt_mission_complete_replay.restype = ctypes.c_int32
+
+    lib.robotrt_mission_send_update_text.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    lib.robotrt_mission_send_update_text.restype = ctypes.c_int32
+
+    lib.robotrt_mission_send_update_json.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+    lib.robotrt_mission_send_update_json.restype = ctypes.c_int32
+
+    lib.robotrt_mission_heartbeat.argtypes = [ctypes.c_void_p]
+    lib.robotrt_mission_heartbeat.restype = ctypes.c_int32
+
+    lib.robotrt_mission_next_update_json.argtypes = [
+        ctypes.c_void_p,
+        ctypes.c_void_p,
+        ctypes.c_uint32,
+        ctypes.POINTER(ctypes.c_uint32),
+        ctypes.POINTER(ctypes.c_uint8),
+    ]
+    lib.robotrt_mission_next_update_json.restype = ctypes.c_int32
+
+    lib.robotrt_mission_destroy.argtypes = [ctypes.c_void_p]
+    lib.robotrt_mission_destroy.restype = ctypes.c_int32
+
+    lib.robotrt_buffer_lease_create_from_bytes.argtypes = [ctypes.POINTER(ctypes.c_uint8), ctypes.c_uint64, ctypes.POINTER(ctypes.c_void_p)]
+    lib.robotrt_buffer_lease_create_from_bytes.restype = ctypes.c_int32
+
+    lib.robotrt_buffer_lease_descriptor.argtypes = [ctypes.c_void_p, ctypes.POINTER(RtBufferDescriptor)]
+    lib.robotrt_buffer_lease_descriptor.restype = ctypes.c_int32
+
+    lib.robotrt_buffer_lease_open_from_descriptor.argtypes = [ctypes.POINTER(RtBufferDescriptor), ctypes.POINTER(ctypes.c_void_p)]
+    lib.robotrt_buffer_lease_open_from_descriptor.restype = ctypes.c_int32
+
+    lib.robotrt_buffer_lease_copy_bytes.argtypes = [
+        ctypes.c_void_p,
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint8),
+        ctypes.c_uint64,
+        ctypes.POINTER(ctypes.c_uint64),
+    ]
+    lib.robotrt_buffer_lease_copy_bytes.restype = ctypes.c_int32
+
+    lib.robotrt_buffer_lease_borrow_readonly.argtypes = [
+        ctypes.c_void_p,
+        ctypes.POINTER(ctypes.POINTER(ctypes.c_uint8)),
+        ctypes.POINTER(ctypes.c_uint64),
+    ]
+    lib.robotrt_buffer_lease_borrow_readonly.restype = ctypes.c_int32
+
+    lib.robotrt_buffer_lease_release.argtypes = [ctypes.c_void_p]
+    lib.robotrt_buffer_lease_release.restype = ctypes.c_int32
+
+    lib.robotrt_error_last.argtypes = [ctypes.POINTER(RtErrorInfo)]
+    lib.robotrt_error_last.restype = ctypes.c_int32
+
+    lib.robotrt_error_message_copy.argtypes = [ctypes.c_void_p, ctypes.c_uint32, ctypes.POINTER(ctypes.c_uint32)]
+    lib.robotrt_error_message_copy.restype = ctypes.c_int32
+
+    lib.robotrt_error_clear.argtypes = []
+    lib.robotrt_error_clear.restype = ctypes.c_int32

robotrt_sdk/_ffi_types.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import ctypes
+
+RT_OK = 0
+RT_DURABILITY_VOLATILE = 0
+RT_DURABILITY_TRANSIENT_LOCAL = 1
+
+
+class RtUuid(ctypes.Structure):
+    _fields_ = [("bytes", ctypes.c_uint8 * 16)]
+
+
+class RtErrorInfo(ctypes.Structure):
+    _fields_ = [
+        ("code", ctypes.c_int32),
+        ("domain", ctypes.c_int32),
+        ("retryable", ctypes.c_uint8),
+        ("_reserved0", ctypes.c_uint8),
+        ("_reserved1", ctypes.c_uint8),
+        ("_reserved2", ctypes.c_uint8),
+        ("message_len", ctypes.c_uint32),
+    ]
+
+
+class RtBufferDescriptor(ctypes.Structure):
+    _fields_ = [
+        ("lease_id", ctypes.c_uint64),
+        ("payload_len", ctypes.c_uint64),
+        ("segment_index", ctypes.c_uint32),
+        ("segment_offset", ctypes.c_uint32),
+        ("segment_capacity", ctypes.c_uint32),
+        ("flags", ctypes.c_uint32),
+    ]
+
+
+class RtExternalBufferRef(ctypes.Structure):
+    _fields_ = [
+        ("buffer_id", RtUuid),
+        ("offset", ctypes.c_uint64),
+        ("len", ctypes.c_uint64),
+    ]
+
+
+class RtTopicQosProfile(ctypes.Structure):
+    _fields_ = [
+        ("reliable", ctypes.c_uint8),
+        ("durability", ctypes.c_uint8),
+        ("_reserved0", ctypes.c_uint8),
+        ("_reserved1", ctypes.c_uint8),
+        ("depth", ctypes.c_uint64),
+        ("deadline_nanos", ctypes.c_uint64),
+        ("lifespan_nanos", ctypes.c_uint64),
+        ("has_deadline", ctypes.c_uint8),
+        ("has_lifespan", ctypes.c_uint8),
+        ("_reserved2", ctypes.c_uint8),
+        ("_reserved3", ctypes.c_uint8),
+    ]
+
+
+class RtActionGoalHealth(ctypes.Structure):
+    _fields_ = [
+        ("goal_id", RtUuid),
+        ("status", ctypes.c_int32),
+        ("liveness", ctypes.c_int32),
+        ("heartbeat_timeout_nanos", ctypes.c_uint64),
+        ("stalled_threshold_nanos", ctypes.c_uint64),
+        ("last_heartbeat_at_unix_nanos", ctypes.c_uint64),
+        ("last_feedback_at_unix_nanos", ctypes.c_uint64),
+        ("last_result_at_unix_nanos", ctypes.c_uint64),
+        ("has_heartbeat_timeout", ctypes.c_uint8),
+        ("has_stalled_threshold", ctypes.c_uint8),
+        ("has_last_heartbeat", ctypes.c_uint8),
+        ("has_last_feedback", ctypes.c_uint8),
+        ("has_last_result", ctypes.c_uint8),
+        ("_reserved0", ctypes.c_uint8),
+        ("_reserved1", ctypes.c_uint8),
+        ("_reserved2", ctypes.c_uint8),
+    ]

robotrt_sdk/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"