daru-io 0.1.0

data/lib/daru/io/importers/mongo.rb

@@ -0,0 +1,139 @@
+require 'daru/io/importers/json'
+
+module Daru
+  module IO
+    module Importers
+      # Mongo Importer Class, that extends `from_mongo` method to `Daru::DataFrame`
+      class Mongo < JSON
+        Daru::DataFrame.register_io_module :from_mongo, self
+
+        # Checks for required gem dependencies of Mongo Importer
+        def initialize
+          super
+          optional_gem 'mongo'
+        end
+
+        # Loads data from a given connection
+        #
+        # @!method self.from(connection)
+        #
+        # @param connection [String or Hash or Mongo::Client] Contains details
+        #   about a Mongo database / hosts to connect.
+        #
+        # @return [Daru::IO::Importers::Mongo]
+        #
+        # @example Loading from a connection string
+        #   instance_1 = Daru::IO::Importers::Mongo.from('mongodb://127.0.0.1:27017/test')
+        #
+        # @example Loading from a connection hash
+        #   instance_2 = Daru::IO::Importers::Mongo.from({ hosts: ['127.0.0.1:27017'], database: 'test' })
+        #
+        # @example Loading from a Mongo::Client connection
+        #   instance_3 = Daru::IO::Importers::Mongo.from(Mongo::Client.new ['127.0.0.1:27017'], database: 'test')
+        def from(connection)
+          @client = get_client(connection)
+          self
+        end
+
+        # Imports a `Daru::DataFrame` from a Mongo Importer instance.
+        #
+        # @param collection [String or Symbol] A specific collection in the
+        #   Mongo database, to import as `Daru::DataFrame`.
+        # @param columns [Array] JSON-path slectors to select specific fields
+        #   from the JSON input.
+        # @param order [String or Array] Either a JSON-path selector string, or
+        #   an array containing the order of the `Daru::DataFrame`. DO NOT
+        #   provide both `order` and `named_columns` at the same time.
+        # @param index [String or Array] Either a JSON-path selector string, or
+        #   an array containing the order of the `Daru::DataFrame`.
+        # @param filter [Hash] Filters and chooses Mongo documents that match
+        #   the given `filter` from the collection.
+        # @param limit [Interger] Limits the number of Mongo documents to be
+        #   parsed from the collection.
+        # @param skip [Integer] Skips `skip` number of documents from the Mongo
+        #   collection.
+        # @param named_columns [Hash] JSON-path selectors to select specific
+        #   fields from the JSON input. DO NOT provide both `order` and
+        #   `named_columns` at the same time.
+        #
+        # @note
+        #   - For more information on using JSON-path selectors, have a look at
+        #     the explanations {http://www.rubydoc.info/gems/jsonpath/0.5.8 here}
+        #     and {http://goessner.net/articles/JsonPath/ here}.
+        #   - The Mongo gem faces `Argument Error : expected Proc Argument`
+        #     issue due to the bug in MRI Ruby 2.4.0 mentioned
+        #     {https://bugs.ruby-lang.org/issues/13107 here}. This seems to have
+        #     been fixed in Ruby 2.4.1 onwards. Hence, please avoid using this
+        #     Mongo Importer in Ruby version 2.4.0.
+        #
+        # @return [Daru::DataFrame]
+        #
+        # @example Importing without jsonpath selectors
+        #   # The below 'cars' collection can be recreated in a Mongo shell with -
+        #   # db.cars.drop()
+        #   # db.cars.insert({name: "Audi", price: 52642})
+        #   # db.cars.insert({name: "Mercedes", price: 57127})
+        #   # db.cars.insert({name: "Volvo", price: 29000})
+        #
+        #   df = instance.call('cars')
+        #
+        #   #=> #<Daru::DataFrame(3x3)>
+        #   #           _id       name      price
+        #   #  0 5948d0bfcd       Audi    52642.0
+        #   #  1 5948d0c6cd   Mercedes    57127.0
+        #   #  2 5948d0cecd      Volvo    29000.0
+        #
+        # @example Importing with jsonpath selectors
+        #   # The below 'cars' collection can be recreated in a Mongo shell with -
+        #   # db.cars.drop()
+        #   # db.cars.insert({name: "Audi", price: 52642, star: { fuel: 9.8, cost: 8.6, seats: 9.9, sound: 9.3 }})
+        #   # db.cars.insert({name: "Mercedes", price: 57127, star: { fuel: 9.3, cost: 8.9, seats: 8.4, sound: 9.1 }})
+        #   # db.cars.insert({name: "Volvo", price: 29000, star: { fuel: 7.8, cost: 9.9, seats: 8.2, sound: 8.9 }})
+        #
+        #   df = instance.call(
+        #     'cars',
+        #     '$.._id',
+        #     '$..name',
+        #     '$..price',
+        #     '$..star..fuel',
+        #     '$..star..cost'
+        #   )
+        #
+        #   #=> #<Daru::DataFrame(3x5)>
+        #   #          _id       name      price       fuel       cost
+        #   # 0 5948d40b50       Audi    52642.0        9.8        8.6
+        #   # 1 5948d42850   Mercedes    57127.0        9.3        8.9
+        #   # 2 5948d44350      Volvo    29000.0        7.8        9.9
+        def call(collection, *columns, order: nil, index: nil,
+          filter: nil, limit: nil, skip: nil, **named_columns)
+          @json = ::JSON.parse(
+            @client[collection.to_sym]
+            .find(filter, skip: skip, limit: limit)
+            .to_json
+          )
+
+          super(*columns, order: order, index: index, **named_columns)
+        end
+
+        private
+
+        def get_client(connection)
+          case connection
+          when ::Mongo::Client
+            connection
+          when Hash
+            hosts = connection.delete :hosts
+            ::Mongo::Client.new(hosts, connection)
+          when String
+            ::Mongo::Client.new(connection)
+          else
+            raise ArgumentError,
+              "Expected #{connection} to be either a Mongo instance, "\
+              'Mongo connection Hash, or Mongo connection URL String. '\
+              "Received #{connection.class} instead."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/daru/io/importers/plaintext.rb

@@ -0,0 +1,97 @@
+require 'daru/io/importers/base'
+
+module Daru
+  module IO
+    module Importers
+      # Plaintext Importer Class, that extends `read_plaintext` method to
+      # `Daru::DataFrame`
+      class Plaintext < Base
+        Daru::DataFrame.register_io_module :read_plaintext, self
+
+        # Checks for required gem dependencies of Plaintext Importer
+        def initialize; end
+
+        # Reads data from a plaintext (.dat) file
+        #
+        # @!method self.read(path)
+        #
+        # @param path [String] Path to plaintext file, where the dataframe is to be
+        #   imported from.
+        #
+        # @return [Daru::IO::Importers::Plaintext]
+        #
+        # @example Reading from plaintext file
+        #   instance = Daru::IO::Importers::Plaintext.read("bank2.dat")
+        def read(path)
+          @file_data = File.read(path).split("\n").map do |line|
+            row = process_row(line.strip.split(/\s+/),[''])
+            next if row == ["\x1A"]
+            row
+          end
+          self
+        end
+
+        # Imports `Daru::DataFrame` from a Plaintext Importer instance
+        #
+        # @param fields [Array] An array of vectors.
+        #
+        # @return [Daru::DataFrame]
+        #
+        # @example Initializing with fields
+        #   df = instance.call([:v1, :v2, :v3, :v4, :v5, :v6])
+        #
+        #   #=> #<Daru::DataFrame(200x6)>
+        #   #       v1    v2    v3    v4    v5    v6
+        #   #  0 214.8 131.0 131.1   9.0   9.7 141.0
+        #   #  1 214.6 129.7 129.7   8.1   9.5 141.7
+        #   #  2 214.8 129.7 129.7   8.7   9.6 142.2
+        #   #  3 214.8 129.7 129.6   7.5  10.4 142.0
+        #   #  4 215.0 129.6 129.7  10.4   7.7 141.8
+        #   #  5 215.7 130.8 130.5   9.0  10.1 141.4
+        #   #  6 215.5 129.5 129.7   7.9   9.6 141.6
+        #   #  7 214.5 129.6 129.2   7.2  10.7 141.7
+        #   #  8 214.9 129.4 129.7   8.2  11.0 141.9
+        #   #  9 215.2 130.4 130.3   9.2  10.0 140.7
+        #   # 10 215.3 130.4 130.3   7.9  11.7 141.8
+        #   # 11 215.1 129.5 129.6   7.7  10.5 142.2
+        #   # 12 215.2 130.8 129.6   7.9  10.8 141.4
+        #   # 13 214.7 129.7 129.7   7.7  10.9 141.7
+        #   # 14 215.1 129.9 129.7   7.7  10.8 141.8
+        #   #...   ...   ...   ...   ...   ...   ...
+        def call(fields)
+          Daru::DataFrame.rows(@file_data, order: fields)
+        end
+
+        private
+
+        INT_PATTERN = /^[-+]?\d+$/
+        FLOAT_PATTERN = /^[-+]?\d+[,.]?\d*(e-?\d+)?$/
+
+        def process_row(row,empty)
+          row.to_a.map do |c|
+            if empty.include?(c)
+              # FIXME: As far as I can guess, it will never work.
+              # It is called only inside `from_plaintext`, and there
+              # data is splitted by `\s+` -- there is no chance that
+              # "empty" (currently just '') will be between data?..
+              nil
+            else
+              try_string_to_number(c)
+            end
+          end
+        end
+
+        def try_string_to_number(s)
+          case s
+          when INT_PATTERN
+            s.to_i
+          when FLOAT_PATTERN
+            s.tr(',', '.').to_f
+          else
+            s
+          end
+        end
+      end
+    end
+  end
+end

data/lib/daru/io/importers/r_data.rb

@@ -0,0 +1,74 @@
+require 'daru/io/importers/rds'
+
+module Daru
+  module IO
+    module Importers
+      # RData Importer Class, that extends `read_rdata` method to `Daru::DataFrame`
+      #
+      # @see Daru::IO::Importers::RDS For .rds format
+      class RData < RDS
+        Daru::DataFrame.register_io_module :read_rdata, self
+
+        # Checks for required gem dependencies of RData Importer
+        def initialize
+          super
+        end
+
+        # Reads data from a Rdata file
+        #
+        # @!method self.read(path)
+        #
+        # @param path [String] Path to RData file, where the dataframe is to be imported from.
+        #
+        # @return [Daru::IO::Importers::RData]
+        #
+        # @example Reading from rdata file
+        #   instance = Daru::IO::Importers::RData.read('ACScounty.RData')
+        def read(path)
+          @instance = RSRuby.instance
+          @instance.eval_R("load('#{path}')")
+          self
+        end
+
+        # Imports a `Daru::DataFrame` from a RData Importer instance and rdata file
+        #
+        # @param variable [String] The variable to be imported from the
+        #   variables stored in the RData file. Please note that the R
+        #   variable to be imported from the RData file should be a
+        #   `data.frame`
+        #
+        # @return [Daru::DataFrame]
+        #
+        # @example Importing a particular variable
+        #   df = instance.call("ACS3")
+        #
+        #   #=>   #<Daru::DataFrame(1629x30)>
+        #   #           Abbreviati       FIPS     Non.US      State       cnty females.di  ...
+        #   #         0         AL       1001       14.7    alabama    autauga       13.8  ...
+        #   #         1         AL       1003       13.5    alabama    baldwin       14.1  ...
+        #   #         2         AL       1005       20.1    alabama    barbour       16.1  ...
+        #   #         3         AL       1009       18.0    alabama     blount       13.7  ...
+        #   #         4         AL       1015       18.6    alabama    calhoun       12.9  ...
+        #   #       ...        ...        ...        ...        ...        ...        ...  ...
+        def call(variable)
+          @variable = variable.to_s
+
+          validate_params
+
+          process_dataframe(@instance.send(@variable.to_sym))
+        end
+
+        private
+
+        def validate_params
+          valid_r_dataframe_variables = @instance.eval_R('Filter(function(x) is.data.frame(get(x)) , ls())')
+          return if valid_r_dataframe_variables.include?(@variable)
+
+          variable_type = @instance.eval_R("typeof(#{@variable})")
+          raise ArgumentError, "Expected the given R variable (#{@variable}) to be a data.frame, got a "\
+                               "#{variable_type} instead."
+        end
+      end
+    end
+  end
+end

data/lib/daru/io/importers/rds.rb

@@ -0,0 +1,67 @@
+require 'daru/io/importers/base'
+
+module Daru
+  module IO
+    module Importers
+      # RDS Importer Class, that extends `read_rds` method to `Daru::DataFrame`
+      #
+      # @see Daru::IO::Importers::RData For .Rdata format
+      class RDS < Base
+        Daru::DataFrame.register_io_module :read_rds, self
+
+        # Checks for required gem dependencies of RDS Importer
+        def initialize
+          optional_gem 'rsruby'
+        end
+
+        # Reads data from a rds file
+        #
+        # @!method self.read(path)
+        #
+        # @param path [String] Path to rds file, where the dataframe is to be
+        #   imported from.
+        #
+        # @return [Daru::IO::Importers::RDS]
+        #
+        # @example Reading from rds file
+        #   instance = Daru::IO::Importers::RDS.read('bc_sites.rds')
+        def read(path)
+          @instance = RSRuby.instance.eval_R("readRDS('#{path}')")
+          self
+        end
+
+        # Imports a `Daru::DataFrame` from a RDS Importer instance and rds file
+        #
+        # @return [Daru::DataFrame]
+        #
+        # @example Reading from a RDS file
+        #   df = instance.call
+        #
+        #   #=> #<Daru::DataFrame(1113x25)>
+        #   #         area descriptio  epa_reach format_ver   latitude   location location_c ...
+        #   #  0      016  GSPTN             NaN        4.1       49.5    THOR IS 2MS22016 T ...
+        #   #  1      012  CSPT              NaN        4.1    50.6167    MITC BY 2MN26012 M ...
+        #   # ...     ...  ...               ...        ...       ...       ...       ...    ...
+        def call
+          process_dataframe(@instance)
+        end
+
+        private
+
+        def process_dataframe(data)
+          data = data.map { |key, values| [key.to_sym, values.map { |val| convert_datatype(val) }] }.to_h
+          Daru::DataFrame.new(data)
+        end
+
+        def convert_datatype(value)
+          case value.to_s
+          when 'NaN'           then nil
+          when value.to_f.to_s then value.to_f
+          when value.to_i.to_s then value.to_i
+          else value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/daru/io/importers/redis.rb

@@ -0,0 +1,135 @@
+require 'daru/io/importers/base'
+
+module Daru
+  module IO
+    module Importers
+      # Redis Importer Class, that extends `from_redis` method to `Daru::DataFrame`
+      class Redis < Base
+        Daru::DataFrame.register_io_module :from_redis, self
+
+        # Checks for required gem dependencies of Redis Importer
+        def initialize
+          require 'json'
+          optional_gem 'redis'
+        end
+
+        # Loads data from a given connection
+        #
+        # @!method self.from(connection)
+        #
+        # @param connection [Hash or Redis Instance] Either a Hash of *Redis* configurations,
+        #   or an existing *Redis* instance. For the hash configurations, have a
+        #   look at
+        #   [Redis#initialize](http://www.rubydoc.info/github/redis/redis-rb/Redis:initialize).
+        #
+        # @return [Daru::IO::Importers::Redis]
+        #
+        # @example Loading from a hash
+        #   instance = Daru::IO::Importers::Redis.from({url: "redis://:[password]@[hostname]:[port]/[db]"})
+        #
+        # @example Loading from a Redis connection
+        #   instance = Daru::IO::Importers::Redis.from(Redis.new({url: "redis://:[password]@[hostname]:[port]/[db]"}))
+        def from(connection={})
+          @client = get_client(connection)
+          self
+        end
+
+        # Imports a `Daru::DataFrame` from a Redis Importer instance
+        #
+        # @param keys [Array] Redis key(s) from whom, the `Daru::DataFrame`
+        #   should be constructed. If no keys are given, all keys in the *Redis*
+        #   connection will be used.
+        # @param match [String] A pattern to get matching keys.
+        # @param count [Integer] Number of matching keys to be obtained. Defaults to
+        #   nil, to collect ALL matching keys.
+        #
+        # @return [Daru::DataFrame]
+        #
+        # @example Importing with no options
+        #   # Say, the Redis connection has this setup
+        #   # Key "10001" => { "name" => "Tyrion", "age" => 32 }.to_json
+        #   # Key "10002" => { "name" => "Jamie", "age" => 37 }.to_json
+        #   # Key "10003" => { "name" => "Cersei", "age" => 37 }.to_json
+        #   # Key "10004" => { "name" => "Joffrey", "age" => 19 }.to_json
+        #
+        #   df = instance.call
+        #
+        #   #=> <Daru::DataFrame(4x2)>
+        #   #           name     age
+        #   # 10001  Tyrion      32
+        #   # 10002   Jamie      37
+        #   # 10003  Cersei      37
+        #   # 10004 Joffrey      19
+        #
+        # @example Importing with keys
+        #   # Say, the Redis connection has this setup
+        #   # Key "10001" => { "name" => "Tyrion", "age" => 32 }.to_json
+        #   # Key "10002" => { "name" => "Jamie", "age" => 37 }.to_json
+        #   # Key "10003" => { "name" => "Cersei", "age" => 37 }.to_json
+        #   # Key "10004" => { "name" => "Joffrey", "age" => 19 }.to_json
+        #
+        #   df = instance.call("10001", "10002")
+        #
+        #   #=> <Daru::DataFrame(2x2)>
+        #   #           name     age
+        #   # 10001  Tyrion      32
+        #   # 10002   Jamie      37
+        #
+        # @example Importing with query for matching keys and count
+        #   # Say, the Redis connection has this setup
+        #   # Key "key:1" => { "name" => "name1", "age" => "age1" }.to_json
+        #   # Key "key:2" => { "name" => "name2", "age" => "age2" }.to_json
+        #   # Key "key:3" => { "name" => "name3", "age" => "age3" }.to_json
+        #   # ...
+        #   # Key "key:2000" => { "name" => "name2000", "age" => "age2000" }.to_json
+        #
+        #   df = instance.call(match: "key:1*", count: 200)
+        #
+        #   #=> #<Daru::DataFrame(200x2)>
+        #   #              name      age
+        #   # key:1927 name1927  age1927
+        #   # key:1759 name1759  age1759
+        #   # key:1703 name1703  age1703
+        #   # key:1640 name1640  age1640
+        #   #   ...        ...      ...
+        def call(*keys, match: nil, count: nil)
+          @match  = match
+          @count  = count
+          @keys   = keys
+          @keys   = choose_keys(*@keys).map(&:to_sym)
+
+          vals = @keys.map { |key| ::JSON.parse(@client.get(key), symbolize_names: true) }
+          Base.guess_parse(@keys, vals)
+        end
+
+        private
+
+        def choose_keys(*keys)
+          return keys.to_a unless keys.empty?
+
+          cursor = nil
+          # Loop to iterate through paginated results of Redis#scan.
+          until cursor == '0' || (!@count.nil? && keys.count > (@count-1))
+            cursor, chunk = @client.scan(cursor, match: @match, count: @count)
+            keys.concat(chunk).uniq!
+          end
+          return keys[0..-1] if @count.nil?
+          keys[0..@count-1]
+        end
+
+        def get_client(connection)
+          case connection
+          when ::Redis
+            connection
+          when Hash
+            ::Redis.new connection
+          else
+            raise ArgumentError, "Expected '#{connection}' to be either "\
+                                 'a Hash or an initialized Redis instance, '\
+                                 "but received #{connection.class} instead."
+          end
+        end
+      end
+    end
+  end
+end