polars-df 0.11.0 → 0.12.0

data/ext/polars/src/functions/eager.rs

@@ -9,8 +9,8 @@ use crate::{RbDataFrame, RbResult, RbSeries};
 pub fn concat_df(seq: RArray) -> RbResult<RbDataFrame> {
     use polars_core::error::PolarsResult;
 
-    let mut iter = seq.each();
-    let first = iter.next().unwrap()?;
+    let mut iter = seq.into_iter();
+    let first = iter.next().unwrap();
 
     let first_rdf = get_df(first)?;
     let identity_df = first_rdf.slice(0, 0);
@@ -18,7 +18,7 @@ pub fn concat_df(seq: RArray) -> RbResult<RbDataFrame> {
     let mut rdfs: Vec<PolarsResult<DataFrame>> = vec![Ok(first_rdf)];
 
     for item in iter {
-        let rdf = get_df(item?)?;
+        let rdf = get_df(item)?;
         rdfs.push(Ok(rdf));
     }
 
@@ -37,13 +37,13 @@ pub fn concat_df(seq: RArray) -> RbResult<RbDataFrame> {
 }
 
 pub fn concat_series(seq: RArray) -> RbResult<RbSeries> {
-    let mut iter = seq.each();
-    let first = iter.next().unwrap()?;
+    let mut iter = seq.into_iter();
+    let first = iter.next().unwrap();
 
     let mut s = get_series(first)?;
 
     for res in iter {
-        let item = res?;
+        let item = res;
         let item = get_series(item)?;
         s.append(&item).map_err(RbPolarsErr::from)?;
     }
@@ -52,8 +52,8 @@ pub fn concat_series(seq: RArray) -> RbResult<RbSeries> {
 
 pub fn concat_df_diagonal(seq: RArray) -> RbResult<RbDataFrame> {
     let mut dfs = Vec::new();
-    for item in seq.each() {
-        dfs.push(get_df(item?)?);
+    for item in seq.into_iter() {
+        dfs.push(get_df(item)?);
     }
     let df = functions::concat_df_diagonal(&dfs).map_err(RbPolarsErr::from)?;
     Ok(df.into())
@@ -61,8 +61,8 @@ pub fn concat_df_diagonal(seq: RArray) -> RbResult<RbDataFrame> {
 
 pub fn concat_df_horizontal(seq: RArray) -> RbResult<RbDataFrame> {
     let mut dfs = Vec::new();
-    for item in seq.each() {
-        dfs.push(get_df(item?)?);
+    for item in seq.into_iter() {
+        dfs.push(get_df(item)?);
     }
     let df = functions::concat_df_horizontal(&dfs).map_err(RbPolarsErr::from)?;
     Ok(df.into())

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

@@ -58,7 +58,7 @@ pub fn rolling_cov(
 pub fn arg_sort_by(
     by: RArray,
     descending: Vec<bool>,
-    nulls_last: bool,
+    nulls_last: Vec<bool>,
     multithreaded: bool,
     maintain_order: bool,
 ) -> RbResult<RbExpr> {
@@ -95,12 +95,12 @@ pub fn col(name: String) -> RbExpr {
 
 pub fn collect_all(lfs: RArray) -> RbResult<RArray> {
     let lfs = lfs
-        .each()
-        .map(|v| <&RbLazyFrame>::try_convert(v?))
+        .into_iter()
+        .map(<&RbLazyFrame>::try_convert)
         .collect::<RbResult<Vec<&RbLazyFrame>>>()?;
 
     Ok(RArray::from_iter(lfs.iter().map(|lf| {
-        let df = lf.ldf.clone().collect().unwrap();
+        let df = lf.ldf.borrow().clone().collect().unwrap();
         RbDataFrame::new(df)
     })))
 }
@@ -118,8 +118,8 @@ pub fn concat_lf(
     let (seq, len) = get_rbseq(lfs)?;
     let mut lfs = Vec::with_capacity(len);
 
-    for res in seq.each() {
-        let item = res?;
+    for res in seq.into_iter() {
+        let item = res;
         let lf = get_lf(item)?;
         lfs.push(lf);
     }
@@ -184,14 +184,9 @@ pub fn concat_lf_diagonal(
     parallel: bool,
     to_supertypes: bool,
 ) -> RbResult<RbLazyFrame> {
-    let iter = lfs.each();
+    let iter = lfs.into_iter();
 
-    let lfs = iter
-        .map(|item| {
-            let item = item?;
-            get_lf(item)
-        })
-        .collect::<RbResult<Vec<_>>>()?;
+    let lfs = iter.map(get_lf).collect::<RbResult<Vec<_>>>()?;
 
     let lf = dsl::functions::concat_lf_diagonal(
         lfs,
@@ -206,17 +201,22 @@ pub fn concat_lf_diagonal(
     Ok(lf.into())
 }
 
-pub fn dtype_cols(dtypes: Vec<DataType>) -> RbExpr {
-    dsl::dtype_cols(dtypes).into()
-}
-
-pub fn dtype_cols2(dtypes: RArray) -> RbResult<RbExpr> {
+pub fn dtype_cols(dtypes: RArray) -> RbResult<RbExpr> {
     let dtypes = dtypes
-        .each()
-        .map(|v| Wrap::<DataType>::try_convert(v?))
+        .into_iter()
+        .map(Wrap::<DataType>::try_convert)
         .collect::<RbResult<Vec<Wrap<DataType>>>>()?;
     let dtypes = vec_extract_wrapped(dtypes);
-    Ok(crate::functions::lazy::dtype_cols(dtypes))
+    Ok(dsl::dtype_cols(dtypes).into())
+}
+
+pub fn index_cols(indices: Vec<i64>) -> RbExpr {
+    if indices.len() == 1 {
+        dsl::nth(indices[0])
+    } else {
+        dsl::index_cols(indices)
+    }
+    .into()
 }
 
 #[allow(clippy::too_many_arguments)]

data/ext/polars/src/functions/range.rs

@@ -27,33 +27,27 @@ pub fn int_ranges(start: &RbExpr, end: &RbExpr, step: &RbExpr, dtype: Wrap<DataT
 pub fn date_range(
     start: &RbExpr,
     end: &RbExpr,
-    every: String,
+    interval: String,
     closed: Wrap<ClosedWindow>,
-    time_unit: Option<Wrap<TimeUnit>>,
-    time_zone: Option<TimeZone>,
 ) -> RbExpr {
     let start = start.inner.clone();
     let end = end.inner.clone();
-    let every = Duration::parse(&every);
+    let interval = Duration::parse(&interval);
     let closed = closed.0;
-    let time_unit = time_unit.map(|x| x.0);
-    dsl::date_range(start, end, every, closed, time_unit, time_zone).into()
+    dsl::date_range(start, end, interval, closed).into()
 }
 
 pub fn date_ranges(
     start: &RbExpr,
     end: &RbExpr,
-    every: String,
+    interval: String,
     closed: Wrap<ClosedWindow>,
-    time_unit: Option<Wrap<TimeUnit>>,
-    time_zone: Option<TimeZone>,
 ) -> RbExpr {
     let start = start.inner.clone();
     let end = end.inner.clone();
-    let every = Duration::parse(&every);
+    let interval = Duration::parse(&interval);
     let closed = closed.0;
-    let time_unit = time_unit.map(|x| x.0);
-    dsl::date_ranges(start, end, every, closed, time_unit, time_zone).into()
+    dsl::date_ranges(start, end, interval, closed).into()
 }
 
 pub fn datetime_range(

data/ext/polars/src/interop/numo/to_numo_series.rs

@@ -1,4 +1,5 @@
 use magnus::{class, prelude::*, Module, RArray, RClass, RModule, Value};
+use polars::series::BitRepr;
 use polars_core::prelude::*;
 
 use crate::error::RbPolarsErr;
@@ -23,7 +24,7 @@ impl RbSeries {
                     .funcall("cast", (np_arr,))
             }
             dt if dt.is_numeric() => {
-                if s.bit_repr_is_large() {
+                if let Some(BitRepr::Large(_)) = s.bit_repr() {
                     let s = s.cast(&DataType::Float64).unwrap();
                     let ca = s.f64().unwrap();
                     // TODO make more efficient