polars-df 0.2.5 → 0.3.0

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

@@ -1,5 +1,5 @@
 use magnus::block::Proc;
-use magnus::{class, RArray, RString, Value};
+use magnus::{class, IntoValue, RArray, RString, Value};
 use polars::chunked_array::ops::SortOptions;
 use polars::lazy::dsl;
 use polars::lazy::dsl::Operator;
@@ -214,6 +214,7 @@ impl RbExpr {
             .sort_with(SortOptions {
                 descending,
                 nulls_last,
+                multithreaded: true,
             })
             .into()
     }
@@ -224,6 +225,7 @@ impl RbExpr {
             .arg_sort(SortOptions {
                 descending: reverse,
                 nulls_last,
+                multithreaded: true,
             })
             .into()
     }
@@ -240,10 +242,10 @@ impl RbExpr {
         self.clone().inner.arg_min().into()
     }
 
-    pub fn search_sorted(&self, element: &RbExpr) -> Self {
+    pub fn search_sorted(&self, element: &RbExpr, side: Wrap<SearchSortedSide>) -> Self {
         self.inner
             .clone()
-            .search_sorted(element.inner.clone())
+            .search_sorted(element.inner.clone(), side.0)
             .into()
     }
 
@@ -287,7 +289,10 @@ impl RbExpr {
         Ok(self
             .inner
             .clone()
-            .apply(move |s| s.fill_null(strat), GetOutput::same_type())
+            .apply(
+                move |s| s.fill_null(strat).map(Some),
+                GetOutput::same_type(),
+            )
             .with_fmt("fill_null_with_strategy")
             .into())
     }
@@ -335,7 +340,10 @@ impl RbExpr {
     pub fn take_every(&self, n: usize) -> Self {
         self.clone()
             .inner
-            .map(move |s: Series| Ok(s.take_every(n)), GetOutput::same_type())
+            .map(
+                move |s: Series| Ok(Some(s.take_every(n))),
+                GetOutput::same_type(),
+            )
             .with_fmt("take_every")
             .into()
     }
@@ -365,7 +373,7 @@ impl RbExpr {
     pub fn rechunk(&self) -> Self {
         self.inner
             .clone()
-            .map(|s| Ok(s.rechunk()), GetOutput::same_type())
+            .map(|s| Ok(Some(s.rechunk())), GetOutput::same_type())
             .into()
     }
 
@@ -527,6 +535,7 @@ impl RbExpr {
                 exact,
                 cache,
                 tz_aware: false,
+                utc: false,
             })
             .into()
     }
@@ -538,6 +547,7 @@ impl RbExpr {
         exact: bool,
         cache: bool,
         tz_aware: bool,
+        utc: bool,
     ) -> Self {
         let tu = match fmt {
             Some(ref fmt) => {
@@ -565,6 +575,7 @@ impl RbExpr {
                 exact,
                 cache,
                 tz_aware,
+                utc,
             })
             .into()
     }
@@ -586,26 +597,27 @@ impl RbExpr {
                 exact,
                 cache,
                 tz_aware: false,
+                utc: false,
             })
             .into()
     }
 
-    pub fn str_strip(&self, matches: Option<char>) -> Self {
+    pub fn str_strip(&self, matches: Option<String>) -> Self {
         self.inner.clone().str().strip(matches).into()
     }
 
-    pub fn str_rstrip(&self, matches: Option<char>) -> Self {
+    pub fn str_rstrip(&self, matches: Option<String>) -> Self {
         self.inner.clone().str().rstrip(matches).into()
     }
 
-    pub fn str_lstrip(&self, matches: Option<char>) -> Self {
+    pub fn str_lstrip(&self, matches: Option<String>) -> Self {
         self.inner.clone().str().lstrip(matches).into()
     }
 
     pub fn str_slice(&self, start: i64, length: Option<u64>) -> Self {
         let function = move |s: Series| {
             let ca = s.utf8()?;
-            Ok(ca.str_slice(start, length)?.into_series())
+            Ok(Some(ca.str_slice(start, length)?.into_series()))
         };
         self.clone()
             .inner
@@ -625,7 +637,7 @@ impl RbExpr {
     pub fn str_lengths(&self) -> Self {
         let function = |s: Series| {
             let ca = s.utf8()?;
-            Ok(ca.str_lengths().into_series())
+            Ok(Some(ca.str_lengths().into_series()))
         };
         self.clone()
             .inner
@@ -637,7 +649,7 @@ impl RbExpr {
     pub fn str_n_chars(&self) -> Self {
         let function = |s: Series| {
             let ca = s.utf8()?;
-            Ok(ca.str_n_chars().into_series())
+            Ok(Some(ca.str_n_chars().into_series()))
         };
         self.clone()
             .inner
@@ -674,37 +686,51 @@ impl RbExpr {
         self.clone().inner.str().rjust(width, fillchar).into()
     }
 
-    pub fn str_contains(&self, pat: String, literal: Option<bool>) -> Self {
+    pub fn str_contains(&self, pat: &RbExpr, literal: Option<bool>, strict: bool) -> Self {
         match literal {
-            Some(true) => self.inner.clone().str().contains_literal(pat).into(),
-            _ => self.inner.clone().str().contains(pat).into(),
+            Some(true) => self
+                .inner
+                .clone()
+                .str()
+                .contains_literal(pat.inner.clone())
+                .into(),
+            _ => self
+                .inner
+                .clone()
+                .str()
+                .contains(pat.inner.clone(), strict)
+                .into(),
         }
     }
 
-    pub fn str_ends_with(&self, sub: String) -> Self {
-        self.inner.clone().str().ends_with(sub).into()
+    pub fn str_ends_with(&self, sub: &RbExpr) -> Self {
+        self.inner.clone().str().ends_with(sub.inner.clone()).into()
     }
 
-    pub fn str_starts_with(&self, sub: String) -> Self {
-        self.inner.clone().str().starts_with(sub).into()
+    pub fn str_starts_with(&self, sub: &RbExpr) -> Self {
+        self.inner
+            .clone()
+            .str()
+            .starts_with(sub.inner.clone())
+            .into()
     }
 
     pub fn str_hex_encode(&self) -> Self {
         self.clone()
             .inner
             .map(
-                move |s| s.utf8().map(|s| s.hex_encode().into_series()),
+                move |s| s.utf8().map(|s| Some(s.hex_encode().into_series())),
                 GetOutput::same_type(),
             )
             .with_fmt("str.hex_encode")
             .into()
     }
 
-    pub fn str_hex_decode(&self, strict: Option<bool>) -> Self {
+    pub fn str_hex_decode(&self, strict: bool) -> Self {
         self.clone()
             .inner
             .map(
-                move |s| s.utf8()?.hex_decode(strict).map(|s| s.into_series()),
+                move |s| s.utf8()?.hex_decode(strict).map(|s| Some(s.into_series())),
                 GetOutput::same_type(),
             )
             .with_fmt("str.hex_decode")
@@ -715,18 +741,22 @@ impl RbExpr {
         self.clone()
             .inner
             .map(
-                move |s| s.utf8().map(|s| s.base64_encode().into_series()),
+                move |s| s.utf8().map(|s| Some(s.base64_encode().into_series())),
                 GetOutput::same_type(),
             )
             .with_fmt("str.base64_encode")
             .into()
     }
 
-    pub fn str_base64_decode(&self, strict: Option<bool>) -> Self {
+    pub fn str_base64_decode(&self, strict: bool) -> Self {
         self.clone()
             .inner
             .map(
-                move |s| s.utf8()?.base64_decode(strict).map(|s| s.into_series()),
+                move |s| {
+                    s.utf8()?
+                        .base64_decode(strict)
+                        .map(|s| Some(s.into_series()))
+                },
                 GetOutput::same_type(),
             )
             .with_fmt("str.base64_decode")
@@ -737,7 +767,7 @@ impl RbExpr {
         let function = move |s: Series| {
             let ca = s.utf8()?;
             match ca.json_path_match(&pat) {
-                Ok(ca) => Ok(ca.into_series()),
+                Ok(ca) => Ok(Some(ca.into_series())),
                 Err(e) => Err(PolarsError::ComputeError(format!("{:?}", e).into())),
             }
         };
@@ -864,7 +894,7 @@ impl RbExpr {
         self.inner
             .clone()
             .map(
-                |s| Ok(s.duration()?.days().into_series()),
+                |s| Ok(Some(s.duration()?.days().into_series())),
                 GetOutput::from_type(DataType::Int64),
             )
             .into()
@@ -874,7 +904,7 @@ impl RbExpr {
         self.inner
             .clone()
             .map(
-                |s| Ok(s.duration()?.hours().into_series()),
+                |s| Ok(Some(s.duration()?.hours().into_series())),
                 GetOutput::from_type(DataType::Int64),
             )
             .into()
@@ -884,7 +914,7 @@ impl RbExpr {
         self.inner
             .clone()
             .map(
-                |s| Ok(s.duration()?.minutes().into_series()),
+                |s| Ok(Some(s.duration()?.minutes().into_series())),
                 GetOutput::from_type(DataType::Int64),
             )
             .into()
@@ -894,7 +924,7 @@ impl RbExpr {
         self.inner
             .clone()
             .map(
-                |s| Ok(s.duration()?.seconds().into_series()),
+                |s| Ok(Some(s.duration()?.seconds().into_series())),
                 GetOutput::from_type(DataType::Int64),
             )
             .into()
@@ -904,7 +934,7 @@ impl RbExpr {
         self.inner
             .clone()
             .map(
-                |s| Ok(s.duration()?.nanoseconds().into_series()),
+                |s| Ok(Some(s.duration()?.nanoseconds().into_series())),
                 GetOutput::from_type(DataType::Int64),
             )
             .into()
@@ -914,7 +944,7 @@ impl RbExpr {
         self.inner
             .clone()
             .map(
-                |s| Ok(s.duration()?.microseconds().into_series()),
+                |s| Ok(Some(s.duration()?.microseconds().into_series())),
                 GetOutput::from_type(DataType::Int64),
             )
             .into()
@@ -924,7 +954,7 @@ impl RbExpr {
         self.inner
             .clone()
             .map(
-                |s| Ok(s.duration()?.milliseconds().into_series()),
+                |s| Ok(Some(s.duration()?.milliseconds().into_series())),
                 GetOutput::from_type(DataType::Int64),
             )
             .into()
@@ -945,7 +975,7 @@ impl RbExpr {
             .map(
                 |s| {
                     s.timestamp(TimeUnit::Milliseconds)
-                        .map(|ca| (ca / 1000).into_series())
+                        .map(|ca| Some((ca / 1000).into_series()))
                 },
                 GetOutput::from_type(DataType::Int64),
             )
@@ -956,18 +986,19 @@ impl RbExpr {
         self.inner.clone().dt().with_time_unit(tu.0).into()
     }
 
-    pub fn dt_with_time_zone(&self, tz: Option<TimeZone>) -> Self {
-        self.inner.clone().dt().with_time_zone(tz).into()
+    pub fn dt_convert_time_zone(&self, tz: TimeZone) -> Self {
+        self.inner.clone().dt().convert_time_zone(tz).into()
     }
 
     pub fn dt_cast_time_unit(&self, tu: Wrap<TimeUnit>) -> Self {
         self.inner.clone().dt().cast_time_unit(tu.0).into()
     }
 
-    pub fn dt_cast_time_zone(&self, tz: String) -> Self {
-        self.inner.clone().dt().cast_time_zone(tz).into()
+    pub fn dt_replace_time_zone(&self, tz: Option<String>) -> Self {
+        self.inner.clone().dt().replace_time_zone(tz).into()
     }
 
+    #[allow(deprecated)]
     pub fn dt_tz_localize(&self, tz: String) -> Self {
         self.inner.clone().dt().tz_localize(tz).into()
     }
@@ -989,7 +1020,7 @@ impl RbExpr {
     }
 
     pub fn reinterpret(&self, signed: bool) -> Self {
-        let function = move |s: Series| reinterpret(&s, signed);
+        let function = move |s: Series| reinterpret(&s, signed).map(Some);
         let dt = if signed {
             DataType::Int64
         } else {
@@ -1391,7 +1422,7 @@ impl RbExpr {
         self.inner
             .clone()
             .map(
-                |s| Ok(s.to_physical_repr().into_owned()),
+                |s| Ok(Some(s.to_physical_repr().into_owned())),
                 GetOutput::map_dtype(|dt| dt.to_physical()),
             )
             .with_fmt("to_physical")
@@ -1428,44 +1459,67 @@ impl RbExpr {
             .into()
     }
 
-    pub fn ewm_mean(&self, alpha: f64, adjust: bool, min_periods: usize) -> Self {
+    pub fn ewm_mean(
+        &self,
+        alpha: f64,
+        adjust: bool,
+        min_periods: usize,
+        ignore_nulls: bool,
+    ) -> Self {
         let options = EWMOptions {
             alpha,
             adjust,
             bias: false,
             min_periods,
+            ignore_nulls,
         };
         self.inner.clone().ewm_mean(options).into()
     }
 
-    pub fn ewm_std(&self, alpha: f64, adjust: bool, bias: bool, min_periods: usize) -> Self {
+    pub fn ewm_std(
+        &self,
+        alpha: f64,
+        adjust: bool,
+        bias: bool,
+        min_periods: usize,
+        ignore_nulls: bool,
+    ) -> Self {
         let options = EWMOptions {
             alpha,
             adjust,
             bias,
             min_periods,
+            ignore_nulls,
         };
         self.inner.clone().ewm_std(options).into()
     }
 
-    pub fn ewm_var(&self, alpha: f64, adjust: bool, bias: bool, min_periods: usize) -> Self {
+    pub fn ewm_var(
+        &self,
+        alpha: f64,
+        adjust: bool,
+        bias: bool,
+        min_periods: usize,
+        ignore_nulls: bool,
+    ) -> Self {
         let options = EWMOptions {
             alpha,
             adjust,
             bias,
             min_periods,
+            ignore_nulls,
         };
         self.inner.clone().ewm_var(options).into()
     }
 
     pub fn extend_constant(&self, value: Wrap<AnyValue>, n: usize) -> Self {
-        let value = Value::from(value);
+        let value = value.into_value();
         self.inner
             .clone()
             .apply(
                 move |s| {
                     let value = value.try_convert::<Wrap<AnyValue>>().unwrap().0;
-                    s.extend_constant(value, n)
+                    s.extend_constant(value, n).map(Some)
                 },
                 GetOutput::same_type(),
             )

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

@@ -1,14 +1,15 @@
-use crate::{RbExpr, RbPolarsErr, RbResult};
+use crate::{RArray, RbExpr, RbPolarsErr, RbResult};
 
 impl RbExpr {
-    pub fn meta_pop(&self) -> Vec<RbExpr> {
-        self.inner
-            .clone()
-            .meta()
-            .pop()
-            .into_iter()
-            .map(RbExpr::from)
-            .collect()
+    pub fn meta_pop(&self) -> RArray {
+        RArray::from_iter(
+            self.inner
+                .clone()
+                .meta()
+                .pop()
+                .into_iter()
+                .map(RbExpr::from),
+        )
     }
 
     pub fn meta_eq(&self, other: &RbExpr) -> bool {

data/ext/polars/src/lib.rs

@@ -21,7 +21,7 @@ use file::get_file_like;
 use lazy::dataframe::{RbLazyFrame, RbLazyGroupBy};
 use lazy::dsl::{RbExpr, RbWhen, RbWhenThen};
 use lazy::utils::rb_exprs_to_exprs;
-use magnus::{define_module, function, method, prelude::*, Error, RArray, RHash, Value};
+use magnus::{define_module, function, method, prelude::*, Error, IntoValue, RArray, RHash, Value};
 use polars::datatypes::{DataType, TimeUnit, IDX_DTYPE};
 use polars::error::PolarsResult;
 use polars::frame::DataFrame;
@@ -146,7 +146,7 @@ fn init() -> RbResult<()> {
     class.define_method("with_row_count", method!(RbDataFrame::with_row_count, 2))?;
     class.define_method("_clone", method!(RbDataFrame::clone, 0))?;
     class.define_method("melt", method!(RbDataFrame::melt, 4))?;
-    class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 6))?;
+    class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 2))?;
     class.define_method("shift", method!(RbDataFrame::shift, 1))?;
     class.define_method("unique", method!(RbDataFrame::unique, 3))?;
@@ -163,7 +163,7 @@ fn init() -> RbResult<()> {
     class.define_method("hmin", method!(RbDataFrame::hmin, 0))?;
     class.define_method("hsum", method!(RbDataFrame::hsum, 1))?;
     class.define_method("quantile", method!(RbDataFrame::quantile, 2))?;
-    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 1))?;
+    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 2))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
     class.define_method("apply", method!(RbDataFrame::apply, 3))?;
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
@@ -221,7 +221,7 @@ fn init() -> RbResult<()> {
     class.define_method("top_k", method!(RbExpr::top_k, 2))?;
     class.define_method("arg_max", method!(RbExpr::arg_max, 0))?;
     class.define_method("arg_min", method!(RbExpr::arg_min, 0))?;
-    class.define_method("search_sorted", method!(RbExpr::search_sorted, 1))?;
+    class.define_method("search_sorted", method!(RbExpr::search_sorted, 2))?;
     class.define_method("take", method!(RbExpr::take, 1))?;
     class.define_method("sort_by", method!(RbExpr::sort_by, 2))?;
     class.define_method("backward_fill", method!(RbExpr::backward_fill, 1))?;
@@ -284,7 +284,7 @@ fn init() -> RbResult<()> {
     class.define_method("product", method!(RbExpr::product, 0))?;
     class.define_method("shrink_dtype", method!(RbExpr::shrink_dtype, 0))?;
     class.define_method("str_parse_date", method!(RbExpr::str_parse_date, 4))?;
-    class.define_method("str_parse_datetime", method!(RbExpr::str_parse_datetime, 5))?;
+    class.define_method("str_parse_datetime", method!(RbExpr::str_parse_datetime, 6))?;
     class.define_method("str_parse_time", method!(RbExpr::str_parse_time, 4))?;
     class.define_method("str_strip", method!(RbExpr::str_strip, 1))?;
     class.define_method("str_rstrip", method!(RbExpr::str_rstrip, 1))?;
@@ -299,7 +299,7 @@ fn init() -> RbResult<()> {
     class.define_method("str_zfill", method!(RbExpr::str_zfill, 1))?;
     class.define_method("str_ljust", method!(RbExpr::str_ljust, 2))?;
     class.define_method("str_rjust", method!(RbExpr::str_rjust, 2))?;
-    class.define_method("str_contains", method!(RbExpr::str_contains, 2))?;
+    class.define_method("str_contains", method!(RbExpr::str_contains, 3))?;
     class.define_method("str_ends_with", method!(RbExpr::str_ends_with, 1))?;
     class.define_method("str_starts_with", method!(RbExpr::str_starts_with, 1))?;
     class.define_method("str_hex_encode", method!(RbExpr::str_hex_encode, 0))?;
@@ -361,9 +361,15 @@ fn init() -> RbResult<()> {
     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_with_time_zone", method!(RbExpr::dt_with_time_zone, 1))?;
+    class.define_method(
+        "dt_convert_time_zone",
+        method!(RbExpr::dt_convert_time_zone, 1),
+    )?;
     class.define_method("dt_cast_time_unit", method!(RbExpr::dt_cast_time_unit, 1))?;
-    class.define_method("dt_cast_time_zone", method!(RbExpr::dt_cast_time_zone, 1))?;
+    class.define_method(
+        "dt_replace_time_zone",
+        method!(RbExpr::dt_replace_time_zone, 1),
+    )?;
     class.define_method("dt_tz_localize", method!(RbExpr::dt_tz_localize, 1))?;
     class.define_method("dt_truncate", method!(RbExpr::dt_truncate, 2))?;
     class.define_method("dt_round", method!(RbExpr::dt_round, 2))?;
@@ -418,9 +424,9 @@ fn init() -> RbResult<()> {
     class.define_method("shuffle", method!(RbExpr::shuffle, 1))?;
     class.define_method("sample_n", method!(RbExpr::sample_n, 4))?;
     class.define_method("sample_frac", method!(RbExpr::sample_frac, 4))?;
-    class.define_method("ewm_mean", method!(RbExpr::ewm_mean, 3))?;
-    class.define_method("ewm_std", method!(RbExpr::ewm_std, 4))?;
-    class.define_method("ewm_var", method!(RbExpr::ewm_var, 4))?;
+    class.define_method("ewm_mean", method!(RbExpr::ewm_mean, 4))?;
+    class.define_method("ewm_std", method!(RbExpr::ewm_std, 5))?;
+    class.define_method("ewm_var", method!(RbExpr::ewm_var, 5))?;
     class.define_method("extend_constant", method!(RbExpr::extend_constant, 2))?;
     class.define_method("any", method!(RbExpr::any, 0))?;
     class.define_method("all", method!(RbExpr::all, 0))?;
@@ -613,7 +619,7 @@ fn init() -> RbResult<()> {
     class.define_method("_clone", method!(RbSeries::clone, 0))?;
     class.define_method("apply_lambda", method!(RbSeries::apply_lambda, 3))?;
     class.define_method("zip_with", method!(RbSeries::zip_with, 2))?;
-    class.define_method("to_dummies", method!(RbSeries::to_dummies, 0))?;
+    class.define_method("to_dummies", method!(RbSeries::to_dummies, 1))?;
     class.define_method("peak_max", method!(RbSeries::peak_max, 0))?;
     class.define_method("peak_min", method!(RbSeries::peak_min, 0))?;
     class.define_method("n_unique", method!(RbSeries::n_unique, 0))?;
@@ -922,23 +928,16 @@ fn parquet_schema(rb_f: Value) -> RbResult<Value> {
     Ok(dict.into())
 }
 
-fn collect_all(lfs: RArray) -> RbResult<Vec<RbDataFrame>> {
-    use polars_core::utils::rayon::prelude::*;
-
+fn collect_all(lfs: RArray) -> RbResult<RArray> {
     let lfs = lfs
         .each()
         .map(|v| v?.try_convert::<&RbLazyFrame>())
         .collect::<RbResult<Vec<&RbLazyFrame>>>()?;
 
-    polars_core::POOL.install(|| {
-        lfs.par_iter()
-            .map(|lf| {
-                let df = lf.ldf.clone().collect()?;
-                Ok(RbDataFrame::new(df))
-            })
-            .collect::<polars_core::error::PolarsResult<Vec<_>>>()
-            .map_err(RbPolarsErr::from)
-    })
+    Ok(RArray::from_iter(lfs.iter().map(|lf| {
+        let df = lf.ldf.clone().collect().unwrap();
+        RbDataFrame::new(df)
+    })))
 }
 
 fn rb_date_range(
@@ -949,8 +948,8 @@ fn rb_date_range(
     name: String,
     tu: Wrap<TimeUnit>,
     tz: Option<TimeZone>,
-) -> RbSeries {
-    polars::time::date_range_impl(
+) -> RbResult<RbSeries> {
+    let date_range = polars::time::date_range_impl(
         &name,
         start,
         stop,
@@ -959,8 +958,8 @@ fn rb_date_range(
         tu.0,
         tz.as_ref(),
     )
-    .into_series()
-    .into()
+    .map_err(RbPolarsErr::from)?;
+    Ok(date_range.into_series().into())
 }
 
 fn coalesce_exprs(exprs: RArray) -> RbResult<RbExpr> {
@@ -983,5 +982,5 @@ fn arg_where(condition: &RbExpr) -> RbExpr {
 }
 
 fn get_idx_type() -> Value {
-    Wrap(IDX_DTYPE).into()
+    Wrap(IDX_DTYPE).into_value()
 }

data/ext/polars/src/object.rs

@@ -1,6 +1,7 @@
 use std::any::Any;
 use std::sync::Arc;
 
+use magnus::IntoValue;
 use polars_core::chunked_array::object::builder::ObjectChunkedBuilder;
 use polars_core::chunked_array::object::registry;
 use polars_core::chunked_array::object::registry::AnonymousObjectBuilder;
@@ -20,7 +21,7 @@ pub(crate) fn register_object_builder() {
 
         let object_converter = Arc::new(|av: AnyValue| {
             let object = ObjectValue {
-                inner: Wrap(av).into(),
+                inner: Wrap(av).into_value(),
             };
             Box::new(object) as Box<dyn Any>
         });