Add cast=False for some dmdt methods

Author: hombit

light-curve/src/dmdt.rs

@@ -1142,21 +1142,27 @@ impl DmDt {
     ///     Time moments, must be sorted
     /// sorted : bool or None, optional
     ///     `True` guarantees that `t` is sorted
+    /// cast : bool
+    ///     If `False` allow np.ndarray input only, `True` allows casting.
+    ///     Casting provides more flexibility with input types at the cost of
+    //      performance.
     ///
     /// Returns
     /// 1d-array of float
     ///
-    #[pyo3(signature=(t, *, sorted=None))]
+    #[pyo3(signature=(t, *, sorted=None, cast=false))]
     fn count_dt<'py>(
         &self,
         py: Python<'py>,
         t: Bound<'py, PyAny>,
         sorted: Option<bool>,
+        cast: bool,
     ) -> Res<Bound<'py, PyUntypedArray>> {
         dtype_dispatch!(
             |t| self.dmdt_f32.py_count_dt(py, t, sorted),
             |t| self.dmdt_f64.py_count_dt(py, t, sorted),
-            t
+            t;
+            cast=cast
         )
     }
 
@@ -1203,24 +1209,30 @@ impl DmDt {
     ///     Magnitudes
     /// sorted : bool or None, optional
     ///     `True` guarantees that the light curve is sorted
+    /// cast : bool
+    ///     If `False` allow np.ndarray input only, `True` allows casting.
+    ///     Casting provides more flexibility with input types at the cost of
+    //      performance.
     ///
     /// Returns
     /// -------
     /// 2d-ndarray of float
     ///
-    #[pyo3(signature = (t, m, *, sorted=None))]
+    #[pyo3(signature = (t, m, *, sorted=None, cast=false))]
     fn points<'py>(
         &self,
         py: Python<'py>,
         t: Bound<'py, PyAny>,
         m: Bound<'py, PyAny>,
         sorted: Option<bool>,
+        cast: bool,
     ) -> Res<Bound<'py, PyUntypedArray>> {
         dtype_dispatch!(
             |t, m| self.dmdt_f32.py_points(py, t, m, sorted),
             |t, m| self.dmdt_f64.py_points(py, t, m, sorted),
             t,
-            =m
+            =m;
+            cast=cast
         )
     }
 
@@ -1372,26 +1384,31 @@ impl DmDt {
     ///     Uncertainties
     /// sorted : bool or None, optional
     ///     `True` guarantees that the light curve is sorted
-    ///
+    /// cast : bool
+    ///     If `False` allow np.ndarray input only, `True` allows casting.
+    ///     Casting provides more flexibility with input types at the cost of
+    //      performance.
     /// Returns
     /// -------
     /// 2d-array of float
     ///
-    #[pyo3(signature = (t, m, sigma, *, sorted=None))]
+    #[pyo3(signature = (t, m, sigma, *, sorted=None, cast=false))]
     fn gausses<'py>(
         &self,
         py: Python<'py>,
         t: Bound<'py, PyAny>,
         m: Bound<'py, PyAny>,
         sigma: Bound<'py, PyAny>,
         sorted: Option<bool>,
+        cast: bool,
     ) -> Res<Bound<'py, PyUntypedArray>> {
         dtype_dispatch!(
             |t, m, sigma| self.dmdt_f32.py_gausses(py, t, m, sigma, sorted),
             |t, m, sigma| self.dmdt_f64.py_gausses(py, t, m, sigma, sorted),
             t,
             =m,
-            =sigma
+            =sigma;
+            cast=cast
         )
     }
 

light-curve/src/features.rs

@@ -73,6 +73,8 @@ const METHOD_CALL_DOC: &str = r#"__call__(self, t, m, sigma=None, *, fill_value=
     cast : bool, optional
         Allows non-numpy input and casting of arrays to a common dtype.
         If `False`, inputs must be `np.ndarray` instances with matched dtypes.
+        Casting provides more flexibility with input types at the cost of
+        performance.
     Returns
     -------
     ndarray of np.float32 or np.float64

light-curve/src/np_array.rs

@@ -77,7 +77,7 @@ fn cast_fail_reason<const N: usize>(
     let fail_name = names.get(idx).expect("idx is out of bounds of names slice");
     let fail_obj = objects
         .get(idx)
-        .expect("idx is out of bounds of names slice");
+        .expect("idx is out of bounds of objects slice");
 
     let error_message = if let Ok(fail_arr) = fail_obj.downcast::<PyUntypedArray>() {
         if fail_arr.ndim() != 1 {
@@ -212,12 +212,13 @@ fn downcast_objects_no_cast<'py, const N: usize>(
             })
             .ok_or_else(|| {
                 let valid_f32_count = f32_arrays.iter().filter(|arr| arr.is_some()).count();
-                cast_fail_reason(
-                    usize::max(valid_f32_count, valid_f64_count),
-                    names,
-                    objects,
-                    false,
-                )
+                let max_count = usize::max(valid_f32_count, valid_f64_count);
+                if max_count == 0 {
+                    unknown_type_exception(names[0], objects[0])
+                } else {
+                    let idx = max_count - 1;
+                    cast_fail_reason(idx, names, objects, false)
+                }
             })?;
         Ok(GenericPyReadonlyArrays::F64(f64_arrays))
     }

light-curve/tests/light_curve_ext/test_dmdt.py

@@ -282,7 +282,14 @@ def test_dmdt_points_dtype(t_dtype, m_dtype):
     t = np.linspace(0, 1, 11, dtype=t_dtype)
     m = np.asarray(t, dtype=m_dtype)
     dmdt = DmDt.from_borders(min_lgdt=0, max_lgdt=1, max_abs_dm=1, lgdt_size=2, dm_size=2, norm=[])
-    values = dmdt.points(t, m)
+
+    if t_dtype is m_dtype:
+        context = nullcontext()
+    else:
+        context = pytest.raises(TypeError)
+    with context:
+        dmdt.points(t, m, cast=False)
+    values = dmdt.points(t, m, cast=True)
     assert values.dtype == np.result_type(t, m)
 
 
@@ -292,7 +299,14 @@ def test_dmdt_gausses_dtype(t_dtype, m_dtype, sigma_dtype):
     m = np.asarray(t, dtype=m_dtype)
     sigma = np.asarray(t, dtype=sigma_dtype)
     dmdt = DmDt.from_borders(min_lgdt=0, max_lgdt=1, max_abs_dm=1, lgdt_size=2, dm_size=2, norm=[])
-    values = dmdt.gausses(t, m, sigma)
+
+    if t_dtype is m_dtype is sigma_dtype:
+        context = nullcontext()
+    else:
+        context = pytest.raises(TypeError)
+    with context:
+        dmdt.gausses(t, m, sigma, cast=False)
+    values = dmdt.gausses(t, m, sigma, cast=True)
     assert values.dtype == np.result_type(t, m, sigma)
 
 

light-curve/tests/light_curve_ext/test_feature.py

@@ -364,6 +364,10 @@ def test_raises_for_wrong_inputs():
         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 <U1"):
         fe(np.array(["a", "b", "c"]), np.array([1.0, 2.0, 3.0]))
+    with pytest.raises(TypeError, match="'t' has type 'list'"):
+        fe([1.0, 2.0, 3.0], [1.0, 2.0, 3.0], cast=False)
+    # No failure of the last test with cast=True
+    _ = fe([1.0, 2.0, 3.0], [1.0, 2.0, 3.0], cast=True)
 
     # Second and third arguments
     t = np.arange(10, dtype=np.float64)
@@ -375,3 +379,7 @@ def test_raises_for_wrong_inputs():
         fe(t, t, np.array(1.0))
     with pytest.raises(TypeError, match="Mismatched dtypes:"):
         fe(t, t.astype(str) + "x")
+    with pytest.raises(TypeError, match="Mismatched dtypes:"):
+        fe(t, t.astype(np.float32), cast=False)
+    # No failure of the last test with cast=True
+    _ = fe(t, t.astype(np.float32), cast=True)