polars-df 0.2.0-x86_64-darwin

data/lib/polars/struct_expr.rb

@@ -0,0 +1,100 @@
+module Polars
+  # Namespace for struct related expressions.
+  class StructExpr
+    # @private
+    attr_accessor :_rbexpr
+
+    # @private
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    # Retrieve one of the fields of this `Struct` as a new Series.
+    #
+    # @return [Expr]
+    def [](item)
+      if item.is_a?(String)
+        field(item)
+      elsif item.is_a?(Integer)
+        Utils.wrap_expr(_rbexpr.struct_field_by_index(item))
+      else
+        raise ArgumentError, "expected type Integer or String, got #{item.class.name}"
+      end
+    end
+
+    # Retrieve one of the fields of this `Struct` as a new Series.
+    #
+    # @param name [String]
+    #   Name of the field
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = (
+    #     Polars::DataFrame.new(
+    #       {
+    #         "int" => [1, 2],
+    #         "str" => ["a", "b"],
+    #         "bool" => [true, nil],
+    #         "list" => [[1, 2], [3]]
+    #       }
+    #     )
+    #     .to_struct("my_struct")
+    #     .to_frame
+    #   )
+    #   df.select(Polars.col("my_struct").struct.field("str"))
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌─────┐
+    #   # │ str │
+    #   # │ --- │
+    #   # │ str │
+    #   # ╞═════╡
+    #   # │ a   │
+    #   # ├╌╌╌╌╌┤
+    #   # │ b   │
+    #   # └─────┘
+    def field(name)
+      Utils.wrap_expr(_rbexpr.struct_field_by_name(name))
+    end
+
+    # Rename the fields of the struct.
+    #
+    # @param names [Array]
+    #   New names in the order of the struct's fields
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = (
+    #     Polars::DataFrame.new(
+    #       {
+    #         "int" => [1, 2],
+    #         "str" => ["a", "b"],
+    #         "bool" => [true, nil],
+    #         "list" => [[1, 2], [3]]
+    #       }
+    #     )
+    #     .to_struct("my_struct")
+    #     .to_frame
+    #   )
+    #   df = df.with_column(
+    #     Polars.col("my_struct").struct.rename_fields(["INT", "STR", "BOOL", "LIST"])
+    #   )
+    #   df.select(Polars.col("my_struct").struct.field("INT"))
+    #   # =>
+    #   # shape: (2, 1)
+    #   # ┌─────┐
+    #   # │ INT │
+    #   # │ --- │
+    #   # │ i64 │
+    #   # ╞═════╡
+    #   # │ 1   │
+    #   # ├╌╌╌╌╌┤
+    #   # │ 2   │
+    #   # └─────┘
+    def rename_fields(names)
+      Utils.wrap_expr(_rbexpr.struct_rename_fields(names))
+    end
+  end
+end

data/lib/polars/struct_name_space.rb

@@ -0,0 +1,64 @@
+module Polars
+  # Series.struct namespace.
+  class StructNameSpace
+    include ExprDispatch
+
+    self._accessor = "struct"
+
+    # @private
+    def initialize(series)
+      self._s = series._s
+    end
+
+    # Retrieve one of the fields of this `Struct` as a new Series.
+    #
+    # @return [Series]
+    def [](item)
+      if item.is_a?(Integer)
+        field(fields[item])
+      elsif item.is_a?(String)
+        field(item)
+      else
+        raise ArgumentError, "expected type Integer or String, got #{item.class.name}"
+      end
+    end
+
+    # Convert this Struct Series to a DataFrame.
+    #
+    # @return [DataFrame]
+    def to_frame
+      Utils.wrap_df(_s.struct_to_frame)
+    end
+
+    # Get the names of the fields.
+    #
+    # @return [Array]
+    def fields
+      if _s.nil?
+        []
+      else
+        _s.struct_fields
+      end
+    end
+
+    # Retrieve one of the fields of this `Struct` as a new Series.
+    #
+    # @param name [String]
+    #   Name of the field
+    #
+    # @return [Series]
+    def field(name)
+      super
+    end
+
+    # Rename the fields of the struct.
+    #
+    # @param names [Array]
+    #   New names in the order of the struct's fields
+    #
+    # @return [Series]
+    def rename_fields(names)
+      super
+    end
+  end
+end

data/lib/polars/utils.rb

@@ -0,0 +1,192 @@
+module Polars
+  # @private
+  module Utils
+    DTYPE_TEMPORAL_UNITS = ["ns", "us", "ms"]
+
+    def self.wrap_s(s)
+      Series._from_rbseries(s)
+    end
+
+    def self.wrap_df(df)
+      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
+
+    def self.col(name)
+      Polars.col(name)
+    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
+      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
+        else
+          raise Todo
+        end
+
+        dt
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def self.selection_to_rbexpr_list(exprs)
+      if exprs.is_a?(String) || exprs.is_a?(Expr) || exprs.is_a?(Series)
+        exprs = [exprs]
+      end
+
+      exprs.map { |e| expr_to_lit_or_expr(e, str_to_lit: false)._rbexpr }
+    end
+
+    def self.expr_to_lit_or_expr(expr, str_to_lit: true)
+      if expr.is_a?(String) && !str_to_lit
+        col(expr)
+      elsif expr.is_a?(Integer) || expr.is_a?(Float) || expr.is_a?(String) || expr.is_a?(Series) || expr.nil?
+        lit(expr)
+      elsif expr.is_a?(Expr)
+        expr
+      else
+        raise ArgumentError, "did not expect value #{expr} of type #{expr.class.name}, maybe disambiguate with Polars.lit or Polars.col"
+      end
+    end
+
+    def self.lit(value)
+      Polars.lit(value)
+    end
+
+    def self.format_path(path)
+      File.expand_path(path)
+    end
+
+    # TODO fix
+    def self.is_polars_dtype(data_type)
+      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
+    }
+
+    # TODO fix
+    def self.rb_type_to_dtype(data_type)
+      if is_polars_dtype(data_type)
+        data_type = data_type.to_s if data_type.is_a?(Symbol)
+        return data_type
+      end
+
+      begin
+        RB_TYPE_TO_DTYPE.fetch(data_type).to_s
+      rescue KeyError
+        raise ArgumentError, "Conversion of Ruby data type #{data_type} to Polars data type not implemented."
+      end
+    end
+
+    def self._process_null_values(null_values)
+      if null_values.is_a?(Hash)
+        null_values.to_a
+      else
+        null_values
+      end
+    end
+
+    def self._prepare_row_count_args(row_count_name = nil, row_count_offset = 0)
+      if !row_count_name.nil?
+        [row_count_name, row_count_offset]
+      else
+        nil
+      end
+    end
+
+    def self.handle_projection_columns(columns)
+      projection = nil
+      if columns
+        raise Todo
+        # if columns.is_a?(String) || columns.is_a?(Symbol)
+        #   columns = [columns]
+        # elsif is_int_sequence(columns)
+        #   projection = columns.to_a
+        #   columns = nil
+        # elsif !is_str_sequence(columns)
+        #   raise ArgumentError, "columns arg should contain a list of all integers or all strings values."
+        # end
+      end
+      [projection, columns]
+    end
+
+    def self.scale_bytes(sz, to:)
+      scaling_factor = {
+          "b" => 1,
+          "k" => 1024,
+          "m" => 1024 ** 2,
+          "g" => 1024 ** 3,
+          "t" => 1024 ** 4,
+      }[to[0]]
+      if scaling_factor > 1
+        sz / scaling_factor.to_f
+      else
+        sz
+      end
+    end
+
+    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

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

data/lib/polars/when.rb

@@ -0,0 +1,16 @@
+module Polars
+  # @private
+  class When
+    attr_accessor :_rbwhen
+
+    def initialize(rbwhen)
+      self._rbwhen = rbwhen
+    end
+
+    def then(expr)
+      expr = Utils.expr_to_lit_or_expr(expr)
+      rbwhenthen = _rbwhen._then(expr._rbexpr)
+      WhenThen.new(rbwhenthen)
+    end
+  end
+end

data/lib/polars/when_then.rb

@@ -0,0 +1,19 @@
+module Polars
+  # @private
+  class WhenThen
+    attr_accessor :_rbwhenthen
+
+    def initialize(rbwhenthen)
+      self._rbwhenthen = rbwhenthen
+    end
+
+    def when(predicate)
+      WhenThenThen.new(_rbwhenthen.when(predicate._rbexpr))
+    end
+
+    def otherwise(expr)
+      expr = Utils.expr_to_lit_or_expr(expr)
+      Utils.wrap_expr(_rbwhenthen.otherwise(expr._rbexpr))
+    end
+  end
+end

data/lib/polars-df.rb

@@ -0,0 +1 @@
+require "polars"

data/lib/polars.rb

@@ -0,0 +1,50 @@
+# ext
+begin
+  require_relative "polars/#{RUBY_VERSION.to_f}/polars"
+rescue LoadError
+  require_relative "polars/polars"
+end
+
+# stdlib
+require "date"
+
+# modules
+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
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: polars-df
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: x86_64-darwin
+authors:
+- Andrew Kane
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-01-15 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: andrew@ankane.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- CHANGELOG.md
+- Cargo.lock
+- Cargo.toml
+- LICENSE-THIRD-PARTY.txt
+- LICENSE.txt
+- README.md
+- lib/polars-df.rb
+- lib/polars.rb
+- lib/polars/3.0/polars.bundle
+- lib/polars/3.1/polars.bundle
+- lib/polars/3.2/polars.bundle
+- 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
+- lib/polars/functions.rb
+- lib/polars/group_by.rb
+- lib/polars/io.rb
+- lib/polars/lazy_frame.rb
+- lib/polars/lazy_functions.rb
+- lib/polars/lazy_group_by.rb
+- 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
+- lib/polars/string_name_space.rb
+- lib/polars/struct_expr.rb
+- lib/polars/struct_name_space.rb
+- lib/polars/utils.rb
+- lib/polars/version.rb
+- lib/polars/when.rb
+- lib/polars/when_then.rb
+homepage: https://github.com/ankane/polars-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 3.3.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.3
+signing_key: 
+specification_version: 4
+summary: Blazingly fast DataFrames for Ruby
+test_files: []