remove buffer protocol support

Author: wyfo

Cargo.lock

@@ -34,7 +34,7 @@ name = "zenoh"
 crate-type = ["cdylib"]
 
 [features]
-default = ["pyo3/abi3-py310", "shared-memory", "zenoh-ext", "zenoh/default"]
+default = ["shared-memory", "zenoh-ext", "zenoh/default"]
 shared-memory = ["zenoh/shared-memory"]
 zenoh-ext = ["dep:zenoh-ext", "zenoh-ext/internal", "zenoh-ext/unstable"]
 
@@ -43,10 +43,6 @@ maintenance = { status = "actively-developed" }
 
 [dependencies]
 paste = "1.0.14"
-pyo3 = { version = "0.25.1", features = ["extension-module"] }
+pyo3 = { version = "0.25.1", features = ["abi3-py39", "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

@@ -16,7 +16,7 @@ use std::{borrow::Cow, io::Read};
 use pyo3::{
     exceptions::{PyTypeError, PyValueError},
     prelude::*,
-    types::{PyByteArray, PyBytes, PyMemoryView, PyString},
+    types::{PyByteArray, PyBytes, PyString},
 };
 
 use crate::{
@@ -45,50 +45,13 @@ impl ZBytes {
             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__(
-        mut this: PyRefMut<Self>,
-        view: *mut pyo3::ffi::Py_buffer,
-        flags: std::ffi::c_int,
-    ) -> PyResult<()> {
-        if view.is_null() {
-            return Err(pyo3::exceptions::PyBufferError::new_err(
-                "Buffer ptr is null",
-            ));
-        }
-        if flags & pyo3::ffi::PyBUF_WRITABLE != 0 {
-            return Err(pyo3::exceptions::PyBufferError::new_err(
-                "ZBytes is not writable",
-            ));
-        }
-        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());
-                this.0 = bytes.into();
-                (buf, len)
-            }
-        };
-        unsafe {
-            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>> {
         // Not using `ZBytes::to_bytes`
         PyBytes::new_with(py, self.0.len(), |bytes| {
@@ -102,13 +65,6 @@ 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()
     }

build.rs

@@ -3,7 +3,7 @@ use std::{str, sync::Arc};
 use pyo3::{
     exceptions::{PyTypeError, PyValueError},
     prelude::*,
-    types::{PyByteArray, PyBytes, PyMemoryView, PySlice, PyString, PyType},
+    types::{PyByteArray, PyBytes, PySlice, PyString, PyType},
 };
 use zenoh::shm::{ChunkAllocResult, PosixShmProviderBackend};
 
@@ -186,7 +186,6 @@ impl ShmProvider {
 #[pyclass]
 pub(crate) struct ZShmMut {
     buf: Option<zenoh::shm::ZShmMut>,
-    view_count: usize,
 }
 
 impl ZShmMut {
@@ -200,25 +199,13 @@ impl ZShmMut {
         Ok(self.buf.as_mut().unwrap())
     }
     pub(crate) fn take(&mut self) -> PyResult<zenoh::shm::ZShmMut> {
-        if self.view_count > 0 {
-            return Err(zerror!(
-                "ZShmMut cannot be converted to ZBytes if it has memoryview in use"
-            ));
-        }
         self.get()?;
         Ok(self.buf.take().unwrap())
     }
 }
 
 #[pymethods]
 impl ZShmMut {
-    fn __getitem__<'py>(
-        this: &Bound<'py, Self>,
-        key: &Bound<'py, PyAny>,
-    ) -> PyResult<Bound<'py, PyAny>> {
-        PyMemoryView::from(this.as_any())?.get_item(key)
-    }
-
     fn __setitem__(this: &Bound<Self>, key: &Bound<PyAny>, value: &Bound<PyAny>) -> PyResult<()> {
         if let Ok(key) = key.extract::<usize>() {
             if let Ok(value) = value.extract::<u8>() {
@@ -245,15 +232,8 @@ impl ZShmMut {
             } else if let Ok(bytes) = value.downcast::<PyBytes>() {
                 return copy_bytes(bytes.as_bytes());
             }
-            #[cfg(Py_3_11)]
-            if let Ok(value) = pyo3::buffer::PyBuffer::<u8>::get(value) {
-                return value.copy_to_slice(
-                    this.py(),
-                    &mut slice[indices.start as usize..indices.stop as usize],
-                );
-            }
         }
-        PyMemoryView::from(this.as_any())?.set_item(key, value)
+        Err(PyTypeError::new_err("expected bytes like argument"))
     }
 
     fn __str__<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyString>> {
@@ -264,53 +244,13 @@ impl ZShmMut {
         Ok(PyBytes::new(py, self.get()?))
     }
 
-    #[cfg(Py_3_11)]
-    unsafe fn __getbuffer__(
-        mut this: PyRefMut<Self>,
-        view: *mut pyo3::ffi::Py_buffer,
-        flags: std::ffi::c_int,
-    ) -> PyResult<()> {
-        if view.is_null() {
-            return Err(pyo3::exceptions::PyBufferError::new_err(
-                "Buffer ptr is null",
-            ));
-        }
-        this.view_count += 1;
-        let buffer = this.get_mut()?;
-        unsafe {
-            crate::utils::init_buffer(
-                view,
-                flags,
-                buffer.as_mut_ptr(),
-                buffer.len(),
-                false,
-                this.into_ptr(),
-            )
-        };
-        Ok(())
-    }
-
-    #[cfg(Py_3_11)]
-    unsafe fn __releasebuffer__(&mut self, _view: *mut pyo3::ffi::Py_buffer) {
-        self.view_count -= 1;
-    }
-
     fn __repr__(&self) -> PyResult<String> {
         Ok(format!("{:?}", self.get()?))
     }
 }
 
 impl From<zenoh::shm::ZShmMut> for ZShmMut {
     fn from(value: zenoh::shm::ZShmMut) -> Self {
-        Self {
-            buf: Some(value),
-            view_count: 0,
-        }
-    }
-}
-
-impl Drop for ZShmMut {
-    fn drop(&mut self) {
-        assert_eq!(self.view_count, 0, "there should be no remaining views");
+        Self { buf: Some(value) }
     }
 }

src/bytes.rs

@@ -129,40 +129,3 @@ pub(crate) fn duration(obj: &Bound<PyAny>) -> PyResult<Option<Duration>> {
         .map(Some)
         .map_err(|_| PyValueError::new_err("negative timeout"))
 }
-
-#[cfg(Py_3_11)]
-pub(crate) unsafe fn init_buffer(
-    view: *mut pyo3::ffi::Py_buffer,
-    flags: std::ffi::c_int,
-    buf: *mut u8,
-    len: usize,
-    readonly: bool,
-    owner: *mut pyo3::ffi::PyObject,
-) {
-    unsafe {
-        (*view).obj = owner;
-        (*view).buf = buf as *mut std::ffi::c_void;
-        (*view).len = len as isize;
-        (*view).readonly = readonly as std::ffi::c_int;
-        (*view).itemsize = 1;
-        (*view).format = if (flags & pyo3::ffi::PyBUF_FORMAT) != 0 {
-            static B: &std::ffi::CStr = pyo3::ffi::c_str!("B");
-            B.as_ptr().cast_mut()
-        } else {
-            std::ptr::null_mut()
-        };
-        (*view).ndim = 1;
-        (*view).shape = if (flags & pyo3::ffi::PyBUF_ND) != 0 {
-            &mut (*view).len
-        } else {
-            std::ptr::null_mut()
-        };
-        (*view).strides = if (flags & pyo3::ffi::PyBUF_STRIDES) != 0 {
-            &mut (*view).itemsize
-        } else {
-            std::ptr::null_mut()
-        };
-        (*view).suboffsets = std::ptr::null_mut();
-        (*view).internal = std::ptr::null_mut();
-    }
-}

src/shm.rs

@@ -11,7 +11,7 @@
 # Contributors:
 #   ZettaScale Zenoh Team, <[email protected]>
 #
-from collections.abc import Buffer, Callable
+from collections.abc import Callable
 from datetime import datetime, timedelta
 from enum import Enum, auto
 from pathlib import Path
@@ -1230,21 +1230,15 @@ class ZBytes:
     encouraged to use any data format of their choice like JSON, protobuf,
     flatbuffers, etc."""
 
-    def __new__(cls, bytes: bytearray | bytes | str | Buffer = None) -> Self: ...
+    def __new__(cls, bytes: bytearray | bytes | str | shm.ZShmMut = None) -> Self: ...
     def to_bytes(self) -> bytes: ...
     def to_string(self) -> str: ...
-    @overload
-    def __getitem__(self, item: int) -> int: ...
-    @overload
-    def __getitem__(self, item: slice) -> memoryview: ...
     def __bool__(self) -> bool: ...
     def __len__(self) -> int: ...
     def __bytes__(self) -> bytes: ...
     def __str__(self) -> str: ...
     def __eq__(self, other: Any) -> bool: ...
     def __hash__(self) -> int: ...
-    def __buffer__(self, flags: int) -> memoryview: ...
-    def __release_buffer__(self, view: memoryview) -> None: ...
 
 _IntoZBytes = Any
 

src/utils.rs

@@ -11,7 +11,6 @@
 # Contributors:
 #   ZettaScale Zenoh Team, <[email protected]>
 #
-from collections.abc import Buffer
 from typing import Self, final, overload
 
 @final
@@ -111,12 +110,6 @@ class ZShmMut:
     def __bytes__(self) -> bytes: ...
     def __str__(self) -> str: ...
     @overload
-    def __getitem__(self, item: int) -> int: ...
-    @overload
-    def __getitem__(self, item: slice) -> memoryview: ...
-    @overload
     def __setitem__(self, item: int, value: int): ...
     @overload
-    def __setitem__(self, item: slice, value: Buffer): ...
-    def __buffer__(self, flags: int) -> memoryview: ...
-    def __release_buffer__(self, view: memoryview) -> None: ...
+    def __setitem__(self, item: slice, value: bytes | bytearray): ...