rover-df 0.2.7 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c75bed3989211e806e54c296290e5f7b3af236a15742daac876e211e3ca5a76f
-  data.tar.gz: 5865ff8f1d0036423f18cfee867da63214ee50f79d373b0f0f244853d8efbefa
+  metadata.gz: e7acc7d0f290ab905594bac7ab1641572e717346f1d0546b3d8b783bcd1e5aca
+  data.tar.gz: 2569b64c237ef836884be2077e8bb8107512d6946631fdb217fb276439412419
 SHA512:
-  metadata.gz: 11718bc8ade75a605e92cabe05c29e55c6d4dfe427cd5ada0a8a216db678b32a88f4a43843d1e7dcda7b7a64adb63b76969f1d958e91ca57c4f71989632e14aa
-  data.tar.gz: 16940236090625bef69cb14d6d9f9f50720314edea1b5892f60443799e5389700ddfb0d79a29ee1e193168097add9d7195799e7f049d85f9c9dc9c443843a678
+  metadata.gz: dc46c174fced1c55a96fff28a5c69dfe5a508de527432dac3801cf65375093e290860112191444ceaa23023456452f9331406cdf360a7e689f0db27c289c157c
+  data.tar.gz: 770174c6fb1cc8a52cd47ef77eae871cb5a346d752e9c1c13b8cb44fdc5d791b60fea3d5480bcaa4453b3bca1e83e32af57a57ff0c2a319308d7206d620fa75b

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## 0.3.1 (2022-05-18)
+
+- Added `to!` to vectors
+- Fixed error with `nil` and `:float64` type
+- Fixed `:header_converters` option with `read_csv` and `parse_csv`
+
+## 0.3.0 (2022-04-03)
+
+- Added `deep_dup` method to data frames
+- Changed `:int` to `:int64`, `:uint` to `:uint64`, and `:float` to `:float64` for type methods
+- Changed missing column to raise `KeyError` instead of `ArgumentError` for aggregate methods
+- Changed passing too many headers to `read_csv` and `parse_csv` to raise `ArgumentError`
+- Changed empty string in CSV headers to match behavior of `nil`
+- Fixed `clone` and `dup` method for vectors
+- Dropped support for Ruby < 2.7
+
+## 0.2.8 (2022-03-15)
+
+- Added `group` and `stacked` options to `plot`
+- Improved performance of `read_csv` and `parse_csv`
+
 ## 0.2.7 (2022-01-16)
 
 - Added support for booleans to Parquet methods

data/README.md

@@ -13,7 +13,7 @@ Simple, powerful data frames for Ruby
 Add this line to your application’s Gemfile:
 
 ```ruby
-gem 'rover-df'
+gem "rover-df"
 ```
 
 ## Intro
@@ -236,7 +236,7 @@ df.group(:a).max(:b)
 Multiple groups
 
 ```ruby
-df.group([:a, :b]).count
+df.group(:a, :b).count
 ```
 
 ## Visualization
@@ -244,7 +244,7 @@ df.group([:a, :b]).count
 Add [Vega](https://github.com/ankane/vega) to your application’s Gemfile:
 
 ```ruby
-gem 'vega'
+gem "vega"
 ```
 
 And use:
@@ -259,6 +259,18 @@ Specify the chart type (`line`, `pie`, `column`, `bar`, `area`, or `scatter`)
 df.plot(:a, :b, type: "pie")
 ```
 
+Group data
+
+```ruby
+df.plot(:a, :b, group: :c)
+```
+
+Stacked columns or bars
+
+```ruby
+df.plot(:a, :b, group: :c, stacked: true)
+```
+
 ## Updating Data
 
 Add a new column
@@ -412,22 +424,22 @@ df.to_parquet
 You can specify column types when creating a data frame
 
 ```ruby
-Rover::DataFrame.new(data, types: {"a" => :int, "b" => :float})
+Rover::DataFrame.new(data, types: {"a" => :int64, "b" => :float64})
 ```
 
 Or
 
 ```ruby
-Rover.read_csv("data.csv", types: {"a" => :int, "b" => :float})
+Rover.read_csv("data.csv", types: {"a" => :int64, "b" => :float64})
 ```
 
 Supported types are:
 
-- boolean - `bool`
-- float - `float`, `float32`
-- integer - `int`, `int32`, `int16`, `int8`
-- unsigned integer - `uint`, `uint32`, `uint16`, `uint8`
-- object - `object`
+- boolean - `:bool`
+- float - `:float64`, `:float32`
+- integer - `:int64`, `:int32`, `:int16`, `:int8`
+- unsigned integer - `:uint64`, `:uint32`, `:uint16`, `:uint8`
+- object - `:object`
 
 Get column types
 
@@ -444,7 +456,7 @@ df[:a].type
 Change the type of a column
 
 ```ruby
-df[:a] = df[:a].to(:int)
+df[:a] = df[:a].to(:int32)
 ```
 
 ## History

data/lib/rover/data_frame.rb

@@ -72,7 +72,7 @@ module Rover
         # multiple columns
         df = DataFrame.new
         where.each do |k|
-          check_column(k, true)
+          check_column(k)
           df[k] = @vectors[k]
         end
         df
@@ -102,7 +102,7 @@ module Rover
     def []=(k, v)
       check_key(k)
       v = to_vector(v, size: size)
-      raise ArgumentError, "Size mismatch: expected #{size}, got #{v.size}" if @vectors.any? && v.size != size
+      raise ArgumentError, "Size mismatch (given #{v.size}, expected #{size})" if @vectors.any? && v.size != size
       @vectors[k] = v
     end
 
@@ -242,11 +242,11 @@ module Rover
       types.each do |name, type|
         schema[name] =
           case type
-          when :int
+          when :int64
             :int64
-          when :uint
+          when :uint64
             :uint64
-          when :float
+          when :float64
             :double
           when :float32
             :float
@@ -346,10 +346,10 @@ module Rover
       end
     end
 
-    def dup
+    def deep_dup
       df = DataFrame.new
       @vectors.each do |k, v|
-        df[k] = v
+        df[k] = v.dup
       end
       df
     end
@@ -401,7 +401,7 @@ module Rover
       keys.all? { |k| self[k].to_numo == other[k].to_numo }
     end
 
-    def plot(x = nil, y = nil, type: nil)
+    def plot(x = nil, y = nil, type: nil, group: nil, stacked: nil)
       require "vega"
 
       raise ArgumentError, "Must specify columns" if keys.size != 2 && (!x || !y)
@@ -416,7 +416,7 @@ module Rover
           raise "Cannot determine type. Use the type option."
         end
       end
-      data = self[[x, y]]
+      data = self[group.nil? ? [x, y] : [x, y, group]]
 
       case type
       when "line", "area"
@@ -430,16 +430,20 @@ module Rover
           end
 
         scale = x_type == "temporal" ? {type: "utc"} : {}
+        encoding = {
+          x: {field: x, type: x_type, scale: scale},
+          y: {field: y, type: "quantitative"}
+        }
+        encoding[:color] = {field: group} if group
 
         Vega.lite
           .data(data)
           .mark(type: type, tooltip: true, interpolate: "cardinal", point: {size: 60})
-          .encoding(
-            x: {field: x, type: x_type, scale: scale},
-            y: {field: y, type: "quantitative"}
-          )
+          .encoding(encoding)
           .config(axis: {labelFontSize: 12})
       when "pie"
+        raise ArgumentError, "Cannot use group option with pie chart" unless group.nil?
+
         Vega.lite
           .data(data)
           .mark(type: "arc", tooltip: true)
@@ -449,34 +453,48 @@ module Rover
           )
           .view(stroke: nil)
       when "column"
+        encoding = {
+          x: {field: x, type: "nominal", sort: "none", axis: {labelAngle: 0}},
+          y: {field: y, type: "quantitative"}
+        }
+        if group
+          encoding[:color] = {field: group}
+          encoding[:xOffset] = {field: group} unless stacked
+        end
+
         Vega.lite
           .data(data)
           .mark(type: "bar", tooltip: true)
-          .encoding(
-            # TODO determine label angle
-            x: {field: x, type: "nominal", sort: "none", axis: {labelAngle: 0}},
-            y: {field: y, type: "quantitative"}
-          )
+          .encoding(encoding)
           .config(axis: {labelFontSize: 12})
       when "bar"
+        encoding = {
+          # TODO determine label angle
+          y: {field: x, type: "nominal", sort: "none", axis: {labelAngle: 0}},
+          x: {field: y, type: "quantitative"}
+        }
+        if group
+          encoding[:color] = {field: group}
+          encoding[:yOffset] = {field: group} unless stacked
+        end
+
         Vega.lite
           .data(data)
           .mark(type: "bar", tooltip: true)
-          .encoding(
-            # TODO determine label angle
-            y: {field: x, type: "nominal", sort: "none", axis: {labelAngle: 0}},
-            x: {field: y, type: "quantitative"}
-          )
+          .encoding(encoding)
           .config(axis: {labelFontSize: 12})
       when "scatter"
+        encoding = {
+          x: {field: x, type: "quantitative", scale: {zero: false}},
+          y: {field: y, type: "quantitative", scale: {zero: false}},
+          size: {value: 60}
+        }
+        encoding[:color] = {field: group} if group
+
         Vega.lite
           .data(data)
           .mark(type: "circle", tooltip: true)
-          .encoding(
-            x: {field: x, type: "quantitative", scale: {zero: false}},
-            y: {field: y, type: "quantitative", scale: {zero: false}},
-            size: {value: 60}
-          )
+          .encoding(encoding)
           .config(axis: {labelFontSize: 12})
       else
         raise ArgumentError, "Invalid type: #{type}"
@@ -485,8 +503,20 @@ module Rover
 
     private
 
+    # for clone
+    def initialize_clone(_)
+      @vectors = @vectors.clone
+      super
+    end
+
+    # for dup
+    def initialize_dup(_)
+      @vectors = @vectors.dup
+      super
+    end
+
     def check_key(key)
-      raise ArgumentError, "Key must be a string or symbol, got #{key.inspect}" unless key.is_a?(String) || key.is_a?(Symbol)
+      raise ArgumentError, "Key must be a String or Symbol, given #{key.class.name}" unless key.is_a?(String) || key.is_a?(Symbol)
     end
 
     # TODO make more efficient
@@ -547,19 +577,9 @@ module Rover
       raise ArgumentError, "Missing keys: #{missing_keys.join(", ")}" if missing_keys.any?
     end
 
-    # TODO in 0.3.0
-    # always use did_you_mean
-    def check_column(key, did_you_mean = false)
+    def check_column(key)
       unless include?(key)
-        if did_you_mean
-          if RUBY_VERSION.to_f >= 2.6
-            raise KeyError.new("Missing column: #{key}", receiver: self, key: key)
-          else
-            raise KeyError.new("Missing column: #{key}")
-          end
-        else
-          raise ArgumentError, "Missing column: #{key}"
-        end
+        raise KeyError.new("Missing column: #{key}", receiver: self, key: key)
       end
     end
 

data/lib/rover/group.rb

@@ -3,6 +3,7 @@ module Rover
     def initialize(df, columns)
       @df = df
       @columns = columns
+      check_columns
     end
 
     def group(*columns)
@@ -22,16 +23,20 @@ module Rover
       end
     end
 
+    def plot(*args, **options)
+      raise ArgumentError, "Multiple groups not supported" if @columns.size > 1
+      # same message as Ruby
+      raise ArgumentError, "unknown keyword: :group" if options.key?(:group)
+
+      @df.plot(*args, **options, group: @columns.first)
+    end
+
     private
 
     # TODO make more efficient
     def grouped_dfs
       # cache here so we can reuse for multiple calcuations if needed
       @grouped_dfs ||= begin
-        raise ArgumentError, "No columns given" if @columns.empty?
-        missing_keys = @columns - @df.keys
-        raise ArgumentError, "Missing keys: #{missing_keys.join(", ")}" if missing_keys.any?
-
         groups = Hash.new { |hash, key| hash[key] = [] }
         i = 0
         @df.each_row do |row|
@@ -46,5 +51,12 @@ module Rover
         result
       end
     end
+
+    def check_columns
+      raise ArgumentError, "No columns given" if @columns.empty?
+
+      missing_keys = @columns - @df.keys
+      raise ArgumentError, "Missing keys: #{missing_keys.join(", ")}" if missing_keys.any?
+    end
   end
 end

data/lib/rover/vector.rb

@@ -1,23 +1,23 @@
 module Rover
   class Vector
     # if a user never specifies types,
-    # the defaults are bool, float, int, and object
-    # keep these simple
-    #
-    # we could create aliases for float64, int64, uint64
-    # if so, type should still return the simple type
+    # the defaults are bool, float64, int64, and object
     TYPE_CAST_MAPPING = {
       bool: Numo::Bit,
       float32: Numo::SFloat,
-      float: Numo::DFloat,
+      float64: Numo::DFloat,
       int8: Numo::Int8,
       int16: Numo::Int16,
       int32: Numo::Int32,
-      int: Numo::Int64,
+      int64: Numo::Int64,
       object: Numo::RObject,
       uint8: Numo::UInt8,
       uint16: Numo::UInt16,
       uint32: Numo::UInt32,
+      uint64: Numo::UInt64,
+      # legacy - must come last
+      float: Numo::DFloat,
+      int: Numo::Int64,
       uint: Numo::UInt64
     }
 
@@ -31,7 +31,12 @@ module Rover
     end
 
     def to(type)
-      Vector.new(self, type: type)
+      dup.to!(type)
+    end
+
+    def to!(type)
+      @data = cast_data(@data, type: type)
+      self
     end
 
     def to_numo
@@ -333,6 +338,18 @@ module Rover
 
     private
 
+    # for clone
+    def initialize_clone(_)
+      @data = @data.clone
+      super
+    end
+
+    # for dup
+    def initialize_dup(_)
+      @data = @data.dup
+      super
+    end
+
     def cast_data(data, type: nil)
       numo_type = numo_type(type) if type
 
@@ -359,7 +376,7 @@ module Rover
         data = data.to_a
 
         if type
-          data = data.map { |v| v || Float::NAN } if [:float, :float32].include?(type)
+          data = data.map { |v| v || Float::NAN } if [:float, :float32, :float64].include?(type)
           data = numo_type.cast(data)
         else
           data =

data/lib/rover/version.rb

@@ -1,3 +1,3 @@
 module Rover
-  VERSION = "0.2.7"
+  VERSION = "0.3.1"
 end

data/lib/rover.rb

@@ -9,47 +9,64 @@ require "rover/version"
 
 module Rover
   class << self
-    def read_csv(path, types: nil, **options)
-      require "csv"
-      csv_to_df(CSV.read(path, **csv_options(options)), types: types, headers: options[:headers])
+    def read_csv(path, **options)
+      csv_to_df(**options) do |csv_options|
+        CSV.read(path, **csv_options)
+      end
     end
 
-    def parse_csv(str, types: nil, **options)
-      require "csv"
-      csv_to_df(CSV.parse(str, **csv_options(options)), types: types, headers: options[:headers])
+    def parse_csv(str, **options)
+      csv_to_df(**options) do |csv_options|
+        CSV.parse(str, **csv_options)
+      end
     end
 
-    def read_parquet(path, types: nil)
-      require "parquet"
-      parquet_to_df(Arrow::Table.load(path), types: types)
+    def read_parquet(path, **options)
+      parquet_to_df(**options) do
+        Arrow::Table.load(path)
+      end
     end
 
-    def parse_parquet(str, types: nil)
-      require "parquet"
-      parquet_to_df(Arrow::Table.load(Arrow::Buffer.new(str), format: :parquet), types: types)
+    def parse_parquet(str, **options)
+      parquet_to_df(**options) do
+        Arrow::Table.load(Arrow::Buffer.new(str), format: :parquet)
+      end
     end
 
     private
 
-    # TODO use date converter
-    def csv_options(options)
-      options = {headers: true, converters: :numeric}.merge(options)
-      raise ArgumentError, "Must specify headers" unless options[:headers]
-      options
-    end
+    def csv_to_df(types: nil, headers: nil, **csv_options)
+      require "csv"
+
+      raise ArgumentError, "Must specify headers" if headers == false
+
+      # TODO use date converter in 0.4.0 - need to test performance
+      table = yield({converters: :numeric}.merge(csv_options))
 
-    def csv_to_df(table, types: nil, headers: nil)
-      if headers && headers.size < table.headers.size
-        raise ArgumentError, "Expected #{table.headers.size} headers, got #{headers.size}"
+      headers = nil if headers == true
+      if headers && table.first && headers.size != table.first.size
+        raise ArgumentError, "Expected #{table.first.size} headers, given #{headers.size}"
+      end
+
+      table_headers = (headers || table.shift || []).dup
+      # keep same behavior as headers: true
+      if table.first
+        while table_headers.size < table.first.size
+          table_headers << nil
+        end
+      end
+      # TODO handle date converters
+      table_headers = table_headers.map! { |v| v.nil? ? nil : v.to_s }
+
+      if csv_options[:header_converters]
+        table_headers = CSV.parse(CSV.generate_line(table_headers), headers: true, header_converters: csv_options[:header_converters]).headers
       end
 
-      table.by_col!
       data = {}
-      keys = table.map { |k, _| [k, true] }.to_h
+      keys = table_headers.map { |k| [k, true] }.to_h
       unnamed_suffix = 1
-      table.each do |k, v|
-        # TODO do same for empty string in 0.3.0
-        if k.nil?
+      table_headers.each_with_index do |k, i|
+        if k.nil? || k.empty?
           k = "unnamed"
           while keys.include?(k)
             unnamed_suffix += 1
@@ -57,7 +74,18 @@ module Rover
           end
           keys[k] = true
         end
-        data[k] = v
+        table_headers[i] = k
+      end
+
+      table_headers.each_with_index do |k, i|
+        # use first value for duplicate headers like headers: true
+        next if data[k]
+
+        values = []
+        table.each do |row|
+          values << row[i]
+        end
+        data[k] = values
       end
 
       DataFrame.new(data, types: types)
@@ -78,7 +106,10 @@ module Rover
       "uint64" => Numo::UInt64
     }
 
-    def parquet_to_df(table, types: nil)
+    def parquet_to_df(types: nil)
+      require "parquet"
+
+      table = yield
       data = {}
       types ||= {}
       table.each_column do |column|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rover-df
 version: !ruby/object:Gem::Version
-  version: 0.2.7
+  version: 0.3.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-16 00:00:00.000000000 Z
+date: 2022-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -51,14 +51,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.4'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Simple, powerful data frames for Ruby