polars-df 0.5.0-arm64-darwin → 0.7.0-arm64-darwin

data/lib/polars/string_name_space.rb

@@ -10,6 +10,113 @@ module Polars
       self._s = series._s
     end
 
+    # Convert a Utf8 column into a Date column.
+    #
+    # @param format [String]
+    #   Format to use for conversion. Refer to the
+    #   [chrono crate documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    #   for the full specification. Example: `"%Y-%m-%d"`.
+    #   If set to nil (default), the format is inferred from the data.
+    # @param strict [Boolean]
+    #   Raise an error if any conversion fails.
+    # @param exact [Boolean]
+    #   Require an exact format match. If false, allow the format to match anywhere
+    #   in the target string.
+    # @param cache [Boolean]
+    #   Use a cache of unique, converted dates to apply the conversion.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(["2020/01/01", "2020/02/01", "2020/03/01"])
+    #   s.str.to_date
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [date]
+    #   # [
+    #   #         2020-01-01
+    #   #         2020-02-01
+    #   #         2020-03-01
+    #   # ]
+    def to_date(format = nil, strict: true, exact: true, cache: true)
+      super
+    end
+
+    # Convert a Utf8 column into a Datetime column.
+    #
+    # @param format [String]
+    #   Format to use for conversion. Refer to the
+    #   [chrono crate documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    #   for the full specification. Example: `"%Y-%m-%d %H:%M:%S"`.
+    #   If set to nil (default), the format is inferred from the data.
+    # @param time_unit ["us", "ns", "ms"]
+    #   Unit of time for the resulting Datetime column. If set to nil (default),
+    #   the time unit is inferred from the format string if given, eg:
+    #   `"%F %T%.3f"` => `Datetime("ms")`. If no fractional second component is
+    #   found, the default is `"us"`.
+    # @param time_zone [String]
+    #   Time zone for the resulting Datetime column.
+    # @param strict [Boolean]
+    #   Raise an error if any conversion fails.
+    # @param exact [Boolean]
+    #   Require an exact format match. If false, allow the format to match anywhere
+    #   in the target string.
+    # @param cache [Boolean]
+    #   Use a cache of unique, converted datetimes to apply the conversion.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(["2020-01-01 01:00Z", "2020-01-01 02:00Z"])
+    #   s.str.to_datetime("%Y-%m-%d %H:%M%#z")
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: '' [datetime[μs, UTC]]
+    #   # [
+    #   #         2020-01-01 01:00:00 UTC
+    #   #         2020-01-01 02:00:00 UTC
+    #   # ]
+    def to_datetime(
+      format = nil,
+      time_unit: nil,
+      time_zone: nil,
+      strict: true,
+      exact: true,
+      cache: true,
+      use_earliest: nil
+    )
+      super
+    end
+
+    # Convert a Utf8 column into a Time column.
+    #
+    # @param format [String]
+    #   Format to use for conversion. Refer to the
+    #   [chrono crate documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
+    #   for the full specification. Example: `"%H:%M:%S"`.
+    #   If set to nil (default), the format is inferred from the data.
+    # @param strict [Boolean]
+    #   Raise an error if any conversion fails.
+    # @param cache [Boolean]
+    #   Use a cache of unique, converted times to apply the conversion.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   s = Polars::Series.new(["01:00", "02:00", "03:00"])
+    #   s.str.to_time("%H:%M")
+    #   # =>
+    #   # shape: (3,)
+    #   # Series: '' [time]
+    #   # [
+    #   #         01:00:00
+    #   #         02:00:00
+    #   #         03:00:00
+    #   # ]
+    def to_time(format = nil, strict: true, cache: true)
+      super
+    end
+
     # Parse a Series of dtype Utf8 to a Date/Datetime Series.
     #
     # @param datatype [Symbol]
@@ -23,10 +130,23 @@ module Polars
     # @param exact [Boolean]
     #   - If true, require an exact format match.
     #   - If false, allow the format to match anywhere in the target string.
+    # @param cache [Boolean]
+    #   Use a cache of unique, converted dates to apply the datetime conversion.
     #
     # @return [Series]
     #
-    # @example
+    # @example Dealing with a consistent format:
+    #   s = Polars::Series.new(["2020-01-01 01:00Z", "2020-01-01 02:00Z"])
+    #   s.str.strptime(Polars::Datetime, "%Y-%m-%d %H:%M%#z")
+    #   # =>
+    #   # shape: (2,)
+    #   # Series: '' [datetime[μs, UTC]]
+    #   # [
+    #   #         2020-01-01 01:00:00 UTC
+    #   #         2020-01-01 02:00:00 UTC
+    #   # ]
+    #
+    # @example Dealing with different formats.
     #   s = Polars::Series.new(
     #     "date",
     #     [
@@ -36,28 +156,24 @@ module Polars
     #       "Sun Jul  8 00:34:60 2001"
     #     ]
     #   )
-    #   s.to_frame.with_column(
-    #     Polars.col("date")
-    #       .str.strptime(Polars::Date, "%F", strict: false)
-    #       .fill_null(
-    #         Polars.col("date").str.strptime(Polars::Date, "%F %T", strict: false)
-    #       )
-    #       .fill_null(Polars.col("date").str.strptime(Polars::Date, "%D", strict: false))
-    #       .fill_null(Polars.col("date").str.strptime(Polars::Date, "%c", strict: false))
-    #   )
+    #   s.to_frame.select(
+    #     Polars.coalesce(
+    #       Polars.col("date").str.strptime(Polars::Date, "%F", strict: false),
+    #       Polars.col("date").str.strptime(Polars::Date, "%F %T", strict: false),
+    #       Polars.col("date").str.strptime(Polars::Date, "%D", strict: false),
+    #       Polars.col("date").str.strptime(Polars::Date, "%c", strict: false)
+    #     )
+    #   ).to_series
     #   # =>
-    #   # shape: (4, 1)
-    #   # ┌────────────┐
-    #   # │ date       │
-    #   # │ ---        │
-    #   # │ date       │
-    #   # ╞════════════╡
-    #   # │ 2021-04-22 │
-    #   # │ 2022-01-04 │
-    #   # │ 2022-01-31 │
-    #   # │ 2001-07-08 │
-    #   # └────────────┘
-    def strptime(datatype, fmt = nil, strict: true, exact: true, cache: true, tz_aware: false, utc: false)
+    #   # shape: (4,)
+    #   # Series: 'date' [date]
+    #   # [
+    #   #         2021-04-22
+    #   #         2022-01-04
+    #   #         2022-01-31
+    #   #         2001-07-08
+    #   # ]
+    def strptime(datatype, fmt = nil, strict: true, exact: true, cache: true)
       super
     end
 
@@ -117,9 +233,23 @@ module Polars
     # @return [Series]
     #
     # @example
-    #   Polars::Series.new([1, nil, 2]).str.concat("-")[0]
-    #   # => "1-null-2"
-    def concat(delimiter = "-")
+    #   Polars::Series.new([1, nil, 2]).str.concat("-")
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         "1-2"
+    #   # ]
+    #
+    # @example
+    #   Polars::Series.new([1, nil, 2]).str.concat("-", ignore_nulls: false)
+    #   # =>
+    #   # shape: (1,)
+    #   # Series: '' [str]
+    #   # [
+    #   #         null
+    #   # ]
+    def concat(delimiter = "-", ignore_nulls: true)
       super
     end
 

data/lib/polars/utils.rb

@@ -40,17 +40,23 @@ module Polars
       td
     end
 
-    def self._datetime_to_pl_timestamp(dt, tu)
-      if tu == "ns"
-        (dt.to_datetime.to_time.to_f * 1e9).to_i
-      elsif tu == "us"
-        (dt.to_datetime.to_time.to_f * 1e6).to_i
-      elsif tu == "ms"
-        (dt.to_datetime.to_time.to_f * 1e3).to_i
-      elsif tu.nil?
-        (dt.to_datetime.to_time.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, "tu must be one of {{'ns', 'us', 'ms'}}, got #{tu}"
+        raise ArgumentError, "time_unit must be one of {{'ns', 'us', 'ms'}}, got #{tu}"
       end
     end
 
@@ -59,46 +65,56 @@ module Polars
       dt.to_i / (3600 * 24)
     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
-        else
-          raise Todo
-        end
-
-        dt
+    def self._to_ruby_time(value)
+      if value == 0
+        ::Time.utc(2000, 1, 1)
       else
-        raise NotImplementedError
+        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, tu = "ns")
-      if tu == "ns"
+    def self._to_ruby_duration(value, time_unit = "ns")
+      if time_unit == "ns"
         value / 1e9
-      elsif tu == "us"
+      elsif time_unit == "us"
         value / 1e6
-      elsif tu == "ms"
+      elsif time_unit == "ms"
         value / 1e3
       else
-        raise ArgumentError, "tu must be one of {{'ns', 'us', 'ms'}}, got #{tu}"
+        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 ArgumentError, "time_unit must be one of {{'ns', 'us', 'ms'}}, got #{time_unit}"
+        end
+      else
+        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]
@@ -139,16 +155,27 @@ module Polars
       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,
-      ::Time => :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)
@@ -158,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
@@ -228,35 +255,70 @@ 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
+
+    USE_EARLIEST_TO_AMBIGUOUS = {
+      true => "earliest",
+      false => "latest"
+    }
+
+    def self.rename_use_earliest_to_ambiguous(use_earliest, ambiguous)
+      unless use_earliest.nil?
+        ambiguous = USE_EARLIEST_TO_AMBIGUOUS.fetch(use_earliest)
+      end
+      ambiguous
+    end
   end
 end

data/lib/polars/version.rb

@@ -1,4 +1,4 @@
 module Polars
   # @private
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

data/lib/polars.rb

@@ -6,16 +6,20 @@ rescue LoadError
 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"
 require_relative "polars/cat_expr"
 require_relative "polars/cat_name_space"
+require_relative "polars/config"
 require_relative "polars/convert"
 require_relative "polars/plot"
 require_relative "polars/data_frame"
@@ -34,9 +38,11 @@ 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/name_expr"
 require_relative "polars/rolling_group_by"
 require_relative "polars/series"
 require_relative "polars/slice"
+require_relative "polars/sql_context"
 require_relative "polars/string_expr"
 require_relative "polars/string_name_space"
 require_relative "polars/struct_expr"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: arm64-darwin
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-05-16 00:00:00.000000000 Z
+date: 2023-11-18 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: andrew@ankane.org
@@ -28,11 +28,14 @@ files:
 - lib/polars/3.0/polars.bundle
 - lib/polars/3.1/polars.bundle
 - lib/polars/3.2/polars.bundle
+- 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
 - lib/polars/cat_expr.rb
 - lib/polars/cat_name_space.rb
+- lib/polars/config.rb
 - lib/polars/convert.rb
 - lib/polars/data_frame.rb
 - lib/polars/data_types.rb
@@ -51,10 +54,12 @@ files:
 - lib/polars/list_expr.rb
 - lib/polars/list_name_space.rb
 - lib/polars/meta_expr.rb
+- lib/polars/name_expr.rb
 - lib/polars/plot.rb
 - lib/polars/rolling_group_by.rb
 - lib/polars/series.rb
 - lib/polars/slice.rb
+- lib/polars/sql_context.rb
 - lib/polars/string_expr.rb
 - lib/polars/string_name_space.rb
 - lib/polars/struct_expr.rb