feat: more helpful error messages for plugin panics

Author: Travis Hammond

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "polars-list-utils"
-version = "0.10.0"
+version = "0.10.1"
 edition = "2024"
 
 [lib]

Cargo.toml

@@ -31,21 +31,21 @@ fn expr_aggregate_list_col_elementwise(
     let ca = inputs[0].list()?;
 
     if ca.dtype() != &DataType::List(Box::new(DataType::Float64)) {
-        let msg = format!("Expected `List(Float64)`, got: {}", ca.dtype());
+        let msg = format!("(aggregate_list_col_elementwise): Expected `List(Float64)`, got: {}", ca.dtype());
         return Err(PolarsError::ComputeError(msg.into()));
     }
 
     if kwargs.list_size == 0 {
         return Err(PolarsError::ComputeError(
-            "list_size must be greater than 0".into(),
+            "(aggregate_list_col_elementwise): list_size must be greater than 0".into(),
         ));
     }
 
     let valid_aggregations = ["mean", "sum", "count"];
     if !valid_aggregations.contains(&kwargs.aggregation.as_str()) {
         return Err(PolarsError::ComputeError(
             format!(
-                "Invalid aggregation method provided: {}. Must be one of [{}]",
+                "(aggregate_list_col_elementwise): Invalid aggregation method provided: {}. Must be one of [{}]",
                 kwargs.aggregation,
                 valid_aggregations.join(", "),
             )
@@ -117,7 +117,7 @@ fn expr_aggregate_list_col_elementwise(
 
     if list_too_short {
         Err(PolarsError::ComputeError(
-            "One of the lists is shorter than the given list_size!".into(),
+            "(aggregate_list_col_elementwise): One of the lists is shorter than the given list_size!".into(),
         ))
     } else {
         Ok(Series::new(PlSmallStr::EMPTY, out))

src/agg.rs

@@ -55,7 +55,7 @@ fn expr_fft(
     let ca = inputs[0].list()?;
 
     if ca.dtype() != &DataType::List(Box::new(DataType::Float64)) {
-        let msg = format!("Expected `List(Float64)`, got: {}", ca.dtype());
+        let msg = format!("(apply_fft): Expected `List(Float64)`, got: {}", ca.dtype());
         return Err(PolarsError::ComputeError(msg.into()));
     }
 
@@ -152,15 +152,15 @@ fn expr_fft(
 
     if invalid_value_encountered {
         Err(PolarsError::ComputeError(
-            "Invalid value in the samples".into(),
+            "(apply_fft): Invalid value in the samples".into(),
         ))
     } else if not_a_power_of_two {
         Err(PolarsError::ComputeError(
-            "Length of the samples is not a power of two".into(),
+            "(apply_fft): Length of the samples is not a power of two".into(),
         ))
     } else if bandpass_error.is_some() {
         Err(PolarsError::ComputeError(
-            format!("{}", bandpass_error.unwrap()).into(),
+            format!("(apply_fft): {}", bandpass_error.unwrap()).into(),
         ))
     } else {
         Ok(out.into_series())

src/dsp.rs

@@ -39,12 +39,12 @@ fn expr_mean_of_range(
     let x = &inputs[1].list()?;
 
     if y.dtype() != &DataType::List(Box::new(DataType::Float64)) {
-        let msg = format!("Expected `List(Float64)`, got: {}", y.dtype());
+        let msg = format!("(mean_of_range): Expected `List(Float64)`, got: {}", y.dtype());
         return Err(PolarsError::ComputeError(msg.into()));
     }
 
     if x.dtype() != &DataType::List(Box::new(DataType::Float64)) {
-        let msg = format!("Expected `List(Float64)`, got: {}", x.dtype());
+        let msg = format!("(mean_of_range): Expected `List(Float64)`, got: {}", x.dtype());
         return Err(PolarsError::ComputeError(msg.into()));
     }
 

src/feat.rs

@@ -34,19 +34,19 @@ fn expr_operate_scalar_on_list(
     let scalar = inputs[1].f64()?;
 
     if list.dtype() != &DataType::List(Box::new(DataType::Float64)) {
-        let msg = format!("Expected `List(Float64)`, got: {}", list.dtype());
+        let msg = format!("(operate_scalar_on_list): Expected `List(Float64)`, got: {}", list.dtype());
         return Err(PolarsError::ComputeError(msg.into()));
     }
     if scalar.dtype() != &DataType::Float64 {
-        let msg = format!("Expected `Float64`, got: {}", scalar.dtype());
+        let msg = format!("(operate_scalar_on_list): Expected `Float64`, got: {}", scalar.dtype());
         return Err(PolarsError::ComputeError(msg.into()));
     }
 
     let valid_operations = ["div", "mul", "add", "sub"];
     if !valid_operations.contains(&kwargs.operation.as_str()) {
         return Err(PolarsError::ComputeError(
             format!(
-                "Invalid operation method provided: {}. Must be one of [{}]",
+                "(operate_scalar_on_list): Invalid operation method provided: {}. Must be one of [{}]",
                 kwargs.operation,
                 valid_operations.join(", "),
             )