polars-df 0.17.0 → 0.18.0

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

@@ -1,61 +1,82 @@
-use magnus::{class, prelude::*, Module, RArray, RClass, RModule, Value};
-use polars::series::BitRepr;
+use magnus::Value;
+use num_traits::{Float, NumCast};
 use polars_core::prelude::*;
 
+use super::numo_rs::{Element, RbArray1};
 use crate::error::RbPolarsErr;
 use crate::raise_err;
 use crate::series::RbSeries;
 use crate::RbResult;
 
 impl RbSeries {
-    /// For numeric types, this should only be called for Series with null types.
-    /// This will cast to floats so that `nil = NAN`
+    /// Convert this Series to a Numo array.
     pub fn to_numo(&self) -> RbResult<Value> {
-        let s = &self.series.borrow();
-        match s.dtype() {
-            DataType::String => {
-                let ca = s.str().unwrap();
+        series_to_numo(&self.series.borrow())
+    }
+}
+
+/// Convert a Series to a Numo array.
+fn series_to_numo(s: &Series) -> RbResult<Value> {
+    series_to_numo_with_copy(s)
+}
 
-                // TODO make more efficient
-                let np_arr = RArray::from_iter(ca);
-                class::object()
-                    .const_get::<_, RModule>("Numo")?
-                    .const_get::<_, RClass>("RObject")?
-                    .funcall("cast", (np_arr,))
-            }
-            dt if dt.is_primitive_numeric() => {
-                if let Some(BitRepr::Large(_)) = s.bit_repr() {
-                    let s = s.cast(&DataType::Float64).unwrap();
-                    let ca = s.f64().unwrap();
-                    // TODO make more efficient
-                    let np_arr = RArray::from_iter(ca.into_iter().map(|opt_v| match opt_v {
-                        Some(v) => v,
-                        None => f64::NAN,
-                    }));
-                    class::object()
-                        .const_get::<_, RModule>("Numo")?
-                        .const_get::<_, RClass>("DFloat")?
-                        .funcall("cast", (np_arr,))
-                } else {
-                    let s = s.cast(&DataType::Float32).unwrap();
-                    let ca = s.f32().unwrap();
-                    // TODO make more efficient
-                    let np_arr = RArray::from_iter(ca.into_iter().map(|opt_v| match opt_v {
-                        Some(v) => v,
-                        None => f32::NAN,
-                    }));
-                    class::object()
-                        .const_get::<_, RModule>("Numo")?
-                        .const_get::<_, RClass>("SFloat")?
-                        .funcall("cast", (np_arr,))
-                }
-            }
-            dt => {
-                raise_err!(
-                    format!("'to_numo' not supported for dtype: {dt:?}"),
-                    ComputeError
-                );
-            }
+/// Convert a Series to a Numo array, copying data in the process.
+fn series_to_numo_with_copy(s: &Series) -> RbResult<Value> {
+    use DataType::*;
+    match s.dtype() {
+        Int8 => numeric_series_to_numpy::<Int8Type, f32>(s),
+        Int16 => numeric_series_to_numpy::<Int16Type, f32>(s),
+        Int32 => numeric_series_to_numpy::<Int32Type, f64>(s),
+        Int64 => numeric_series_to_numpy::<Int64Type, f64>(s),
+        UInt8 => numeric_series_to_numpy::<UInt8Type, f32>(s),
+        UInt16 => numeric_series_to_numpy::<UInt16Type, f32>(s),
+        UInt32 => numeric_series_to_numpy::<UInt32Type, f64>(s),
+        UInt64 => numeric_series_to_numpy::<UInt64Type, f64>(s),
+        Float32 => numeric_series_to_numpy::<Float32Type, f32>(s),
+        Float64 => numeric_series_to_numpy::<Float64Type, f64>(s),
+        Boolean => boolean_series_to_numo(s),
+        String => {
+            let ca = s.str().unwrap();
+            RbArray1::from_iter(ca)
+        }
+        dt => {
+            raise_err!(
+                format!("'to_numo' not supported for dtype: {dt:?}"),
+                ComputeError
+            );
         }
     }
 }
+
+/// Convert numeric types to f32 or f64 with NaN representing a null value.
+fn numeric_series_to_numpy<T, U>(s: &Series) -> RbResult<Value>
+where
+    T: PolarsNumericType,
+    T::Native: Element,
+    U: Float + Element,
+{
+    let ca: &ChunkedArray<T> = s.as_ref().as_ref();
+    if s.null_count() == 0 {
+        let values = ca.into_no_null_iter();
+        RbArray1::<T::Native>::from_iter(values)
+    } else {
+        let mapper = |opt_v: Option<T::Native>| match opt_v {
+            Some(v) => NumCast::from(v).unwrap(),
+            None => U::nan(),
+        };
+        let values = ca.iter().map(mapper);
+        RbArray1::from_iter(values)
+    }
+}
+
+/// Convert booleans to bit if no nulls are present, otherwise convert to objects.
+fn boolean_series_to_numo(s: &Series) -> RbResult<Value> {
+    let ca = s.bool().unwrap();
+    if s.null_count() == 0 {
+        let values = ca.into_no_null_iter();
+        RbArray1::<bool>::from_iter(values)
+    } else {
+        let values = ca.iter();
+        RbArray1::from_iter(values)
+    }
+}

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

@@ -2,12 +2,13 @@ use magnus::{r_hash::ForEach, typed_data::Obj, IntoValue, RArray, RHash, TryConv
 use polars::io::{HiveOptions, RowIndex};
 use polars::lazy::frame::LazyFrame;
 use polars::prelude::*;
-use polars_plan::plans::ScanSources;
+use polars_plan::dsl::ScanSources;
 use std::cell::RefCell;
 use std::io::BufWriter;
 use std::num::NonZeroUsize;
 use std::path::PathBuf;
 
+use super::SinkTarget;
 use crate::conversion::*;
 use crate::expr::rb_exprs_to_exprs;
 use crate::file::get_file_like;
@@ -374,16 +375,16 @@ impl RbLazyFrame {
     #[allow(clippy::too_many_arguments)]
     pub fn sink_parquet(
         &self,
-        path: PathBuf,
+        target: SinkTarget,
         compression: String,
         compression_level: Option<i32>,
         statistics: Wrap<StatisticsOptions>,
         row_group_size: Option<usize>,
         data_page_size: Option<usize>,
-        maintain_order: bool,
         cloud_options: Option<Vec<(String, String)>>,
         retries: usize,
-    ) -> RbResult<()> {
+        sink_options: Wrap<SinkOptions>,
+    ) -> RbResult<RbLazyFrame> {
         let compression = parse_parquet_compression(&compression, compression_level)?;
 
         let options = ParquetWriteOptions {
@@ -391,67 +392,83 @@ impl RbLazyFrame {
             statistics: statistics.0,
             row_group_size,
             data_page_size,
-            maintain_order,
         };
 
-        let cloud_options = {
-            let cloud_options =
-                parse_cloud_options(path.to_str().unwrap(), cloud_options.unwrap_or_default())?;
-            Some(cloud_options.with_max_retries(retries))
+        let cloud_options = match target.base_path() {
+            None => None,
+            Some(base_path) => {
+                let cloud_options = parse_cloud_options(
+                    base_path.to_str().unwrap(),
+                    cloud_options.unwrap_or_default(),
+                )?;
+                Some(cloud_options.with_max_retries(retries))
+            }
         };
 
         let ldf = self.ldf.borrow().clone();
-        ldf.sink_parquet(&path, options, cloud_options)
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
+        match target {
+            SinkTarget::File(target) => {
+                ldf.sink_parquet(target, options, cloud_options, sink_options.0)
+            }
+        }
+        .map_err(RbPolarsErr::from)
+        .map(Into::into)
+        .map_err(Into::into)
     }
 
     pub fn sink_ipc(
         &self,
-        path: PathBuf,
+        target: SinkTarget,
         compression: Option<Wrap<IpcCompression>>,
-        maintain_order: bool,
         cloud_options: Option<Vec<(String, String)>>,
         retries: usize,
-    ) -> RbResult<()> {
+        sink_options: Wrap<SinkOptions>,
+    ) -> RbResult<RbLazyFrame> {
         let options = IpcWriterOptions {
             compression: compression.map(|c| c.0),
-            maintain_order,
+            ..Default::default()
         };
 
-        let cloud_options = {
-            let cloud_options =
-                parse_cloud_options(path.to_str().unwrap(), cloud_options.unwrap_or_default())?;
-            Some(cloud_options.with_max_retries(retries))
+        let cloud_options = match target.base_path() {
+            None => None,
+            Some(base_path) => {
+                let cloud_options = parse_cloud_options(
+                    base_path.to_str().unwrap(),
+                    cloud_options.unwrap_or_default(),
+                )?;
+                Some(cloud_options.with_max_retries(retries))
+            }
         };
 
         let ldf = self.ldf.borrow().clone();
-        ldf.sink_ipc(&path, options, cloud_options)
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub fn sink_csv(
-        &self,
-        path: PathBuf,
-        include_bom: bool,
-        include_header: bool,
-        separator: u8,
-        line_terminator: String,
-        quote_char: u8,
-        batch_size: Wrap<NonZeroUsize>,
-        datetime_format: Option<String>,
-        date_format: Option<String>,
-        time_format: Option<String>,
-        float_scientific: Option<bool>,
-        float_precision: Option<usize>,
-        null_value: Option<String>,
-        quote_style: Option<Wrap<QuoteStyle>>,
-        maintain_order: bool,
-    ) -> RbResult<()> {
-        // TODO
-        let cloud_options = None;
+        match target {
+            SinkTarget::File(target) => {
+                ldf.sink_ipc(target, options, cloud_options, sink_options.0)
+            }
+        }
+        .map_err(RbPolarsErr::from)
+        .map(Into::into)
+        .map_err(Into::into)
+    }
+
+    pub fn sink_csv(&self, arguments: &[Value]) -> RbResult<RbLazyFrame> {
+        let target = SinkTarget::try_convert(arguments[0])?;
+        let include_bom = bool::try_convert(arguments[1])?;
+        let include_header = bool::try_convert(arguments[2])?;
+        let separator = u8::try_convert(arguments[3])?;
+        let line_terminator = String::try_convert(arguments[4])?;
+        let quote_char = u8::try_convert(arguments[5])?;
+        let batch_size = Wrap::<NonZeroUsize>::try_convert(arguments[6])?;
+        let datetime_format = Option::<String>::try_convert(arguments[7])?;
+        let date_format = Option::<String>::try_convert(arguments[8])?;
+        let time_format = Option::<String>::try_convert(arguments[9])?;
+        let float_scientific = Option::<bool>::try_convert(arguments[10])?;
+        let float_precision = Option::<usize>::try_convert(arguments[11])?;
+        let null_value = Option::<String>::try_convert(arguments[12])?;
+        let quote_style = Option::<Wrap<QuoteStyle>>::try_convert(arguments[13])?;
+        let cloud_options = Option::<Vec<(String, String)>>::try_convert(arguments[14])?;
+        let retries = usize::try_convert(arguments[15])?;
+        let sink_options = Wrap::<SinkOptions>::try_convert(arguments[16])?;
 
         let quote_style = quote_style.map_or(QuoteStyle::default(), |wrap| wrap.0);
         let null_value = null_value.unwrap_or(SerializeOptions::default().null);
@@ -472,42 +489,59 @@ impl RbLazyFrame {
         let options = CsvWriterOptions {
             include_bom,
             include_header,
-            maintain_order,
             batch_size: batch_size.0,
             serialize_options,
         };
 
-        let cloud_options = {
-            let cloud_options =
-                parse_cloud_options(path.to_str().unwrap(), cloud_options.unwrap_or_default())?;
-            Some(cloud_options)
+        let cloud_options = match target.base_path() {
+            None => None,
+            Some(base_path) => {
+                let cloud_options = parse_cloud_options(
+                    base_path.to_str().unwrap(),
+                    cloud_options.unwrap_or_default(),
+                )?;
+                Some(cloud_options.with_max_retries(retries))
+            }
         };
 
         let ldf = self.ldf.borrow().clone();
-        ldf.sink_csv(&path, options, cloud_options)
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
+        match target {
+            SinkTarget::File(target) => {
+                ldf.sink_csv(target, options, cloud_options, sink_options.0)
+            }
+        }
+        .map_err(RbPolarsErr::from)
+        .map(Into::into)
+        .map_err(Into::into)
     }
 
     pub fn sink_json(
         &self,
-        path: PathBuf,
-        maintain_order: bool,
+        target: SinkTarget,
         cloud_options: Option<Vec<(String, String)>>,
         retries: usize,
-    ) -> RbResult<()> {
-        let options = JsonWriterOptions { maintain_order };
-
-        let cloud_options = {
-            let cloud_options =
-                parse_cloud_options(path.to_str().unwrap(), cloud_options.unwrap_or_default())?;
-            Some(cloud_options.with_max_retries(retries))
+        sink_options: Wrap<SinkOptions>,
+    ) -> RbResult<RbLazyFrame> {
+        let options = JsonWriterOptions {};
+
+        let cloud_options = match target.base_path() {
+            None => None,
+            Some(base_path) => {
+                let cloud_options = parse_cloud_options(
+                    base_path.to_str().unwrap(),
+                    cloud_options.unwrap_or_default(),
+                )?;
+                Some(cloud_options.with_max_retries(retries))
+            }
         };
 
         let ldf = self.ldf.borrow().clone();
-        ldf.sink_json(&path, options, cloud_options)
-            .map_err(RbPolarsErr::from)?;
-        Ok(())
+        match target {
+            SinkTarget::File(path) => ldf.sink_json(path, options, cloud_options, sink_options.0),
+        }
+        .map_err(RbPolarsErr::from)
+        .map(Into::into)
+        .map_err(Into::into)
     }
 
     pub fn fetch(&self, n_rows: usize) -> RbResult<RbDataFrame> {
@@ -679,6 +713,7 @@ impl RbLazyFrame {
         how: Wrap<JoinType>,
         suffix: String,
         validate: Wrap<JoinValidation>,
+        maintain_order: Wrap<MaintainOrderJoin>,
         coalesce: Option<bool>,
     ) -> RbResult<Self> {
         let coalesce = match coalesce {
@@ -702,6 +737,7 @@ impl RbLazyFrame {
             .how(how.0)
             .validate(validate.0)
             .coalesce(coalesce)
+            .maintain_order(maintain_order.0)
             .suffix(suffix)
             .finish()
             .into())

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

@@ -1,7 +1,9 @@
 mod general;
 mod serde;
+mod sink;
 
 use polars::lazy::frame::LazyFrame;
+pub use sink::SinkTarget;
 use std::cell::RefCell;
 
 #[magnus::wrap(class = "Polars::RbLazyFrame")]

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

@@ -0,0 +1,99 @@
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+
+use magnus::{RHash, TryConvert, Value};
+use polars::prelude::sync_on_close::SyncOnCloseType;
+use polars::prelude::{SinkOptions, SpecialEq};
+
+use crate::prelude::Wrap;
+use crate::{RbResult, RbValueError};
+
+#[derive(Clone)]
+pub enum SinkTarget {
+    File(polars_plan::dsl::SinkTarget),
+}
+
+impl TryConvert for Wrap<polars_plan::dsl::SinkTarget> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        if let Ok(v) = PathBuf::try_convert(ob) {
+            Ok(Wrap(polars::prelude::SinkTarget::Path(Arc::new(v))))
+        } else {
+            let writer = {
+                let rb_f = ob;
+                RbResult::Ok(crate::file::try_get_rbfile(rb_f, true)?.0.into_writeable())
+            }?;
+
+            Ok(Wrap(polars_plan::prelude::SinkTarget::Dyn(SpecialEq::new(
+                Arc::new(Mutex::new(Some(writer))),
+            ))))
+        }
+    }
+}
+
+impl TryConvert for SinkTarget {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        Ok(Self::File(
+            <Wrap<polars_plan::dsl::SinkTarget>>::try_convert(ob)?.0,
+        ))
+    }
+}
+
+impl SinkTarget {
+    pub fn base_path(&self) -> Option<&Path> {
+        match self {
+            Self::File(t) => match t {
+                polars::prelude::SinkTarget::Path(p) => Some(p.as_path()),
+                polars::prelude::SinkTarget::Dyn(_) => None,
+            },
+        }
+    }
+}
+
+impl TryConvert for Wrap<SyncOnCloseType> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "none" => SyncOnCloseType::None,
+            "data" => SyncOnCloseType::Data,
+            "all" => SyncOnCloseType::All,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`sync_on_close` must be one of {{'none', 'data', 'all'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<SinkOptions> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = RHash::try_convert(ob)?;
+
+        if parsed.len() != 3 {
+            return Err(RbValueError::new_err(
+                "`sink_options` must be a dictionary with the exactly 3 field.",
+            ));
+        }
+
+        let sync_on_close = parsed.get("sync_on_close").ok_or_else(|| {
+            RbValueError::new_err("`sink_options` must contain `sync_on_close` field")
+        })?;
+        let sync_on_close = Wrap::<SyncOnCloseType>::try_convert(sync_on_close)?.0;
+
+        let maintain_order = parsed.get("maintain_order").ok_or_else(|| {
+            RbValueError::new_err("`sink_options` must contain `maintain_order` field")
+        })?;
+        let maintain_order = bool::try_convert(maintain_order)?;
+
+        let mkdir = parsed
+            .get("mkdir")
+            .ok_or_else(|| RbValueError::new_err("`sink_options` must contain `mkdir` field"))?;
+        let mkdir = bool::try_convert(mkdir)?;
+
+        Ok(Wrap(SinkOptions {
+            sync_on_close,
+            maintain_order,
+            mkdir,
+        }))
+    }
+}

data/ext/polars/src/lib.rs

@@ -221,8 +221,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("gather", method!(RbExpr::gather, 1))?;
     class.define_method("get", method!(RbExpr::get, 1))?;
     class.define_method("sort_by", method!(RbExpr::sort_by, 5))?;
-    class.define_method("backward_fill", method!(RbExpr::backward_fill, 1))?;
-    class.define_method("forward_fill", method!(RbExpr::forward_fill, 1))?;
     class.define_method("shift", method!(RbExpr::shift, 2))?;
     class.define_method("fill_null", method!(RbExpr::fill_null, 1))?;
     class.define_method(
@@ -248,7 +246,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("slice", method!(RbExpr::slice, 2))?;
     class.define_method("append", method!(RbExpr::append, 2))?;
     class.define_method("rechunk", method!(RbExpr::rechunk, 0))?;
-    class.define_method("round", method!(RbExpr::round, 1))?;
+    class.define_method("round", method!(RbExpr::round, 2))?;
     class.define_method("floor", method!(RbExpr::floor, 0))?;
     class.define_method("ceil", method!(RbExpr::ceil, 0))?;
     class.define_method("clip", method!(RbExpr::clip, 2))?;
@@ -271,7 +269,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("_and", method!(RbExpr::_and, 1))?;
     class.define_method("_xor", method!(RbExpr::_xor, 1))?;
     class.define_method("_or", method!(RbExpr::_or, 1))?;
-    class.define_method("is_in", method!(RbExpr::is_in, 1))?;
+    class.define_method("is_in", method!(RbExpr::is_in, 2))?;
     class.define_method("repeat_by", method!(RbExpr::repeat_by, 1))?;
     class.define_method("pow", method!(RbExpr::pow, 1))?;
     class.define_method("cum_sum", method!(RbExpr::cum_sum, 1))?;
@@ -430,6 +428,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     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("interpolate_by", method!(RbExpr::interpolate_by, 1))?;
     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))?;
@@ -449,7 +448,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "rolling_quantile_by",
         method!(RbExpr::rolling_quantile_by, 6),
     )?;
-    class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 2))?;
+    class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 4))?;
     class.define_method("lower_bound", method!(RbExpr::lower_bound, 0))?;
     class.define_method("upper_bound", method!(RbExpr::upper_bound, 0))?;
     class.define_method("list_max", method!(RbExpr::list_max, 0))?;
@@ -558,7 +557,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("first", function!(functions::lazy::first, 0))?;
     class.define_singleton_method("last", function!(functions::lazy::last, 0))?;
     class.define_singleton_method("cols", function!(functions::lazy::cols, 1))?;
-    class.define_singleton_method("fold", function!(functions::lazy::fold, 3))?;
+    class.define_singleton_method("fold", function!(functions::lazy::fold, 5))?;
     class.define_singleton_method("cum_fold", function!(functions::lazy::cum_fold, 4))?;
     class.define_singleton_method("lit", function!(functions::lazy::lit, 2))?;
     class.define_singleton_method("int_range", function!(functions::range::int_range, 4))?;
@@ -614,6 +613,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "concat_lf_diagonal",
         function!(functions::lazy::concat_lf_diagonal, 4),
     )?;
+    class.define_singleton_method(
+        "concat_lf_horizontal",
+        function!(functions::lazy::concat_lf_horizontal, 2),
+    )?;
     class.define_singleton_method("concat_df", function!(functions::eager::concat_df, 1))?;
     class.define_singleton_method("concat_lf", function!(functions::lazy::concat_lf, 4))?;
     class.define_singleton_method(
@@ -745,7 +748,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("collect", method!(RbLazyFrame::collect, 0))?;
     class.define_method("sink_parquet", method!(RbLazyFrame::sink_parquet, 9))?;
     class.define_method("sink_ipc", method!(RbLazyFrame::sink_ipc, 5))?;
-    class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, 15))?;
+    class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, -1))?;
     class.define_method("sink_json", method!(RbLazyFrame::sink_json, 4))?;
     class.define_method("fetch", method!(RbLazyFrame::fetch, 1))?;
     class.define_method("filter", method!(RbLazyFrame::filter, 1))?;
@@ -759,7 +762,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     )?;
     class.define_method("with_context", method!(RbLazyFrame::with_context, 1))?;
     class.define_method("join_asof", method!(RbLazyFrame::join_asof, 14))?;
-    class.define_method("join", method!(RbLazyFrame::join, 10))?;
+    class.define_method("join", method!(RbLazyFrame::join, 11))?;
     class.define_method("with_column", method!(RbLazyFrame::with_column, 1))?;
     class.define_method("with_columns", method!(RbLazyFrame::with_columns, 1))?;
     class.define_method(

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

@@ -245,7 +245,7 @@ fn iterator_to_list(
         match opt_val {
             None => builder.append_null(),
             Some(s) => {
-                if s.len() == 0 && s.dtype() != dt {
+                if s.is_empty() && s.dtype() != dt {
                     builder
                         .append_series(&Series::full_null(PlSmallStr::EMPTY, 0, dt))
                         .unwrap()

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

@@ -372,7 +372,7 @@ impl<'a> ApplyLambda<'a> for BooleanChunked {
         first_value: AnyValue<'a>,
     ) -> RbResult<Series> {
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         if self.null_count() > 0 {
@@ -656,7 +656,7 @@ where
         first_value: AnyValue<'a>,
     ) -> RbResult<Series> {
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         if self.null_count() > 0 {
@@ -935,7 +935,7 @@ impl<'a> ApplyLambda<'a> for StringChunked {
         first_value: AnyValue<'a>,
     ) -> RbResult<Series> {
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         if self.null_count() > 0 {
@@ -1132,7 +1132,7 @@ impl<'a> ApplyLambda<'a> for StructChunked {
         first_value: AnyValue<'a>,
     ) -> RbResult<Series> {
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         let iter = iter_struct(self).skip(init_null_count + 1).map(|val| {

data/ext/polars/src/on_startup.rs

@@ -1,5 +1,6 @@
 use std::any::Any;
 use std::sync::Arc;
+use std::sync::OnceLock;
 
 use magnus::IntoValue;
 use polars::prelude::*;
@@ -11,8 +12,10 @@ use polars_core::prelude::AnyValue;
 use crate::prelude::ObjectValue;
 use crate::Wrap;
 
+static POLARS_REGISTRY_INIT_LOCK: OnceLock<()> = OnceLock::new();
+
 pub(crate) fn register_startup_deps() {
-    if !registry::is_object_builder_registered() {
+    POLARS_REGISTRY_INIT_LOCK.get_or_init(|| {
         let object_builder = Box::new(|name: PlSmallStr, capacity: usize| {
             Box::new(ObjectChunkedBuilder::<ObjectValue>::new(name, capacity))
                 as Box<dyn AnonymousObjectBuilder>
@@ -24,9 +27,18 @@ pub(crate) fn register_startup_deps() {
             };
             Box::new(object) as Box<dyn Any>
         });
+        let rbobject_converter = Arc::new(|av: AnyValue| {
+            let object = Wrap(av).into_value();
+            Box::new(object) as Box<dyn Any>
+        });
 
         let object_size = std::mem::size_of::<ObjectValue>();
         let physical_dtype = ArrowDataType::FixedSizeBinary(object_size);
-        registry::register_object_builder(object_builder, object_converter, physical_dtype)
-    }
+        registry::register_object_builder(
+            object_builder,
+            object_converter,
+            rbobject_converter,
+            physical_dtype,
+        )
+    });
 }