polars-df 0.1.5 → 0.2.0

data/lib/polars/lazy_frame.rb

@@ -198,7 +198,7 @@ module Polars
     #     }
     #   ).lazy
     #   lf.dtypes
-    #   # => [:i64, :f64, :str]
+    #   # => [Polars::Int64, Polars::Float64, Polars::Utf8]
     def dtypes
       _ldf.dtypes
     end
@@ -216,7 +216,7 @@ module Polars
     #     }
     #   ).lazy
     #   lf.schema
-    #   # => {"foo"=>:i64, "bar"=>:f64, "ham"=>:str}
+    #   # => {"foo"=>Polars::Int64, "bar"=>Polars::Float64, "ham"=>Polars::Utf8}
     def schema
       _ldf.schema
     end
@@ -1173,7 +1173,8 @@ module Polars
       truncate: true,
       include_boundaries: false,
       closed: "left",
-      by: nil
+      by: nil,
+      start_by: "window"
     )
       if offset.nil?
         if period.nil?
@@ -1200,7 +1201,8 @@ module Polars
         truncate,
         include_boundaries,
         closed,
-        rbexprs_by
+        rbexprs_by,
+        start_by
       )
       LazyGroupBy.new(lgb, self.class)
     end
@@ -2165,7 +2167,8 @@ module Polars
     #   # │ 3.0 ┆ 1.0 │
     #   # └─────┴─────┘
     def quantile(quantile, interpolation: "nearest")
-      _from_rbldf(_ldf.quantile(quantile, interpolation))
+      quantile = Utils.expr_to_lit_or_expr(quantile, str_to_lit: false)
+      _from_rbldf(_ldf.quantile(quantile._rbexpr, interpolation))
     end
 
     # Explode lists to long format.

data/lib/polars/lazy_functions.rb

@@ -8,13 +8,18 @@ module Polars
         name = name.to_a
       end
 
-      if name.is_a?(Array)
+      if name.is_a?(Class) && name < DataType
+        name = [name]
+      end
+
+      if name.is_a?(DataType)
+        Utils.wrap_expr(_dtype_cols([name]))
+      elsif name.is_a?(Array)
         if name.length == 0 || name[0].is_a?(String) || name[0].is_a?(Symbol)
           name = name.map { |v| v.is_a?(Symbol) ? v.to_s : v }
           Utils.wrap_expr(RbExpr.cols(name))
         elsif Utils.is_polars_dtype(name[0])
-          raise Todo
-          # Utils.wrap_expr(_dtype_cols(name))
+          Utils.wrap_expr(_dtype_cols(name))
         else
           raise ArgumentError, "Expected list values to be all `str` or all `DataType`"
         end

data/lib/polars/list_expr.rb

@@ -568,7 +568,7 @@ module Polars
     #   # └────────────┘
     def to_struct(n_field_strategy: "first_non_null", name_generator: nil)
       raise Todo if name_generator
-      Utils.wrap_expr(_rbexpr.lst_to_struct(n_field_strategy, name_generator))
+      Utils.wrap_expr(_rbexpr.lst_to_struct(n_field_strategy, name_generator, 0))
     end
 
     # Run any polars expression against the lists' elements.

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 `:i64`:
+    # @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)
@@ -1751,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
 
@@ -1764,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.
@@ -1776,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
 
@@ -1789,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
@@ -1804,7 +1804,7 @@ module Polars
     #   s.is_utf8
     #   # => true
     def is_utf8
-      dtype == :str
+      dtype == Utf8
     end
     alias_method :utf8?, :is_utf8
 
@@ -1840,7 +1840,7 @@ module Polars
     #   #         3
     #   # ]
     def set(filter, value)
-      Utils.wrap_s(_s.send("set_with_mask_#{dtype}", filter._s, value))
+      Utils.wrap_s(_s.send("set_with_mask_#{DTYPE_TO_FFINAME.fetch(dtype)}", filter._s, value))
     end
 
     # Set values at the index locations.
@@ -3101,7 +3101,7 @@ module Polars
     #   #         4
     #   #         5
     #   # ]
-    def interpolate
+    def interpolate(method: "linear")
       super
     end
 
@@ -3525,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)
@@ -3539,15 +3539,39 @@ module Polars
         return Utils.wrap_s(_s.send(op, other._s))
       end
 
-      if other.is_a?(Date) || other.is_a?(DateTime) || other.is_a?(Time) || other.is_a?(String)
+      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}", other))
-    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?
@@ -3571,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)
 
@@ -3599,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
@@ -3646,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),
@@ -3661,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

@@ -42,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
@@ -99,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 = {
@@ -108,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

data/lib/polars/version.rb

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

data/lib/polars.rb

@@ -1,45 +1,46 @@
 # ext
 begin
-  require "polars/#{RUBY_VERSION.to_f}/polars"
+  require_relative "polars/#{RUBY_VERSION.to_f}/polars"
 rescue LoadError
-  require "polars/polars"
+  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/convert"
-require "polars/data_frame"
-require "polars/date_time_expr"
-require "polars/date_time_name_space"
-require "polars/dynamic_group_by"
-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/rolling_group_by"
-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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-12-22 00:00:00.000000000 Z
+date: 2023-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -65,6 +65,7 @@ files:
 - 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
@@ -103,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.26
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Blazingly fast DataFrames for Ruby