Merge pull request #510 from light-curve/fix-casting-exceptions

Fix error messages for invalid inputs

Author: hombit

light-curve/src/np_array.rs

@@ -1,7 +1,7 @@
 use crate::errors::{Exception, Res};
 
 use numpy::prelude::*;
-use numpy::{Element, PyArray1, PyReadonlyArray1};
+use numpy::{Element, PyArray1, PyReadonlyArray1, PyUntypedArray, PyUntypedArrayMethods};
 use pyo3::prelude::*;
 
 pub(crate) type Arr<'a, T> = PyReadonlyArray1<'a, T>;
@@ -22,6 +22,30 @@ impl DType for f64 {
     }
 }
 
+pub(crate) fn unknown_type_exception(name: &str, obj: Bound<PyAny>) -> Exception {
+    let message = if let Ok(arr) = obj.downcast::<PyUntypedArray>() {
+        let ndim = arr.ndim();
+        if ndim != 1 {
+            format!("'{name}' is a {ndim}-d array, only 1-d arrays are supported.")
+        } else {
+            let dtype = match arr.dtype().str() {
+                Ok(s) => s,
+                Err(err) => return err.into(),
+            };
+            format!("'{name}' has dtype {dtype}, but only float32 and float64 are supported.")
+        }
+    } else {
+        let tp = match obj.get_type().name() {
+            Ok(s) => s,
+            Err(err) => return err.into(),
+        };
+        format!(
+            "'{name}' has type '{tp}', float32 or float64 1-d numpy array was supported. Try to cast with np.asarray."
+        )
+    };
+    Exception::TypeError(message)
+}
+
 pub(crate) fn extract_matched_array<'py, T>(
     y_name: &'static str,
     y: Bound<'py, PyAny>,
@@ -39,43 +63,37 @@ where
                 Ok(y)
             } else {
                 Err(Exception::ValueError(format!(
-                    "Mismatched length ({}: {}, {}: {})",
-                    y_name,
-                    y.len(),
+                    "Mismatched lengths: '{}': {}, '{}': {}",
                     x_name,
                     x.len(),
+                    y_name,
+                    y.len(),
                 )))
             }
         } else {
             Ok(y)
         }
     } else {
-        let y_type = y
-            .get_type()
-            .name()
-            .map(|name| {
-                if name == "ndarray" {
-                    format!(
-                        "ndarray[{}]",
-                        y.getattr("dtype")
-                            .map(|dtype| dtype
-                                .getattr("name")
-                                .map(|p| p.to_string())
-                                .unwrap_or("unknown".into()))
-                            .unwrap_or("unknown".into())
-                    )
-                } else {
-                    name.to_string()
-                }
-            })
-            .unwrap_or("unknown".into());
-        Err(Exception::TypeError(format!(
-            "Mismatched types ({}: np.ndarray[{}], {}: {})",
-            x_name,
-            T::dtype_name(),
-            y_name,
-            y_type
-        )))
+        let error_message = if let Ok(y_arr) = y.downcast::<PyUntypedArray>() {
+            if y_arr.ndim() != 1 {
+                format!(
+                    "'{}' is a {}-d array, only 1-d arrays are supported.",
+                    y_name,
+                    y_arr.ndim()
+                )
+            } else {
+                format!(
+                    "Mismatched dtypes: '{}': {}, '{}': {}",
+                    x_name,
+                    x.dtype().str()?,
+                    y_name,
+                    y_arr.dtype().str()?
+                )
+            }
+        } else {
+            format!("'{y_name}' must be a numpy array of the same shape and dtype as '{x_name}', '{x_name}' has type 'np.ndarray[{x_dtype}]', '{y_name}' has type '{y_type}')", y_type=y.get_type().name()?, x_dtype=T::dtype_name())
+        };
+        Err(Exception::TypeError(error_message))
     }
 }
 
@@ -102,7 +120,7 @@ macro_rules! dtype_dispatch {
             let f64 = $f64;
             f64(x64)
         } else {
-            Err(crate::errors::Exception::TypeError("Unsupported dtype".into()).into())
+            Err(crate::np_array::unknown_type_exception(stringify!($first_arg), $first_arg.clone()))
         }
     }};
     ($f32:expr, $f64:expr, $first_arg:expr $(,$eq:tt $arg:expr)+ $(,)?) => {{
@@ -116,7 +134,7 @@ macro_rules! dtype_dispatch {
             let f64 = $f64;
             f64(x64.clone(), $(crate::np_array::extract_matched_array(stringify!($arg), $arg, x_name, &x64, _distinguish_eq_symbol!($eq))?,)*)
         } else {
-            Err(crate::errors::Exception::TypeError("Unsupported dtype".into()).into())
+            Err(crate::np_array::unknown_type_exception(stringify!($first_arg), $first_arg.clone()))
         }
     }};
 }

light-curve/tests/light_curve_ext/test_feature.py

@@ -352,3 +352,26 @@ def test_json_deserialization():
     from_json = lc.feature_from_json(json)
     assert isinstance(from_json, lc._FeatureEvaluator)
     from_json(*gen_lc(128))
+
+
+def test_raises_for_wrong_inputs():
+    fe = lc.Amplitude()
+
+    # First argument
+    with pytest.raises(TypeError, match="'t' has type 'list'"):
+        fe([1.0, 2.0, 3.0], [1.0, 2.0, 3.0])
+    with pytest.raises(TypeError, match="'t' is a 2-d array"):
+        fe(np.array([[1.0, 2.0, 3.0]]), np.array([1.0, 2.0, 3.0]))
+    with pytest.raises(TypeError, match="'t' has dtype int64"):
+        fe(np.array([1, 2, 3], dtype=np.int64), np.array([[1.0, 2.0, 3.0]]))
+
+    # Second and third arguments
+    t = np.arange(10, dtype=np.float64)
+    with pytest.raises(ValueError, match="Mismatched lengths:"):
+        fe(t, np.arange(11, dtype=np.float64))
+    with pytest.raises(TypeError, match="'m' must be a numpy array"):
+        fe(t, list(t))
+    with pytest.raises(TypeError, match="'sigma' is a 0-d array"):
+        fe(t, t, np.array(1.0))
+    with pytest.raises(TypeError, match="Mismatched dtypes:"):
+        fe(t, t.astype(np.float32))