daru 0.2.1 → 0.2.2

data/lib/daru/index/index.rb

@@ -74,7 +74,7 @@ module Daru
     def ==(other)
       return false if self.class != other.class || other.size != @size
 
-      @relation_hash.keys == other.to_a &&
+      @keys == other.to_a &&
         @relation_hash.values == other.relation_hash.values
     end
 
@@ -201,7 +201,7 @@ module Daru
     end
 
     def to_a
-      @relation_hash.keys
+      @keys
     end
 
     def key(value)
@@ -230,16 +230,16 @@ module Daru
     #   #     3  false
     #   #     4  true
     def is_values(*indexes) # rubocop:disable Style/PredicateName
-      bool_array = @relation_hash.keys.map { |r| indexes.include?(r) }
+      bool_array = @keys.map { |r| indexes.include?(r) }
       Daru::Vector.new(bool_array)
     end
 
     def empty?
-      @relation_hash.empty?
+      @size.zero?
     end
 
     def dup
-      Daru::Index.new @relation_hash.keys
+      Daru::Index.new @keys, name: @name
     end
 
     def add *indexes
@@ -285,15 +285,17 @@ module Daru
     #   di.sort #=> Daru::Index.new [1, 2, 99, 100, 101]
     def sort opts={}
       opts = {ascending: true}.merge(opts)
-      if opts[:ascending]
-        new_index, = @relation_hash.sort.transpose
-      else
-        new_index, = @relation_hash.sort.reverse.transpose
-      end
+
+      new_index = @keys.sort
+      new_index = new_index.reverse unless opts[:ascending]
 
       self.class.new(new_index)
     end
 
+    def to_df
+      Daru::DataFrame.new(name => to_a)
+    end
+
     private
 
     def guess_index index
@@ -342,7 +344,6 @@ module Daru
 
     # Raises IndexError when one of the positions is an invalid position
     def validate_positions *positions
-      positions = [positions] if positions.is_a? Integer
       positions.each do |pos|
         raise IndexError, "#{pos} is not a valid position." if pos >= size || pos < -size
       end

data/lib/daru/index/multi_index.rb

@@ -9,6 +9,7 @@ module Daru
     end
 
     attr_reader :labels
+    attr_reader :name
 
     def levels
       @levels.map(&:keys)
@@ -19,7 +20,7 @@ module Daru
     # If user don't want to put name for particular level then user must put
     # empty string in that index of Array `name`.
     # For example there is multi_index of 3 levels and user don't want to name
-    # level 0, then do mulit_index.name = ['', 'level1_name1', 'level2_name']
+    # level 0, then do multi_index.name = ['', 'level1_name1', 'level2_name']
     #
     # @example
     #
@@ -196,12 +197,12 @@ module Daru
     end
 
     def add *indexes
-      Daru::MultiIndex.from_tuples to_a << indexes
+      Daru::MultiIndex.from_tuples(to_a + [indexes])
     end
 
     def reorder(new_order)
       from = to_a
-      self.class.from_tuples(new_order.map { |i| from[i] })
+      MultiIndex.from_tuples(new_order.map { |i| from[i] })
     end
 
     def try_retrieve_from_integer int
@@ -365,5 +366,9 @@ module Daru
         [nil] * (cur.size - left.size) + left.map(&:first)
       }
     end
+
+    def to_df
+      Daru::DataFrame.new(@name.zip(to_a.transpose).to_h)
+    end
   end
 end

data/lib/daru/io/io.rb

@@ -34,7 +34,7 @@ module Daru
     end
   end
 
-  module IO # rubocop:disable Metrics/ModuleLength
+  module IO
     class << self
       # Functions for loading/writing Excel files.
 
@@ -134,23 +134,11 @@ module Daru
       #
       # @return A dataframe containing the data in the given relation
       def from_activerecord(relation, *fields)
-        if fields.empty?
-          records = relation.map do |record|
-            record.attributes.symbolize_keys
-          end
-          return Daru::DataFrame.new(records)
-        else
-          fields = fields.map(&:to_sym)
-        end
+        fields = relation.klass.column_names if fields.empty?
+        fields = fields.map(&:to_sym)
 
-        vectors = fields.map { |name| [name, Daru::Vector.new([], name: name)] }.to_h
-
-        Daru::DataFrame.new(vectors, order: fields).tap do |df|
-          relation.pluck(*fields).each do |record|
-            df.add_row(Array(record))
-          end
-          df.update
-        end
+        result = relation.pluck(*fields).transpose
+        Daru::DataFrame.new(result, order: fields).tap(&:update)
       end
 
       # Loading data from plain text files

data/lib/daru/iruby/templates/dataframe.html.erb

@@ -1,5 +1,5 @@
 <b> Daru::DataFrame<%= name ? ": #{name} " : ''%>(<%=nrows%>x<%=ncols%>) </b>
-<table>
+<table border="1" class="dataframe">
   <%= table_thead %>
   <%= table_tbody %>
 </table>

data/lib/daru/vector.rb

@@ -151,8 +151,6 @@ module Daru
     attr_accessor :labels
     # Store vector data in an array
     attr_reader :data
-    # Ploting library being used for this vector
-    attr_reader :plotting_library
     # TODO: Make private.
     attr_reader :nil_positions, :nan_positions
 
@@ -197,6 +195,13 @@ module Daru
       end
     end
 
+    # attr_reader for :plotting_library
+    def plotting_library
+      init_plotting_library
+
+      @plotting_library
+    end
+
     def plotting_library= lib
       case lib
       when :gruff, :nyaplot
@@ -207,11 +212,18 @@ module Daru
           )
         end
       else
-        raise ArguementError, "Plotting library #{lib} not supported. "\
+        raise ArgumentError, "Plotting library #{lib} not supported. "\
           'Supported libraries are :nyaplot and :gruff'
       end
     end
 
+    # this method is overwritten: see Daru::Vector#plotting_library=
+    def plot(*args, **options, &b)
+      init_plotting_library
+
+      plot(*args, **options, &b)
+    end
+
     # Get one or more elements with specified index or a range.
     #
     # == Usage
@@ -1481,6 +1493,11 @@ module Daru
 
     private
 
+    # Will lazily load the plotting library being used for this vector
+    def init_plotting_library
+      self.plotting_library = Daru.plotting_library
+    end
+
     def copy(values)
       # Make sure values is right-justified to the size of the vector
       values.concat([nil] * (size-values.size)) if values.size < size
@@ -1514,8 +1531,6 @@ module Daru
       guard_sizes!
 
       @possibly_changed_type = true
-      # Include plotting functionality
-      self.plotting_library = Daru.plotting_library
     end
 
     def parse_source source, opts
@@ -1598,7 +1613,6 @@ module Daru
 
     # Raises IndexError when one of the positions is an invalid position
     def validate_positions *positions
-      positions = [positions] if positions.is_a? Integer
       positions.each do |pos|
         raise IndexError, "#{pos} is not a valid position." if pos >= size
       end

data/lib/daru/version.rb

@@ -1,3 +1,3 @@
 module Daru
-  VERSION = '0.2.1'.freeze
+  VERSION = '0.2.2'.freeze
 end

data/spec/core/group_by_spec.rb

@@ -620,9 +620,14 @@ describe Daru::Core::GroupBy do
       end
 
       it 'works as older methods' do
-        newer_way = spending_df.group_by([:year, :category]).aggregate(spending: :sum, nb_spending: :sum)
         older_way = spending_df.group_by([:year, :category]).sum
+
+        newer_way = spending_df.group_by([:year, :category]).aggregate(spending: :sum, nb_spending: :sum)
         expect(newer_way).to eq(older_way)
+
+        contrived_way = spending_df.group_by([:year, :category]).aggregate(spending: :sum, nb_spending_lambda: ->(df) { df[:nb_spending].sum })
+        contrived_way.rename_vectors(nb_spending_lambda: :nb_spending)
+        expect(contrived_way).to eq(older_way)
       end
 
       context 'can aggregate on MultiIndex' do

data/spec/dataframe_spec.rb

@@ -2784,6 +2784,11 @@ describe Daru::DataFrame do
         :a  => [1,2,3,4,5]
       }, order: [:b, 'a', :a]))
     end
+
+    it 'raises ArgumentError if argument was not an index' do
+      df = Daru::DataFrame.new([])
+      expect { df.reindex_vectors([]) }.to raise_error(ArgumentError)
+    end
   end
 
   context "#to_matrix" do
@@ -3673,6 +3678,41 @@ describe Daru::DataFrame do
     end
   end
 
+  context '#reset_index' do
+    context 'when Index' do
+      subject do
+        Daru::DataFrame.new(
+          {'vals' => [1,2,3,4,5]},
+          index: Daru::Index.new(%w[a b c d e], name: 'indices')
+        ).reset_index
+      end
+
+      it { is_expected.to eq Daru::DataFrame.new(
+        'indices' => %w[a b c d e],
+        'vals' => [1,2,3,4,5]
+      )}
+    end
+
+    context 'when MultiIndex' do
+      subject do
+        mi = Daru::MultiIndex.from_tuples([
+          [0, 'a'], [0, 'b'], [1, 'a'], [1, 'b']
+        ])
+        mi.name = %w[nums alphas]
+        Daru::DataFrame.new(
+          {'vals' => [1,2,3,4]},
+          index: mi
+        ).reset_index
+      end
+
+      it { is_expected.to eq Daru::DataFrame.new(
+        'nums' => [0,0,1,1],
+        'alphas' => %w[a b a b],
+        'vals' => [1,2,3,4]
+      )}
+    end
+  end
+
   context "#set_index" do
     before(:each) do
       @df = Daru::DataFrame.new({
@@ -3712,6 +3752,26 @@ describe Daru::DataFrame do
         jholu.set_index(:a)
       }.to raise_error(ArgumentError)
     end
+
+    it "sets multiindex if array is given" do
+      df = Daru::DataFrame.new({
+        a: %w[a a b b],
+        b: [1, 2, 1, 2],
+        c: %w[a b c d]
+      })
+      df.set_index(%i[a b])
+      expected =
+        Daru::DataFrame.new(
+          { c: %w[a b c d] },
+          index: Daru::MultiIndex.from_tuples(
+            [['a', 1], ['a', 2], ['b', 1], ['b', 2]]
+          )
+        ).tap do |df|
+          df.index.name = %i[a b]
+          df
+        end
+      expect(df).to eq(expected)
+    end
   end
 
   context "#concat" do
@@ -4037,6 +4097,56 @@ describe Daru::DataFrame do
     end
   end
 
+  context '#access_row_tuples_by_indexs' do
+    let(:df) {
+      Daru::DataFrame.new({col: [:a, :b, :c, :d, :e], num: [52,12,07,17,01]}) }
+    let(:df_idx) {
+      Daru::DataFrame.new({a: [52, 12, 07], b: [1, 2, 3]}, index: [:one, :two, :three])
+    }
+    let (:mi_idx) do
+      Daru::MultiIndex.from_tuples [
+        [:a,:one,:bar],
+        [:a,:one,:baz],
+        [:b,:two,:bar],
+        [:a,:two,:baz],
+      ]
+    end
+    let (:df_mi) do
+      Daru::DataFrame.new({
+        a: 1..4,
+        b: 'a'..'d'
+      }, index: mi_idx )
+    end
+    context 'when no index is given' do
+      it 'returns empty Array' do
+        expect(df.access_row_tuples_by_indexs()).to eq([])
+      end
+    end
+    context 'when index(s) are given' do
+      it 'returns Array of row tuples' do
+        expect(df.access_row_tuples_by_indexs(1)).to eq([[:b, 12]])
+        expect(df.access_row_tuples_by_indexs(0,3)).to eq([[:a, 52], [:d, 17]])
+      end
+    end
+    context 'when custom index(s) are given' do
+      it 'returns Array of row tuples' do
+        expect(df_idx.access_row_tuples_by_indexs(:one,:three)).to eq(
+          [[52, 1], [7, 3]]
+        )
+      end
+    end
+    context 'when multi index is given' do
+      it 'returns Array of row tuples' do
+        expect(df_mi.access_row_tuples_by_indexs(:a)).to eq(
+          [[1, "a"], [2, "b"], [4, "d"]]
+        )
+        expect(df_mi.access_row_tuples_by_indexs(:a, :one, :baz)).to eq(
+          [[2, "b"]]
+        )
+      end
+    end
+  end
+
   context '#aggregate' do
     let(:cat_idx) { Daru::CategoricalIndex.new [:a, :b, :a, :a, :c] }
     let(:df) { Daru::DataFrame.new(num: [52,12,07,17,01], cat_index: cat_idx) }

data/spec/index/index_spec.rb

@@ -388,4 +388,30 @@ describe Daru::Index do
     end
 
   end
+
+  context '#to_df' do
+    let(:idx) do
+      Daru::Index.new(['speaker', 'mic', 'guitar', 'amp'],
+                      name: 'instruments')
+    end
+    subject { idx.to_df }
+
+    it { is_expected.to eq Daru::DataFrame.new(
+           'instruments' => ['speaker', 'mic', 'guitar', 'amp']
+         )
+    }
+  end
+
+  context "#dup" do
+    let(:idx) do
+      Daru::Index.new(['speaker', 'mic', 'guitar', 'amp'],
+                      name: 'instruments')
+    end
+    subject { idx.dup }
+
+    it { is_expected.to eq idx }
+    it 'have same names' do
+      expect(subject.name).to eq idx.name
+    end
+  end
 end

data/spec/index/multi_index_spec.rb

@@ -659,4 +659,22 @@ describe Daru::MultiIndex do
       it { expect(idx.valid? :a, :three).to eq false }
     end
   end
+
+  context '#to_df' do
+    let(:idx) do
+      described_class.from_tuples([
+        %w[a one bar],
+        %w[a two bar],
+        %w[b two baz],
+        %w[b one foo]
+      ]).tap { |idx| idx.name = %w[col1 col2 col3] }
+    end
+
+    subject { idx.to_df }
+    it { is_expected.to eq Daru::DataFrame.new(
+           'col1' => %w[a a b b],
+           'col2' => %w[one two two one],
+           'col3' => %w[bar bar baz foo]
+    )}
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: daru
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - Sameer Deshmukh
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-02 00:00:00.000000000 Z
+date: 2019-08-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backports
@@ -56,14 +56,14 @@ dependencies:
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.10'
 - !ruby/object:Gem::Dependency
@@ -280,16 +280,16 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.13
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.13
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -418,6 +418,7 @@ files:
 - benchmarks/TradeoffData.csv
 - benchmarks/csv_reading.rb
 - benchmarks/dataframe_creation.rb
+- benchmarks/db_loading.rb
 - benchmarks/duplicating.rb
 - benchmarks/group_by.rb
 - benchmarks/joining.rb
@@ -585,8 +586,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: Data Analysis in RUby