Merge pull request #118 from kngwyu/err-fetch

Properly fetch errors in Python interpreter

Author: kngwyu

src/array.rs

@@ -813,7 +813,7 @@ impl<T: TypeNum> PyArray<T, Ix1> {
             )
         };
         if res.is_null() {
-            Err(ErrorKind::dims_cast(self, dims))
+            Err(ErrorKind::py(self.py()))
         } else {
             Ok(())
         }
@@ -936,7 +936,7 @@ impl<T: TypeNum, D> PyArray<T, D> {
         let other_ptr = other.as_array_ptr();
         let result = unsafe { PY_ARRAY_API.PyArray_CopyInto(other_ptr, self_ptr) };
         if result == -1 {
-            Err(ErrorKind::dtype_cast(self, U::npy_data_type()))
+            Err(ErrorKind::py(self.py()))
         } else {
             Ok(())
         }
@@ -965,7 +965,7 @@ impl<T: TypeNum, D> PyArray<T, D> {
             )
         };
         if ptr.is_null() {
-            Err(ErrorKind::dtype_cast(self, U::npy_data_type()))
+            Err(ErrorKind::py(self.py()))
         } else {
             Ok(unsafe { PyArray::<U, D>::from_owned_ptr(self.py(), ptr) })
         }
@@ -1018,7 +1018,7 @@ impl<T: TypeNum, D> PyArray<T, D> {
             )
         };
         if ptr.is_null() {
-            Err(ErrorKind::dims_cast(self, dims))
+            Err(ErrorKind::py(self.py()))
         } else {
             Ok(unsafe { PyArray::<T, D2>::from_owned_ptr(self.py(), ptr) })
         }

src/error.rs

@@ -3,7 +3,7 @@
 use crate::array::PyArray;
 use crate::convert::ToNpyDims;
 use crate::types::{NpyDataType, TypeNum};
-use pyo3::{exceptions as exc, PyErr, PyResult};
+use pyo3::{exceptions as exc, PyErr, PyResult, Python};
 use std::error;
 use std::fmt;
 
@@ -34,42 +34,6 @@ impl<T, E: IntoPyErr> IntoPyResult for Result<T, E> {
     }
 }
 
-/// Represents a shape and dtype of numpy array.
-///
-/// Only for error formatting.
-#[derive(Debug)]
-pub struct ArrayShape {
-    pub dims: Box<[usize]>,
-    pub dtype: NpyDataType,
-}
-
-impl ArrayShape {
-    fn boxed_dims(dims: &[usize]) -> Box<[usize]> {
-        dims.into_iter()
-            .map(|&x| x)
-            .collect::<Vec<_>>()
-            .into_boxed_slice()
-    }
-    fn from_array<T: TypeNum, D>(array: &PyArray<T, D>) -> Self {
-        ArrayShape {
-            dims: Self::boxed_dims(array.shape()),
-            dtype: T::npy_data_type(),
-        }
-    }
-    fn from_dims<T: TypeNum, D: ToNpyDims>(dims: D) -> Self {
-        ArrayShape {
-            dims: Self::boxed_dims(dims.slice()),
-            dtype: T::npy_data_type(),
-        }
-    }
-}
-
-impl fmt::Display for ArrayShape {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "dims={:?}, dtype={:?}", self.dims, self.dtype)
-    }
-}
-
 /// Represents a dimension and dtype of numpy array.
 ///
 /// Only for error formatting.
@@ -96,8 +60,8 @@ pub enum ErrorKind {
     PyToRust { from: ArrayDim, to: ArrayDim },
     /// Error for casting rust's `Vec` into numpy array.
     FromVec { dim1: usize, dim2: usize },
-    /// Error in numpy -> numpy data conversion
-    PyToPy(Box<(ArrayShape, ArrayShape)>),
+    /// Error occured in Python iterpreter
+    Python(PyErr),
     /// The array need to be contiguous to finish the opretion
     NotContiguous,
 }
@@ -120,18 +84,8 @@ impl ErrorKind {
             },
         }
     }
-    pub(crate) fn dtype_cast<T: TypeNum, D>(from: &PyArray<T, D>, to: NpyDataType) -> Self {
-        let from = ArrayShape::from_array(from);
-        let to = ArrayShape {
-            dims: from.dims.clone(),
-            dtype: to,
-        };
-        ErrorKind::PyToPy(Box::new((from, to)))
-    }
-    pub(crate) fn dims_cast<T: TypeNum, D>(from: &PyArray<T, D>, to_dim: impl ToNpyDims) -> Self {
-        let from = ArrayShape::from_array(from);
-        let to = ArrayShape::from_dims::<T, _>(to_dim);
-        ErrorKind::PyToPy(Box::new((from, to)))
+    pub(crate) fn py(py: Python<'_>) -> Self {
+        ErrorKind::Python(PyErr::fetch(py))
     }
 }
 
@@ -146,11 +100,7 @@ impl fmt::Display for ErrorKind {
                 "Cast failed: Vec To PyArray:\n expect all dim {} but {} was found",
                 dim1, dim2
             ),
-            ErrorKind::PyToPy(e) => write!(
-                f,
-                "Cast failed: from=ndarray({}), to=ndarray(dtype={})",
-                e.0, e.1,
-            ),
+            ErrorKind::Python(e) => write!(f, "Python error: {:?}", e),
             ErrorKind::NotContiguous => write!(f, "This array is not contiguous!"),
         }
     }
@@ -160,7 +110,10 @@ impl error::Error for ErrorKind {}
 
 impl From<ErrorKind> for PyErr {
     fn from(err: ErrorKind) -> PyErr {
-        PyErr::new::<exc::TypeError, _>(format!("{}", err))
+        match err {
+            ErrorKind::Python(e) => e,
+            _ => PyErr::new::<exc::TypeError, _>(format!("{}", err)),
+        }
     }
 }
 

src/lib.rs

@@ -48,7 +48,7 @@ pub use crate::array::{
     PyArrayDyn,
 };
 pub use crate::convert::{IntoPyArray, NpyIndex, ToNpyDims, ToPyArray};
-pub use crate::error::{ArrayShape, ErrorKind, IntoPyErr, IntoPyResult};
+pub use crate::error::{ErrorKind, IntoPyErr, IntoPyResult};
 pub use crate::npyffi::{PY_ARRAY_API, PY_UFUNC_API};
 pub use crate::types::{c32, c64, NpyDataType, TypeNum};
 pub use ndarray::{Ix1, Ix2, Ix3, Ix4, Ix5, Ix6, IxDyn};

tests/to_py.rs

@@ -68,7 +68,6 @@ macro_rules! small_array_test {
 small_array_test!(i8 u8 i16 u16 i32 u32 i64 u64 usize);
 
 #[test]
-#[ignore]
 fn usize_dtype() {
     let gil = pyo3::Python::acquire_gil();
     let py = gil.python();