polars-df 0.25.0 → 0.26.0

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

@@ -4,9 +4,10 @@ use num_traits::AsPrimitive;
 use polars::prelude::*;
 
 use crate::any_value::rb_object_to_any_value;
-use crate::conversion::{Wrap, slice_extract_wrapped, vec_extract_wrapped};
+use crate::conversion::Wrap;
 use crate::prelude::ObjectValue;
-use crate::{RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError};
+use crate::ruby::gvl::GvlExt;
+use crate::{RbResult, RbSeries, RbTypeError, RbValueError};
 
 pub fn series_from_objects(rb: &Ruby, name: PlSmallStr, objects: Vec<ObjectValue>) -> Series {
     let mut validity = BitmapBuilder::with_capacity(objects.len());
@@ -107,21 +108,26 @@ impl RbSeries {
     }
 }
 
-fn vec_wrap_any_value<'s>(arr: RArray) -> RbResult<Vec<Wrap<AnyValue<'s>>>> {
-    let mut val = Vec::with_capacity(arr.len());
-    for v in arr.into_iter() {
-        val.push(Wrap::<AnyValue<'s>>::try_convert(v)?);
-    }
-    Ok(val)
+fn convert_to_avs(
+    values: RArray,
+    strict: bool,
+    allow_object: bool,
+) -> RbResult<Vec<AnyValue<'static>>> {
+    values
+        .into_iter()
+        .map(|v| rb_object_to_any_value(v, strict, allow_object))
+        .collect()
 }
 
 impl RbSeries {
     pub fn new_from_any_values(name: String, values: RArray, strict: bool) -> RbResult<Self> {
-        let any_values_result = vec_wrap_any_value(values);
-        // from anyvalues is fallible
+        let any_values_result = values
+            .into_iter()
+            .map(|v| rb_object_to_any_value(v, strict, true))
+            .collect::<RbResult<Vec<AnyValue>>>();
+
         let result = any_values_result.and_then(|avs| {
-            let avs = slice_extract_wrapped(&avs);
-            let s = Series::from_any_values(name.clone().into(), avs, strict).map_err(|e| {
+            let s = Series::from_any_values(name.clone().into(), avs.as_slice(), strict).map_err(|e| {
                 RbTypeError::new_err(format!(
                     "{e}\n\nHint: Try setting `strict: false` to allow passing data with mixed types."
                 ))
@@ -131,7 +137,7 @@ impl RbSeries {
 
         // Fall back to Object type for non-strict construction.
         if !strict && result.is_err() {
-            return Self::new_object(name, values, strict);
+            return Ruby::attach(|rb| Self::new_object(rb, name, values, strict));
         }
 
         result
@@ -143,21 +149,13 @@ impl RbSeries {
         dtype: Wrap<DataType>,
         strict: bool,
     ) -> RbResult<Self> {
-        let any_values = values
-            .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!(
-                "{e}\n\nHint: Try setting `strict: false` to allow passing data with mixed types."
-            ))
-        })?;
+        let avs = convert_to_avs(values, strict, false)?;
+        let s = Series::from_any_values_and_dtype(name.into(), avs.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())
     }
 
@@ -204,7 +202,7 @@ impl RbSeries {
         Ok(Series::new_null(name.into(), len).into())
     }
 
-    pub fn new_object(name: String, val: RArray, _strict: bool) -> RbResult<Self> {
+    pub fn new_object(_rb: &Ruby, name: String, val: RArray, _strict: bool) -> RbResult<Self> {
         let val = val
             .into_iter()
             .map(ObjectValue::from)
@@ -233,29 +231,12 @@ impl RbSeries {
     }
 
     pub fn new_array(
-        width: usize,
-        inner: Option<Wrap<DataType>>,
         name: String,
-        val: RArray,
-        _strict: bool,
+        values: RArray,
+        strict: bool,
+        dtype: Wrap<DataType>,
     ) -> RbResult<Self> {
-        let val = vec_wrap_any_value(val)?;
-        let val = vec_extract_wrapped(val);
-        let out = Series::new(name.into(), &val);
-        match out.dtype() {
-            DataType::List(list_inner) => {
-                let out = out
-                    .cast(&DataType::Array(
-                        Box::new(inner.map(|dt| dt.0).unwrap_or(*list_inner.clone())),
-                        width,
-                    ))
-                    .map_err(RbPolarsErr::from)?;
-                Ok(out.into())
-            }
-            _ => Err(RbValueError::new_err(
-                "could not create Array from input".to_string(),
-            )),
-        }
+        Self::new_from_any_values_and_dtype(name, values, dtype, strict)
     }
 
     pub fn new_decimal(name: String, values: RArray, strict: bool) -> RbResult<Self> {

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

@@ -2,49 +2,49 @@ use magnus::{IntoValue, Ruby, Value, value::ReprValue};
 use polars_core::prelude::*;
 
 use crate::prelude::*;
+use crate::ruby::utils::TryIntoValue;
 use crate::{RbPolarsErr, RbResult, RbSeries};
 
 impl RbSeries {
     /// Convert this Series to a Ruby array.
     /// This operation copies data.
-    pub fn to_a(&self) -> RbResult<Value> {
-        let series = &self.series.read();
+    pub fn to_a(ruby: &Ruby, self_: &Self) -> RbResult<Value> {
+        let series = &self_.series.read();
 
-        fn to_a_recursive(series: &Series) -> RbResult<Value> {
-            let ruby = Ruby::get().unwrap();
+        fn to_a_recursive(ruby: &Ruby, series: &Series) -> RbResult<Value> {
             let rblist = match series.dtype() {
                 DataType::Boolean => ruby
-                    .ary_from_iter(series.bool().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.bool().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt8 => ruby
-                    .ary_from_iter(series.u8().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u8().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt16 => ruby
-                    .ary_from_iter(series.u16().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u16().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt32 => ruby
-                    .ary_from_iter(series.u32().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u32().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt64 => ruby
-                    .ary_from_iter(series.u64().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u64().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::UInt128 => ruby
-                    .ary_from_iter(series.u128().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.u128().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int8 => ruby
-                    .ary_from_iter(series.i8().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i8().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int16 => ruby
-                    .ary_from_iter(series.i16().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i16().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int32 => ruby
-                    .ary_from_iter(series.i32().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i32().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int64 => ruby
-                    .ary_from_iter(series.i64().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i64().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Int128 => ruby
-                    .ary_from_iter(series.i128().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.i128().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Float16 => ruby
                     .ary_from_iter(
@@ -53,14 +53,15 @@ impl RbSeries {
                             .cast(&DataType::Float32)
                             .map_err(RbPolarsErr::from)?
                             .f32()
-                            .map_err(RbPolarsErr::from)?,
+                            .map_err(RbPolarsErr::from)?
+                            .iter(),
                     )
                     .as_value(),
                 DataType::Float32 => ruby
-                    .ary_from_iter(series.f32().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.f32().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Float64 => ruby
-                    .ary_from_iter(series.f64().map_err(RbPolarsErr::from)?)
+                    .ary_from_iter(series.f64().map_err(RbPolarsErr::from)?.iter())
                     .as_value(),
                 DataType::Categorical(_, _) | DataType::Enum(_, _) => {
                     with_match_categorical_physical_type!(series.dtype().cat_physical().unwrap(), |$C| {
@@ -71,10 +72,7 @@ impl RbSeries {
                     let v = ruby.ary_new_capa(series.len());
                     for i in 0..series.len() {
                         let obj: Option<&ObjectValue> = series.get_object(i).map(|any| any.into());
-                        match obj {
-                            Some(val) => v.push(val.to_value()).unwrap(),
-                            None => v.push(ruby.qnil()).unwrap(),
-                        };
+                        v.push(obj.cloned().into_value_with(ruby))?;
                     }
                     v.as_value()
                 }
@@ -87,7 +85,7 @@ impl RbSeries {
                                 v.push(ruby.qnil()).unwrap();
                             }
                             Some(s) => {
-                                let rblst = to_a_recursive(s.as_ref())?;
+                                let rblst = to_a_recursive(ruby, s.as_ref())?;
                                 v.push(rblst)?;
                             }
                         }
@@ -103,7 +101,7 @@ impl RbSeries {
                                 v.push(ruby.qnil()).unwrap();
                             }
                             Some(s) => {
-                                let rblst = to_a_recursive(s.as_ref())?;
+                                let rblst = to_a_recursive(ruby, s.as_ref())?;
                                 v.push(rblst)?;
                             }
                         }
@@ -112,35 +110,35 @@ impl RbSeries {
                 }
                 DataType::Date => {
                     let ca = series.date().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Time => {
                     let ca = series.time().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Datetime(_, _) => {
                     let ca = series.datetime().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Decimal(_, _) => {
                     let ca = series.decimal().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::String => {
                     let ca = series.str().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Struct(_) => {
                     let ca = series.struct_().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Duration(_) => {
                     let ca = series.duration().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Binary => {
                     let ca = series.binary().map_err(RbPolarsErr::from)?;
-                    return Ok(Wrap(ca).into_value_with(&ruby));
+                    return Wrap(ca).try_into_value_with(ruby);
                 }
                 DataType::Null => {
                     let null: Option<u8> = None;
@@ -163,10 +161,7 @@ impl RbSeries {
                     }
                     impl ExactSizeIterator for NullIter {}
 
-                    Ruby::get()
-                        .unwrap()
-                        .ary_from_iter(NullIter { iter, n })
-                        .as_value()
+                    ruby.ary_from_iter(NullIter { iter, n }).as_value()
                 }
                 DataType::Unknown(_) => {
                     panic!("to_a not implemented for unknown")
@@ -175,12 +170,12 @@ impl RbSeries {
                     unreachable!()
                 }
                 DataType::Extension(_, _) => {
-                    return to_a_recursive(series.ext().unwrap().storage());
+                    return to_a_recursive(ruby, series.ext().unwrap().storage());
                 }
             };
             Ok(rblist.as_value())
         }
 
-        to_a_recursive(series)
+        to_a_recursive(ruby, series)
     }
 }

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

@@ -10,7 +10,7 @@ use crate::ruby::exceptions::{RbIndexError, RbRuntimeError, RbValueError};
 use crate::ruby::gvl::GvlExt;
 use crate::ruby::plan_callback::PlanCallbackExt;
 use crate::ruby::ruby_function::RubyObject;
-use crate::ruby::thread::start_background_ruby_thread;
+use crate::ruby::utils::TryIntoValue;
 use crate::utils::EnterPolarsExt;
 use crate::{RbDataFrame, RbErr, RbPolarsErr, RbResult, RbSeries};
 
@@ -113,7 +113,7 @@ impl RbSeries {
                 let rbseries = RbSeries::new(s);
                 rb_modules::pl_utils(ruby).funcall("wrap_s", (rbseries,))
             }
-            _ => Ok(Wrap(av).into_value_with(ruby)),
+            _ => Wrap(av).try_into_value_with(ruby),
         }
     }
 
@@ -157,8 +157,8 @@ impl RbSeries {
         self.series.write().rename(name.into());
     }
 
-    pub fn dtype(rb: &Ruby, self_: &Self) -> Value {
-        Wrap(self_.series.read().dtype().clone()).into_value_with(rb)
+    pub fn dtype(rb: &Ruby, self_: &Self) -> RbResult<Value> {
+        Wrap(self_.series.read().dtype().clone()).try_into_value_with(rb)
     }
 
     pub fn set_sorted_flag(&self, descending: bool) -> Self {
@@ -445,10 +445,10 @@ impl RbSeries {
         width_strat: Wrap<ListToStructWidthStrategy>,
         name_gen: Option<Value>,
     ) -> RbResult<Self> {
-        start_background_ruby_thread(rb);
         let name_gen = name_gen.map(RubyObject::from);
+        // ensure new_ruby is called with GVL
+        let get_index_name = name_gen.map(PlanCallback::<usize, String>::new_ruby);
         rb.enter_polars(|| {
-            let get_index_name = name_gen.map(PlanCallback::<usize, String>::new_ruby);
             let get_index_name = get_index_name.map(|f| {
                 NameGenerator(Arc::new(move |i| f.call(i).map(PlSmallStr::from)) as Arc<_>)
             });

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

@@ -4,6 +4,7 @@ use super::RbSeries;
 use crate::map::series::ApplyLambdaGeneric;
 use crate::prelude::*;
 use crate::ruby::gvl::GvlExt;
+use crate::ruby::utils::TryIntoValue;
 use crate::series::construction::series_from_objects;
 use crate::{RbPolarsErr, RbResult};
 use crate::{apply_all_polars_dtypes, raise_err};
@@ -78,7 +79,7 @@ fn call_and_collect_objects<T, I>(
     skip_nulls: bool,
 ) -> RbResult<Series>
 where
-    T: IntoValue,
+    T: TryIntoValue,
     I: Iterator<Item = Option<T>>,
 {
     let mut objects = Vec::with_capacity(len);
@@ -91,7 +92,7 @@ where
                 continue;
             }
             None => rb.qnil().into_value_with(rb),
-            Some(val) => val.into_value_with(rb),
+            Some(val) => val.try_into_value_with(rb)?,
         };
         let out: Value = lambda.funcall("call", (arg,))?;
         objects.push(ObjectValue {

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

@@ -139,23 +139,23 @@ fn scatter_impl(
             with_match_physical_numeric_polars_type!(dt, |$T| {
                 let ca: &mut ChunkedArray<$T> = mutable_s.as_mut();
                 let values: &ChunkedArray<$T> = values.as_ref().as_ref();
-                ca.scatter(idx, values)
+                ca.scatter(idx, values.iter())
             })
         }
         DataType::Boolean => {
             let ca: &mut ChunkedArray<BooleanType> = mutable_s.as_mut();
             let values = values.bool()?;
-            ca.scatter(idx, values)
+            ca.scatter(idx, values.iter())
         }
         DataType::Binary => {
             let ca: &mut ChunkedArray<BinaryType> = mutable_s.as_mut();
             let values = values.binary()?;
-            ca.scatter(idx, values)
+            ca.scatter(idx, values.iter())
         }
         DataType::String => {
             let ca: &mut ChunkedArray<StringType> = mutable_s.as_mut();
             let values = values.str()?;
-            ca.scatter(idx, values)
+            ca.scatter(idx, values.iter())
         }
         _ => Err(PolarsError::ComputeError(
             format!("not yet implemented for dtype: {logical_dtype}").into(),

data/ext/polars/src/utils.rs

@@ -16,7 +16,6 @@ macro_rules! apply_all_polars_dtypes {
     ($self:expr, $method:ident, $($args:expr),*) => {
         match $self.dtype() {
             DataType::Boolean => $self.bool().unwrap().$method($($args),*),
-            DataType::String => $self.str().unwrap().$method($($args),*),
             DataType::UInt8 => $self.u8().unwrap().$method($($args),*),
             DataType::UInt16 => $self.u16().unwrap().$method($($args),*),
             DataType::UInt32 => $self.u32().unwrap().$method($($args),*),
@@ -27,15 +26,40 @@ macro_rules! apply_all_polars_dtypes {
             DataType::Int32 => $self.i32().unwrap().$method($($args),*),
             DataType::Int64 => $self.i64().unwrap().$method($($args),*),
             DataType::Int128 => $self.i128().unwrap().$method($($args),*),
-            DataType::Float16 => todo!(),
+            DataType::Float16 => $self.cast(&DataType::Float32).unwrap().f32().unwrap().$method($($args),*),
             DataType::Float32 => $self.f32().unwrap().$method($($args),*),
             DataType::Float64 => $self.f64().unwrap().$method($($args),*),
-            DataType::Date => $self.date().unwrap().physical().$method($($args),*),
-            DataType::Datetime(_, _) => $self.datetime().unwrap().physical().$method($($args),*),
-            // TODO implement
-            // DataType::List(_) => $self.list().unwrap().$method($($args),*),
+            DataType::String => $self.str().unwrap().$method($($args),*),
+            DataType::Binary => $self.binary().unwrap().$method($($args),*),
+            DataType::Decimal(_, _) => $self.decimal().unwrap().$method($($args),*),
+
+            DataType::Date => $self.date().unwrap().$method($($args),*),
+            DataType::Datetime(_, _) => $self.datetime().unwrap().$method($($args),*),
+            DataType::Duration(_) => $self.duration().unwrap().$method($($args),*),
+            DataType::Time => $self.time().unwrap().$method($($args),*),
+
+            DataType::List(_) => $self.list().unwrap().$method($($args),*),
             DataType::Struct(_) => $self.struct_().unwrap().$method($($args),*),
-            dt => panic!("dtype {:?} not supported", dt)
+            DataType::Array(_, _) => $self.array().unwrap().$method($($args),*),
+
+            dt @ (DataType::Categorical(_, _) | DataType::Enum(_, _)) => match dt.cat_physical().unwrap() {
+                CategoricalPhysical::U8 => $self.cat8().unwrap().$method($($args),*),
+                CategoricalPhysical::U16 => $self.cat16().unwrap().$method($($args),*),
+                CategoricalPhysical::U32 => $self.cat32().unwrap().$method($($args),*),
+            },
+
+            DataType::Object(_) => {
+                $self
+                .as_any()
+                .downcast_ref::<ObjectChunked<ObjectValue>>()
+                .unwrap()
+                .$method($($args),*)
+            },
+            DataType::Extension(_, _) => $self.ext().unwrap().$method($($args),*),
+
+            DataType::Null => $self.null().unwrap().$method($($args),*),
+
+            dt @ (DataType::BinaryOffset | DataType::Unknown(_)) => panic!("dtype {:?} not supported", dt)
         }
     }
 }

data/lib/polars/array_expr.rb

@@ -377,7 +377,9 @@ module Polars
     #   # │ [1, 2]    │
     #   # └───────────┘
     def unique(maintain_order: false)
-      Utils.wrap_expr(_rbexpr.arr_unique(maintain_order))
+      eval(
+        F.element.unique(maintain_order: maintain_order), as_list: true
+      )
     end
 
     # Count the number of unique values in every sub-arrays.
@@ -403,7 +405,7 @@ module Polars
     #   # │ [2, 3, 4]     ┆ 3        │
     #   # └───────────────┴──────────┘
     def n_unique
-      Utils.wrap_expr(_rbexpr.arr_n_unique)
+      agg(F.element.n_unique)
     end
 
     # Convert an Array column into a List column with the same inner data type.
@@ -432,6 +434,13 @@ module Polars
 
     # Evaluate whether any boolean value is true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `false`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `true` values,
+    #     the output is null.
+    #
     # @return [Expr]
     #
     # @example
@@ -461,12 +470,19 @@ module Polars
     #   # │ [null, null]   ┆ false │
     #   # │ null           ┆ null  │
     #   # └────────────────┴───────┘
-    def any
-      Utils.wrap_expr(_rbexpr.arr_any)
+    def any(ignore_nulls: true)
+      agg(F.element.any(ignore_nulls: ignore_nulls))
     end
 
     # Evaluate whether all boolean values are true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `true`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `false` values,
+    #     the output is null.
+    #
     # @return [Expr]
     #
     # @example
@@ -496,8 +512,8 @@ module Polars
     #   # │ [null, null]   ┆ true  │
     #   # │ null           ┆ null  │
     #   # └────────────────┴───────┘
-    def all
-      Utils.wrap_expr(_rbexpr.arr_all)
+    def all(ignore_nulls: true)
+      agg(F.element.all(ignore_nulls: ignore_nulls))
     end
 
     # Sort the arrays in this column.
@@ -567,7 +583,7 @@ module Polars
     #   # │ [9, 1, 2]     ┆ [2, 1, 9]     │
     #   # └───────────────┴───────────────┘
     def reverse
-      Utils.wrap_expr(_rbexpr.arr_reverse)
+      eval(F.element.reverse)
     end
 
     # Retrieve the index of the minimal value in every sub-array.

data/lib/polars/array_name_space.rb

@@ -212,6 +212,13 @@ module Polars
 
     # Evaluate whether any boolean value is true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `false`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `true` values,
+    #     the output is null.
+    #
     # @return [Series]
     #
     # @example
@@ -230,7 +237,7 @@ module Polars
     #   #         false
     #   #         null
     #   # ]
-    def any
+    def any(ignore_nulls: true)
       super
     end
 
@@ -378,6 +385,13 @@ module Polars
 
     # Evaluate whether all boolean values are true for every subarray.
     #
+    # @param ignore_nulls [Boolean]
+    #   * If set to `true` (default), null values are ignored. If there
+    #     are no non-null values, the output is `true`.
+    #   * If set to `false`, [Kleene logic](https://en.wikipedia.org/wiki/Three-valued_logic) is used to deal with nulls:
+    #     if the column contains any null values and no `false` values,
+    #     the output is null.
+    #
     # @return [Series]
     #
     # @example
@@ -396,7 +410,7 @@ module Polars
     #   #         true
     #   #         null
     #   # ]
-    def all
+    def all(ignore_nulls: true)
       super
     end
 

data/lib/polars/binary_name_space.rb

@@ -226,6 +226,38 @@ module Polars
       super
     end
 
+    # Get the byte value at the given index.
+    #
+    # For example, index `0` would return the first byte of every binary value
+    # and index `-1` would return the last byte of every binary value.
+    # The behavior if an index is out of bounds is determined by the argument
+    # `null_on_oob`.
+    #
+    # @param index [Object]
+    #   Index to return per binary value
+    # @param null_on_oob [Boolean]
+    #   Behavior if an index is out of bounds:
+    #
+    #   * true -> set as null
+    #   * false -> raise an error
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", ["\x01\x02\x03".b, "".b, "\x04\x05".b])
+    #   s.bin.get(0, null_on_oob: true)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [u8]
+    #   # [
+    #   #         1
+    #   #         null
+    #   #         4
+    #   # ]
+    def get(index, null_on_oob: false)
+      super
+    end
+
     # Take the first `n` bytes of the binary values.
     #
     # @param n [Object]

data/lib/polars/collect_batches.rb

@@ -14,5 +14,9 @@ module Polars
         yield DataFrame._from_rbdf(rbdf)
       end
     end
+
+    def arrow_c_stream
+      @inner.arrow_c_stream
+    end
   end
 end