reachpy 0.1.0__tar.gz

reachpy-0.1.0/Cargo.lock

@@ -0,0 +1,201 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "byteorder"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
+
+[[package]]
+name = "cdr"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9617422bf43fde9280707a7e90f8f7494389c182f5c70b0f67592d0f06d41dfa"
+dependencies = [
+ "byteorder",
+ "serde",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91fd8e38a3b50ed1167fb981cd6fd60147e091784c427b8f7183a7ee32c31c12"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e368e7ddfdeb98c9bca7f8383be1648fd84ab466bf2bc015e94008db6d35611e"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f29e10af80b1f7ccaf7f69eace800a03ecd13e883acfacc1e5d0988605f651e"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df6e520eff47c45997d2fc7dd8214b25dd1310918bbb2642156ef66a67f29813"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.28.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4cdc218d835738f81c2338f822078af45b4afdf8b2e33cbb5916f108b813acb"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "reachpy-messages"
+version = "0.1.0"
+dependencies = [
+ "byteorder",
+ "cdr",
+ "pyo3",
+ "thiserror",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"

reachpy-0.1.0/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["crates/reachpy-messages"]
+resolver = "2"

reachpy-0.1.0/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: reachpy
+Version: 0.1.0
+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: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Libraries
+Summary: Python-native robotics framework built on ROS2
+Author: ReachPy Contributors
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# ReachPy 🚀
+
+**ReachPy** is a modern Python framework built to dramatically improve the Developer Experience (DX) for robotics engineers using ROS 2. 
+
+Building robotics applications in ROS 2 shouldn't mean wrestling with boilerplate, complex build pipelines, or rigid message compilation. ReachPy aims to provide a more Pythonic, intuitive, and dynamic interface to the ROS 2 ecosystem, letting you focus on writing robot logic rather than fighting the middleware.
+
+## ✨ Why ReachPy?
+
+While `rclpy` provides the standard bindings for ROS 2, the workflow often requires dropping down to C++ build tools (`colcon`, `CMake`) just to define custom data structures. ReachPy is being built to bridge this gap, offering dynamic runtime features powered by a high-performance Rust backend.
+
+## 📦 Core Components
+
+### Dynamic Messaging (`reachpy_messages`)
+At the core of ReachPy is our custom message serialization engine, written in Rust (via PyO3). 
+
+Instead of writing `.msg` files, recompiling your workspace, and sourcing environments just to add a new field to a message, `reachpy_messages` allows you to define, serialize, and deserialize native ROS 2 Common Data Representation (CDR) bytes **on the fly**.
+
+- **Dynamic Schema Registry:** Register complex nested types, arrays, and primitives entirely at runtime.
+- **Native CDR Support:** Outputs perfectly aligned Little-Endian bytes that are 100% compatible with standard ROS 2 nodes.
+- **Blazing Fast:** Offloads the heavy lifting of byte-packing to Rust, ensuring your Python nodes stay performant.
+
+## 🚀 Quick Start (Preview)
+
+*Note: ReachPy is currently in active development.*
+
+```python
+import reachpy
+from reachpy.messages import MessageSchema, FieldSchema, FieldType
+
+# 1. Define a ROS 2 compatible message entirely in Python
+schema = MessageSchema(
+    name="RobotWaypoint",
+    fields=[
+        FieldSchema("x", FieldType.Float64),
+        FieldSchema("y", FieldType.Float64),
+        FieldSchema("is_active", FieldType.Bool)
+    ]
+)
+
+# 2. Register it dynamically (no CMake or colcon build required!)
+reachpy.messages.register_schema("RobotWaypoint", schema)
+
+# 3. Serialize directly to ROS 2 CDR bytes to send over the wire
+cdr_payload = reachpy.messages.serialize("RobotWaypoint", [15.2, -7.8, True])
+```
+
+## 🛠️ Building from Source
+
+ReachPy uses Rust for its performance-critical extensions. You will need Rust and Python 3.8+ installed.
+
+```bash
+# Build and install the Rust extension locally
+maturin develop --release
+```

reachpy-0.1.0/README.md

@@ -0,0 +1,54 @@
+# ReachPy 🚀
+
+**ReachPy** is a modern Python framework built to dramatically improve the Developer Experience (DX) for robotics engineers using ROS 2. 
+
+Building robotics applications in ROS 2 shouldn't mean wrestling with boilerplate, complex build pipelines, or rigid message compilation. ReachPy aims to provide a more Pythonic, intuitive, and dynamic interface to the ROS 2 ecosystem, letting you focus on writing robot logic rather than fighting the middleware.
+
+## ✨ Why ReachPy?
+
+While `rclpy` provides the standard bindings for ROS 2, the workflow often requires dropping down to C++ build tools (`colcon`, `CMake`) just to define custom data structures. ReachPy is being built to bridge this gap, offering dynamic runtime features powered by a high-performance Rust backend.
+
+## 📦 Core Components
+
+### Dynamic Messaging (`reachpy_messages`)
+At the core of ReachPy is our custom message serialization engine, written in Rust (via PyO3). 
+
+Instead of writing `.msg` files, recompiling your workspace, and sourcing environments just to add a new field to a message, `reachpy_messages` allows you to define, serialize, and deserialize native ROS 2 Common Data Representation (CDR) bytes **on the fly**.
+
+- **Dynamic Schema Registry:** Register complex nested types, arrays, and primitives entirely at runtime.
+- **Native CDR Support:** Outputs perfectly aligned Little-Endian bytes that are 100% compatible with standard ROS 2 nodes.
+- **Blazing Fast:** Offloads the heavy lifting of byte-packing to Rust, ensuring your Python nodes stay performant.
+
+## 🚀 Quick Start (Preview)
+
+*Note: ReachPy is currently in active development.*
+
+```python
+import reachpy
+from reachpy.messages import MessageSchema, FieldSchema, FieldType
+
+# 1. Define a ROS 2 compatible message entirely in Python
+schema = MessageSchema(
+    name="RobotWaypoint",
+    fields=[
+        FieldSchema("x", FieldType.Float64),
+        FieldSchema("y", FieldType.Float64),
+        FieldSchema("is_active", FieldType.Bool)
+    ]
+)
+
+# 2. Register it dynamically (no CMake or colcon build required!)
+reachpy.messages.register_schema("RobotWaypoint", schema)
+
+# 3. Serialize directly to ROS 2 CDR bytes to send over the wire
+cdr_payload = reachpy.messages.serialize("RobotWaypoint", [15.2, -7.8, True])
+```
+
+## 🛠️ Building from Source
+
+ReachPy uses Rust for its performance-critical extensions. You will need Rust and Python 3.8+ installed.
+
+```bash
+# Build and install the Rust extension locally
+maturin develop --release
+```

reachpy-0.1.0/crates/reachpy-messages/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "reachpy-messages"
+version = "0.1.0"
+edition = "2021"
+description = "ReachPy message system — Python-native ROS2 message definitions with CDR serialization"
+
+[lib]
+name = "reachpy_messages"
+crate-type = ["cdylib", "rlib"]
+path = "lib.rs"
+
+[dependencies]
+pyo3     = { version = "0.28", features = ["extension-module"] }
+cdr      = "0.2"
+thiserror = "1.0"
+byteorder = "1.5"
+
+[dev-dependencies]
+pyo3 = { version = "0.28", features = ["auto-initialize"] }

reachpy-0.1.0/crates/reachpy-messages/lib.rs

@@ -0,0 +1,741 @@
+use byteorder::{LittleEndian, ReadBytesExt, WriteBytesExt};
+use pyo3::exceptions::{PyKeyError, PyTypeError, PyValueError};
+use pyo3::prelude::*;
+use pyo3::types::{PyBytes, PyDict, PyList, PyTuple};
+use pyo3::IntoPyObjectExt;
+use std::collections::HashMap;
+use std::io::Cursor;
+use std::sync::{Mutex, OnceLock};
+use thiserror::Error;
+
+const CDR_LE_ENCAPSULATION: [u8; 4] = [0x00, 0x01, 0x00, 0x00];
+
+#[derive(Clone)]
+struct FieldSchema {
+    name: String,
+    field_type: FieldType,
+}
+
+#[derive(Clone)]
+enum FieldType {
+    Bool,
+    Int8,
+    Int16,
+    Int32,
+    Int64,
+    UInt8,
+    UInt16,
+    UInt32,
+    UInt64,
+    Float32,
+    Float64,
+    RosString,
+    RosBytes,
+    Array(Box<FieldType>),
+    Struct(String),
+    Time,
+    Duration,
+}
+
+impl FieldType {
+    fn from_name(name: &str) -> Result<Self, MessageError> {
+        if let Some(inner) = name
+            .strip_prefix("array<")
+            .and_then(|value| value.strip_suffix('>'))
+        {
+            return Ok(Self::Array(Box::new(Self::from_name(inner)?)));
+        }
+        if let Some(struct_name) = name.strip_prefix("struct:") {
+            if struct_name.trim().is_empty() {
+                return Err(MessageError::SchemaDefinition(
+                    "Struct type must include a schema name".into(),
+                ));
+            }
+            return Ok(Self::Struct(struct_name.trim().to_string()));
+        }
+        match name {
+            "bool" => Ok(Self::Bool),
+            "int8" => Ok(Self::Int8),
+            "int16" => Ok(Self::Int16),
+            "int32" => Ok(Self::Int32),
+            "int64" => Ok(Self::Int64),
+            "uint8" => Ok(Self::UInt8),
+            "uint16" => Ok(Self::UInt16),
+            "uint32" => Ok(Self::UInt32),
+            "uint64" => Ok(Self::UInt64),
+            "float32" => Ok(Self::Float32),
+            "float64" => Ok(Self::Float64),
+            "string" | "ros_string" => Ok(Self::RosString),
+            "bytes" | "ros_bytes" => Ok(Self::RosBytes),
+            "time" => Ok(Self::Time),
+            "duration" => Ok(Self::Duration),
+            other => Err(MessageError::SerializationError(format!(
+                "Unsupported field type '{other}'"
+            ))),
+        }
+    }
+
+    fn as_name(&self) -> String {
+        match self {
+            Self::Bool => "bool".to_string(),
+            Self::Int8 => "int8".to_string(),
+            Self::Int16 => "int16".to_string(),
+            Self::Int32 => "int32".to_string(),
+            Self::Int64 => "int64".to_string(),
+            Self::UInt8 => "uint8".to_string(),
+            Self::UInt16 => "uint16".to_string(),
+            Self::UInt32 => "uint32".to_string(),
+            Self::UInt64 => "uint64".to_string(),
+            Self::Float32 => "float32".to_string(),
+            Self::Float64 => "float64".to_string(),
+            Self::RosString => "string".to_string(),
+            Self::RosBytes => "bytes".to_string(),
+            Self::Array(inner) => format!("array<{}>", inner.as_name()),
+            Self::Struct(name) => format!("struct:{name}"),
+            Self::Time => "time".to_string(),
+            Self::Duration => "duration".to_string(),
+        }
+    }
+
+}
+
+#[derive(Clone)]
+struct MessageSchema {
+    fields: Vec<FieldSchema>,
+}
+
+#[derive(Debug, Error)]
+pub enum MessageError {
+    #[error("Unknown custom message schema: {0}")]
+    UnknownSchema(String),
+    #[error("Field type mismatch on '{field}': expected {expected}, got {got}")]
+    TypeMismatch {
+        field: String,
+        expected: String,
+        got: String,
+    },
+    #[error("Serialization failed: {0}")]
+    SerializationError(String),
+    #[error("Deserialization failed: {0}")]
+    DeserializationError(String),
+    #[error("Schema already registered: {0}")]
+    DuplicateSchema(String),
+    #[error("Schema definition error: {0}")]
+    SchemaDefinition(String),
+}
+
+impl From<MessageError> for PyErr {
+    fn from(value: MessageError) -> Self {
+        match value {
+            MessageError::UnknownSchema(name) => PyKeyError::new_err(name),
+            MessageError::TypeMismatch { .. }
+            | MessageError::SerializationError(_)
+            | MessageError::DeserializationError(_) => PyTypeError::new_err(value.to_string()),
+            MessageError::DuplicateSchema(_) | MessageError::SchemaDefinition(_) => {
+                PyValueError::new_err(value.to_string())
+            }
+        }
+    }
+}
+
+static SCHEMA_REGISTRY: OnceLock<Mutex<HashMap<String, MessageSchema>>> = OnceLock::new();
+
+fn get_schema_registry() -> &'static Mutex<HashMap<String, MessageSchema>> {
+    SCHEMA_REGISTRY.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
+fn register_schema_internal(name: &str, schema: MessageSchema) -> Result<(), MessageError> {
+    let mut registry = get_schema_registry()
+        .lock()
+        .map_err(|_| MessageError::SerializationError("Schema registry lock poisoned".into()))?;
+    if registry.contains_key(name) {
+        return Err(MessageError::DuplicateSchema(name.to_string()));
+    }
+    registry.insert(name.to_string(), schema);
+    Ok(())
+}
+
+fn get_schema_internal(name: &str) -> Result<MessageSchema, MessageError> {
+    let registry = get_schema_registry()
+        .lock()
+        .map_err(|_| MessageError::DeserializationError("Schema registry lock poisoned".into()))?;
+    registry
+        .get(name)
+        .cloned()
+        .ok_or_else(|| MessageError::UnknownSchema(name.to_string()))
+}
+
+fn parse_schema(fields: &Bound<'_, PyList>) -> Result<MessageSchema, MessageError> {
+    let mut parsed_fields = Vec::with_capacity(fields.len());
+    for item in fields.iter() {
+        let pair = item.cast::<PyList>().ok();
+        let tuple = item.cast::<PyTuple>().ok();
+
+        let (name, field_type_name): (String, String) = if let Some(p) = pair {
+            if p.len() != 2 {
+                return Err(MessageError::SchemaDefinition(
+                    "Each field entry must contain exactly 2 items".into(),
+                ));
+            }
+            (
+                p.get_item(0)
+                    .map_err(|e| MessageError::SchemaDefinition(e.to_string()))?
+                    .extract::<String>()
+                    .map_err(|e| MessageError::SchemaDefinition(e.to_string()))?,
+                p.get_item(1)
+                    .map_err(|e| MessageError::SchemaDefinition(e.to_string()))?
+                    .extract::<String>()
+                    .map_err(|e| MessageError::SchemaDefinition(e.to_string()))?,
+            )
+        } else if let Some(t) = tuple {
+            if t.len() != 2 {
+                return Err(MessageError::SchemaDefinition(
+                    "Each field entry must contain exactly 2 items".into(),
+                ));
+            }
+            (
+                t.get_item(0)
+                    .map_err(|e| MessageError::SchemaDefinition(e.to_string()))?
+                    .extract::<String>()
+                    .map_err(|e| MessageError::SchemaDefinition(e.to_string()))?,
+                t.get_item(1)
+                    .map_err(|e| MessageError::SchemaDefinition(e.to_string()))?
+                    .extract::<String>()
+                    .map_err(|e| MessageError::SchemaDefinition(e.to_string()))?,
+            )
+        } else {
+            return Err(MessageError::SchemaDefinition(
+                "Fields must be provided as list[tuple[str, str]]".into(),
+            ));
+        };
+
+        let field_type = FieldType::from_name(&field_type_name)?;
+        parsed_fields.push(FieldSchema { name, field_type });
+    }
+
+    Ok(MessageSchema {
+        fields: parsed_fields,
+    })
+}
+
+fn type_name_for_value(value: &Bound<'_, PyAny>) -> &'static str {
+    if value.extract::<bool>().is_ok() {
+        "bool"
+    } else if value.extract::<i64>().is_ok() {
+        "int"
+    } else if value.extract::<u64>().is_ok() {
+        "uint"
+    } else if value.extract::<f64>().is_ok() {
+        "float"
+    } else if value.extract::<String>().is_ok() {
+        "string"
+    } else if value.cast::<PyBytes>().is_ok() {
+        "bytes"
+    } else if value.cast::<PyList>().is_ok() || value.extract::<Vec<Py<PyAny>>>().is_ok() {
+        "list"
+    } else if value.cast::<PyDict>().is_ok() {
+        "dict"
+    } else {
+        "unknown"
+    }
+}
+
+fn write_field_value(
+    buf: &mut Vec<u8>,
+    py: Python<'_>,
+    field: &FieldSchema,
+    value: &Bound<'_, PyAny>,
+) -> Result<(), MessageError> {
+    let mismatch = |expected: String| MessageError::TypeMismatch {
+        field: field.name.clone(),
+        expected,
+        got: type_name_for_value(value).to_string(),
+    };
+    write_by_type(buf, py, &field.field_type, value, &field.name, &mismatch)
+}
+
+fn write_by_type(
+    buf: &mut Vec<u8>,
+    py: Python<'_>,
+    field_type: &FieldType,
+    value: &Bound<'_, PyAny>,
+    field_name: &str,
+    mismatch: &dyn Fn(String) -> MessageError,
+) -> Result<(), MessageError> {
+    match field_type {
+        FieldType::Bool => {
+            align_write(buf, 1);
+            buf.write_u8(if value
+                .extract::<bool>()
+                .map_err(|_| mismatch("bool".to_string()))?
+            {
+                1
+            } else {
+                0
+            })
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::Int8 => {
+            align_write(buf, 1);
+            buf.write_i8(
+                value
+                    .extract::<i8>()
+                    .map_err(|_| mismatch("int8".to_string()))?,
+            )
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::Int16 => {
+            align_write(buf, 2);
+            buf.write_i16::<LittleEndian>(
+                value
+                    .extract::<i16>()
+                    .map_err(|_| mismatch("int16".to_string()))?,
+            )
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::Int32 => {
+            align_write(buf, 4);
+            buf.write_i32::<LittleEndian>(
+                value
+                    .extract::<i32>()
+                    .map_err(|_| mismatch("int32".to_string()))?,
+            )
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::Int64 => {
+            align_write(buf, 8);
+            buf.write_i64::<LittleEndian>(
+                value
+                    .extract::<i64>()
+                    .map_err(|_| mismatch("int64".to_string()))?,
+            )
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::UInt8 => {
+            align_write(buf, 1);
+            buf.write_u8(
+                value
+                    .extract::<u8>()
+                    .map_err(|_| mismatch("uint8".to_string()))?,
+            )
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::UInt16 => {
+            align_write(buf, 2);
+            buf.write_u16::<LittleEndian>(
+                value
+                    .extract::<u16>()
+                    .map_err(|_| mismatch("uint16".to_string()))?,
+            )
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::UInt32 => {
+            align_write(buf, 4);
+            buf.write_u32::<LittleEndian>(
+                value
+                    .extract::<u32>()
+                    .map_err(|_| mismatch("uint32".to_string()))?,
+            )
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::UInt64 => {
+            align_write(buf, 8);
+            buf.write_u64::<LittleEndian>(
+                value
+                    .extract::<u64>()
+                    .map_err(|_| mismatch("uint64".to_string()))?,
+            )
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::Float32 => {
+            align_write(buf, 4);
+            buf.write_f32::<LittleEndian>(
+                value
+                    .extract::<f32>()
+                    .map_err(|_| mismatch("float32".to_string()))?,
+            )
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::Float64 => {
+            align_write(buf, 8);
+            buf.write_f64::<LittleEndian>(
+                value
+                    .extract::<f64>()
+                    .map_err(|_| mismatch("float64".to_string()))?,
+            )
+            .map_err(|e| MessageError::SerializationError(e.to_string()))?
+        }
+        FieldType::RosString => {
+            align_write(buf, 4);
+            let data = value
+                .extract::<String>()
+                .map_err(|_| mismatch("string".to_string()))?;
+            let bytes = data.as_bytes();
+            let ros_len = bytes.len() as u32 + 1;
+            buf.write_u32::<LittleEndian>(ros_len)
+                .map_err(|e| MessageError::SerializationError(e.to_string()))?;
+            buf.extend_from_slice(bytes);
+            buf.push(0_u8);
+        }
+        FieldType::RosBytes => {
+            align_write(buf, 4);
+            let data = value
+                .cast::<PyBytes>()
+                .map_err(|_| mismatch("bytes".to_string()))?
+                .as_bytes();
+            buf.write_u32::<LittleEndian>(data.len() as u32)
+                .map_err(|e| MessageError::SerializationError(e.to_string()))?;
+            buf.extend_from_slice(data);
+        }
+        FieldType::Array(inner) => {
+            align_write(buf, 4);
+            let items = value
+                .cast::<PyList>()
+                .map_err(|_| mismatch(format!("array<{}>", inner.as_name())))?;
+            buf.write_u32::<LittleEndian>(items.len() as u32)
+                .map_err(|e| MessageError::SerializationError(e.to_string()))?;
+            for item in items.iter() {
+                let item_mismatch = |expected: String| MessageError::TypeMismatch {
+                    field: field_name.to_string(),
+                    expected,
+                    got: type_name_for_value(&item).to_string(),
+                };
+                write_by_type(buf, py, inner, &item, field_name, &item_mismatch)?;
+            }
+        }
+        FieldType::Struct(schema_name) => {
+            let nested = value
+                .cast::<PyDict>()
+                .map_err(|_| mismatch(format!("struct:{schema_name}")))?;
+            let nested_schema = get_schema_internal(schema_name)?;
+            for nested_field in &nested_schema.fields {
+                let nested_value = nested
+                    .get_item(&nested_field.name)
+                    .map_err(|e| MessageError::SerializationError(e.to_string()))?
+                    .ok_or_else(|| {
+                        MessageError::SerializationError(format!(
+                            "Missing nested field '{}.{}'",
+                            field_name, nested_field.name
+                        ))
+                    })?;
+                write_by_type(
+                    buf,
+                    py,
+                    &nested_field.field_type,
+                    &nested_value,
+                    &format!("{field_name}.{}", nested_field.name),
+                    mismatch,
+                )?;
+            }
+        }
+        FieldType::Time | FieldType::Duration => {
+            let dict = value
+                .cast::<PyDict>()
+                .map_err(|_| mismatch(field_type.as_name()))?;
+            align_write(buf, 4);
+            let sec = dict
+                .get_item("sec")
+                .map_err(|e| MessageError::SerializationError(e.to_string()))?
+                .ok_or_else(|| MessageError::SerializationError(format!("Missing field '{field_name}.sec'")))?
+                .extract::<i32>()
+                .map_err(|_| mismatch(format!("{} with int32 sec", field_type.as_name())))?;
+            buf.write_i32::<LittleEndian>(sec)
+                .map_err(|e| MessageError::SerializationError(e.to_string()))?;
+            align_write(buf, 4);
+            let nanosec = dict
+                .get_item("nanosec")
+                .map_err(|e| MessageError::SerializationError(e.to_string()))?
+                .ok_or_else(|| MessageError::SerializationError(format!("Missing field '{field_name}.nanosec'")))?
+                .extract::<u32>()
+                .map_err(|_| mismatch(format!("{} with uint32 nanosec", field_type.as_name())))?;
+            buf.write_u32::<LittleEndian>(nanosec)
+                .map_err(|e| MessageError::SerializationError(e.to_string()))?;
+        }
+    }
+
+    Ok(())
+}
+
+fn read_field_value<'py>(
+    py: Python<'py>,
+    reader: &mut Cursor<&[u8]>,
+    field: &FieldSchema,
+) -> Result<Py<PyAny>, MessageError> {
+    read_by_type(py, reader, &field.field_type, &field.name)
+}
+
+fn read_by_type<'py>(
+    py: Python<'py>,
+    reader: &mut Cursor<&[u8]>,
+    field_type: &FieldType,
+    field_name: &str,
+) -> Result<Py<PyAny>, MessageError> {
+    let value = match field_type {
+        FieldType::Bool => {
+            align_read(reader, 1)?;
+            (reader
+                .read_u8()
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+                != 0)
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::Int8 => { align_read(reader, 1)?;
+            reader
+            .read_i8()
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::Int16 => { align_read(reader, 2)?;
+            reader
+            .read_i16::<LittleEndian>()
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::Int32 => { align_read(reader, 4)?;
+            reader
+            .read_i32::<LittleEndian>()
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::Int64 => { align_read(reader, 8)?;
+            reader
+            .read_i64::<LittleEndian>()
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::UInt8 => { align_read(reader, 1)?;
+            reader
+            .read_u8()
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::UInt16 => { align_read(reader, 2)?;
+            reader
+            .read_u16::<LittleEndian>()
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::UInt32 => { align_read(reader, 4)?;
+            reader
+            .read_u32::<LittleEndian>()
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::UInt64 => { align_read(reader, 8)?;
+            reader
+            .read_u64::<LittleEndian>()
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::Float32 => { align_read(reader, 4)?;
+            reader
+            .read_f32::<LittleEndian>()
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::Float64 => { align_read(reader, 8)?;
+            reader
+            .read_f64::<LittleEndian>()
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+            .into_py_any(py)
+            .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::RosString => {
+            align_read(reader, 4)?;
+            let len = reader
+                .read_u32::<LittleEndian>()
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?;
+            let mut buf = vec![0_u8; len as usize];
+            std::io::Read::read_exact(reader, &mut buf)
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?;
+            if buf.last().copied() != Some(0) {
+                return Err(MessageError::DeserializationError(format!(
+                    "Invalid ROS string for '{}': missing NUL terminator",
+                    field_name
+                )));
+            }
+            buf.pop();
+            String::from_utf8(buf)
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+                .into_py_any(py)
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+        }
+        FieldType::RosBytes => {
+            align_read(reader, 4)?;
+            let len = reader
+                .read_u32::<LittleEndian>()
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?;
+            let mut buf = vec![0_u8; len as usize];
+            std::io::Read::read_exact(reader, &mut buf)
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?;
+            PyBytes::new(py, &buf).into_any().unbind()
+        }
+        FieldType::Array(inner) => {
+            align_read(reader, 4)?;
+            let len = reader
+                .read_u32::<LittleEndian>()
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?
+                as usize;
+            let out = PyList::empty(py);
+            for _ in 0..len {
+                out.append(read_by_type(py, reader, inner, field_name)?)
+                    .map_err(|e| MessageError::DeserializationError(e.to_string()))?;
+            }
+            out.into_any().unbind()
+        }
+        FieldType::Struct(schema_name) => {
+            let schema = get_schema_internal(schema_name)?;
+            let out = PyDict::new(py);
+            for nested_field in &schema.fields {
+                let nested_value = read_by_type(
+                    py,
+                    reader,
+                    &nested_field.field_type,
+                    &format!("{field_name}.{}", nested_field.name),
+                )?;
+                out.set_item(&nested_field.name, nested_value)
+                    .map_err(|e| MessageError::DeserializationError(e.to_string()))?;
+            }
+            out.into_any().unbind()
+        }
+        FieldType::Time | FieldType::Duration => {
+            align_read(reader, 4)?;
+            let sec = reader
+                .read_i32::<LittleEndian>()
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?;
+            align_read(reader, 4)?;
+            let nanosec = reader
+                .read_u32::<LittleEndian>()
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?;
+            let out = PyDict::new(py);
+            out.set_item("sec", sec)
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?;
+            out.set_item("nanosec", nanosec)
+                .map_err(|e| MessageError::DeserializationError(e.to_string()))?;
+            out.into_any().unbind()
+        }
+    };
+
+    Ok(value)
+}
+
+fn align_write(buf: &mut Vec<u8>, align: usize) {
+    let rem = buf.len() % align;
+    if rem != 0 {
+        let pad = align - rem;
+        buf.resize(buf.len() + pad, 0_u8);
+    }
+}
+
+fn align_read(reader: &mut Cursor<&[u8]>, align: usize) -> Result<(), MessageError> {
+    let pos = reader.position() as usize;
+    let rem = pos % align;
+    if rem != 0 {
+        let pad = (align - rem) as u64;
+        let new_pos = reader.position() + pad;
+        if (new_pos as usize) > reader.get_ref().len() {
+            return Err(MessageError::DeserializationError(
+                "Input truncated while aligning CDR stream".into(),
+            ));
+        }
+        reader.set_position(new_pos);
+    }
+    Ok(())
+}
+
+#[pyfunction]
+fn register_schema(name: &str, fields: &Bound<'_, PyList>) -> PyResult<()> {
+    let schema = parse_schema(fields)?;
+    register_schema_internal(name, schema)?;
+    Ok(())
+}
+
+#[pyfunction]
+fn get_schema(py: Python<'_>, name: &str) -> PyResult<Py<PyList>> {
+    let schema = get_schema_internal(name)?;
+    let out = PyList::empty(py);
+    for field in schema.fields {
+        out.append((field.name, field.field_type.as_name()))?;
+    }
+    Ok(out.unbind())
+}
+
+#[pyfunction]
+fn schema_exists(name: &str) -> bool {
+    if let Ok(registry) = get_schema_registry().lock() {
+        registry.contains_key(name)
+    } else {
+        false
+    }
+}
+
+#[pyfunction]
+fn unregister_schema(name: &str) -> PyResult<()> {
+    let mut registry = get_schema_registry()
+        .lock()
+        .map_err(|_| PyValueError::new_err("Schema registry lock poisoned"))?;
+    registry
+        .remove(name)
+        .ok_or_else(|| MessageError::UnknownSchema(name.to_string()))?;
+    Ok(())
+}
+
+#[pyfunction]
+fn serialize(py: Python<'_>, schema_name: &str, values: &Bound<'_, PyDict>) -> PyResult<Py<PyBytes>> {
+    let schema = get_schema_internal(schema_name)?;
+    let mut out = Vec::with_capacity(128);
+    out.extend_from_slice(&CDR_LE_ENCAPSULATION);
+    for field in &schema.fields {
+        let value = values
+            .get_item(&field.name)?
+            .ok_or_else(|| MessageError::SerializationError(format!("Missing field '{}'", field.name)))?;
+        write_field_value(&mut out, py, field, &value)?;
+    }
+    Ok(PyBytes::new(py, &out).unbind())
+}
+
+#[pyfunction]
+fn deserialize(py: Python<'_>, schema_name: &str, data: &[u8]) -> PyResult<Py<PyDict>> {
+    if data.len() < 4 {
+        return Err(PyValueError::new_err("CDR payload too short (missing encapsulation header)"));
+    }
+    if data[0..2] != CDR_LE_ENCAPSULATION[0..2] {
+        return Err(PyValueError::new_err(format!(
+            "Unsupported CDR encapsulation {:02x?}. Only little-endian CDR is currently supported",
+            &data[0..4]
+        )));
+    }
+
+    let schema = get_schema_internal(schema_name)?;
+    let out = PyDict::new(py);
+    let mut cursor = Cursor::new(data);
+    cursor.set_position(4);
+
+    for field in &schema.fields {
+        let value = read_field_value(py, &mut cursor, field)?;
+        out.set_item(&field.name, value)?;
+    }
+
+    Ok(out.unbind())
+}
+
+#[pymodule]
+fn _reachpy_messages(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(register_schema, m)?)?;
+    m.add_function(wrap_pyfunction!(get_schema, m)?)?;
+    m.add_function(wrap_pyfunction!(schema_exists, m)?)?;
+    m.add_function(wrap_pyfunction!(unregister_schema, m)?)?;
+    m.add_function(wrap_pyfunction!(serialize, m)?)?;
+    m.add_function(wrap_pyfunction!(deserialize, m)?)?;
+    Ok(())
+}

reachpy-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["maturin>=1.0,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "reachpy"
+version = "0.1.0"
+description = "Python-native robotics framework built on ROS2"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+readme = "README.md"
+authors = [
+    { name = "ReachPy Contributors" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Rust",
+    "Topic :: Software Development :: Libraries",
+]
+
+[tool.maturin]
+features = ["pyo3/extension-module"]
+python-source = "python"
+module-name = "reachpy._reachpy_messages"

reachpy-0.1.0/python/reachpy/__init__.py

@@ -0,0 +1,5 @@
+"""ReachPy public Python package surface."""
+
+from . import _reachpy_messages as reachpy_messages
+
+__all__ = ["reachpy_messages"]