Use a more specific name for the Owner type, i.e. PySliceContainer.

Author: adamreichold

src/array.rs

@@ -17,7 +17,7 @@ use std::{iter::ExactSizeIterator, marker::PhantomData};
 use crate::convert::{ArrayExt, IntoPyArray, NpyIndex, ToNpyDims, ToPyArray};
 use crate::dtype::{DataType, Element};
 use crate::error::{FromVecError, NotContiguousError, ShapeError};
-use crate::owner::Owner;
+use crate::slice_container::PySliceContainer;
 
 /// A safe, static-typed interface for
 /// [NumPy ndarray](https://numpy.org/doc/stable/reference/arrays.ndarray.html).
@@ -447,7 +447,7 @@ impl<T: Element, D: Dimension> PyArray<T, D> {
         dims: ID,
         strides: *const npy_intp,
         data_ptr: *const T,
-        owner: *mut PyAny,
+        container: *mut PyAny,
     ) -> &'py Self
     where
         ID: IntoDimension<Dim = D>,
@@ -467,36 +467,36 @@ impl<T: Element, D: Dimension> PyArray<T, D> {
 
         PY_ARRAY_API.PyArray_SetBaseObject(
             ptr as *mut npyffi::PyArrayObject,
-            owner as *mut ffi::PyObject,
+            container as *mut ffi::PyObject,
         );
 
         Self::from_owned_ptr(py, ptr)
     }
 
-    pub(crate) unsafe fn from_raw_parts<'py, ID, O>(
+    pub(crate) unsafe fn from_raw_parts<'py, ID, C>(
         py: Python<'py>,
         dims: ID,
         strides: *const npy_intp,
         data_ptr: *const T,
-        owner: O,
+        container: C,
     ) -> &'py Self
     where
         ID: IntoDimension<Dim = D>,
-        Owner: From<O>,
+        PySliceContainer: From<C>,
     {
-        let owner = pyo3::PyClassInitializer::from(Owner::from(owner))
+        let container = pyo3::PyClassInitializer::from(PySliceContainer::from(container))
             .create_cell(py)
             .expect("Object creation failed.");
 
-        Self::new_with_data(py, dims, strides, data_ptr, owner as *mut PyAny)
+        Self::new_with_data(py, dims, strides, data_ptr, container as *mut PyAny)
     }
 
-    /// Creates a NumPy array backed by `array` and ties its ownership to the Python object `owner`.
+    /// Creates a NumPy array backed by `array` and ties its ownership to the Python object `container`.
     ///
     /// # Safety
     ///
-    /// `owner` is set as a base object of the returned array which must not be dropped until `owner` is dropped.
-    /// Furthermore, `array` must not be reallocated from the time this method is called and until `owner` is dropped.
+    /// `container` is set as a base object of the returned array which must not be dropped until `container` is dropped.
+    /// Furthermore, `array` must not be reallocated from the time this method is called and until `container` is dropped.
     ///
     /// # Example
     ///
@@ -521,21 +521,26 @@ impl<T: Element, D: Dimension> PyArray<T, D> {
     ///     }
     /// }
     /// ```
-    pub unsafe fn borrow_from_array<'py, S>(array: &ArrayBase<S, D>, owner: &'py PyAny) -> &'py Self
+    pub unsafe fn borrow_from_array<'py, S>(
+        array: &ArrayBase<S, D>,
+        container: &'py PyAny,
+    ) -> &'py Self
     where
         S: Data<Elem = T>,
     {
         let (strides, dims) = (array.npy_strides(), array.raw_dim());
         let data_ptr = array.as_ptr();
 
-        mem::forget(owner.to_object(owner.py()));
+        let py = container.py();
+
+        mem::forget(container.to_object(py));
 
         Self::new_with_data(
-            owner.py(),
+            py,
             dims,
             strides.as_ptr(),
             data_ptr,
-            owner as *const PyAny as *mut PyAny,
+            container as *const PyAny as *mut PyAny,
         )
     }
 

src/lib.rs

@@ -41,8 +41,8 @@ mod dtype;
 mod error;
 pub mod npyffi;
 pub mod npyiter;
-mod owner;
 mod readonly;
+mod slice_container;
 mod sum_products;
 
 pub use ndarray;

src/owner.rs renamed to src/slice_container.rs

@@ -9,21 +9,24 @@ use pyo3::{ffi, types::PyAny, PyCell};
 
 use crate::dtype::Element;
 
-pub(crate) struct Owner {
+/// Utility type to safely store Box<[_]> or Vec<_> on the Python heap
+pub(crate) struct PySliceContainer {
     ptr: *mut u8,
     len: usize,
     cap: usize,
     drop: unsafe fn(*mut u8, usize, usize),
 }
 
-unsafe impl Send for Owner {}
+unsafe impl Send for PySliceContainer {}
 
-impl<T: Send> From<Box<[T]>> for Owner {
+impl<T: Send> From<Box<[T]>> for PySliceContainer {
     fn from(data: Box<[T]>) -> Self {
         unsafe fn drop_boxed_slice<T>(ptr: *mut u8, len: usize, _cap: usize) {
             let _ = Box::from_raw(slice::from_raw_parts_mut(ptr as *mut T, len) as *mut [T]);
         }
 
+        // FIXME(adamreichold): Use `Box::into_raw` when
+        // `*mut [T]::{as_mut_ptr, len}` become stable and compatible with out MSRV.
         let ptr = data.as_ptr() as *mut u8;
         let len = data.len();
         let cap = 0;
@@ -40,12 +43,14 @@ impl<T: Send> From<Box<[T]>> for Owner {
     }
 }
 
-impl<T: Send> From<Vec<T>> for Owner {
+impl<T: Send> From<Vec<T>> for PySliceContainer {
     fn from(data: Vec<T>) -> Self {
         unsafe fn drop_vec<T>(ptr: *mut u8, len: usize, cap: usize) {
             let _ = Vec::from_raw_parts(ptr as *mut T, len, cap);
         }
 
+        // FIXME(adamreichold): Use `Vec::into_raw_parts`
+        // when it becomes stable and compatible with our MSRV.
         let ptr = data.as_ptr() as *mut u8;
         let len = data.len();
         let cap = data.capacity();
@@ -62,7 +67,7 @@ impl<T: Send> From<Vec<T>> for Owner {
     }
 }
 
-impl<A, D> From<ArrayBase<OwnedRepr<A>, D>> for Owner
+impl<A, D> From<ArrayBase<OwnedRepr<A>, D>> for PySliceContainer
 where
     A: Element,
     D: Dimension,
@@ -72,32 +77,32 @@ where
     }
 }
 
-impl Drop for Owner {
+impl Drop for PySliceContainer {
     fn drop(&mut self) {
         unsafe {
             (self.drop)(self.ptr, self.len, self.cap);
         }
     }
 }
 
-impl PyClass for Owner {
+impl PyClass for PySliceContainer {
     type Dict = PyClassDummySlot;
     type WeakRef = PyClassDummySlot;
     type BaseNativeType = PyAny;
 }
 
-impl PyClassImpl for Owner {
-    const DOC: &'static str = "Memory store for a PyArray backed by a Rust type \0";
+impl PyClassImpl for PySliceContainer {
+    const DOC: &'static str = "Memory store for a PyArray backed by a Box<[_]> or a Vec<_> \0";
 
     type BaseType = PyAny;
     type Layout = PyCell<Self>;
     type ThreadChecker = ThreadCheckerStub<Self>;
 }
 
-unsafe impl PyTypeInfo for Owner {
+unsafe impl PyTypeInfo for PySliceContainer {
     type AsRefTarget = PyCell<Self>;
 
-    const NAME: &'static str = "Owner";
+    const NAME: &'static str = "PySliceContainer";
     const MODULE: Option<&'static str> = Some("_rust_numpy");
 
     #[inline]