polars-df 0.2.0-x86_64-darwin

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2020 Ritchie Vink
+Copyright (c) 2022-2023 Andrew Kane
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+# Polars Ruby
+
+:fire: Blazingly fast DataFrames for Ruby, powered by [Polars](https://github.com/pola-rs/polars)
+
+[![Build Status](https://github.com/ankane/polars-ruby/workflows/build/badge.svg?branch=master)](https://github.com/ankane/polars-ruby/actions)
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem "polars-df"
+```
+
+## Getting Started
+
+This library follows the [Polars Python API](https://pola-rs.github.io/polars/py-polars/html/reference/index.html).
+
+```ruby
+Polars.read_csv("iris.csv")
+  .lazy
+  .filter(Polars.col("sepal_length") > 5)
+  .groupby("species")
+  .agg(Polars.all.sum)
+  .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.
+
+## Examples
+
+### Creating DataFrames
+
+From a CSV
+
+```ruby
+Polars.read_csv("file.csv")
+```
+
+From Parquet
+
+```ruby
+Polars.read_parquet("file.parquet")
+```
+
+From Active Record
+
+```ruby
+Polars::DataFrame.new(User.all)
+```
+
+From a hash
+
+```ruby
+Polars::DataFrame.new({
+  a: [1, 2, 3],
+  b: ["one", "two", "three"]
+})
+```
+
+From an array of series
+
+```ruby
+Polars::DataFrame.new([
+  Polars::Series.new("a", [1, 2, 3]),
+  Polars::Series.new("b", ["one", "two", "three"])
+])
+```
+
+## History
+
+View the [changelog](CHANGELOG.md)
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/ankane/polars-ruby/issues)
+- Fix bugs and [submit pull requests](https://github.com/ankane/polars-ruby/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone https://github.com/ankane/polars-ruby.git
+cd polars-ruby
+bundle install
+bundle exec rake compile
+bundle exec rake test
+```

data/lib/polars/batched_csv_reader.rb

@@ -0,0 +1,96 @@
+module Polars
+  # @private
+  class BatchedCsvReader
+    attr_accessor :_reader, :new_columns
+
+    def initialize(
+      file,
+      has_header: true,
+      columns: nil,
+      sep: ",",
+      comment_char: nil,
+      quote_char: '"',
+      skip_rows: 0,
+      dtypes: nil,
+      null_values: nil,
+      ignore_errors: false,
+      parse_dates: false,
+      n_threads: nil,
+      infer_schema_length: 100,
+      batch_size: 50_000,
+      n_rows: nil,
+      encoding: "utf8",
+      low_memory: false,
+      rechunk: true,
+      skip_rows_after_header: 0,
+      row_count_name: nil,
+      row_count_offset: 0,
+      sample_size: 1024,
+      eol_char: "\n",
+      new_columns: nil
+    )
+      if file.is_a?(String) || (defined?(Pathname) && file.is_a?(Pathname))
+        path = Utils.format_path(file)
+      end
+
+      dtype_list = nil
+      dtype_slice = nil
+      if !dtypes.nil?
+        if dtypes.is_a?(Hash)
+          dtype_list = []
+          dtypes.each do|k, v|
+            dtype_list << [k, Utils.rb_type_to_dtype(v)]
+          end
+        elsif dtypes.is_a?(Array)
+          dtype_slice = dtypes
+        else
+          raise ArgumentError, "dtype arg should be list or dict"
+        end
+      end
+
+      processed_null_values = Utils._process_null_values(null_values)
+      projection, columns = Utils.handle_projection_columns(columns)
+
+      self._reader = RbBatchedCsv.new(
+        infer_schema_length,
+        batch_size,
+        has_header,
+        ignore_errors,
+        n_rows,
+        skip_rows,
+        projection,
+        sep,
+        rechunk,
+        columns,
+        encoding,
+        n_threads,
+        path,
+        dtype_list,
+        dtype_slice,
+        low_memory,
+        comment_char,
+        quote_char,
+        processed_null_values,
+        parse_dates,
+        skip_rows_after_header,
+        Utils._prepare_row_count_args(row_count_name, row_count_offset),
+        sample_size,
+        eol_char
+      )
+      self.new_columns = new_columns
+    end
+
+    def next_batches(n)
+      batches = _reader.next_batches(n)
+      if !batches.nil?
+        if new_columns
+          batches.map { |df| Utils._update_columns(Utils.wrap_df(df), new_columns) }
+        else
+          batches.map { |df| Utils.wrap_df(df) }
+        end
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/polars/cat_expr.rb

@@ -0,0 +1,52 @@
+module Polars
+  # Namespace for categorical related expressions.
+  class CatExpr
+    # @private
+    attr_accessor :_rbexpr
+
+    # @private
+    def initialize(expr)
+      self._rbexpr = expr._rbexpr
+    end
+
+    # Determine how this categorical series should be sorted.
+    #
+    # @param ordering ["physical", "lexical"]
+    #   Ordering type:
+    #
+    #   - 'physical' -> Use the physical representation of the categories to determine the order (default).
+    #   - 'lexical' -> Use the string values to determine the ordering.
+    #
+    # @return [Expr]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"cats" => ["z", "z", "k", "a", "b"], "vals" => [3, 1, 2, 2, 3]}
+    #   ).with_columns(
+    #     [
+    #       Polars.col("cats").cast(:cat).cat.set_ordering("lexical")
+    #     ]
+    #   )
+    #   df.sort(["cats", "vals"])
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌──────┬──────┐
+    #   # │ cats ┆ vals │
+    #   # │ ---  ┆ ---  │
+    #   # │ cat  ┆ i64  │
+    #   # ╞══════╪══════╡
+    #   # │ a    ┆ 2    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ b    ┆ 3    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ k    ┆ 2    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ z    ┆ 1    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ z    ┆ 3    │
+    #   # └──────┴──────┘
+    def set_ordering(ordering)
+      Utils.wrap_expr(_rbexpr.cat_set_ordering(ordering))
+    end
+  end
+end

data/lib/polars/cat_name_space.rb

@@ -0,0 +1,54 @@
+module Polars
+  # Series.cat namespace.
+  class CatNameSpace
+    include ExprDispatch
+
+    self._accessor = "cat"
+
+    # @private
+    def initialize(series)
+      self._s = series._s
+    end
+
+    # Determine how this categorical series should be sorted.
+    #
+    # @param ordering ["physical", "lexical"]
+    #   Ordering type:
+    #
+    #   - 'physical' -> Use the physical representation of the categories to
+    #       determine the order (default).
+    #   - 'lexical' -> Use the string values to determine the ordering.
+    #
+    # @return [Series]
+    #
+    # @example
+    #   df = Polars::DataFrame.new(
+    #     {"cats" => ["z", "z", "k", "a", "b"], "vals" => [3, 1, 2, 2, 3]}
+    #   ).with_columns(
+    #     [
+    #       Polars.col("cats").cast(:cat).cat.set_ordering("lexical")
+    #     ]
+    #   )
+    #   df.sort(["cats", "vals"])
+    #   # =>
+    #   # shape: (5, 2)
+    #   # ┌──────┬──────┐
+    #   # │ cats ┆ vals │
+    #   # │ ---  ┆ ---  │
+    #   # │ cat  ┆ i64  │
+    #   # ╞══════╪══════╡
+    #   # │ a    ┆ 2    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ b    ┆ 3    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ k    ┆ 2    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ z    ┆ 1    │
+    #   # ├╌╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ z    ┆ 3    │
+    #   # └──────┴──────┘
+    def set_ordering(ordering)
+      super
+    end
+  end
+end

data/lib/polars/convert.rb

@@ -0,0 +1,100 @@
+module Polars
+  module Convert
+    # Construct a DataFrame from a dictionary of sequences.
+    #
+    # This operation clones data, unless you pass in a `Hash<String, Series>`.
+    #
+    # @param data [Hash]
+    #   Two-dimensional data represented as a hash. Hash must contain
+    #   arrays.
+    # @param columns [Array]
+    #   Column labels to use for resulting DataFrame. If specified, overrides any
+    #   labels already present in the data. Must match data dimensions.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   data = {"a" => [1, 2], "b" => [3, 4]}
+    #   Polars.from_hash(data)
+    #   # =>
+    #   # shape: (2, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 1   ┆ 3   │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
+    #   # │ 2   ┆ 4   │
+    #   # └─────┴─────┘
+    def from_hash(data, columns: nil)
+      DataFrame._from_hash(data, columns: columns)
+    end
+
+    # Construct a DataFrame from a sequence of dictionaries. This operation clones data.
+    #
+    # @param hashes [Array]
+    #   Array with hashes mapping column name to value.
+    # @param infer_schema_length [Integer]
+    #   How many hashes/rows to scan to determine the data types
+    #   if set to `nil` all rows are scanned. This will be slow.
+    # @param schema [Object]
+    #   Schema that (partially) overwrites the inferred schema.
+    #
+    # @return [DataFrame]
+    #
+    # @example
+    #   data = [{"a" => 1, "b" => 4}, {"a" => 2, "b" => 5}, {"a" => 3, "b" => 6}]
+    #   Polars.from_hashes(data)
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬─────┐
+    #   # │ a   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i64 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 1   ┆ 4   │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
+    #   # │ 2   ┆ 5   │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
+    #   # │ 3   ┆ 6   │
+    #   # └─────┴─────┘
+    #
+    # @example Overwrite first column name and dtype
+    #   Polars.from_hashes(data, schema: {"c" => :i32})
+    #   # =>
+    #   # shape: (3, 2)
+    #   # ┌─────┬─────┐
+    #   # │ c   ┆ b   │
+    #   # │ --- ┆ --- │
+    #   # │ i32 ┆ i64 │
+    #   # ╞═════╪═════╡
+    #   # │ 1   ┆ 4   │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
+    #   # │ 2   ┆ 5   │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌┤
+    #   # │ 3   ┆ 6   │
+    #   # └─────┴─────┘
+    #
+    # @example Let polars infer the dtypes but inform about a 3rd column
+    #   Polars.from_hashes(data, schema: {"a" => :unknown, "b" => :unknown, "c" => :i32})
+    #   # shape: (3, 3)
+    #   # ┌─────┬─────┬──────┐
+    #   # │ a   ┆ b   ┆ c    │
+    #   # │ --- ┆ --- ┆ ---  │
+    #   # │ i64 ┆ i64 ┆ i32  │
+    #   # ╞═════╪═════╪══════╡
+    #   # │ 1   ┆ 4   ┆ null │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 2   ┆ 5   ┆ null │
+    #   # ├╌╌╌╌╌┼╌╌╌╌╌┼╌╌╌╌╌╌┤
+    #   # │ 3   ┆ 6   ┆ null │
+    #   # └─────┴─────┴──────┘
+    # def from_hashes(hashes, infer_schema_length: 50, schema: nil)
+    #   DataFrame._from_hashes(hashes, infer_schema_length: infer_schema_length, schema: schema)
+    # end
+
+    # def from_records
+    # end
+  end
+end