charty 0.1.4.dev → 0.2.4

data/lib/charty/table_adapters/daru_adapter.rb

@@ -0,0 +1,70 @@
+require "delegate"
+
+module Charty
+  module TableAdapters
+    class DaruAdapter < BaseAdapter
+      TableAdapters.register(:daru, self)
+
+      extend Forwardable
+      include Enumerable
+
+      def self.supported?(data)
+        defined?(Daru::DataFrame) && data.is_a?(Daru::DataFrame)
+      end
+
+      def initialize(data, columns: nil, index: nil)
+        @data = check_type(Daru::DataFrame, data, :data)
+
+        self.columns = columns unless columns.nil?
+        self.index = index unless index.nil?
+      end
+
+      attr_reader :data
+
+      def index
+        DaruIndex.new(data.index)
+      end
+
+      def_delegator :data, :index=
+
+      def columns
+        DaruIndex.new(data.vectors)
+      end
+
+      def columns=(values)
+        data.vectors = Daru::Index.coerce(values)
+      end
+
+      def column_names
+        @data.vectors.to_a
+      end
+
+      def compare_data_equality(other)
+        case other
+        when DaruAdapter
+          data == other.data
+        else
+          super
+        end
+      end
+
+      def [](row, column)
+        if row
+          @data[column][row]
+        else
+          column_data = if @data.has_vector?(column)
+                          @data[column]
+                        else
+                          @data[column.to_s]
+                        end
+          Vector.new(column_data)
+        end
+      end
+
+      private def check_type(type, data, name)
+        return data if data.is_a?(type)
+        raise TypeError, "#{name} must be a #{type}"
+      end
+    end
+  end
+end

data/lib/charty/table_adapters/datasets_adapter.rb

@@ -0,0 +1,49 @@
+module Charty
+  module TableAdapters
+    class DatasetsAdapter < BaseAdapter
+      TableAdapters.register(:datasets, self)
+
+      include Enumerable
+
+      def self.supported?(data)
+        defined?(Datasets::Dataset) &&
+          data.is_a?(Datasets::Dataset)
+      end
+
+      def initialize(dataset)
+        @table = dataset.to_table
+        @records = []
+      end
+
+      def data
+        @table
+      end
+
+      def column_names
+        @table.column_names
+      end
+
+      def length
+        data.n_rows
+      end
+
+      def each(&block)
+        return to_enum(__method__) unless block_given?
+
+        @table.each_record(&block)
+      end
+
+      # @param [Integer] row  Row index
+      # @param [Symbol,String,Integer] column Column index
+      def [](row, column)
+        if row
+          record = @table.find_record(row)
+          return nil if record.nil?
+          record[column]
+        else
+          Vector.new(@table[column], index: index, name: column)
+        end
+      end
+    end
+  end
+end

data/lib/charty/table_adapters/hash_adapter.rb

@@ -0,0 +1,224 @@
+require 'date'
+
+module Charty
+  module TableAdapters
+    class HashAdapter < BaseAdapter
+      TableAdapters.register(:hash, self)
+
+      def self.supported?(data)
+        case data
+        when []
+          true
+        when Array
+          case data[0]
+          when Numeric, String, Time, Date
+            true
+          when Hash
+            data.all? {|el| el.is_a? Hash }
+          when method(:array?)
+            data.all?(&method(:array?))
+          end
+        when Hash
+          true
+        end
+      end
+
+      def self.array?(data)
+        case data
+        when Charty::Vector
+          true
+        when Array, method(:daru_vector?), method(:narray_vector?), method(:nmatrix_vector?),
+             method(:numpy_vector?), method(:pandas_series?)
+          true
+        else
+          false
+        end
+      end
+
+      def self.daru_vector?(x)
+        defined?(Daru::Vector) && x.is_a?(Daru::Vector)
+      end
+
+      def self.narray_vector?(x)
+        defined?(Numo::NArray) && x.is_a?(Numo::NArray) && x.ndim == 1
+      end
+
+      def self.nmatrix_vector?(x)
+        defined?(NMatrix) && x.is_a?(NMatrix) && x.dim == 1
+      end
+
+      def self.numpy_vector?(x)
+        defined?(Numpy::NDArray) && x.is_a?(Numpy::NDArray) && x.ndim == 1
+      end
+
+      def self.pandas_series?(x)
+        defined?(Pandas::Series) && x.is_a?(Pandas::Series)
+      end
+
+      def initialize(data, columns: nil, index: nil)
+        case data
+        when Hash
+          arrays = data.values
+          columns ||= data.keys
+        when Array
+          case data[0]
+          when Numeric, String, Time, Date
+            arrays = [data]
+          when Hash
+            raise NotImplementedError,
+                  "an array of records is not supported"
+          when self.class.method(:array?)
+            unsupported_data_format unless data.all?(&self.class.method(:array?))
+            arrays = data.map(&:to_a).transpose
+          else
+            unsupported_data_format
+          end
+        else
+          unsupported_data_format
+        end
+
+        unless arrays.empty?
+          arrays, columns, index = check_data(arrays, columns, index)
+        end
+
+        @data = arrays.map.with_index {|a, i| [columns[i], a] }.to_h
+        self.columns = columns unless columns.nil?
+        self.index = index unless index.nil?
+      end
+
+      private def check_data(arrays, columns, index)
+        # NOTE: After Ruby 2.7, we can write the following code by filter_map:
+        #         indexes = arrays.filter_map {|ary| ary.index if ary.is_a?(Charty::Vector) }
+        indexes = []
+        arrays.each do |array|
+          index = case array
+                  when Charty::Vector
+                    array.index
+                  when ->(x) { defined?(Daru) && x.is_a?(Daru::Vector) }
+                    Charty::DaruIndex.new(array.index)
+                  when ->(x) { defined?(Pandas) && x.is_a?(Pandas::Series) }
+                    Charty::PandasIndex.new(array.index)
+                  else
+                    if index.nil?
+                      RangeIndex.new(0 ... array.size)
+                    else
+                      check_and_convert_index(index, :index, array.size)
+                    end
+                  end
+          indexes << index
+        end
+        index = union_indexes(*indexes)
+
+        arrays = arrays.map do |array|
+          case array
+          when Charty::Vector
+            array.data
+          when Hash
+            raise NotImplementedError
+          when self.class.method(:array?)
+            array
+          else
+            Array.try_convert(array)
+          end
+        end
+
+        columns = generate_column_names(arrays.length, columns)
+
+        return arrays, columns, index
+      end
+
+      private def union_indexes(*indexes)
+        result = nil
+        while result.nil? && indexes.length > 0
+          result = indexes.shift
+        end
+        indexes.each do |index|
+          next if index.nil?
+          result = result.union(index)
+        end
+        result
+      end
+
+      attr_reader :data
+
+      def_delegator :@data, :keys, :column_names
+
+      def length
+        case
+        when column_names.empty?
+          0
+        else
+          data[column_names[0]].size
+        end
+      end
+
+      def column_length
+        data.length
+      end
+
+      def compare_data_equality(other)
+        case other
+        when DaruAdapter, PandasDataFrameAdapter
+          other.compare_data_equality(self)
+        else
+          super
+        end
+      end
+
+      def [](row, column)
+        if row
+          @data[column][row]
+        else
+          case column
+          when Symbol
+            sym_key = column
+            str_key = column.to_s
+          else
+            str_key = String.try_convert(column)
+            sym_key = str_key.to_sym
+          end
+
+          column_data = if @data.key?(sym_key)
+                          @data[sym_key]
+                        else
+                          @data[str_key]
+                        end
+          Vector.new(column_data, index: index, name: column)
+        end
+      end
+
+      def each
+        i, n = 0, shape[0]
+        while i < n
+          record = @data.map {|k, v| v[i] }
+          yield record
+          i += 1
+        end
+      end
+
+      private def make_data_from_records(data, columns)
+        n_rows = data.length
+        n_columns = data.map(&:size).max
+        columns = generate_column_names(n_columns, columns)
+        columns.map.with_index { |key, j|
+          values = n_rows.times.map {|i| data[i][j] }
+          [key, values]
+        }.to_h
+      end
+
+      private def generate_column_names(n_columns, columns)
+        # FIXME: this is the same as NArrayAdapter#generate_column_names
+        columns ||= []
+        if columns.length >= n_columns
+          columns[0, n_columns]
+        else
+          columns + columns.length.upto(n_columns - 1).map {|i| "X#{i}" }
+        end
+      end
+
+      private def unsupported_data_format
+        raise ArgumentError, "Unsupported data format"
+      end
+    end
+  end
+end

data/lib/charty/table_adapters/narray_adapter.rb

@@ -0,0 +1,76 @@
+module Charty
+  module TableAdapters
+    class NArrayAdapter < BaseAdapter
+      TableAdapters.register(:narray, self)
+
+      def self.supported?(data)
+        defined?(Numo::NArray) && data.is_a?(Numo::NArray) && data.ndim <= 2
+      end
+
+      def initialize(data, columns: nil, index: nil)
+        case data.ndim
+        when 1
+          data = data.reshape(data.length, 1)
+        when 2
+          # do nothing
+        else
+          raise ArgumentError, "Unsupported data format"
+        end
+        @data = data
+        self.columns = Index.new(generate_column_names(data.shape[1], columns))
+        self.index = index || RangeIndex.new(0 ... length)
+      end
+
+      attr_reader :data
+
+      def length
+        data.shape[0]
+      end
+
+      def column_length
+        data.shape[1]
+      end
+
+      def compare_data_equality(other)
+        case other
+        when NArrayAdapter
+          data == other.data
+        else
+          super
+        end
+      end
+
+      def [](row, column)
+        if row
+          @data[row, resolve_column_index(column)]
+        else
+          column_data = @data[true, resolve_column_index(column)]
+          Charty::Vector.new(column_data, index: index, name: column)
+        end
+      end
+
+      private def resolve_column_index(column)
+        case column
+        when String, Symbol
+          index = column_names.index(column.to_sym) || column_names.index(column.to_s)
+          return index if index
+          raise IndexError, "invalid column name: #{column}"
+        when Integer
+          column
+        else
+          message = "column must be String or Integer: #{column.inspect}"
+          raise ArgumentError, message
+        end
+      end
+
+      private def generate_column_names(n_columns, columns)
+        columns ||= []
+        if columns.length >= n_columns
+          columns[0, n_columns]
+        else
+          columns + columns.length.upto(n_columns - 1).map {|i| "X#{i}" }
+        end
+      end
+    end
+  end
+end

data/lib/charty/table_adapters/nmatrix_adapter.rb

@@ -0,0 +1,67 @@
+module Charty
+  module TableAdapters
+    class NMatrixAdapter < BaseAdapter
+      TableAdapters.register(:nmatrix, self)
+
+      def self.supported?(data)
+        defined?(NMatrix) && data.is_a?(NMatrix) && data.shape.length <= 2
+      end
+
+      def initialize(data, columns: nil)
+        case data.shape.length
+        when 1
+          data = data.reshape(data.size, 1)
+        when 2
+          # do nothing
+        else
+          raise ArgumentError, "Unsupported data format"
+        end
+        @data = data
+        self.columns = Index.new(generate_column_names(data.shape[1], columns))
+        self.index = index || RangeIndex.new(0 ... length)
+      end
+
+      attr_reader :data
+
+      def length
+        data.shape[0]
+      end
+
+      def column_length
+        data.shape[1]
+      end
+
+      def [](row, column)
+        if row
+          @data[row, resolve_column_index(column)]
+        else
+          column_data = @data[:*, resolve_column_index(column)].reshape([@data.shape[0]])
+          Charty::Vector.new(column_data, index: index, name: column)
+        end
+      end
+
+      private def resolve_column_index(column)
+        case column
+        when String, Symbol
+          index = column_names.index(column.to_sym) || column_names.index(column.to_s)
+          return index if index
+          raise IndexError, "invalid column name: #{column}"
+        when Integer
+          column
+        else
+          message = "column must be String or Integer: #{column.inspect}"
+          raise ArgumentError, message
+        end
+      end
+
+      private def generate_column_names(n_columns, columns)
+        columns ||= []
+        if columns.length >= n_columns
+          columns[0, n_columns]
+        else
+          columns + columns.length.upto(n_columns - 1).map {|i| "X#{i}" }
+        end
+      end
+    end
+  end
+end