polars-df 0.1.0 → 0.1.1

data/lib/polars/series.rb

@@ -45,6 +45,17 @@ module Polars
       _s.dtype.to_sym
     end
 
+    def flags
+      {
+        "SORTED_ASC" => _s.is_sorted_flag,
+        "SORTED_DESC" => _s.is_sorted_reverse_flag
+      }
+    end
+
+    def inner_dtype
+      _s.inner_dtype&.to_sym
+    end
+
     def name
       _s.name
     end
@@ -53,6 +64,9 @@ module Polars
       [_s.len]
     end
 
+    # def time_unit
+    # end
+
     def to_s
       _s.to_s
     end
@@ -70,6 +84,24 @@ module Polars
       Utils.wrap_s(_s.bitxor(other._s))
     end
 
+    # def ==(other)
+    # end
+
+    # def !=(other)
+    # end
+
+    # def >(other)
+    # end
+
+    # def <(other)
+    # end
+
+    # def >=(other)
+    # end
+
+    # def <=(other)
+    # end
+
     def +(other)
      Utils. wrap_s(_s.add(other._s))
     end
@@ -86,10 +118,62 @@ module Polars
       Utils.wrap_s(_s.div(other._s))
     end
 
+    def **(power)
+      # if is_datelike
+      #   raise ArgumentError, "first cast to integer before raising datelike dtypes to a power"
+      # end
+      to_frame.select(Polars.col(name).pow(power)).to_series
+    end
+
+    # def -@(other)
+    # end
+
+    def [](item)
+      _s.get_idx(item)
+    end
+
+    # def []=(key, value)
+    # end
+
+    def estimated_size(unit = "b")
+      sz = _s.estimated_size
+      Utils.scale_bytes(sz, to: unit)
+    end
+
+    def sqrt
+      self ** 0.5
+    end
+
+    def any
+      to_frame.select(Polars.col(name).any).to_series[0]
+    end
+
+    def all
+      to_frame.select(Polars.col(name).all).to_series[0]
+    end
+
+    # def log
+    # end
+
+    # def log10
+    # end
+
+    # def exp
+    # end
+
+    # def drop_nulls
+    # end
+
+    # def drop_nans
+    # end
+
     def to_frame
       Utils.wrap_df(RbDataFrame.new([_s]))
     end
 
+    # def describe
+    # end
+
     def sum
       _s.sum
     end
@@ -98,6 +182,10 @@ module Polars
       _s.mean
     end
 
+    def product
+      to_frame.select(Polars.col(name).product).to_series[0]
+    end
+
     def min
       _s.min
     end
@@ -106,6 +194,53 @@ module Polars
       _s.max
     end
 
+    # def nan_max
+    # end
+
+    # def nan_min
+    # end
+
+    def std(ddof: 1)
+      if !is_numeric
+        nil
+      else
+        to_frame.select(Polars.col(name).std(ddof: ddof)).to_series[0]
+      end
+    end
+
+    def var(ddof: 1)
+      if !is_numeric
+        nil
+      else
+        to_frame.select(Polars.col(name).var(ddof: ddof)).to_series[0]
+      end
+    end
+
+    def median
+      _s.median
+    end
+
+    def quantile(quantile, interpolation: "nearest")
+      _s.quantile(quantile, interpolation)
+    end
+
+    def to_dummies
+      Utils.wrap_df(_s.to_dummies)
+    end
+
+    def value_counts(sort: false)
+      Utils.wrap_df(_s.value_counts(sort))
+    end
+
+    # def unique_counts
+    # end
+
+    # def entropy
+    # end
+
+    # def cumulative_eval
+    # end
+
     def alias(name)
       s = dup
       s._s.rename(name)
@@ -141,8 +276,12 @@ module Polars
       Utils.wrap_s(_s.cummax(reverse))
     end
 
+    def cumprod(reverse: false)
+      Utils.wrap_s(_s.cumprod(reverse))
+    end
+
     def limit(n = 10)
-      to_frame().select(Utils.col(name).limit(n)).to_series
+      to_frame.select(Utils.col(name).limit(n)).to_series
     end
 
     def slice(offset, length = nil)
@@ -167,6 +306,9 @@ module Polars
       to_frame.select(Utils.col(name).tail(n)).to_series
     end
 
+    # def take_every
+    # end
+
     def sort(reverse: false, in_place: false)
       if in_place
         self._s = _s.sort(reverse)
@@ -176,21 +318,360 @@ module Polars
       end
     end
 
-    def to_a
-      _s.to_a
+    # def top_k
+    # end
+
+    # def arg_sort
+    # end
+
+    # def argsort
+    # end
+
+    # def arg_unique
+    # end
+
+    def arg_min
+      _s.arg_min
+    end
+
+    def arg_max
+      _s.arg_max
+    end
+
+    # def search_sorted
+    # end
+
+    # def unique
+    # end
+
+    # def take
+    # end
+
+    def null_count
+      _s.null_count
+    end
+
+    def has_validity
+      _s.has_validity
+    end
+
+    def is_empty
+      len == 0
+    end
+    alias_method :empty?, :is_empty
+
+    # def is_null
+    # end
+
+    # def is_not_null
+    # end
+
+    # def is_finite
+    # end
+
+    # def is_infinite
+    # end
+
+    # def is_nan
+    # end
+
+    # def is_not_nan
+    # end
+
+    # def is_in
+    # end
+
+    # def arg_true
+    # end
+
+    # def is_unique
+    # end
+
+    # def is_first
+    # end
+
+    # def is_duplicated
+    # end
+
+    # def explode
+    # end
+
+    def series_equal(other, null_equal: false, strict: false)
+      _s.series_equal(other._s, null_equal, strict)
     end
 
     def len
       _s.len
     end
 
+    # def cast
+    # end
+
+    # def to_physical
+    # end
+
+    def to_a
+      _s.to_a
+    end
+
     def rechunk(in_place: false)
       opt_s = _s.rechunk(in_place)
       in_place ? self : Utils.wrap_s(opt_s)
     end
 
+    # def reverse
+    # end
+
+    def is_numeric
+      [:i8, :i16, :i32, :i64, :u8, :u16, :u32, :u64, :f32, :f64].include?(dtype)
+    end
+    alias_method :numeric?, :is_numeric
+
+    # def is_datelike
+    # end
+
+    def is_float
+      [:f32, :f64].include?(dtype)
+    end
+    alias_method :float?, :is_float
+
+    def is_bool
+      dtype == :bool
+    end
+    alias_method :bool?, :is_bool
+
+    def is_utf8
+      dtype == :str
+    end
+    alias_method :utf8?, :is_utf8
+
+    # def view
+    # end
+
+    # def to_numo
+    # end
+
+    # def set
+    # end
+
+    # def set_at_idx
+    # end
+
+    # def cleared
+    # end
+
+    # clone handled by initialize_copy
+
+    # def fill_nan
+    # end
+
+    # def fill_null
+    # end
+
+    def floor
+      Utils.wrap_s(_s.floor)
+    end
+
+    def ceil
+      Utils.wrap_s(_s.ceil)
+    end
+
+    # default to 0 like Ruby
+    def round(decimals = 0)
+      Utils.wrap_s(_s.round(decimals))
+    end
+
+    # def dot
+    # end
+
+    # def mode
+    # end
+
+    # def sign
+    # end
+
+    # def sin
+    # end
+
+    # def cos
+    # end
+
+    # def tan
+    # end
+
+    # def arcsin
+    # end
+
+    # def arccos
+    # end
+
+    # def arctan
+    # end
+
+    # def arcsinh
+    # end
+
+    # def arccosh
+    # end
+
+    # def arctanh
+    # end
+
+    # def sinh
+    # end
+
+    # def cosh
+    # end
+
+    # def tanh
+    # end
+
+    # def apply
+    # end
+
+    # def shift
+    # end
+
+    # def shift_and_fill
+    # end
+
+    # def zip_with
+    # end
+
+    # def rolling_min
+    # end
+
+    # def rolling_max
+    # end
+
+    # def rolling_mean
+    # end
+
+    # def rolling_sum
+    # end
+
+    # def rolling_std
+    # end
+
+    # def rolling_var
+    # end
+
+    # def rolling_apply
+    # end
+
+    # def rolling_median
+    # end
+
+    # def rolling_quantile
+    # end
+
+    # def rolling_skew
+    # end
+
+    # def sample
+    # end
+
+    def peak_max
+      Utils.wrap_s(_s.peak_max)
+    end
+
+    def peak_min
+      Utils.wrap_s(_s.peak_min)
+    end
+
+    def n_unique
+      _s.n_unique
+    end
+
+    # def shrink_to_fit
+    # end
+
+    # def _hash
+    # end
+
+    # def reinterpret
+    # end
+
+    # def interpolate
+    # end
+
+    # def abs
+    # end
+
+    # def rank
+    # end
+
+    # def diff
+    # end
+
+    # def pct_change
+    # end
+
+    # def skew
+    # end
+
+    # def kurtosis
+    # end
+
+    # def clip
+    # end
+
+    # def clip_min
+    # end
+
+    # def clip_max
+    # end
+
+    # def reshape
+    # end
+
+    # def shuffle
+    # end
+
+    # def ewm_mean
+    # end
+
+    # def ewm_std
+    # end
+
+    # def ewm_var
+    # end
+
+    # def extend_constant
+    # end
+
+    def set_sorted(reverse: false)
+      Utils.wrap_s(_s.set_sorted(reverse))
+    end
+
+    # def new_from_index
+    # end
+
+    # def shrink_dtype
+    # end
+
+    # def arr
+    # end
+
+    # def cat
+    # end
+
+    # def dt
+    # end
+
+    # def str
+    # end
+
+    # def struct
+    # end
+
     private
 
+    def initialize_copy(other)
+      super
+      self._s = _s._clone
+    end
+
     def sequence_to_rbseries(name, values, dtype: nil, strict: true, dtype_if_empty: nil)
       ruby_dtype = nil
 
@@ -205,17 +686,42 @@ module Polars
         end
       end
 
+      rb_temporal_types = []
+      rb_temporal_types << Date if defined?(Date)
+      rb_temporal_types << DateTime if defined?(DateTime)
+      rb_temporal_types << Time if defined?(Time)
+
       # _get_first_non_none
       value = values.find { |v| !v.nil? }
 
-      if !dtype.nil? && is_polars_dtype(dtype) && ruby_dtype.nil?
+      if !dtype.nil? && Utils.is_polars_dtype(dtype) && ruby_dtype.nil?
         constructor = polars_type_to_constructor(dtype)
         rbseries = constructor.call(name, values, strict)
         return rbseries
-      end
+      else
+        if ruby_dtype.nil?
+          if value.nil?
+            # generic default dtype
+            ruby_dtype = Float
+          else
+            ruby_dtype = value.class
+          end
+        end
 
-      constructor = rb_type_to_constructor(value.class)
-      constructor.call(name, values, strict)
+        # temporal branch
+        if rb_temporal_types.include?(ruby_dtype)
+          # if dtype.nil?
+          #   dtype = rb_type_to_dtype(ruby_dtype)
+          # elsif rb_temporal_types.include?(dtype)
+          #   dtype = rb_type_to_dtype(dtype)
+          # end
+
+          raise "todo"
+        else
+          constructor = rb_type_to_constructor(value.class)
+          constructor.call(name, values, strict)
+        end
+      end
     end
 
     POLARS_TYPE_TO_CONSTRUCTOR = {
@@ -253,9 +759,5 @@ module Polars
       # RbSeries.method(:new_object)
       raise ArgumentError, "Cannot determine type"
     end
-
-    def is_polars_dtype(data_type)
-      true
-    end
   end
 end

data/lib/polars/string_expr.rb

@@ -6,12 +6,129 @@ module Polars
       self._rbexpr = expr._rbexpr
     end
 
+    # def strptime
+    # end
+
     def lengths
       Utils.wrap_expr(_rbexpr.str_lengths)
     end
 
+    def n_chars
+      Utils.wrap_expr(_rbexpr.str_n_chars)
+    end
+
+    def concat(delimiter = "-")
+      Utils.wrap_expr(_rbexpr.str_concat(delimiter))
+    end
+
+    def to_uppercase
+      Utils.wrap_expr(_rbexpr.str_to_uppercase)
+    end
+
+    def to_lowercase
+      Utils.wrap_expr(_rbexpr.str_to_lowercase)
+    end
+
+    def strip(matches = nil)
+      if !matches.nil? && matches.length > 1
+        raise ArgumentError, "matches should contain a single character"
+      end
+      Utils.wrap_expr(_rbexpr.str_strip(matches))
+    end
+
+    def lstrip(matches = nil)
+      if !matches.nil? && matches.length > 1
+        raise ArgumentError, "matches should contain a single character"
+      end
+      Utils.wrap_expr(_rbexpr.str_lstrip(matches))
+    end
+
+    def rstrip(matches = nil)
+      if !matches.nil? && matches.length > 1
+        raise ArgumentError, "matches should contain a single character"
+      end
+      Utils.wrap_expr(_rbexpr.str_rstrip(matches))
+    end
+
+    def zfill(alignment)
+      Utils.wrap_expr(_rbexpr.str_zfill(alignment))
+    end
+
+    def ljust(width, fillchar = " ")
+      Utils.wrap_expr(_rbexpr.str_ljust(width, fillchar))
+    end
+
+    def rjust(width, fillchar = " ")
+      Utils.wrap_expr(_rbexpr.str_rjust(width, fillchar))
+    end
+
     def contains(pattern, literal: false)
       Utils.wrap_expr(_rbexpr.str_contains(pattern, literal))
     end
+
+    def ends_with(sub)
+      Utils.wrap_expr(_rbexpr.str_ends_with(sub))
+    end
+
+    def starts_with(sub)
+      Utils.wrap_expr(_rbexpr.str_starts_with(sub))
+    end
+
+    # def json_path_match
+    # end
+
+    # def decode
+    # end
+
+    # def encode
+    # end
+
+    def extract(pattern, group_index: 1)
+      Utils.wrap_expr(_rbexpr.str_extract(pattern, group_index))
+    end
+
+    def extract_all(pattern)
+      Utils.wrap_expr(_rbexpr.str_extract_all(pattern))
+    end
+
+    def count_match(pattern)
+      Utils.wrap_expr(_rbexpr.count_match(pattern))
+    end
+
+    def split(by, inclusive: false)
+      if inclusive
+        Utils.wrap_expr(_rbexpr.str_split_inclusive(by))
+      else
+        Utils.wrap_expr(_rbexpr.str_split(by))
+      end
+    end
+
+    def split_exact(by, n, inclusive: false)
+      if inclusive
+        Utils.wrap_expr(_rbexpr.str_split_exact_inclusive(by, n))
+      else
+        Utils.wrap_expr(_rbexpr.str_split_exact(by, n))
+      end
+    end
+
+    def splitn(by, n)
+      Utils.wrap_expr(_rbexpr.str_splitn(by, n))
+    end
+
+    def replace(pattern, literal: false)
+      pattern = Utils.expr_to_lit_or_expr(pattern, str_to_lit: true)
+      value = Utils.expr_to_lit_or_expr(value, str_to_lit: true)
+      Utils.wrap_expr(_rbexpr.str_replace(pattern._rbexpr, value._rbexpr, literal))
+    end
+
+    def replace_all(pattern, literal: false)
+      pattern = Utils.expr_to_lit_or_expr(pattern, str_to_lit: true)
+      value = Utils.expr_to_lit_or_expr(value, str_to_lit: true)
+      Utils.wrap_expr(_rbexpr.str_replace_all(pattern._rbexpr, value._rbexpr, literal))
+    end
+
+    def slice(offset, length = nil)
+      Utils.wrap_expr(_rbexpr.str_slice(offset, length))
+    end
   end
 end