Merge pull request #72 from kngwyu/err-refine

Refactor IntoPyErr

Author: kngwyu

README.md

@@ -45,7 +45,7 @@ numpy = "0.3"
 ``` rust
 extern crate numpy;
 extern crate pyo3;
-use numpy::{IntoPyResult, PyArray1, get_array_module};
+use numpy::{PyArray1, get_array_module};
 use pyo3::prelude::{ObjectProtocol, PyDict, PyResult, Python};
 
 fn main() -> Result<(), ()> {
@@ -65,7 +65,7 @@ fn main_<'py>(py: Python<'py>) -> PyResult<()> {
     let pyarray: &PyArray1<i32> = py
         .eval("np.array([1, 2, 3], dtype='int32')", Some(&dict), None)?
         .extract()?;
-    let slice = pyarray.as_slice().into_pyresult("Array Cast failed")?;
+    let slice = pyarray.as_slice()?;
     assert_eq!(slice, &[1, 2, 3]);
     Ok(())
 }
@@ -118,21 +118,24 @@ fn rust_ext(_py: Python, m: &PyModule) -> PyResult<()> {
         x: &PyArrayDyn<f64>,
         y: &PyArrayDyn<f64>,
     ) -> PyResult<PyArrayDyn<f64>> {
-        let x = x.as_array().into_pyresult("x must be f64 array")?;
-        let y = y.as_array().into_pyresult("y must be f64 array")?;
+        // you can convert numpy error into PyErr via ?
+        let x = x.as_array()?;
+        // you can also specify your error context, via closure
+        let y = y.as_array().into_pyresult_with(|| "y must be f64 array")?;
         Ok(axpy(a, x, y).to_pyarray(py).to_owned(py))
     }
 
     // wrapper of `mult`
     #[pyfn(m, "mult")]
     fn mult_py(_py: Python, a: f64, x: &PyArrayDyn<f64>) -> PyResult<()> {
-        let x = x.as_array_mut().into_pyresult("x must be f64 array")?;
+        let x = x.as_array_mut()?;
         mult(a, x);
         Ok(())
     }
 
     Ok(())
 }
+
 ```
 
 Contribution

example/extensions/src/lib.rs

@@ -26,15 +26,17 @@ fn rust_ext(_py: Python, m: &PyModule) -> PyResult<()> {
         x: &PyArrayDyn<f64>,
         y: &PyArrayDyn<f64>,
     ) -> PyResult<PyArrayDyn<f64>> {
-        let x = x.as_array().into_pyresult("x must be f64 array")?;
-        let y = y.as_array().into_pyresult("y must be f64 array")?;
+        // you can convert numpy error into PyErr via ?
+        let x = x.as_array()?;
+         // you can also specify your error context, via closure
+        let y = y.as_array().into_pyresult_with(|| "y must be f64 array")?;
         Ok(axpy(a, x, y).to_pyarray(py).to_owned(py))
     }
 
     // wrapper of `mult`
     #[pyfn(m, "mult")]
     fn mult_py(_py: Python, a: f64, x: &PyArrayDyn<f64>) -> PyResult<()> {
-        let x = x.as_array_mut().into_pyresult("x must be f64 array")?;
+        let x = x.as_array_mut()?;
         mult(a, x);
         Ok(())
     }

src/array.rs

@@ -10,7 +10,7 @@ use std::os::raw::c_int;
 use std::ptr;
 
 use convert::{NpyIndex, ToNpyDims};
-use error::{ErrorKind, IntoPyErr};
+use error::{ErrorKind, IntoPyResult};
 use types::{NpyDataType, TypeNum};
 
 /// A safe, static-typed interface for
@@ -130,7 +130,7 @@ impl<'a, T: TypeNum, D: Dimension> FromPyObject<'a> for &'a PyArray<T, D> {
         array
             .type_check()
             .map(|_| array)
-            .map_err(|err| err.into_pyerr("FromPyObject::extract typecheck failed"))
+            .into_pyresult_with(|| "FromPyObject::extract typecheck failed")
     }
 }
 

src/error.rs

@@ -7,19 +7,27 @@ use std::error;
 use std::fmt;
 use types::{NpyDataType, TypeNum};
 
-pub trait IntoPyErr {
-    fn into_pyerr(self, msg: &str) -> PyErr;
+pub trait IntoPyErr: Into<PyErr> {
+    fn into_pyerr(self) -> PyErr;
+    fn into_pyerr_with<D: fmt::Display>(self, impl FnOnce() -> D) -> PyErr;
 }
 
 pub trait IntoPyResult {
     type ValueType;
-    fn into_pyresult(self, msg: &str) -> PyResult<Self::ValueType>;
+    fn into_pyresult(self) -> PyResult<Self::ValueType>;
+    fn into_pyresult_with<D: fmt::Display>(self, impl FnOnce() -> D) -> PyResult<Self::ValueType>;
 }
 
 impl<T, E: IntoPyErr> IntoPyResult for Result<T, E> {
     type ValueType = T;
-    fn into_pyresult(self, msg: &str) -> PyResult<T> {
-        self.map_err(|e| e.into_pyerr(msg))
+    fn into_pyresult(self) -> PyResult<Self::ValueType> {
+        self.map_err(|e| e.into())
+    }
+    fn into_pyresult_with<D: fmt::Display>(
+        self,
+        msg: impl FnOnce() -> D,
+    ) -> PyResult<Self::ValueType> {
+        self.map_err(|e| e.into_pyerr_with(msg))
     }
 }
 
@@ -117,11 +125,24 @@ impl fmt::Display for ErrorKind {
 
 impl error::Error for ErrorKind {}
 
+impl From<ErrorKind> for PyErr {
+    fn from(err: ErrorKind) -> PyErr {
+        match err {
+            ErrorKind::PyToRust { .. } | ErrorKind::FromVec { .. } | ErrorKind::PyToPy(_) => {
+                PyErr::new::<exc::TypeError, _>(format!("{}", err))
+            }
+        }
+    }
+}
+
 impl IntoPyErr for ErrorKind {
-    fn into_pyerr(self, msg: &str) -> PyErr {
+    fn into_pyerr(self) -> PyErr {
+        Into::into(self)
+    }
+    fn into_pyerr_with<D: fmt::Display>(self, msg: impl FnOnce() -> D) -> PyErr {
         match self {
             ErrorKind::PyToRust { .. } | ErrorKind::FromVec { .. } | ErrorKind::PyToPy(_) => {
-                PyErr::new::<exc::TypeError, _>(format!("{}, msg: {}", self, msg))
+                PyErr::new::<exc::TypeError, _>(format!("{} msg: {}", self, msg()))
             }
         }
     }

src/lib.rs

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