Provide an efficient way to go from Array<Py<T>, D> to PyArray<PyObject, D>.

Author: adamreichold

src/array.rs

@@ -4,7 +4,7 @@ use ndarray::*;
 use num_traits::AsPrimitive;
 use pyo3::{
     ffi, prelude::*, pyobject_native_type_info, pyobject_native_type_named, type_object,
-    types::PyAny, AsPyPointer, PyDowncastError, PyNativeType, PyResult,
+    types::PyAny, AsPyPointer, PyClass, PyDowncastError, PyNativeType, PyResult,
 };
 use std::{
     cell::Cell,
@@ -637,23 +637,25 @@ impl<T: Element, D: Dimension> PyArray<T, D> {
         }
     }
 
-    /// Construct PyArray from
-    /// [`ndarray::Array`](https://docs.rs/ndarray/latest/ndarray/type.Array.html).
+    /// Construct PyArray from [`ndarray::Array`]
     ///
-    /// This method uses internal [`Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html)
-    /// of `ndarray::Array` as numpy array.
+    /// This method uses internal [`Vec`] of `ndarray::Array` as NumPy array.
     ///
     /// # Example
+    ///
     /// ```
-    /// # #[macro_use] extern crate ndarray;
+    /// use ndarray::array;
     /// use numpy::PyArray;
+    ///
     /// pyo3::Python::with_gil(|py| {
     ///     let pyarray = PyArray::from_owned_array(py, array![[1, 2], [3, 4]]);
     ///     assert_eq!(pyarray.readonly().as_array(), array![[1, 2], [3, 4]]);
     /// });
     /// ```
     pub fn from_owned_array<'py>(py: Python<'py>, arr: Array<T, D>) -> &'py Self {
-        IntoPyArray::into_pyarray(arr, py)
+        let (strides, dims) = (arr.npy_strides(), arr.raw_dim());
+        let data_ptr = arr.as_ptr();
+        unsafe { PyArray::from_raw_parts(py, dims, strides.as_ptr(), data_ptr, arr) }
     }
 
     /// Get the immutable reference of the specified element, with checking the passed index is valid.
@@ -850,6 +852,51 @@ impl<T: Element, D: Dimension> PyArray<T, D> {
     }
 }
 
+impl<D: Dimension> PyArray<PyObject, D> {
+    /// Construct PyArray containing objects from [`ndarray::Array`]
+    ///
+    /// This method uses internal [`Vec`] of `ndarray::Array` as NumPy array.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use ndarray::array;
+    /// use pyo3::{pyclass, Py, Python};
+    /// use numpy::PyArray;
+    ///
+    /// #[pyclass]
+    /// struct CustomElement {
+    ///     foo: i32,
+    ///     bar: f64,
+    /// }
+    ///
+    /// Python::with_gil(|py| {
+    ///     let array = array![
+    ///         Py::new(py, CustomElement {
+    ///             foo: 1,
+    ///             bar: 2.0,
+    ///         }).unwrap(),
+    ///         Py::new(py, CustomElement {
+    ///             foo: 3,
+    ///             bar: 4.0,
+    ///         }).unwrap(),
+    ///     ];
+    ///
+    ///     let pyarray = PyArray::from_owned_object_array(py, array);
+    ///
+    ///     assert!(pyarray.readonly().get(0).unwrap().as_ref(py).is_instance::<CustomElement>().unwrap());
+    /// });
+    /// ```
+    pub fn from_owned_object_array<'py, T: PyClass>(
+        py: Python<'py>,
+        arr: Array<Py<T>, D>,
+    ) -> &'py Self {
+        let (strides, dims) = (arr.npy_strides(), arr.raw_dim());
+        let data_ptr = arr.as_ptr() as *const PyObject;
+        unsafe { PyArray::from_raw_parts(py, dims, strides.as_ptr(), data_ptr, arr) }
+    }
+}
+
 impl<T: Copy + Element> PyArray<T, Ix0> {
     /// Get the element of zero-dimensional PyArray.
     ///

src/convert.rs

@@ -63,9 +63,7 @@ where
     type Item = A;
     type Dim = D;
     fn into_pyarray<'py>(self, py: Python<'py>) -> &'py PyArray<Self::Item, Self::Dim> {
-        let (strides, dims) = (self.npy_strides(), self.raw_dim());
-        let data_ptr = self.as_ptr();
-        unsafe { PyArray::from_raw_parts(py, dims, strides.as_ptr(), data_ptr, self) }
+        PyArray::from_owned_array(py, self)
     }
 }
 

src/dtype.rs

@@ -126,6 +126,8 @@ impl PyArrayDescr {
 /// as only the data type can be checked during downcasting, but not the dynamic type of each element stored in the array.
 /// This is not possible as the elements and hence their dynamic type could be changed later on via aliasing Python references to the array.
 /// Therefore, the only safe type to store in object arrays is `Py<PyAny>` also known as `PyObject`.
+///
+/// You can however create `ndarray::Array<Py<T>, D>` and turn that into a NumPy array safely and efficiently using [`from_owned_object_array`][crate::PyArray::from_owned_object_array].
 pub unsafe trait Element: Clone + Send {
     /// Flag that indicates whether this type is trivially copyable.
     ///

src/slice_container.rs

@@ -7,8 +7,6 @@ use pyo3::pyclass_slots::PyClassDummySlot;
 use pyo3::type_object::{LazyStaticType, PyTypeInfo};
 use pyo3::{ffi, types::PyAny, PyCell};
 
-use crate::dtype::Element;
-
 /// Utility type to safely store Box<[_]> or Vec<_> on the Python heap
 pub(crate) struct PySliceContainer {
     ptr: *mut u8,
@@ -69,7 +67,7 @@ impl<T: Send> From<Vec<T>> for PySliceContainer {
 
 impl<A, D> From<ArrayBase<OwnedRepr<A>, D>> for PySliceContainer
 where
-    A: Element,
+    A: Send,
     D: Dimension,
 {
     fn from(data: ArrayBase<OwnedRepr<A>, D>) -> Self {