polars-df 0.23.0 → 0.24.0

data/ext/polars/src/batched_csv.rs

@@ -1,4 +1,3 @@
-use std::cell::RefCell;
 use std::path::PathBuf;
 use std::sync::Mutex;
 
@@ -7,13 +6,15 @@ use polars::io::RowIndex;
 use polars::io::csv::read::OwnedBatchedCsvReader;
 use polars::io::mmap::MmapBytesReader;
 use polars::prelude::*;
+use polars_utils::open_file;
 
 use crate::conversion::*;
+use crate::utils::EnterPolarsExt;
 use crate::{RbDataFrame, RbPolarsErr, RbResult};
 
 #[magnus::wrap(class = "Polars::RbBatchedCsv")]
 pub struct RbBatchedCsv {
-    pub reader: RefCell<Mutex<OwnedBatchedCsvReader>>,
+    pub reader: Mutex<OwnedBatchedCsvReader>,
 }
 
 impl RbBatchedCsv {
@@ -26,27 +27,28 @@ impl RbBatchedCsv {
         let ignore_errors = bool::try_convert(arguments[3])?;
         let n_rows = Option::<usize>::try_convert(arguments[4])?;
         let skip_rows = usize::try_convert(arguments[5])?;
-        let projection = Option::<Vec<usize>>::try_convert(arguments[6])?;
-        let separator = String::try_convert(arguments[7])?;
-        let rechunk = bool::try_convert(arguments[8])?;
-        let columns = Option::<Vec<String>>::try_convert(arguments[9])?;
-        let encoding = Wrap::<CsvEncoding>::try_convert(arguments[10])?;
-        let n_threads = Option::<usize>::try_convert(arguments[11])?;
-        let path = PathBuf::try_convert(arguments[12])?;
-        let overwrite_dtype = Option::<Vec<(String, Wrap<DataType>)>>::try_convert(arguments[13])?;
-        let overwrite_dtype_slice = Option::<Vec<Wrap<DataType>>>::try_convert(arguments[14])?;
-        let low_memory = bool::try_convert(arguments[15])?;
-        let comment_prefix = Option::<String>::try_convert(arguments[16])?;
-        let quote_char = Option::<String>::try_convert(arguments[17])?;
-        let null_values = Option::<Wrap<NullValues>>::try_convert(arguments[18])?;
-        let missing_utf8_is_empty_string = bool::try_convert(arguments[19])?;
-        let try_parse_dates = bool::try_convert(arguments[20])?;
-        let skip_rows_after_header = usize::try_convert(arguments[21])?;
-        let row_index = Option::<(String, IdxSize)>::try_convert(arguments[22])?;
-        let eol_char = String::try_convert(arguments[23])?;
-        let raise_if_empty = bool::try_convert(arguments[24])?;
-        let truncate_ragged_lines = bool::try_convert(arguments[25])?;
-        let decimal_comma = bool::try_convert(arguments[26])?;
+        let skip_lines = usize::try_convert(arguments[6])?;
+        let projection = Option::<Vec<usize>>::try_convert(arguments[7])?;
+        let separator = String::try_convert(arguments[8])?;
+        let rechunk = bool::try_convert(arguments[9])?;
+        let columns = Option::<Vec<String>>::try_convert(arguments[10])?;
+        let encoding = Wrap::<CsvEncoding>::try_convert(arguments[11])?;
+        let n_threads = Option::<usize>::try_convert(arguments[12])?;
+        let path = PathBuf::try_convert(arguments[13])?;
+        let schema_overrides = Option::<Vec<(String, Wrap<DataType>)>>::try_convert(arguments[14])?;
+        let overwrite_dtype_slice = Option::<Vec<Wrap<DataType>>>::try_convert(arguments[15])?;
+        let low_memory = bool::try_convert(arguments[16])?;
+        let comment_prefix = Option::<String>::try_convert(arguments[17])?;
+        let quote_char = Option::<String>::try_convert(arguments[18])?;
+        let null_values = Option::<Wrap<NullValues>>::try_convert(arguments[19])?;
+        let missing_utf8_is_empty_string = bool::try_convert(arguments[20])?;
+        let try_parse_dates = bool::try_convert(arguments[21])?;
+        let skip_rows_after_header = usize::try_convert(arguments[22])?;
+        let row_index = Option::<(String, IdxSize)>::try_convert(arguments[23])?;
+        let eol_char = String::try_convert(arguments[24])?;
+        let raise_if_empty = bool::try_convert(arguments[25])?;
+        let truncate_ragged_lines = bool::try_convert(arguments[26])?;
+        let decimal_comma = bool::try_convert(arguments[27])?;
         // end arguments
 
         let null_values = null_values.map(|w| w.0);
@@ -65,7 +67,7 @@ impl RbBatchedCsv {
             None
         };
 
-        let overwrite_dtype = overwrite_dtype.map(|overwrite_dtype| {
+        let schema_overrides = schema_overrides.map(|overwrite_dtype| {
             overwrite_dtype
                 .iter()
                 .map(|(name, dtype)| {
@@ -82,13 +84,14 @@ impl RbBatchedCsv {
                 .collect::<Vec<_>>()
         });
 
-        let file = std::fs::File::open(path).map_err(RbPolarsErr::from)?;
+        let file = open_file(&path).map_err(RbPolarsErr::from)?;
         let reader = Box::new(file) as Box<dyn MmapBytesReader>;
         let reader = CsvReadOptions::default()
             .with_infer_schema_length(infer_schema_length)
             .with_has_header(has_header)
             .with_n_rows(n_rows)
             .with_skip_rows(skip_rows)
+            .with_skip_lines(skip_lines)
             .with_ignore_errors(ignore_errors)
             .with_projection(projection.map(Arc::new))
             .with_rechunk(rechunk)
@@ -97,6 +100,7 @@ impl RbBatchedCsv {
             .with_n_threads(n_threads)
             .with_dtype_overwrite(overwrite_dtype_slice.map(Arc::new))
             .with_low_memory(low_memory)
+            .with_schema_overwrite(schema_overrides.map(Arc::new))
             .with_skip_rows_after_header(skip_rows_after_header)
             .with_row_index(row_index)
             .with_raise_if_empty(raise_if_empty)
@@ -115,24 +119,16 @@ impl RbBatchedCsv {
             )
             .into_reader_with_file_handle(reader);
 
-        let reader = reader
-            .batched(overwrite_dtype.map(Arc::new))
-            .map_err(RbPolarsErr::from)?;
+        let reader = reader.batched(None).map_err(RbPolarsErr::from)?;
 
         Ok(RbBatchedCsv {
-            reader: RefCell::new(Mutex::new(reader)),
+            reader: Mutex::new(reader),
         })
     }
 
-    pub fn next_batches(ruby: &Ruby, rb_self: &Self, n: usize) -> RbResult<Option<RArray>> {
-        let reader = &rb_self.reader;
-        let batches = reader
-            .borrow()
-            .lock()
-            .map_err(|e| RbPolarsErr::Other(e.to_string()))?
-            .next_batches(n)
-            .map_err(RbPolarsErr::from)?;
-
-        Ok(batches.map(|batches| ruby.ary_from_iter(batches.into_iter().map(RbDataFrame::from))))
+    pub fn next_batches(rb: &Ruby, self_: &Self, n: usize) -> RbResult<Option<RArray>> {
+        let reader = &self_.reader;
+        let batches = rb.enter_polars(move || reader.lock().unwrap().next_batches(n))?;
+        Ok(batches.map(|batches| rb.ary_from_iter(batches.into_iter().map(RbDataFrame::from))))
     }
 }

data/ext/polars/src/c_api/allocator.rs

@@ -0,0 +1,7 @@
+#[cfg(target_os = "linux")]
+#[global_allocator]
+static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
+
+#[cfg(target_os = "macos")]
+#[global_allocator]
+static ALLOC: mimalloc::MiMalloc = mimalloc::MiMalloc;

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

@@ -0,0 +1 @@
+pub mod allocator;

data/ext/polars/src/catalog/unity.rs

@@ -11,6 +11,7 @@ use polars_io::catalog::unity::schema::parse_type_json_str;
 use polars_io::pl_async;
 
 use crate::rb_modules::polars;
+use crate::utils::EnterPolarsExt;
 use crate::utils::to_rb_err;
 use crate::{RbResult, RbValueError, Wrap};
 
@@ -29,8 +30,8 @@ macro_rules! rbdict_insert_keys {
     };
 }
 
-static CATALOG_INFO_CLS: Lazy<RClass> = Lazy::new(|_| {
-    polars()
+static CATALOG_INFO_CLS: Lazy<RClass> = Lazy::new(|rb| {
+    polars(rb)
         .const_get::<_, RClass>("Catalog")
         .unwrap()
         .const_get::<_, RModule>("Unity")
@@ -39,8 +40,8 @@ static CATALOG_INFO_CLS: Lazy<RClass> = Lazy::new(|_| {
         .unwrap()
 });
 
-static NAMESPACE_INFO_CLS: Lazy<RClass> = Lazy::new(|_| {
-    polars()
+static NAMESPACE_INFO_CLS: Lazy<RClass> = Lazy::new(|rb| {
+    polars(rb)
         .const_get::<_, RClass>("Catalog")
         .unwrap()
         .const_get::<_, RModule>("Unity")
@@ -49,8 +50,8 @@ static NAMESPACE_INFO_CLS: Lazy<RClass> = Lazy::new(|_| {
         .unwrap()
 });
 
-static TABLE_INFO_CLS: Lazy<RClass> = Lazy::new(|_| {
-    polars()
+static TABLE_INFO_CLS: Lazy<RClass> = Lazy::new(|rb| {
+    polars(rb)
         .const_get::<_, RClass>("Catalog")
         .unwrap()
         .const_get::<_, RModule>("Unity")
@@ -59,8 +60,8 @@ static TABLE_INFO_CLS: Lazy<RClass> = Lazy::new(|_| {
         .unwrap()
 });
 
-static COLUMN_INFO_CLS: Lazy<RClass> = Lazy::new(|_| {
-    polars()
+static COLUMN_INFO_CLS: Lazy<RClass> = Lazy::new(|rb| {
+    polars(rb)
         .const_get::<_, RClass>("Catalog")
         .unwrap()
         .const_get::<_, RModule>("Unity")
@@ -85,15 +86,15 @@ impl RbCatalogClient {
         builder.build().map(RbCatalogClient).map_err(to_rb_err)
     }
 
-    pub fn list_catalogs(ruby: &Ruby, rb_self: &Self) -> RbResult<Value> {
-        let v = pl_async::get_runtime()
-            .block_in_place_on(rb_self.client().list_catalogs())
-            .map_err(to_rb_err)?;
+    pub fn list_catalogs(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        let v = rb.enter_polars(|| {
+            pl_async::get_runtime().block_in_place_on(self_.client().list_catalogs())
+        })?;
 
         let mut opt_err = None;
 
-        let out = ruby.ary_from_iter(v.into_iter().map(|x| {
-            let v = catalog_info_to_rbobject(ruby, x);
+        let out = rb.ary_from_iter(v.into_iter().map(|x| {
+            let v = catalog_info_to_rbobject(rb, x);
             if let Ok(v) = v {
                 Some(v)
             } else {
@@ -107,15 +108,15 @@ impl RbCatalogClient {
         Ok(out.as_value())
     }
 
-    pub fn list_namespaces(ruby: &Ruby, rb_self: &Self, catalog_name: String) -> RbResult<Value> {
-        let v = pl_async::get_runtime()
-            .block_in_place_on(rb_self.client().list_namespaces(&catalog_name))
-            .map_err(to_rb_err)?;
+    pub fn list_namespaces(rb: &Ruby, self_: &Self, catalog_name: String) -> RbResult<Value> {
+        let v = rb.enter_polars(|| {
+            pl_async::get_runtime().block_in_place_on(self_.client().list_namespaces(&catalog_name))
+        })?;
 
         let mut opt_err = None;
 
-        let out = ruby.ary_from_iter(v.into_iter().map(|x| {
-            let v = namespace_info_to_rbobject(ruby, x);
+        let out = rb.ary_from_iter(v.into_iter().map(|x| {
+            let v = namespace_info_to_rbobject(rb, x);
             match v {
                 Ok(v) => Some(v),
                 Err(_) => {
@@ -131,20 +132,21 @@ impl RbCatalogClient {
     }
 
     pub fn list_tables(
-        ruby: &Ruby,
-        rb_self: &Self,
+        rb: &Ruby,
+        self_: &Self,
         catalog_name: String,
         namespace: String,
     ) -> RbResult<Value> {
-        let v = pl_async::get_runtime()
-            .block_in_place_on(rb_self.client().list_tables(&catalog_name, &namespace))
-            .map_err(to_rb_err)?;
+        let v = rb.enter_polars(|| {
+            pl_async::get_runtime()
+                .block_in_place_on(self_.client().list_tables(&catalog_name, &namespace))
+        })?;
 
         let mut opt_err = None;
 
-        let out = ruby
+        let out = rb
             .ary_from_iter(v.into_iter().map(|table_info| {
-                let v = table_info_to_rbobject(ruby, table_info);
+                let v = table_info_to_rbobject(rb, table_info);
 
                 if let Ok(v) = v {
                     Some(v)
@@ -161,85 +163,100 @@ impl RbCatalogClient {
     }
 
     pub fn get_table_info(
-        ruby: &Ruby,
-        rb_self: &Self,
+        rb: &Ruby,
+        self_: &Self,
         table_name: String,
         catalog_name: String,
         namespace: String,
     ) -> RbResult<Value> {
-        let table_info = pl_async::get_runtime()
-            .block_in_place_on(rb_self.client().get_table_info(
-                &table_name,
-                &catalog_name,
-                &namespace,
-            ))
+        let table_info = rb
+            .enter_polars(|| {
+                pl_async::get_runtime().block_in_place_on(self_.client().get_table_info(
+                    &table_name,
+                    &catalog_name,
+                    &namespace,
+                ))
+            })
             .map_err(to_rb_err)?;
 
-        table_info_to_rbobject(ruby, table_info)
+        table_info_to_rbobject(rb, table_info)
     }
 
     pub fn create_catalog(
-        ruby: &Ruby,
-        rb_self: &Self,
+        rb: &Ruby,
+        self_: &Self,
         catalog_name: String,
         comment: Option<String>,
         storage_root: Option<String>,
     ) -> RbResult<Value> {
-        let catalog_info = pl_async::get_runtime()
-            .block_in_place_on(rb_self.client().create_catalog(
-                &catalog_name,
-                comment.as_deref(),
-                storage_root.as_deref(),
-            ))
+        let catalog_info = rb
+            .detach(|| {
+                pl_async::get_runtime().block_in_place_on(self_.client().create_catalog(
+                    &catalog_name,
+                    comment.as_deref(),
+                    storage_root.as_deref(),
+                ))
+            })
             .map_err(to_rb_err)?;
 
-        catalog_info_to_rbobject(ruby, catalog_info)
+        catalog_info_to_rbobject(rb, catalog_info)
     }
 
-    pub fn delete_catalog(&self, catalog_name: String, force: bool) -> RbResult<()> {
-        pl_async::get_runtime()
-            .block_in_place_on(self.client().delete_catalog(&catalog_name, force))
-            .map_err(to_rb_err)
+    pub fn delete_catalog(
+        rb: &Ruby,
+        self_: &Self,
+        catalog_name: String,
+        force: bool,
+    ) -> RbResult<()> {
+        rb.detach(|| {
+            pl_async::get_runtime()
+                .block_in_place_on(self_.client().delete_catalog(&catalog_name, force))
+        })
+        .map_err(to_rb_err)
     }
 
     pub fn create_namespace(
-        ruby: &Ruby,
-        rb_self: &Self,
+        rb: &Ruby,
+        self_: &Self,
         catalog_name: String,
         namespace: String,
         comment: Option<String>,
         storage_root: Option<String>,
     ) -> RbResult<Value> {
-        let namespace_info = pl_async::get_runtime()
-            .block_in_place_on(rb_self.client().create_namespace(
-                &catalog_name,
-                &namespace,
-                comment.as_deref(),
-                storage_root.as_deref(),
-            ))
+        let namespace_info = rb
+            .detach(|| {
+                pl_async::get_runtime().block_in_place_on(self_.client().create_namespace(
+                    &catalog_name,
+                    &namespace,
+                    comment.as_deref(),
+                    storage_root.as_deref(),
+                ))
+            })
             .map_err(to_rb_err)?;
 
-        namespace_info_to_rbobject(ruby, namespace_info)
+        namespace_info_to_rbobject(rb, namespace_info)
     }
 
     pub fn delete_namespace(
-        &self,
+        rb: &Ruby,
+        self_: &Self,
         catalog_name: String,
         namespace: String,
         force: bool,
     ) -> RbResult<()> {
-        pl_async::get_runtime()
-            .block_in_place_on(
-                self.client()
-                    .delete_namespace(&catalog_name, &namespace, force),
-            )
-            .map_err(to_rb_err)
+        rb.detach(|| {
+            pl_async::get_runtime().block_in_place_on(self_.client().delete_namespace(
+                &catalog_name,
+                &namespace,
+                force,
+            ))
+        })
+        .map_err(to_rb_err)
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn create_table(
-        ruby: &Ruby,
-        rb_self: &Self,
+        rb: &Ruby,
+        self_: &Self,
         catalog_name: String,
         namespace: String,
         table_name: String,
@@ -250,47 +267,52 @@ impl RbCatalogClient {
         storage_root: Option<String>,
         properties: Vec<(String, String)>,
     ) -> RbResult<Value> {
-        let table_info = pl_async::get_runtime()
-            .block_in_place_on(
-                rb_self.client().create_table(
-                    &catalog_name,
-                    &namespace,
-                    &table_name,
-                    schema.as_ref().map(|x| &x.0),
-                    &TableType::from_str(&table_type)
-                        .map_err(|e| RbValueError::new_err(e.to_string()))?,
-                    data_source_format
-                        .as_deref()
-                        .map(DataSourceFormat::from_str)
-                        .transpose()
-                        .map_err(|e| RbValueError::new_err(e.to_string()))?
-                        .as_ref(),
-                    comment.as_deref(),
-                    storage_root.as_deref(),
-                    &mut properties.iter().map(|(a, b)| (a.as_str(), b.as_str())),
-                ),
-            )
-            .map_err(to_rb_err)?;
-
-        table_info_to_rbobject(ruby, table_info)
+        let table_info = rb.detach(|| {
+            pl_async::get_runtime()
+                .block_in_place_on(
+                    self_.client().create_table(
+                        &catalog_name,
+                        &namespace,
+                        &table_name,
+                        schema.as_ref().map(|x| &x.0),
+                        &TableType::from_str(&table_type)
+                            .map_err(|e| RbValueError::new_err(e.to_string()))?,
+                        data_source_format
+                            .as_deref()
+                            .map(DataSourceFormat::from_str)
+                            .transpose()
+                            .map_err(|e| RbValueError::new_err(e.to_string()))?
+                            .as_ref(),
+                        comment.as_deref(),
+                        storage_root.as_deref(),
+                        &mut properties.iter().map(|(a, b)| (a.as_str(), b.as_str())),
+                    ),
+                )
+                .map_err(to_rb_err)
+        })?;
+
+        table_info_to_rbobject(rb, table_info)
     }
 
     pub fn delete_table(
-        &self,
+        rb: &Ruby,
+        self_: &Self,
         catalog_name: String,
         namespace: String,
         table_name: String,
     ) -> RbResult<()> {
-        pl_async::get_runtime()
-            .block_in_place_on(
-                self.client()
-                    .delete_table(&catalog_name, &namespace, &table_name),
-            )
-            .map_err(to_rb_err)
+        rb.detach(|| {
+            pl_async::get_runtime().block_in_place_on(self_.client().delete_table(
+                &catalog_name,
+                &namespace,
+                &table_name,
+            ))
+        })
+        .map_err(to_rb_err)
     }
 
-    pub fn type_json_to_polars_type(ruby: &Ruby, type_json: String) -> RbResult<Value> {
-        Ok(Wrap(parse_type_json_str(&type_json).map_err(to_rb_err)?).into_value_with(ruby))
+    pub fn type_json_to_polars_type(rb: &Ruby, type_json: String) -> RbResult<Value> {
+        Ok(Wrap(parse_type_json_str(&type_json).map_err(to_rb_err)?).into_value_with(rb))
     }
 }
 

data/ext/polars/src/conversion/any_value.rs

@@ -11,7 +11,7 @@ use super::{ObjectValue, Wrap, struct_dict};
 
 use crate::exceptions::RbOverflowError;
 use crate::rb_modules::pl_utils;
-use crate::{RbErr, RbPolarsErr, RbResult, RbSeries};
+use crate::{RbErr, RbPolarsErr, RbResult, RbSeries, RbValueError};
 
 impl IntoValue for Wrap<AnyValue<'_>> {
     fn into_value_with(self, ruby: &Ruby) -> Value {
@@ -49,7 +49,7 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::CategoricalOwned(cat, map) | AnyValue::EnumOwned(cat, map) => unsafe {
             map.cat_to_str_unchecked(cat).into_value_with(ruby)
         },
-        AnyValue::Date(v) => pl_utils().funcall("_to_ruby_date", (v,)).unwrap(),
+        AnyValue::Date(v) => pl_utils(ruby).funcall("_to_ruby_date", (v,)).unwrap(),
         AnyValue::Datetime(v, time_unit, time_zone) => {
             datetime_to_rb_object(v, time_unit, time_zone)
         }
@@ -58,11 +58,11 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         }
         AnyValue::Duration(v, time_unit) => {
             let time_unit = time_unit.to_ascii();
-            pl_utils()
+            pl_utils(ruby)
                 .funcall("_to_ruby_duration", (v, time_unit))
                 .unwrap()
         }
-        AnyValue::Time(v) => pl_utils().funcall("_to_ruby_time", (v,)).unwrap(),
+        AnyValue::Time(v) => pl_utils(ruby).funcall("_to_ruby_time", (v,)).unwrap(),
         AnyValue::Array(v, _) | AnyValue::List(v) => RbSeries::new(v).to_a().as_value(),
         ref av @ AnyValue::Struct(_, _, flds) => struct_dict(ruby, av._iter_struct_av(), flds),
         AnyValue::StructOwned(payload) => struct_dict(ruby, payload.0.into_iter(), &payload.1),
@@ -79,7 +79,9 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::Decimal(v, prec, scale) => {
             let mut buf = DecimalFmtBuffer::new();
             let s = buf.format_dec128(v, scale, false, false);
-            pl_utils().funcall("_to_ruby_decimal", (prec, s)).unwrap()
+            pl_utils(ruby)
+                .funcall("_to_ruby_decimal", (prec, s))
+                .unwrap()
         }
     }
 }
@@ -198,14 +200,8 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
         Ok(AnyValue::Datetime(v, TimeUnit::Nanoseconds, None))
     }
 
-    fn get_datetime(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
-        let sec: i64 = ob.funcall("to_i", ())?;
-        let nsec: i64 = ob.funcall("nsec", ())?;
-        Ok(AnyValue::Datetime(
-            sec * 1_000_000_000 + nsec,
-            TimeUnit::Nanoseconds,
-            None,
-        ))
+    fn get_datetime(ob: Value, strict: bool) -> RbResult<AnyValue<'static>> {
+        get_time(ob.funcall("to_time", ())?, strict)
     }
 
     fn get_decimal(ob: Value, _strict: bool) -> RbResult<AnyValue<'static>> {
@@ -258,13 +254,13 @@ pub(crate) fn rb_object_to_any_value<'s>(ob: Value, strict: bool) -> RbResult<An
     // call is_a? for ActiveSupport::TimeWithZone
     } else if ob.funcall::<_, _, bool>("is_a?", (ruby.class_time(),))? {
         get_time(ob, strict)
-    } else if ob.is_kind_of(crate::rb_modules::datetime()) {
+    } else if ob.is_kind_of(crate::rb_modules::datetime(&ruby)) {
         get_datetime(ob, strict)
-    } else if ob.is_kind_of(crate::rb_modules::date()) {
+    } else if ob.is_kind_of(crate::rb_modules::date(&ruby)) {
         get_date(ob, strict)
-    } else if ob.is_kind_of(crate::rb_modules::bigdecimal()) {
+    } else if ob.is_kind_of(crate::rb_modules::bigdecimal(&ruby)) {
         get_decimal(ob, strict)
     } else {
-        Err(RbPolarsErr::Other(format!("object type not supported {ob:?}")).into())
+        Err(RbValueError::new_err(format!("Cannot convert {ob}")))
     }
 }

data/ext/polars/src/conversion/chunked_array.rs

@@ -74,7 +74,7 @@ impl IntoValue for Wrap<&StructChunked> {
 
 impl IntoValue for Wrap<&DurationChunked> {
     fn into_value_with(self, ruby: &Ruby) -> Value {
-        let utils = pl_utils();
+        let utils = pl_utils(ruby);
         let time_unit = Wrap(self.0.time_unit()).into_value_with(ruby);
         let iter = self.0.physical().into_iter().map(|opt_v| {
             opt_v.map(|v| {
@@ -89,7 +89,7 @@ impl IntoValue for Wrap<&DurationChunked> {
 
 impl IntoValue for Wrap<&DatetimeChunked> {
     fn into_value_with(self, ruby: &Ruby) -> Value {
-        let utils = pl_utils();
+        let utils = pl_utils(ruby);
         let time_unit = Wrap(self.0.time_unit()).into_value_with(ruby);
         let time_zone = self
             .0
@@ -109,7 +109,7 @@ impl IntoValue for Wrap<&DatetimeChunked> {
 
 impl IntoValue for Wrap<&TimeChunked> {
     fn into_value_with(self, ruby: &Ruby) -> Value {
-        let utils = pl_utils();
+        let utils = pl_utils(ruby);
         let iter = self.0.physical().into_iter().map(|opt_v| {
             opt_v.map(|v| utils.funcall::<_, _, Value>("_to_ruby_time", (v,)).unwrap())
         });
@@ -119,7 +119,7 @@ impl IntoValue for Wrap<&TimeChunked> {
 
 impl IntoValue for Wrap<&DateChunked> {
     fn into_value_with(self, ruby: &Ruby) -> Value {
-        let utils = pl_utils();
+        let utils = pl_utils(ruby);
         let iter = self.0.physical().into_iter().map(|opt_v| {
             opt_v.map(|v| utils.funcall::<_, _, Value>("_to_ruby_date", (v,)).unwrap())
         });
@@ -129,7 +129,7 @@ impl IntoValue for Wrap<&DateChunked> {
 
 impl IntoValue for Wrap<&DecimalChunked> {
     fn into_value_with(self, ruby: &Ruby) -> Value {
-        let utils = pl_utils();
+        let utils = pl_utils(ruby);
         let rb_precision = self.0.precision().into_value_with(ruby);
         let mut buf = DecimalFmtBuffer::new();
         let iter = self.0.physical().into_iter().map(|opt_v| {

data/ext/polars/src/conversion/datetime.rs

@@ -1,11 +1,12 @@
-use magnus::{Value, prelude::*};
+use magnus::{Ruby, Value, prelude::*};
 use polars::prelude::*;
 
 use crate::rb_modules::pl_utils;
 
 pub fn datetime_to_rb_object(v: i64, tu: TimeUnit, tz: Option<&TimeZone>) -> Value {
+    let ruby = Ruby::get().unwrap();
     let tu = tu.to_ascii();
-    pl_utils()
+    pl_utils(&ruby)
         .funcall("_to_ruby_datetime", (v, tu, tz.map(|v| v.to_string())))
         .unwrap()
 }