polars-df 0.1.0 → 0.1.2

data/lib/polars/string_expr.rb

@@ -6,12 +6,129 @@ module Polars
       self._rbexpr = expr._rbexpr
     end
 
+    # def strptime
+    # end
+
     def lengths
       Utils.wrap_expr(_rbexpr.str_lengths)
     end
 
+    def n_chars
+      Utils.wrap_expr(_rbexpr.str_n_chars)
+    end
+
+    def concat(delimiter = "-")
+      Utils.wrap_expr(_rbexpr.str_concat(delimiter))
+    end
+
+    def to_uppercase
+      Utils.wrap_expr(_rbexpr.str_to_uppercase)
+    end
+
+    def to_lowercase
+      Utils.wrap_expr(_rbexpr.str_to_lowercase)
+    end
+
+    def strip(matches = nil)
+      if !matches.nil? && matches.length > 1
+        raise ArgumentError, "matches should contain a single character"
+      end
+      Utils.wrap_expr(_rbexpr.str_strip(matches))
+    end
+
+    def lstrip(matches = nil)
+      if !matches.nil? && matches.length > 1
+        raise ArgumentError, "matches should contain a single character"
+      end
+      Utils.wrap_expr(_rbexpr.str_lstrip(matches))
+    end
+
+    def rstrip(matches = nil)
+      if !matches.nil? && matches.length > 1
+        raise ArgumentError, "matches should contain a single character"
+      end
+      Utils.wrap_expr(_rbexpr.str_rstrip(matches))
+    end
+
+    def zfill(alignment)
+      Utils.wrap_expr(_rbexpr.str_zfill(alignment))
+    end
+
+    def ljust(width, fillchar = " ")
+      Utils.wrap_expr(_rbexpr.str_ljust(width, fillchar))
+    end
+
+    def rjust(width, fillchar = " ")
+      Utils.wrap_expr(_rbexpr.str_rjust(width, fillchar))
+    end
+
     def contains(pattern, literal: false)
       Utils.wrap_expr(_rbexpr.str_contains(pattern, literal))
     end
+
+    def ends_with(sub)
+      Utils.wrap_expr(_rbexpr.str_ends_with(sub))
+    end
+
+    def starts_with(sub)
+      Utils.wrap_expr(_rbexpr.str_starts_with(sub))
+    end
+
+    # def json_path_match
+    # end
+
+    # def decode
+    # end
+
+    # def encode
+    # end
+
+    def extract(pattern, group_index: 1)
+      Utils.wrap_expr(_rbexpr.str_extract(pattern, group_index))
+    end
+
+    def extract_all(pattern)
+      Utils.wrap_expr(_rbexpr.str_extract_all(pattern))
+    end
+
+    def count_match(pattern)
+      Utils.wrap_expr(_rbexpr.count_match(pattern))
+    end
+
+    def split(by, inclusive: false)
+      if inclusive
+        Utils.wrap_expr(_rbexpr.str_split_inclusive(by))
+      else
+        Utils.wrap_expr(_rbexpr.str_split(by))
+      end
+    end
+
+    def split_exact(by, n, inclusive: false)
+      if inclusive
+        Utils.wrap_expr(_rbexpr.str_split_exact_inclusive(by, n))
+      else
+        Utils.wrap_expr(_rbexpr.str_split_exact(by, n))
+      end
+    end
+
+    def splitn(by, n)
+      Utils.wrap_expr(_rbexpr.str_splitn(by, n))
+    end
+
+    def replace(pattern, literal: false)
+      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))
+    end
+
+    def replace_all(pattern, literal: false)
+      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_all(pattern._rbexpr, value._rbexpr, literal))
+    end
+
+    def slice(offset, length = nil)
+      Utils.wrap_expr(_rbexpr.str_slice(offset, length))
+    end
   end
 end

data/lib/polars/struct_expr.rb

@@ -0,0 +1,27 @@
+module Polars
+  class StructExpr
+    attr_accessor :_rbexpr
+
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    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
+
+    def field(name)
+      Utils.wrap_expr(_rbexpr.struct_field_by_name(name))
+    end
+
+    def rename_fields(names)
+      Utils.wrap_expr(_rbexpr.struct_rename_fields(names))
+    end
+  end
+end

data/lib/polars/utils.rb

@@ -1,5 +1,8 @@
 module Polars
+  # @private
   module Utils
+    DTYPE_TEMPORAL_UNITS = ["ns", "us", "ms"]
+
     def self.wrap_s(s)
       Series._from_rbseries(s)
     end
@@ -43,5 +46,62 @@ module Polars
     def self.format_path(path)
       File.expand_path(path)
     end
+
+    # TODO fix
+    def self.is_polars_dtype(data_type)
+      true
+    end
+
+    # TODO fix
+    def self.rb_type_to_dtype(dtype)
+      dtype.to_s
+    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
   end
 end

data/lib/polars/version.rb

@@ -1,3 +1,3 @@
 module Polars
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

data/lib/polars.rb

@@ -2,23 +2,37 @@
 require "polars/polars"
 
 # modules
+require "polars/batched_csv_reader"
+require "polars/cat_expr"
 require "polars/data_frame"
+require "polars/date_time_expr"
 require "polars/expr"
 require "polars/functions"
+require "polars/io"
 require "polars/lazy_frame"
 require "polars/lazy_functions"
 require "polars/lazy_group_by"
-require "polars/io"
+require "polars/list_expr"
+require "polars/meta_expr"
 require "polars/series"
 require "polars/string_expr"
+require "polars/struct_expr"
 require "polars/utils"
 require "polars/version"
 require "polars/when"
 require "polars/when_then"
 
 module Polars
+  # @private
   class Error < StandardError; end
 
+  # @private
+  class Todo < Error
+    def message
+      "not implemented yet"
+    end
+  end
+
   extend Functions
   extend IO
   extend LazyFunctions

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-22 00:00:00.000000000 Z
+date: 2022-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -32,31 +32,42 @@ extensions:
 extra_rdoc_files: []
 files:
 - CHANGELOG.md
+- Cargo.lock
+- Cargo.toml
 - LICENSE.txt
 - README.md
 - ext/polars/Cargo.toml
 - ext/polars/extconf.rb
+- ext/polars/src/batched_csv.rs
 - ext/polars/src/conversion.rs
 - ext/polars/src/dataframe.rs
 - ext/polars/src/error.rs
 - ext/polars/src/file.rs
+- ext/polars/src/lazy/apply.rs
 - ext/polars/src/lazy/dataframe.rs
 - ext/polars/src/lazy/dsl.rs
+- ext/polars/src/lazy/meta.rs
 - ext/polars/src/lazy/mod.rs
 - ext/polars/src/lazy/utils.rs
 - ext/polars/src/lib.rs
 - ext/polars/src/series.rs
 - lib/polars-df.rb
 - lib/polars.rb
+- lib/polars/batched_csv_reader.rb
+- lib/polars/cat_expr.rb
 - lib/polars/data_frame.rb
+- lib/polars/date_time_expr.rb
 - lib/polars/expr.rb
 - lib/polars/functions.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/meta_expr.rb
 - lib/polars/series.rb
 - lib/polars/string_expr.rb
+- lib/polars/struct_expr.rb
 - lib/polars/utils.rb
 - lib/polars/version.rb
 - lib/polars/when.rb