polars-df 0.1.4 → 0.2.0

data/lib/polars/rolling_group_by.rb

@@ -0,0 +1,35 @@
+module Polars
+  # A rolling grouper.
+  #
+  # This has an `.agg` method which will allow you to run all polars expressions in a
+  # groupby context.
+  class RollingGroupBy
+    def initialize(
+      df,
+      index_column,
+      period,
+      offset,
+      closed,
+      by
+    )
+      period = Utils._timedelta_to_pl_duration(period)
+      offset = Utils._timedelta_to_pl_duration(offset)
+
+      @df = df
+      @time_column = index_column
+      @period = period
+      @offset = offset
+      @closed = closed
+      @by = by
+    end
+
+    def agg(aggs)
+      @df.lazy
+        .groupby_rolling(
+          index_column: @time_column, period: @period, offset: @offset, closed: @closed, by: @by
+        )
+        .agg(aggs)
+        .collect(no_optimization: true, string_cache: false)
+    end
+  end
+end

data/lib/polars/series.rb

@@ -23,9 +23,9 @@ module Polars
     # @example Constructing a Series by specifying name and values positionally:
     #   s = Polars::Series.new("a", [1, 2, 3])
     #
-    # @example Notice that the dtype is automatically inferred as a polars Int64:
+    # @example Notice that the dtype is automatically inferred as a polars `Int64`:
     #   s.dtype
-    #   # => :i64
+    #   # => Polars::Int64
     #
     # @example Constructing a Series with a specific dtype:
     #   s2 = Polars::Series.new("a", [1, 2, 3], dtype: :f32)
@@ -45,6 +45,11 @@ module Polars
 
       name = "" if name.nil?
 
+      # TODO improve
+      if values.is_a?(Range) && values.begin.is_a?(String)
+        values = values.to_a
+      end
+
       if values.nil?
         self._s = sequence_to_rbseries(name, [], dtype: dtype, dtype_if_empty: dtype_if_empty)
       elsif values.is_a?(Series)
@@ -1668,8 +1673,32 @@ module Polars
       super
     end
 
-    # def to_physical
-    # end
+    # Cast to physical representation of the logical dtype.
+    #
+    # - `:date` -> `:i32`
+    # - `:datetime` -> `:i64`
+    # - `:time` -> `:i64`
+    # - `:duration` -> `:i64`
+    # - `:cat` -> `:u32`
+    # - other data types will be left unchanged.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("values", ["a", nil, "x", "a"])
+    #   s.cast(:cat).to_physical
+    #   # =>
+    #   # shape: (4,)
+    #   # Series: 'values' [u32]
+    #   # [
+    #   #         0
+    #   #         null
+    #   #         1
+    #   #         0
+    #   # ]
+    def to_physical
+      super
+    end
 
     # Convert this Series to a Ruby Array. This operation clones data.
     #
@@ -1722,7 +1751,7 @@ module Polars
     #   s.is_numeric
     #   # => true
     def is_numeric
-      [:i8, :i16, :i32, :i64, :u8, :u16, :u32, :u64, :f32, :f64].include?(dtype)
+      [Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64, Float32, Float64].include?(dtype)
     end
     alias_method :numeric?, :is_numeric
 
@@ -1735,7 +1764,7 @@ module Polars
     #   s.is_datelike
     #   # => true
     def is_datelike
-      [:date, :datetime, :duration, :time].include?(dtype)
+      [Date, Datetime, Duration, Time].include?(dtype)
     end
 
     # Check if this Series has floating point numbers.
@@ -1747,7 +1776,7 @@ module Polars
     #   s.is_float
     #   # => true
     def is_float
-      [:f32, :f64].include?(dtype)
+      [Float32, Float64].include?(dtype)
     end
     alias_method :float?, :is_float
 
@@ -1760,7 +1789,7 @@ module Polars
     #   s.is_boolean
     #   # => true
     def is_boolean
-      dtype == :bool
+      dtype == Boolean
     end
     alias_method :boolean?, :is_boolean
     alias_method :is_bool, :is_boolean
@@ -1775,7 +1804,7 @@ module Polars
     #   s.is_utf8
     #   # => true
     def is_utf8
-      dtype == :str
+      dtype == Utf8
     end
     alias_method :utf8?, :is_utf8
 
@@ -1785,8 +1814,34 @@ module Polars
     # def to_numo
     # end
 
-    # def set
-    # end
+    # Set masked values.
+    #
+    # @param filter [Series]
+    #   Boolean mask.
+    # @param value [Object]
+    #   Value with which to replace the masked values.
+    #
+    # @return [Series]
+    #
+    # @note
+    #   Use of this function is frequently an anti-pattern, as it can
+    #   block optimization (predicate pushdown, etc). Consider using
+    #   `Polars.when(predicate).then(value).otherwise(self)` instead.
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.set(s == 2, 10)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         1
+    #   #         10
+    #   #         3
+    #   # ]
+    def set(filter, value)
+      Utils.wrap_s(_s.send("set_with_mask_#{DTYPE_TO_FFINAME.fetch(dtype)}", filter._s, value))
+    end
 
     # Set values at the index locations.
     #
@@ -2286,8 +2341,41 @@ module Polars
       super
     end
 
-    # def apply
-    # end
+    # Apply a custom/user-defined function (UDF) over elements in this Series and
+    # return a new Series.
+    #
+    # If the function returns another datatype, the return_dtype arg should be set,
+    # otherwise the method will fail.
+    #
+    # @param return_dtype [Symbol]
+    #   Output datatype. If none is given, the same datatype as this Series will be
+    #   used.
+    # @param skip_nulls [Boolean]
+    #   Nulls will be skipped and not passed to the Ruby function.
+    #   This is faster because Ruby can be skipped and because we call
+    #   more specialized functions.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s.apply { |x| x + 10 }
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [i64]
+    #   # [
+    #   #         11
+    #   #         12
+    #   #         13
+    #   # ]
+    def apply(return_dtype: nil, skip_nulls: true, &func)
+      if return_dtype.nil?
+        pl_return_dtype = nil
+      else
+        pl_return_dtype = Utils.rb_type_to_dtype(return_dtype)
+      end
+      Utils.wrap_s(_s.apply_lambda(func, pl_return_dtype, skip_nulls))
+    end
 
     # Shift the values by a given period.
     #
@@ -2953,8 +3041,35 @@ module Polars
       end
     end
 
-    # def _hash
-    # end
+    # Hash the Series.
+    #
+    # The hash value is of type `:u64`.
+    #
+    # @param seed [Integer]
+    #   Random seed parameter. Defaults to 0.
+    # @param seed_1 [Integer]
+    #   Random seed parameter. Defaults to `seed` if not set.
+    # @param seed_2 [Integer]
+    #   Random seed parameter. Defaults to `seed` if not set.
+    # @param seed_3 [Integer]
+    #   Random seed parameter. Defaults to `seed` if not set.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new("a", [1, 2, 3])
+    #   s._hash(42)
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: 'a' [u64]
+    #   # [
+    #   #         2374023516666777365
+    #   #         10386026231460783898
+    #   #         17796317186427479491
+    #   # ]
+    def _hash(seed = 0, seed_1 = nil, seed_2 = nil, seed_3 = nil)
+      super
+    end
 
     # Reinterpret the underlying bits as a signed/unsigned integer.
     #
@@ -2986,7 +3101,7 @@ module Polars
     #   #         4
     #   #         5
     #   # ]
-    def interpolate
+    def interpolate(method: "linear")
       super
     end
 
@@ -3410,10 +3525,10 @@ module Polars
         return Utils.wrap_s(_s.send(op, other._s))
       end
 
-      if dtype == :str
+      if dtype == Utf8
         raise Todo
       end
-      Utils.wrap_s(_s.send("#{op}_#{dtype}", other))
+      Utils.wrap_s(_s.send("#{op}_#{DTYPE_TO_FFINAME.fetch(dtype)}", other))
     end
 
     def _arithmetic(other, op)
@@ -3424,8 +3539,39 @@ module Polars
         return Utils.wrap_s(_s.send(op, other._s))
       end
 
-      raise Todo
-    end
+      if other.is_a?(::Date) || other.is_a?(::DateTime) || other.is_a?(::Time) || other.is_a?(String)
+        raise Todo
+      end
+      if other.is_a?(Float) && !is_float
+        raise Todo
+      end
+
+      Utils.wrap_s(_s.send("#{op}_#{DTYPE_TO_FFINAME.fetch(dtype)}", other))
+    end
+
+    DTYPE_TO_FFINAME = {
+      Int8 => "i8",
+      Int16 => "i16",
+      Int32 => "i32",
+      Int64 => "i64",
+      UInt8 => "u8",
+      UInt16 => "u16",
+      UInt32 => "u32",
+      UInt64 => "u64",
+      Float32 => "f32",
+      Float64 => "f64",
+      Boolean => "bool",
+      Utf8 => "str",
+      List => "list",
+      Date => "date",
+      Datetime => "datetime",
+      Duration => "duration",
+      Time => "time",
+      Object => "object",
+      Categorical => "categorical",
+      Struct => "struct",
+      Binary => "binary"
+    }
 
     def series_to_rbseries(name, values)
       # should not be in-place?
@@ -3449,9 +3595,9 @@ module Polars
       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)
+      rb_temporal_types << ::Date if defined?(::Date)
+      rb_temporal_types << ::DateTime if defined?(::DateTime)
+      rb_temporal_types << ::Time if defined?(::Time)
 
       value = _get_first_non_none(values)
 
@@ -3477,11 +3623,11 @@ module Polars
           #   dtype = rb_type_to_dtype(dtype)
           # end
 
-          if ruby_dtype == Date
+          if ruby_dtype == ::Date
             RbSeries.new_opt_date(name, values, strict)
-          elsif ruby_dtype == Time
+          elsif ruby_dtype == ::Time
             RbSeries.new_opt_datetime(name, values, strict)
-          elsif ruby_dtype == DateTime
+          elsif ruby_dtype == ::DateTime
             RbSeries.new_opt_datetime(name, values.map(&:to_time), strict)
           else
             raise Todo
@@ -3524,6 +3670,21 @@ module Polars
     end
 
     POLARS_TYPE_TO_CONSTRUCTOR = {
+      Float32 => RbSeries.method(:new_opt_f32),
+      Float64 => RbSeries.method(:new_opt_f64),
+      Int8 => RbSeries.method(:new_opt_i8),
+      Int16 => RbSeries.method(:new_opt_i16),
+      Int32 => RbSeries.method(:new_opt_i32),
+      Int64 => RbSeries.method(:new_opt_i64),
+      UInt8 => RbSeries.method(:new_opt_u8),
+      UInt16 => RbSeries.method(:new_opt_u16),
+      UInt32 => RbSeries.method(:new_opt_u32),
+      UInt64 => RbSeries.method(:new_opt_u64),
+      Boolean => RbSeries.method(:new_opt_bool),
+      Utf8 => RbSeries.method(:new_str)
+    }
+
+    SYM_TYPE_TO_CONSTRUCTOR = {
       f32: RbSeries.method(:new_opt_f32),
       f64: RbSeries.method(:new_opt_f64),
       i8: RbSeries.method(:new_opt_i8),
@@ -3539,7 +3700,11 @@ module Polars
     }
 
     def polars_type_to_constructor(dtype)
-      POLARS_TYPE_TO_CONSTRUCTOR.fetch(dtype.to_sym)
+      if dtype.is_a?(Class) && dtype < DataType
+        POLARS_TYPE_TO_CONSTRUCTOR.fetch(dtype)
+      else
+        SYM_TYPE_TO_CONSTRUCTOR.fetch(dtype.to_sym)
+      end
     rescue KeyError
       raise ArgumentError, "Cannot construct RbSeries for type #{dtype}."
     end

data/lib/polars/string_expr.rb

@@ -64,24 +64,24 @@ module Polars
     #   # ├╌╌╌╌╌╌╌╌╌╌╌╌┤
     #   # │ 2001-07-08 │
     #   # └────────────┘
-    def strptime(datatype, fmt = nil, strict: true, exact: true)
+    def strptime(datatype, fmt = nil, strict: true, exact: true, cache: true, tz_aware: false)
       if !Utils.is_polars_dtype(datatype)
         raise ArgumentError, "expected: {DataType} got: #{datatype}"
       end
 
       if datatype == :date
-        Utils.wrap_expr(_rbexpr.str_parse_date(fmt, strict, exact))
+        Utils.wrap_expr(_rbexpr.str_parse_date(fmt, strict, exact, cache))
       elsif datatype == :datetime
         # TODO fix
         tu = nil # datatype.tu
-        dtcol = Utils.wrap_expr(_rbexpr.str_parse_datetime(fmt, strict, exact))
+        dtcol = Utils.wrap_expr(_rbexpr.str_parse_datetime(fmt, strict, exact, cache, tz_aware))
         if tu.nil?
           dtcol
         else
           dtcol.dt.cast_time_unit(tu)
         end
       elsif datatype == :time
-        Utils.wrap_expr(_rbexpr.str_parse_time(fmt, strict, exact))
+        Utils.wrap_expr(_rbexpr.str_parse_time(fmt, strict, exact, cache))
       else
         raise ArgumentError, "dtype should be of type :date, :datetime, or :time"
       end
@@ -725,7 +725,8 @@ module Polars
     #   # │ ["678", "910"] │
     #   # └────────────────┘
     def extract_all(pattern)
-      Utils.wrap_expr(_rbexpr.str_extract_all(pattern))
+      pattern = Utils.expr_to_lit_or_expr(pattern, str_to_lit: true)
+      Utils.wrap_expr(_rbexpr.str_extract_all(pattern._rbexpr))
     end
 
     # Count all successive non-overlapping regex matches.

data/lib/polars/string_name_space.rb

@@ -60,7 +60,7 @@ module Polars
     #   # ├╌╌╌╌╌╌╌╌╌╌╌╌┤
     #   # │ 2001-07-08 │
     #   # └────────────┘
-    def strptime(datatype, fmt = nil, strict: true, exact: true)
+    def strptime(datatype, fmt = nil, strict: true, exact: true, cache: true, tz_aware: false)
       super
     end
 

data/lib/polars/utils.rb

@@ -11,6 +11,10 @@ module Polars
       DataFrame._from_rbdf(df)
     end
 
+    def self.wrap_ldf(ldf)
+      LazyFrame._from_rbldf(ldf)
+    end
+
     def self.wrap_expr(rbexpr)
       Expr._from_rbexpr(rbexpr)
     end
@@ -38,18 +42,18 @@ module Polars
     end
 
     def self._to_ruby_datetime(value, dtype, tu: "ns", tz: nil)
-      if dtype == :date
+      if dtype == :date || dtype == Date
         # days to seconds
         # important to create from utc. Not doing this leads
         # to inconsistencies dependent on the timezone you are in.
-        Time.at(value * 86400).utc.to_date
+        ::Time.at(value * 86400).utc.to_date
       # TODO fix dtype
-      elsif dtype.to_s.start_with?("datetime[")
+      elsif dtype.to_s.start_with?("datetime[") || dtype.is_a?(Datetime)
         if tz.nil? || tz == ""
           if tu == "ns"
             raise Todo
           elsif tu == "us"
-            dt = Time.at(value / 1000000, value % 1000000, :usec).utc
+            dt = ::Time.at(value / 1000000, value % 1000000, :usec).utc
           elsif tu == "ms"
             raise Todo
           else
@@ -95,7 +99,7 @@ module Polars
 
     # TODO fix
     def self.is_polars_dtype(data_type)
-      data_type.is_a?(Symbol) || data_type.is_a?(String)
+      data_type.is_a?(Symbol) || data_type.is_a?(String) || data_type.is_a?(DataType) || (data_type.is_a?(Class) && data_type < DataType)
     end
 
     RB_TYPE_TO_DTYPE = {
@@ -104,14 +108,15 @@ module Polars
       String => :str,
       TrueClass => :bool,
       FalseClass => :bool,
-      Date => :date,
-      DateTime => :datetime
+      ::Date => :date,
+      ::DateTime => :datetime
     }
 
     # TODO fix
     def self.rb_type_to_dtype(data_type)
       if is_polars_dtype(data_type)
-        return data_type.to_s
+        data_type = data_type.to_s if data_type.is_a?(Symbol)
+        return data_type
       end
 
       begin
@@ -171,5 +176,17 @@ module Polars
     def self.bool?(value)
       value == true || value == false
     end
+
+    def self._is_iterable_of(val, eltype)
+      val.all? { |x| x.is_a?(eltype) }
+    end
+
+    def self.is_str_sequence(val, allow_str: false)
+      if allow_str == false && val.is_a?(String)
+        false
+      else
+        val.is_a?(Array) && _is_iterable_of(val, String)
+      end
+    end
   end
 end

data/lib/polars/version.rb

@@ -1,4 +1,4 @@
 module Polars
   # @private
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

data/lib/polars.rb

@@ -1,40 +1,49 @@
 # ext
-require "polars/polars"
+begin
+  require_relative "polars/#{RUBY_VERSION.to_f}/polars"
+rescue LoadError
+  require_relative "polars/polars"
+end
 
 # stdlib
 require "date"
 
 # modules
-require "polars/expr_dispatch"
-require "polars/batched_csv_reader"
-require "polars/cat_expr"
-require "polars/cat_name_space"
-require "polars/data_frame"
-require "polars/date_time_expr"
-require "polars/date_time_name_space"
-require "polars/exceptions"
-require "polars/expr"
-require "polars/functions"
-require "polars/group_by"
-require "polars/io"
-require "polars/lazy_frame"
-require "polars/lazy_functions"
-require "polars/lazy_group_by"
-require "polars/list_expr"
-require "polars/list_name_space"
-require "polars/meta_expr"
-require "polars/series"
-require "polars/slice"
-require "polars/string_expr"
-require "polars/string_name_space"
-require "polars/struct_expr"
-require "polars/struct_name_space"
-require "polars/utils"
-require "polars/version"
-require "polars/when"
-require "polars/when_then"
+require_relative "polars/expr_dispatch"
+require_relative "polars/batched_csv_reader"
+require_relative "polars/cat_expr"
+require_relative "polars/cat_name_space"
+require_relative "polars/convert"
+require_relative "polars/data_frame"
+require_relative "polars/data_types"
+require_relative "polars/date_time_expr"
+require_relative "polars/date_time_name_space"
+require_relative "polars/dynamic_group_by"
+require_relative "polars/exceptions"
+require_relative "polars/expr"
+require_relative "polars/functions"
+require_relative "polars/group_by"
+require_relative "polars/io"
+require_relative "polars/lazy_frame"
+require_relative "polars/lazy_functions"
+require_relative "polars/lazy_group_by"
+require_relative "polars/list_expr"
+require_relative "polars/list_name_space"
+require_relative "polars/meta_expr"
+require_relative "polars/rolling_group_by"
+require_relative "polars/series"
+require_relative "polars/slice"
+require_relative "polars/string_expr"
+require_relative "polars/string_name_space"
+require_relative "polars/struct_expr"
+require_relative "polars/struct_name_space"
+require_relative "polars/utils"
+require_relative "polars/version"
+require_relative "polars/when"
+require_relative "polars/when_then"
 
 module Polars
+  extend Convert
   extend Functions
   extend IO
   extend LazyFunctions

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-02 00:00:00.000000000 Z
+date: 2023-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -39,6 +39,9 @@ files:
 - README.md
 - ext/polars/Cargo.toml
 - ext/polars/extconf.rb
+- ext/polars/src/apply/dataframe.rs
+- ext/polars/src/apply/mod.rs
+- ext/polars/src/apply/series.rs
 - ext/polars/src/batched_csv.rs
 - ext/polars/src/conversion.rs
 - ext/polars/src/dataframe.rs
@@ -60,9 +63,12 @@ files:
 - lib/polars/batched_csv_reader.rb
 - lib/polars/cat_expr.rb
 - lib/polars/cat_name_space.rb
+- lib/polars/convert.rb
 - lib/polars/data_frame.rb
+- lib/polars/data_types.rb
 - lib/polars/date_time_expr.rb
 - lib/polars/date_time_name_space.rb
+- lib/polars/dynamic_group_by.rb
 - lib/polars/exceptions.rb
 - lib/polars/expr.rb
 - lib/polars/expr_dispatch.rb
@@ -75,6 +81,7 @@ files:
 - lib/polars/list_expr.rb
 - lib/polars/list_name_space.rb
 - lib/polars/meta_expr.rb
+- lib/polars/rolling_group_by.rb
 - lib/polars/series.rb
 - lib/polars/slice.rb
 - lib/polars/string_expr.rb
@@ -97,14 +104,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Blazingly fast DataFrames for Ruby