polars-df 0.4.0-x86_64-linux → 0.6.0-x86_64-linux

data/lib/polars/utils.rb

@@ -23,52 +23,98 @@ module Polars
       Polars.col(name)
     end
 
+    def self.arrlen(obj)
+      if obj.is_a?(Range)
+        # size only works for numeric ranges
+        obj.to_a.length
+      elsif obj.is_a?(String)
+        nil
+      else
+        obj.length
+      end
+    rescue
+      nil
+    end
+
     def self._timedelta_to_pl_duration(td)
       td
     end
 
-    def self._datetime_to_pl_timestamp(dt, tu)
-      if tu == "ns"
-        (dt.to_datetime.utc.to_f * 1e9).to_i
-      elsif tu == "us"
-        (dt.to_datetime.utc.to_f * 1e6).to_i
-      elsif tu == "ms"
-        (dt.to_datetime.utc.to_f * 1e3).to_i
-      elsif tu.nil?
-        (dt.to_datetime.utc.to_f * 1e6).to_i
+    def self._datetime_to_pl_timestamp(dt, time_unit)
+      dt = dt.to_datetime.to_time
+      if time_unit == "ns"
+        nanos = dt.nsec
+        dt.to_i * 1_000_000_000 + nanos
+      elsif time_unit == "us"
+        micros = dt.usec
+        dt.to_i * 1_000_000 + micros
+      elsif time_unit == "ms"
+        millis = dt.usec / 1000
+        dt.to_i * 1_000 + millis
+      elsif time_unit.nil?
+        # Ruby has ns precision
+        nanos = dt.nsec
+        dt.to_i * 1_000_000_000 + nanos
+      else
+        raise ArgumentError, "time_unit must be one of {{'ns', 'us', 'ms'}}, got #{tu}"
+      end
+    end
+
+    def self._date_to_pl_date(d)
+      dt = d.to_datetime.to_time
+      dt.to_i / (3600 * 24)
+    end
+
+    def self._to_ruby_time(value)
+      if value == 0
+        ::Time.utc(2000, 1, 1)
       else
-        raise ArgumentError, "tu must be one of {{'ns', 'us', 'ms'}}, got #{tu}"
-      end
-    end
-
-    def self._to_ruby_datetime(value, dtype, tu: "ns", tz: nil)
-      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
-      # TODO fix dtype
-      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
-          elsif tu == "ms"
-            raise Todo
-          else
-            raise ArgumentError, "tu must be one of {{'ns', 'us', 'ms'}}, got #{tu}"
-          end
+        seconds, nanoseconds = value.divmod(1_000_000_000)
+        minutes, seconds = seconds.divmod(60)
+        hours, minutes = minutes.divmod(60)
+        ::Time.utc(2000, 1, 1, hours, minutes, seconds, nanoseconds / 1000.0)
+      end
+    end
+
+    def self._to_ruby_duration(value, time_unit = "ns")
+      if time_unit == "ns"
+        value / 1e9
+      elsif time_unit == "us"
+        value / 1e6
+      elsif time_unit == "ms"
+        value / 1e3
+      else
+        raise ArgumentError, "time_unit must be one of {{'ns', 'us', 'ms'}}, got #{time_unit}"
+      end
+    end
+
+    def self._to_ruby_date(value)
+      # 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
+    end
+
+    def self._to_ruby_datetime(value, time_unit = "ns", time_zone = nil)
+      if time_zone.nil? || time_zone == ""
+        if time_unit == "ns"
+          return ::Time.at(value / 1000000000, value % 1000000000, :nsec).utc
+        elsif time_unit == "us"
+          return ::Time.at(value / 1000000, value % 1000000, :usec).utc
+        elsif time_unit == "ms"
+          return ::Time.at(value / 1000, value % 1000, :millisecond).utc
         else
-          raise Todo
+          raise ArgumentError, "time_unit must be one of {{'ns', 'us', 'ms'}}, got #{time_unit}"
         end
-
-        dt
       else
-        raise NotImplementedError
+        raise Todo
       end
     end
 
+    def self._to_ruby_decimal(digits, scale)
+      BigDecimal("#{digits}e#{scale}")
+    end
+
     def self.selection_to_rbexpr_list(exprs)
       if exprs.is_a?(String) || exprs.is_a?(Symbol) || exprs.is_a?(Expr) || exprs.is_a?(Series)
         exprs = [exprs]
@@ -102,19 +148,34 @@ module Polars
     end
 
     # TODO fix
-    def self.is_polars_dtype(data_type)
+    def self.is_polars_dtype(data_type, include_unknown: false)
+      if data_type == Unknown
+        return include_unknown
+      end
       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 = {
-      Float => :f64,
-      Integer => :i64,
-      String => :str,
-      TrueClass => :bool,
-      FalseClass => :bool,
-      ::Date => :date,
-      ::DateTime => :datetime
-    }
+    def self.map_rb_type_to_dtype(ruby_dtype)
+      if ruby_dtype == Float
+        Float64
+      elsif ruby_dtype == Integer
+        Int64
+      elsif ruby_dtype == String
+        Utf8
+      elsif ruby_dtype == TrueClass || ruby_dtype == FalseClass
+        Boolean
+      elsif ruby_dtype == DateTime || ruby_dtype == ::Time || (defined?(ActiveSupport::TimeWithZone) && ruby_dtype == ActiveSupport::TimeWithZone)
+        Datetime.new("ns")
+      elsif ruby_dtype == ::Date
+        Date
+      elsif ruby_dtype == ::Array
+        List
+      elsif ruby_dtype == NilClass
+        Null
+      else
+        raise TypeError, "Invalid type"
+      end
+    end
 
     # TODO fix
     def self.rb_type_to_dtype(data_type)
@@ -124,8 +185,8 @@ module Polars
       end
 
       begin
-        RB_TYPE_TO_DTYPE.fetch(data_type).to_s
-      rescue KeyError
+        map_rb_type_to_dtype(data_type)
+      rescue TypeError
         raise ArgumentError, "Conversion of Ruby data type #{data_type} to Polars data type not implemented."
       end
     end
@@ -178,7 +239,7 @@ module Polars
     end
 
     def self.bool?(value)
-      value == true || value == false
+      value.is_a?(TrueClass) || value.is_a?(FalseClass)
     end
 
     def self.strlike?(value)
@@ -194,35 +255,58 @@ module Polars
     end
 
     def self.is_bool_sequence(val)
-      val.is_a?(Array) && val.all? { |x| x == true || x == false }
+      val.is_a?(::Array) && val.all? { |x| x == true || x == false }
     end
 
     def self.is_dtype_sequence(val)
-      val.is_a?(Array) && val.all? { |x| is_polars_dtype(x) }
+      val.is_a?(::Array) && val.all? { |x| is_polars_dtype(x) }
     end
 
     def self.is_int_sequence(val)
-      val.is_a?(Array) && _is_iterable_of(val, Integer)
+      val.is_a?(::Array) && _is_iterable_of(val, Integer)
     end
 
     def self.is_expr_sequence(val)
-      val.is_a?(Array) && _is_iterable_of(val, Expr)
+      val.is_a?(::Array) && _is_iterable_of(val, Expr)
     end
 
     def self.is_rbexpr_sequence(val)
-      val.is_a?(Array) && _is_iterable_of(val, RbExpr)
+      val.is_a?(::Array) && _is_iterable_of(val, RbExpr)
     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)
+        val.is_a?(::Array) && _is_iterable_of(val, String)
       end
     end
 
     def self.local_file?(file)
       Dir.glob(file).any?
     end
+
+    def self.parse_as_expression(input, str_as_lit: false, structify: false)
+      if input.is_a?(Expr)
+        expr = input
+      elsif input.is_a?(String) && !str_as_lit
+        expr = Polars.col(input)
+        structify = false
+      elsif [Integer, Float, String, Series, ::Date, ::Time, ::DateTime].any? { |cls| input.is_a?(cls) } || input.nil?
+        expr = Polars.lit(input)
+        structify = false
+      elsif input.is_a?(Array)
+        expr = Polars.lit(Polars::Series.new("", [input]))
+        structify = false
+      else
+        raise TypeError, "did not expect value #{input} of type #{input.class.name}, maybe disambiguate with pl.lit or pl.col"
+      end
+
+      if structify
+        raise Todo
+      end
+
+      expr._rbexpr
+    end
   end
 end

data/lib/polars/version.rb

@@ -1,4 +1,4 @@
 module Polars
   # @private
-  VERSION = "0.4.0"
+  VERSION = "0.6.0"
 end

data/lib/polars.rb

@@ -1,16 +1,19 @@
 # ext
 begin
-  require_relative "polars/#{RUBY_VERSION.to_f}/polars"
+  require "polars/#{RUBY_VERSION.to_f}/polars"
 rescue LoadError
-  require_relative "polars/polars"
+  require "polars/polars"
 end
 
 # stdlib
+require "bigdecimal"
 require "date"
 require "stringio"
 
 # modules
 require_relative "polars/expr_dispatch"
+require_relative "polars/array_expr"
+require_relative "polars/array_name_space"
 require_relative "polars/batched_csv_reader"
 require_relative "polars/binary_expr"
 require_relative "polars/binary_name_space"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: x86_64-linux
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-01 00:00:00.000000000 Z
+date: 2023-07-24 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: andrew@ankane.org
@@ -28,6 +28,8 @@ files:
 - lib/polars/3.0/polars.so
 - lib/polars/3.1/polars.so
 - lib/polars/3.2/polars.so
+- lib/polars/array_expr.rb
+- lib/polars/array_name_space.rb
 - lib/polars/batched_csv_reader.rb
 - lib/polars/binary_expr.rb
 - lib/polars/binary_name_space.rb