Do not assume trivally copyable types for Element impls using DataType::Object.

Author: adamreichold

src/array.rs

@@ -10,7 +10,7 @@ use std::{cell::Cell, mem, os::raw::c_int, ptr, slice};
 use std::{iter::ExactSizeIterator, marker::PhantomData};
 
 use crate::convert::{IntoPyArray, NpyIndex, ToNpyDims, ToPyArray};
-use crate::dtype::Element;
+use crate::dtype::{DataType, Element};
 use crate::error::{FromVecError, NotContiguousError, ShapeError};
 use crate::slice_box::SliceBox;
 
@@ -731,8 +731,17 @@ impl<T: Element> PyArray<T, Ix1> {
     /// ```
     pub fn from_slice<'py>(py: Python<'py>, slice: &[T]) -> &'py Self {
         let array = PyArray::new(py, [slice.len()], false);
-        unsafe {
-            array.copy_ptr(slice.as_ptr(), slice.len());
+        if T::DATA_TYPE != DataType::Object {
+            unsafe {
+                array.copy_ptr(slice.as_ptr(), slice.len());
+            }
+        } else {
+            unsafe {
+                let data_ptr = array.data();
+                for (i, item) in slice.iter().enumerate() {
+                    data_ptr.add(i).write(item.clone());
+                }
+            }
         }
         array
     }

src/convert.rs

@@ -7,7 +7,7 @@ use std::{mem, os::raw::c_int};
 
 use crate::{
     npyffi::{self, npy_intp},
-    Element, PyArray,
+    DataType, Element, PyArray,
 };
 
 /// Covnersion trait from some rust types to `PyArray`.
@@ -130,25 +130,29 @@ where
     type Dim = D;
     fn to_pyarray<'py>(&self, py: Python<'py>) -> &'py PyArray<Self::Item, Self::Dim> {
         let len = self.len();
-        if let Some(order) = self.order() {
-            // if the array is contiguous, copy it by `copy_ptr`.
-            let strides = self.npy_strides();
-            unsafe {
-                let array = PyArray::new_(py, self.raw_dim(), strides.as_ptr(), order.to_flag());
-                array.copy_ptr(self.as_ptr(), len);
-                array
+        match self.order() {
+            Some(order) if A::DATA_TYPE != DataType::Object => {
+                // if the array is contiguous, copy it by `copy_ptr`.
+                let strides = self.npy_strides();
+                unsafe {
+                    let array =
+                        PyArray::new_(py, self.raw_dim(), strides.as_ptr(), order.to_flag());
+                    array.copy_ptr(self.as_ptr(), len);
+                    array
+                }
             }
-        } else {
-            // if the array is not contiguous, copy all elements by `ArrayBase::iter`.
-            let dim = self.raw_dim();
-            let strides = NpyStrides::from_dim(&dim, mem::size_of::<A>());
-            unsafe {
-                let array = PyArray::<A, _>::new_(py, dim, strides.as_ptr(), 0);
-                let data_ptr = array.data();
-                for (i, item) in self.iter().enumerate() {
-                    data_ptr.add(i).write(item.clone());
+            _ => {
+                // if the array is not contiguous, copy all elements by `ArrayBase::iter`.
+                let dim = self.raw_dim();
+                let strides = NpyStrides::from_dim(&dim, mem::size_of::<A>());
+                unsafe {
+                    let array = PyArray::<A, _>::new_(py, dim, strides.as_ptr(), 0);
+                    let data_ptr = array.data();
+                    for (i, item) in self.iter().enumerate() {
+                        data_ptr.add(i).write(item.clone());
+                    }
+                    array
                 }
-                array
             }
         }
     }