polars-df 0.17.1 → 0.18.0

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

@@ -0,0 +1,99 @@
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, Mutex};
+
+use magnus::{RHash, TryConvert, Value};
+use polars::prelude::sync_on_close::SyncOnCloseType;
+use polars::prelude::{SinkOptions, SpecialEq};
+
+use crate::prelude::Wrap;
+use crate::{RbResult, RbValueError};
+
+#[derive(Clone)]
+pub enum SinkTarget {
+    File(polars_plan::dsl::SinkTarget),
+}
+
+impl TryConvert for Wrap<polars_plan::dsl::SinkTarget> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        if let Ok(v) = PathBuf::try_convert(ob) {
+            Ok(Wrap(polars::prelude::SinkTarget::Path(Arc::new(v))))
+        } else {
+            let writer = {
+                let rb_f = ob;
+                RbResult::Ok(crate::file::try_get_rbfile(rb_f, true)?.0.into_writeable())
+            }?;
+
+            Ok(Wrap(polars_plan::prelude::SinkTarget::Dyn(SpecialEq::new(
+                Arc::new(Mutex::new(Some(writer))),
+            ))))
+        }
+    }
+}
+
+impl TryConvert for SinkTarget {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        Ok(Self::File(
+            <Wrap<polars_plan::dsl::SinkTarget>>::try_convert(ob)?.0,
+        ))
+    }
+}
+
+impl SinkTarget {
+    pub fn base_path(&self) -> Option<&Path> {
+        match self {
+            Self::File(t) => match t {
+                polars::prelude::SinkTarget::Path(p) => Some(p.as_path()),
+                polars::prelude::SinkTarget::Dyn(_) => None,
+            },
+        }
+    }
+}
+
+impl TryConvert for Wrap<SyncOnCloseType> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = match String::try_convert(ob)?.as_str() {
+            "none" => SyncOnCloseType::None,
+            "data" => SyncOnCloseType::Data,
+            "all" => SyncOnCloseType::All,
+            v => {
+                return Err(RbValueError::new_err(format!(
+                    "`sync_on_close` must be one of {{'none', 'data', 'all'}}, got {v}",
+                )));
+            }
+        };
+        Ok(Wrap(parsed))
+    }
+}
+
+impl TryConvert for Wrap<SinkOptions> {
+    fn try_convert(ob: Value) -> RbResult<Self> {
+        let parsed = RHash::try_convert(ob)?;
+
+        if parsed.len() != 3 {
+            return Err(RbValueError::new_err(
+                "`sink_options` must be a dictionary with the exactly 3 field.",
+            ));
+        }
+
+        let sync_on_close = parsed.get("sync_on_close").ok_or_else(|| {
+            RbValueError::new_err("`sink_options` must contain `sync_on_close` field")
+        })?;
+        let sync_on_close = Wrap::<SyncOnCloseType>::try_convert(sync_on_close)?.0;
+
+        let maintain_order = parsed.get("maintain_order").ok_or_else(|| {
+            RbValueError::new_err("`sink_options` must contain `maintain_order` field")
+        })?;
+        let maintain_order = bool::try_convert(maintain_order)?;
+
+        let mkdir = parsed
+            .get("mkdir")
+            .ok_or_else(|| RbValueError::new_err("`sink_options` must contain `mkdir` field"))?;
+        let mkdir = bool::try_convert(mkdir)?;
+
+        Ok(Wrap(SinkOptions {
+            sync_on_close,
+            maintain_order,
+            mkdir,
+        }))
+    }
+}

data/ext/polars/src/lib.rs

@@ -221,8 +221,6 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("gather", method!(RbExpr::gather, 1))?;
     class.define_method("get", method!(RbExpr::get, 1))?;
     class.define_method("sort_by", method!(RbExpr::sort_by, 5))?;
-    class.define_method("backward_fill", method!(RbExpr::backward_fill, 1))?;
-    class.define_method("forward_fill", method!(RbExpr::forward_fill, 1))?;
     class.define_method("shift", method!(RbExpr::shift, 2))?;
     class.define_method("fill_null", method!(RbExpr::fill_null, 1))?;
     class.define_method(
@@ -248,7 +246,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("slice", method!(RbExpr::slice, 2))?;
     class.define_method("append", method!(RbExpr::append, 2))?;
     class.define_method("rechunk", method!(RbExpr::rechunk, 0))?;
-    class.define_method("round", method!(RbExpr::round, 1))?;
+    class.define_method("round", method!(RbExpr::round, 2))?;
     class.define_method("floor", method!(RbExpr::floor, 0))?;
     class.define_method("ceil", method!(RbExpr::ceil, 0))?;
     class.define_method("clip", method!(RbExpr::clip, 2))?;
@@ -271,7 +269,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_method("_and", method!(RbExpr::_and, 1))?;
     class.define_method("_xor", method!(RbExpr::_xor, 1))?;
     class.define_method("_or", method!(RbExpr::_or, 1))?;
-    class.define_method("is_in", method!(RbExpr::is_in, 1))?;
+    class.define_method("is_in", method!(RbExpr::is_in, 2))?;
     class.define_method("repeat_by", method!(RbExpr::repeat_by, 1))?;
     class.define_method("pow", method!(RbExpr::pow, 1))?;
     class.define_method("cum_sum", method!(RbExpr::cum_sum, 1))?;
@@ -450,7 +448,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
         "rolling_quantile_by",
         method!(RbExpr::rolling_quantile_by, 6),
     )?;
-    class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 2))?;
+    class.define_method("rolling_skew", method!(RbExpr::rolling_skew, 4))?;
     class.define_method("lower_bound", method!(RbExpr::lower_bound, 0))?;
     class.define_method("upper_bound", method!(RbExpr::upper_bound, 0))?;
     class.define_method("list_max", method!(RbExpr::list_max, 0))?;
@@ -559,7 +557,7 @@ fn init(ruby: &Ruby) -> RbResult<()> {
     class.define_singleton_method("first", function!(functions::lazy::first, 0))?;
     class.define_singleton_method("last", function!(functions::lazy::last, 0))?;
     class.define_singleton_method("cols", function!(functions::lazy::cols, 1))?;
-    class.define_singleton_method("fold", function!(functions::lazy::fold, 3))?;
+    class.define_singleton_method("fold", function!(functions::lazy::fold, 5))?;
     class.define_singleton_method("cum_fold", function!(functions::lazy::cum_fold, 4))?;
     class.define_singleton_method("lit", function!(functions::lazy::lit, 2))?;
     class.define_singleton_method("int_range", function!(functions::range::int_range, 4))?;

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

@@ -245,7 +245,7 @@ fn iterator_to_list(
         match opt_val {
             None => builder.append_null(),
             Some(s) => {
-                if s.len() == 0 && s.dtype() != dt {
+                if s.is_empty() && s.dtype() != dt {
                     builder
                         .append_series(&Series::full_null(PlSmallStr::EMPTY, 0, dt))
                         .unwrap()

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

@@ -372,7 +372,7 @@ impl<'a> ApplyLambda<'a> for BooleanChunked {
         first_value: AnyValue<'a>,
     ) -> RbResult<Series> {
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         if self.null_count() > 0 {
@@ -656,7 +656,7 @@ where
         first_value: AnyValue<'a>,
     ) -> RbResult<Series> {
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         if self.null_count() > 0 {
@@ -935,7 +935,7 @@ impl<'a> ApplyLambda<'a> for StringChunked {
         first_value: AnyValue<'a>,
     ) -> RbResult<Series> {
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         if self.null_count() > 0 {
@@ -1132,7 +1132,7 @@ impl<'a> ApplyLambda<'a> for StructChunked {
         first_value: AnyValue<'a>,
     ) -> RbResult<Series> {
         let mut avs = Vec::with_capacity(self.len());
-        avs.extend(std::iter::repeat(AnyValue::Null).take(init_null_count));
+        avs.extend(std::iter::repeat_n(AnyValue::Null, init_null_count));
         avs.push(first_value);
 
         let iter = iter_struct(self).skip(init_null_count + 1).map(|val| {

data/ext/polars/src/on_startup.rs

@@ -1,5 +1,6 @@
 use std::any::Any;
 use std::sync::Arc;
+use std::sync::OnceLock;
 
 use magnus::IntoValue;
 use polars::prelude::*;
@@ -11,8 +12,10 @@ use polars_core::prelude::AnyValue;
 use crate::prelude::ObjectValue;
 use crate::Wrap;
 
+static POLARS_REGISTRY_INIT_LOCK: OnceLock<()> = OnceLock::new();
+
 pub(crate) fn register_startup_deps() {
-    if !registry::is_object_builder_registered() {
+    POLARS_REGISTRY_INIT_LOCK.get_or_init(|| {
         let object_builder = Box::new(|name: PlSmallStr, capacity: usize| {
             Box::new(ObjectChunkedBuilder::<ObjectValue>::new(name, capacity))
                 as Box<dyn AnonymousObjectBuilder>
@@ -24,9 +27,18 @@ pub(crate) fn register_startup_deps() {
             };
             Box::new(object) as Box<dyn Any>
         });
+        let rbobject_converter = Arc::new(|av: AnyValue| {
+            let object = Wrap(av).into_value();
+            Box::new(object) as Box<dyn Any>
+        });
 
         let object_size = std::mem::size_of::<ObjectValue>();
         let physical_dtype = ArrowDataType::FixedSizeBinary(object_size);
-        registry::register_object_builder(object_builder, object_converter, physical_dtype)
-    }
+        registry::register_object_builder(
+            object_builder,
+            object_converter,
+            rbobject_converter,
+            physical_dtype,
+        )
+    });
 }

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

@@ -27,7 +27,7 @@ impl RbSeries {
                 DataType::Categorical(_, _) | DataType::Enum(_, _) => {
                     RArray::from_iter(series.categorical().unwrap().iter_str()).into_value()
                 }
-                DataType::Object(_, _) => {
+                DataType::Object(_) => {
                     let v = RArray::with_capacity(series.len());
                     for i in 0..series.len() {
                         let obj: Option<&ObjectValue> = series.get_object(i).map(|any| any.into());
@@ -105,10 +105,10 @@ impl RbSeries {
                 DataType::Null => {
                     let null: Option<u8> = None;
                     let n = series.len();
-                    let iter = std::iter::repeat(null).take(n);
-                    use std::iter::{Repeat, Take};
+                    let iter = std::iter::repeat_n(null, n);
+                    use std::iter::RepeatN;
                     struct NullIter {
-                        iter: Take<Repeat<Option<u8>>>,
+                        iter: RepeatN<Option<u8>>,
                         n: usize,
                     }
                     impl Iterator for NullIter {

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

@@ -317,7 +317,7 @@ impl RbSeries {
 
         macro_rules! dispatch_apply {
             ($self:expr, $method:ident, $($args:expr),*) => {
-                if matches!($self.dtype(), DataType::Object(_, _)) {
+                if matches!($self.dtype(), DataType::Object(_)) {
                     // let ca = $self.0.unpack::<ObjectType<ObjectValue>>().unwrap();
                     // ca.$method($($args),*)
                     todo!()
@@ -484,7 +484,7 @@ impl RbSeries {
 
                 ca.into_series()
             }
-            Some(DataType::Object(_, _)) => {
+            Some(DataType::Object(_)) => {
                 let ca =
                     dispatch_apply!(series, apply_lambda_with_object_out_type, lambda, 0, None)?;
                 ca.into_series()

data/lib/polars/expr.rb

@@ -1176,8 +1176,8 @@ module Polars
     #   # │ 1.0 │
     #   # │ 1.2 │
     #   # └─────┘
-    def round(decimals = 0)
-      _from_rbexpr(_rbexpr.round(decimals))
+    def round(decimals = 0, mode: "half_to_even")
+      _from_rbexpr(_rbexpr.round(decimals, mode))
     end
 
     # Compute the dot/inner product between two Expressions.
@@ -1867,7 +1867,7 @@ module Polars
     #   # │ 2   ┆ 6   │
     #   # └─────┴─────┘
     def forward_fill(limit: nil)
-      _from_rbexpr(_rbexpr.forward_fill(limit))
+      fill_null(strategy: "forward", limit: limit)
     end
 
     # Fill missing values with the next to be seen values.
@@ -1897,7 +1897,7 @@ module Polars
     #   # │ null ┆ 6   │
     #   # └──────┴─────┘
     def backward_fill(limit: nil)
-      _from_rbexpr(_rbexpr.backward_fill(limit))
+      fill_null(strategy: "backward", limit: limit)
     end
 
     # Reverse the selection.
@@ -3712,6 +3712,8 @@ module Polars
     #
     # @param other [Object]
     #   Series or sequence of primitive type.
+    # @param nulls_equal [Boolean]
+    #   If true, treat null as a distinct value. Null values will not propagate.
     #
     # @return [Expr]
     #
@@ -3719,19 +3721,19 @@ module Polars
     #   df = Polars::DataFrame.new(
     #     {"sets" => [[1, 2, 3], [1, 2], [9, 10]], "optional_members" => [1, 2, 3]}
     #   )
-    #   df.select([Polars.col("optional_members").is_in("sets").alias("contains")])
+    #   df.with_columns(contains: Polars.col("optional_members").is_in("sets"))
     #   # =>
-    #   # shape: (3, 1)
-    #   # ┌──────────┐
-    #   # │ contains │
-    #   # │ ---      │
-    #   # │ bool     │
-    #   # ╞══════════╡
-    #   # │ true     │
-    #   # │ true     │
-    #   # │ false    │
-    #   # └──────────┘
-    def is_in(other)
+    #   # shape: (3, 3)
+    #   # ┌───────────┬──────────────────┬──────────┐
+    #   # │ sets      ┆ optional_members ┆ contains │
+    #   # │ ---       ┆ ---              ┆ ---      │
+    #   # │ list[i64] ┆ i64              ┆ bool     │
+    #   # ╞═══════════╪══════════════════╪══════════╡
+    #   # │ [1, 2, 3] ┆ 1                ┆ true     │
+    #   # │ [1, 2]    ┆ 2                ┆ true     │
+    #   # │ [9, 10]   ┆ 3                ┆ false    │
+    #   # └───────────┴──────────────────┴──────────┘
+    def is_in(other, nulls_equal: false)
       if other.is_a?(::Array)
         if other.length == 0
           other = Polars.lit(nil)._rbexpr
@@ -3741,7 +3743,7 @@ module Polars
       else
         other = Utils.parse_into_expression(other, str_as_lit: false)
       end
-      _from_rbexpr(_rbexpr.is_in(other))
+      _from_rbexpr(_rbexpr.is_in(other, nulls_equal))
     end
     alias_method :in?, :is_in
 
@@ -5715,6 +5717,11 @@ module Polars
     #   Integer size of the rolling window.
     # @param bias [Boolean]
     #   If false, the calculations are corrected for statistical bias.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window.
     #
     # @return [Expr]
     #
@@ -5733,8 +5740,8 @@ module Polars
     #   # │ 0.381802 │
     #   # │ 0.47033  │
     #   # └──────────┘
-    def rolling_skew(window_size, bias: true)
-      _from_rbexpr(_rbexpr.rolling_skew(window_size, bias))
+    def rolling_skew(window_size, bias: true, min_samples: nil, center: false)
+      _from_rbexpr(_rbexpr.rolling_skew(window_size, bias, min_samples, center))
     end
 
     # Compute absolute values.
@@ -5889,6 +5896,7 @@ module Polars
     #   # │ 20   │
     #   # └──────┘
     def diff(n: 1, null_behavior: "ignore")
+      n = Utils.parse_into_expression(n)
       _from_rbexpr(_rbexpr.diff(n, null_behavior))
     end
 

data/lib/polars/io/database.rb

@@ -51,7 +51,7 @@ module Polars
           when :decimal
             Decimal
           when :float
-            # TODO uncomment in 0.18.0
+            # TODO uncomment in future release
             # if column_type.limit && column_type.limit <= 24
             #   Float32
             # else
@@ -59,7 +59,7 @@ module Polars
             # end
             Float64
           when :integer
-            # TODO uncomment in 0.18.0
+            # TODO uncomment in future release
             # case column_type.limit
             # when 1
             #   Int8

data/lib/polars/lazy_frame.rb

@@ -433,7 +433,10 @@ module Polars
       no_optimization: false,
       slice_pushdown: true,
       storage_options: nil,
-      retries: 2
+      retries: 2,
+      sync_on_close: nil,
+      mkdir: false,
+      lazy: false
     )
       lf = _set_sink_optimizations(
         type_coercion: type_coercion,
@@ -468,17 +471,30 @@ module Polars
         storage_options = nil
       end
 
-      lf.sink_parquet(
+      sink_options = {
+        "sync_on_close" => sync_on_close || "none",
+        "maintain_order" => maintain_order,
+        "mkdir" => mkdir
+      }
+
+      lf = lf.sink_parquet(
         path,
         compression,
         compression_level,
         statistics,
         row_group_size,
         data_pagesize_limit,
-        maintain_order,
         storage_options,
-        retries
+        retries,
+        sink_options
       )
+      lf = LazyFrame._from_rbldf(lf)
+
+      if !lazy
+        lf.collect
+        return nil
+      end
+      lf
     end
 
     # Evaluate the query in streaming mode and write to an IPC file.
@@ -520,7 +536,10 @@ module Polars
       projection_pushdown: true,
       simplify_expression: true,
       slice_pushdown: true,
-      no_optimization: false
+      no_optimization: false,
+      sync_on_close: nil,
+      mkdir: false,
+      lazy: false
     )
       # TODO support storage options in Rust
       storage_options = nil
@@ -541,13 +560,26 @@ module Polars
         storage_options = nil
       end
 
-      lf.sink_ipc(
+      sink_options = {
+        "sync_on_close" => sync_on_close || "none",
+        "maintain_order" => maintain_order,
+        "mkdir" => mkdir
+      }
+
+      lf = lf.sink_ipc(
         path,
         compression,
-        maintain_order,
         storage_options,
-        retries
+        retries,
+        sink_options
       )
+      lf = LazyFrame._from_rbldf(lf)
+
+      if !lazy
+        lf.collect
+        return nil
+      end
+      lf
     end
 
     # Evaluate the query in streaming mode and write to a CSV file.
@@ -652,7 +684,10 @@ module Polars
       slice_pushdown: true,
       no_optimization: false,
       storage_options: nil,
-      retries: 2
+      retries: 2,
+      sync_on_close: nil,
+      mkdir: false,
+      lazy: false
     )
       Utils._check_arg_is_1byte("separator", separator, false)
       Utils._check_arg_is_1byte("quote_char", quote_char, false)
@@ -672,7 +707,13 @@ module Polars
         storage_options = nil
       end
 
-      lf.sink_csv(
+      sink_options = {
+        "sync_on_close" => sync_on_close || "none",
+        "maintain_order" => maintain_order,
+        "mkdir" => mkdir
+      }
+
+      lf = lf.sink_csv(
         path,
         include_bom,
         include_header,
@@ -687,10 +728,17 @@ module Polars
         float_precision,
         null_value,
         quote_style,
-        maintain_order,
         storage_options,
-        retries
+        retries,
+        sink_options
       )
+      lf = LazyFrame._from_rbldf(lf)
+
+      if !lazy
+        lf.collect
+        return nil
+      end
+      lf
     end
 
     # Evaluate the query in streaming mode and write to an NDJSON file.
@@ -730,7 +778,10 @@ module Polars
       slice_pushdown: true,
       no_optimization: false,
       storage_options: nil,
-      retries: 2
+      retries: 2,
+      sync_on_close: nil,
+      mkdir: false,
+      lazy: false
     )
       lf = _set_sink_optimizations(
         type_coercion: type_coercion,
@@ -747,7 +798,20 @@ module Polars
         storage_options = nil
       end
 
-      lf.sink_json(path, maintain_order, storage_options, retries)
+      sink_options = {
+        "sync_on_close" => sync_on_close || "none",
+        "maintain_order" => maintain_order,
+        "mkdir" => mkdir
+      }
+
+      lf = lf.sink_json(path, storage_options, retries, sink_options)
+      lf = LazyFrame._from_rbldf(lf)
+
+      if !lazy
+        lf.collect
+        return nil
+      end
+      lf
     end
 
     # @private

data/lib/polars/list_expr.rb

@@ -403,7 +403,7 @@ module Polars
     # The indices may be defined in a single column, or by sublists in another
     # column of dtype `List`.
     #
-    # @param index [Object]
+    # @param indices [Object]
     #   Indices to return per sublist
     # @param null_on_oob [Boolean]
     #   Behavior if an index is out of bounds:
@@ -427,12 +427,9 @@ module Polars
     #   # │ []          ┆ [null, null] │
     #   # │ [1, 2, … 5] ┆ [1, 5]       │
     #   # └─────────────┴──────────────┘
-    def gather(index, null_on_oob: false)
-      if index.is_a?(::Array)
-        index = Series.new(index)
-      end
-      index = Utils.parse_into_expression(index, str_as_lit: false)
-      Utils.wrap_expr(_rbexpr.list_gather(index, null_on_oob))
+    def gather(indices, null_on_oob: false)
+      indices = Utils.parse_into_expression(indices)
+      Utils.wrap_expr(_rbexpr.list_gather(indices, null_on_oob))
     end
     alias_method :take, :gather
 

data/lib/polars/series.rb

@@ -3577,24 +3577,26 @@ module Polars
     #   Integer size of the rolling window.
     # @param bias [Boolean]
     #   If false, the calculations are corrected for statistical bias.
+    # @param min_samples [Integer]
+    #   The number of values in the window that should be non-null before computing
+    #   a result. If set to `nil` (default), it will be set equal to `window_size`.
+    # @param center [Boolean]
+    #   Set the labels at the center of the window.
     #
     # @return [Series]
     #
     # @example
-    #   s = Polars::Series.new("a", [1.0, 2.0, 3.0, 4.0, 6.0, 8.0])
-    #   s.rolling_skew(3)
+    #   Polars::Series.new([1, 4, 2, 9]).rolling_skew(3)
     #   # =>
-    #   # shape: (6,)
-    #   # Series: 'a' [f64]
+    #   # shape: (4,)
+    #   # Series: '' [f64]
     #   # [
     #   #         null
     #   #         null
-    #   #         0.0
-    #   #         0.0
     #   #         0.381802
-    #   #         0.0
+    #   #         0.47033
     #   # ]
-    def rolling_skew(window_size, bias: true)
+    def rolling_skew(window_size, bias: true, min_samples: nil, center: false)
       super
     end
 
@@ -4043,7 +4045,7 @@ module Polars
     #
     # @example
     #   s.kurtosis(fisher: false, bias: false)
-    #   # => 2.1040361802642726
+    #   # => 2.1040361802642717
     def kurtosis(fisher: true, bias: true)
       _s.kurtosis(fisher, bias)
     end

data/lib/polars/version.rb

@@ -1,4 +1,4 @@
 module Polars
   # @private
-  VERSION = "0.17.1"
+  VERSION = "0.18.0"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 0.18.0
 platform: ruby
 authors:
 - Andrew Kane
 bindir: bin
 cert_chain: []
-date: 2025-04-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -99,6 +99,7 @@ files:
 - ext/polars/src/lazyframe/general.rs
 - ext/polars/src/lazyframe/mod.rs
 - ext/polars/src/lazyframe/serde.rs
+- ext/polars/src/lazyframe/sink.rs
 - ext/polars/src/lazygroupby.rs
 - ext/polars/src/lib.rs
 - ext/polars/src/map/dataframe.rs
@@ -209,7 +210,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Blazingly fast DataFrames for Ruby
 test_files: []