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

The base way to construct a PyArray containing objects in a strongly typed
manner is to crate a ndarray::Array<Py<T>, D> instead of converting it into a
PyArray without copying using this method.

Author: adamreichold

src/array.rs

@@ -629,23 +629,25 @@ impl<T: Element, D: Dimension> PyArray<T, D> {
         }
     }
 
-    /// Construct PyArray from
-    /// [`ndarray::Array`](https://docs.rs/ndarray/latest/ndarray/type.Array.html).
+    /// Constructs a `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 the internal [`Vec`] of the `ndarray::Array` as the base object of the 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.
@@ -858,6 +860,51 @@ impl<T: Element, D: Dimension> PyArray<T, D> {
     }
 }
 
+impl<D: Dimension> PyArray<PyObject, D> {
+    /// Constructs a `PyArray` containing objects from [`ndarray::Array`]
+    ///
+    /// This method uses the internal [`Vec`] of the `ndarray::Array` as the base object the 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>(py: Python<'py>, arr: Array<Py<T>, D>) -> &'py Self
+    where
+        Py<T>: ToPyObject,
+    {
+        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 {
 /// eliminated in the resulting NumPy array.
 /// In other words, objects are always treated as `Py<PyAny>` (a.k.a. `PyObject`) by Python code,
 /// and only `Py<PyAny>` can be stored in a type safe manner.
+///
+/// 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 {