polars-df 0.1.0 → 0.1.1

data/lib/polars/lazy_frame.rb

@@ -8,6 +8,51 @@ module Polars
       ldf
     end
 
+    # def columns
+    # end
+
+    # def dtypes
+    # end
+
+    # def schema
+    # end
+
+    # def width
+    # end
+
+    # def include?(key)
+    # end
+
+    # clone handled by initialize_copy
+
+    # def [](item)
+    # end
+
+    # def to_s
+    # end
+    # alias_method :inspect, :to_s
+
+    # def write_json
+    # end
+
+    # def pipe
+    # end
+
+    # def describe_plan
+    # end
+
+    # def describe_optimized_plan
+    # end
+
+    # def show_graph
+    # end
+
+    # def sort
+    # end
+
+    # def profile
+    # end
+
     def collect(
       type_coercion: true,
       predicate_pushdown: true,
@@ -42,8 +87,21 @@ module Polars
       Utils.wrap_df(ldf.collect)
     end
 
+    # def fetch
+    # end
+
+    def lazy
+      self
+    end
+
+    # def cache
+    # end
+
+    # def cleared
+    # end
+
     def filter(predicate)
-      self.class._from_rbldf(
+      _from_rbldf(
         _ldf.filter(
           Utils.expr_to_lit_or_expr(predicate, str_to_lit: false)._rbexpr
         )
@@ -52,7 +110,7 @@ module Polars
 
     def select(exprs)
       exprs = Utils.selection_to_rbexpr_list(exprs)
-      self.class._from_rbldf(_ldf.select(exprs))
+      _from_rbldf(_ldf.select(exprs))
     end
 
     def groupby(by, maintain_order: false)
@@ -61,6 +119,15 @@ module Polars
       LazyGroupBy.new(lgb, self.class)
     end
 
+    # def groupby_rolling
+    # end
+
+    # def groupby_dynamic
+    # end
+
+    # def join_asof
+    # end
+
     def join(
       other,
       left_on: nil,
@@ -76,7 +143,7 @@ module Polars
       end
 
       if how == "cross"
-        return self.class._from_rbldf(
+        return _from_rbldf(
           _ldf.join(
             other._ldf, [], [], allow_parallel, force_parallel, how, suffix
           )
@@ -94,7 +161,7 @@ module Polars
         raise ArgumentError, "must specify `on` OR `left_on` and `right_on`"
       end
 
-      self.class._from_rbldf(
+      _from_rbldf(
         self._ldf.join(
           other._ldf,
           rbexprs_left,
@@ -123,17 +190,128 @@ module Polars
         when Expr
           rbexprs << e._rbexpr
         when Series
-          rbexprs = Internal.lit(e)._rbexpr
+          rbexprs = Utils.lit(e)._rbexpr
         else
           raise ArgumentError, "Expected an expression, got #{e}"
         end
       end
 
-      self.class._from_rbldf(_ldf.with_columns(rbexprs))
+      _from_rbldf(_ldf.with_columns(rbexprs))
     end
 
+    # def with_context
+    # end
+
     def with_column(column)
       with_columns([column])
     end
+
+    # def drop
+    # end
+
+    def rename(mapping)
+      existing = mapping.keys
+      _new = mapping.values
+      _from_rbldf(_ldf.rename(existing, _new))
+    end
+
+    # def reverse
+    # end
+
+    # def shift
+    # end
+
+    # def shift_and_fill
+    # end
+
+    # def slice
+    # end
+
+    # def limit
+    # end
+
+    # def head
+    # end
+
+    # def tail
+    # end
+
+    # def last
+    # end
+
+    # def first
+    # end
+
+    # def with_row_count
+    # end
+
+    # def take_every
+    # end
+
+    # def fill_null
+    # end
+
+    def fill_nan(fill_value)
+      if !fill_value.is_a?(Expr)
+        fill_value = Utils.lit(fill_value)
+      end
+      _from_rbldf(_ldf.fill_nan(fill_value._rbexpr))
+    end
+
+    # def std
+    # end
+
+    # def var
+    # end
+
+    # def max
+    # end
+
+    # def min
+    # end
+
+    # def sum
+    # end
+
+    # def mean
+    # end
+
+    # def median
+    # end
+
+    # def quantile
+    # end
+
+    # def explode
+    # end
+
+    # def unique
+    # end
+
+    # def drop_nulls
+    # end
+
+    # def melt
+    # end
+
+    # def map
+    # end
+
+    # def interpolate
+    # end
+
+    # def unnest
+    # end
+
+    private
+
+    def initialize_copy(other)
+      super
+      self._ldf = _ldf._clone
+    end
+
+    def _from_rbldf(rb_ldf)
+      self.class._from_rbldf(rb_ldf)
+    end
   end
 end

data/lib/polars/lazy_functions.rb

@@ -5,6 +5,10 @@ module Polars
       Utils.wrap_expr(RbExpr.col(name))
     end
 
+    def element
+      col("")
+    end
+
     def std(column, ddof: 1)
       if column.is_a?(Series)
         column.std(ddof: ddof)

data/lib/polars/list_expr.rb

@@ -0,0 +1,108 @@
+module Polars
+  class ListExpr
+    attr_accessor :_rbexpr
+
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    def lengths
+      Utils.wrap_expr(_rbexpr.arr_lengths)
+    end
+
+    def sum
+      Utils.wrap_expr(_rbexpr.lst_sum)
+    end
+
+    def max
+      Utils.wrap_expr(_rbexpr.lst_max)
+    end
+
+    def min
+      Utils.wrap_expr(_rbexpr.lst_min)
+    end
+
+    def mean
+      Utils.wrap_expr(_rbexpr.lst_mean)
+    end
+
+    def sort(reverse: false)
+      Utils.wrap_expr(_rbexpr.lst_sort(reverse))
+    end
+
+    def reverse
+      Utils.wrap_expr(_rbexpr.lst_reverse)
+    end
+
+    def unique
+      Utils.wrap_expr(_rbexpr.lst_unique)
+    end
+
+    # def concat
+    # end
+
+    def get(index)
+      index = Utils.expr_to_lit_or_expr(index, str_to_lit: false)._rbexpr
+      Utils.wrap_expr(_rbexpr.lst_get(index))
+    end
+
+    def [](item)
+      get(item)
+    end
+
+    def first
+      get(0)
+    end
+
+    def last
+      get(-1)
+    end
+
+    def contains(item)
+      Utils.wrap_expr(_rbexpr.arr_contains(Utils.expr_to_lit_or_expr(item)._rbexpr))
+    end
+
+    def join(separator)
+      Utils.wrap_expr(_rbexpr.lst_join(separator))
+    end
+
+    def arg_min
+      Utils.wrap_expr(_rbexpr.lst_arg_min)
+    end
+
+    def arg_max
+      Utils.wrap_expr(_rbexpr.lst_arg_max)
+    end
+
+    def diff(n: 1, null_behavior: "ignore")
+      Utils.wrap_expr(_rbexpr.lst_diff(n, null_behavior))
+    end
+
+    def shift(periods = 1)
+      Utils.wrap_expr(_rbexpr.lst_shift(periods))
+    end
+
+    def slice(offset, length = nil)
+      offset = Utils.expr_to_lit_or_expr(offset, str_to_lit: false)._rbexpr
+      length = Utils.expr_to_lit_or_expr(length, str_to_lit: false)._rbexpr
+      Utils.wrap_expr(_rbexpr.lst_slice(offset, length))
+    end
+
+    def head(n = 5)
+      slice(0, n)
+    end
+
+    def tail(n = 5)
+      offset = -Utils.expr_to_lit_or_expr(n, str_to_lit: false)
+      slice(offset, n)
+    end
+
+    # def to_struct(n_field_strategy: "first_non_null", name_generator: nil)
+    #   Utils.wrap_expr(_rbexpr.lst_to_struct(n_field_strategy, name_generator))
+    # end
+
+    def eval(expr, parallel: false)
+       Utils.wrap_expr(_rbexpr.lst_eval(expr._rbexpr, parallel))
+    end
+  end
+end

data/lib/polars/meta_expr.rb

@@ -0,0 +1,33 @@
+module Polars
+  class MetaExpr
+    attr_accessor :_rbexpr
+
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    def ==(other)
+      _rbexpr.meta_eq(other._rbexpr)
+    end
+
+    def !=(other)
+      !(self == other)
+    end
+
+    def pop
+      _rbexpr.meta_pop.map { |e| Utils.wrap_expr(e) }
+    end
+
+    def root_names
+      _rbexpr.meta_roots
+    end
+
+    def output_name
+      _rbexpr.meta_output_name
+    end
+
+    def undo_aliases
+      Utils.wrap_expr(_rbexpr.meta_undo_aliases)
+    end
+  end
+end