Merge sedsprintf_rs upstream main

Author: Rylan-Meilutis

sedsprintf_rs/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
+version = "1.1.0"
 name = "sedsprintf_rs_2026"
-version = "1.0.8"
 edition = "2024"
 build = "build.rs"
 authors = ["Rylan Meilutis <[email protected]>"]

sedsprintf_rs/header_templates/sedsprintf.h.txt

@@ -6,6 +6,7 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <string.h> /* for strlen in string macros */
+#include <stdbool.h> /* for bool type */
 
 #ifdef __cplusplus
 extern "C" {
@@ -179,6 +180,57 @@ int32_t seds_pkt_copy_bytes(const SedsPacketView * pkt, void * dst, size_t dst_l
 
 int32_t seds_pkt_copy_data(const SedsPacketView * pkt, size_t elem_size, void * dst, size_t dst_elems);
 
+
+/**
+ * Typed payload getters using TelemetryPacket::data_as_* helpers.
+ *
+ * Semantics (matching seds_pkt_copy_data / Rust side):
+ *  - If out is NULL or out_elems == 0 or out_elems < needed:
+ *       returns the required element count (>= 0), performs NO copy.
+ *  - On success:
+ *       returns the number of elements written (>= 0).
+ *  - On error:
+ *       returns a negative SedsResult error code.
+ */
+
+int32_t seds_pkt_get_f32 (const SedsPacketView * pkt, float    * out, size_t out_elems);
+int32_t seds_pkt_get_f64 (const SedsPacketView * pkt, double   * out, size_t out_elems);
+
+int32_t seds_pkt_get_u8  (const SedsPacketView * pkt, uint8_t  * out, size_t out_elems);
+int32_t seds_pkt_get_u16 (const SedsPacketView * pkt, uint16_t * out, size_t out_elems);
+int32_t seds_pkt_get_u32 (const SedsPacketView * pkt, uint32_t * out, size_t out_elems);
+int32_t seds_pkt_get_u64 (const SedsPacketView * pkt, uint64_t * out, size_t out_elems);
+
+int32_t seds_pkt_get_i8  (const SedsPacketView * pkt, int8_t   * out, size_t out_elems);
+int32_t seds_pkt_get_i16 (const SedsPacketView * pkt, int16_t  * out, size_t out_elems);
+int32_t seds_pkt_get_i32 (const SedsPacketView * pkt, int32_t  * out, size_t out_elems);
+int32_t seds_pkt_get_i64 (const SedsPacketView * pkt, int64_t  * out, size_t out_elems);
+
+int32_t seds_pkt_get_bool(const SedsPacketView * pkt, bool     * out, size_t out_elems);
+
+/**
+ * String getter for MessageDataType::String payloads.
+ *
+ * Semantics:
+ *  - If buf is NULL or buf_len == 0:
+ *       returns required length INCLUDING terminating NUL (>= 1), no copy.
+ *  - If buf_len is too small:
+ *       writes as much as fits (buf_len-1 chars), NUL-terminates,
+ *       returns required length (>= 1).
+ *  - On success:
+ *       returns 0.
+ *  - On error:
+ *       returns negative SedsResult error code.
+ */
+int32_t seds_pkt_get_string(const SedsPacketView * pkt, char * buf, size_t buf_len);
+
+/* @breif Get the length of a string payload (Including NUL terminator).
+ * @return length (>=0) on success; SedsResult on error.
+ */
+int32_t seds_pkt_get_string_len(const SedsPacketView * pkt);
+
+
+
 SedsResult seds_pkt_get_typed(const SedsPacketView * pkt,
                               void * out,
                               size_t count,

sedsprintf_rs/header_templates/sedsprintf_rs.pyi.txt

@@ -78,6 +78,23 @@ class Packet:
     def wire_size(self) -> int: ...
     def serialize(self) -> bytes: ...
 
+    # Typed payload decoders (mirror TelemetryPacket::data_as_*)
+    def data_as_u8(self) -> List[int]: ...
+    def data_as_u16(self) -> List[int]: ...
+    def data_as_u32(self) -> List[int]: ...
+    def data_as_u64(self) -> List[int]: ...
+
+    def data_as_i8(self) -> List[int]: ...
+    def data_as_i16(self) -> List[int]: ...
+    def data_as_i32(self) -> List[int]: ...
+    def data_as_i64(self) -> List[int]: ...
+
+    def data_as_f32(self) -> List[float]: ...
+    def data_as_f64(self) -> List[float]: ...
+
+    def data_as_bool(self) -> List[bool]: ...
+    def data_as_string(self) -> str: ...
+
 
 # ==============================
 # Router (lifecycle, logging, queues)
@@ -97,12 +114,13 @@ class Router:
     """
 
     @staticmethod
-    def new_singleton(tx: Optional[TxCallback] = ...,
-            now_ms: Optional[NowMsCallback] = ...,
-            handlers: Optional[
-                Sequence[Tuple[int, Optional[PacketHandler], Optional[SerializedHandler]]]
-            ] = ...,
-        ) -> "Router":
+    def new_singleton(
+        tx: Optional[TxCallback] = ...,
+        now_ms: Optional[NowMsCallback] = ...,
+        handlers: Optional[
+            Sequence[Tuple[int, Optional[PacketHandler], Optional[SerializedHandler]]]
+        ] = ...,
+    ) -> "Router":
         """
         Create or retrieve a per-process singleton Router.
 
@@ -115,7 +133,6 @@ class Router:
         """
         ...
 
-
     def __init__(
         self,
         tx: Optional[TxCallback] = ...,

sedsprintf_rs/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "sedsprintf_rs_2026"
-version = "1.0.8"
+version = "1.1.0"
 description = "Rust telemetry and serialization library"
 authors = [{ name = "Rylan Meilutis", email = "[email protected]" }]
 readme = "README.md"

sedsprintf_rs/src/c_api.rs

@@ -1136,6 +1136,123 @@ pub extern "C" fn seds_pkt_data_ptr(
     view.payload as *const c_void
 }
 
+
+macro_rules! impl_seds_pkt_get_typed_from_packet {
+    ($fname:ident, $method:ident, $ty:ty) => {
+        #[unsafe(no_mangle)]
+        pub extern "C" fn $fname(
+            pkt: *const SedsPacketView,
+            out: *mut $ty,
+            out_elems: usize,
+        ) -> i32 {
+            // Basic arg check
+            if pkt.is_null() {
+                return status_from_err(TelemetryError::BadArg);
+            }
+
+            let view = unsafe { &*pkt };
+            let tpkt = match view_to_packet(view) {
+                Ok(p) => p,
+                Err(_) => return status_from_err(TelemetryError::BadArg),
+            };
+
+            let vals = match tpkt.$method() {
+                Ok(v) => v,
+                Err(e) => return status_from_err(e),
+            };
+
+            let needed = vals.len();
+
+            // No payload => nothing to copy
+            if needed == 0 {
+                return 0;
+            }
+
+            // Query / too-small: return required element count
+            if out.is_null() || out_elems == 0 || out_elems < needed {
+                return needed as i32;
+            }
+
+            unsafe {
+                ptr::copy_nonoverlapping(vals.as_ptr(), out, needed);
+            }
+
+            needed as i32
+        }
+    };
+}
+
+
+// Typed getters using TelemetryPacket's data_as_* helpers.
+// All use "query" semantics like seds_pkt_copy_data:
+//   - If out is NULL or out_elems < needed, return needed (element count) and do not copy.
+//   - On success, return the number of elements written.
+
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_f32, data_as_f32, f32);
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_f64, data_as_f64, f64);
+
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_u8,  data_as_u8,  u8);
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_u16, data_as_u16, u16);
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_u32, data_as_u32, u32);
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_u64, data_as_u64, u64);
+
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_i8,  data_as_i8,  i8);
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_i16, data_as_i16, i16);
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_i32, data_as_i32, i32);
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_i64, data_as_i64, i64);
+
+impl_seds_pkt_get_typed_from_packet!(seds_pkt_get_bool, data_as_bool, bool);
+
+#[unsafe(no_mangle)]
+pub extern "C" fn seds_pkt_get_string(
+    pkt: *const SedsPacketView,
+    buf: *mut c_char,
+    buf_len: usize,
+) -> i32 {
+    if pkt.is_null() {
+        return status_from_err(TelemetryError::BadArg);
+    }
+
+    let view = unsafe { &*pkt };
+    let tpkt = match view_to_packet(view) {
+        Ok(p) => p,
+        Err(_) => return status_from_err(TelemetryError::BadArg),
+    };
+
+    let s = match tpkt.data_as_string() {
+        Ok(s) => s,
+        Err(e) => return status_from_err(e),
+    };
+
+    // Same semantics as the other string helpers:
+    // - if buf is NULL or buf_len == 0 → return required length (incl NUL)
+    // - if too small → write as much as fits + NUL, return required length
+    // - on success → return 0
+    unsafe { write_str_to_buf(&s, buf, buf_len) }
+}
+
+#[unsafe(no_mangle)]
+pub extern "C" fn seds_pkt_get_string_len(
+    pkt: *const SedsPacketView,
+) -> i32 {
+    if pkt.is_null() {
+        return status_from_err(TelemetryError::BadArg);
+    }
+
+    let view = unsafe { &*pkt };
+    let tpkt = match view_to_packet(view) {
+        Ok(p) => p,
+        Err(_) => return status_from_err(TelemetryError::BadArg),
+    };
+
+    let s = match tpkt.data_as_string() {
+        Ok(s) => s,
+        Err(e) => return status_from_err(e),
+    };
+
+    (s.len() + 1) as i32
+}
+
 /// Copy raw payload bytes into `dst`.
 ///
 /// Query mode:

sedsprintf_rs/src/lib.rs

@@ -355,6 +355,9 @@ pub enum TelemetryError {
 
     /// UTF-8 decoding failed where string payloads are expected.
     InvalidUtf8,
+
+    /// Payload type size mismatch.
+    TypeMismatch { expected: usize, got: usize },
 }
 
 impl TelemetryError {
@@ -375,6 +378,7 @@ impl TelemetryError {
             TelemetryError::Deserialize(_) => TelemetryErrorCode::Deserialize,
             TelemetryError::Io(_) => TelemetryErrorCode::Io,
             TelemetryError::InvalidUtf8 => TelemetryErrorCode::InvalidUtf8,
+            TelemetryError::TypeMismatch { .. } => TelemetryErrorCode::TypeMismatch,
         }
     }
 }
@@ -433,6 +437,7 @@ pub enum TelemetryErrorCode {
     Deserialize = -12,
     Io = -13,
     InvalidUtf8 = -14,
+    TypeMismatch = -15,
 }
 
 // Generate ReprI32Enum helpers for TelemetryErrorCode
@@ -468,6 +473,7 @@ impl TelemetryErrorCode {
             TelemetryErrorCode::Deserialize => "{Deserialize Error}",
             TelemetryErrorCode::Io => "{IO Error}",
             TelemetryErrorCode::InvalidUtf8 => "{Invalid UTF-8}",
+            TelemetryErrorCode::TypeMismatch => "{Type Mismatch}",
         }
     }
 

sedsprintf_rs/src/python_api.rs

@@ -153,6 +153,105 @@ impl PyPacket {
         PyBytes::new(py, &self.inner.payload())
     }
 
+    /// Decode payload as `Vec<u8>` for unsigned byte arrays.
+    fn data_as_u8(&self) -> PyResult<Vec<u8>> {
+        self.inner
+            .data_as_u8()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as `Vec<u16>` for unsigned 16-bit arrays.
+    fn data_as_u16(&self) -> PyResult<Vec<u16>> {
+        self.inner
+            .data_as_u16()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as `Vec<u32>` for unsigned 32-bit arrays.
+    fn data_as_u32(&self) -> PyResult<Vec<u32>> {
+        self.inner
+            .data_as_u32()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as `Vec<u64>` for unsigned 64-bit arrays.
+    fn data_as_u64(&self) -> PyResult<Vec<u64>> {
+        self.inner
+            .data_as_u64()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as `Vec<i8>` for signed 8-bit arrays.
+    fn data_as_i8(&self) -> PyResult<Vec<i8>> {
+        self.inner
+            .data_as_i8()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as `Vec<i16>` for signed 16-bit arrays.
+    fn data_as_i16(&self) -> PyResult<Vec<i16>> {
+        self.inner
+            .data_as_i16()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as `Vec<i32>` for signed 32-bit arrays.
+    fn data_as_i32(&self) -> PyResult<Vec<i32>> {
+        self.inner
+            .data_as_i32()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as `Vec<i64>` for signed 64-bit arrays.
+    fn data_as_i64(&self) -> PyResult<Vec<i64>> {
+        self.inner
+            .data_as_i64()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as `Vec<f32>` for float32 arrays.
+    fn data_as_f32(&self) -> PyResult<Vec<f32>> {
+        self.inner
+            .data_as_f32()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as `Vec<f64>` for float64 arrays.
+    fn data_as_f64(&self) -> PyResult<Vec<f64>> {
+        self.inner
+            .data_as_f64()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as `Vec<bool>` for boolean arrays.
+    fn data_as_bool(&self) -> PyResult<Vec<bool>> {
+        self.inner
+            .data_as_bool()
+            .map(|v| v.to_vec())
+            .map_err(py_err_from)
+    }
+
+    /// Decode payload as a UTF-8 string for `DataType::String`.
+    ///
+    /// Uses the same rules as the C FFI helper:
+    /// - strips trailing `\0` bytes
+    /// - errors on invalid UTF-8 or wrong type.
+    fn data_as_string(&self) -> PyResult<String> {
+        self.inner
+            .data_as_string()
+            .map_err(py_err_from)
+    }
+
     /// Human-readable header string (no payload).
     fn header_string(&self) -> String {
         self.inner.header_string()