big_ml 0.1.2 → 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a50eda2eba99d6592ba297ee52e9d83b50542e91
+  data.tar.gz: 81deabae37c7a0216e89f51a548d98340895cc1d
+SHA512:
+  metadata.gz: 48b9bc705f8ae24e698e812e4568a9b3f655d55d15f70293f9bfbbf6750473dceaca8c2f1f3d8e978d1fe386bf015c51b69f674fd380122ce9e758131326af1c
+  data.tar.gz: ca6dc1b896895752e275e108ee6d73aa35f23b5dbad4ff3b37733315b9eecae0cc27b22fe4f7639c4a5f5ff9e2b7d05ae2eda4a796419059c44a6bdcab543a05

data/.rspec

@@ -1,2 +1,2 @@
---format nested
+--format documentation
 --color

data/.rvmrc.example

@@ -1 +1 @@
-rvm use --create ruby-1.9.3-p194@bigml > /dev/null
+rvm use --create ruby-2.1.0@bigml > /dev/null

data/.travis.yml

@@ -1,4 +1,4 @@
 language: ruby
 rvm:
-  - 1.9.2
   - 1.9.3
+  - 2.1.0

data/README.md

@@ -1,6 +1,6 @@
 # BigML
 
-A Ruby wrapper for the [BigML REST API](https://bigml.com/developers), provides access to sources, datasets, models, and predictions. You can create, retrieve, update and delete 
+A Ruby wrapper for the [BigML REST API](https://bigml.com/developers), provides access to sources, datasets, models, and predictions. You can create, retrieve, update and delete
 
 [![Build Status](https://secure.travis-ci.org/vigosan/big_ml.png?branch=master)](http://travis-ci.org/vigosan/big_ml)
 
@@ -14,6 +14,7 @@ BigML.configure do |c|
   c.username = 'foo'
   c.api_key  = 'bar'
   c.dev_mode = true
+  #c.debug   = true # Raises errors for bad requests
 end
 
 # easy creation of sources
@@ -26,7 +27,7 @@ all_datasets = BigML::Dataset.all
 # or just want to create one?
 dataset = source.to_dataset
 
-# find a concrete one 
+# find a concrete one
 model = BigML::Model.find("4fe8868a035d07682f002891")
 
 # create you predictions using parameters...
@@ -66,10 +67,10 @@ Install the gem with rubygem in your system:
 
 This library has been tested on the following ruby interpreters:
 
-* MRI 1.9.2
-* MRI 1.9.3
+* 1.9.3
+* 2.1.0
 
-## Running the tests 
+## Running the tests
 
 Download and run the test suit:
 

data/lib/big_ml.rb

@@ -2,13 +2,18 @@ require 'big_ml/util/client'
 require 'big_ml/model'
 require 'big_ml/dataset'
 require 'big_ml/prediction'
+require 'big_ml/batch_prediction'
 require 'big_ml/source'
+require 'big_ml/evaluation'
+require 'big_ml/ensemble'
 
 require 'big_ml/util/config'
 
 module BigML
   extend Util::Config
 
+  UnsuccessfulRequestError = Class.new(StandardError)
+
   class << self
     def new(options = {})
       Client.new(options)

data/lib/big_ml/base.rb

@@ -1,4 +1,5 @@
 require 'big_ml/util/client'
+require 'timeout'
 
 module BigML
   class Base
@@ -23,6 +24,22 @@ module BigML
       self.class.update(id, options)
     end
 
+    def ready?
+      success? || error?
+    end
+
+    def success?
+      status["code"] == 5
+    end
+
+    def error?
+      status["code"] < 0
+    end
+
+    def wait_for_ready(options = {})
+      BigML::Base.wait_for_ready(self, options)
+    end
+
     class << self
       def all(options = {})
         response = client.get("/#{resource_name}", options)
@@ -47,6 +64,20 @@ module BigML
         all.each {|s| delete(s.id) }
       end
 
+      # Keeps reloading resource until it is ready
+      def wait_for_ready(resource, options = {})
+        klass = resource.class
+        remaining = options.fetch :timeout, 60
+        delay = options.fetch :delay, 1
+        until resource && resource.ready?
+          resource = klass.find(resource.id)
+          sleep(delay) unless resource.ready?
+          remaining = remaining - delay
+          raise Timeout::Error if remaining <= 0
+        end
+        resource
+      end
+
       private
 
       def client

data/lib/big_ml/batch_prediction.rb

@@ -0,0 +1,39 @@
+require 'big_ml/base'
+
+module BigML
+  class BatchPrediction < Base
+    BATCH_PREDICTION_PROPERTIES = [
+      :category, :code, :created, :credits, :dataset, :dataset_status,
+      :description, :fields, :dataset, :model, :model_status, :name,
+      :objective_fields, :prediction, :prediction_path, :private, :resource,
+      :source, :source_status, :status, :tags, :updated
+    ]
+
+    attr_reader *BATCH_PREDICTION_PROPERTIES
+
+    class << self
+      def create(model_or_ensemble, dataset, options = {})
+        arguments = { dataset: dataset }
+        if model_or_ensemble.start_with? 'model'
+          arguments[:model] = model_or_ensemble
+        elsif model_or_ensemble.start_with? 'ensemble'
+          arguments[:ensemble] = model_or_ensemble
+        else
+          raise ArgumentError, "Expected model or ensemble, got #{model_or_ensemble}"
+        end
+        response = client.post("/#{resource_name}", {}, arguments.merge(options))
+        self.new(response) if response.success?
+      end
+
+      def download(id)
+        response = client.get("/#{resource_name}/#{id}/download")
+        response.body if response.success?
+      end
+    end
+
+    def download
+      self.class.download(id)
+    end
+
+  end
+end

data/lib/big_ml/ensemble.rb

@@ -0,0 +1,32 @@
+require 'big_ml/base'
+
+module BigML
+  class Ensemble < Base
+    ENSEMBLE_PROPERTIES = [
+      :category, :code, :columns, :created, :credits, 
+      :dataset, :dataset_status, :description, :dev, :distributions,
+      :holdout, :error_models, :excluded_fields, :finished_models,
+      :input_fields, :locale, :max_columns, :max_rows, :model_order,
+      :models, :name, :node_threshold, :number_of_batchpredictions,
+      :number_of_evaluations, :number_of_models, :number_of_predictions,
+      :number_of_public_predictions, :objective_field, :ordering,
+      :out_of_bag, :price, :private, :randomize, :random_candidates,
+      :range, :replacement, :resource, :rows, :sample_rate, :seed,
+      :shared, :shared_hash, :sharing_key, :size, :source, :source_status, 
+      :status, :subscription, :tags, :tlp, :updated
+    ]
+
+    attr_reader *ENSEMBLE_PROPERTIES
+
+    def to_prediction(options)
+      Prediction.create(resource, options)
+    end
+
+    class << self
+      def create(dataset, options = {})
+        response = client.post("/#{resource_name}", {}, options.merge(dataset: dataset))
+        self.new(response) if response.success?
+      end
+    end
+  end
+end

data/lib/big_ml/evaluation.rb

@@ -0,0 +1,31 @@
+require 'big_ml/base'
+
+module BigML
+  class Evaluation < Base
+    EVALUATION_PROPERTIES = [
+      :category, :code, :combiner, :created, :credits, :dataset, :dataset_status, 
+      :description, :dev, :ensemble, :fields_map, :locale, :max_rows, :missing_strategy,
+      :model, :model_status, :model_type, :name, :number_of_models, :ordering,
+      :out_of_bag, :private, :range, :replacement, :resource, :result, :rows, :sample_rate,
+      :shared, :shared_hash, :sharing_key, :size, :status, :subscription, :tags,
+      :threshold, :type, :updated
+    ]
+
+    attr_reader *EVALUATION_PROPERTIES
+
+    class << self
+      def create(model_or_ensemble, dataset, options = {})
+        arguments = { dataset: dataset }
+        if model_or_ensemble.start_with? 'model'
+          arguments[:model] = model_or_ensemble
+        elsif model_or_ensemble.start_with? 'ensemble'
+          arguments[:ensemble] = model_or_ensemble
+        else
+          raise ArgumentError, "Expected model or ensemble, got #{model_or_ensemble}"
+        end
+        response = client.post("/#{resource_name}", {}, arguments.merge(options))
+        self.new(response) if response.success?
+      end
+    end
+  end
+end

data/lib/big_ml/prediction.rb

@@ -12,8 +12,8 @@ module BigML
     attr_reader *PREDICTION_PROPERTIES
 
     class << self
-      def create(model, options = {})
-        response = client.post("/#{resource_name}", {}, { :model => model }.merge!(options))
+      def create(model_or_ensemble, options = {})
+        response = client.post("/#{resource_name}", {}, { model_or_ensemble.split('/').first.to_sym => model_or_ensemble }.merge!(options))
         self.new(response) if response.success?
       end
     end

data/lib/big_ml/util/client.rb

@@ -12,6 +12,7 @@ module BigML
       format :json
 
       attr_accessor *Config::VALID_OPTIONS_KEYS
+      alias_method :debug?, :debug
 
       def initialize(attrs={})
         attrs = BigML.options.merge(attrs)

data/lib/big_ml/util/config.rb

@@ -11,8 +11,10 @@ module BigML
       DEFAULT_BIGML_API_KEY  = nil
       # Set default mode to production
       DEFAULT_IN_DEV_MODE    = false
+      # Set default debug mode to off
+      DEFAULT_IN_DEBUG_MODE  = false
       # An array of valid keys in the options hash when configuring a {BigML::Client}
-      VALID_OPTIONS_KEYS     = [:username, :api_key, :dev_mode]
+      VALID_OPTIONS_KEYS     = [:username, :api_key, :dev_mode, :debug]
 
       attr_accessor *VALID_OPTIONS_KEYS
 
@@ -31,6 +33,7 @@ module BigML
         self.username = DEFAULT_BIGML_USERNAME
         self.api_key  = DEFAULT_BIGML_API_KEY
         self.dev_mode = DEFAULT_IN_DEV_MODE
+        self.debug    = DEFAULT_IN_DEBUG_MODE
       end
     end
   end

data/lib/big_ml/util/request.rb

@@ -1,19 +1,19 @@
 module BigML
   module Request
     def get(path, options = {}, body = {})
-      self.class.get(path, prepare_options(options, body))
+      handle_response self.class.get(path, prepare_options(options, body))
     end
 
     def put(path, options = {}, body = {})
-      self.class.put(path, prepare_options(options, body))
+      handle_response self.class.put(path, prepare_options(options, body))
     end
 
     def post(path, options = {}, body = {})
-      self.class.post(path, prepare_options(options, body))
+      handle_response self.class.post(path, prepare_options(options, body))
     end
 
     def delete(path, options = {}, body = {})
-      self.class.delete(path, prepare_options(options, body))
+      handle_response self.class.delete(path, prepare_options(options, body))
     end
 
     private
@@ -25,5 +25,10 @@ module BigML
         { :headers => {'content-type' => 'application/json'}, :query => options, :body => body.to_json }
       end
     end
+
+    def handle_response(response)
+      debug? && !response.success? and raise UnsuccessfulRequestError, response.inspect
+      response
+    end
   end
 end

data/lib/big_ml/version.rb

@@ -1,3 +1,3 @@
 module BigML
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

data/spec/integration/dataset_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe BigML::Dataset, :vcr do
 
-  before(:each) do
+  before do
     BigML::Source.delete_all
     BigML::Dataset.delete_all
   end
@@ -10,59 +10,57 @@ describe BigML::Dataset, :vcr do
   describe "no dataset" do
     describe ".all" do
       it "must be empty" do
-        BigML::Dataset.all.should == []
+        expect(BigML::Dataset.all).to eq([])
       end
     end
   end
 
   describe "one dataset" do
-    before do
-      @source = BigML::Source.create("spec/fixtures/iris.csv")
-      @dataset = BigML::Dataset.create(@source.resource)
-    end
+    let(:source) { BigML::Source.create "spec/fixtures/iris.csv" }
+    let(:dataset) { BigML::Dataset.create source.resource }
 
     it "was created successfully" do
-      @dataset.code.should == 201
+      expect(dataset.code).to eq(201)
     end
 
     it "must have only one item" do 
-      BigML::Dataset.all.should have(1).datasets
+      expect(BigML::Dataset.all.length).to eq(1)
     end
 
     it "must have the same file_name" do
-      BigML::Dataset.all.first.size.should == 4608
+      expect(BigML::Dataset.all.first.size).to eq(4608)
     end
 
     it "must be able to be find using the reference" do
-      BigML::Dataset.find(@dataset.id) == @dataset
+      expect(BigML::Dataset.find(dataset.id).id).to eq(dataset.id)
     end
 
     it "must be able to update the name" do
-      BigML::Dataset.update(@dataset.id, { :name => 'foo name' }).code.should == 202
-      BigML::Dataset.find(@dataset.id).name.should == 'foo name'
+      expect(BigML::Dataset.update(dataset.id, { name: 'foo name' }).code).to eq(202)
+      expect(BigML::Dataset.find(dataset.id).name).to eq('foo name')
     end
 
     it "must be able to update the name from the instance" do
-      @dataset.update(:name => 'foo name').code.should == 202
-      BigML::Dataset.find(@dataset.id).name.should == 'foo name'
+      expect(dataset.update(name: 'foo name').code).to eq(202)
+      expect(BigML::Dataset.find(dataset.id).name).to eq('foo name')
     end
 
     it "must be able to be deleted using the destroy method" do
-      dataset_id = @dataset.id
-      @dataset.destroy
-      BigML::Dataset.find(dataset_id).should be_nil
+      dataset_id = dataset.id
+      dataset.destroy
+      expect(BigML::Dataset.find(dataset_id)).to be_nil
     end
 
     it "must be able to remove the dataset" do
-      BigML::Dataset.delete(@dataset.id)
-      BigML::Dataset.find(@dataset.id).should be_nil
-      BigML::Dataset.all.should have(0).datasets
+      BigML::Dataset.delete(dataset.id)
+      expect(BigML::Dataset.find(dataset.id)).to be_nil
+      expect(BigML::Dataset.all.length).to eq(0)
     end
 
     it "can be converted in a model" do
-      model = @dataset.to_model
-      model.instance_of?(BigML::Model).should be_true
-      model.code.should == 201
+      model = dataset.to_model
+      expect(model).to be_instance_of(BigML::Model)
+      expect(model.code).to eq(201)
     end
   end
 end

data/spec/integration/ensemble_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe BigML::Ensemble, :vcr do
+
+  before do
+    BigML::Source.delete_all
+    BigML::Dataset.delete_all
+    BigML::Ensemble.delete_all
+  end
+
+  describe "no ensemble" do
+    describe ".all" do
+      it "must be empty" do
+        expect(BigML::Ensemble.all).to eq([])
+      end
+    end
+  end
+
+  describe "one ensemble" do
+    let(:source) { BigML::Source.create 'spec/fixtures/iris.csv' }
+    let(:dataset) { BigML::Dataset.create source.wait_for_ready.resource }
+    let!(:ensemble) { BigML::Ensemble.create dataset.wait_for_ready.resource, number_of_models: 2 }
+
+    it "was created successfully" do
+      expect(ensemble.code).to eq(201)
+    end
+
+    it "must have only one item" do
+      expect(BigML::Ensemble.all.length).to eq(1)
+    end
+
+    it "must have the same size" do
+      expect(BigML::Ensemble.all.first.size).to eq(9216)
+    end
+
+    it "must be able to set number of models" do
+      BigML::Ensemble.create dataset.wait_for_ready.resource, number_of_models: 3
+      expect(BigML::Ensemble.all.first.number_of_models).to eq(3)
+    end
+
+    it "must be able to be find using the reference" do
+      expect(BigML::Ensemble.find(ensemble.id).id).to eq(ensemble.id)
+    end
+
+    it "must be able to update the name" do
+      expect(BigML::Ensemble.update(ensemble.wait_for_ready.id, { name: 'foo name' }).code).to eq(202)
+      expect(BigML::Ensemble.find(ensemble.id).name).to eq('foo name')
+    end
+
+    it "must be able to update the name from the instance" do
+      expect(ensemble.wait_for_ready.update(name: 'foo name').code).to eq(202)
+      expect(BigML::Ensemble.find(ensemble.id).name).to eq('foo name')
+    end
+
+    it "must be able to remove the ensemble" do
+      BigML::Ensemble.delete ensemble.wait_for_ready.id
+      expect(BigML::Ensemble.find ensemble.id).to be_nil
+      expect(BigML::Ensemble.all.length).to eq(0)
+    end
+
+    it "must be able to be deleted using the destroy method" do
+      ensemble_id = ensemble.id
+      ensemble.wait_for_ready.destroy
+      expect(BigML::Ensemble.find ensemble_id).to be_nil
+    end
+
+    it "can be converted in a prediction" do
+      prediction = ensemble.wait_for_ready.to_prediction(input_data: { "000001" => 3 })
+      expect(ensemble).to be_instance_of(BigML::Ensemble)
+      expect(ensemble.code).to eq(201)
+    end
+  end
+end