polars-df 0.2.0-x86_64-darwin → 0.2.1-x86_64-darwin

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bae71f83979c08ff1af0c94f7e6fcd9c00a1377d8d34d3abc0b6b307508c93a2
-  data.tar.gz: b8391580345d59b73f9af210a182fd149ca69ea81cacf4f049b10ec3386e394d
+  metadata.gz: ee93a61f42e0acf492693c5516582437239b66b29a411d49a61e43ee2c640bf0
+  data.tar.gz: e79a6954afbf9e66bb1b73410abdc750fd5ee7bdca289ae7aa31607608c120f1
 SHA512:
-  metadata.gz: d3b159a63142ede08662aad0e8b9ad1d2c6ee254e3dbb0b5f3ea40be52761c3f1685212d8b5fb66c58ba583ca048a92bd602dcf8a9f1431f4159a8e014b24256
-  data.tar.gz: 144c33d409843c2da7d48bd489956441438e35a2a12cdf74d0cad7bab6c98793e9313141aae5f2abc2411f1cd87027ecb4d0d1f33665ef0d7bcf456b4df852b9
+  metadata.gz: 6679b43359387e0f6688c3d96337ffb7408e58296f16524708748feb4c57ff396b439d3a24a79f0c913dd252f920fb3f42be1bc5a0be364ee6aa66c094107ccf
+  data.tar.gz: 80f69ce23c42d4dd3345bd8364f689af571284ba95770d32be4760a99a9b0eb7cb7b21892c326321c0db33b6bffc57e4a19c989b8044878ef7e42aeffe3d7f68

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.2.1 (2023-01-18)
+
+- Added `read_sql` method
+- Added `to_csv` method
+- Added support for symbol keys
+
 ## 0.2.0 (2023-01-14)
 
 - Updated Polars to 0.26.1

data/Cargo.lock

@@ -1367,7 +1367,7 @@ dependencies = [
 
 [[package]]
 name = "polars"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "ahash",
  "jemallocator",

data/README.md

@@ -25,7 +25,13 @@ Polars.read_csv("iris.csv")
   .collect
 ```
 
-You can follow [Polars tutorials](https://pola-rs.github.io/polars-book/user-guide/introduction.html) and convert the code to Ruby in many cases. Feel free to open an issue if you run into problems. Some methods are missing at the moment.
+You can follow [Polars tutorials](https://pola-rs.github.io/polars-book/user-guide/introduction.html) and convert the code to Ruby in many cases. Feel free to open an issue if you run into problems.
+
+## Reference
+
+- [Series](https://www.rubydoc.info/gems/polars-df/Polars/Series)
+- [DataFrame](https://www.rubydoc.info/gems/polars-df/Polars/DataFrame)
+- [LazyFrame](https://www.rubydoc.info/gems/polars-df/Polars/LazyFrame)
 
 ## Examples
 
@@ -46,7 +52,7 @@ Polars.read_parquet("file.parquet")
 From Active Record
 
 ```ruby
-Polars::DataFrame.new(User.all)
+Polars.read_sql(User.all)
 ```
 
 From a hash
@@ -67,6 +73,261 @@ Polars::DataFrame.new([
 ])
 ```
 
+## Attributes
+
+Get number of rows
+
+```ruby
+df.height
+```
+
+Get column names
+
+```ruby
+df.columns
+```
+
+Check if a column exists
+
+```ruby
+df.include?(name)
+```
+
+## Selecting Data
+
+Select a column
+
+```ruby
+df["a"]
+```
+
+Select multiple columns
+
+```ruby
+df[["a", "b"]]
+```
+
+Select first rows
+
+```ruby
+df.head
+```
+
+Select last rows
+
+```ruby
+df.tail
+```
+
+## Filtering
+
+Filter on a condition
+
+```ruby
+df[Polars.col("a") == 2]
+df[Polars.col("a") != 2]
+df[Polars.col("a") > 2]
+df[Polars.col("a") >= 2]
+df[Polars.col("a") < 2]
+df[Polars.col("a") <= 2]
+```
+
+And, or, and exclusive or
+
+```ruby
+df[(Polars.col("a") > 100) & (Polars.col("b") == "one")] # and
+df[(Polars.col("a") > 100) | (Polars.col("b") == "one")] # or
+df[(Polars.col("a") > 100) ^ (Polars.col("b") == "one")] # xor
+```
+
+## Operations
+
+Basic operations
+
+```ruby
+df["a"] + 5
+df["a"] - 5
+df["a"] * 5
+df["a"] / 5
+df["a"] % 5
+df["a"] ** 2
+df["a"].sqrt
+df["a"].abs
+```
+
+Rounding
+
+```ruby
+df["a"].round(2)
+df["a"].ceil
+df["a"].floor
+```
+
+Logarithm
+
+```ruby
+df["a"].log # natural log
+df["a"].log(10)
+```
+
+Exponentiation
+
+```ruby
+df["a"].exp
+```
+
+Trigonometric functions
+
+```ruby
+df["a"].sin
+df["a"].cos
+df["a"].tan
+df["a"].asin
+df["a"].acos
+df["a"].atan
+```
+
+Hyperbolic functions
+
+```ruby
+df["a"].sinh
+df["a"].cosh
+df["a"].tanh
+df["a"].asinh
+df["a"].acosh
+df["a"].atanh
+```
+
+Summary statistics
+
+```ruby
+df["a"].sum
+df["a"].mean
+df["a"].median
+df["a"].quantile(0.90)
+df["a"].min
+df["a"].max
+df["a"].std
+df["a"].var
+```
+
+## Grouping
+
+Group
+
+```ruby
+df.groupby("a").count
+```
+
+Works with all summary statistics
+
+```ruby
+df.groupby("a").max
+```
+
+Multiple groups
+
+```ruby
+df.groupby(["a", "b"]).count
+```
+
+## Combining Data Frames
+
+Add rows
+
+```ruby
+df.vstack(other_df)
+```
+
+Add columns
+
+```ruby
+df.hstack(other_df)
+```
+
+Inner join
+
+```ruby
+df.join(other_df, on: "a")
+```
+
+Left join
+
+```ruby
+df.join(other_df, on: "a", how: "left")
+```
+
+## Encoding
+
+One-hot encoding
+
+```ruby
+df.to_dummies
+```
+
+## Conversion
+
+Array of rows
+
+```ruby
+df.rows
+```
+
+Hash of series
+
+```ruby
+df.to_h
+```
+
+CSV
+
+```ruby
+df.to_csv
+# or
+df.write_csv("data.csv")
+```
+
+Parquet
+
+```ruby
+df.write_parquet("data.parquet")
+```
+
+## Types
+
+You can specify column types when creating a data frame
+
+```ruby
+Polars::DataFrame.new(data, columns: {"a" => Polars::Int32, "b" => Polars::Float32})
+```
+
+Supported types are:
+
+- boolean - `Boolean`
+- float - `Float64`, `Float32`
+- integer - `Int64`, `Int32`, `Int16`, `Int8`
+- unsigned integer - `UInt64`, `UInt32`, `UInt16`, `UInt8`
+- string - `Utf8`, `Categorical`
+- temporal - `Date`, `Datetime`, `Time`, `Duration`
+
+Get column types
+
+```ruby
+df.schema
+```
+
+For a specific column
+
+```ruby
+df["a"].dtype
+```
+
+Cast a column
+
+```ruby
+df["a"].cast(Polars::Int32)
+```
+
 ## History
 
 View the [changelog](CHANGELOG.md)

data/lib/polars/data_frame.rb

@@ -17,6 +17,7 @@ module Polars
     #   the orientation is inferred by matching the columns and data dimensions. If
     #   this does not yield conclusive results, column orientation is used.
     def initialize(data = nil, columns: nil, orient: nil)
+      # TODO deprecate in favor of read_sql
       if defined?(ActiveRecord) && (data.is_a?(ActiveRecord::Relation) || data.is_a?(ActiveRecord::Result))
         result = data.is_a?(ActiveRecord::Result) ? data : data.connection.select_all(data.to_sql)
         data = {}
@@ -275,6 +276,7 @@ module Polars
     def height
       _df.height
     end
+    alias_method :count, :height
 
     # Get the width of the DataFrame.
     #
@@ -521,13 +523,13 @@ module Polars
             return df.slice(row_selection, 1)
           end
           # df[2, "a"]
-          if col_selection.is_a?(String)
+          if col_selection.is_a?(String) || col_selection.is_a?(Symbol)
             return self[col_selection][row_selection]
           end
         end
 
         # column selection can be "a" and ["a", "b"]
-        if col_selection.is_a?(String)
+        if col_selection.is_a?(String) || col_selection.is_a?(Symbol)
           col_selection = [col_selection]
         end
 
@@ -553,8 +555,8 @@ module Polars
 
         # select single column
         # df["foo"]
-        if item.is_a?(String)
-          return Utils.wrap_s(_df.column(item))
+        if item.is_a?(String) || item.is_a?(Symbol)
+          return Utils.wrap_s(_df.column(item.to_s))
         end
 
         # df[idx]
@@ -574,6 +576,11 @@ module Polars
         end
       end
 
+      # Ruby-specific
+      if item.is_a?(Expr)
+        return filter(item)
+      end
+
       raise ArgumentError, "Cannot get item of type: #{item.class.name}"
     end
 
@@ -797,6 +804,13 @@ module Polars
       nil
     end
 
+    # Write to comma-separated values (CSV) string.
+    #
+    # @return [String]
+    def to_csv(**options)
+      write_csv(**options)
+    end
+
     # Write to Apache Avro file.
     #
     # @param file [String]

data/lib/polars/data_types.rb

@@ -93,7 +93,7 @@ module Polars
   class Time < DataType
   end
 
-  # Type for wrapping arbitrary Python objects.
+  # Type for wrapping arbitrary Ruby objects.
   class Object < DataType
   end
 

data/lib/polars/io.rb

@@ -590,8 +590,31 @@ module Polars
       DataFrame._read_ndjson(file)
     end
 
-    # def read_sql
-    # end
+    # Read a SQL query into a DataFrame.
+    #
+    # @param sql [Object]
+    #   ActiveRecord::Relation or ActiveRecord::Result.
+    #
+    # @return [DataFrame]
+    def read_sql(sql)
+      if !defined?(ActiveRecord)
+        raise Error, "Active Record not available"
+      end
+
+      result =
+        if sql.is_a?(ActiveRecord::Result)
+          sql
+        elsif sql.is_a?(ActiveRecord::Relation)
+          sql.connection.select_all(sql.to_sql)
+        else
+          raise ArgumentError, "Expected ActiveRecord::Relation or ActiveRecord::Result"
+        end
+      data = {}
+      result.columns.each_with_index do |k, i|
+        data[k] = result.rows.map { |r| r[i] }
+      end
+      DataFrame.new(data)
+    end
 
     # def read_excel
     # end

data/lib/polars/series.rb

@@ -1647,6 +1647,7 @@ module Polars
     def len
       _s.len
     end
+    alias_method :count, :len
     alias_method :length, :len
 
     # Cast between data types.
@@ -2183,6 +2184,7 @@ module Polars
     def arcsin
       super
     end
+    alias_method :asin, :arcsin
 
     # Compute the element-wise value for the inverse cosine.
     #
@@ -2202,6 +2204,7 @@ module Polars
     def arccos
       super
     end
+    alias_method :acos, :arccos
 
     # Compute the element-wise value for the inverse tangent.
     #
@@ -2221,6 +2224,7 @@ module Polars
     def arctan
       super
     end
+    alias_method :atan, :arctan
 
     # Compute the element-wise value for the inverse hyperbolic sine.
     #
@@ -2240,6 +2244,7 @@ module Polars
     def arcsinh
       super
     end
+    alias_method :asinh, :arcsinh
 
     # Compute the element-wise value for the inverse hyperbolic cosine.
     #
@@ -2260,6 +2265,7 @@ module Polars
     def arccosh
       super
     end
+    alias_method :acosh, :arccosh
 
     # Compute the element-wise value for the inverse hyperbolic tangent.
     #
@@ -2283,6 +2289,7 @@ module Polars
     def arctanh
       super
     end
+    alias_method :atanh, :arctanh
 
     # Compute the element-wise value for the hyperbolic sine.
     #

data/lib/polars/utils.rb

@@ -70,7 +70,7 @@ module Polars
     end
 
     def self.selection_to_rbexpr_list(exprs)
-      if exprs.is_a?(String) || exprs.is_a?(Expr) || exprs.is_a?(Series)
+      if exprs.is_a?(String) || exprs.is_a?(Symbol) || exprs.is_a?(Expr) || exprs.is_a?(Series)
         exprs = [exprs]
       end
 
@@ -78,9 +78,9 @@ module Polars
     end
 
     def self.expr_to_lit_or_expr(expr, str_to_lit: true)
-      if expr.is_a?(String) && !str_to_lit
+      if (expr.is_a?(String) || expr.is_a?(Symbol)) && !str_to_lit
         col(expr)
-      elsif expr.is_a?(Integer) || expr.is_a?(Float) || expr.is_a?(String) || expr.is_a?(Series) || expr.nil?
+      elsif expr.is_a?(Integer) || expr.is_a?(Float) || expr.is_a?(String) || expr.is_a?(Symbol) || expr.is_a?(Series) || expr.nil?
         lit(expr)
       elsif expr.is_a?(Expr)
         expr

data/lib/polars/version.rb

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

data/lib/polars.rb

@@ -7,6 +7,7 @@ end
 
 # stdlib
 require "date"
+require "stringio"
 
 # modules
 require_relative "polars/expr_dispatch"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: polars-df
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: x86_64-darwin
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-15 00:00:00.000000000 Z
+date: 2023-01-18 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: andrew@ankane.org