polars-df 0.1.3 → 0.1.4

data/ext/polars/src/list_construction.rs

@@ -0,0 +1,100 @@
+use magnus::Value;
+use polars::prelude::*;
+use polars_core::utils::CustomIterTools;
+
+use crate::conversion::get_rbseq;
+use crate::{RbPolarsErr, RbResult};
+
+pub fn rb_seq_to_list(name: &str, seq: Value, dtype: &DataType) -> RbResult<Series> {
+    let (seq, len) = get_rbseq(seq)?;
+
+    let s = match dtype {
+        DataType::Int64 => {
+            let mut builder =
+                ListPrimitiveChunkedBuilder::<Int64Type>::new(name, len, len * 5, DataType::Int64);
+            for sub_seq in seq.each() {
+                let sub_seq = sub_seq?;
+                let (sub_seq, len) = get_rbseq(sub_seq)?;
+
+                // safety: we know the iterators len
+                let iter = unsafe {
+                    sub_seq
+                        .each()
+                        .map(|v| {
+                            let v = v.unwrap();
+                            if v.is_nil() {
+                                None
+                            } else {
+                                Some(v.try_convert::<i64>().unwrap())
+                            }
+                        })
+                        .trust_my_length(len)
+                };
+                builder.append_iter(iter)
+            }
+            builder.finish().into_series()
+        }
+        DataType::Float64 => {
+            let mut builder = ListPrimitiveChunkedBuilder::<Float64Type>::new(
+                name,
+                len,
+                len * 5,
+                DataType::Float64,
+            );
+            for sub_seq in seq.each() {
+                let sub_seq = sub_seq?;
+                let (sub_seq, len) = get_rbseq(sub_seq)?;
+                // safety: we know the iterators len
+                let iter = unsafe {
+                    sub_seq
+                        .each()
+                        .map(|v| {
+                            let v = v.unwrap();
+                            if v.is_nil() {
+                                None
+                            } else {
+                                Some(v.try_convert::<f64>().unwrap())
+                            }
+                        })
+                        .trust_my_length(len)
+                };
+                builder.append_iter(iter)
+            }
+            builder.finish().into_series()
+        }
+        DataType::Boolean => {
+            let mut builder = ListBooleanChunkedBuilder::new(name, len, len * 5);
+            for sub_seq in seq.each() {
+                let sub_seq = sub_seq?;
+                let (sub_seq, len) = get_rbseq(sub_seq)?;
+                // safety: we know the iterators len
+                let iter = unsafe {
+                    sub_seq
+                        .each()
+                        .map(|v| {
+                            let v = v.unwrap();
+                            if v.is_nil() {
+                                None
+                            } else {
+                                Some(v.try_convert::<bool>().unwrap())
+                            }
+                        })
+                        .trust_my_length(len)
+                };
+                builder.append_iter(iter)
+            }
+            builder.finish().into_series()
+        }
+        DataType::Utf8 => {
+            return Err(RbPolarsErr::todo());
+        }
+        dt => {
+            return Err(RbPolarsErr::other(format!(
+                "cannot create list array from {:?}",
+                dt
+            )));
+        }
+    };
+
+    Ok(s)
+}

data/ext/polars/src/series.rs

@@ -5,6 +5,7 @@ use polars::series::IsSorted;
 use std::cell::RefCell;
 
 use crate::conversion::*;
+use crate::list_construction::rb_seq_to_list;
 use crate::set::set_at_idx;
 use crate::{RbDataFrame, RbPolarsErr, RbResult, RbValueError};
 
@@ -123,6 +124,19 @@ impl RbSeries {
         RbSeries::new(s)
     }
 
+    pub fn new_object(name: String, val: RArray, _strict: bool) -> RbResult<Self> {
+        let val = val
+            .each()
+            .map(|v| v.map(ObjectValue::from))
+            .collect::<RbResult<Vec<ObjectValue>>>()?;
+        let s = ObjectChunked::<ObjectValue>::new_from_vec(&name, val).into_series();
+        Ok(s.into())
+    }
+
+    pub fn new_list(name: String, seq: Value, dtype: Wrap<DataType>) -> RbResult<Self> {
+        rb_seq_to_list(&name, seq, &dtype.0).map(|s| s.into())
+    }
+
     pub fn estimated_size(&self) -> usize {
         self.series.borrow().estimated_size()
     }
@@ -787,4 +801,25 @@ impl RbSeries {
         let ca: ChunkedArray<Int32Type> = builder.finish();
         Ok(ca.into_date().into_series().into())
     }
+
+    pub fn new_opt_datetime(name: String, values: RArray, _strict: Option<bool>) -> RbResult<Self> {
+        let len = values.len();
+        let mut builder = PrimitiveChunkedBuilder::<Int64Type>::new(&name, len);
+        for item in values.each() {
+            let v = item?;
+            if v.is_nil() {
+                builder.append_null();
+            } else {
+                let sec: i64 = v.funcall("to_i", ())?;
+                let nsec: i64 = v.funcall("nsec", ())?;
+                // TODO use strict
+                builder.append_value(sec * 1_000_000_000 + nsec);
+            }
+        }
+        let ca: ChunkedArray<Int64Type> = builder.finish();
+        Ok(ca
+            .into_datetime(TimeUnit::Nanoseconds, None)
+            .into_series()
+            .into())
+    }
 }

data/lib/polars/cat_name_space.rb

@@ -0,0 +1,54 @@
+module Polars
+  # Series.cat namespace.
+  class CatNameSpace
+    include ExprDispatch
+
+    self._accessor = "cat"
+
+    # @private
+    def initialize(series)
+      self._s = series._s
+    end
+
+    # Determine how this categorical series should be sorted.
+    #
+    # @param ordering ["physical", "lexical"]
+    #   Ordering type:
+    #
+    #   - 'physical' -> Use the physical representation of the categories to
+    #       determine the order (default).
+    #   - 'lexical' -> Use the string values to determine the ordering.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"cats" => ["z", "z", "k", "a", "b"], "vals" => [3, 1, 2, 2, 3]}
+    #   ).with_columns(
+    #     [
+    #       Polars.col("cats").cast(:cat).cat.set_ordering("lexical")
+    #     ]
+    #   )
+    #   df.sort(["cats", "vals"])
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌──────┬──────┐
+    #   # │ cats ┆ vals │
+    #   # │ ---  ┆ ---  │
+    #   # │ cat  ┆ i64  │
+    #   # ╞══════╪══════╡
+    #   # │ a    ┆ 2    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ b    ┆ 3    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ k    ┆ 2    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ z    ┆ 1    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ z    ┆ 3    │
+    #   # └──────┴──────┘
+    def set_ordering(ordering)
+      super
+    end
+  end
+end

data/lib/polars/data_frame.rb

@@ -880,7 +880,7 @@ module Polars
     #       "val" => [1, 2, 3]
     #     }
     #   )
-    #   df.reverse()
+    #   df.reverse
     #   # =>
     #   # shape: (3, 2)
     #   # ┌─────┬─────┐
@@ -1998,8 +1998,105 @@ module Polars
       self[name]
     end
 
-    # def fill_null
-    # end
+    # Fill null values using the specified value or strategy.
+    #
+    # @param value [Numeric]
+    #   Value used to fill null values.
+    # @param strategy [nil, "forward", "backward", "min", "max", "mean", "zero", "one"]
+    #   Strategy used to fill null values.
+    # @param limit [Integer]
+    #   Number of consecutive null values to fill when using the 'forward' or
+    #   'backward' strategy.
+    # @param matches_supertype [Boolean]
+    #   Fill all matching supertype of the fill `value`.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {
+    #       "a" => [1, 2, nil, 4],
+    #       "b" => [0.5, 4, nil, 13]
+    #     }
+    #   )
+    #   df.fill_null(99)
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────┐
+    #   # │ a   ┆ b    │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ f64  │
+    #   # ╞═════╪══════╡
+    #   # │ 1   ┆ 0.5  │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 2   ┆ 4.0  │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 99  ┆ 99.0 │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 4   ┆ 13.0 │
+    #   # └─────┴──────┘
+    #
+    # @example
+    #   df.fill_null(strategy: "forward")
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────┐
+    #   # │ a   ┆ b    │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ f64  │
+    #   # ╞═════╪══════╡
+    #   # │ 1   ┆ 0.5  │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 2   ┆ 4.0  │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 2   ┆ 4.0  │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 4   ┆ 13.0 │
+    #   # └─────┴──────┘
+    #
+    # @example
+    #   df.fill_null(strategy: "max")
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────┐
+    #   # │ a   ┆ b    │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ f64  │
+    #   # ╞═════╪══════╡
+    #   # │ 1   ┆ 0.5  │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 2   ┆ 4.0  │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 4   ┆ 13.0 │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 4   ┆ 13.0 │
+    #   # └─────┴──────┘
+    #
+    # @example
+    #   df.fill_null(strategy: "zero")
+    #   # =>
+    #   # shape: (4, 2)
+    #   # ┌─────┬──────┐
+    #   # │ a   ┆ b    │
+    #   # │ --- ┆ ---  │
+    #   # │ i64 ┆ f64  │
+    #   # ╞═════╪══════╡
+    #   # │ 1   ┆ 0.5  │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 2   ┆ 4.0  │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 0   ┆ 0.0  │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 4   ┆ 13.0 │
+    #   # └─────┴──────┘
+    def fill_null(value = nil, strategy: nil, limit: nil, matches_supertype: true)
+      _from_rbdf(
+        lazy
+          .fill_null(value, strategy: strategy, limit: limit, matches_supertype: matches_supertype)
+          .collect(no_optimization: true)
+          ._df
+      )
+    end
 
     # Fill floating point NaN values by an Expression evaluation.
     #
@@ -2357,7 +2454,7 @@ module Polars
     #     [
     #       (Polars.col("a") ** 2).alias("a^2"),
     #       (Polars.col("b") / 2).alias("b/2"),
-    #       (Polars.col("c").is_not()).alias("not c")
+    #       (Polars.col("c").is_not).alias("not c")
     #     ]
     #   )
     #   # =>

data/lib/polars/date_time_expr.rb

@@ -1357,9 +1357,9 @@ module Polars
 
     # Offset this date by a relative time offset.
     #
-    # This differs from ``pl.col("foo") + timedelta`` in that it can
+    # This differs from `Polars.col("foo") + timedelta` in that it can
     # take months and leap years into account. Note that only a single minus
-    # sign is allowed in the ``by`` string, as the first character.
+    # sign is allowed in the `by` string, as the first character.
     #
     # @param by [String]
     #   The offset is dictated by the following string language: