nexosis_api 1.4.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8f386ea632449db904147f0f38b1fbb113633ef
-  data.tar.gz: c6afea0f24270d210be6fea0efa8e8e99be6b6fb
+  metadata.gz: 98e972055cf506f2a4e54483c50f57605ade5992
+  data.tar.gz: f9da5b974d540d66e589c8f09a5df16a10ff9d81
 SHA512:
-  metadata.gz: 27fcb7d85fe04fb158a52e2c1dc76f438f4bd8b71380b5d8410cd264081086b4038dc2010dc82ba5a84d5fcc46ce95d3a9836699d993997f243207263f794130
-  data.tar.gz: 88e9204cdfc9fd40e5ee0532acda9a56c7eb73677c301feb47a47886a0909e8a358fb9aa7fdf726992d6874a461a525901111f4a3db7dfc0a599268c37d0cbbb
+  metadata.gz: 9f763f8f98fd480d8d84e2b77ace7d8097f426ff003fc1e5bb01ad114306792ab589ef147e297e7a1684ef1ebec5e602f45c5daf5c3f9a1204ab6f78b07452bc
+  data.tar.gz: ea5d25a7bc0502c59ac958c26af5d170e80a0ee6fa5389e395a61fed7e1e2b1cbccd6c209c44fb0b70420233156167c0b37f7497f4e272450d0f25f869d5dbd2

data/lib/nexosis_api/algorithm_contestant.rb

@@ -0,0 +1,43 @@
+module NexosisApi
+  # Class to parse results of an algorithm run
+  # @since 2.0.0
+  class AlgorithmContestant
+    def initialize(contestant_hash)
+      contestant_hash.each do |k, v|
+        if k.to_s == 'links'
+          instance_variable_set("@#{k}", v.map { |l| NexosisApi::Link.new(l) unless l.nil? })
+        elsif k.to_s == 'dataSourceProperties'
+          @datasource_properties = v
+        elsif k.to_s == 'algorithm'
+          instance_variable_set("@#{k}", NexosisApi::Algorithm.new(v)) unless v.nil?
+        else
+          instance_variable_set("@#{k}", v)
+        end
+      end
+    end
+
+    # Unique identifier for this contestant
+    attr_reader :id
+
+    # Identifier of algorithm run
+    # @return [NexosisApi::Algorithm]
+    attr_accessor :algorithm
+
+    # Name and value for metrics calculated for this algorithm
+    # @return [Hash]
+    attr_accessor :metrics
+
+    # Relevant hypermedia as {NexosisApi::Link}
+    # @return [Array]
+    attr_accessor :links
+
+    # Operations performed on datasource prior to run
+    # @return [Array]
+    attr_reader :datasource_properties
+
+    # The test dataset used to score the algo
+    # @return [Array of Hash] columnname: value hash of each observation row in test set
+    # @note - may be nil when reviewing contestant lists
+    attr_reader :data
+  end
+end

data/lib/nexosis_api/client.rb

@@ -1,5 +1,4 @@
-require 'nexosis_api/algorithm_run'
-require 'nexosis_api/algorithm_selection'
+require 'nexosis_api/algorithm_contestant'
 require 'nexosis_api/algorithm'
 require 'nexosis_api/calendar_jointarget'
 require 'nexosis_api/classifier_result'
@@ -21,12 +20,15 @@ require 'nexosis_api/metric'
 require 'nexosis_api/model_summary'
 require 'nexosis_api/paged_array'
 require 'nexosis_api/predict_response'
+require 'nexosis_api/session_contest'
 require 'nexosis_api/session_response'
 require 'nexosis_api/session_result'
+require 'nexosis_api/session_selection_metrics'
 require 'nexosis_api/session'
 require 'nexosis_api/time_interval'
 require 'nexosis_api/view_definition'
 require 'nexosis_api/view_data'
+require 'nexosis_api/client/contest'
 require 'nexosis_api/client/sessions'
 require 'nexosis_api/client/datasets'
 require 'nexosis_api/client/imports'
@@ -43,6 +45,7 @@ module NexosisApi
     include Client::Imports
     include Client::Views
     include Client::Models
+    include Client::Contest
 
     def initialize(options = {})
       raise ArgumentError, 'api_key was not defined' unless options[:api_key].nil? == false
@@ -53,15 +56,22 @@ module NexosisApi
       @options = { headers: @headers, format: :json }
     end
 
-    # Gets the current account balance.
+    # Gets the quota stats for the account
     #
-    # @return [String] a string with the numeric balance and currency identifier postfix - 10.0 USD
-    # @example Get account balance
-    #   client.get_account_balance
-    def get_account_balance()
-      session_url = '/sessions'
+    # @return [Hash] a hash of quota values and current values
+    def get_account_quotas()
+      session_url = '/sessions?page=0&pageSize=1'
       response = self.class.get(session_url, @options)
-      response.headers['nexosis-account-balance']
+      response.headers.select { |k, _v| k.to_s.start_with? 'nexosis-account' }
+    end
+
+    # Provide access to read or modify the api key
+    # @return [String]
+    # @since 2.0.0
+    def api_key(value)
+      @api_key = value unless value.nil?
+      @headers['api-key'] = @api_key
+      @api_key
     end
 
     private

data/lib/nexosis_api/client/contest.rb

@@ -0,0 +1,66 @@
+module NexosisApi
+  class Client
+    # Session Contest-based API operations
+    #
+    # @see http://docs.nexosis.com/
+    # @since 2.0.0
+    module Contest
+
+      # @return [NexosisApi::SessionContest]
+      def get_session_contest(session_id)
+        raise ArgumentError, 'session_id was not provided and is not optional ' if session_id.to_s.empty?
+        contest_url = "/sessions/#{session_id}/contest"
+        response = self.class.get(contest_url, headers: @headers)
+        raise HttpException.new("There was a problem getting session contest #{response.code}.",
+                                "getting contest for #{session_id}",
+                                response) unless response.success?
+        NexosisApi::SessionContest.new(response.parsed_response)
+      end
+
+      # @return [NexosisApi::AlgorithmContestant]
+      def get_contest_champion(session_id)
+        raise ArgumentError, 'session_id was not provided and is not optional ' if session_id.to_s.empty?
+        champion_url = "/sessions/#{session_id}/contest/champion"
+        response = self.class.get(champion_url, headers: @headers)
+        raise HttpException.new("There was a problem getting session champion #{response.code}.",
+                                "getting champion for #{session_id}",
+                                response) unless response.success?
+        NexosisApi::AlgorithmContestant.new(response.parsed_response)
+      end
+
+      # @return [Array of NexosisApi::AlgorithmContestant]
+      def get_contestants(session_id)
+        raise ArgumentError, 'session_id was not provided and is not optional ' if session_id.to_s.empty?
+        contestants_url = "/sessions/#{session_id}/contest/contestants"
+        response = self.class.get(contestants_url, headers: @headers)
+        raise HttpException.new("There was a problem getting session contestants #{response.code}.",
+                                "getting contestants for #{session_id}",
+                                response) unless response.success?
+        response.parsed_response['items'].map { |c| NexosisApi::AlgorithmContestant.new(c) }
+      end
+
+      # @return [NexosisApi::AlgorithmContestant]
+      def get_contestant_results(session_id, contestant_id)
+        raise ArgumentError, 'session_id was not provided and is not optional ' if session_id.to_s.empty?
+        raise ArgumentError, 'contestant_id was not provided and is not optional ' if contestant_id.to_s.empty?
+        contestant_url = "/sessions/#{session_id}/contest/contestants/#{contestant_id}"
+        response = self.class.get(contestant_url, headers: @headers)
+        raise HttpException.new("There was a problem getting session contestant result #{response.code}.",
+                                "getting contestant result for #{session_id}:#{contestant_id}",
+                                response) unless response.success?
+        NexosisApi::AlgorithmContestant.new(response.parsed_response)
+      end
+
+      # @return [NexosisApi::SessionSelectionMetrics]
+      def get_selection_metrics(session_id)
+        raise ArgumentError, 'session_id was not provided and is not optional ' if session_id.to_s.empty?
+        selection_url = "/sessions/#{session_id}/contest/selection"
+        response = self.class.get(selection_url, headers: @headers)
+        raise HttpException.new("There was a problem getting session selection metrics #{response.code}.",
+                                "getting selection metrics for #{session_id}",
+                                response) unless response.success?
+        NexosisApi::SessionSelectionMetrics.new(response.parsed_response)
+      end
+    end
+  end
+end

data/lib/nexosis_api/client/imports.rb

@@ -36,10 +36,12 @@ module NexosisApi
       # @param bucket_name [String] the AWS S3 bucket name in which the path will be found
       # @param path [String] the path within the bucket (usually file name)
       # @param region [String] the region in which your bucket exists. Defaults to us-east-1
+      # @param credentials [Hash] :access_key_id and :secret_access_key for user with rights to read the target file.
       # @param column_metadata [Array of NexosisApi::Column] description of each column in target dataset. Optional.
       # @return [NexosisApi::ImportsResponse]
       # @see http://docs.aws.amazon.com/general/latest/gr/rande.html#s3_region for information on region names
-      def import_from_s3(dataset_name, bucket_name, path, region = 'us-east-1', column_metadata = [])
+      # @note If credentials are provided they will be encrypted at the server, used once, and then removed from storage.
+      def import_from_s3(dataset_name, bucket_name, path, region = 'us-east-1', credentials = {}, column_metadata = [])
         raise ArgumentError, 'dataset_name was not provided and is not optional ' unless dataset_name.to_s.empty? == false
         raise ArgumentError, 'bucket_name was not provided and is not optional ' unless bucket_name.to_s.empty? == false
         raise ArgumentError, 'path was not provided and is not optional ' unless path.to_s.empty? == false
@@ -52,29 +54,87 @@ module NexosisApi
           'region' => region,
           'columns' => column_json
         }
+        body['accessKeyId'] = credentials[:access_key_id] unless credentials.nil? || credentials[:access_key_id].nil?
+        body['secretAccessKey'] = credentials[:secret_access_key] unless credentials.nil? || credentials[:secret_access_key].nil?
         response = self.class.post(s3_import_url, headers: @headers, body: body.to_json)
-        if (response.success?)
-          NexosisApi::ImportsResponse.new(response.parsed_response)
-        else
-          raise HttpException.new("There was a problem importing from s3: #{response.code}.", "uploading dataset from s3 #{dataset_name}" ,response)
-        end
+        raise HttpException.new("There was a problem importing from s3: #{response.code}.",
+                                "uploading dataset from s3 #{dataset_name}",
+                                response) unless response.success?
+        NexosisApi::ImportsResponse.new(response.parsed_response)
       end
 
-      # Get s3 response back from import created previously. Presumably to check status.
+      # Get response back from import created previously. Presumably to check status.
       #
       # @param import_id [String] The id returned from a previous request to import
       # @return [NexosisApi::ImportsResponse]
-      # @example get S3 import
+      # @example get import
       #    NexosisApi.client.retrieve_import('740dca2a-b488-4322-887e-fa473b1caa54')
       def retrieve_import(import_id)
         raise ArgumentError, 'import_id was not provided and is not optional ' unless import_id.to_s.empty? == false
         imports_url = "/imports/#{import_id}"
         response = self.class.get(imports_url, headers: @headers)
-        if (response.success?)
-          NexosisApi::ImportsResponse.new(response.parsed_response)
-        else
-          raise HttpException.new("There was a problem getting the import #{response.code}.", "requesting an import #{import_id}" ,response)
-        end
+        raise HttpException.new("There was a problem getting the import #{response.code}.",
+                                "requesting an import #{import_id}", response) unless response.success?
+        NexosisApi::ImportsResponse.new(response.parsed_response)
+      end
+
+      # Import a csv, json file (gzip'd or raw) from a Microsoft Azure storage blob
+      #
+      # @param dataset_name [String] the name to give to the new dataset or existing dataset to which this data will be upserted
+      # @param connection_string [String] the azure blob storage connection string providing access to the file resource
+      # @param container [String] the container in which the object is located.
+      # @param blob_name [String] the name of the object to import, usually a file. Always csv or json content.
+      # If folders have been used this will contain the full path within the container.
+      # @param column_metadata [Array of NexosisApi::Column] description of each column in target dataset. Optional.
+      # @return [NexosisApi::ImportsResponse]
+      # @since 2.0.0
+      # @note the connection string provided will be encrypted at the server, used once, and then removed from storage.
+      def import_from_azure(dataset_name, connection_string, container, blob_name, column_metadata = [])
+        raise ArgumentError, 'dataset_name was not provided and is not optional ' unless dataset_name.empty? == false
+        raise ArgumentError, 'connection_string was not provided and is not optional ' unless connection_string.empty? == false
+        raise ArgumentError, 'container was not provided and is not optional ' unless container.empty? == false
+        raise ArgumentError, 'blob_name was not provided and is not optional ' unless blob_name.empty? == false
+        azure_url = '/imports/azure'
+        column_json = Column.to_json(column_metadata)
+        body = {
+          'dataSetName' => dataset_name,
+          'connectionString' => connection_string,
+          'container' => container,
+          'blob' => blob_name,
+          'columns' => column_json
+        }
+        response = self.class.post(azure_url, headers: @headers, body: body.to_json)
+        raise HttpException.new("There was a problem importing from azure: #{response.code}.",
+                                "uploading dataset from azure #{dataset_name}",
+                                response) unless response.success?
+        NexosisApi::ImportsResponse.new(response.parsed_response)
+      end
+
+      # Import a csv or json file directly from any avaiable and reachable public endpoint.
+      #
+      # @param dataset_name [String] the name to give to the new dataset or existing dataset to which this data will be upserted
+      # @param url [String] the url indicating where to find the file resource to import
+      # @param column_metadata [Array of NexosisApi::Column] description of each column in target dataset. Optional.
+      # @param options [Hash] may provide basic auth credentials or a 'content-type' value to identify csv or json content.
+      # @return [NexosisApi::ImportsResponse]
+      # @note imports depend on file extensions, so use a content type indicator if json or csv cannot be inferred.
+      # @note Urls protected by basic auth can be accessed if given a userid and password in options
+      # @since 2.0.0
+      def import_from_url(dataset_name, url, column_metadata = [], options = {})
+        raise ArgumentError, 'dataset_name was not provided and is not optional ' unless dataset_name.empty? == false
+        raise ArgumentError, 'url was not provided and is not optional ' unless url.empty? == false
+        endpoint_url = '/imports/url'
+        column_json = Column.to_json(column_metadata)
+        body = {
+          'dataSetName' => dataset_name,
+          'url' => url,
+          'columns' => column_json
+        }
+        response = self.class.post(endpoint_url, headers: @headers, body: body.to_json)
+        raise HttpException.new("There was a problem importing from url: #{response.code}.",
+                                "uploading dataset from #{url}",
+                                response) unless response.success?
+        NexosisApi::ImportsResponse.new(response.parsed_response)
       end
     end
   end

data/lib/nexosis_api/client/sessions.rb

@@ -78,19 +78,7 @@ module NexosisApi
       #    For instance if your data includes many recoreds per hour, then you could request hour, day, or any other result interval.
       #    However, if your data includes only a few records per day or fewer, then a request for an hourly result interval will produce poor results.
       def create_forecast_session(dataset_name, start_date, end_date, target_column = nil, result_interval = NexosisApi::TimeInterval::DAY, column_metadata = nil)
-        create_session(dataset_name, start_date, end_date, target_column, false, nil, 'forecast', result_interval, column_metadata)
-      end
-
-      # Estimate the cost of a forecast from data already saved to the API.
-      #
-      # @param dataset_name [String] The name of the saved data set that has the data to forecast on.
-      # @param start_date [DateTime] The starting date of the forecast period. Can be ISO 8601 string. 
-      # @param end_date [DateTime] The ending date of the forecast period. Can be ISO 8601 string.
-      # @param target_column [String] The name of the column for which you want predictions. Nil if defined in dataset.
-      # @param result_interval [NexosisApi::TimeInterval] (optional) - The date/time interval (e.g. Day, Hour) at which predictions should be generated. So, if Hour is specified for this parameter you will get a Result record for each hour between startDate and endDate. If unspecified, we’ll generate predictions at a Day interval.
-      # @return [NexosisApi::SessionResponse] providing information about the sesssion, including the cost
-      def estimate_forecast_session(dataset_name, start_date, end_date, target_column = nil, result_interval = NexosisApi::TimeInterval::DAY)
-        create_session(dataset_name, start_date, end_date, target_column, true, nil, 'forecast', result_interval)
+        create_session(dataset_name, start_date, end_date, target_column, nil, 'forecast', result_interval, column_metadata)
       end
 
       # Analyze impact for an event with data already saved to the API.
@@ -104,20 +92,7 @@ module NexosisApi
       # @param column_metadata [Array of NexosisApi::Column] (optional) - specification for how to handle columns if different from existing metadata on dataset 
       # @return [NexosisApi::SessionResponse] providing information about the sesssion
       def create_impact_session(dataset_name, start_date, end_date, event_name, target_column = nil, result_interval = NexosisApi::TimeInterval::DAY, column_metadata = nil)
-        create_session(dataset_name, start_date, end_date, target_column, false, event_name, 'impact', result_interval, column_metadata)
-      end
-
-      # Estimate the cost of impact analysis for an event with data already saved to the API.
-      #
-      # @param dataset_name [String] The name of the saved data set that has the data to forecast on.
-      # @param start_date [DateTime] The starting date of the impactful event. Can be ISO 8601 string. 
-      # @param end_date [DateTime] The ending date of the impactful event. Can be ISO 8601 string.
-      # @param event_name [String] The name of the event.
-      # @param target_column [String] The name of the column for which you want predictions. Nil if defined in dataset.
-      # @param result_interval [NexosisApi::TimeInterval] (optional) - The date/time interval (e.g. Day, Hour) at which predictions should be generated. So, if Hour is specified for this parameter you will get a Result record for each hour between startDate and endDate. If unspecified, we’ll generate predictions at a Day interval.
-      # @return [NexosisApi::SessionResponse] providing information about the sesssion, including the cost
-      def estimate_impact_session(dataset_name, start_date, end_date, event_name, target_column = nil, result_interval = NexosisApi::TimeInterval::DAY)
-        create_session(dataset_name, start_date, end_date, target_column, true, event_name, 'impact', result_interval)
+        create_session(dataset_name, start_date, end_date, target_column, event_name, 'impact', result_interval, column_metadata)
       end
 
       # Get the results of the session.
@@ -157,7 +132,7 @@ module NexosisApi
       # @param datasource_name [String] The datasource from which to build the model
       # @param target_column [String] The column which will be predicted when using the model
       # @param columns [Hash] column metadata to modify roles, imputation, or target.
-      # @param options [Hash] prediction_domain and or balanced indicator for classification
+      # @param options [Hash] prediction_domain and or balance (true or false) indicator for classification
       # @note - classifcation assumes balanced classes. The use of a 'balanced=false' option
       # indicates that no attempt should be made to sample the classes in balanced fashion.
       # @since 1.3.0
@@ -166,10 +141,9 @@ module NexosisApi
         body = {
           dataSourceName: datasource_name,
           targetColumn: target_column,
-          predictionDomain: options[:prediction_domain].downcase,
-          isEstimate: false
+          predictionDomain: options[:prediction_domain].downcase
         }
-        body.store(:balance, options[:balance]) if options.include?(:balance) && body[:predictionDomain] == 'classification'
+        body.store(:extraParameters, { balance: options[:balance] }) if options.include?(:balance) && body[:predictionDomain] == 'classification'
         body.store(columns: columns) unless columns.empty?
         response = self.class.post(model_url, headers: @headers, body: body.to_json)
         if response.success?
@@ -195,13 +169,12 @@ module NexosisApi
       private
 
       # @private
-      def create_session(dataset_name, start_date, end_date, target_column = nil, is_estimate=false, event_name = nil, type = 'forecast', result_interval = NexosisApi::TimeInterval::DAY, column_metadata = nil)
+      def create_session(dataset_name, start_date, end_date, target_column = nil, event_name = nil, type = 'forecast', result_interval = NexosisApi::TimeInterval::DAY, column_metadata = nil)
         session_url = "/sessions/#{type}"
         query = {
           'targetColumn' => target_column.to_s,
           'startDate' => start_date.to_s,
           'endDate' => end_date.to_s,
-          'isestimate' => is_estimate.to_s,
           'resultInterval' => result_interval.to_s
         }
         query['dataSetName'] = dataset_name.to_s unless dataset_name.to_s.empty?

data/lib/nexosis_api/imports_response.rb

@@ -30,7 +30,7 @@ module NexosisApi
     # @return [String]
     attr_accessor :import_id
 
-    # Currently always s3
+    # Where the import was requested from - S3, Azure, or Url
     # @return [String]
     attr_accessor :type, :s3 
     

data/lib/nexosis_api/metric.rb

@@ -1,20 +1,15 @@
 module NexosisApi
   # Class to parse algorithm metrics from model results
   class Metric
-    def initialize(metric_hash)
-      metric_hash.each do |k, v|
-        instance_variable_set("@#{k}", v) unless v.nil?
-      end
+    def initialize(name, value)
+      @name = name
+      @value = value
     end
 
     # Friendly name of the metric
     # @return [String]
     attr_accessor :name
 
-    # Identifier for metric type
-    # @return [String]
-    attr_accessor :code
-
     # Calculated metric
     # @return [Float]
     attr_accessor :value

data/lib/nexosis_api/model_summary.rb

@@ -23,7 +23,7 @@ module NexosisApi
         elsif (k == 'metrics')
           @metrics = v.reject { |_key, value| value.nil? }
                       .map do |col_key, col_val|
-                        NexosisApi::Metric.new(name: col_key, value: col_val)
+                        NexosisApi::Metric.new(col_key, col_val)
                       end
         elsif (k == 'sessionId')
           @session_id = v

data/lib/nexosis_api/session.rb

@@ -9,7 +9,10 @@ module NexosisApi
                   'availablePredictionIntervals' => :@prediction_intervals,
                   'startDate' => :@start_date,
                   'endDate' => :@end_date,
-                  'predictionDomain' => :@prediction_domain }
+                  'predictionDomain' => :@prediction_domain,
+                  'extraParameters' => :@extra_parameters,
+                  'targetColumn' => :@target_column,
+                  'statusHistory' => :@status_history }
       session_hash.each do |k, v|
         if (k == 'links')
           @links = v.map { |l| NexosisApi::Link.new(l) }
@@ -25,15 +28,10 @@ module NexosisApi
         else
           instance_variable_set("@#{k}", v) unless v.nil?
         end
-        instance_variable_set(val_map[k], v) unless val_map[k].nil?
+        instance_variable_set(val_map[k.to_s], v) unless val_map[k.to_s].nil?
       end
     end
 
-    # identifier for this sesssion
-    # @return [String]
-    # @deprecated use session_id instead
-    attr_accessor :sessionId
-
     # identifier for this sesssion
     # @return [String]
     # @since 1.4.0
@@ -43,36 +41,23 @@ module NexosisApi
     # @return [String]
     attr_accessor :type
 
-    # Is this session requested, estimated, started, or completed
+    # Is this session requested, started, or completed
     # @return [String]
     attr_accessor :status
 
     # Date and status of each status this session has entered
-    # @return [Hash]
-    attr_accessor :statusHistory
+    # @return [Array of Hash]
+    # @note - each status object in array is form { date: 'date', status: 'status' }
+    attr_accessor :status_history
 
     # reserved for future extensions
     # @return [Hash]
-    attr_accessor :extraParameters
-    
-    # the dataset used in this session
-    # @return [String]
-    # @deprecated - Use the @datasource_name property instead
-    attr_accessor :dataSetName
+    # @note - included 'balance' parameter for classification models
+    attr_accessor :extra_parameters
 
     # The column in the dataset for which this session ran predictions
     # @return [String]
-    attr_accessor :targetColumn
-
-    # The start date of analysis in this session
-    # @return [DateTime]
-    # @deprecated use start_date instead
-    attr_accessor :startDate
-
-    # The end date of analysis in this session
-    # @return [DateTime]
-    # @deprecated use end_date instead
-    attr_accessor :endDate
+    attr_accessor :target_column
 
     # The start date of analysis in this session
     # @return [DateTime]
@@ -88,10 +73,6 @@ module NexosisApi
     # @return [Array of NexosisApi::Link]
     attr_accessor :links
 
-    # Is this session an estimate only session
-    # @return [Boolean]
-    attr_accessor :is_estimate
-
     # The column descriptors for the data in this session
     #    will reflect either the metadata sent in, defaults form dataset, or inferred values
     # @return[Array of NexosisApi::Column]
@@ -133,11 +114,5 @@ module NexosisApi
     # A list of warning or error messages optionally returned from session
     # @return [Array of Message]
     attr_accessor :messages
-
-    # Whether classes were sampled as balanced in the context of a classification model
-    # @return [Boolean]
-    # @note - the default is true and has no means outside of classification
-    # @since 1.4.1
-    attr_accessor :balance
   end
 end

data/lib/nexosis_api/session_contest.rb

@@ -0,0 +1,30 @@
+module NexosisApi
+  # Class to parse the algorithm contestants from a session
+  # @since 2.0.0
+  class SessionContest < Session
+    def initialize(contest_hash)
+      contest_hash.each do |k, v|
+        if k.to_s == 'champion'
+          instance_variable_set("@#{k}", NexosisApi::AlgorithmContestant.new(v))
+        elsif k.to_s == 'contestants'
+          instance_variable_set("@#{k}", v.map { |c| NexosisApi::AlgorithmContestant.new(c) })
+        elsif k.to_s == 'championMetric'
+          @champion_metric = v
+        end
+      end
+      super(contest_hash.reject { |key, _v| key == 'champion' || key == 'contestants' })
+    end
+
+    # The champion algorithm used
+    # @return [NexosisApi::AlgorithmContestant]
+    attr_accessor :champion
+
+    # All other algorithms which competed
+    # @return [Array of NexosisApi::AlgorithmContestant]
+    attr_accessor :contestants
+
+    # Name of metric used to determine champion algorithm
+    # @return [String] metric name
+    attr_accessor :champion_metric
+  end
+end

data/lib/nexosis_api/session_response.rb

@@ -1,28 +1,33 @@
 require 'nexosis_api/session'
 
 module NexosisApi
-  #Class to parse the results from a new session
+  # Class to parse the results from a new session
   class SessionResponse < Session
     def initialize(forecast_hash)
+      val_map = {
+        'Nexosis-Account-DataSetCount-Allotted' => :@datasets_allotted,
+        'Nexosis-Account-DataSetCount-Current' => :@datasets_current,
+        'Nexosis-Account-PredictionCount-Allotted' => :@predictions_allotted,
+        'Nexosis-Account-PredictionCount-Current' => :@predictions_current,
+        'Nexosis-Account-SessionCount-Allotted' => :@sessions_allotted,
+        'Nexosis-Account-SessionCount-Current' => :@sessions_current
+      }
       forecast_hash.each do |k, v|
-        if(k == 'session')
+        if (k == 'session')
           super(v) unless v.nil?
-        elsif(k == 'nexosis-request-cost')
-          instance_variable_set('@cost', v[0]) unless v.nil?
-        elsif(k == 'nexosis-account-balance')
-          instance_variable_set('@account_balance', v[0]) unless v.nil?
-        elsif(k == 'balance')
-          @balance = v
+        else
+          instance_variable_set(val_map[k], v) unless val_map[k].nil?
         end
       end
     end
 
-    # The cost of this session with currency identifier
-    # @return [String]
-    attr_accessor :cost
-
-    # Remaining balance after charge for this session
-    # @return [String]
-    attr_accessor :account_balance
+    attr_reader :datasets_allotted
+    attr_reader :datasets_allotted
+    attr_reader :datasets_current
+    attr_reader :predictions_allotted
+    attr_reader :predictions_current
+    attr_reader :sessions_allotted
+    attr_reader :sessions_current
+    
   end
 end

data/lib/nexosis_api/session_result.rb

@@ -6,7 +6,7 @@ module NexosisApi
         if k.to_s == 'metrics' && session_hash['type'] == 'impact'
           instance_variable_set("@#{k}", NexosisApi::ImpactMetric.new(v)) unless v.nil?
         elsif k.to_s == 'metrics'
-          @metrics = v.map { |key, value| NexosisApi::Metric.new( { 'name' => key.to_s, 'value' => value } ) } unless v.nil?
+          @metrics = v.map { |key, value| NexosisApi::Metric.new(key.to_s, value) } unless v.nil?
         elsif k.to_s == 'data'
           @data = v
         end

data/lib/nexosis_api/session_selection_metrics.rb

@@ -0,0 +1,21 @@
+module NexosisApi
+  # Class to parse the session selection metrics from a particular session
+  # @since 2.0.0
+  class SessionSelectionMetrics < Session
+    def initialize(metrics_hash)
+      if !metrics_hash['metricSets'].nil?
+        @dataset_properties = metrics_hash['metricSets'][0]['dataSetProperties'] unless metrics_hash['metricSets'][0]['dataSetProperties'].nil?
+        @metrics = metrics_hash['metricSets'][0]['metrics'] unless metrics_hash['metricSets'][0]['metrics'].nil?
+      end
+      super(metrics_hash.reject { |k, _v| k == 'metricSets' })
+    end
+
+    # transformations performed on dataset prior to algorithm run
+    # @return [Array] string list of transformations
+    attr_reader :dataset_properties
+
+    # dataset metrics describing some properties of it
+    # @return [Hash] name value pairs of dataset metrics
+    attr_reader :metrics
+  end
+end

data/nexosisapi.gemspec

@@ -16,6 +16,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.required_ruby_version = '>= 2.0.0'
   spec.summary = "Ruby client for working with the Nexosis API"
-  spec.version = '1.4.1'
+  spec.version = '2.0.0'
   spec.metadata["yard.run"] = "yri"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nexosis_api
 version: !ruby/object:Gem::Version
-  version: 1.4.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Nexosis,Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-20 00:00:00.000000000 Z
+date: 2017-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -47,11 +47,11 @@ extra_rdoc_files: []
 files:
 - lib/nexosis_api.rb
 - lib/nexosis_api/algorithm.rb
-- lib/nexosis_api/algorithm_run.rb
-- lib/nexosis_api/algorithm_selection.rb
+- lib/nexosis_api/algorithm_contestant.rb
 - lib/nexosis_api/calendar_jointarget.rb
 - lib/nexosis_api/classifier_result.rb
 - lib/nexosis_api/client.rb
+- lib/nexosis_api/client/contest.rb
 - lib/nexosis_api/client/datasets.rb
 - lib/nexosis_api/client/imports.rb
 - lib/nexosis_api/client/models.rb
@@ -76,8 +76,10 @@ files:
 - lib/nexosis_api/paged_array.rb
 - lib/nexosis_api/predict_response.rb
 - lib/nexosis_api/session.rb
+- lib/nexosis_api/session_contest.rb
 - lib/nexosis_api/session_response.rb
 - lib/nexosis_api/session_result.rb
+- lib/nexosis_api/session_selection_metrics.rb
 - lib/nexosis_api/time_interval.rb
 - lib/nexosis_api/view_data.rb
 - lib/nexosis_api/view_definition.rb

data/lib/nexosis_api/algorithm_run.rb

@@ -1,32 +0,0 @@
-module NexosisApi
-  # Class to parse results of an algorithm run
-  class AlgorithmRun
-    def initialize(run_hash)
-      run_hash.each do |k, v|
-        if k == 'metrics'
-          metric_set = []
-          v.each { |m| metric_set << NexosisApi::Metric.new(m) unless m.nil? }
-          instance_variable_set("@#{k}", metric_set)
-        elsif k == 'links'
-          link_set = []
-          v.each { |l| link_set << NexosisApi::Link.new(l) unless l.nil? }
-          instance_variable_set("@#{k}", link_set)
-        else
-          instance_variable_set("@#{k}", NexosisApi::Algorithm.new(v)) unless v.nil?
-        end
-      end
-    end
-
-    # Identifier of algorithm run
-    # @return [NexosisApi::Algorithm]
-    attr_accessor :algorithm        
-
-    # Set of {NexosisApi::Metric} on algorithm
-    # @return [Array]
-    attr_accessor :metrics
-
-    # Relevant hypermedia as {NexosisApi::Link}
-    # @return [Array]
-    attr_accessor :links
-  end
-end

data/lib/nexosis_api/algorithm_selection.rb

@@ -1,34 +0,0 @@
-module NexosisApi
-  # Class to parse the model data results from a session 
-  class AlgorithmSelection
-    def initialize(data_hash)
-      data_hash.each do |k, v|
-        if k == 'champion'
-          instance_variable_set("@#{k}", NexosisApi::AlgorithmRun.new(v))
-        elsif k == 'contestants'
-          contestant_array = []
-          v.each { |c| contestant_array << NexosisApi::AlgorithmRun.new(c) }
-          instance_variable_set("@#{k}", contestant_array)
-        else
-          instance_variable_set("@#{k}", v) unless v.nil?
-        end
-      end
-    end
-
-    # The date on which this algo was selected as champion
-    # @return [DateTime]
-    attr_accessor :date
-
-    # The session which selected the algorithm
-    # @return [String] session identifier
-    attr_accessor :sessionId
-
-    # The champion algorithm used
-    # @return [NexosisApi::AlgorithmRun]
-    attr_accessor :champion
-
-    # All other algorithms which competed
-    # @return [Array of NexosisApi::AlgorithmRun]
-    attr_accessor :contestants
-  end
-end