polars-df 0.10.0 → 0.11.0

data/ext/polars/src/lazyframe/mod.rs

@@ -48,7 +48,7 @@ impl RbLazyFrame {
         // in this scope
         let json = unsafe { std::mem::transmute::<&'_ str, &'static str>(json.as_str()) };
 
-        let lp = serde_json::from_str::<LogicalPlan>(json)
+        let lp = serde_json::from_str::<DslPlan>(json)
             .map_err(|err| RbValueError::new_err(format!("{:?}", err)))?;
         Ok(LazyFrame::from(lp).into())
     }
@@ -63,7 +63,10 @@ impl RbLazyFrame {
         row_index: Option<(String, IdxSize)>,
     ) -> RbResult<Self> {
         let batch_size = batch_size.map(|v| v.0);
-        let row_index = row_index.map(|(name, offset)| RowIndex { name, offset });
+        let row_index = row_index.map(|(name, offset)| RowIndex {
+            name: Arc::from(name.as_str()),
+            offset,
+        });
 
         let lf = LazyJsonLineReader::new(path)
             .with_infer_schema_length(infer_schema_length)
@@ -107,7 +110,10 @@ impl RbLazyFrame {
         let quote_char = quote_char.map(|s| s.as_bytes()[0]);
         let separator = separator.as_bytes()[0];
         let eol_char = eol_char.as_bytes()[0];
-        let row_index = row_index.map(|(name, offset)| RowIndex { name, offset });
+        let row_index = row_index.map(|(name, offset)| RowIndex {
+            name: Arc::from(name.as_str()),
+            offset,
+        });
 
         let overwrite_dtype = overwrite_dtype.map(|overwrite_dtype| {
             overwrite_dtype
@@ -119,17 +125,17 @@ impl RbLazyFrame {
         let r = LazyCsvReader::new(path)
             .with_infer_schema_length(infer_schema_length)
             .with_separator(separator)
-            .has_header(has_header)
+            .with_has_header(has_header)
             .with_ignore_errors(ignore_errors)
             .with_skip_rows(skip_rows)
             .with_n_rows(n_rows)
             .with_cache(cache)
-            .with_dtype_overwrite(overwrite_dtype.as_ref())
+            .with_dtype_overwrite(overwrite_dtype.map(Arc::new))
             // TODO add with_schema
-            .low_memory(low_memory)
+            .with_low_memory(low_memory)
             .with_comment_prefix(comment_prefix.as_deref())
             .with_quote_char(quote_char)
-            .with_end_of_line_char(eol_char)
+            .with_eol_char(eol_char)
             .with_rechunk(rechunk)
             .with_skip_rows_after_header(skip_rows_after_header)
             .with_encoding(encoding.0)
@@ -137,7 +143,7 @@ impl RbLazyFrame {
             .with_try_parse_dates(try_parse_dates)
             .with_null_values(null_values)
             // TODO add with_missing_is_null
-            .truncate_ragged_lines(truncate_ragged_lines);
+            .with_truncate_ragged_lines(truncate_ragged_lines);
 
         if let Some(_lambda) = with_schema_modify {
             todo!();
@@ -159,6 +165,7 @@ impl RbLazyFrame {
         use_statistics: bool,
         hive_partitioning: bool,
         hive_schema: Option<Wrap<Schema>>,
+        glob: bool,
     ) -> RbResult<Self> {
         let parallel = parallel.0;
         let hive_schema = hive_schema.map(|s| Arc::new(s.0));
@@ -171,7 +178,10 @@ impl RbLazyFrame {
                 .ok_or_else(|| RbValueError::new_err("expected a path argument".to_string()))?
         };
 
-        let row_index = row_index.map(|(name, offset)| RowIndex { name, offset });
+        let row_index = row_index.map(|(name, offset)| RowIndex {
+            name: Arc::from(name.as_str()),
+            offset,
+        });
         let hive_options = HiveOptions {
             enabled: hive_partitioning,
             schema: hive_schema,
@@ -187,6 +197,7 @@ impl RbLazyFrame {
             cloud_options: None,
             use_statistics,
             hive_options,
+            glob,
         };
 
         let lf = if path.is_some() {
@@ -206,7 +217,11 @@ impl RbLazyFrame {
         row_index: Option<(String, IdxSize)>,
         memory_map: bool,
     ) -> RbResult<Self> {
-        let row_index = row_index.map(|(name, offset)| RowIndex { name, offset });
+        let row_index = row_index.map(|(name, offset)| RowIndex {
+            name: Arc::from(name.as_str()),
+            offset,
+        });
+
         let args = ScanArgsIpc {
             n_rows,
             cache,
@@ -226,8 +241,11 @@ impl RbLazyFrame {
         Ok(())
     }
 
-    pub fn describe_plan(&self) -> String {
-        self.ldf.describe_plan()
+    pub fn describe_plan(&self) -> RbResult<String> {
+        self.ldf
+            .describe_plan()
+            .map_err(RbPolarsErr::from)
+            .map_err(Into::into)
     }
 
     pub fn describe_optimized_plan(&self) -> RbResult<String> {
@@ -641,58 +659,56 @@ impl RbLazyFrame {
         ldf.fill_nan(fill_value.inner.clone()).into()
     }
 
-    pub fn min(&self) -> RbResult<Self> {
+    pub fn min(&self) -> Self {
         let ldf = self.ldf.clone();
-        let out = ldf.min().map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+        let out = ldf.min();
+        out.into()
     }
 
-    pub fn max(&self) -> RbResult<Self> {
+    pub fn max(&self) -> Self {
         let ldf = self.ldf.clone();
-        let out = ldf.max().map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+        let out = ldf.max();
+        out.into()
     }
 
-    pub fn sum(&self) -> RbResult<Self> {
+    pub fn sum(&self) -> Self {
         let ldf = self.ldf.clone();
-        let out = ldf.sum().map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+        let out = ldf.sum();
+        out.into()
     }
 
-    pub fn mean(&self) -> RbResult<Self> {
+    pub fn mean(&self) -> Self {
         let ldf = self.ldf.clone();
-        let out = ldf.mean().map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+        let out = ldf.mean();
+        out.into()
     }
 
-    pub fn std(&self, ddof: u8) -> RbResult<Self> {
+    pub fn std(&self, ddof: u8) -> Self {
         let ldf = self.ldf.clone();
-        let out = ldf.std(ddof).map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+        let out = ldf.std(ddof);
+        out.into()
     }
 
-    pub fn var(&self, ddof: u8) -> RbResult<Self> {
+    pub fn var(&self, ddof: u8) -> Self {
         let ldf = self.ldf.clone();
-        let out = ldf.var(ddof).map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+        let out = ldf.var(ddof);
+        out.into()
     }
 
-    pub fn median(&self) -> RbResult<Self> {
+    pub fn median(&self) -> Self {
         let ldf = self.ldf.clone();
-        let out = ldf.median().map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+        let out = ldf.median();
+        out.into()
     }
 
     pub fn quantile(
         &self,
         quantile: &RbExpr,
         interpolation: Wrap<QuantileInterpolOptions>,
-    ) -> RbResult<Self> {
+    ) -> Self {
         let ldf = self.ldf.clone();
-        let out = ldf
-            .quantile(quantile.inner.clone(), interpolation.0)
-            .map_err(RbPolarsErr::from)?;
-        Ok(out.into())
+        let out = ldf.quantile(quantile.inner.clone(), interpolation.0);
+        out.into()
     }
 
     pub fn explode(&self, column: RArray) -> RbResult<Self> {

data/ext/polars/src/lib.rs

@@ -5,6 +5,7 @@ mod error;
 mod expr;
 mod file;
 mod functions;
+mod interop;
 mod lazyframe;
 mod lazygroupby;
 mod map;
@@ -59,18 +60,23 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("read_csv", function!(RbDataFrame::read_csv, -1))?;
     class.define_singleton_method("read_parquet", function!(RbDataFrame::read_parquet, 9))?;
     class.define_singleton_method("read_ipc", function!(RbDataFrame::read_ipc, 6))?;
+    class.define_singleton_method("read_ipc_stream", function!(RbDataFrame::read_ipc_stream, 6))?;
     class.define_singleton_method("read_avro", function!(RbDataFrame::read_avro, 4))?;
-    class.define_singleton_method("read_rows", function!(RbDataFrame::read_rows, 3))?;
-    class.define_singleton_method("read_hashes", function!(RbDataFrame::read_hashes, 4))?;
-    class.define_singleton_method("read_hash", function!(RbDataFrame::read_hash, 1))?;
+    class.define_singleton_method("from_rows", function!(RbDataFrame::from_rows, 3))?;
+    class.define_singleton_method("from_hashes", function!(RbDataFrame::from_hashes, 5))?;
     class.define_singleton_method("read_json", function!(RbDataFrame::read_json, 1))?;
     class.define_singleton_method("read_ndjson", function!(RbDataFrame::read_ndjson, 1))?;
     class.define_method("estimated_size", method!(RbDataFrame::estimated_size, 0))?;
+    class.define_method("dtype_strings", method!(RbDataFrame::dtype_strings, 0))?;
     class.define_method("write_avro", method!(RbDataFrame::write_avro, 2))?;
     class.define_method("write_json", method!(RbDataFrame::write_json, 3))?;
     class.define_method("write_ndjson", method!(RbDataFrame::write_ndjson, 1))?;
     class.define_method("write_csv", method!(RbDataFrame::write_csv, 10))?;
     class.define_method("write_ipc", method!(RbDataFrame::write_ipc, 2))?;
+    class.define_method(
+        "write_ipc_stream",
+        method!(RbDataFrame::write_ipc_stream, 2),
+    )?;
     class.define_method("row_tuple", method!(RbDataFrame::row_tuple, 1))?;
     class.define_method("row_tuples", method!(RbDataFrame::row_tuples, 0))?;
     class.define_method("to_numo", method!(RbDataFrame::to_numo, 0))?;
@@ -88,7 +94,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sample_n", method!(RbDataFrame::sample_n, 4))?;
     class.define_method("sample_frac", method!(RbDataFrame::sample_frac, 4))?;
     class.define_method("rechunk", method!(RbDataFrame::rechunk, 0))?;
-    class.define_method("to_s", method!(RbDataFrame::to_s, 0))?;
+    class.define_method("to_s", method!(RbDataFrame::as_str, 0))?;
     class.define_method("get_columns", method!(RbDataFrame::get_columns, 0))?;
     class.define_method("columns", method!(RbDataFrame::columns, 0))?;
     class.define_method(
@@ -106,8 +112,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("vstack_mut", method!(RbDataFrame::vstack_mut, 1))?;
     class.define_method("vstack", method!(RbDataFrame::vstack, 1))?;
     class.define_method("drop_in_place", method!(RbDataFrame::drop_in_place, 1))?;
-    class.define_method("drop_nulls", method!(RbDataFrame::drop_nulls, 1))?;
-    class.define_method("drop", method!(RbDataFrame::drop, 1))?;
     class.define_method("select_at_idx", method!(RbDataFrame::select_at_idx, 1))?;
     class.define_method(
         "get_column_index",
@@ -115,7 +119,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_method("get_column", method!(RbDataFrame::get_column, 1))?;
     class.define_method("select", method!(RbDataFrame::select, 1))?;
-    class.define_method("take", method!(RbDataFrame::take, 1))?;
+    class.define_method("take", method!(RbDataFrame::gather, 1))?;
     class.define_method(
         "take_with_series",
         method!(RbDataFrame::take_with_series, 1),
@@ -134,7 +138,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("melt", method!(RbDataFrame::melt, 4))?;
     class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 3))?;
-    class.define_method("shift", method!(RbDataFrame::shift, 1))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
     class.define_method("mean_horizontal", method!(RbDataFrame::mean_horizontal, 1))?;
     class.define_method("max_horizontal", method!(RbDataFrame::max_horizontal, 0))?;
@@ -142,7 +145,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sum_horizontal", method!(RbDataFrame::sum_horizontal, 1))?;
     class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 3))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
-    class.define_method("apply", method!(RbDataFrame::apply, 3))?;
+    class.define_method("map_rows", method!(RbDataFrame::map_rows, 3))?;
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
     class.define_method("hash_rows", method!(RbDataFrame::hash_rows, 4))?;
     class.define_method("transpose", method!(RbDataFrame::transpose, 2))?;
@@ -205,8 +208,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("cast", method!(RbExpr::cast, 2))?;
     class.define_method("sort_with", method!(RbExpr::sort_with, 2))?;
     class.define_method("arg_sort", method!(RbExpr::arg_sort, 2))?;
-    class.define_method("top_k", method!(RbExpr::top_k, 1))?;
-    class.define_method("bottom_k", method!(RbExpr::bottom_k, 1))?;
+    class.define_method("top_k", method!(RbExpr::top_k, 3))?;
+    class.define_method("bottom_k", method!(RbExpr::bottom_k, 3))?;
     class.define_method("peak_min", method!(RbExpr::peak_min, 0))?;
     class.define_method("peak_max", method!(RbExpr::peak_max, 0))?;
     class.define_method("arg_max", method!(RbExpr::arg_max, 0))?;
@@ -415,20 +418,31 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_dst_offset", method!(RbExpr::dt_dst_offset, 0))?;
     class.define_method("dt_round", method!(RbExpr::dt_round, 2))?;
     class.define_method("dt_combine", method!(RbExpr::dt_combine, 2))?;
-    class.define_method("map", method!(RbExpr::map, 3))?;
+    class.define_method("map_batches", method!(RbExpr::map_batches, 4))?;
     class.define_method("dot", method!(RbExpr::dot, 1))?;
     class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
     class.define_method("mode", method!(RbExpr::mode, 0))?;
     class.define_method("exclude", method!(RbExpr::exclude, 1))?;
     class.define_method("interpolate", method!(RbExpr::interpolate, 1))?;
-    class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 6))?;
-    class.define_method("rolling_min", method!(RbExpr::rolling_min, 6))?;
-    class.define_method("rolling_max", method!(RbExpr::rolling_max, 6))?;
-    class.define_method("rolling_mean", method!(RbExpr::rolling_mean, 6))?;
-    class.define_method("rolling_std", method!(RbExpr::rolling_std, 8))?;
-    class.define_method("rolling_var", method!(RbExpr::rolling_var, 8))?;
-    class.define_method("rolling_median", method!(RbExpr::rolling_median, 7))?;
-    class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 9))?;
+    class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 4))?;
+    class.define_method("rolling_sum_by", method!(RbExpr::rolling_sum_by, 4))?;
+    class.define_method("rolling_min", method!(RbExpr::rolling_min, 4))?;
+    class.define_method("rolling_min_by", method!(RbExpr::rolling_min_by, 4))?;
+    class.define_method("rolling_max", method!(RbExpr::rolling_max, 4))?;
+    class.define_method("rolling_max_by", method!(RbExpr::rolling_max_by, 4))?;
+    class.define_method("rolling_mean", method!(RbExpr::rolling_mean, 4))?;
+    class.define_method("rolling_mean_by", method!(RbExpr::rolling_mean_by, 4))?;
+    class.define_method("rolling_std", method!(RbExpr::rolling_std, 5))?;
+    class.define_method("rolling_std_by", method!(RbExpr::rolling_std_by, 5))?;
+    class.define_method("rolling_var", method!(RbExpr::rolling_var, 5))?;
+    class.define_method("rolling_var_by", method!(RbExpr::rolling_var_by, 5))?;
+    class.define_method("rolling_median", method!(RbExpr::rolling_median, 4))?;
+    class.define_method("rolling_median_by", method!(RbExpr::rolling_median_by, 4))?;
+    class.define_method("rolling_quantile", method!(RbExpr::rolling_quantile, 6))?;
+    class.define_method(
+        "rolling_quantile_by",
+        method!(RbExpr::rolling_quantile_by, 6),
+    )?;
     class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 2))?;
     class.define_method("lower_bound", method!(RbExpr::lower_bound, 0))?;
     class.define_method("upper_bound", method!(RbExpr::upper_bound, 0))?;
@@ -611,6 +625,17 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_singleton_method("collect_all", function!(functions::lazy::collect_all, 1))?;
     class.define_singleton_method("date_range", function!(functions::range::date_range, 6))?;
+    class.define_singleton_method("date_ranges", function!(functions::range::date_ranges, 6))?;
+    class.define_singleton_method(
+        "datetime_range",
+        function!(functions::range::datetime_range, 6),
+    )?;
+    class.define_singleton_method(
+        "datetime_ranges",
+        function!(functions::range::datetime_ranges, 6),
+    )?;
+    class.define_singleton_method("time_range", function!(functions::range::time_range, 4))?;
+    class.define_singleton_method("time_ranges", function!(functions::range::time_ranges, 4))?;
     class.define_singleton_method(
         "dtype_str_repr",
         function!(functions::misc::dtype_str_repr, 1),
@@ -689,7 +714,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_from_csv", function!(RbLazyFrame::new_from_csv, -1))?;
     class.define_singleton_method(
         "new_from_parquet",
-        function!(RbLazyFrame::new_from_parquet, 11),
+        function!(RbLazyFrame::new_from_parquet, 12),
     )?;
     class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 6))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;

data/ext/polars/src/map/lazy.rs

@@ -8,31 +8,11 @@ pub fn binary_lambda(_lambda: Value, _a: Series, _b: Series) -> PolarsResult<Opt
 }
 
 pub fn map_single(
-    rbexpr: &RbExpr,
+    _rbexpr: &RbExpr,
     _lambda: Value,
-    output_type: Option<Wrap<DataType>>,
-    agg_list: bool,
+    _output_type: Option<Wrap<DataType>>,
+    _agg_list: bool,
+    _is_elementwise: bool,
 ) -> RbExpr {
-    let output_type = output_type.map(|wrap| wrap.0);
-
-    let output_type2 = output_type.clone();
-    let function = move |_s: Series| {
-        let _output_type = output_type2.clone().unwrap_or(DataType::Unknown);
-
-        todo!();
-    };
-
-    let output_map = GetOutput::map_field(move |fld| match output_type {
-        Some(ref dt) => Field::new(fld.name(), dt.clone()),
-        None => {
-            let mut fld = fld.clone();
-            fld.coerce(DataType::Unknown);
-            fld
-        }
-    });
-    if agg_list {
-        rbexpr.clone().inner.map_list(function, output_map).into()
-    } else {
-        rbexpr.clone().inner.map(function, output_map).into()
-    }
+    todo!();
 }

data/ext/polars/src/map/series.rs

@@ -33,7 +33,12 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
             .apply_lambda_with_utf8_out_type(lambda, null_count, Some(first_value.as_str()))
             .map(|ca| ca.into_series().into())
     } else if out.respond_to("_s", true)? {
-        todo!()
+        let rb_rbseries: &RbSeries = out.funcall("_s", ()).unwrap();
+        let series = rb_rbseries.series.borrow();
+        let dt = series.dtype();
+        applyer
+            .apply_lambda_with_list_out_type(lambda, null_count, &series, dt)
+            .map(|ca| ca.into_series().into())
     } else if out.is_kind_of(class::array()) {
         todo!()
     } else if out.is_kind_of(class::hash()) {
@@ -66,6 +71,7 @@ pub trait ApplyLambda<'a> {
     fn apply_lambda_unknown(&'a self, _lambda: Value) -> RbResult<RbSeries>;
 
     /// Apply a lambda that doesn't change output types
+    #[allow(dead_code)]
     fn apply_lambda(&'a self, _lambda: Value) -> RbResult<RbSeries>;
 
     // Used to store a struct type

data/ext/polars/src/series/aggregation.rs

@@ -1,6 +1,6 @@
 use crate::error::RbPolarsErr;
 use crate::prelude::*;
-use crate::{RbResult, RbSeries, RbValueError};
+use crate::{RbResult, RbSeries};
 use magnus::{IntoValue, Value};
 
 impl RbSeries {
@@ -36,31 +36,52 @@ impl RbSeries {
         Ok(Wrap(
             self.series
                 .borrow()
-                .max_as_series()
+                .max_reduce()
                 .map_err(RbPolarsErr::from)?
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
+                .as_any_value(),
         )
         .into_value())
     }
 
-    pub fn mean(&self) -> Option<f64> {
+    pub fn mean(&self) -> RbResult<Value> {
         match self.series.borrow().dtype() {
-            DataType::Boolean => {
-                let s = self.series.borrow().cast(&DataType::UInt8).unwrap();
-                s.mean()
+            DataType::Boolean => Ok(Wrap(
+                self.series
+                    .borrow()
+                    .cast(&DataType::UInt8)
+                    .unwrap()
+                    .mean_reduce()
+                    .as_any_value(),
+            )
+            .into_value()),
+            DataType::Datetime(_, _) | DataType::Duration(_) | DataType::Time => {
+                Ok(Wrap(self.series.borrow().mean_reduce().as_any_value()).into_value())
             }
-            _ => self.series.borrow().mean(),
+            _ => Ok(self.series.borrow().mean().into_value()),
         }
     }
 
-    pub fn median(&self) -> Option<f64> {
+    pub fn median(&self) -> RbResult<Value> {
         match self.series.borrow().dtype() {
-            DataType::Boolean => {
-                let s = self.series.borrow().cast(&DataType::UInt8).unwrap();
-                s.median()
-            }
-            _ => self.series.borrow().median(),
+            DataType::Boolean => Ok(Wrap(
+                self.series
+                    .borrow()
+                    .cast(&DataType::UInt8)
+                    .unwrap()
+                    .median_reduce()
+                    .map_err(RbPolarsErr::from)?
+                    .as_any_value(),
+            )
+            .into_value()),
+            DataType::Datetime(_, _) | DataType::Duration(_) | DataType::Time => Ok(Wrap(
+                self.series
+                    .borrow()
+                    .median_reduce()
+                    .map_err(RbPolarsErr::from)?
+                    .as_any_value(),
+            )
+            .into_value()),
+            _ => Ok(self.series.borrow().median().into_value()),
         }
     }
 
@@ -68,10 +89,9 @@ impl RbSeries {
         Ok(Wrap(
             self.series
                 .borrow()
-                .min_as_series()
+                .min_reduce()
                 .map_err(RbPolarsErr::from)?
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
+                .as_any_value(),
         )
         .into_value())
     }
@@ -81,25 +101,22 @@ impl RbSeries {
         quantile: f64,
         interpolation: Wrap<QuantileInterpolOptions>,
     ) -> RbResult<Value> {
-        Ok(Wrap(
-            self.series
-                .borrow()
-                .quantile_as_series(quantile, interpolation.0)
-                .map_err(|_| RbValueError::new_err("invalid quantile".into()))?
-                .get(0)
-                .unwrap_or(AnyValue::Null),
-        )
-        .into_value())
+        let bind = self
+            .series
+            .borrow()
+            .quantile_reduce(quantile, interpolation.0);
+        let sc = bind.map_err(RbPolarsErr::from)?;
+
+        Ok(Wrap(sc.as_any_value()).into_value())
     }
 
     pub fn sum(&self) -> RbResult<Value> {
         Ok(Wrap(
             self.series
                 .borrow()
-                .sum_as_series()
+                .sum_reduce()
                 .map_err(RbPolarsErr::from)?
-                .get(0)
-                .map_err(RbPolarsErr::from)?,
+                .as_any_value(),
         )
         .into_value())
     }