polars-df 0.21.1 → 0.23.0

data/ext/polars/src/lib.rs

@@ -34,9 +34,9 @@ use expr::selector::RbSelector;
 use functions::string_cache::RbStringCacheHolder;
 use functions::whenthen::{RbChainedThen, RbChainedWhen, RbThen, RbWhen};
 use interop::arrow::to_ruby::RbArrowArrayStream;
-use lazyframe::RbLazyFrame;
+use lazyframe::{RbLazyFrame, RbOptFlags};
 use lazygroupby::RbLazyGroupBy;
-use magnus::{Ruby, define_module, function, method, prelude::*};
+use magnus::{Ruby, function, method, prelude::*};
 use series::RbSeries;
 use sql::RbSQLContext;
 
@@ -52,7 +52,7 @@ fn re_escape(pattern: String) -> String {
 fn init(ruby: &Ruby) -> RbResult<()> {
     crate::on_startup::register_startup_deps();
 
-    let module = define_module("Polars")?;
+    let module = ruby.define_module("Polars")?;
 
     let class = module.define_class("RbBatchedCsv", ruby.class_object())?;
     class.define_singleton_method("new", function!(RbBatchedCsv::new, -1))?;
@@ -156,9 +156,15 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("transpose", method!(RbDataFrame::transpose, 2))?;
     class.define_method("upsample", method!(RbDataFrame::upsample, 4))?;
     class.define_method("to_struct", method!(RbDataFrame::to_struct, 1))?;
-    class.define_method("unnest", method!(RbDataFrame::unnest, 1))?;
     class.define_method("clear", method!(RbDataFrame::clear, 0))?;
-    class.define_method("serialize_json", method!(RbDataFrame::serialize_json, 1))?;
+    class.define_method(
+        "serialize_binary",
+        method!(RbDataFrame::serialize_binary, 1),
+    )?;
+    class.define_singleton_method(
+        "deserialize_binary",
+        function!(RbDataFrame::deserialize_binary, 1),
+    )?;
 
     let class = module.define_class("RbExpr", ruby.class_object())?;
     class.define_method("+", method!(RbExpr::add, 1))?;
@@ -291,7 +297,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("cum_min", method!(RbExpr::cum_min, 1))?;
     class.define_method("cum_prod", method!(RbExpr::cum_prod, 1))?;
     class.define_method("product", method!(RbExpr::product, 0))?;
-    class.define_method("shrink_dtype", method!(RbExpr::shrink_dtype, 0))?;
     class.define_method("str_to_date", method!(RbExpr::str_to_date, 4))?;
     class.define_method("str_to_datetime", method!(RbExpr::str_to_datetime, 7))?;
     class.define_method("str_to_time", method!(RbExpr::str_to_time, 3))?;
@@ -359,7 +364,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_base64_encode", method!(RbExpr::str_base64_encode, 0))?;
     class.define_method("str_base64_decode", method!(RbExpr::str_base64_decode, 1))?;
     class.define_method("str_to_integer", method!(RbExpr::str_to_integer, 3))?;
-    class.define_method("str_json_decode", method!(RbExpr::str_json_decode, 2))?;
+    class.define_method("str_json_decode", method!(RbExpr::str_json_decode, 1))?;
     class.define_method("binary_hex_encode", method!(RbExpr::bin_hex_encode, 0))?;
     class.define_method("binary_hex_decode", method!(RbExpr::bin_hex_decode, 1))?;
     class.define_method(
@@ -426,26 +431,25 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dt_millisecond", method!(RbExpr::dt_millisecond, 0))?;
     class.define_method("dt_microsecond", method!(RbExpr::dt_microsecond, 0))?;
     class.define_method("dt_nanosecond", method!(RbExpr::dt_nanosecond, 0))?;
-    class.define_method("dt_total_days", method!(RbExpr::dt_total_days, 0))?;
-    class.define_method("dt_total_hours", method!(RbExpr::dt_total_hours, 0))?;
-    class.define_method("dt_total_minutes", method!(RbExpr::dt_total_minutes, 0))?;
-    class.define_method("dt_total_seconds", method!(RbExpr::dt_total_seconds, 0))?;
+    class.define_method("dt_total_days", method!(RbExpr::dt_total_days, 1))?;
+    class.define_method("dt_total_hours", method!(RbExpr::dt_total_hours, 1))?;
+    class.define_method("dt_total_minutes", method!(RbExpr::dt_total_minutes, 1))?;
+    class.define_method("dt_total_seconds", method!(RbExpr::dt_total_seconds, 1))?;
     class.define_method(
         "dt_total_nanoseconds",
-        method!(RbExpr::dt_total_nanoseconds, 0),
+        method!(RbExpr::dt_total_nanoseconds, 1),
     )?;
     class.define_method(
         "dt_total_microseconds",
-        method!(RbExpr::dt_total_microseconds, 0),
+        method!(RbExpr::dt_total_microseconds, 1),
     )?;
     class.define_method(
         "dt_total_milliseconds",
-        method!(RbExpr::dt_total_milliseconds, 0),
+        method!(RbExpr::dt_total_milliseconds, 1),
     )?;
     class.define_method("dt_timestamp", method!(RbExpr::dt_timestamp, 1))?;
     class.define_method("dt_to_string", method!(RbExpr::dt_to_string, 1))?;
     class.define_method("dt_offset_by", method!(RbExpr::dt_offset_by, 1))?;
-    class.define_method("dt_epoch_seconds", method!(RbExpr::dt_epoch_seconds, 0))?;
     class.define_method("dt_with_time_unit", method!(RbExpr::dt_with_time_unit, 1))?;
     class.define_method(
         "dt_convert_time_zone",
@@ -527,7 +531,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_eval", method!(RbExpr::list_eval, 1))?;
     class.define_method("list_filter", method!(RbExpr::list_filter, 1))?;
     class.define_method("cumulative_eval", method!(RbExpr::cumulative_eval, 2))?;
-    class.define_method("list_to_struct", method!(RbExpr::list_to_struct, 3))?;
+    class.define_method("list_to_struct", method!(RbExpr::list_to_struct, 1))?;
     class.define_method("rank", method!(RbExpr::rank, 3))?;
     class.define_method("diff", method!(RbExpr::diff, 2))?;
     class.define_method("pct_change", method!(RbExpr::pct_change, 1))?;
@@ -578,6 +582,13 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("hist", method!(RbExpr::hist, 4))?;
     class.define_method("into_selector", method!(RbExpr::into_selector, 0))?;
     class.define_singleton_method("new_selector", function!(RbExpr::new_selector, 1))?;
+    #[cfg(feature = "serialize_binary")]
+    class.define_method("serialize_binary", method!(RbExpr::serialize_binary, 1))?;
+    #[cfg(feature = "serialize_binary")]
+    class.define_singleton_method(
+        "deserialize_binary",
+        function!(RbExpr::deserialize_binary, 1),
+    )?;
 
     // bitwise
     class.define_method("bitwise_count_ones", method!(RbExpr::bitwise_count_ones, 0))?;
@@ -810,7 +821,20 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("re_escape", function!(re_escape, 1))?;
 
     let class = module.define_class("RbLazyFrame", ruby.class_object())?;
-    class.define_singleton_method("read_json", function!(RbLazyFrame::read_json, 1))?;
+    #[cfg(feature = "serialize_binary")]
+    class.define_method(
+        "serialize_binary",
+        method!(RbLazyFrame::serialize_binary, 1),
+    )?;
+    #[cfg(feature = "serialize_binary")]
+    class.define_singleton_method(
+        "deserialize_binary",
+        function!(RbLazyFrame::deserialize_binary, 1),
+    )?;
+    class.define_singleton_method(
+        "deserialize_json",
+        function!(RbLazyFrame::deserialize_json, 1),
+    )?;
     class.define_singleton_method(
         "new_from_ndjson",
         function!(RbLazyFrame::new_from_ndjson, 8),
@@ -820,7 +844,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "new_from_parquet",
         function!(RbLazyFrame::new_from_parquet, 6),
     )?;
-    class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 10))?;
+    class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 3))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
     class.define_method("describe_plan", method!(RbLazyFrame::describe_plan, 0))?;
     class.define_method(
@@ -887,7 +911,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("cast_all", method!(RbLazyFrame::cast_all, 2))?;
     class.define_method("_clone", method!(RbLazyFrame::clone, 0))?;
     class.define_method("collect_schema", method!(RbLazyFrame::collect_schema, 0))?;
-    class.define_method("unnest", method!(RbLazyFrame::unnest, 1))?;
+    class.define_method("unnest", method!(RbLazyFrame::unnest, 2))?;
     class.define_method("count", method!(RbLazyFrame::count, 0))?;
     class.define_method("merge_sorted", method!(RbLazyFrame::merge_sorted, 2))?;
 
@@ -902,10 +926,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_opt_u16", function!(RbSeries::new_opt_u16, 3))?;
     class.define_singleton_method("new_opt_u32", function!(RbSeries::new_opt_u32, 3))?;
     class.define_singleton_method("new_opt_u64", function!(RbSeries::new_opt_u64, 3))?;
+    class.define_singleton_method("new_opt_u128", function!(RbSeries::new_opt_u128, 3))?;
     class.define_singleton_method("new_opt_i8", function!(RbSeries::new_opt_i8, 3))?;
     class.define_singleton_method("new_opt_i16", function!(RbSeries::new_opt_i16, 3))?;
     class.define_singleton_method("new_opt_i32", function!(RbSeries::new_opt_i32, 3))?;
     class.define_singleton_method("new_opt_i64", function!(RbSeries::new_opt_i64, 3))?;
+    class.define_singleton_method("new_opt_i128", function!(RbSeries::new_opt_i128, 3))?;
     class.define_singleton_method("new_opt_f32", function!(RbSeries::new_opt_f32, 3))?;
     class.define_singleton_method("new_opt_f64", function!(RbSeries::new_opt_f64, 3))?;
     class.define_singleton_method(
@@ -1002,6 +1028,12 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("lt", method!(RbSeries::lt, 1))?;
     class.define_method("lt_eq", method!(RbSeries::lt_eq, 1))?;
     class.define_method("not_", method!(RbSeries::not_, 0))?;
+    class.define_method("shrink_dtype", method!(RbSeries::shrink_dtype, 0))?;
+    class.define_method(
+        "str_to_decimal_infer",
+        method!(RbSeries::str_to_decimal_infer, 1),
+    )?;
+    class.define_method("str_json_decode", method!(RbSeries::str_json_decode, 1))?;
     class.define_method("to_s", method!(RbSeries::to_s, 0))?;
     class.define_method("len", method!(RbSeries::len, 0))?;
     class.define_method("to_a", method!(RbSeries::to_a, 0))?;
@@ -1298,5 +1330,98 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("all", function!(RbSelector::all, 0))?;
     class.define_method("_hash", method!(RbSelector::hash, 0))?;
 
+    // opt flags
+    let class = module.define_class("RbOptFlags", ruby.class_object())?;
+    class.define_singleton_method("empty", function!(RbOptFlags::empty, 0))?;
+    class.define_singleton_method("default", function!(RbOptFlags::default, 0))?;
+    class.define_method("no_optimizations", method!(RbOptFlags::no_optimizations, 0))?;
+    class.define_method("copy", method!(RbOptFlags::copy, 0))?;
+    class.define_method(
+        "get_type_coercion",
+        method!(RbOptFlags::get_type_coercion, 0),
+    )?;
+    class.define_method(
+        "set_type_coercion",
+        method!(RbOptFlags::set_type_coercion, 1),
+    )?;
+    class.define_method("get_type_check", method!(RbOptFlags::get_type_check, 0))?;
+    class.define_method("set_type_check", method!(RbOptFlags::set_type_check, 1))?;
+    class.define_method(
+        "get_projection_pushdown",
+        method!(RbOptFlags::get_projection_pushdown, 0),
+    )?;
+    class.define_method(
+        "set_projection_pushdown",
+        method!(RbOptFlags::set_projection_pushdown, 1),
+    )?;
+    class.define_method(
+        "get_predicate_pushdown",
+        method!(RbOptFlags::get_predicate_pushdown, 0),
+    )?;
+    class.define_method(
+        "set_predicate_pushdown",
+        method!(RbOptFlags::set_predicate_pushdown, 1),
+    )?;
+    class.define_method(
+        "get_cluster_with_columns",
+        method!(RbOptFlags::get_cluster_with_columns, 0),
+    )?;
+    class.define_method(
+        "set_cluster_with_columns",
+        method!(RbOptFlags::set_cluster_with_columns, 1),
+    )?;
+    class.define_method(
+        "get_simplify_expression",
+        method!(RbOptFlags::get_simplify_expression, 0),
+    )?;
+    class.define_method(
+        "set_simplify_expression",
+        method!(RbOptFlags::set_simplify_expression, 1),
+    )?;
+    class.define_method(
+        "get_slice_pushdown",
+        method!(RbOptFlags::get_slice_pushdown, 0),
+    )?;
+    class.define_method(
+        "set_slice_pushdown",
+        method!(RbOptFlags::set_slice_pushdown, 1),
+    )?;
+    class.define_method(
+        "get_comm_subplan_elim",
+        method!(RbOptFlags::get_comm_subplan_elim, 0),
+    )?;
+    class.define_method(
+        "set_comm_subplan_elim",
+        method!(RbOptFlags::set_comm_subplan_elim, 1),
+    )?;
+    class.define_method(
+        "get_comm_subexpr_elim",
+        method!(RbOptFlags::get_comm_subexpr_elim, 0),
+    )?;
+    class.define_method(
+        "set_comm_subexpr_elim",
+        method!(RbOptFlags::set_comm_subexpr_elim, 1),
+    )?;
+    class.define_method(
+        "get_check_order_observe",
+        method!(RbOptFlags::get_check_order_observe, 0),
+    )?;
+    class.define_method(
+        "set_check_order_observe",
+        method!(RbOptFlags::set_check_order_observe, 1),
+    )?;
+    class.define_method(
+        "get_fast_projection",
+        method!(RbOptFlags::get_fast_projection, 0),
+    )?;
+    class.define_method(
+        "set_fast_projection",
+        method!(RbOptFlags::set_fast_projection, 1),
+    )?;
+    class.define_method("get_eager", method!(RbOptFlags::get_eager, 0))?;
+    class.define_method("set_eager", method!(RbOptFlags::set_eager, 1))?;
+    class.define_method("get_streaming", method!(RbOptFlags::get_streaming, 0))?;
+    class.define_method("set_streaming", method!(RbOptFlags::set_streaming, 1))?;
+
     Ok(())
 }

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

@@ -1,4 +1,4 @@
-use magnus::{IntoValue, RArray, TryConvert, Value, class, prelude::*, typed_data::Obj};
+use magnus::{IntoValue, RArray, Ruby, TryConvert, Value, prelude::*, typed_data::Obj};
 use polars::prelude::*;
 use polars_core::frame::row::{Row, rows_to_schema_first_non_null};
 use polars_core::series::SeriesIter;
@@ -25,32 +25,35 @@ pub fn apply_lambda_unknown<'a>(
     lambda: Value,
     inference_size: usize,
 ) -> RbResult<(Value, bool)> {
+    let ruby = Ruby::get_with(lambda);
     let mut null_count = 0;
     let mut iters = get_iters(df);
 
     for _ in 0..df.height() {
         let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
-        let arg = (RArray::from_iter(iter),);
+        let arg = (ruby.ary_from_iter(iter),);
         let out: Value = lambda.funcall("call", arg)?;
 
         if out.is_nil() {
             null_count += 1;
             continue;
-        } else if out.is_kind_of(class::true_class()) || out.is_kind_of(class::false_class()) {
+        } else if out.is_kind_of(ruby.class_true_class())
+            || out.is_kind_of(ruby.class_false_class())
+        {
             let first_value = bool::try_convert(out).ok();
             return Ok((
-                Obj::wrap(RbSeries::new(
+                ruby.obj_wrap(RbSeries::new(
                     apply_lambda_with_bool_out_type(df, lambda, null_count, first_value)
                         .into_series(),
                 ))
                 .as_value(),
                 false,
             ));
-        } else if out.is_kind_of(class::float()) {
+        } else if out.is_kind_of(ruby.class_float()) {
             let first_value = f64::try_convert(out).ok();
 
             return Ok((
-                Obj::wrap(RbSeries::new(
+                ruby.obj_wrap(RbSeries::new(
                     apply_lambda_with_primitive_out_type::<Float64Type>(
                         df,
                         lambda,
@@ -62,10 +65,10 @@ pub fn apply_lambda_unknown<'a>(
                 .as_value(),
                 false,
             ));
-        } else if out.is_kind_of(class::integer()) {
+        } else if out.is_kind_of(ruby.class_integer()) {
             let first_value = i64::try_convert(out).ok();
             return Ok((
-                Obj::wrap(RbSeries::new(
+                ruby.obj_wrap(RbSeries::new(
                     apply_lambda_with_primitive_out_type::<Int64Type>(
                         df,
                         lambda,
@@ -77,7 +80,7 @@ pub fn apply_lambda_unknown<'a>(
                 .as_value(),
                 false,
             ));
-        // } else if out.is_kind_of(class::string()) {
+        // } else if out.is_kind_of(ruby.class_string()) {
         //     let first_value = String::try_convert(out).ok();
         //     return Ok((
         //         RbSeries::new(
@@ -92,7 +95,7 @@ pub fn apply_lambda_unknown<'a>(
             let series = rb_rbseries.series.borrow();
             let dt = series.dtype();
             return Ok((
-                Obj::wrap(RbSeries::new(
+                ruby.obj_wrap(RbSeries::new(
                     apply_lambda_with_list_out_type(df, lambda, null_count, Some(&series), dt)?
                         .into_series(),
                 ))
@@ -102,7 +105,7 @@ pub fn apply_lambda_unknown<'a>(
         } else if Wrap::<Row<'a>>::try_convert(out).is_ok() {
             let first_value = Wrap::<Row<'a>>::try_convert(out).unwrap().0;
             return Ok((
-                Obj::wrap(RbDataFrame::from(
+                ruby.obj_wrap(RbDataFrame::from(
                     apply_lambda_with_rows_output(
                         df,
                         lambda,
@@ -115,7 +118,7 @@ pub fn apply_lambda_unknown<'a>(
                 .as_value(),
                 true,
             ));
-        } else if out.is_kind_of(class::array()) {
+        } else if out.is_kind_of(ruby.class_array()) {
             return Err(RbPolarsErr::Other(
                 "A list output type is invalid. Do you mean to create polars List Series?\
 Then return a Series object."
@@ -141,7 +144,7 @@ where
     let mut iters = get_iters_skip(df, init_null_count + skip);
     ((init_null_count + skip)..df.height()).map(move |_| {
         let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
-        let tpl = (RArray::from_iter(iter),);
+        let tpl = (Ruby::get_with(lambda).ary_from_iter(iter),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
             Ok(val) => T::try_convert(val).ok(),
             Err(e) => panic!("ruby function failed {e}"),
@@ -237,7 +240,7 @@ pub fn apply_lambda_with_list_out_type(
         let mut iters = get_iters_skip(df, init_null_count + skip);
         let iter = ((init_null_count + skip)..df.height()).map(|_| {
             let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
-            let tpl = (RArray::from_iter(iter),);
+            let tpl = (Ruby::get_with(lambda).ary_from_iter(iter),);
             match lambda.funcall::<_, _, Value>("call", tpl) {
                 Ok(val) => match val.funcall::<_, _, Value>("_s", ()) {
                     Ok(val) => Obj::<RbSeries>::try_convert(val)
@@ -281,7 +284,7 @@ pub fn apply_lambda_with_rows_output<'a>(
     let mut iters = get_iters_skip(df, init_null_count + skip);
     let mut row_iter = ((init_null_count + skip)..df.height()).map(|_| {
         let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
-        let tpl = (RArray::from_iter(iter),);
+        let tpl = (Ruby::get_with(lambda).ary_from_iter(iter),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
             Ok(val) => {
                 match RArray::try_convert(val).ok() {

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

@@ -1,17 +1,18 @@
-use magnus::{RArray, Value, prelude::*};
+use magnus::{Ruby, Value, prelude::*};
 use polars::prelude::*;
 
 use crate::rb_modules::*;
 use crate::{RbExpr, RbSeries, Wrap};
 
 fn to_series(v: Value, name: &str) -> PolarsResult<Series> {
+    let ruby = Ruby::get_with(v);
     let rb_rbseries = match v.funcall("_s", ()) {
         Ok(s) => s,
         // the lambda did not return a series, we try to create a new Ruby Series
         _ => {
-            let data = RArray::new();
+            let data = ruby.ary_new();
             data.push(v).unwrap();
-            let res = series().funcall::<_, _, Value>("new", (name.to_string(), data));
+            let res = pl_series().funcall::<_, _, Value>("new", (name.to_string(), data));
 
             match res {
                 Ok(ruby_s) => ruby_s.funcall::<_, _, &RbSeries>("_s", ()).unwrap(),
@@ -34,8 +35,8 @@ pub fn binary_lambda(lambda: Value, a: Series, b: Series) -> PolarsResult<Option
     let rbseries_b = RbSeries::new(b);
 
     // Wrap this RbSeries object in the Ruby side Series wrapper
-    let ruby_series_wrapper_a: Value = utils().funcall("wrap_s", (rbseries_a,)).unwrap();
-    let ruby_series_wrapper_b: Value = utils().funcall("wrap_s", (rbseries_b,)).unwrap();
+    let ruby_series_wrapper_a: Value = pl_utils().funcall("wrap_s", (rbseries_a,)).unwrap();
+    let ruby_series_wrapper_b: Value = pl_utils().funcall("wrap_s", (rbseries_b,)).unwrap();
 
     // call the lambda and get a Ruby side Series wrapper
     let result_series_wrapper: Value =

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

@@ -1,4 +1,4 @@
-use magnus::{IntoValue, TryConvert, Value, class, prelude::*, typed_data::Obj};
+use magnus::{IntoValue, Ruby, TryConvert, Value, prelude::*, typed_data::Obj};
 use polars::prelude::*;
 
 use super::*;
@@ -12,12 +12,13 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
     out: Value,
     null_count: usize,
 ) -> RbResult<RbSeries> {
-    if out.is_kind_of(class::true_class()) || out.is_kind_of(class::false_class()) {
+    let ruby = Ruby::get_with(lambda);
+    if out.is_kind_of(ruby.class_true_class()) || out.is_kind_of(ruby.class_false_class()) {
         let first_value = bool::try_convert(out).unwrap();
         applyer
             .apply_lambda_with_bool_out_type(lambda, null_count, Some(first_value))
             .map(|ca| ca.into_series().into())
-    } else if out.is_kind_of(class::float()) {
+    } else if out.is_kind_of(ruby.class_float()) {
         let first_value = f64::try_convert(out).unwrap();
         applyer
             .apply_lambda_with_primitive_out_type::<Float64Type>(
@@ -26,7 +27,7 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
                 Some(first_value),
             )
             .map(|ca| ca.into_series().into())
-    } else if out.is_kind_of(class::string()) {
+    } else if out.is_kind_of(ruby.class_string()) {
         let first_value = String::try_convert(out).unwrap();
         applyer
             .apply_lambda_with_utf8_out_type(lambda, null_count, Some(first_value.as_str()))
@@ -38,9 +39,9 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
         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()) {
+    } else if out.is_kind_of(ruby.class_array()) {
         todo!()
-    } else if out.is_kind_of(class::hash()) {
+    } else if out.is_kind_of(ruby.class_hash()) {
         let first = Wrap::<AnyValue<'_>>::try_convert(out)?;
         applyer.apply_into_struct(lambda, null_count, first.0)
     }

data/ext/polars/src/on_startup.rs

@@ -2,15 +2,23 @@ use std::any::Any;
 use std::sync::Arc;
 use std::sync::OnceLock;
 
-use magnus::IntoValue;
+use magnus::{IntoValue, Ruby, Value, prelude::*};
 use polars::prelude::*;
 use polars_core::chunked_array::object::builder::ObjectChunkedBuilder;
 use polars_core::chunked_array::object::registry;
 use polars_core::chunked_array::object::registry::AnonymousObjectBuilder;
 use polars_core::prelude::AnyValue;
+use polars_error::PolarsWarning;
 
 use crate::Wrap;
 use crate::prelude::ObjectValue;
+use crate::rb_modules::pl_utils;
+
+fn warning_function(msg: &str, _warning: PolarsWarning) {
+    if let Err(e) = pl_utils().funcall::<_, _, Value>("_polars_warn", (msg.to_string(),)) {
+        eprintln!("{e}")
+    }
+}
 
 static POLARS_REGISTRY_INIT_LOCK: OnceLock<()> = OnceLock::new();
 
@@ -23,12 +31,12 @@ pub(crate) fn register_startup_deps() {
 
         let object_converter = Arc::new(|av: AnyValue| {
             let object = ObjectValue {
-                inner: Wrap(av).into_value().into(),
+                inner: Wrap(av).into_value_with(&Ruby::get().unwrap()).into(),
             };
             Box::new(object) as Box<dyn Any>
         });
         let rbobject_converter = Arc::new(|av: AnyValue| {
-            let object = Wrap(av).into_value();
+            let object = Wrap(av).into_value_with(&Ruby::get().unwrap());
             Box::new(object) as Box<dyn Any>
         });
 
@@ -40,8 +48,7 @@ pub(crate) fn register_startup_deps() {
             rbobject_converter,
             physical_dtype,
         );
-        // TODO
         // Register warning function for `polars_warn!`.
-        // polars_error::set_warning_function(warning_function);
+        polars_error::set_warning_function(warning_function);
     });
 }

data/ext/polars/src/rb_modules.rs

@@ -9,13 +9,13 @@ pub(crate) fn polars() -> RModule {
 static SERIES: Lazy<RClass> =
     Lazy::new(|ruby| ruby.get_inner(&POLARS).const_get("Series").unwrap());
 
-pub(crate) fn series() -> RClass {
+pub(crate) fn pl_series() -> RClass {
     Ruby::get().unwrap().get_inner(&SERIES)
 }
 
 static UTILS: Lazy<RModule> = Lazy::new(|ruby| ruby.get_inner(&POLARS).const_get("Utils").unwrap());
 
-pub(crate) fn utils() -> RModule {
+pub(crate) fn pl_utils() -> RModule {
     Ruby::get().unwrap().get_inner(&UTILS)
 }