polars-df 0.14.0 → 0.16.0

data/ext/polars/src/expr/general.rs

@@ -9,7 +9,6 @@ use polars_core::series::IsSorted;
 use crate::conversion::{parse_fill_null_strategy, Wrap};
 use crate::map::lazy::map_single;
 use crate::rb_exprs_to_exprs;
-use crate::utils::reinterpret;
 use crate::{RbExpr, RbResult};
 
 impl RbExpr {
@@ -165,7 +164,7 @@ impl RbExpr {
         self.inner.clone().implode().into()
     }
 
-    pub fn quantile(&self, quantile: &Self, interpolation: Wrap<QuantileInterpolOptions>) -> Self {
+    pub fn quantile(&self, quantile: &Self, interpolation: Wrap<QuantileMethod>) -> Self {
         self.inner
             .clone()
             .quantile(quantile.inner.clone(), interpolation.0)
@@ -272,6 +271,7 @@ impl RbExpr {
                 nulls_last,
                 multithreaded: true,
                 maintain_order: false,
+                limit: None,
             })
             .into()
     }
@@ -284,6 +284,7 @@ impl RbExpr {
                 nulls_last,
                 multithreaded: true,
                 maintain_order: false,
+                limit: None,
             })
             .into()
     }
@@ -364,6 +365,7 @@ impl RbExpr {
                     nulls_last,
                     multithreaded,
                     maintain_order,
+                    limit: None,
                 },
             )
             .into())
@@ -463,14 +465,7 @@ impl RbExpr {
     }
 
     pub fn gather_every(&self, n: usize, offset: usize) -> Self {
-        self.clone()
-            .inner
-            .map(
-                move |s: Series| Ok(Some(s.gather_every(n, offset))),
-                GetOutput::same_type(),
-            )
-            .with_fmt("gather_every")
-            .into()
+        self.inner.clone().gather_every(n, offset).into()
     }
 
     pub fn tail(&self, n: Option<usize>) -> Self {
@@ -644,8 +639,16 @@ impl RbExpr {
         output_type: Option<Wrap<DataType>>,
         agg_list: bool,
         is_elementwise: bool,
+        returns_scalar: bool,
     ) -> Self {
-        map_single(self, lambda, output_type, agg_list, is_elementwise)
+        map_single(
+            self,
+            lambda,
+            output_type,
+            agg_list,
+            is_elementwise,
+            returns_scalar,
+        )
     }
 
     pub fn dot(&self, other: &Self) -> Self {
@@ -653,16 +656,7 @@ impl RbExpr {
     }
 
     pub fn reinterpret(&self, signed: bool) -> Self {
-        let function = move |s: Series| reinterpret(&s, signed).map(Some);
-        let dt = if signed {
-            DataType::Int64
-        } else {
-            DataType::UInt64
-        };
-        self.clone()
-            .inner
-            .map(function, GetOutput::from_type(dt))
-            .into()
+        self.inner.clone().reinterpret(signed).into()
     }
 
     pub fn mode(&self) -> Self {
@@ -717,7 +711,7 @@ impl RbExpr {
     }
 
     pub fn reshape(&self, dims: Vec<i64>) -> Self {
-        self.inner.clone().reshape(&dims, NestedType::Array).into()
+        self.inner.clone().reshape(&dims).into()
     }
 
     pub fn cum_count(&self, reverse: bool) -> Self {

data/ext/polars/src/expr/list.rs

@@ -1,4 +1,4 @@
-use magnus::Value;
+use magnus::{prelude::*, value::Opaque, Ruby, Value};
 use polars::lazy::dsl::lit;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
@@ -179,23 +179,30 @@ impl RbExpr {
     pub fn list_to_struct(
         &self,
         width_strat: Wrap<ListToStructWidthStrategy>,
-        _name_gen: Option<Value>,
+        name_gen: Option<Value>,
         upper_bound: usize,
     ) -> RbResult<Self> {
-        // TODO fix
-        let name_gen = None;
-        // let name_gen = name_gen.map(|lambda| {
-        //     Arc::new(move |idx: usize| {
-        //         let out: Value = lambda.funcall("call", (idx,)).unwrap();
-        //         String::try_convert(out).unwrap()
-        //     }) as NameGenerator
-        // });
+        let name_gen = name_gen.map(|lambda| {
+            let lambda = Opaque::from(lambda);
+            Arc::new(move |idx: usize| {
+                let lambda = Ruby::get().unwrap().get_inner(lambda);
+                let out: String = lambda.funcall("call", (idx,)).unwrap();
+                PlSmallStr::from_string(out)
+            });
+
+            // non-Ruby thread
+            todo!();
+        });
 
         Ok(self
             .inner
             .clone()
             .list()
-            .to_struct(width_strat.0, name_gen, upper_bound)
+            .to_struct(ListToStructArgs::InferWidth {
+                infer_field_strategy: width_strat.0,
+                get_index_name: name_gen,
+                max_fields: upper_bound,
+            })
             .into())
     }
 

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

@@ -84,13 +84,17 @@ impl RbExpr {
         self.inner.clone().meta()._into_selector().into()
     }
 
-    pub fn meta_tree_format(&self) -> RbResult<String> {
+    fn compute_tree_format(&self, display_as_dot: bool) -> RbResult<String> {
         let e = self
             .inner
             .clone()
             .meta()
-            .into_tree_formatter()
+            .into_tree_formatter(display_as_dot)
             .map_err(RbPolarsErr::from)?;
         Ok(format!("{e}"))
     }
+
+    pub fn meta_tree_format(&self) -> RbResult<String> {
+        self.compute_tree_format(false)
+    }
 }

data/ext/polars/src/expr/rolling.rs

@@ -1,5 +1,4 @@
 use polars::prelude::*;
-use std::any::Any;
 
 use crate::conversion::Wrap;
 use crate::RbExpr;
@@ -169,7 +168,7 @@ impl RbExpr {
             weights,
             min_periods,
             center,
-            fn_params: Some(Arc::new(RollingVarParams { ddof }) as Arc<dyn Any + Send + Sync>),
+            fn_params: Some(RollingFnParams::Var(RollingVarParams { ddof })),
         };
 
         self.inner.clone().rolling_std(options).into()
@@ -187,7 +186,7 @@ impl RbExpr {
             window_size: Duration::parse(&window_size),
             min_periods,
             closed_window: closed.0,
-            fn_params: Some(Arc::new(RollingVarParams { ddof }) as Arc<dyn Any + Send + Sync>),
+            fn_params: Some(RollingFnParams::Var(RollingVarParams { ddof })),
         };
 
         self.inner
@@ -210,7 +209,7 @@ impl RbExpr {
             weights,
             min_periods,
             center,
-            fn_params: Some(Arc::new(RollingVarParams { ddof }) as Arc<dyn Any + Send + Sync>),
+            fn_params: Some(RollingFnParams::Var(RollingVarParams { ddof })),
         };
 
         self.inner.clone().rolling_var(options).into()
@@ -228,7 +227,7 @@ impl RbExpr {
             window_size: Duration::parse(&window_size),
             min_periods,
             closed_window: closed.0,
-            fn_params: Some(Arc::new(RollingVarParams { ddof }) as Arc<dyn Any + Send + Sync>),
+            fn_params: Some(RollingFnParams::Var(RollingVarParams { ddof })),
         };
 
         self.inner
@@ -277,7 +276,7 @@ impl RbExpr {
     pub fn rolling_quantile(
         &self,
         quantile: f64,
-        interpolation: Wrap<QuantileInterpolOptions>,
+        interpolation: Wrap<QuantileMethod>,
         window_size: usize,
         weights: Option<Vec<f64>>,
         min_periods: Option<usize>,
@@ -302,7 +301,7 @@ impl RbExpr {
         &self,
         by: &RbExpr,
         quantile: f64,
-        interpolation: Wrap<QuantileInterpolOptions>,
+        interpolation: Wrap<QuantileMethod>,
         window_size: String,
         min_periods: usize,
         closed: Wrap<ClosedWindow>,

data/ext/polars/src/expr/string.rs

@@ -130,6 +130,11 @@ impl RbExpr {
         self.inner.clone().str().to_lowercase().into()
     }
 
+    // requires nightly
+    // pub fn str_to_titlecase(&self) -> Self {
+    //     self.inner.clone().str().to_titlecase().into()
+    // }
+
     pub fn str_len_bytes(&self) -> Self {
         self.inner.clone().str().len_bytes().into()
     }
@@ -200,51 +205,19 @@ impl RbExpr {
     }
 
     pub fn str_hex_encode(&self) -> Self {
-        self.clone()
-            .inner
-            .map(
-                move |s| s.str().map(|s| Some(s.hex_encode().into_series())),
-                GetOutput::same_type(),
-            )
-            .with_fmt("str.hex_encode")
-            .into()
+        self.inner.clone().str().hex_encode().into()
     }
 
     pub fn str_hex_decode(&self, strict: bool) -> Self {
-        self.clone()
-            .inner
-            .map(
-                move |s| s.str()?.hex_decode(strict).map(|s| Some(s.into_series())),
-                GetOutput::same_type(),
-            )
-            .with_fmt("str.hex_decode")
-            .into()
+        self.inner.clone().str().hex_decode(strict).into()
     }
 
     pub fn str_base64_encode(&self) -> Self {
-        self.clone()
-            .inner
-            .map(
-                move |s| s.str().map(|s| Some(s.base64_encode().into_series())),
-                GetOutput::same_type(),
-            )
-            .with_fmt("str.base64_encode")
-            .into()
+        self.inner.clone().str().base64_encode().into()
     }
 
     pub fn str_base64_decode(&self, strict: bool) -> Self {
-        self.clone()
-            .inner
-            .map(
-                move |s| {
-                    s.str()?
-                        .base64_decode(strict)
-                        .map(|s| Some(s.into_series()))
-                },
-                GetOutput::same_type(),
-            )
-            .with_fmt("str.base64_decode")
-            .into()
+        self.inner.clone().str().base64_decode(strict).into()
     }
 
     pub fn str_to_integer(&self, base: &Self, strict: bool) -> Self {

data/ext/polars/src/file.rs

@@ -1,10 +1,12 @@
 use std::fs::File;
 use std::io;
-use std::io::{BufReader, Cursor, Read, Seek, SeekFrom, Write};
+use std::io::{Cursor, Read, Seek, SeekFrom, Write};
 use std::path::PathBuf;
 
 use magnus::{exception, prelude::*, Error, RString, Value};
+use polars::io::cloud::CloudOptions;
 use polars::io::mmap::MmapBytesReader;
+use polars_utils::mmap::MemSlice;
 
 use crate::error::RbPolarsErr;
 use crate::prelude::resolve_homedir;
@@ -24,9 +26,8 @@ impl RbFileLikeObject {
         RbFileLikeObject { inner: object }
     }
 
-    pub fn as_buffer(&self) -> std::io::Cursor<Vec<u8>> {
-        let data = self.as_file_buffer().into_inner();
-        std::io::Cursor::new(data)
+    pub fn as_bytes(&self) -> bytes::Bytes {
+        self.as_file_buffer().into_inner().into()
     }
 
     pub fn as_file_buffer(&self) -> Cursor<Vec<u8>> {
@@ -132,7 +133,42 @@ impl FileLike for RbFileLikeObject {}
 
 pub enum EitherRustRubyFile {
     Rb(RbFileLikeObject),
-    Rust(BufReader<File>),
+    Rust(File),
+}
+
+impl EitherRustRubyFile {
+    pub fn into_dyn(self) -> Box<dyn FileLike> {
+        match self {
+            EitherRustRubyFile::Rb(f) => Box::new(f),
+            EitherRustRubyFile::Rust(f) => Box::new(f),
+        }
+    }
+
+    pub fn into_dyn_writeable(self) -> Box<dyn Write> {
+        match self {
+            EitherRustRubyFile::Rb(f) => Box::new(f),
+            EitherRustRubyFile::Rust(f) => Box::new(f),
+        }
+    }
+}
+
+pub enum RubyScanSourceInput {
+    Buffer(MemSlice),
+    Path(PathBuf),
+    #[allow(dead_code)]
+    File(File),
+}
+
+pub fn get_ruby_scan_source_input(rb_f: Value, write: bool) -> RbResult<RubyScanSourceInput> {
+    if let Ok(file_path) = PathBuf::try_convert(rb_f) {
+        // TODO resolve_homedir
+        Ok(RubyScanSourceInput::Path(file_path))
+    } else {
+        let f = RbFileLikeObject::with_requirements(rb_f, !write, write, !write)?;
+        Ok(RubyScanSourceInput::Buffer(MemSlice::from_bytes(
+            f.as_bytes(),
+        )))
+    }
 }
 
 ///
@@ -142,14 +178,13 @@ pub fn get_either_file(rb_f: Value, truncate: bool) -> RbResult<EitherRustRubyFi
     if let Ok(rstring) = RString::try_convert(rb_f) {
         let s = unsafe { rstring.as_str() }?;
         let file_path = std::path::Path::new(&s);
-        let file_path = resolve_homedir(file_path);
+        let file_path = resolve_homedir(&file_path);
         let f = if truncate {
-            File::create(file_path).map_err(RbPolarsErr::io)?
+            File::create(file_path).map_err(RbPolarsErr::from)?
         } else {
             polars_utils::open_file(&file_path).map_err(RbPolarsErr::from)?
         };
-        let reader = BufReader::new(f);
-        Ok(EitherRustRubyFile::Rust(reader))
+        Ok(EitherRustRubyFile::Rust(f))
     } else {
         let f = RbFileLikeObject::with_requirements(rb_f, !truncate, truncate, !truncate)?;
         Ok(EitherRustRubyFile::Rb(f))
@@ -157,21 +192,41 @@ pub fn get_either_file(rb_f: Value, truncate: bool) -> RbResult<EitherRustRubyFi
 }
 
 pub fn get_file_like(f: Value, truncate: bool) -> RbResult<Box<dyn FileLike>> {
-    use EitherRustRubyFile::*;
-    match get_either_file(f, truncate)? {
-        Rb(f) => Ok(Box::new(f)),
-        Rust(f) => Ok(Box::new(f.into_inner())),
-    }
+    Ok(get_either_file(f, truncate)?.into_dyn())
 }
 
-pub fn get_mmap_bytes_reader(rb_f: Value) -> RbResult<Box<dyn MmapBytesReader>> {
-    if let Ok(bytes) = rb_f.funcall::<_, _, RString>("read", ()) {
-        let bytes = unsafe { bytes.as_slice() };
-        // TODO avoid copy
-        Ok(Box::new(Cursor::new(bytes.to_vec())))
-    } else {
-        let p = PathBuf::try_convert(rb_f)?;
-        let f = File::open(p).map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
-        Ok(Box::new(f))
+pub enum RbReadBytes {
+    Bytes(RString),
+    Other(Value),
+}
+
+pub fn read_if_bytesio(rb_f: Value) -> RbReadBytes {
+    rb_f.funcall("read", ())
+        .map(RbReadBytes::Bytes)
+        .unwrap_or(RbReadBytes::Other(rb_f))
+}
+
+pub fn get_mmap_bytes_reader<'a>(rb_f: &'a RbReadBytes) -> RbResult<Box<dyn MmapBytesReader + 'a>> {
+    get_mmap_bytes_reader_and_path(rb_f).map(|t| t.0)
+}
+
+pub fn get_mmap_bytes_reader_and_path<'a>(
+    rb_f: &'a RbReadBytes,
+) -> RbResult<(Box<dyn MmapBytesReader + 'a>, Option<PathBuf>)> {
+    match rb_f {
+        RbReadBytes::Bytes(v) => Ok((Box::new(Cursor::new(unsafe { v.as_slice() })), None)),
+        RbReadBytes::Other(v) => {
+            let path = PathBuf::try_convert(*v)?;
+            let f = File::open(&path)
+                .map_err(|e| Error::new(exception::runtime_error(), e.to_string()))?;
+            Ok((Box::new(f), Some(path)))
+        }
     }
 }
+
+pub fn try_get_writeable(
+    rb_f: Value,
+    _cloud_options: Option<&CloudOptions>,
+) -> RbResult<Box<dyn Write>> {
+    Ok(get_either_file(rb_f, true)?.into_dyn_writeable())
+}

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

@@ -28,14 +28,14 @@ pub fn min_horizontal(exprs: RArray) -> RbResult<RbExpr> {
     Ok(e.into())
 }
 
-pub fn sum_horizontal(exprs: RArray) -> RbResult<RbExpr> {
+pub fn sum_horizontal(exprs: RArray, ignore_nulls: bool) -> RbResult<RbExpr> {
     let exprs = rb_exprs_to_exprs(exprs)?;
-    let e = dsl::sum_horizontal(exprs).map_err(RbPolarsErr::from)?;
+    let e = dsl::sum_horizontal(exprs, ignore_nulls).map_err(RbPolarsErr::from)?;
     Ok(e.into())
 }
 
-pub fn mean_horizontal(exprs: RArray) -> RbResult<RbExpr> {
+pub fn mean_horizontal(exprs: RArray, ignore_nulls: bool) -> RbResult<RbExpr> {
     let exprs = rb_exprs_to_exprs(exprs)?;
-    let e = dsl::mean_horizontal(exprs).map_err(RbPolarsErr::from)?;
+    let e = dsl::mean_horizontal(exprs, ignore_nulls).map_err(RbPolarsErr::from)?;
     Ok(e.into())
 }

data/ext/polars/src/functions/business.rs

@@ -0,0 +1,15 @@
+use polars::lazy::dsl;
+
+use crate::RbExpr;
+
+// TODO add to Ruby
+pub fn business_day_count(
+    start: &RbExpr,
+    end: &RbExpr,
+    week_mask: [bool; 7],
+    holidays: Vec<i32>,
+) -> RbExpr {
+    let start = start.inner.clone();
+    let end = end.inner.clone();
+    dsl::business_day_count(start, end, week_mask, holidays).into()
+}

data/ext/polars/src/functions/io.rs

@@ -1,34 +1,55 @@
+use std::io::BufReader;
+
 use magnus::{RHash, Value};
+use polars::prelude::ArrowSchema;
+use polars_core::datatypes::create_enum_dtype;
+use polars_core::export::arrow::array::Utf8ViewArray;
 
 use crate::conversion::Wrap;
-use crate::file::get_file_like;
-use crate::prelude::DataType;
+use crate::file::{get_either_file, EitherRustRubyFile};
+use crate::prelude::ArrowDataType;
 use crate::{RbPolarsErr, RbResult};
 
 pub fn read_ipc_schema(rb_f: Value) -> RbResult<RHash> {
     use polars_core::export::arrow::io::ipc::read::read_file_metadata;
-    let mut r = get_file_like(rb_f, false)?;
-    let metadata = read_file_metadata(&mut r).map_err(RbPolarsErr::from)?;
+    let metadata = match get_either_file(rb_f, false)? {
+        EitherRustRubyFile::Rust(r) => {
+            read_file_metadata(&mut BufReader::new(r)).map_err(RbPolarsErr::from)?
+        }
+        EitherRustRubyFile::Rb(mut r) => read_file_metadata(&mut r).map_err(RbPolarsErr::from)?,
+    };
 
     let dict = RHash::new();
-    for field in metadata.schema.iter_values() {
-        let dt: Wrap<DataType> = Wrap((&field.dtype).into());
-        dict.aset(field.name.as_str(), dt)?;
-    }
+    fields_to_rbdict(&metadata.schema, &dict)?;
     Ok(dict)
 }
 
 pub fn read_parquet_schema(rb_f: Value) -> RbResult<RHash> {
     use polars_parquet::read::{infer_schema, read_metadata};
 
-    let mut r = get_file_like(rb_f, false)?;
-    let metadata = read_metadata(&mut r).map_err(RbPolarsErr::from)?;
+    let metadata = match get_either_file(rb_f, false)? {
+        EitherRustRubyFile::Rust(r) => {
+            read_metadata(&mut BufReader::new(r)).map_err(RbPolarsErr::from)?
+        }
+        EitherRustRubyFile::Rb(mut r) => read_metadata(&mut r).map_err(RbPolarsErr::from)?,
+    };
     let arrow_schema = infer_schema(&metadata).map_err(RbPolarsErr::from)?;
 
     let dict = RHash::new();
-    for field in arrow_schema.iter_values() {
-        let dt: Wrap<DataType> = Wrap((&field.dtype).into());
+    fields_to_rbdict(&arrow_schema, &dict)?;
+    Ok(dict)
+}
+
+fn fields_to_rbdict(schema: &ArrowSchema, dict: &RHash) -> RbResult<()> {
+    for field in schema.iter_values() {
+        let dt = if field.is_enum() {
+            Wrap(create_enum_dtype(Utf8ViewArray::new_empty(
+                ArrowDataType::Utf8View,
+            )))
+        } else {
+            Wrap(polars::prelude::DataType::from_arrow_field(field))
+        };
         dict.aset(field.name.as_str(), dt)?;
     }
-    Ok(dict)
+    Ok(())
 }

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

@@ -70,6 +70,7 @@ pub fn arg_sort_by(
             nulls_last,
             multithreaded,
             maintain_order,
+            limit: None,
         },
     )
     .into())
@@ -94,10 +95,7 @@ pub fn col(name: String) -> RbExpr {
 }
 
 pub fn collect_all(lfs: RArray) -> RbResult<RArray> {
-    let lfs = lfs
-        .into_iter()
-        .map(<&RbLazyFrame>::try_convert)
-        .collect::<RbResult<Vec<&RbLazyFrame>>>()?;
+    let lfs = lfs.typecheck::<Obj<RbLazyFrame>>()?;
 
     Ok(RArray::from_iter(lfs.iter().map(|lf| {
         let df = lf.ldf.borrow().clone().collect().unwrap();
@@ -173,8 +171,14 @@ pub fn cum_fold(
     let exprs = rb_exprs_to_exprs(exprs)?;
     let lambda = Opaque::from(lambda);
 
-    let func =
-        move |a: Series, b: Series| binary_lambda(Ruby::get().unwrap().get_inner(lambda), a, b);
+    let func = move |a: Column, b: Column| {
+        binary_lambda(
+            Ruby::get().unwrap().get_inner(lambda),
+            a.take_materialized_series(),
+            b.take_materialized_series(),
+        )
+        .map(|v| v.map(Column::from))
+    };
     Ok(dsl::cum_fold_exprs(acc.inner.clone(), func, exprs, include_init).into())
 }
 
@@ -263,8 +267,14 @@ pub fn fold(acc: &RbExpr, lambda: Value, exprs: RArray) -> RbResult<RbExpr> {
     let exprs = rb_exprs_to_exprs(exprs)?;
     let lambda = Opaque::from(lambda);
 
-    let func =
-        move |a: Series, b: Series| binary_lambda(Ruby::get().unwrap().get_inner(lambda), a, b);
+    let func = move |a: Column, b: Column| {
+        binary_lambda(
+            Ruby::get().unwrap().get_inner(lambda),
+            a.take_materialized_series(),
+            b.take_materialized_series(),
+        )
+        .map(|v| v.map(Column::from))
+    };
     Ok(dsl::fold_exprs(acc.inner.clone(), func, exprs).into())
 }
 
@@ -311,8 +321,8 @@ pub fn lit(value: Value, allow_object: bool) -> RbResult<RbExpr> {
     }
 }
 
-pub fn pearson_corr(a: &RbExpr, b: &RbExpr, ddof: u8) -> RbExpr {
-    dsl::pearson_corr(a.inner.clone(), b.inner.clone(), ddof).into()
+pub fn pearson_corr(a: &RbExpr, b: &RbExpr) -> RbExpr {
+    dsl::pearson_corr(a.inner.clone(), b.inner.clone()).into()
 }
 
 pub fn repeat(value: &RbExpr, n: &RbExpr, dtype: Option<Wrap<DataType>>) -> RbResult<RbExpr> {
@@ -336,8 +346,8 @@ pub fn repeat(value: &RbExpr, n: &RbExpr, dtype: Option<Wrap<DataType>>) -> RbRe
     Ok(dsl::repeat(value, n).into())
 }
 
-pub fn spearman_rank_corr(a: &RbExpr, b: &RbExpr, ddof: u8, propagate_nans: bool) -> RbExpr {
-    dsl::spearman_rank_corr(a.inner.clone(), b.inner.clone(), ddof, propagate_nans).into()
+pub fn spearman_rank_corr(a: &RbExpr, b: &RbExpr, propagate_nans: bool) -> RbExpr {
+    dsl::spearman_rank_corr(a.inner.clone(), b.inner.clone(), propagate_nans).into()
 }
 
 pub fn sql_expr(sql: String) -> RbResult<RbExpr> {

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

@@ -11,7 +11,7 @@ pub fn get_index_type() -> Value {
     Wrap(IDX_DTYPE).into_value()
 }
 
-pub fn threadpool_size() -> usize {
+pub fn thread_pool_size() -> usize {
     POOL.current_num_threads()
 }
 

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

@@ -1,4 +1,5 @@
 pub mod aggregation;
+pub mod business;
 pub mod eager;
 pub mod io;
 pub mod lazy;

data/ext/polars/src/interop/arrow/mod.rs

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