polars-df 0.3.1-aarch64-linux → 0.5.0-aarch64-linux

data/lib/polars/string_expr.rb

@@ -11,8 +11,8 @@ module Polars
 
     # Parse a Utf8 expression to a Date/Datetime/Time type.
     #
-    # @param datatype [Symbol]
-    #   `:date`, `:dateime`, or `:time`.
+    # @param dtype [Object]
+    #   The data type to convert into. Can be either Date, Datetime, or Time.
     # @param fmt [String]
     #   Format to use, refer to the
     #   [chrono strftime documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html)
@@ -33,57 +33,56 @@ module Polars
     #   the format string, if given, eg: "%F %T%.3f" => Datetime("ms"). If
     #   no fractional second component is found then the default is "us".
     #
-    # @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, +00:00]]
+    #   # [
+    #   #         2020-01-01 01:00:00 +00:00
+    #   #         2020-01-01 02:00:00 +00:00
+    #   # ]
+    #
+    # @example Dealing with different formats.
     #   s = Polars::Series.new(
     #     "date",
     #     [
     #       "2021-04-22",
     #       "2022-01-04 00:00:00",
     #       "01/31/22",
-    #       "Sun Jul  8 00:34:60 2001"
+    #       "Sun Jul  8 00:34:60 2001",
     #     ]
     #   )
-    #   s.to_frame.with_column(
-    #     Polars.col("date")
-    #       .str.strptime(:date, "%F", strict: false)
-    #       .fill_null(
-    #         Polars.col("date").str.strptime(:date, "%F %T", strict: false)
-    #       )
-    #       .fill_null(Polars.col("date").str.strptime(:date, "%D", strict: false))
-    #       .fill_null(Polars.col("date").str.strptime(: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)
-      if !Utils.is_polars_dtype(datatype)
-        raise ArgumentError, "expected: {DataType} got: #{datatype}"
-      end
-
-      if datatype == :date
+    #   # shape: (4,)
+    #   # Series: 'date' [date]
+    #   # [
+    #   #         2021-04-22
+    #   #         2022-01-04
+    #   #         2022-01-31
+    #   #         2001-07-08
+    #   # ]
+    def strptime(dtype, fmt = nil, strict: true, exact: true, cache: true, tz_aware: false, utc: false)
+      if dtype == Date
         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, cache, tz_aware, utc))
-        if tu.nil?
-          dtcol
-        else
-          dtcol.dt.cast_time_unit(tu)
-        end
-      elsif datatype == :time
+      elsif dtype == Datetime || dtype.is_a?(Datetime)
+        dtype = Datetime.new if dtype == Datetime
+        time_unit = dtype.time_unit
+        time_zone = dtype.time_zone
+        Utils.wrap_expr(_rbexpr.str_parse_datetime(fmt, time_unit, time_zone, strict, exact, cache, tz_aware, utc))
+      elsif dtype == Time
         Utils.wrap_expr(_rbexpr.str_parse_time(fmt, strict, exact, cache))
       else
-        raise ArgumentError, "dtype should be of type :date, :datetime, or :time"
+        raise ArgumentError, "dtype should be of type {Date, Datetime, Time}"
       end
     end
 
@@ -332,7 +331,7 @@ module Polars
     #   # │ -0001   │
     #   # │ 00000   │
     #   # │ 00001   │
-    #   # │ ...     │
+    #   # │ …       │
     #   # │ 10000   │
     #   # │ 100000  │
     #   # │ 1000000 │
@@ -521,6 +520,40 @@ module Polars
       Utils.wrap_expr(_rbexpr.str_starts_with(sub))
     end
 
+    # Parse string values as JSON.
+    #
+    # Throw errors if encounter invalid JSON strings.
+    #
+    # @param dtype [Object]
+    #   The dtype to cast the extracted value to. If nil, the dtype will be
+    #   inferred from the JSON value.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"json" => ['{"a":1, "b": true}', nil, '{"a":2, "b": false}']}
+    #   )
+    #   dtype = Polars::Struct.new([Polars::Field.new("a", Polars::Int64), Polars::Field.new("b", Polars::Boolean)])
+    #   df.select(Polars.col("json").str.json_extract(dtype))
+    #   # =>
+    #   # shape: (3, 1)
+    #   # ┌─────────────┐
+    #   # │ json        │
+    #   # │ ---         │
+    #   # │ struct[2]   │
+    #   # ╞═════════════╡
+    #   # │ {1,true}    │
+    #   # │ {null,null} │
+    #   # │ {2,false}   │
+    #   # └─────────────┘
+    def json_extract(dtype = nil)
+      if !dtype.nil?
+        dtype = Utils.rb_type_to_dtype(dtype)
+      end
+      Utils.wrap_expr(_rbexpr.str_json_extract(dtype))
+    end
+
     # Extract the first match of json string with provided JSONPath expression.
     #
     # Throw errors if encounter invalid json strings.
@@ -846,10 +879,10 @@ module Polars
     #   # │ 1   ┆ 123ABC │
     #   # │ 2   ┆ abc456 │
     #   # └─────┴────────┘
-    def replace(pattern, value, literal: false)
+    def replace(pattern, value, literal: false, n: 1)
       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))
+      Utils.wrap_expr(_rbexpr.str_replace_n(pattern._rbexpr, value._rbexpr, literal, n))
     end
 
     # Replace all matching regex/literal substrings with a new string value.
@@ -912,5 +945,78 @@ module Polars
     def slice(offset, length = nil)
       Utils.wrap_expr(_rbexpr.str_slice(offset, length))
     end
+
+    # Returns a column with a separate row for every string character.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"a": ["foo", "bar"]})
+    #   df.select(Polars.col("a").str.explode)
+    #   # =>
+    #   # shape: (6, 1)
+    #   # ┌─────┐
+    #   # │ a   │
+    #   # │ --- │
+    #   # │ str │
+    #   # ╞═════╡
+    #   # │ f   │
+    #   # │ o   │
+    #   # │ o   │
+    #   # │ b   │
+    #   # │ a   │
+    #   # │ r   │
+    #   # └─────┘
+    def explode
+      Utils.wrap_expr(_rbexpr.explode)
+    end
+
+    # Parse integers with base radix from strings.
+    #
+    # By default base 2. ParseError/Overflows become Nulls.
+    #
+    # @param radix [Integer]
+    #   Positive integer which is the base of the string we are parsing.
+    #   Default: 2.
+    # @param strict [Boolean]
+    #   Bool, Default=true will raise any ParseError or overflow as ComputeError.
+    #   False silently convert to Null.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"bin" => ["110", "101", "010", "invalid"]})
+    #   df.select(Polars.col("bin").str.parse_int(2, strict: false))
+    #   # =>
+    #   # shape: (4, 1)
+    #   # ┌──────┐
+    #   # │ bin  │
+    #   # │ ---  │
+    #   # │ i32  │
+    #   # ╞══════╡
+    #   # │ 6    │
+    #   # │ 5    │
+    #   # │ 2    │
+    #   # │ null │
+    #   # └──────┘
+    #
+    # @example
+    #   df = Polars::DataFrame.new({"hex" => ["fa1e", "ff00", "cafe", nil]})
+    #   df.select(Polars.col("hex").str.parse_int(16, strict: true))
+    #   # =>
+    #   # shape: (4, 1)
+    #   # ┌───────┐
+    #   # │ hex   │
+    #   # │ ---   │
+    #   # │ i32   │
+    #   # ╞═══════╡
+    #   # │ 64030 │
+    #   # │ 65280 │
+    #   # │ 51966 │
+    #   # │ null  │
+    #   # └───────┘
+    def parse_int(radix = 2, strict: true)
+      Utils.wrap_expr(_rbexpr.str_parse_int(radix, strict))
+    end
   end
 end

data/lib/polars/string_name_space.rb

@@ -38,12 +38,12 @@ module Polars
     #   )
     #   s.to_frame.with_column(
     #     Polars.col("date")
-    #       .str.strptime(:date, "%F", strict: false)
+    #       .str.strptime(Polars::Date, "%F", strict: false)
     #       .fill_null(
-    #         Polars.col("date").str.strptime(:date, "%F %T", strict: false)
+    #         Polars.col("date").str.strptime(Polars::Date, "%F %T", strict: false)
     #       )
-    #       .fill_null(Polars.col("date").str.strptime(:date, "%D", strict: false))
-    #       .fill_null(Polars.col("date").str.strptime(:date, "%c", 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))
     #   )
     #   # =>
     #   # shape: (4, 1)

data/lib/polars/struct_name_space.rb

@@ -60,5 +60,37 @@ module Polars
     def rename_fields(names)
       super
     end
+
+    # Get the struct definition as a name/dtype schema dict.
+    #
+    # @return [Object]
+    def schema
+      if _s.nil?
+        {}
+      else
+        _s.dtype.to_schema
+      end
+    end
+
+    # Convert this struct Series to a DataFrame with a separate column for each field.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   s = Polars::Series.new([{"a" => 1, "b" => 2}, {"a" => 3, "b" => 4}])
+    #   s.struct.unnest
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 1   ┆ 2   │
+    #   # │ 3   ┆ 4   │
+    #   # └─────┴─────┘
+    def unnest
+      Utils.wrap_df(_s.struct_unnest)
+    end
   end
 end

data/lib/polars/utils.rb

@@ -23,24 +23,42 @@ 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
+        (dt.to_datetime.to_time.to_f * 1e9).to_i
       elsif tu == "us"
-        (dt.to_datetime.utc.to_f * 1e6).to_i
+        (dt.to_datetime.to_time.to_f * 1e6).to_i
       elsif tu == "ms"
-        (dt.to_datetime.utc.to_f * 1e3).to_i
+        (dt.to_datetime.to_time.to_f * 1e3).to_i
       elsif tu.nil?
-        (dt.to_datetime.utc.to_f * 1e6).to_i
+        (dt.to_datetime.to_time.to_f * 1e6).to_i
       else
         raise ArgumentError, "tu 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_datetime(value, dtype, tu: "ns", tz: nil)
       if dtype == :date || dtype == Date
         # days to seconds
@@ -69,6 +87,18 @@ module Polars
       end
     end
 
+    def self._to_ruby_duration(value, tu = "ns")
+      if tu == "ns"
+        value / 1e9
+      elsif tu == "us"
+        value / 1e6
+      elsif tu == "ms"
+        value / 1e3
+      else
+        raise ArgumentError, "tu must be one of {{'ns', 'us', 'ms'}}, got #{tu}"
+      end
+    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]
@@ -93,12 +123,19 @@ module Polars
       Polars.lit(value)
     end
 
-    def self.format_path(path)
-      File.expand_path(path)
+    def self.normalise_filepath(path, check_not_directory: true)
+      path = File.expand_path(path)
+      if check_not_directory && File.exist?(path) && Dir.exist?(path)
+        raise ArgumentError, "Expected a file path; #{path} is a directory"
+      end
+      path
     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
 
@@ -109,7 +146,8 @@ module Polars
       TrueClass => :bool,
       FalseClass => :bool,
       ::Date => :date,
-      ::DateTime => :datetime
+      ::DateTime => :datetime,
+      ::Time => :datetime
     }
 
     # TODO fix
@@ -174,7 +212,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)
@@ -216,5 +254,9 @@ module Polars
         val.is_a?(Array) && _is_iterable_of(val, String)
       end
     end
+
+    def self.local_file?(file)
+      Dir.glob(file).any?
+    end
   end
 end

data/lib/polars/version.rb

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

data/lib/polars.rb

@@ -1,8 +1,8 @@
 # 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
@@ -12,6 +12,8 @@ require "stringio"
 # modules
 require_relative "polars/expr_dispatch"
 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/convert"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.0
 platform: aarch64-linux
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-22 00:00:00.000000000 Z
+date: 2023-05-16 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: andrew@ankane.org
@@ -29,6 +29,8 @@ files:
 - lib/polars/3.1/polars.so
 - lib/polars/3.2/polars.so
 - 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/convert.rb