polars-df 0.20.0 → 0.21.0

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

@@ -1,9 +1,9 @@
-use std::path::{Path, PathBuf};
 use std::sync::{Arc, Mutex};
 
 use magnus::{RHash, TryConvert, Value};
 use polars::prelude::sync_on_close::SyncOnCloseType;
-use polars::prelude::{SinkOptions, SpecialEq};
+use polars::prelude::{PlPath, SinkOptions, SpecialEq};
+use polars_utils::plpath::PlPathRef;
 
 use crate::prelude::Wrap;
 use crate::{RbResult, RbValueError};
@@ -15,8 +15,8 @@ pub enum SinkTarget {
 
 impl TryConvert for Wrap<polars_plan::dsl::SinkTarget> {
     fn try_convert(ob: Value) -> RbResult<Self> {
-        if let Ok(v) = PathBuf::try_convert(ob) {
-            Ok(Wrap(polars::prelude::SinkTarget::Path(Arc::new(v))))
+        if let Ok(v) = String::try_convert(ob) {
+            Ok(Wrap(polars::prelude::SinkTarget::Path(PlPath::new(&v))))
         } else {
             let writer = {
                 let rb_f = ob;
@@ -39,10 +39,10 @@ impl TryConvert for SinkTarget {
 }
 
 impl SinkTarget {
-    pub fn base_path(&self) -> Option<&Path> {
+    pub fn base_path(&self) -> Option<PlPathRef<'_>> {
         match self {
             Self::File(t) => match t {
-                polars::prelude::SinkTarget::Path(p) => Some(p.as_path()),
+                polars::prelude::SinkTarget::Path(p) => Some(p.as_ref()),
                 polars::prelude::SinkTarget::Dyn(_) => None,
             },
         }

data/ext/polars/src/lib.rs

@@ -1,5 +1,6 @@
 mod allocator;
 mod batched_csv;
+mod catalog;
 mod conversion;
 mod dataframe;
 mod error;
@@ -8,6 +9,7 @@ mod expr;
 mod file;
 mod functions;
 mod interop;
+mod io;
 mod lazyframe;
 mod lazygroupby;
 mod map;
@@ -20,23 +22,25 @@ mod sql;
 mod utils;
 
 use batched_csv::RbBatchedCsv;
+use catalog::unity::RbCatalogClient;
 use conversion::*;
 use dataframe::RbDataFrame;
 use error::RbPolarsErr;
 use exceptions::{RbTypeError, RbValueError};
-use expr::rb_exprs_to_exprs;
 use expr::RbExpr;
+use expr::rb_exprs_to_exprs;
+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 lazygroupby::RbLazyGroupBy;
-use magnus::{define_module, function, method, prelude::*, Ruby};
+use magnus::{Ruby, define_module, function, method, prelude::*};
 use series::RbSeries;
 use sql::RbSQLContext;
 
-use magnus::error::Result as RbResult;
 use magnus::Error as RbErr;
+use magnus::error::Result as RbResult;
 
 // TODO move
 fn re_escape(pattern: String) -> String {
@@ -143,7 +147,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("pivot_expr", method!(RbDataFrame::pivot_expr, 7))?;
     class.define_method("partition_by", method!(RbDataFrame::partition_by, 3))?;
     class.define_method("lazy", method!(RbDataFrame::lazy, 0))?;
-    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 3))?;
+    class.define_method("to_dummies", method!(RbDataFrame::to_dummies, 4))?;
     class.define_method("null_count", method!(RbDataFrame::null_count, 0))?;
     class.define_method("map_rows", method!(RbDataFrame::map_rows, 3))?;
     class.define_method("shrink_to_fit", method!(RbDataFrame::shrink_to_fit, 0))?;
@@ -329,7 +333,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("str_hex_decode", method!(RbExpr::str_hex_decode, 1))?;
     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, 2))?;
+    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("binary_hex_encode", method!(RbExpr::bin_hex_encode, 0))?;
     class.define_method("binary_hex_decode", method!(RbExpr::bin_hex_decode, 1))?;
@@ -426,7 +430,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("dot", method!(RbExpr::dot, 1))?;
     class.define_method("reinterpret", method!(RbExpr::reinterpret, 1))?;
     class.define_method("mode", method!(RbExpr::mode, 0))?;
-    class.define_method("exclude", method!(RbExpr::exclude, 1))?;
     class.define_method("interpolate", method!(RbExpr::interpolate, 1))?;
     class.define_method("interpolate_by", method!(RbExpr::interpolate_by, 1))?;
     class.define_method("rolling_sum", method!(RbExpr::rolling_sum, 4))?;
@@ -467,6 +470,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_sort", method!(RbExpr::list_sort, 2))?;
     class.define_method("list_reverse", method!(RbExpr::list_reverse, 0))?;
     class.define_method("list_unique", method!(RbExpr::list_unique, 1))?;
+    class.define_method("list_set_operation", method!(RbExpr::list_set_operation, 2))?;
     class.define_method("list_get", method!(RbExpr::list_get, 2))?;
     class.define_method("list_join", method!(RbExpr::list_join, 2))?;
     class.define_method("list_arg_min", method!(RbExpr::list_arg_min, 0))?;
@@ -477,6 +481,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("list_shift", method!(RbExpr::list_shift, 1))?;
     class.define_method("list_slice", method!(RbExpr::list_slice, 2))?;
     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("rank", method!(RbExpr::rank, 3))?;
@@ -518,6 +523,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("set_sorted_flag", method!(RbExpr::set_sorted_flag, 1))?;
     class.define_method("replace", method!(RbExpr::replace, 2))?;
     class.define_method("replace_strict", method!(RbExpr::replace_strict, 4))?;
+    class.define_method("into_selector", method!(RbExpr::into_selector, 0))?;
+    class.define_singleton_method("new_selector", function!(RbExpr::new_selector, 1))?;
 
     // meta
     class.define_method("meta_pop", method!(RbExpr::meta_pop, 1))?;
@@ -534,10 +541,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "meta_is_regex_projection",
         method!(RbExpr::meta_is_regex_projection, 0),
     )?;
-    class.define_method("_meta_selector_add", method!(RbExpr::_meta_selector_add, 1))?;
-    class.define_method("_meta_selector_sub", method!(RbExpr::_meta_selector_sub, 1))?;
-    class.define_method("_meta_selector_and", method!(RbExpr::_meta_selector_and, 1))?;
-    class.define_method("_meta_as_selector", method!(RbExpr::_meta_as_selector, 0))?;
     class.define_method("meta_tree_format", method!(RbExpr::meta_tree_format, 1))?;
 
     // name
@@ -550,15 +553,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
 
     // maybe add to different class
     let class = module.define_module("Plr")?;
-    class.define_singleton_method("dtype_cols", function!(functions::lazy::dtype_cols, 1))?;
-    class.define_singleton_method("index_cols", function!(functions::lazy::index_cols, 1))?;
     class.define_singleton_method("col", function!(functions::lazy::col, 1))?;
     class.define_singleton_method("len", function!(functions::lazy::len, 0))?;
-    class.define_singleton_method("first", function!(functions::lazy::first, 0))?;
-    class.define_singleton_method("last", function!(functions::lazy::last, 0))?;
-    class.define_singleton_method("cols", function!(functions::lazy::cols, 1))?;
     class.define_singleton_method("fold", function!(functions::lazy::fold, 5))?;
-    class.define_singleton_method("cum_fold", function!(functions::lazy::cum_fold, 4))?;
+    class.define_singleton_method("cum_fold", function!(functions::lazy::cum_fold, 6))?;
     class.define_singleton_method("lit", function!(functions::lazy::lit, 3))?;
     class.define_singleton_method("int_range", function!(functions::range::int_range, 4))?;
     class.define_singleton_method("int_ranges", function!(functions::range::int_ranges, 4))?;
@@ -729,7 +727,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("new_from_csv", function!(RbLazyFrame::new_from_csv, -1))?;
     class.define_singleton_method(
         "new_from_parquet",
-        function!(RbLazyFrame::new_from_parquet, -1),
+        function!(RbLazyFrame::new_from_parquet, 6),
     )?;
     class.define_singleton_method("new_from_ipc", function!(RbLazyFrame::new_from_ipc, 10))?;
     class.define_method("write_json", method!(RbLazyFrame::write_json, 1))?;
@@ -750,7 +748,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("sink_ipc", method!(RbLazyFrame::sink_ipc, 5))?;
     class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, -1))?;
     class.define_method("sink_json", method!(RbLazyFrame::sink_json, 4))?;
-    class.define_method("fetch", method!(RbLazyFrame::fetch, 1))?;
     class.define_method("filter", method!(RbLazyFrame::filter, 1))?;
     class.define_method("select", method!(RbLazyFrame::select, 1))?;
     class.define_method("select_seq", method!(RbLazyFrame::select_seq, 1))?;
@@ -908,9 +905,9 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("median", method!(RbSeries::median, 0))?;
     class.define_method("quantile", method!(RbSeries::quantile, 2))?;
     class.define_method("_clone", method!(RbSeries::clone, 0))?;
-    class.define_method("apply_lambda", method!(RbSeries::apply_lambda, 3))?;
+    class.define_method("map_elements", method!(RbSeries::map_elements, 3))?;
     class.define_method("zip_with", method!(RbSeries::zip_with, 2))?;
-    class.define_method("to_dummies", method!(RbSeries::to_dummies, 2))?;
+    class.define_method("to_dummies", method!(RbSeries::to_dummies, 3))?;
     class.define_method("n_unique", method!(RbSeries::n_unique, 0))?;
     class.define_method("floor", method!(RbSeries::floor, 0))?;
     class.define_method("shrink_to_fit", method!(RbSeries::shrink_to_fit, 0))?;
@@ -1111,5 +1108,86 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     let class = module.define_class("ArrowArrayStream", ruby.class_object())?;
     class.define_method("to_i", method!(RbArrowArrayStream::to_i, 0))?;
 
+    // catalog
+    let class = module.define_class("RbCatalogClient", ruby.class_object())?;
+    class.define_singleton_method("new", function!(RbCatalogClient::new, 2))?;
+    class.define_singleton_method(
+        "type_json_to_polars_type",
+        function!(RbCatalogClient::type_json_to_polars_type, 1),
+    )?;
+    class.define_method("list_catalogs", method!(RbCatalogClient::list_catalogs, 0))?;
+    class.define_method(
+        "list_namespaces",
+        method!(RbCatalogClient::list_namespaces, 1),
+    )?;
+    class.define_method("list_tables", method!(RbCatalogClient::list_tables, 2))?;
+    class.define_method(
+        "get_table_info",
+        method!(RbCatalogClient::get_table_info, 3),
+    )?;
+    class.define_method(
+        "create_catalog",
+        method!(RbCatalogClient::create_catalog, 3),
+    )?;
+    class.define_method(
+        "delete_catalog",
+        method!(RbCatalogClient::delete_catalog, 2),
+    )?;
+    class.define_method(
+        "create_namespace",
+        method!(RbCatalogClient::create_namespace, 4),
+    )?;
+    class.define_method(
+        "delete_namespace",
+        method!(RbCatalogClient::delete_namespace, 3),
+    )?;
+    class.define_method("create_table", method!(RbCatalogClient::create_table, 9))?;
+    class.define_method("delete_table", method!(RbCatalogClient::delete_table, 3))?;
+
+    // categories
+    let class = module.define_class("RbCategories", ruby.class_object())?;
+    class.define_singleton_method(
+        "global_categories",
+        function!(RbCategories::global_categories, 0),
+    )?;
+
+    // data type expr
+    let _class = module.define_class("RbDataTypeExpr", ruby.class_object())?;
+
+    // selector
+    let class = module.define_class("RbSelector", ruby.class_object())?;
+    class.define_method("union", method!(RbSelector::union, 1))?;
+    class.define_method("difference", method!(RbSelector::difference, 1))?;
+    class.define_method("exclusive_or", method!(RbSelector::exclusive_or, 1))?;
+    class.define_method("intersect", method!(RbSelector::intersect, 1))?;
+    class.define_singleton_method("by_dtype", function!(RbSelector::by_dtype, 1))?;
+    class.define_singleton_method("by_name", function!(RbSelector::by_name, 2))?;
+    class.define_singleton_method("by_index", function!(RbSelector::by_index, 2))?;
+    class.define_singleton_method("first", function!(RbSelector::first, 1))?;
+    class.define_singleton_method("last", function!(RbSelector::last, 1))?;
+    class.define_singleton_method("matches", function!(RbSelector::matches, 1))?;
+    class.define_singleton_method("enum_", function!(RbSelector::enum_, 0))?;
+    class.define_singleton_method("categorical", function!(RbSelector::categorical, 0))?;
+    class.define_singleton_method("nested", function!(RbSelector::nested, 0))?;
+    class.define_singleton_method("list", function!(RbSelector::list, 1))?;
+    class.define_singleton_method("array", function!(RbSelector::array, 2))?;
+    class.define_singleton_method("struct_", function!(RbSelector::struct_, 0))?;
+    class.define_singleton_method("integer", function!(RbSelector::integer, 0))?;
+    class.define_singleton_method("signed_integer", function!(RbSelector::signed_integer, 0))?;
+    class.define_singleton_method(
+        "unsigned_integer",
+        function!(RbSelector::unsigned_integer, 0),
+    )?;
+    class.define_singleton_method("float", function!(RbSelector::float, 0))?;
+    class.define_singleton_method("decimal", function!(RbSelector::decimal, 0))?;
+    class.define_singleton_method("numeric", function!(RbSelector::numeric, 0))?;
+    class.define_singleton_method("temporal", function!(RbSelector::temporal, 0))?;
+    class.define_singleton_method("datetime", function!(RbSelector::datetime, 2))?;
+    class.define_singleton_method("duration", function!(RbSelector::duration, 1))?;
+    class.define_singleton_method("object", function!(RbSelector::object, 0))?;
+    class.define_singleton_method("empty", function!(RbSelector::empty, 0))?;
+    class.define_singleton_method("all", function!(RbSelector::all, 0))?;
+    class.define_method("_hash", method!(RbSelector::hash, 0))?;
+
     Ok(())
 }

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

@@ -1,6 +1,6 @@
-use magnus::{class, prelude::*, typed_data::Obj, IntoValue, RArray, TryConvert, Value};
+use magnus::{IntoValue, RArray, TryConvert, Value, class, prelude::*, typed_data::Obj};
 use polars::prelude::*;
-use polars_core::frame::row::{rows_to_schema_first_non_null, Row};
+use polars_core::frame::row::{Row, rows_to_schema_first_non_null};
 use polars_core::series::SeriesIter;
 
 use super::*;
@@ -144,7 +144,7 @@ where
         let tpl = (RArray::from_iter(iter),);
         match lambda.funcall::<_, _, Value>("call", tpl) {
             Ok(val) => T::try_convert(val).ok(),
-            Err(e) => panic!("ruby function failed {}", e),
+            Err(e) => panic!("ruby function failed {e}"),
         }
     })
 }
@@ -157,7 +157,7 @@ pub fn apply_lambda_with_primitive_out_type<D>(
     first_value: Option<D::Native>,
 ) -> ChunkedArray<D>
 where
-    D: RbArrowPrimitiveType,
+    D: RbPolarsNumericType,
     D::Native: IntoValue + TryConvert,
 {
     let skip = usize::from(first_value.is_some());
@@ -247,11 +247,11 @@ pub fn apply_lambda_with_list_out_type(
                         if val.is_nil() {
                             None
                         } else {
-                            panic!("should return a Series, got a {:?}", val)
+                            panic!("should return a Series, got a {val:?}")
                         }
                     }
                 },
-                Err(e) => panic!("ruby function failed {}", e),
+                Err(e) => panic!("ruby function failed {e}"),
             }
         });
         iterator_to_list(
@@ -302,7 +302,7 @@ pub fn apply_lambda_with_rows_output<'a>(
                     None => Ok(&null_row),
                 }
             }
-            Err(e) => panic!("ruby function failed {}", e),
+            Err(e) => panic!("ruby function failed {e}"),
         }
     });
 

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

@@ -1,4 +1,4 @@
-use magnus::{prelude::*, RArray, Value};
+use magnus::{RArray, Value, prelude::*};
 use polars::prelude::*;
 
 use crate::rb_modules::*;

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

@@ -2,27 +2,37 @@ pub mod dataframe;
 pub mod lazy;
 pub mod series;
 
-use magnus::{prelude::*, RHash, Value};
+use magnus::{RHash, Value, prelude::*};
 use polars::chunked_array::builder::get_list_builder;
 use polars::prelude::*;
-use polars_core::utils::CustomIterTools;
 use polars_core::POOL;
+use polars_core::utils::CustomIterTools;
 use rayon::prelude::*;
 
-use crate::{ObjectValue, RbPolarsErr, RbResult, RbSeries, Wrap};
+use crate::{ObjectValue, RbPolarsErr, RbResult, RbSeries, RbValueError, Wrap};
+
+pub trait RbPolarsNumericType: PolarsNumericType {}
 
-pub trait RbArrowPrimitiveType: PolarsNumericType {}
+impl RbPolarsNumericType for UInt8Type {}
+impl RbPolarsNumericType for UInt16Type {}
+impl RbPolarsNumericType for UInt32Type {}
+impl RbPolarsNumericType for UInt64Type {}
+impl RbPolarsNumericType for Int8Type {}
+impl RbPolarsNumericType for Int16Type {}
+impl RbPolarsNumericType for Int32Type {}
+impl RbPolarsNumericType for Int64Type {}
+impl RbPolarsNumericType for Float32Type {}
+impl RbPolarsNumericType for Float64Type {}
 
-impl RbArrowPrimitiveType for UInt8Type {}
-impl RbArrowPrimitiveType for UInt16Type {}
-impl RbArrowPrimitiveType for UInt32Type {}
-impl RbArrowPrimitiveType for UInt64Type {}
-impl RbArrowPrimitiveType for Int8Type {}
-impl RbArrowPrimitiveType for Int16Type {}
-impl RbArrowPrimitiveType for Int32Type {}
-impl RbArrowPrimitiveType for Int64Type {}
-impl RbArrowPrimitiveType for Float32Type {}
-impl RbArrowPrimitiveType for Float64Type {}
+pub(super) fn check_nested_object(dt: &DataType) -> RbResult<()> {
+    if dt.contains_objects() {
+        Err(RbValueError::new_err(
+            "nested objects are not allowed\n\nSet `return_dtype: Polars::Object` to use Ruby's native nesting.",
+        ))
+    } else {
+        Ok(())
+    }
+}
 
 fn iterator_to_struct(
     it: impl Iterator<Item = Option<Value>>,
@@ -37,7 +47,7 @@ fn iterator_to_struct(
         _ => {
             return Err(crate::exceptions::ComputeError::new_err(format!(
                 "expected struct got {first_value:?}",
-            )))
+            )));
         }
     };
 
@@ -70,9 +80,11 @@ fn iterator_to_struct(
             Some(dict) => {
                 let dict = RHash::try_convert(dict)?;
                 if dict.len() != struct_width {
-                    return Err(crate::exceptions::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())
-                    ));
+                    return Err(crate::exceptions::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()
+                    )));
                 }
                 // we ignore the keys of the rest of the dicts
                 // the first item determines the output name
@@ -109,7 +121,7 @@ fn iterator_to_primitive<T>(
     capacity: usize,
 ) -> ChunkedArray<T>
 where
-    T: RbArrowPrimitiveType,
+    T: RbPolarsNumericType,
 {
     // safety: we know the iterators len
     let mut ca: ChunkedArray<T> = unsafe {

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

@@ -1,4 +1,4 @@
-use magnus::{class, prelude::*, typed_data::Obj, IntoValue, TryConvert, Value};
+use magnus::{IntoValue, TryConvert, Value, class, prelude::*, typed_data::Obj};
 use polars::prelude::*;
 
 use super::*;
@@ -85,7 +85,7 @@ pub trait ApplyLambda<'a> {
         first_value: Option<D::Native>,
     ) -> RbResult<ChunkedArray<D>>
     where
-        D: RbArrowPrimitiveType,
+        D: RbPolarsNumericType,
         D::Native: IntoValue + TryConvert;
 
     /// Apply a lambda with a boolean output type
@@ -143,7 +143,7 @@ where
 {
     match call_lambda(lambda, in_val) {
         Ok(out) => S::try_convert(out),
-        Err(e) => panic!("ruby function failed {}", e),
+        Err(e) => panic!("ruby function failed {e}"),
     }
 }
 
@@ -219,7 +219,7 @@ impl<'a> ApplyLambda<'a> for BooleanChunked {
         first_value: Option<D::Native>,
     ) -> RbResult<ChunkedArray<D>>
     where
-        D: RbArrowPrimitiveType,
+        D: RbPolarsNumericType,
         D::Native: IntoValue + TryConvert,
     {
         let skip = usize::from(first_value.is_some());
@@ -438,7 +438,7 @@ impl<'a> ApplyLambda<'a> for BooleanChunked {
 
 impl<'a, T> ApplyLambda<'a> for ChunkedArray<T>
 where
-    T: RbArrowPrimitiveType + PolarsNumericType,
+    T: RbPolarsNumericType + PolarsNumericType,
     T::Native: IntoValue + TryConvert,
     ChunkedArray<T>: IntoSeries,
 {
@@ -503,7 +503,7 @@ where
         first_value: Option<D::Native>,
     ) -> RbResult<ChunkedArray<D>>
     where
-        D: RbArrowPrimitiveType,
+        D: RbPolarsNumericType,
         D::Native: IntoValue + TryConvert,
     {
         let skip = usize::from(first_value.is_some());
@@ -782,7 +782,7 @@ impl<'a> ApplyLambda<'a> for StringChunked {
         first_value: Option<D::Native>,
     ) -> RbResult<ChunkedArray<D>>
     where
-        D: RbArrowPrimitiveType,
+        D: RbPolarsNumericType,
         D::Native: IntoValue + TryConvert,
     {
         let skip = usize::from(first_value.is_some());
@@ -1047,7 +1047,7 @@ impl<'a> ApplyLambda<'a> for StructChunked {
         first_value: Option<D::Native>,
     ) -> RbResult<ChunkedArray<D>>
     where
-        D: RbArrowPrimitiveType,
+        D: RbPolarsNumericType,
         D::Native: IntoValue + TryConvert,
     {
         let skip = usize::from(first_value.is_some());

data/ext/polars/src/on_startup.rs

@@ -9,8 +9,8 @@ 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;
+use crate::prelude::ObjectValue;
 
 static POLARS_REGISTRY_INIT_LOCK: OnceLock<()> = OnceLock::new();
 
@@ -39,6 +39,9 @@ pub(crate) fn register_startup_deps() {
             object_converter,
             rbobject_converter,
             physical_dtype,
-        )
+        );
+        // TODO
+        // Register warning function for `polars_warn!`.
+        // polars_error::set_warning_function(warning_function);
     });
 }

data/ext/polars/src/rb_modules.rs

@@ -1,4 +1,4 @@
-use magnus::{value::Lazy, ExceptionClass, Module, RClass, RModule, Ruby};
+use magnus::{ExceptionClass, Module, RClass, RModule, Ruby, value::Lazy};
 
 static POLARS: Lazy<RModule> = Lazy::new(|ruby| ruby.class_object().const_get("Polars").unwrap());
 

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

@@ -1,8 +1,8 @@
-use magnus::{prelude::*, RArray, RString};
+use magnus::{RArray, RString, prelude::*};
 use polars_core::prelude::*;
 
 use crate::any_value::rb_object_to_any_value;
-use crate::conversion::{slice_extract_wrapped, vec_extract_wrapped, Wrap};
+use crate::conversion::{Wrap, slice_extract_wrapped, vec_extract_wrapped};
 use crate::prelude::ObjectValue;
 use crate::series::to_series;
 use crate::{RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError};
@@ -122,13 +122,17 @@ impl RbSeries {
             .into_iter()
             .map(|v| rb_object_to_any_value(v, strict))
             .collect::<RbResult<Vec<AnyValue>>>()?;
-        let s =
-            Series::from_any_values_and_dtype(name.into(), any_values.as_slice(), &dtype.0, strict)
-                .map_err(|e| {
-                    RbTypeError::new_err(format!(
+        let s = Series::from_any_values_and_dtype(
+            name.into(),
+            any_values.as_slice(),
+            &dtype.0,
+            strict,
+        )
+        .map_err(|e| {
+            RbTypeError::new_err(format!(
                 "{e}\n\nHint: Try setting `strict: false` to allow passing data with mixed types."
             ))
-                })?;
+        })?;
         Ok(s.into())
     }
 

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

@@ -1,8 +1,8 @@
-use magnus::{value::qnil, IntoValue, RArray, Value};
+use magnus::{IntoValue, RArray, Value, value::qnil};
 use polars_core::prelude::*;
 
-use crate::prelude::*;
 use crate::RbSeries;
+use crate::prelude::*;
 
 impl RbSeries {
     /// Convert this Series to a Ruby array.
@@ -25,7 +25,9 @@ impl RbSeries {
                 DataType::Float32 => RArray::from_iter(series.f32().unwrap()).into_value(),
                 DataType::Float64 => RArray::from_iter(series.f64().unwrap()).into_value(),
                 DataType::Categorical(_, _) | DataType::Enum(_, _) => {
-                    RArray::from_iter(series.categorical().unwrap().iter_str()).into_value()
+                    with_match_categorical_physical_type!(series.dtype().cat_physical().unwrap(), |$C| {
+                        RArray::from_iter(series.cat::<$C>().unwrap().iter_str()).into_value()
+                    })
                 }
                 DataType::Object(_) => {
                     let v = RArray::with_capacity(series.len());
@@ -132,7 +134,7 @@ impl RbSeries {
                     unreachable!()
                 }
             };
-            rblist
+            rblist.into_value()
         }
 
         to_a_recursive(series)