Switch constructors for one-dimensional arrays to collect Rust-side data structures which then back the NumPy arrays as base objects.

Author: adamreichold

src/array.rs

@@ -952,18 +952,8 @@ impl<T: Element> PyArray<T, Ix1> {
     /// });
     /// ```
     pub fn from_slice<'py>(py: Python<'py>, slice: &[T]) -> &'py Self {
-        unsafe {
-            let array = PyArray::new(py, [slice.len()], false);
-            if T::IS_COPY {
-                ptr::copy_nonoverlapping(slice.as_ptr(), array.data(), slice.len());
-            } else {
-                let data_ptr = array.data();
-                for (i, item) in slice.iter().enumerate() {
-                    data_ptr.add(i).write(item.clone());
-                }
-            }
-            array
-        }
+        let data = slice.to_vec();
+        data.into_pyarray(py)
     }
 
     /// Construct one-dimension PyArray
@@ -996,20 +986,8 @@ impl<T: Element> PyArray<T, Ix1> {
     /// });
     /// ```
     pub fn from_exact_iter(py: Python<'_>, iter: impl ExactSizeIterator<Item = T>) -> &Self {
-        // NumPy will always zero-initialize object pointers,
-        // so the array can be dropped safely if the iterator panics.
-        unsafe {
-            let len = iter.len();
-            let array = Self::new(py, [len], false);
-            let mut idx = 0;
-            for item in iter {
-                assert!(idx < len);
-                array.uget_raw([idx]).write(item);
-                idx += 1;
-            }
-            assert!(idx == len);
-            array
-        }
+        let data = iter.collect::<Box<[_]>>();
+        data.into_pyarray(py)
     }
 
     /// Construct one-dimension PyArray from a type which implements
@@ -1028,29 +1006,8 @@ impl<T: Element> PyArray<T, Ix1> {
     /// });
     /// ```
     pub fn from_iter(py: Python<'_>, iter: impl IntoIterator<Item = T>) -> &Self {
-        let iter = iter.into_iter();
-        let (min_len, max_len) = iter.size_hint();
-        let mut capacity = max_len.unwrap_or_else(|| min_len.max(512 / mem::size_of::<T>()));
-        unsafe {
-            // NumPy will always zero-initialize object pointers,
-            // so the array can be dropped safely if the iterator panics.
-            let array = Self::new(py, [capacity], false);
-            let mut length = 0;
-            for (i, item) in iter.enumerate() {
-                length += 1;
-                if length > capacity {
-                    capacity *= 2;
-                    array
-                        .resize(capacity)
-                        .expect("PyArray::from_iter: Failed to allocate memory");
-                }
-                array.uget_raw([i]).write(item);
-            }
-            if capacity > length {
-                array.resize(length).unwrap()
-            }
-            array
-        }
+        let data = iter.into_iter().collect::<Vec<_>>();
+        data.into_pyarray(py)
     }
 
     /// Extends or trancates the length of 1 dimension PyArray.
@@ -1335,8 +1292,6 @@ impl<T: Element + AsPrimitive<f64>> PyArray<T, Ix1> {
 mod tests {
     use super::*;
 
-    use std::ops::Range;
-
     #[test]
     fn test_get_unchecked() {
         pyo3::Python::with_gil(|py| {
@@ -1366,36 +1321,4 @@ mod tests {
             py_run!(py, arr, "assert arr.dtype.hasobject");
         });
     }
-
-    struct InsincereIterator(Range<usize>, usize);
-
-    impl Iterator for InsincereIterator {
-        type Item = usize;
-
-        fn next(&mut self) -> Option<Self::Item> {
-            self.0.next()
-        }
-    }
-
-    impl ExactSizeIterator for InsincereIterator {
-        fn len(&self) -> usize {
-            self.1
-        }
-    }
-
-    #[test]
-    #[should_panic]
-    fn from_exact_iter_too_short() {
-        Python::with_gil(|py| {
-            PyArray::from_exact_iter(py, InsincereIterator(0..3, 5));
-        });
-    }
-
-    #[test]
-    #[should_panic]
-    fn from_exact_iter_too_long() {
-        Python::with_gil(|py| {
-            PyArray::from_exact_iter(py, InsincereIterator(0..5, 3));
-        });
-    }
 }

tests/to_py.rs

@@ -62,6 +62,18 @@ fn long_iter_to_pyarray() {
     });
 }
 
+#[test]
+fn exact_iter_to_pyarray() {
+    Python::with_gil(|py| {
+        let arr = PyArray::from_exact_iter(py, 0_u32..512);
+
+        assert_eq!(
+            arr.readonly().as_slice().unwrap(),
+            (0_u32..512).collect::<Vec<_>>(),
+        );
+    });
+}
+
 #[test]
 fn from_small_array() {
     macro_rules! small_array_test {