polars-df 0.16.0 → 0.17.1

data/LICENSE.txt

@@ -1,5 +1,5 @@
 Copyright (c) 2020 Ritchie Vink
-Copyright (c) 2022-2024 Andrew Kane
+Copyright (c) 2022-2025 Andrew Kane
 Some portions Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy

data/README.md

@@ -1,6 +1,6 @@
 # Ruby Polars
 
-:fire: Blazingly fast DataFrames for Ruby, powered by [Polars](https://github.com/pola-rs/polars)
+🔥 Blazingly fast DataFrames for Ruby, powered by [Polars](https://github.com/pola-rs/polars)
 
 [![Build Status](https://github.com/ankane/ruby-polars/actions/workflows/build.yml/badge.svg)](https://github.com/ankane/ruby-polars/actions)
 
@@ -88,7 +88,7 @@ From Avro
 Polars.read_avro("file.avro")
 ```
 
-From Delta Lake (requires [deltalake-rb](https://github.com/ankane/delta-ruby)) [experimental, unreleased]
+From Delta Lake (requires [deltalake-rb](https://github.com/ankane/delta-ruby)) [experimental]
 
 ```ruby
 Polars.read_delta("./table")
@@ -365,7 +365,7 @@ Avro
 df.write_avro("file.avro")
 ```
 
-Delta Lake [experimental, unreleased]
+Delta Lake [experimental]
 
 ```ruby
 df.write_delta("./table")
@@ -448,7 +448,7 @@ df.group_by("c").plot("a", "b", stacked: true)
 
 ## History
 
-View the [changelog](CHANGELOG.md)
+View the [changelog](https://github.com/ankane/ruby-polars/blob/master/CHANGELOG.md)
 
 ## Contributing
 

data/ext/polars/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polars"
-version = "0.16.0"
+version = "0.17.1"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2021"
@@ -12,20 +12,22 @@ crate-type = ["cdylib"]
 
 [dependencies]
 ahash = "0.8"
-arrow = { package = "polars-arrow", version = "=0.45.1" }
+arrow = { package = "polars-arrow", version = "=0.46.0" }
 bytes = "1"
 chrono = "0.4"
 either = "1.8"
 magnus = "0.7"
-polars-core = "=0.45.1"
-polars-plan = "=0.45.1"
-polars-parquet = "=0.45.1"
-polars-utils = "=0.45.1"
+num-traits = "0.2"
+polars-core = "=0.46.0"
+polars-plan = "=0.46.0"
+polars-parquet = "=0.46.0"
+polars-utils = "=0.46.0"
+rayon = "1.9"
 regex = "1"
 serde_json = "1"
 
 [dependencies.polars]
-version = "=0.45.1"
+version = "=0.46.0"
 features = [
     "abs",
     "approx_unique",
@@ -62,6 +64,7 @@ features = [
     "gcp",
     "http",
     "interpolate",
+    "interpolate_by",
     "ipc",
     "ipc_streaming",
     "is_between",

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

@@ -17,7 +17,7 @@ impl IntoValue for Wrap<AnyValue<'_>> {
     }
 }
 
-impl<'s> TryConvert for Wrap<AnyValue<'s>> {
+impl TryConvert for Wrap<AnyValue<'_>> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         rb_object_to_any_value(ob, true).map(Wrap)
     }
@@ -33,6 +33,7 @@ pub(crate) fn any_value_into_rb_object(av: AnyValue, ruby: &Ruby) -> Value {
         AnyValue::Int16(v) => ruby.into_value(v),
         AnyValue::Int32(v) => ruby.into_value(v),
         AnyValue::Int64(v) => ruby.into_value(v),
+        AnyValue::Int128(_v) => todo!(),
         AnyValue::Float32(v) => ruby.into_value(v),
         AnyValue::Float64(v) => ruby.into_value(v),
         AnyValue::Null => ruby.qnil().as_value(),

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

@@ -146,6 +146,10 @@ impl IntoValue for Wrap<DataType> {
                 let class = pl.const_get::<_, Value>("Int64").unwrap();
                 class.funcall("new", ()).unwrap()
             }
+            DataType::Int128 => {
+                let class = pl.const_get::<_, Value>("Int128").unwrap();
+                class.funcall("new", ()).unwrap()
+            }
             DataType::UInt8 => {
                 let class = pl.const_get::<_, Value>("UInt8").unwrap();
                 class.funcall("new", ()).unwrap()
@@ -1061,6 +1065,24 @@ impl TryConvert for Wrap<JoinValidation> {
     }
 }
 
+impl TryConvert for Wrap<MaintainOrderJoin> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "none" => MaintainOrderJoin::None,
+            "left" => MaintainOrderJoin::Left,
+            "right" => MaintainOrderJoin::Right,
+            "left_right" => MaintainOrderJoin::LeftRight,
+            "right_left" => MaintainOrderJoin::RightLeft,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`maintain_order` must be one of {{'none', 'left', 'right', 'left_right', 'right_left'}}, got {v}",
+                )))
+            },
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
 impl TryConvert for Wrap<QuoteStyle> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let parsed = match String::try_convert(ob)?.as_str() {

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

@@ -295,11 +295,11 @@ impl RbDataFrame {
         Ok(())
     }
 
-    pub fn slice(&self, offset: usize, length: Option<usize>) -> Self {
-        let df = self.df.borrow().slice(
-            offset as i64,
-            length.unwrap_or_else(|| self.df.borrow().height()),
-        );
+    pub fn slice(&self, offset: i64, length: Option<usize>) -> Self {
+        let df = self
+            .df
+            .borrow()
+            .slice(offset, length.unwrap_or_else(|| self.df.borrow().height()));
         df.into()
     }
 

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

@@ -296,30 +296,24 @@ impl RbDataFrame {
         Ok(())
     }
 
-    pub fn write_json(&self, rb_f: Value, pretty: bool, row_oriented: bool) -> RbResult<()> {
+    pub fn write_json(&self, rb_f: Value) -> RbResult<()> {
         let file = BufWriter::new(get_file_like(rb_f, true)?);
 
-        let r = match (pretty, row_oriented) {
-            (_, true) => JsonWriter::new(file)
-                .with_json_format(JsonFormat::Json)
-                .finish(&mut self.df.borrow_mut()),
-            (true, _) => serde_json::to_writer_pretty(file, &*self.df.borrow())
-                .map_err(|e| PolarsError::ComputeError(format!("{:?}", e).into())),
-            (false, _) => serde_json::to_writer(file, &*self.df.borrow())
-                .map_err(|e| PolarsError::ComputeError(format!("{:?}", e).into())),
-        };
-        r.map_err(|e| RbPolarsErr::Other(format!("{:?}", e)))?;
+        JsonWriter::new(file)
+            .with_json_format(JsonFormat::Json)
+            .finish(&mut self.df.borrow_mut())
+            .map_err(RbPolarsErr::from)?;
         Ok(())
     }
 
     pub fn write_ndjson(&self, rb_f: Value) -> RbResult<()> {
         let file = BufWriter::new(get_file_like(rb_f, true)?);
 
-        let r = JsonWriter::new(file)
+        JsonWriter::new(file)
             .with_json_format(JsonFormat::JsonLines)
-            .finish(&mut self.df.borrow_mut());
+            .finish(&mut self.df.borrow_mut())
+            .map_err(RbPolarsErr::from)?;
 
-        r.map_err(|e| RbPolarsErr::Other(format!("{:?}", e)))?;
         Ok(())
     }
 

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

@@ -671,6 +671,10 @@ impl RbExpr {
         self.inner.clone().interpolate(method.0).into()
     }
 
+    pub fn interpolate_by(&self, by: &Self) -> Self {
+        self.inner.clone().interpolate_by(by.inner.clone()).into()
+    }
+
     pub fn lower_bound(&self) -> Self {
         self.inner.clone().lower_bound().into()
     }

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

@@ -1,9 +1,9 @@
 use std::io::BufReader;
 
+use arrow::array::Utf8ViewArray;
 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_either_file, EitherRustRubyFile};
@@ -11,7 +11,7 @@ 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;
+    use arrow::io::ipc::read::read_file_metadata;
     let metadata = match get_either_file(rb_f, false)? {
         EitherRustRubyFile::Rust(r) => {
             read_file_metadata(&mut BufReader::new(r)).map_err(RbPolarsErr::from)?

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

@@ -205,6 +205,21 @@ pub fn concat_lf_diagonal(
     Ok(lf.into())
 }
 
+pub fn concat_lf_horizontal(lfs: RArray, parallel: bool) -> RbResult<RbLazyFrame> {
+    let iter = lfs.into_iter();
+
+    let lfs = iter.map(get_lf).collect::<RbResult<Vec<_>>>()?;
+
+    let args = UnionArgs {
+        rechunk: false, // No need to rechunk with horizontal concatenation
+        parallel,
+        to_supertypes: false,
+        ..Default::default()
+    };
+    let lf = dsl::functions::concat_lf_horizontal(lfs, args).map_err(RbPolarsErr::from)?;
+    Ok(lf.into())
+}
+
 pub fn dtype_cols(dtypes: RArray) -> RbResult<RbExpr> {
     let dtypes = dtypes
         .into_iter()

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

@@ -1,2 +1,3 @@
+pub mod numo_rs;
 pub mod to_numo_df;
 pub mod to_numo_series;

data/ext/polars/src/interop/numo/numo_rs.rs

@@ -0,0 +1,52 @@
+use magnus::{class, prelude::*, IntoValue, Module, RArray, RClass, RModule, Value};
+
+use crate::RbResult;
+
+pub trait Element: IntoValue {
+    fn class_name() -> &'static str;
+}
+
+macro_rules! create_element {
+    ($type:ty, $name:expr) => {
+        impl Element for $type {
+            fn class_name() -> &'static str {
+                $name
+            }
+        }
+    };
+}
+
+create_element!(i8, "Int8");
+create_element!(i16, "Int16");
+create_element!(i32, "Int32");
+create_element!(i64, "Int64");
+create_element!(u8, "UInt8");
+create_element!(u16, "UInt16");
+create_element!(u32, "UInt32");
+create_element!(u64, "UInt64");
+create_element!(f32, "SFloat");
+create_element!(f64, "DFloat");
+create_element!(bool, "Bit");
+
+impl<T> Element for Option<T>
+where
+    Option<T>: IntoValue,
+{
+    fn class_name() -> &'static str {
+        "RObject"
+    }
+}
+
+pub struct RbArray1<T>(T);
+
+impl<T: Element> RbArray1<T> {
+    pub fn from_iter<I>(values: I) -> RbResult<Value>
+    where
+        I: IntoIterator<Item = T>,
+    {
+        class::object()
+            .const_get::<_, RModule>("Numo")?
+            .const_get::<_, RClass>(T::class_name())?
+            .funcall("cast", (RArray::from_iter(values),))
+    }
+}

data/ext/polars/src/interop/numo/to_numo_series.rs

@@ -1,61 +1,82 @@
-use magnus::{class, prelude::*, Module, RArray, RClass, RModule, Value};
-use polars::series::BitRepr;
+use magnus::Value;
+use num_traits::{Float, NumCast};
 use polars_core::prelude::*;
 
+use super::numo_rs::{Element, RbArray1};
 use crate::error::RbPolarsErr;
 use crate::raise_err;
 use crate::series::RbSeries;
 use crate::RbResult;
 
 impl RbSeries {
-    /// For numeric types, this should only be called for Series with null types.
-    /// This will cast to floats so that `nil = NAN`
+    /// Convert this Series to a Numo array.
     pub fn to_numo(&self) -> RbResult<Value> {
-        let s = &self.series.borrow();
-        match s.dtype() {
-            DataType::String => {
-                let ca = s.str().unwrap();
+        series_to_numo(&self.series.borrow())
+    }
+}
+
+/// Convert a Series to a Numo array.
+fn series_to_numo(s: &Series) -> RbResult<Value> {
+    series_to_numo_with_copy(s)
+}
 
-                // TODO make more efficient
-                let np_arr = RArray::from_iter(ca);
-                class::object()
-                    .const_get::<_, RModule>("Numo")?
-                    .const_get::<_, RClass>("RObject")?
-                    .funcall("cast", (np_arr,))
-            }
-            dt if dt.is_numeric() => {
-                if let Some(BitRepr::Large(_)) = s.bit_repr() {
-                    let s = s.cast(&DataType::Float64).unwrap();
-                    let ca = s.f64().unwrap();
-                    // TODO make more efficient
-                    let np_arr = RArray::from_iter(ca.into_iter().map(|opt_v| match opt_v {
-                        Some(v) => v,
-                        None => f64::NAN,
-                    }));
-                    class::object()
-                        .const_get::<_, RModule>("Numo")?
-                        .const_get::<_, RClass>("DFloat")?
-                        .funcall("cast", (np_arr,))
-                } else {
-                    let s = s.cast(&DataType::Float32).unwrap();
-                    let ca = s.f32().unwrap();
-                    // TODO make more efficient
-                    let np_arr = RArray::from_iter(ca.into_iter().map(|opt_v| match opt_v {
-                        Some(v) => v,
-                        None => f32::NAN,
-                    }));
-                    class::object()
-                        .const_get::<_, RModule>("Numo")?
-                        .const_get::<_, RClass>("SFloat")?
-                        .funcall("cast", (np_arr,))
-                }
-            }
-            dt => {
-                raise_err!(
-                    format!("'to_numo' not supported for dtype: {dt:?}"),
-                    ComputeError
-                );
-            }
+/// Convert a Series to a Numo array, copying data in the process.
+fn series_to_numo_with_copy(s: &Series) -> RbResult<Value> {
+    use DataType::*;
+    match s.dtype() {
+        Int8 => numeric_series_to_numpy::<Int8Type, f32>(s),
+        Int16 => numeric_series_to_numpy::<Int16Type, f32>(s),
+        Int32 => numeric_series_to_numpy::<Int32Type, f64>(s),
+        Int64 => numeric_series_to_numpy::<Int64Type, f64>(s),
+        UInt8 => numeric_series_to_numpy::<UInt8Type, f32>(s),
+        UInt16 => numeric_series_to_numpy::<UInt16Type, f32>(s),
+        UInt32 => numeric_series_to_numpy::<UInt32Type, f64>(s),
+        UInt64 => numeric_series_to_numpy::<UInt64Type, f64>(s),
+        Float32 => numeric_series_to_numpy::<Float32Type, f32>(s),
+        Float64 => numeric_series_to_numpy::<Float64Type, f64>(s),
+        Boolean => boolean_series_to_numo(s),
+        String => {
+            let ca = s.str().unwrap();
+            RbArray1::from_iter(ca)
+        }
+        dt => {
+            raise_err!(
+                format!("'to_numo' not supported for dtype: {dt:?}"),
+                ComputeError
+            );
         }
     }
 }
+
+/// Convert numeric types to f32 or f64 with NaN representing a null value.
+fn numeric_series_to_numpy<T, U>(s: &Series) -> RbResult<Value>
+where
+    T: PolarsNumericType,
+    T::Native: Element,
+    U: Float + Element,
+{
+    let ca: &ChunkedArray<T> = s.as_ref().as_ref();
+    if s.null_count() == 0 {
+        let values = ca.into_no_null_iter();
+        RbArray1::<T::Native>::from_iter(values)
+    } else {
+        let mapper = |opt_v: Option<T::Native>| match opt_v {
+            Some(v) => NumCast::from(v).unwrap(),
+            None => U::nan(),
+        };
+        let values = ca.iter().map(mapper);
+        RbArray1::from_iter(values)
+    }
+}
+
+/// Convert booleans to bit if no nulls are present, otherwise convert to objects.
+fn boolean_series_to_numo(s: &Series) -> RbResult<Value> {
+    let ca = s.bool().unwrap();
+    if s.null_count() == 0 {
+        let values = ca.into_no_null_iter();
+        RbArray1::<bool>::from_iter(values)
+    } else {
+        let values = ca.iter();
+        RbArray1::from_iter(values)
+    }
+}

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

@@ -431,27 +431,24 @@ impl RbLazyFrame {
         Ok(())
     }
 
-    #[allow(clippy::too_many_arguments)]
-    pub fn sink_csv(
-        &self,
-        path: PathBuf,
-        include_bom: bool,
-        include_header: bool,
-        separator: u8,
-        line_terminator: String,
-        quote_char: u8,
-        batch_size: Wrap<NonZeroUsize>,
-        datetime_format: Option<String>,
-        date_format: Option<String>,
-        time_format: Option<String>,
-        float_scientific: Option<bool>,
-        float_precision: Option<usize>,
-        null_value: Option<String>,
-        quote_style: Option<Wrap<QuoteStyle>>,
-        maintain_order: bool,
-    ) -> RbResult<()> {
-        // TODO
-        let cloud_options = None;
+    pub fn sink_csv(&self, arguments: &[Value]) -> RbResult<()> {
+        let path = PathBuf::try_convert(arguments[0])?;
+        let include_bom = bool::try_convert(arguments[1])?;
+        let include_header = bool::try_convert(arguments[2])?;
+        let separator = u8::try_convert(arguments[3])?;
+        let line_terminator = String::try_convert(arguments[4])?;
+        let quote_char = u8::try_convert(arguments[5])?;
+        let batch_size = Wrap::<NonZeroUsize>::try_convert(arguments[6])?;
+        let datetime_format = Option::<String>::try_convert(arguments[7])?;
+        let date_format = Option::<String>::try_convert(arguments[8])?;
+        let time_format = Option::<String>::try_convert(arguments[9])?;
+        let float_scientific = Option::<bool>::try_convert(arguments[10])?;
+        let float_precision = Option::<usize>::try_convert(arguments[11])?;
+        let null_value = Option::<String>::try_convert(arguments[12])?;
+        let quote_style = Option::<Wrap<QuoteStyle>>::try_convert(arguments[13])?;
+        let maintain_order = bool::try_convert(arguments[14])?;
+        let cloud_options = Option::<Vec<(String, String)>>::try_convert(arguments[15])?;
+        let retries = usize::try_convert(arguments[16])?;
 
         let quote_style = quote_style.map_or(QuoteStyle::default(), |wrap| wrap.0);
         let null_value = null_value.unwrap_or(SerializeOptions::default().null);
@@ -480,7 +477,7 @@ impl RbLazyFrame {
         let cloud_options = {
             let cloud_options =
                 parse_cloud_options(path.to_str().unwrap(), cloud_options.unwrap_or_default())?;
-            Some(cloud_options)
+            Some(cloud_options.with_max_retries(retries))
         };
 
         let ldf = self.ldf.borrow().clone();
@@ -633,6 +630,8 @@ impl RbLazyFrame {
         tolerance: Option<Wrap<AnyValue<'_>>>,
         tolerance_str: Option<String>,
         coalesce: bool,
+        allow_eq: bool,
+        check_sortedness: bool,
     ) -> RbResult<Self> {
         let coalesce = if coalesce {
             JoinCoalesce::CoalesceColumns
@@ -657,6 +656,8 @@ impl RbLazyFrame {
                 right_by: right_by.map(strings_to_pl_smallstr),
                 tolerance: tolerance.map(|t| t.0.into_static()),
                 tolerance_str: tolerance_str.map(|s| s.into()),
+                allow_eq,
+                check_sortedness,
             }))
             .suffix(suffix)
             .finish()
@@ -675,6 +676,7 @@ impl RbLazyFrame {
         how: Wrap<JoinType>,
         suffix: String,
         validate: Wrap<JoinValidation>,
+        maintain_order: Wrap<MaintainOrderJoin>,
         coalesce: Option<bool>,
     ) -> RbResult<Self> {
         let coalesce = match coalesce {
@@ -698,6 +700,7 @@ impl RbLazyFrame {
             .how(how.0)
             .validate(validate.0)
             .coalesce(coalesce)
+            .maintain_order(maintain_order.0)
             .suffix(suffix)
             .finish()
             .into())

data/ext/polars/src/lib.rs

@@ -69,7 +69,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("estimated_size", method!(RbDataFrame::estimated_size, 0))?;
     class.define_method("dtype_strings", method!(RbDataFrame::dtype_strings, 0))?;
     class.define_method("write_avro", method!(RbDataFrame::write_avro, 3))?;
-    class.define_method("write_json", method!(RbDataFrame::write_json, 3))?;
+    class.define_method("write_json", method!(RbDataFrame::write_json, 1))?;
     class.define_method("write_ndjson", method!(RbDataFrame::write_ndjson, 1))?;
     class.define_method("write_csv", method!(RbDataFrame::write_csv, 10))?;
     class.define_method("write_ipc", method!(RbDataFrame::write_ipc, 5))?;
@@ -430,6 +430,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     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))?;
     class.define_method("rolling_sum_by", method!(RbExpr::rolling_sum_by, 4))?;
     class.define_method("rolling_min", method!(RbExpr::rolling_min, 4))?;
@@ -614,6 +615,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "concat_lf_diagonal",
         function!(functions::lazy::concat_lf_diagonal, 4),
     )?;
+    class.define_singleton_method(
+        "concat_lf_horizontal",
+        function!(functions::lazy::concat_lf_horizontal, 2),
+    )?;
     class.define_singleton_method("concat_df", function!(functions::eager::concat_df, 1))?;
     class.define_singleton_method("concat_lf", function!(functions::lazy::concat_lf, 4))?;
     class.define_singleton_method(
@@ -745,7 +750,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("collect", method!(RbLazyFrame::collect, 0))?;
     class.define_method("sink_parquet", method!(RbLazyFrame::sink_parquet, 9))?;
     class.define_method("sink_ipc", method!(RbLazyFrame::sink_ipc, 5))?;
-    class.define_method("sink_csv", method!(RbLazyFrame::sink_csv, 15))?;
+    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))?;
@@ -758,8 +763,8 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         method!(RbLazyFrame::group_by_dynamic, 9),
     )?;
     class.define_method("with_context", method!(RbLazyFrame::with_context, 1))?;
-    class.define_method("join_asof", method!(RbLazyFrame::join_asof, 12))?;
-    class.define_method("join", method!(RbLazyFrame::join, 10))?;
+    class.define_method("join_asof", method!(RbLazyFrame::join_asof, 14))?;
+    class.define_method("join", method!(RbLazyFrame::join, 11))?;
     class.define_method("with_column", method!(RbLazyFrame::with_column, 1))?;
     class.define_method("with_columns", method!(RbLazyFrame::with_columns, 1))?;
     class.define_method(

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

@@ -5,9 +5,9 @@ pub mod series;
 use magnus::{prelude::*, RHash, Value};
 use polars::chunked_array::builder::get_list_builder;
 use polars::prelude::*;
-use polars_core::export::rayon::prelude::*;
 use polars_core::utils::CustomIterTools;
 use polars_core::POOL;
+use rayon::prelude::*;
 
 use crate::{ObjectValue, RbPolarsErr, RbResult, RbSeries, Wrap};
 

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

@@ -21,6 +21,7 @@ impl RbSeries {
                 DataType::Int16 => RArray::from_iter(series.i16().unwrap()).into_value(),
                 DataType::Int32 => RArray::from_iter(series.i32().unwrap()).into_value(),
                 DataType::Int64 => RArray::from_iter(series.i64().unwrap()).into_value(),
+                DataType::Int128 => todo!(),
                 DataType::Float32 => RArray::from_iter(series.f32().unwrap()).into_value(),
                 DataType::Float64 => RArray::from_iter(series.f64().unwrap()).into_value(),
                 DataType::Categorical(_, _) | DataType::Enum(_, _) => {

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

@@ -1,7 +1,7 @@
+use arrow::array::Array;
+use arrow::ffi::{ArrowArrayStream, ArrowArrayStreamReader};
 use magnus::prelude::*;
 use magnus::Value;
-use polars::export::arrow::array::Array;
-use polars::export::arrow::ffi::{ArrowArrayStream, ArrowArrayStreamReader};
 use polars::prelude::*;
 
 use super::RbSeries;

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

@@ -1,4 +1,4 @@
-use polars::export::arrow::array::Array;
+use arrow::array::Array;
 use polars::prelude::*;
 
 use crate::error::RbPolarsErr;