polars-df 0.6.0 → 0.8.0

data/ext/polars/src/{apply → map}/dataframe.rs

@@ -1,4 +1,4 @@
-use magnus::{class, IntoValue, RArray, TryConvert, Value};
+use magnus::{class, prelude::*, typed_data::Obj, IntoValue, RArray, TryConvert, Value};
 use polars::prelude::*;
 use polars_core::frame::row::{rows_to_schema_first_non_null, Row};
 use polars_core::series::SeriesIter;
@@ -34,20 +34,20 @@ pub fn apply_lambda_unknown<'a>(
             null_count += 1;
             continue;
         } else if out.is_kind_of(class::true_class()) || out.is_kind_of(class::false_class()) {
-            let first_value = out.try_convert::<bool>().ok();
+            let first_value = bool::try_convert(out).ok();
             return Ok((
-                RbSeries::new(
+                Obj::wrap(RbSeries::new(
                     apply_lambda_with_bool_out_type(df, lambda, null_count, first_value)
                         .into_series(),
-                )
-                .into(),
+                ))
+                .as_value(),
                 false,
             ));
         } else if out.is_kind_of(class::float()) {
-            let first_value = out.try_convert::<f64>().ok();
+            let first_value = f64::try_convert(out).ok();
 
             return Ok((
-                RbSeries::new(
+                Obj::wrap(RbSeries::new(
                     apply_lambda_with_primitive_out_type::<Float64Type>(
                         df,
                         lambda,
@@ -55,14 +55,14 @@ pub fn apply_lambda_unknown<'a>(
                         first_value,
                     )
                     .into_series(),
-                )
-                .into(),
+                ))
+                .as_value(),
                 false,
             ));
         } else if out.is_kind_of(class::integer()) {
-            let first_value = out.try_convert::<i64>().ok();
+            let first_value = i64::try_convert(out).ok();
             return Ok((
-                RbSeries::new(
+                Obj::wrap(RbSeries::new(
                     apply_lambda_with_primitive_out_type::<Int64Type>(
                         df,
                         lambda,
@@ -70,12 +70,12 @@ pub fn apply_lambda_unknown<'a>(
                         first_value,
                     )
                     .into_series(),
-                )
-                .into(),
+                ))
+                .as_value(),
                 false,
             ));
         // } else if out.is_kind_of(class::string()) {
-        //     let first_value = out.try_convert::<String>().ok();
+        //     let first_value = String::try_convert(out).ok();
         //     return Ok((
         //         RbSeries::new(
         //             apply_lambda_with_utf8_out_type(df, lambda, null_count, first_value)
@@ -85,25 +85,21 @@ pub fn apply_lambda_unknown<'a>(
         //         false,
         //     ));
         } else if out.respond_to("_s", true)? {
-            let rb_rbseries: Value = out.funcall("_s", ()).unwrap();
-            let series = rb_rbseries
-                .try_convert::<&RbSeries>()
-                .unwrap()
-                .series
-                .borrow();
+            let rb_rbseries: Obj<RbSeries> = out.funcall("_s", ()).unwrap();
+            let series = rb_rbseries.series.borrow();
             let dt = series.dtype();
             return Ok((
-                RbSeries::new(
+                Obj::wrap(RbSeries::new(
                     apply_lambda_with_list_out_type(df, lambda, null_count, Some(&series), dt)?
                         .into_series(),
-                )
-                .into(),
+                ))
+                .as_value(),
                 false,
             ));
-        } else if out.try_convert::<Wrap<Row<'a>>>().is_ok() {
-            let first_value = out.try_convert::<Wrap<Row<'a>>>().unwrap().0;
+        } else if Wrap::<Row<'a>>::try_convert(out).is_ok() {
+            let first_value = Wrap::<Row<'a>>::try_convert(out).unwrap().0;
             return Ok((
-                RbDataFrame::from(
+                Obj::wrap(RbDataFrame::from(
                     apply_lambda_with_rows_output(
                         df,
                         lambda,
@@ -112,8 +108,8 @@ pub fn apply_lambda_unknown<'a>(
                         inference_size,
                     )
                     .map_err(RbPolarsErr::from)?,
-                )
-                .into(),
+                ))
+                .as_value(),
                 true,
             ));
         } else if out.is_kind_of(class::array()) {
@@ -143,7 +139,7 @@ where
         let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
         let tpl = (RArray::from_iter(iter),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
-            Ok(val) => val.try_convert::<T>().ok(),
+            Ok(val) => T::try_convert(val).ok(),
             Err(e) => panic!("ruby function failed {}", e),
         }
     })
@@ -191,7 +187,7 @@ pub fn apply_lambda_with_utf8_out_type(
     lambda: Value,
     init_null_count: usize,
     first_value: Option<&str>,
-) -> Utf8Chunked {
+) -> StringChunked {
     let skip = usize::from(first_value.is_some());
     if init_null_count == df.height() {
         ChunkedArray::full_null("apply", df.height())
@@ -219,8 +215,7 @@ pub fn apply_lambda_with_list_out_type(
             let tpl = (RArray::from_iter(iter),);
             match lambda.funcall::<_, _, Value>("call", tpl) {
                 Ok(val) => match val.funcall::<_, _, Value>("_s", ()) {
-                    Ok(val) => val
-                        .try_convert::<&RbSeries>()
+                    Ok(val) => Obj::<RbSeries>::try_convert(val)
                         .ok()
                         .map(|ps| ps.series.borrow().clone()),
                     Err(_) => {
@@ -257,11 +252,11 @@ pub fn apply_lambda_with_rows_output<'a>(
         let tpl = (RArray::from_iter(iter),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
             Ok(val) => {
-                match val.try_convert::<RArray>().ok() {
+                match RArray::try_convert(val).ok() {
                     Some(tuple) => {
                         row_buf.0.clear();
                         for v in tuple.each() {
-                            let v = v.unwrap().try_convert::<Wrap<AnyValue>>().unwrap().0;
+                            let v = Wrap::<AnyValue>::try_convert(v.unwrap()).unwrap().0;
                             row_buf.0.push(v);
                         }
                         let ptr = &row_buf as *const Row;

data/ext/polars/src/{apply → map}/mod.rs

@@ -2,7 +2,7 @@ pub mod dataframe;
 pub mod lazy;
 pub mod series;
 
-use magnus::{RHash, Value};
+use magnus::{prelude::*, RHash, Value};
 use polars::chunked_array::builder::get_list_builder;
 use polars::prelude::*;
 use polars_core::export::rayon::prelude::*;
@@ -68,7 +68,7 @@ fn iterator_to_struct(
                 }
             }
             Some(dict) => {
-                let dict = dict.try_convert::<RHash>()?;
+                let dict = RHash::try_convert(dict)?;
                 if dict.len() != struct_width {
                     return Err(crate::error::ComputeError::new_err(
                         format!("Cannot create struct type.\n> The struct dtype expects {} fields, but it got a dict with {} fields.", struct_width, dict.len())
@@ -78,7 +78,7 @@ fn iterator_to_struct(
                 // the first item determines the output name
                 todo!()
                 // for ((_, val), field_items) in dict.iter().zip(&mut items) {
-                //     let item = val.try_convert::<Wrap<AnyValue>>()?;
+                //     let item = Wrap::<AnyValue>::try_convert(val)?;
                 //     field_items.push(item.0)
                 // }
             }
@@ -198,11 +198,11 @@ fn iterator_to_utf8(
     first_value: Option<&str>,
     name: &str,
     capacity: usize,
-) -> Utf8Chunked {
+) -> StringChunked {
     let first_value = first_value.map(|v| v.to_string());
 
     // safety: we know the iterators len
-    let mut ca: Utf8Chunked = unsafe {
+    let mut ca: StringChunked = unsafe {
         if init_null_count > 0 {
             (0..init_null_count)
                 .map(|_| None)

data/ext/polars/src/{apply → map}/series.rs

@@ -1,4 +1,4 @@
-use magnus::{class, IntoValue, RHash, TryConvert, Value};
+use magnus::{class, prelude::*, typed_data::Obj, IntoValue, RHash, TryConvert, Value};
 use polars::prelude::*;
 
 use super::*;
@@ -14,12 +14,12 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
     null_count: usize,
 ) -> RbResult<RbSeries> {
     if out.is_kind_of(class::true_class()) || out.is_kind_of(class::false_class()) {
-        let first_value = out.try_convert::<bool>().unwrap();
+        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()) {
-        let first_value = out.try_convert::<f64>().unwrap();
+        let first_value = f64::try_convert(out).unwrap();
         applyer
             .apply_lambda_with_primitive_out_type::<Float64Type>(
                 lambda,
@@ -28,7 +28,7 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
             )
             .map(|ca| ca.into_series().into())
     } else if out.is_kind_of(class::string()) {
-        let first_value = out.try_convert::<String>().unwrap();
+        let first_value = String::try_convert(out).unwrap();
         applyer
             .apply_lambda_with_utf8_out_type(lambda, null_count, Some(first_value.as_str()))
             .map(|ca| ca.into_series().into())
@@ -37,13 +37,13 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
     } else if out.is_kind_of(class::array()) {
         todo!()
     } else if out.is_kind_of(class::hash()) {
-        let first = out.try_convert::<Wrap<AnyValue<'_>>>()?;
+        let first = Wrap::<AnyValue<'_>>::try_convert(out)?;
         applyer.apply_to_struct(lambda, null_count, first.0)
     }
     // this succeeds for numpy ints as well, where checking if it is pyint fails
     // we do this later in the chain so that we don't extract integers from string chars.
-    else if out.try_convert::<i64>().is_ok() {
-        let first_value = out.try_convert::<i64>().unwrap();
+    else if i64::try_convert(out).is_ok() {
+        let first_value = i64::try_convert(out).unwrap();
         applyer
             .apply_lambda_with_primitive_out_type::<Int64Type>(
                 lambda,
@@ -51,7 +51,7 @@ fn infer_and_finish<'a, A: ApplyLambda<'a>>(
                 Some(first_value),
             )
             .map(|ca| ca.into_series().into())
-    } else if let Ok(av) = out.try_convert::<Wrap<AnyValue>>() {
+    } else if let Ok(av) = Wrap::<AnyValue>::try_convert(out) {
         applyer
             .apply_extract_any_values(lambda, null_count, av.0)
             .map(|s| s.into())
@@ -101,7 +101,7 @@ pub trait ApplyLambda<'a> {
         lambda: Value,
         init_null_count: usize,
         first_value: Option<&str>,
-    ) -> RbResult<Utf8Chunked>;
+    ) -> RbResult<StringChunked>;
 
     /// Apply a lambda with list output type
     fn apply_lambda_with_list_out_type(
@@ -141,7 +141,7 @@ where
     S: TryConvert,
 {
     match call_lambda(lambda, in_val) {
-        Ok(out) => out.try_convert::<S>(),
+        Ok(out) => S::try_convert(out),
         Err(e) => panic!("ruby function failed {}", e),
     }
 }
@@ -151,13 +151,9 @@ where
     T: IntoValue,
 {
     let out: Value = lambda.funcall("call", (in_val,))?;
-    let py_series: Value = out.funcall("_s", ())?;
-    Ok(py_series
-        .try_convert::<&RbSeries>()
-        .unwrap()
-        .series
-        .borrow()
-        .clone())
+    let py_series: Obj<RbSeries> = out.funcall("_s", ())?;
+    let tmp = py_series.series.borrow();
+    Ok(tmp.clone())
 }
 
 impl<'a> ApplyLambda<'a> for BooleanChunked {
@@ -289,7 +285,7 @@ impl<'a> ApplyLambda<'a> for BooleanChunked {
         lambda: Value,
         init_null_count: usize,
         first_value: Option<&str>,
-    ) -> RbResult<Utf8Chunked> {
+    ) -> RbResult<StringChunked> {
         let skip = usize::from(first_value.is_some());
         if init_null_count == self.len() {
             Ok(ChunkedArray::full_null(self.name(), self.len()))
@@ -566,7 +562,7 @@ where
         lambda: Value,
         init_null_count: usize,
         first_value: Option<&str>,
-    ) -> RbResult<Utf8Chunked> {
+    ) -> RbResult<StringChunked> {
         let skip = usize::from(first_value.is_some());
         if init_null_count == self.len() {
             Ok(ChunkedArray::full_null(self.name(), self.len()))
@@ -709,7 +705,7 @@ where
     }
 }
 
-impl<'a> ApplyLambda<'a> for Utf8Chunked {
+impl<'a> ApplyLambda<'a> for StringChunked {
     fn apply_lambda_unknown(&'a self, lambda: Value) -> RbResult<RbSeries> {
         let mut null_count = 0;
         for opt_v in self.into_iter() {
@@ -838,7 +834,7 @@ impl<'a> ApplyLambda<'a> for Utf8Chunked {
         lambda: Value,
         init_null_count: usize,
         first_value: Option<&str>,
-    ) -> RbResult<Utf8Chunked> {
+    ) -> RbResult<StringChunked> {
         let skip = usize::from(first_value.is_some());
         if init_null_count == self.len() {
             Ok(ChunkedArray::full_null(self.name(), self.len()))
@@ -1083,7 +1079,7 @@ impl<'a> ApplyLambda<'a> for StructChunked {
         lambda: Value,
         init_null_count: usize,
         first_value: Option<&str>,
-    ) -> RbResult<Utf8Chunked> {
+    ) -> RbResult<StringChunked> {
         let names = self.fields().iter().map(|s| s.name()).collect::<Vec<_>>();
 
         let skip = usize::from(first_value.is_some());

data/ext/polars/src/object.rs

@@ -1,31 +1 @@
-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;
-use polars_core::prelude::AnyValue;
-
-use crate::prelude::ObjectValue;
-use crate::Wrap;
-
 pub(crate) const OBJECT_NAME: &str = "object";
-
-pub(crate) fn register_object_builder() {
-    if !registry::is_object_builder_registered() {
-        let object_builder = Box::new(|name: &str, capacity: usize| {
-            Box::new(ObjectChunkedBuilder::<ObjectValue>::new(name, capacity))
-                as Box<dyn AnonymousObjectBuilder>
-        });
-
-        let object_converter = Arc::new(|av: AnyValue| {
-            let object = ObjectValue {
-                inner: Wrap(av).into_value(),
-            };
-            Box::new(object) as Box<dyn Any>
-        });
-
-        registry::register_object_builder(object_builder, object_converter)
-    }
-}

data/ext/polars/src/on_startup.rs

@@ -0,0 +1,32 @@
+use std::any::Any;
+use std::sync::Arc;
+
+use magnus::IntoValue;
+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 crate::prelude::ObjectValue;
+use crate::Wrap;
+
+pub(crate) fn register_object_builder() {
+    if !registry::is_object_builder_registered() {
+        let object_builder = Box::new(|name: &str, capacity: usize| {
+            Box::new(ObjectChunkedBuilder::<ObjectValue>::new(name, capacity))
+                as Box<dyn AnonymousObjectBuilder>
+        });
+
+        let object_converter = Arc::new(|av: AnyValue| {
+            let object = ObjectValue {
+                inner: Wrap(av).into_value().into(),
+            };
+            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)
+    }
+}

data/ext/polars/src/rb_modules.rs

@@ -1,25 +1,40 @@
-use magnus::{class, memoize, Module, RClass, RModule};
+use magnus::{value::Lazy, Module, RClass, RModule, Ruby};
+
+static POLARS: Lazy<RModule> = Lazy::new(|ruby| ruby.class_object().const_get("Polars").unwrap());
 
 pub(crate) fn polars() -> RModule {
-    *memoize!(RModule: class::object().const_get("Polars").unwrap())
+    Ruby::get().unwrap().get_inner(&POLARS)
 }
 
+static SERIES: Lazy<RClass> =
+    Lazy::new(|ruby| ruby.get_inner(&POLARS).const_get("Series").unwrap());
+
 pub(crate) fn series() -> RClass {
-    *memoize!(RClass: polars().const_get("Series").unwrap())
+    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 {
-    *memoize!(RModule: polars().const_get("Utils").unwrap())
+    Ruby::get().unwrap().get_inner(&UTILS)
 }
 
+static BIGDECIMAL: Lazy<RClass> =
+    Lazy::new(|ruby| ruby.class_object().const_get("BigDecimal").unwrap());
+
 pub(crate) fn bigdecimal() -> RClass {
-    *memoize!(RClass: class::object().const_get("BigDecimal").unwrap())
+    Ruby::get().unwrap().get_inner(&BIGDECIMAL)
 }
 
+static DATE: Lazy<RClass> = Lazy::new(|ruby| ruby.class_object().const_get("Date").unwrap());
+
 pub(crate) fn date() -> RClass {
-    *memoize!(RClass: class::object().const_get("Date").unwrap())
+    Ruby::get().unwrap().get_inner(&DATE)
 }
 
+static DATETIME: Lazy<RClass> =
+    Lazy::new(|ruby| ruby.class_object().const_get("DateTime").unwrap());
+
 pub(crate) fn datetime() -> RClass {
-    *memoize!(RClass: class::object().const_get("DateTime").unwrap())
+    Ruby::get().unwrap().get_inner(&DATETIME)
 }

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

@@ -17,6 +17,7 @@ impl RbSeries {
             self.series
                 .borrow()
                 .max_as_series()
+                .map_err(RbPolarsErr::from)?
                 .get(0)
                 .map_err(RbPolarsErr::from)?,
         )
@@ -48,6 +49,7 @@ impl RbSeries {
             self.series
                 .borrow()
                 .min_as_series()
+                .map_err(RbPolarsErr::from)?
                 .get(0)
                 .map_err(RbPolarsErr::from)?,
         )
@@ -75,6 +77,7 @@ impl RbSeries {
             self.series
                 .borrow()
                 .sum_as_series()
+                .map_err(RbPolarsErr::from)?
                 .get(0)
                 .map_err(RbPolarsErr::from)?,
         )

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

@@ -1,4 +1,4 @@
-use magnus::RArray;
+use magnus::{prelude::*, RArray};
 use polars_core::prelude::*;
 
 use crate::conversion::{slice_extract_wrapped, vec_extract_wrapped, Wrap};
@@ -16,7 +16,7 @@ impl RbSeries {
                 if item.is_nil() {
                     builder.append_null()
                 } else {
-                    match item.try_convert::<bool>() {
+                    match bool::try_convert(*item) {
                         Ok(val) => builder.append_value(val),
                         Err(e) => {
                             if strict {
@@ -49,7 +49,7 @@ where
             if item.is_nil() {
                 builder.append_null()
             } else {
-                match item.try_convert::<T::Native>() {
+                match T::Native::try_convert(*item) {
                     Ok(val) => builder.append_value(val),
                     Err(e) => {
                         if strict {
@@ -92,7 +92,7 @@ init_method_opt!(new_opt_f64, Float64Type, f64);
 fn vec_wrap_any_value<'s>(arr: RArray) -> RbResult<Vec<Wrap<AnyValue<'s>>>> {
     let mut val = Vec::with_capacity(arr.len());
     for v in arr.each() {
-        val.push(v?.try_convert()?);
+        val.push(Wrap::<AnyValue<'s>>::try_convert(v?)?);
     }
     Ok(val)
 }
@@ -106,7 +106,7 @@ impl RbSeries {
         Ok(s.into())
     }
 
-    pub fn new_str(name: String, val: Wrap<Utf8Chunked>, _strict: bool) -> Self {
+    pub fn new_str(name: String, val: Wrap<StringChunked>, _strict: bool) -> Self {
         let mut s = val.0.into_series();
         s.rename(&name);
         RbSeries::new(s)

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

@@ -1,4 +1,4 @@
-use magnus::{class, Module, RArray, RClass, RModule, Value};
+use magnus::{class, prelude::*, Module, RArray, RClass, RModule, Value};
 use polars_core::prelude::*;
 
 use crate::{raise_err, RbPolarsErr, RbResult, RbSeries};
@@ -9,11 +9,11 @@ impl RbSeries {
     pub fn to_numo(&self) -> RbResult<Value> {
         let s = &self.series.borrow();
         match s.dtype() {
-            DataType::Utf8 => {
-                let ca = s.utf8().unwrap();
+            DataType::String => {
+                let ca = s.str().unwrap();
 
                 // TODO make more efficient
-                let np_arr = RArray::from_iter(ca.into_iter());
+                let np_arr = RArray::from_iter(ca);
                 class::object()
                     .const_get::<_, RModule>("Numo")?
                     .const_get::<_, RClass>("RObject")?