finalize implementation

Author: wyfo

Cargo.lock

@@ -34,18 +34,19 @@ name = "zenoh"
 crate-type = ["cdylib"]
 
 [features]
-default = ["shared-memory", "zenoh/default", "zenoh-ext"]
+default = ["pyo3/abi3-py310", "shared-memory", "zenoh-ext", "zenoh/default"]
 shared-memory = ["zenoh/shared-memory"]
-zenoh-ext = ["dep:zenoh-ext", "zenoh-ext/unstable", "zenoh-ext/internal"]
+zenoh-ext = ["dep:zenoh-ext", "zenoh-ext/internal", "zenoh-ext/unstable"]
 
 [badges]
 maintenance = { status = "actively-developed" }
 
 [dependencies]
 paste = "1.0.14"
-pyo3 = { version = "0.25.1", features = [
-  "extension-module",
-  "abi3-py311",
-] }
-zenoh = { version = "1.5.1", git = "https://github.com/ZettaScaleLabs/zenoh.git", branch = "shm-new-api", features = ["unstable", "internal"], default-features = false }
-zenoh-ext = { version = "1.5.1", git = "https://github.com/ZettaScaleLabs/zenoh.git", branch = "shm-new-api", features = ["internal"], optional = true }
+pyo3 = { version = "0.25.1", features = ["extension-module"] }
+zenoh = { version = "1.5.1", git = "https://github.com/eclipse-zenoh/zenoh.git", branch = "main", features = ["internal", "unstable"], default-features = false }
+zenoh-ext = { version = "1.5.1", git = "https://github.com/eclipse-zenoh/zenoh.git", branch = "main", features = ["internal"], optional = true }
+
+[build-dependencies]
+pyo3-build-config = { version = "0.25.1", features = ["resolve-config"] }
+

Cargo.toml

@@ -0,0 +1,3 @@
+fn main() {
+    pyo3_build_config::use_pyo3_cfgs();
+}

build.rs

@@ -0,0 +1,89 @@
+#
+# Copyright (c) 2022 ZettaScale Technology
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License 2.0 which is available at
+# http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0
+# which is available at https://www.apache.org/licenses/LICENSE-2.0.
+#
+# SPDX-License-Identifier: EPL-2.0 OR Apache-2.0
+#
+# Contributors:
+#   ZettaScale Zenoh Team, <[email protected]>
+#
+import time
+from typing import Optional
+
+import zenoh
+
+
+def main(
+    conf: zenoh.Config, key: str, payload: str, iter: Optional[int], interval: int
+):
+    # initiate logging
+    zenoh.init_log_from_env_or("error")
+
+    print("Opening session...")
+    with zenoh.open(conf) as session:
+
+        print("Creating POSIX SHM provider...")
+        provider = zenoh.shm.ShmProvider.default_backend(1024 * 1024)
+
+        print(f"Declaring Publisher on '{key}'...")
+        pub = session.declare_publisher(key)
+
+        print("Press CTRL-C to quit...")
+        for idx in itertools.count() if iter is None else range(iter):
+            time.sleep(interval)
+            prefix = f"[{idx:4d}] "
+            sbuf = provider.alloc(
+                len(prefix) + len(payload),
+                policy=zenoh.shm.BlockOn(zenoh.shm.GarbageCollect()),
+            )
+            sbuf[: len(prefix)] = prefix.encode()
+            sbuf[len(prefix) :] = payload.encode()
+
+            print(f"Putting Data ('{key}': '{sbuf}')...")
+            pub.put(sbuf)
+
+
+# --- Command line argument parsing --- --- --- --- --- ---
+if __name__ == "__main__":
+    import argparse
+    import itertools
+
+    import common
+
+    parser = argparse.ArgumentParser(prog="z_pub", description="zenoh pub example")
+    common.add_config_arguments(parser)
+    parser.add_argument(
+        "--key",
+        "-k",
+        dest="key",
+        default="demo/example/zenoh-python-pub",
+        type=str,
+        help="The key expression to publish onto.",
+    )
+    parser.add_argument(
+        "--payload",
+        "-p",
+        dest="payload",
+        default="Pub from Python!",
+        type=str,
+        help="The payload to publish.",
+    )
+    parser.add_argument(
+        "--iter", dest="iter", type=int, help="How many puts to perform"
+    )
+    parser.add_argument(
+        "--interval",
+        dest="interval",
+        type=float,
+        default=1.0,
+        help="Interval between each put",
+    )
+
+    args = parser.parse_args()
+    conf = common.get_config_from_args(args)
+
+    main(conf, args.key, args.payload, args.iter, args.interval)

examples/z_pub_shm.py

@@ -11,22 +11,16 @@
 // Contributors:
 //   ZettaScale Zenoh Team, <[email protected]>
 //
-use std::{
-    borrow::Cow,
-    ffi::{c_int, c_void},
-    io::Read,
-    ptr,
-};
+use std::{borrow::Cow, io::Read};
 
 use pyo3::{
-    exceptions::{PyBufferError, PyTypeError, PyValueError},
+    exceptions::{PyTypeError, PyValueError},
     prelude::*,
-    types::{PyByteArray, PyBytes, PyString},
+    types::{PyByteArray, PyBytes, PyMemoryView, PyString},
 };
 
 use crate::{
     macros::{downcast_or_new, wrapper},
-    shm::ZShmMut,
     utils::{IntoPyResult, MapInto},
 };
 
@@ -46,52 +40,53 @@ impl ZBytes {
             Ok(Self(bytes.as_bytes().into()))
         } else if let Ok(string) = obj.downcast::<PyString>() {
             Ok(Self(string.to_string().into()))
-        } else if let Ok(buf) = obj.downcast_exact::<ZShmMut>() {
-            Ok(Self(buf.borrow_mut().take()?.into()))
         } else {
+            #[cfg(feature = "shared-memory")]
+            if let Ok(buf) = obj.downcast_exact::<crate::shm::ZShmMut>() {
+                return Ok(Self(buf.borrow_mut().take()?.into()));
+            }
+            #[cfg(Py_3_11)]
+            if let Ok(buffer) = pyo3::buffer::PyBuffer::<u8>::get(obj) {
+                return Ok(Self(buffer.to_vec(obj.py())?.into()));
+            }
             Err(PyTypeError::new_err(format!(
                 "expected bytes/str type, found '{}'",
                 obj.get_type().name().unwrap()
             )))
         }
     }
 
+    #[cfg(Py_3_11)]
     unsafe fn __getbuffer__(
-        this: Bound<'_, Self>,
+        mut this: PyRefMut<Self>,
         view: *mut pyo3::ffi::Py_buffer,
-        flags: c_int,
+        flags: std::ffi::c_int,
     ) -> PyResult<()> {
         if view.is_null() {
-            return Err(PyBufferError::new_err("Buffer ptr is null"));
+            return Err(pyo3::exceptions::PyBufferError::new_err(
+                "Buffer ptr is null",
+            ));
         }
         if flags & pyo3::ffi::PyBUF_WRITABLE != 0 {
-            return Err(PyBufferError::new_err("ZBytes is not writable"));
+            return Err(pyo3::exceptions::PyBufferError::new_err(
+                "ZBytes is not writable",
+            ));
         }
-        let mut borrow = this.borrow_mut();
-        let (buf, len) = match borrow.0.to_bytes() {
+        let (buf, len) = match this.0.to_bytes() {
             Cow::Borrowed(bytes) => (bytes.as_ptr(), bytes.len()),
             Cow::Owned(bytes) => {
                 let (buf, len) = (bytes.as_ptr(), bytes.len());
-                borrow.0 = bytes.into();
+                this.0 = bytes.into();
                 (buf, len)
             }
         };
         unsafe {
-            (*view).buf = buf as *mut c_void;
-            (*view).obj = this.into_ptr();
-            (*view).len = len as isize;
-            (*view).readonly = 1;
-            (*view).itemsize = 1;
-            (*view).format = ptr::null_mut();
-            (*view).ndim = 1;
-            (*view).shape = ptr::null_mut();
-            (*view).strides = ptr::null_mut();
-            (*view).suboffsets = ptr::null_mut();
-            (*view).internal = ptr::null_mut();
-        }
+            crate::utils::init_buffer(view, flags, buf.cast_mut(), len, true, this.into_ptr())
+        };
         Ok(())
     }
 
+    #[cfg(Py_3_11)]
     unsafe fn __releasebuffer__(&mut self, _view: *mut pyo3::ffi::Py_buffer) {}
 
     fn to_bytes<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyBytes>> {
@@ -107,6 +102,13 @@ impl ZBytes {
             .map_err(|_| PyValueError::new_err("not an UTF8 error"))
     }
 
+    fn __getitem__<'py>(
+        this: &Bound<'py, Self>,
+        obj: &Bound<'py, PyAny>,
+    ) -> PyResult<Bound<'py, PyAny>> {
+        PyMemoryView::from(this.as_any())?.get_item(obj)
+    }
+
     fn __len__(&self) -> usize {
         self.0.len()
     }

src/bytes.rs

@@ -97,11 +97,11 @@ pub(crate) mod zenoh {
 
     #[cfg(feature = "shared-memory")]
     #[pymodule]
-    mod _shm {
+    mod shm {
         #[pymodule_export]
         use crate::shm::{
-            AllocAlignment, BlockOn, DeallocEldest, DeallocOptimal, DeallocYoungest, Deallocate,
-            Defragment, GarbageCollect, JustAlloc, ShmProvider, ZShmMut,
+            AllocAlignment, BlockOn, Deallocate, Defragment, GarbageCollect, JustAlloc,
+            ShmProvider, ZShmMut,
         };
     }
 
@@ -112,7 +112,7 @@ pub(crate) mod zenoh {
         #[cfg(feature = "zenoh-ext")]
         sys_modules.set_item("zenoh._ext", m.getattr("_ext")?)?;
         #[cfg(feature = "shared-memory")]
-        sys_modules.set_item("zenoh._shm", m.getattr("_shm")?)?;
+        sys_modules.set_item("zenoh.shm", m.getattr("shm")?)?;
         // TODO
         // crate::logging::init_logger(m.py())?;
         Ok(())