polars-df 0.25.1 → 0.26.1

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

@@ -2,7 +2,7 @@ use std::hash::BuildHasher;
 
 use arrow::bitmap::MutableBitmap;
 use either::Either;
-use magnus::{IntoValue, RArray, Ruby, Value, prelude::*, value::Opaque};
+use magnus::{RArray, Ruby, Value, prelude::*, value::Opaque};
 use polars::prelude::*;
 
 use crate::conversion::*;
@@ -10,6 +10,7 @@ use crate::prelude::strings_to_pl_smallstr;
 use crate::rb_modules::pl_utils;
 use crate::ruby::exceptions::RbIndexError;
 use crate::ruby::gvl::GvlExt;
+use crate::ruby::utils::TryIntoValue;
 use crate::series::ToRbSeries;
 use crate::series::to_series;
 use crate::utils::EnterPolarsExt;
@@ -144,13 +145,13 @@ impl RbDataFrame {
         Ok(())
     }
 
-    pub fn dtypes(ruby: &Ruby, self_: &Self) -> RArray {
+    pub fn dtypes(ruby: &Ruby, self_: &Self) -> RbResult<RArray> {
         let df = self_.df.read();
         let iter = df
             .columns()
             .iter()
-            .map(|s| Wrap(s.dtype().clone()).into_value_with(ruby));
-        ruby.ary_from_iter(iter)
+            .map(|s| Wrap(s.dtype().clone()).try_into_value_with(ruby));
+        ruby.ary_try_from_iter(iter)
     }
 
     pub fn n_chunks(&self) -> usize {

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

@@ -5,7 +5,7 @@ use polars_core::utils::CustomIterTools;
 use super::*;
 use crate::error::RbPolarsErr;
 use crate::prelude::*;
-use crate::ruby::utils::to_pl_err;
+use crate::ruby::utils::{TryIntoValue, to_pl_err};
 use crate::series::construction::series_from_objects;
 use crate::{RbResult, RbSeries, raise_err};
 
@@ -28,9 +28,11 @@ impl RbDataFrame {
         drop(df); // Release lock before calling lambda.
 
         let lambda_result_iter = (0..height).map(move |_| {
-            let iter = iters.iter_mut().map(|it| Wrap(it.next().unwrap()));
-            let tpl = rb.ary_from_iter(iter);
-            lambda.funcall::<_, _, Value>("call", (tpl,))
+            let iter = iters
+                .iter_mut()
+                .map(|it| Wrap(it.next().unwrap()).try_into_value_with(rb));
+            rb.ary_try_from_iter(iter)
+                .and_then(|tpl| lambda.funcall::<_, _, Value>("call", (tpl,)))
         });
 
         // Simple case: return type set.

data/ext/polars/src/error.rs

@@ -63,7 +63,7 @@ impl From<RbPolarsErr> for Error {
                 PolarsError::StructFieldNotFound(name) => {
                     StructFieldNotFoundError::new_err(name.to_string())
                 }
-                PolarsError::Context { .. } => {
+                PolarsError::Context { .. } | PolarsError::ExprContext { .. } => {
                     let tmp = RbPolarsErr::Polars(err.context_trace());
                     RbErr::from(tmp)
                 }

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

@@ -38,30 +38,10 @@ impl RbExpr {
         self.inner.clone().arr().median().into()
     }
 
-    pub fn arr_unique(&self, maintain_order: bool) -> Self {
-        if maintain_order {
-            self.inner.clone().arr().unique_stable().into()
-        } else {
-            self.inner.clone().arr().unique().into()
-        }
-    }
-
-    pub fn arr_n_unique(&self) -> Self {
-        self.inner.clone().arr().n_unique().into()
-    }
-
     pub fn arr_to_list(&self) -> Self {
         self.inner.clone().arr().to_list().into()
     }
 
-    pub fn arr_all(&self) -> Self {
-        self.inner.clone().arr().all().into()
-    }
-
-    pub fn arr_any(&self) -> Self {
-        self.inner.clone().arr().any().into()
-    }
-
     pub fn arr_sort(&self, descending: bool, nulls_last: bool) -> Self {
         self.inner
             .clone()
@@ -74,10 +54,6 @@ impl RbExpr {
             .into()
     }
 
-    pub fn arr_reverse(&self) -> Self {
-        self.inner.clone().arr().reverse().into()
-    }
-
     pub fn arr_arg_min(&self) -> Self {
         self.inner.clone().arr().arg_min().into()
     }

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

@@ -1,7 +1,8 @@
-use magnus::{IntoValue, RArray, Ruby, TryConvert, Value};
+use magnus::{RArray, Ruby, TryConvert, Value};
 use polars::prelude::{DataType, DataTypeExpr, PlSmallStr, Schema};
 
 use crate::prelude::Wrap;
+use crate::ruby::utils::TryIntoValue;
 use crate::{RbExpr, RbPolarsErr, RbResult};
 
 #[magnus::wrap(class = "Polars::RbDataTypeExpr")]
@@ -36,7 +37,7 @@ impl RbDataTypeExpr {
             .inner
             .into_datatype(&schema.0)
             .map_err(RbPolarsErr::from)?;
-        Ok(Wrap(dtype).into_value_with(ruby))
+        Wrap(dtype).try_into_value_with(ruby)
     }
 
     pub fn struct_with_fields(rb_fields: RArray) -> RbResult<Self> {

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

@@ -8,13 +8,13 @@ impl RbExpr {
         &self,
         n: &RbExpr,
         week_mask: [bool; 7],
-        holidays: Vec<i32>,
+        holidays: &RbExpr,
         roll: Wrap<Roll>,
     ) -> Self {
         self.inner
             .clone()
             .dt()
-            .add_business_days(n.inner.clone(), week_mask, holidays, roll.0)
+            .add_business_days(n.inner.clone(), week_mask, holidays.inner.clone(), roll.0)
             .into()
     }
 
@@ -133,11 +133,11 @@ impl RbExpr {
         self.clone().inner.dt().year().into()
     }
 
-    pub fn dt_is_business_day(&self, week_mask: [bool; 7], holidays: Vec<i32>) -> Self {
+    pub fn dt_is_business_day(&self, week_mask: [bool; 7], holidays: &RbExpr) -> Self {
         self.inner
             .clone()
             .dt()
-            .is_business_day(week_mask, holidays)
+            .is_business_day(week_mask, holidays.inner.clone())
             .into()
     }
 

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

@@ -5,13 +5,13 @@ use polars::lazy::dsl;
 use polars::prelude::*;
 use polars::series::ops::NullBehavior;
 use polars_core::chunked_array::cast::CastOptions;
-use polars_core::series::IsSorted;
+use polars_plan::plans::AExprSorted;
 
 use super::datatype::RbDataTypeExpr;
 use super::selector::RbSelector;
 use crate::conversion::{Wrap, parse_fill_null_strategy};
 use crate::expr::ToExprs;
-use crate::{RbExpr, RbPolarsErr, RbResult};
+use crate::{RbDataType, RbExpr, RbPolarsErr, RbResult};
 
 impl RbExpr {
     pub fn add(&self, rhs: &Self) -> RbResult<Self> {
@@ -182,8 +182,8 @@ impl RbExpr {
         self.inner.clone().item(allow_empty).into()
     }
 
-    pub fn implode(&self) -> Self {
-        self.inner.clone().implode().into()
+    pub fn implode(&self, maintain_order: bool) -> Self {
+        self.inner.clone().implode(maintain_order).into()
     }
 
     pub fn quantile(&self, quantile: &Self, interpolation: Wrap<QuantileMethod>) -> Self {
@@ -366,8 +366,11 @@ impl RbExpr {
             .into()
     }
 
-    pub fn gather(&self, idx: &Self) -> Self {
-        self.inner.clone().gather(idx.inner.clone()).into()
+    pub fn gather(&self, idx: &Self, null_on_oob: bool) -> Self {
+        self.inner
+            .clone()
+            .gather(idx.inner.clone(), null_on_oob)
+            .into()
     }
 
     pub fn get(&self, idx: &Self, null_on_oob: bool) -> Self {
@@ -530,6 +533,10 @@ impl RbExpr {
         self.clone().inner.round_sig_figs(digits).into()
     }
 
+    pub fn truncate(&self, decimals: u32) -> Self {
+        self.inner.clone().truncate(decimals).into()
+    }
+
     pub fn floor(&self) -> Self {
         self.inner.clone().floor().into()
     }
@@ -727,8 +734,11 @@ impl RbExpr {
         self.inner.clone().dot(other.inner.clone()).into()
     }
 
-    pub fn reinterpret(&self, signed: bool) -> Self {
-        self.inner.clone().reinterpret(signed).into()
+    pub fn reinterpret(&self, signed: Option<bool>, dtype: Option<RbDataType>) -> Self {
+        self.inner
+            .clone()
+            .reinterpret(signed, dtype.map(|dt| dt.0))
+            .into()
     }
 
     pub fn mode(&self, maintain_order: bool) -> Self {
@@ -904,6 +914,10 @@ impl RbExpr {
         self.inner.clone().all(drop_nulls).into()
     }
 
+    pub fn is_empty(&self, ignore_nulls: bool) -> Self {
+        self.inner.clone().is_empty(ignore_nulls).into()
+    }
+
     pub fn log(&self, base: &RbExpr) -> Self {
         self.inner.clone().log(base.inner.clone()).into()
     }
@@ -924,13 +938,11 @@ impl RbExpr {
         self.inner.clone().hash(seed, seed_1, seed_2, seed_3).into()
     }
 
-    pub fn set_sorted_flag(&self, descending: bool) -> Self {
-        let is_sorted = if descending {
-            IsSorted::Descending
-        } else {
-            IsSorted::Ascending
-        };
-        self.inner.clone().set_sorted_flag(is_sorted).into()
+    pub fn set_sorted_flag(&self, descending: bool, nulls_last: bool) -> Self {
+        let sortedness = AExprSorted::default()
+            .with_desc(Some(descending))
+            .with_nulls_last(Some(nulls_last));
+        self.inner.clone().set_sorted_flag(sortedness).into()
     }
 
     pub fn replace(&self, old: &Self, new: &Self) -> Self {

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

@@ -7,14 +7,6 @@ use crate::conversion::Wrap;
 use crate::{RbExpr, RbResult};
 
 impl RbExpr {
-    pub fn list_all(&self) -> Self {
-        self.inner.clone().list().all().into()
-    }
-
-    pub fn list_any(&self) -> Self {
-        self.inner.clone().list().any().into()
-    }
-
     pub fn list_arg_max(&self) -> Self {
         self.inner.clone().list().arg_max().into()
     }
@@ -103,10 +95,6 @@ impl RbExpr {
         self.inner.clone().list().min().into()
     }
 
-    pub fn list_reverse(&self) -> Self {
-        self.inner.clone().list().reverse().into()
-    }
-
     pub fn list_shift(&self, periods: &RbExpr) -> Self {
         self.inner
             .clone()
@@ -213,20 +201,6 @@ impl RbExpr {
             .into())
     }
 
-    pub fn list_n_unique(&self) -> Self {
-        self.inner.clone().list().n_unique().into()
-    }
-
-    pub fn list_unique(&self, maintain_order: bool) -> Self {
-        let e = self.inner.clone();
-
-        if maintain_order {
-            e.list().unique_stable().into()
-        } else {
-            e.list().unique().into()
-        }
-    }
-
     pub fn list_set_operation(&self, other: &RbExpr, operation: Wrap<SetOperation>) -> Self {
         let e = self.inner.clone().list();
         match operation.0 {

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

@@ -6,9 +6,9 @@ pub fn business_day_count(
     start: &RbExpr,
     end: &RbExpr,
     week_mask: [bool; 7],
-    holidays: Vec<i32>,
+    holidays: &RbExpr,
 ) -> RbExpr {
     let start = start.inner.clone();
     let end = end.inner.clone();
-    dsl::business_day_count(start, end, week_mask, holidays).into()
+    dsl::business_day_count(start, end, week_mask, holidays.inner.clone()).into()
 }

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

@@ -8,6 +8,7 @@ use crate::conversion::Wrap;
 use crate::file::{EitherRustRubyFile, get_either_file};
 use crate::io::cloud_options::OptRbCloudOptions;
 use crate::ruby::gvl::GvlExt;
+use crate::ruby::utils::TryIntoValue;
 use crate::{RbPolarsErr, RbResult};
 
 pub fn read_ipc_schema(rb: &Ruby, rb_f: Value) -> RbResult<RHash> {
@@ -32,7 +33,6 @@ pub fn read_parquet_metadata(
 ) -> RbResult<RHash> {
     use std::io::Cursor;
 
-    use polars_io::pl_async::get_runtime;
     use polars_parquet::read::read_metadata;
     use polars_parquet::read::schema::read_custom_key_value_metadata;
 
@@ -53,7 +53,7 @@ pub fn read_parquet_metadata(
                 use polars_error::PolarsResult;
 
                 rb.detach(|| {
-                    get_runtime().block_on(async {
+                    polars_core::runtime::ASYNC.block_on(async {
                         let mut reader =
                             ParquetObjectStore::from_uri(p, cloud_options.as_ref(), None).await?;
                         let result = reader.get_metadata().await?;
@@ -97,9 +97,10 @@ pub fn read_parquet_schema(rb_f: Value) -> RbResult<RHash> {
 }
 
 fn fields_to_rbdict(schema: &ArrowSchema, dict: &RHash) -> RbResult<()> {
+    let ruby = &Ruby::get_with(*dict);
     for field in schema.iter_values() {
         let dt = Wrap(polars::prelude::DataType::from_arrow_field(field));
-        dict.aset(field.name.as_str(), dt)?;
+        dict.aset(field.name.as_str(), dt.try_into_value_with(ruby)?)?;
     }
     Ok(())
 }

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

@@ -1,17 +1,23 @@
 use magnus::encoding::EncodingCapable;
-use magnus::{Float, Integer, RArray, RString, Ruby, Value, prelude::*, typed_data::Obj};
+use magnus::{
+    Float, Integer, RArray, RString, Ruby, Value, prelude::*, typed_data::Obj, value::Qfalse,
+    value::Qtrue,
+};
 use polars::lazy::dsl;
 use polars::prelude::*;
+use polars_plan::plans::DynLiteralValue;
 
+use crate::conversion::any_value::rb_object_to_any_value;
 use crate::conversion::{Wrap, get_lf, get_rbseq};
 use crate::expr::ToExprs;
 use crate::expr::datatype::RbDataTypeExpr;
 use crate::lazyframe::RbOptFlags;
+use crate::ruby::exceptions::{RbTypeError, RbValueError};
 use crate::ruby::plan_callback::PlanCallbackExt;
 use crate::ruby::ruby_function::RubyObject;
 use crate::ruby::thread::start_background_ruby_thread;
 use crate::utils::EnterPolarsExt;
-use crate::{RbDataFrame, RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbValueError, map};
+use crate::{RbDataFrame, RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, map};
 
 macro_rules! set_unwrapped_or_0 {
     ($($var:ident),+ $(,)?) => {
@@ -378,34 +384,28 @@ pub fn fold(
     .into())
 }
 
-pub fn lit(value: Value, allow_object: bool, is_scalar: bool) -> RbResult<RbExpr> {
+pub fn lit(rb: &Ruby, value: Value, allow_object: bool, is_scalar: bool) -> RbResult<RbExpr> {
     let ruby = Ruby::get_with(value);
-    if value.is_kind_of(ruby.class_true_class()) || value.is_kind_of(ruby.class_false_class()) {
-        Ok(dsl::lit(bool::try_convert(value)?).into())
-    } else if let Some(v) = Integer::from_value(value) {
-        match v.to_i64() {
-            Ok(val) => {
-                if val > 0 && val < i32::MAX as i64 || val < 0 && val > i32::MIN as i64 {
-                    Ok(dsl::lit(val as i32).into())
-                } else {
-                    Ok(dsl::lit(val).into())
-                }
-            }
-            _ => {
-                let val = v.to_u64()?;
-                Ok(dsl::lit(val).into())
-            }
-        }
-    } else if let Some(v) = Float::from_value(value) {
-        Ok(dsl::lit(v.to_f64()).into())
-    } else if let Some(v) = RString::from_value(value) {
-        if v.enc_get() == ruby.utf8_encindex() {
-            Ok(dsl::lit(v.to_string()?).into())
+    if Qtrue::from_value(value).is_some() {
+        Ok(dsl::lit(true).into())
+    } else if Qfalse::from_value(value).is_some() {
+        Ok(dsl::lit(false).into())
+    } else if let Some(int) = Integer::from_value(value) {
+        let v = i128::try_convert(int.as_value())
+            .map_err(|e| polars_err!(InvalidOperation: "integer too large for Polars: {e}"))
+            .map_err(RbPolarsErr::from)?;
+        Ok(Expr::Literal(LiteralValue::Dyn(DynLiteralValue::Int(v))).into())
+    } else if let Some(float) = Float::from_value(value) {
+        let val = f64::try_convert(float.as_value())?;
+        Ok(Expr::Literal(LiteralValue::Dyn(DynLiteralValue::Float(val))).into())
+    } else if let Some(rbstr) = RString::from_value(value) {
+        if rbstr.enc_get() == ruby.utf8_encindex() {
+            Ok(dsl::lit(rbstr.to_string()?).into())
         } else {
-            Ok(dsl::lit(unsafe { v.as_slice() }).into())
+            Ok(dsl::lit(unsafe { rbstr.as_slice() }).into())
         }
-    } else if let Ok(series) = Obj::<RbSeries>::try_convert(value) {
-        let s = series.series.read();
+    } else if let Ok(series) = <&RbSeries>::try_convert(value) {
+        let s = series.clone().series.into_inner();
         if is_scalar {
             let av = s
                 .get(0)
@@ -413,17 +413,39 @@ pub fn lit(value: Value, allow_object: bool, is_scalar: bool) -> RbResult<RbExpr
             let av = av.into_static();
             Ok(dsl::lit(Scalar::new(s.dtype().clone(), av)).into())
         } else {
-            Ok(dsl::lit(s.clone()).into())
+            Ok(dsl::lit(s).into())
         }
     } else if value.is_nil() {
         Ok(dsl::lit(Null {}).into())
-    } else if allow_object {
-        todo!()
     } else {
-        Err(RbValueError::new_err(format!(
-            "could not convert value {:?} as a Literal",
-            value.to_string()
-        )))
+        let raise = || {
+            RbTypeError::new_err(format!(
+                "cannot create expression literal for value of type {}.\
+                    \n\nHint: Pass `allow_object: true` to accept any value and create a literal of type Object.",
+                unsafe { value.classname() },
+            ))
+        };
+
+        let av = rb_object_to_any_value(value, true, allow_object).map_err(|_| raise())?;
+        match av {
+            AnyValue::ObjectOwned(_) => {
+                // Check again for object allowance as for cached addresses this is not checked.
+                if allow_object {
+                    let s = RbSeries::new_object(
+                        rb,
+                        "".to_string(),
+                        rb.ary_new_from_values(&[value]),
+                        false,
+                    )?
+                    .series
+                    .into_inner();
+                    Ok(dsl::lit(s).into())
+                } else {
+                    Err(raise())
+                }
+            }
+            _ => Ok(Expr::Literal(LiteralValue::from(av)).into()),
+        }
     }
 }
 
@@ -461,7 +483,7 @@ pub fn reduce(
     .into())
 }
 
-pub fn repeat(value: &RbExpr, n: &RbExpr, dtype: Option<Wrap<DataType>>) -> RbResult<RbExpr> {
+pub fn repeat(value: &RbExpr, n: &RbExpr, dtype: Option<Wrap<DataType>>) -> RbExpr {
     let mut value = value.inner.clone();
     let n = n.inner.clone();
 
@@ -469,17 +491,7 @@ pub fn repeat(value: &RbExpr, n: &RbExpr, dtype: Option<Wrap<DataType>>) -> RbRe
         value = value.cast(dtype.0);
     }
 
-    if let Expr::Literal(lv) = &value {
-        let av = lv.to_any_value().unwrap();
-        // Integer inputs that fit in Int32 are parsed as such
-        if let DataType::Int64 = av.dtype() {
-            let int_value = av.try_extract::<i64>().unwrap();
-            if int_value >= i32::MIN as i64 && int_value <= i32::MAX as i64 {
-                value = value.cast(DataType::Int32);
-            }
-        }
-    }
-    Ok(dsl::repeat(value, n).into())
+    dsl::repeat(value, n).into()
 }
 
 pub fn spearman_rank_corr(a: &RbExpr, b: &RbExpr, propagate_nans: bool) -> RbExpr {

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

@@ -1,18 +1,19 @@
-use magnus::{IntoValue, Ruby, Value};
+use magnus::{Ruby, Value};
 use polars_core;
-use polars_core::POOL;
 use polars_core::fmt::FloatFmt;
 use polars_core::prelude::IDX_DTYPE;
+use polars_core::runtime::RAYON;
 
 use crate::conversion::Wrap;
+use crate::ruby::utils::TryIntoValue;
 use crate::{RbResult, RbValueError};
 
-pub fn get_index_type(ruby: &Ruby) -> Value {
-    Wrap(IDX_DTYPE).into_value_with(ruby)
+pub fn get_index_type(ruby: &Ruby) -> RbResult<Value> {
+    Wrap(IDX_DTYPE).try_into_value_with(ruby)
 }
 
 pub fn thread_pool_size() -> usize {
-    POOL.current_num_threads()
+    RAYON.current_num_threads()
 }
 
 pub fn set_float_fmt(fmt: String) -> RbResult<()> {

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

@@ -7,7 +7,6 @@ pub mod meta;
 pub mod misc;
 pub mod random;
 pub mod range;
-pub mod string_cache;
 pub mod strings;
 pub mod utils;
 pub mod whenthen;

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

@@ -1,6 +1,8 @@
 use crate::RbResult;
-use polars_core::config::get_engine_affinity;
 
 pub fn rb_get_engine_affinity() -> RbResult<String> {
-    Ok(get_engine_affinity())
+    Ok(polars_config::config()
+        .engine_affinity()
+        .as_static_str()
+        .to_string())
 }

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

@@ -1,10 +1,11 @@
 use magnus::prelude::*;
-use magnus::{RHash, Value};
+use magnus::{RHash, Ruby, Value};
 use polars::prelude::{ArrowDataType, DataType};
 use polars_error::polars_err;
 
 use crate::interop::arrow::to_rust::normalize_arrow_fields;
 use crate::prelude::Wrap;
+use crate::ruby::utils::TryIntoValue;
 use crate::series::import_schema_rbcapsule;
 use crate::utils::to_rb_err;
 use crate::{RbResult, RbValueError};
@@ -16,6 +17,7 @@ pub fn init_polars_schema_from_arrow_c_schema(
     polars_schema: RHash,
     schema_object: Value,
 ) -> RbResult<()> {
+    let ruby = &Ruby::get_with(polars_schema);
     let schema_capsule = schema_object.funcall("arrow_c_schema", ())?;
 
     let field = import_schema_rbcapsule(schema_capsule)?;
@@ -33,7 +35,7 @@ pub fn init_polars_schema_from_arrow_c_schema(
         let dtype = DataType::from_arrow_field(&field);
 
         let name = field.name.as_str();
-        let dtype = Wrap(dtype);
+        let dtype = Wrap(dtype).try_into_value_with(ruby)?;
 
         if polars_schema.get(name).is_some() {
             return Err(to_rb_err(polars_err!(

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

@@ -6,20 +6,12 @@ use polars::frame::DataFrame;
 use polars::prelude::{ArrayRef, ArrowField, PlSmallStr, PolarsResult, SchemaExt};
 use polars::series::Series;
 use polars_core::utils::arrow;
+use std::ffi::CString;
 
 use crate::RbResult;
+use crate::ruby::capsule::RbCapsule;
 
-#[magnus::wrap(class = "Polars::ArrowArrayStream")]
-pub struct RbArrowArrayStream {
-    pub(crate) stream: ffi::ArrowArrayStream,
-}
-
-impl RbArrowArrayStream {
-    pub fn to_i(&self) -> usize {
-        (&self.stream as *const _) as usize
-    }
-}
-
+// TODO switch to RbCapsule in 0.27.0
 #[magnus::wrap(class = "Polars::ArrowSchema")]
 pub struct RbArrowSchema {
     pub(crate) schema: ffi::ArrowSchema,
@@ -31,11 +23,24 @@ impl RbArrowSchema {
     }
 }
 
+pub(crate) fn series_to_stream(series: &Series, ruby: &Ruby) -> RbResult<Value> {
+    let field = series.field().to_arrow(CompatLevel::newest());
+    let series = series.clone();
+    let iter = Box::new(
+        (0..series.n_chunks()).map(move |i| Ok(series.to_arrow(i, CompatLevel::newest()))),
+    ) as _;
+
+    let stream = ffi::export_iterator(iter, field);
+    let stream_capsule_name = CString::new("arrow_array_stream").unwrap();
+    Ok(RbCapsule::new(stream, Some(stream_capsule_name)).into_value_with(ruby))
+}
+
 pub(crate) fn dataframe_to_stream(df: &DataFrame, ruby: &Ruby) -> RbResult<Value> {
     let iter = Box::new(DataFrameStreamIterator::new(df));
     let field = iter.field();
     let stream = ffi::export_iterator(iter, field);
-    Ok(RbArrowArrayStream { stream }.into_value_with(ruby))
+    let stream_capsule_name = CString::new("arrow_array_stream").unwrap();
+    Ok(RbCapsule::new(stream, Some(stream_capsule_name)).into_value_with(ruby))
 }
 
 pub(crate) fn polars_schema_to_rbcapsule(