polars-df 0.26.0 → 0.26.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2166cba9f090e8a98fdd28f09ef84bda7130502339522fb724f994581191ffa0
-  data.tar.gz: bfdd2939e545302b8a050c706112ae59a297054d048daa4551fd1227589eeba6
+  metadata.gz: 6e17df47d46e8c53ba63698ff3d91f67cd4eb4f9d7d1833a676c12c743ca7adb
+  data.tar.gz: a5d055718adbcc275b35f8a069be8b25261fb34dcdba3c64dea8d444982e0072
 SHA512:
-  metadata.gz: 189165a0d01be7174c29ebe5678c9e7bc0cd88e6f0bada0e424967b17b3e56f649645a4bd9de7b409f270390f82be94faf7d12a3bd3ca39de2cc04705382eb78
-  data.tar.gz: 1daf4e9a15adb6f09497ac729ef5ff4fb33de85df5b65d79bfca5de976c9f09d371e7564c00814c9cf20dc606b413fb708de3ea1aeb44c337e1aacaebd09a457
+  metadata.gz: 7a928541df7f9f4a0cb4cc034935729f99c34ad66444e5ac17b969e1ead01e45077de7b7a75b0bf039e13d055160324374e8deab4ff30b3d2230c061852d11af
+  data.tar.gz: 6838a74b47b629afb8f6cf263f41743488ca027ee4ed46d42b19d55a251ad0920c86654cbbacee0245251cabafe317c9475701deb011b2cbfbd7fa7115d0a5eb

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 0.26.1 (2026-07-22)
+
+- Added support for more types to `scan_iceberg` method
+- Fixed return dtype for `cum_sum_horizontal` method
+
 ## 0.26.0 (2026-06-04)
 
 - Updated Polars to 0.54.4

data/Cargo.lock

@@ -530,9 +530,9 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.18"
+version = "0.9.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
 dependencies = [
  "crossbeam-utils",
 ]
@@ -650,9 +650,9 @@ dependencies = [
 
 [[package]]
 name = "ethnum"
-version = "1.5.1"
+version = "1.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0939f82868b77ef93ce3c3c3daf2b3c526b456741da5a1a4559e590965b6026b"
+checksum = "40404c3f5f511ec4da6fe866ddf6a717c309fdbb69fbbad7b0f3edab8f2e835f"
 
 [[package]]
 name = "event-listener"
@@ -1341,12 +1341,11 @@ checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
 [[package]]
 name = "libmimalloc-sys"
-version = "0.1.44"
+version = "0.1.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "667f4fec20f29dfc6bc7357c582d91796c169ad7e2fce709468aefeb2c099870"
+checksum = "6a45a52f43e1c16f667ccfe4dd8c85b7f7c204fd5e3bf46c5b0db9a5c3c0b8e9"
 dependencies = [
  "cc",
- "libc",
 ]
 
 [[package]]
@@ -1459,9 +1458,9 @@ checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "memmap2"
-version = "0.9.5"
+version = "0.9.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
+checksum = "d1219ed1b7f229ee7104d281dd01d6802fe28bb6e95d292942c4daacdeb798c0"
 dependencies = [
  "libc",
 ]
@@ -2248,7 +2247,7 @@ dependencies = [
 
 [[package]]
 name = "polars-ruby"
-version = "0.26.0"
+version = "0.26.1"
 dependencies = [
  "ahash",
  "bytes",
@@ -2500,9 +2499,9 @@ dependencies = [
 
 [[package]]
 name = "quinn-proto"
-version = "0.11.14"
+version = "0.11.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
+checksum = "4fcb935c5bec503c2f0e306bdd3e58bb9029dcb14fa8d9ac76e3a5256ac0763e"
 dependencies = [
  "bytes",
  "getrandom 0.3.3",

data/Cargo.toml

@@ -4,6 +4,3 @@ resolver = "2"
 
 [profile.release]
 strip = true
-
-[profile.dev]
-strip = true

data/README.md

@@ -381,6 +381,12 @@ Delta Lake (experimental)
 df.write_delta("./table")
 ```
 
+Arrow array (experimental, requires [nanoarrow](https://github.com/ankane/nanoarrow-ruby))
+
+```ruby
+df.to_arrow
+```
+
 Numo array
 
 ```ruby

data/ext/polars/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "polars-ruby"
-version = "0.26.0"
+version = "0.26.1"
 license = "MIT"
 authors = ["Andrew Kane <andrew@ankane.org>"]
 edition = "2024"

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

@@ -39,6 +39,7 @@ use crate::object::OBJECT_NAME;
 use crate::rb_modules::pl_series;
 use crate::ruby::gvl::GvlExt;
 use crate::ruby::utils::TryIntoValue;
+use crate::series::import_schema_rbcapsule;
 use crate::utils::to_rb_err;
 use crate::{
     RbDataFrame, RbExpr, RbLazyFrame, RbPolarsErr, RbResult, RbSeries, RbTypeError, RbValueError,
@@ -515,7 +516,28 @@ impl TryConvert for Wrap<Schema> {
 impl TryConvert for Wrap<ArrowSchema> {
     fn try_convert(ob: Value) -> RbResult<Self> {
         let ruby = Ruby::get_with(ob);
-        // TODO improve
+
+        if let Ok(schema_capsule) = ob.funcall::<_, _, Value>("arrow_c_schema", ()) {
+            let field = import_schema_rbcapsule(schema_capsule)?;
+
+            let ArrowDataType::Struct(fields) = field.dtype else {
+                return Err(RbValueError::new_err(format!(
+                    "arrow_c_schema of object did not return struct dtype: \
+                    object: {:?}, dtype: {:?}",
+                    ob, &field.dtype
+                )));
+            };
+
+            let mut schema = ArrowSchema::from_iter_check_duplicates(fields).unwrap();
+
+            if let Some(md) = field.metadata {
+                *schema.metadata_mut() = Arc::unwrap_or_clone(md);
+            }
+
+            return Ok(Wrap(schema));
+        }
+
+        // TODO remove in 0.27.0
         let ob = RHash::try_convert(ob)?;
         let fields: RArray = ob.aref(ruby.to_symbol("fields"))?;
         let mut arrow_schema = ArrowSchema::with_capacity(fields.len());
@@ -546,6 +568,33 @@ impl TryConvert for Wrap<ArrowSchema> {
                 "binary_view" => ArrowDataType::BinaryView,
                 "string_view" => ArrowDataType::Utf8View,
                 "unknown" => ArrowDataType::Unknown,
+                "timestamp" => {
+                    let time_unit: String = f.aref(ruby.to_symbol("time_unit"))?;
+                    let time_zone: Option<String> = f.aref(ruby.to_symbol("time_zone"))?;
+                    let arrow_time_unit = match time_unit.as_str() {
+                        "us" => ArrowTimeUnit::Microsecond,
+                        "ns" => ArrowTimeUnit::Nanosecond,
+                        _ => todo!(),
+                    };
+                    ArrowDataType::Timestamp(arrow_time_unit, time_zone.map(|v| v.into()))
+                }
+                "time64" => {
+                    let time_unit: String = f.aref(ruby.to_symbol("time_unit"))?;
+                    let arrow_time_unit = match time_unit.as_str() {
+                        "us" => ArrowTimeUnit::Microsecond,
+                        _ => todo!(),
+                    };
+                    ArrowDataType::Time64(arrow_time_unit)
+                }
+                "decimal" => {
+                    let precision: usize = f.aref(ruby.to_symbol("precision"))?;
+                    let scale: usize = f.aref(ruby.to_symbol("scale"))?;
+                    ArrowDataType::Decimal(precision, scale)
+                }
+                "fixed_size_binary" => {
+                    let limit: usize = f.aref(ruby.to_symbol("limit"))?;
+                    ArrowDataType::FixedSizeBinary(limit)
+                }
                 _ => todo!(),
             };
             let is_nullable = f.aref(ruby.to_symbol("nullable"))?;

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(

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

@@ -10,6 +10,7 @@ use polars::prelude::*;
 use polars_core::query_result::QueryResult;
 use polars_plan::dsl::ScanSources;
 use polars_plan::plans::{HintIR, Sorted};
+use std::ffi::CString;
 use std::num::NonZeroUsize;
 
 use super::{RbLazyFrame, RbOptFlags};
@@ -27,8 +28,7 @@ use crate::ruby::ruby_function::RubyObject;
 use crate::ruby::utils::TryIntoValue;
 use crate::utils::{EnterPolarsExt, to_rb_err};
 use crate::{
-    RbArrowArrayStream, RbDataFrame, RbExpr, RbLazyGroupBy, RbPolarsErr, RbResult, RbTypeError,
-    RbValueError,
+    RbCapsule, RbDataFrame, RbExpr, RbLazyGroupBy, RbPolarsErr, RbResult, RbTypeError, RbValueError,
 };
 
 fn rbobject_to_first_path_and_scan_sources(
@@ -1314,7 +1314,8 @@ impl RbCollectBatches {
         let iter = Box::new(ArrowStreamIterator::new(self_.inner.clone(), dtype.clone()));
         let field = ArrowField::new(PlSmallStr::EMPTY, dtype, false);
         let stream = export_iterator(iter, field);
-        Ok(RbArrowArrayStream { stream }.into_value_with(rb))
+        let stream_capsule_name = CString::new("arrow_array_stream").unwrap();
+        Ok(RbCapsule::new(stream, Some(stream_capsule_name)).into_value_with(rb))
     }
 }
 

data/ext/polars/src/lib.rs

@@ -37,10 +37,11 @@ use expr::RbExpr;
 use expr::datatype::RbDataTypeExpr;
 use expr::selector::RbSelector;
 use functions::whenthen::{RbChainedThen, RbChainedWhen, RbThen, RbWhen};
-use interop::arrow::to_rb::{RbArrowArrayStream, RbArrowSchema};
+use interop::arrow::to_rb::RbArrowSchema;
 use lazyframe::{RbCollectBatches, RbInProcessQuery, RbLazyFrame, RbOptFlags};
 use lazygroupby::RbLazyGroupBy;
 use magnus::{Ruby, function, method, prelude::*};
+use ruby::capsule::RbCapsule;
 use ruby::exceptions::{RbTypeError, RbValueError};
 use series::RbSeries;
 use sql::RbSQLContext;
@@ -1135,6 +1136,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("to_s", method!(RbSeries::as_str, 0))?;
     class.define_method("len", method!(RbSeries::len, 0))?;
     class.define_method("to_a", method!(RbSeries::to_a, 0))?;
+    class.define_method("arrow_c_stream", method!(RbSeries::__arrow_c_stream__, 0))?;
     class.define_method("median", method!(RbSeries::median, 0))?;
     class.define_method("quantile", method!(RbSeries::quantile, 2))?;
     class.define_method("_clone", method!(RbSeries::clone, 0))?;
@@ -1340,9 +1342,10 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("register", method!(RbSQLContext::register, 2))?;
     class.define_method("unregister", method!(RbSQLContext::unregister, 1))?;
 
-    // arrow array stream
-    let class = module.define_class("ArrowArrayStream", ruby.class_object())?;
-    class.define_method("to_i", method!(RbArrowArrayStream::to_i, 0))?;
+    // capsule
+    let class = module.define_class("Capsule", ruby.class_object())?;
+    class.define_method("to_i", method!(RbCapsule::to_i, 0))?;
+    class.define_method("name", method!(RbCapsule::name, 0))?;
 
     // arrow schema
     let class = module.define_class("ArrowSchema", ruby.class_object())?;

data/ext/polars/src/ruby/capsule.rs

@@ -0,0 +1,27 @@
+use std::any::Any;
+use std::ffi::CString;
+
+#[magnus::wrap(class = "Polars::Capsule")]
+pub struct RbCapsule {
+    value: Box<dyn Any + Send>,
+    name: Option<CString>,
+}
+
+impl RbCapsule {
+    pub fn new<T: 'static + Send>(value: T, name: Option<CString>) -> Self {
+        Self {
+            value: Box::new(value),
+            name,
+        }
+    }
+
+    pub fn to_i(&self) -> usize {
+        (&*self.value as *const dyn Any as *const ()) as usize
+    }
+
+    // TODO use &CStr when Magnus supports it
+    // https://github.com/matsadler/magnus/pull/182
+    pub fn name(&self) -> Option<&str> {
+        self.name.as_deref().map(|v| v.to_str().unwrap())
+    }
+}

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

@@ -1,3 +1,4 @@
+pub mod capsule;
 pub mod exceptions;
 pub mod gvl;
 pub mod lazy;

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

@@ -1,6 +1,7 @@
 use magnus::{IntoValue, Ruby, Value, value::ReprValue};
 use polars_core::prelude::*;
 
+use crate::interop::arrow::to_rb::series_to_stream;
 use crate::prelude::*;
 use crate::ruby::utils::TryIntoValue;
 use crate::{RbPolarsErr, RbResult, RbSeries};
@@ -178,4 +179,8 @@ impl RbSeries {
 
         to_a_recursive(ruby, series)
     }
+
+    pub fn __arrow_c_stream__(ruby: &Ruby, self_: &Self) -> RbResult<Value> {
+        series_to_stream(&self_.series.read(), ruby)
+    }
 }

data/lib/polars/data_frame.rb

@@ -771,7 +771,14 @@ module Polars
       s.get_index_signed(row)
     end
 
-    # no to_arrow
+    # Collect the underlying arrow arrays in an Arrow Table.
+    #
+    # @return [Nanoarrow::Array]
+    def to_arrow
+      require "nanoarrow"
+
+      Nanoarrow::Array.new(self)
+    end
 
     # Convert DataFrame to a hash mapping column name to values.
     #
@@ -810,6 +817,8 @@ module Polars
     #   df.to_numo.class
     #   # => Numo::RObject
     def to_numo
+      require "numo/narray"
+
       out = _df.to_numo
       if out.nil?
         Numo::NArray.vstack(width.times.map { |i| to_series(i).to_numo }).transpose

data/lib/polars/functions/aggregation/horizontal.rb

@@ -242,10 +242,10 @@ module Polars
       rbexprs = Utils.parse_into_list_of_expressions(*exprs)
       exprs_wrapped = rbexprs.map { |e| Utils.wrap_expr(e) }
 
-      # (Expr): use u32 as that will not cast to float as eagerly
-      Polars.cum_fold(Polars.lit(0).cast(UInt32), exprs_wrapped) { |a, b| a + b }.alias(
-        "cum_sum"
-      )
+      Polars.cum_fold(
+        Polars.lit(0).cast(Polars.dtype_of(Polars.sum_horizontal(exprs))),
+        exprs_wrapped
+      ) { |a, b| a + b }.alias("cum_sum")
     end
   end
 end

data/lib/polars/iceberg_dataset.rb

@@ -17,24 +17,48 @@ module Polars
 
       table = scan.table
       snapshot = scan.snapshot
-      schema = snapshot ? table.schema_by_id(snapshot[:schema_id]) : table.current_schema
+      schema = snapshot ? table.schema_by_id(snapshot.is_a?(Hash) ? snapshot[:schema_id] : snapshot.schema_id) : table.current_schema
 
-      if files.empty?
-        # TODO improve
+      if files.empty? && !schema.respond_to?(:arrow_c_schema)
+        # TODO remove in 0.27.0
         schema =
           schema.fields.to_h do |field|
             dtype =
               case field[:type]
+              when "unknown"
+                Unknown
+              when "boolean"
+                Boolean
               when "int"
-                Polars::Int32
+                Int32
               when "long"
-                Polars::Int64
+                Int64
+              when "float"
+                Float32
               when "double"
-                Polars::Float64
+                Float64
+              when "decimal"
+                Decimal.new(field[:precision], field[:scale])
               when "string"
-                Polars::String
+                String
+              when "uuid"
+                Binary
+              when "fixed"
+                Binary
+              when "binary"
+                Binary
+              when "date"
+                Date
+              when "time"
+                Time # ns instead of us since does not support time unit
               when "timestamp"
-                Polars::Datetime
+                Datetime.new("us")
+              when "timestamp_ns"
+                Datetime.new("ns")
+              when "timestamptz"
+                Datetime.new("us", "+00:00")
+              when "timestamptz_ns"
+                Datetime.new("ns", "+00:00")
               else
                 raise Todo
               end
@@ -44,25 +68,26 @@ module Polars
 
         LazyFrame.new(schema: schema)
       else
-        sources = files.map { |v| v[:data_file_path] }
+        sources = files.map { |v| v.is_a?(Hash) ? v[:data_file_path] : v.file.file_path }
 
         column_mapping = [
           "iceberg-column-mapping",
-          arrow_schema(schema)
+          schema.respond_to?(:arrow_c_schema) ? schema : arrow_schema(schema)
         ]
 
         deletion_files = [
           "iceberg-position-delete",
           files.map.with_index
-            .select { |v, i| v[:deletes].any? }
-            .to_h { |v, i| [i, v[:deletes].map { |d| d[:file_path] }] }
+            .select { |v, i| (v.is_a?(Hash) ? v[:deletes] : v.delete_files).any? }
+            .to_h { |v, i| [i, v.is_a?(Hash) ? v[:deletes].map { |d| d[:file_path] } : v.delete_files.map(&:file_path)] }
         ]
 
         scan_options = {
-          storage_options: @storage_options,
+          schema: schema.respond_to?(:arrow_c_schema) ? Schema.new(schema) : nil,
           cast_options: Polars::ScanCastOptions._default_iceberg,
           missing_columns: "insert",
           extra_columns: "ignore",
+          storage_options: @storage_options,
           _column_mapping: column_mapping,
           _deletion_files: deletion_files
         }
@@ -73,11 +98,14 @@ module Polars
 
     private
 
+    # TODO remove in 0.27.0
     def arrow_schema(schema)
       fields =
         schema.fields.map do |field|
           type =
             case field[:type]
+            when "unknown"
+              "unknown"
             when "boolean"
               "boolean"
             when "int"
@@ -88,11 +116,42 @@ module Polars
               "float32"
             when "double"
               "float64"
+            when "decimal"
+              "decimal"
+            when "string"
+              "string"
+            when "uuid"
+              limit = 16
+              "fixed_size_binary"
+            when "fixed"
+              limit = field[:limit]
+              "fixed_size_binary"
+            when "binary"
+              "large_binary"
+            when "date"
+              "date32"
+            when "time"
+              time_unit = "us"
+              "time64"
+            when "timestamp"
+              time_unit = "us"
+              "timestamp"
+            when "timestamp_ns"
+              time_unit = "ns"
+              "timestamp"
+            when "timestamptz"
+              time_unit = "us"
+              time_zone = "+00:00"
+              "timestamp"
+            when "timestamptz_ns"
+              time_unit = "ns"
+              time_zone = "+00:00"
+              "timestamp"
             else
               raise Todo
             end
 
-          {
+          arrow_field = {
             name: field[:name],
             type: type,
             nullable: !field[:required],
@@ -100,6 +159,14 @@ module Polars
               "PARQUET:field_id" => field[:id].to_s
             }
           }
+          arrow_field[:limit] = limit if limit
+          if type == "decimal"
+            arrow_field[:precision] = field[:precision]
+            arrow_field[:scale] = field[:scale]
+          end
+          arrow_field[:time_unit] = time_unit if time_unit
+          arrow_field[:time_zone] = time_zone if time_zone
+          arrow_field
         end
 
       {fields: fields}

data/lib/polars/io/delta.rb

@@ -25,6 +25,8 @@ module Polars
       storage_options: nil,
       delta_table_options: nil
     )
+      require "deltalake-rb"
+
       df =
         scan_delta(
           source,
@@ -62,6 +64,8 @@ module Polars
       delta_table_options: nil,
       rechunk: nil
     )
+      require "deltalake-rb"
+
       dl_tbl =
         _get_delta_lake_table(
           source,

data/lib/polars/schema.rb

@@ -71,6 +71,15 @@ module Polars
       @schema.values
     end
 
+    # Convert the schema to a nanoarrow schema.
+    #
+    # @return [Nanoarrow::Schema]
+    def to_arrow
+      require "nanoarrow"
+
+      Nanoarrow::Schema.new(self)
+    end
+
     # Get the number of schema entries.
     #
     # @return [Integer]

data/lib/polars/series.rb

@@ -73,6 +73,8 @@ module Polars
         self._s = Utils.dataframe_to_rbseries(
           original_name, values, dtype: dtype, strict: strict
         )
+      elsif values.respond_to?(:arrow_c_stream)
+        self._s = RbSeries.from_arrow_c_stream(values)
       else
         raise TypeError, "Series constructor called with unsupported type; got #{values.class.name}"
       end
@@ -496,6 +498,11 @@ module Polars
       end
     end
 
+    # @private
+    def arrow_c_stream
+      _s.arrow_c_stream
+    end
+
     # Return the Series as a scalar, or return the element at the given index.
     #
     # If no index is provided, this is equivalent to `s[0]`, with a check
@@ -3114,6 +3121,8 @@ module Polars
     #   # Numo::Int64#shape=[3]
     #   # [1, 2, 3]
     def to_numo
+      require "numo/narray"
+
       if dtype.temporal?
         Numo::RObject.cast(to_a)
       else
@@ -3121,6 +3130,15 @@ module Polars
       end
     end
 
+    # Return the underlying Arrow array.
+    #
+    # @return [Nanoarrow::Array]
+    def to_arrow
+      require "nanoarrow"
+
+      Nanoarrow::Array.new(self)
+    end
+
     # Set masked values.
     #
     # @param filter [Series]

data/lib/polars/version.rb

@@ -1,4 +1,4 @@
 module Polars
   # @private
-  VERSION = "0.26.0"
+  VERSION = "0.26.1"
 end

data/lib/polars.rb

@@ -126,6 +126,10 @@ module Polars
   # @private
   N_INFER_DEFAULT = 100
 
+  # @private
+  # TODO remove in 0.27.0
+  ArrowArrayStream = Capsule
+
   # @private
   class ArrowArrayStream
     def arrow_c_stream

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.26.1
 platform: ruby
 authors:
 - Andrew Kane
@@ -113,6 +113,7 @@ files:
 - ext/polars/src/on_startup.rs
 - ext/polars/src/prelude.rs
 - ext/polars/src/rb_modules.rs
+- ext/polars/src/ruby/capsule.rs
 - ext/polars/src/ruby/exceptions.rs
 - ext/polars/src/ruby/gvl.rs
 - ext/polars/src/ruby/lazy.rs
@@ -262,7 +263,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.13
+rubygems_version: 4.0.14
 specification_version: 4
 summary: Blazingly fast DataFrames for Ruby
 test_files: []