polars-df 0.2.0-x86_64-linux → 0.2.1-x86_64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b29f236908ce6ba564c391104421f045d9bf9fd1fcdd84d8fbd30e9999f66e54
-  data.tar.gz: 9511bce38ac472c491596c5c929e781e608ab87edd81538312fd390c318aa61a
+  metadata.gz: f743e9640f5f15c0e569a023bf2866c3f273ae309c085168cc4d38647bf532d4
+  data.tar.gz: cfda09672859e7408a641a17b4d31532fd3d59552c0897639ecbbc8ec3e91ca2
 SHA512:
-  metadata.gz: a92fda54be50f6153635943e7613d8fb2554f4b07c5318661dbd02cde6ee81eb710d5df51a0a9f951c9d57f1248726b5870149827b7b611cc5620a2df90bc6d5
-  data.tar.gz: 8a0b8ae93b04e155f2d0c391ffae27f9e9749170e892dc4b10e7f4693d8dc2d7f0a5a5501ea301c4bcfadc306ba6839e907941fc58b2d8217c43f369f4a247ee
+  metadata.gz: 4bfa89bab471e2559e6952607064459562ca4d4a2f6f1101c54ce65dda5febd0d51a9acc65a701934b71270d67c207b6f4807b425e59c2ccd949f7eabc09b0f3
+  data.tar.gz: d8a0322152aa207c3e1a512c54b1bcc93f3ddb672e485f61d8fdcce49873551ae62dac7a131cc47c01d2dea8a766ac3913f54df7def66307132302ad2dd86392

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-linux
 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