nexosis_api 1.2.4 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 98843ea8efaca93ca14c66a6f8babdc8769992d7
-  data.tar.gz: 426cdb0bcc87d9abeb21a6a4c9526e88d075e78e
+  metadata.gz: 05cf5a6d76290c17f23d0db1e00a5d9215dfc56c
+  data.tar.gz: e28cbae30ef33132f250eb200efe6545eb46091b
 SHA512:
-  metadata.gz: 3eabe9f10de72d8634aab044c866d9a878809c04fdb3f3f428b84bb8b5a1c2e394ca12a25288a3481fe62e20e110a2a3f37cf16d8e0dd76f3babf857423d99f5
-  data.tar.gz: 81e486c7cf604819e2350041f9cf19408beab4248e646821c3f46ff5913d5f299be57f5bcc5fba9209794ebdaeac5882e656007803523d620e62ddfe2bc6719e
+  metadata.gz: b17a834985acaa28a81bf3ecb2e7874b03adfd40907b9df3698b324b334bd8e0c1d51fb103cf8c521d7523d23b32c2c014392a3e0ae27689f55b48ec9a4b90ef
+  data.tar.gz: 06de1a773837de420b6a41cb24c32b41a50e007cdfd1eaccd2916fd18d7102448c7ea4b041545d29e1dbbefc98e759d68f9499f072fe15894b3709ad43e40e55

data/lib/nexosis_api/algorithm.rb

@@ -7,6 +7,10 @@ module NexosisApi
       end
     end
 
+    # A unique identififer for the algorithm
+    # @return [String]
+    attr_accessor :key
+
     # A friendly name for the algorithm
     # @return [String]
     attr_accessor :name

data/lib/nexosis_api/client.rb

@@ -16,6 +16,8 @@ require 'nexosis_api/imports_response'
 require 'nexosis_api/join'
 require 'nexosis_api/link'
 require 'nexosis_api/metric'
+require 'nexosis_api/model_summary'
+require 'nexosis_api/predict_response'
 require 'nexosis_api/session_response'
 require 'nexosis_api/session_result'
 require 'nexosis_api/session'
@@ -26,6 +28,7 @@ require 'nexosis_api/client/sessions'
 require 'nexosis_api/client/datasets'
 require 'nexosis_api/client/imports'
 require 'nexosis_api/client/views'
+require 'nexosis_api/client/models'
 
 module NexosisApi
   # Primary entry point to working with Nexosis API
@@ -36,13 +39,15 @@ module NexosisApi
     include Client::Datasets
     include Client::Imports
     include Client::Views
+    include Client::Models
 
     def initialize(options = {})
       raise ArgumentError, 'api_key was not defined' unless options[:api_key].nil? == false
       @api_key = options[:api_key]
       self.class.base_uri options[:base_uri] unless options[:base_uri].nil?
-      @headers = {'api-key' => @api_key, 'Content-Type' => 'application/json'}
-      @options = {headers: @headers, format: :json}
+      @headers = { 'api-key' => @api_key, 'Content-Type' => 'application/json',
+                   'User-Agent' => 'Nexosis-Ruby-API-Client/1.2' }
+      @options = { headers: @headers, format: :json }
     end
 
     # Gets the current account balance.

data/lib/nexosis_api/client/datasets.rb

@@ -34,11 +34,9 @@ module NexosisApi
         list_dataset_url = "/data?partialName=#{partial_name}"
         response = self.class.get(list_dataset_url, headers: @headers)
         if response.success?
-          results = []
-          response.parsed_response['items'].each do |dr|
-            results << NexosisApi::DatasetSummary.new(dr)
+          response.parsed_response['items'].map do |dr|
+            NexosisApi::DatasetSummary.new(dr)
           end
-          results
         else
           raise HttpException.new("There was a problem listing datasets: #{response.code}.", "listing datasets with partial name #{partial_name}", response)
         end
@@ -55,11 +53,8 @@ module NexosisApi
       #    The dates can be used independently and are inclusive. Lack of options returns all values within the given page.
       def get_dataset(dataset_name, page_number = 0, page_size = 50, query_options = {})
         response = get_dataset_internal(dataset_name, page_number, page_size, query_options)
-        if response.success?
-          NexosisApi::DatasetData.new(response.parsed_response)
-        else
-          raise HttpException.new("There was a problem getting the dataset: #{response.code}.", "getting dataset #{dataset_name}", response)
-        end
+        return NexosisApi::DatasetData.new(response.parsed_response) if response.success?
+        raise HttpException.new("There was a problem getting the dataset: #{response.code}.", "getting dataset #{dataset_name}", response)
       end
 
       # Get the data in the set, written to a CSV file, optionally filtering it.
@@ -75,11 +70,8 @@ module NexosisApi
       #    NexosisApi.client.get_dataset_csv('MyDataset', 1, 20, {:include => 'sales'})
       def get_dataset_csv(dataset_name, page_number = 0, page_size = 50, query_options = {})
         response = get_dataset_internal(dataset_name, page_number, page_size, query_options, 'text/csv')
-        if response.success?
-          response.body
-        else
-          raise HttpException.new("There was a problem getting the dataset: #{response.code}.", "getting dataset #{dataset_name}", response)
-        end
+        return response.body if response.success?
+        raise HttpException.new("There was a problem getting the dataset: #{response.code}.", "getting dataset #{dataset_name}", response)
       end
 
       # Remove data from a data set or the entire set.
@@ -92,6 +84,7 @@ module NexosisApi
       #    - cascade_forecast - will cascade deletes to all related forecasts
       #    - cascade_session - will cascade deletes to all related sessions
       #    - cascade_view - will cascade deletes to all related views (any part of join - think twice)
+      #    - cascase_model - will cascade deletes to all models created from this dataset
       #    - cascade - will cascade deletes to all related forecasts and sessions
       # @example - request delete with cascade forecast
       #    NexosisApi.client.remove_dataset('mydataset', {:cascade_forecast => true})
@@ -105,16 +98,13 @@ module NexosisApi
           query['startDate'] = [filter_options[:start_date].to_s] unless filter_options[:start_date].nil?
           query['endDate'] = [filter_options[:end_date].to_s] unless filter_options[:end_date].nil?
         end
-        #normalizer = proc { |query_set| query_set.map { |key, value| value.map { |v| "#{key}=#{v}" } }.join('&') }
+        # normalizer = proc { |query_set| query_set.map { |key, value| value.map { |v| "#{key}=#{v}" } }.join('&') }
         response = self.class.delete(dataset_remove_url,
                                      headers: @headers,
                                      query: query,
                                      query_string_normalizer: ->(query_map) {array_query_normalizer(query_map)})
-        if response.success?
-          return
-        else
-          raise HttpException.new("There was a problem removing the dataset: #{response.code}.", "removing dataset #{dataset_name}", response)
-        end
+        return if response.success?
+        raise HttpException.new("There was a problem removing the dataset: #{response.code}.", "removing dataset #{dataset_name}", response)
       end
 
       private
@@ -146,7 +136,7 @@ module NexosisApi
       # @private
       def create_cascade_options(option_hash)
         return nil if option_hash.nil?
-        return %w[session view forecast] if option_hash.key?(:cascade)
+        return %w[session view forecast model] if option_hash.key?(:cascade)
         options_set = []
         option_hash.each_key { |k| options_set << k.to_s.gsub(/cascade_/, '') if k.to_s.include? 'cascade_' }
         # HACK: required to be backward compatible with incorrect key names

data/lib/nexosis_api/client/imports.rb

@@ -10,16 +10,12 @@ module NexosisApi
       #
       # @return [Array of NexosisApi::ImportsResponse]
       def list_imports
-        imports_url = "/imports"
-        response = self.class.get(imports_url, :headers => @headers)
-        if(response.success?)
-          items = []
-          response.parsed_response["items"].each do |i|
-            items << NexosisApi::ImportsResponse.new(i)
-          end
-          items
+        imports_url = '/imports'
+        response = self.class.get(imports_url, headers: @headers)
+        if (response.success?)
+          response.parsed_response['items'].map { |i| NexosisApi::ImportsResponse.new(i) }
         else
-          raise HttpException.new("There was a problem getting the imports: #{response.code}.", "uploading dataset from s3 #{dataset_name}" ,response)
+          raise HttpException.new("There was a problem getting the imports: #{response.code}.", "uploading dataset from s3 #{dataset_name}", response)
         end
       end
 
@@ -32,21 +28,21 @@ module NexosisApi
       # @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 = [])
-        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
-                s3_import_url = "/imports/s3"
+      def import_from_s3(dataset_name, bucket_name, path, region = 'us-east-1', 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
+        s3_import_url = '/imports/s3'
         column_json = Column.to_json(column_metadata)
         body = {
-          "dataSetName" => dataset_name,
-          "bucket" => bucket_name,
-          "path" => path,
-          "region" => region,
-          "columns" => column_json
+          'dataSetName' => dataset_name,
+          'bucket' => bucket_name,
+          'path' => path,
+          'region' => region,
+          'columns' => column_json
         }
-        response = self.class.post(s3_import_url, :headers => @headers, :body => body.to_json)
-        if(response.success?)
+        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)
@@ -60,10 +56,10 @@ module NexosisApi
       # @example get S3 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
+        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?)
+        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)

data/lib/nexosis_api/client/models.rb

@@ -0,0 +1,107 @@
+module NexosisApi
+  class Client
+    # class to operate on model endpoint in Nexosis API
+    # @since 1.3.0
+    module Models
+      # List all models created in your company, optionally filtered by query parameters
+      #
+      # @param datasource_name [String] optionally limit to those
+      # models created for this data source name.
+      # @param query_options [Hash] limit by dates: begin_date and/or end_date
+      # @note - query options dates can either be ISO 8601 compliant strings or Date objects
+      # @return [Array of NexosisApi::ModelSummary] - all models available within the query parameters
+      def list_models(datasource_name = nil, page = 0, page_size = 50, query_options = {})
+        model_url = '/models'
+        query = {
+          page: page,
+          pageSize: page_size
+        }
+        unless query_options.empty?
+          query.store('createdBeforeDate', query_options['end_date']) unless query_options['end_date'].nil?
+          query.store('createdAfterDate', query_options['begin_date']) unless query_options['begin_date'].nil?
+        end
+        query.store(dataSourceName: datasource_name) unless datasource_name.nil?
+        response = self.class.get(model_url, headers: @headers, query: query)
+        if (response.success?)
+          response.parsed_response['items'].map { |item| NexosisApi::ModelSummary.new(item) }
+        else
+          raise HttpException.new("There was a problem listing models: #{response.code}.", "listing models with data source name #{datasource_name}", response)
+        end
+      end
+
+      # Get the details of the particular model requested by id
+      #
+      # @param model_id [String] The unique identifier for the model returned by a create-model session
+      # @return [NexosisApi::ModelSummary]
+      def get_model(model_id)
+        raise ArgumentError, 'Retrieving a model requires that model_id be specified and it is currently null.' if model_id.nil?
+        model_url = "/models/#{model_id}"
+        response = self.class.get(model_url, @options)
+        if (response.success?)
+          NexosisApi::ModelSummary.new(response.parsed_response)
+        else
+          raise HttpException.new("There was a problem getting your model: #{response.code}.", "Could not get model #{model_id}", response)
+        end
+      end
+
+      # Run a feature set through the model to get predictions
+      #
+      # @param model_id [String] unique identifier of model to use
+      # @param feature_data [Array of Hash] feature columns with values to predict from
+      # @return [NexosisApi::PredictResponse]
+      # @note The feature data shape should match that of the dataset used to create the model.
+      # Any missing features in this request will reduce the quality of the predictions.
+      def predict(model_id, feature_data)
+        raise ArgumentError, 'Running predictions requires that model_id be specified and it is currently empty.' if model_id.empty?
+        raise ArgumentError, 'Running predictions requires that feature_data be specified and it is currently empty.' if feature_data.empty?
+        predict_url = "/models/#{model_id}/predict"
+        response = self.class.post(predict_url, headers: @headers, body: { "data": feature_data }.to_json)
+        if (response.success?)
+          NexosisApi::PredictResponse.new(model_id, response.parsed_response)
+        else
+          raise HttpException.new("There was a problem predicting from your model: #{response.code}.",
+                                  "Could not start predict for #{model_id}",
+                                  response)
+        end
+      end
+
+      # Remove an existing model
+      #
+      # @param model_id [String] the unique id of the model to remove.
+      def remove_model(model_id)
+        raise ArgumentError, 'Deleting a model requires that model_id be specified and it is currently empty.' if model_id.empty?
+        delete_url = "/models/#{model_id}"
+        response = self.class.delete(delete_url, @options)
+        unless (response.success?)
+          raise HttpException.new("There was a problem deleting your model: #{response.code}.",
+                                  "Could not delete #{model_id}",
+                                  response)
+        end
+      end
+
+      # Deletes multiple models based on the provided filter criteria.
+      # @param datasource_name [String] remove all models created by this datasource
+      # @param begin_date [DateTime] remove all models created after this date/time - inclusive. May be a ISO 8601 compliant string.
+      # @param end_date [DateTime] remove all models created before this date/time - inclusive. May be a ISO 8601 compliant string.
+      # @note - Use with great care. This permanently removes trained models.
+      # All parameters are indepdently optional, but one must be sent.
+      def remove_models(datasource_name = nil, begin_date = nil, end_date = nil)
+        params_unset = datasource_name.nil?
+        params_unset &= begin_date.nil?
+        params_unset &= end_date.nil?
+        raise ArgumentError, 'Must set one of the method parameters.' if params_unset
+        delete_url = '/models'
+        query = {}
+        query.store('dataSourceName', datasource_name) unless datasource_name.nil?
+        query.store('createdAfterDate', begin_date) unless begin_date.nil?
+        query.store('createdBeforeDate', end_date) unless end_date.nil?
+        response = self.class.delete(delete_url, headers: @headers, query: query)
+        unless (response.success?)
+          raise HttpException.new("There was a problem deleting your models: #{response.code}.",
+                                  'Could not delete models',
+                                  response)
+        end
+      end
+    end
+  end
+end

data/lib/nexosis_api/client/sessions.rb

@@ -45,21 +45,18 @@ module NexosisApi
       # Remove a session
       # @param session_id [String] required session identifier
       def remove_session(session_id)
-        if(session_id.to_s.empty?)
+        if (session_id.to_s.empty?)
           raise ArgumentError 'session_id cannot be empty or nil'
         end
         session_url = "/sessions/#{session_id}"
         response = self.class.delete(session_url, headers: @headers)
-        if(response.success?)
-          return
-        else
-          raise HttpException.new('Could not delete session with given id', "remove session with id #{session_id.to_s}",response)
-        end
+        return if response.success?
+        raise HttpException.new('Could not delete session with given id', "remove session with id #{session_id}", response)
       end
 
       # Remove sessions that have been run. All query options are optional and will be used to limit the sessions removed.
-      # @param query_options [Hash] optionally provide query parametes to limit the set of sessions removed. 
-      # @note query parameters hash members are type, dataset_name, event_name, start_date, and end_date. 
+      # @param query_options [Hash] optionally provide query parametes to limit the set of sessions removed.
+      # @note query parameters hash members are type, dataset_name, event_name, start_date, and end_date.
       #    Start and end dates refer to the session requested date.
       #    Results are not removed but then can only be accessed by dataset name
       # @example Remove all sessions based on a dataset by name
@@ -67,25 +64,22 @@ module NexosisApi
       def remove_sessions(query_options = {})
         sessions_url = '/sessions'
         response = self.class.delete(sessions_url, :headers => @headers, :query => get_query_from_options(query_options))
-        if(response.success?)
-          return
-        else
-          raise HttpException.new('Could not remove sessions', "Remove sessions with query #{query_options.to_s}",response)
-        end
+        return if response.success?
+        raise HttpException.new('Could not remove sessions', "Remove sessions with query #{query_options.to_s}",response)
       end
 
       # Initiate a new forecast session based on a named dataset.
       #
       # @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 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.
-      # @param column_metadata [Array of NexosisApi::Column] (optional) - specification for how to handle columns if different from existing metadata on dataset 
+      # @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
       # @note The time interval selected must be greater than or equal to the finest granularity of the data provided.
       #    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. 
+      #    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
@@ -136,18 +130,13 @@ module NexosisApi
       # @return [NexosisApi::SessionResult] SessionResult if parsed, String of csv data otherwise
       def get_session_results(session_id, as_csv = false)
         session_result_url = "/sessions/#{session_id}/results"
-        if as_csv
-          @headers["Accept"] = 'text/csv'
-        end
+        @headers['Accept'] = 'text/csv' if as_csv
         response = self.class.get(session_result_url, @options)
         @headers.delete('Accept')
 
-				if(response.success?)
-          if(as_csv)
-            response.body
-          else
-            NexosisApi::SessionResult.new(response.parsed_response)
-          end
+        if (response.success?)
+          return response.body if as_csv
+          NexosisApi::SessionResult.new(response.parsed_response)
         else
           raise HttpException.new("There was a problem getting the session: #{response.code}.", "get results for session #{session_id}" ,response)
         end
@@ -160,17 +149,34 @@ module NexosisApi
       def get_session(session_id)
         session_url = "/sessions/#{session_id}"
         response = self.class.get(session_url, @options)
-        if(response.success?)
-          NexosisApi::Session.new(response.parsed_response)
+        return NexosisApi::Session.new(response.parsed_response) if response.success?
+        raise HttpException.new("There was a problem getting the session: #{response.code}.", "getting session #{session_id}" ,response)
+      end
+
+      def create_model(datasource_name, target_column, columns = {})
+        model_url = '/sessions/model'
+        body = {
+          dataSourceName: datasource_name,
+          targetColumn: target_column,
+          predictionDomain: 'regression',
+          isEstimate: false
+        }
+        body.store(columns: columns) unless columns.empty?
+        response = self.class.post(model_url, headers: @headers, body: body.to_json)
+        if response.success?
+          session_hash = { 'session' => response.parsed_response }.merge(response.headers)
+          NexosisApi::SessionResponse.new(session_hash)
         else
-          raise HttpException.new("There was a problem getting the session: #{response.code}.", "getting session #{session_id}" ,response)
+          raise HttpException.new("There was a problem creating the model session: #{response.code}.", 'creating model session' ,response)
         end
-			end
+      end
 
       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)
+
+      # @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)
         session_url = "/sessions/#{type}"
-        query = { 
+        query = {
           'targetColumn' => target_column.to_s,
           'startDate' => start_date.to_s,
           'endDate' => end_date.to_s,
@@ -178,20 +184,20 @@ module NexosisApi
           'resultInterval' => result_interval.to_s
         }
         query['dataSetName'] = dataset_name.to_s unless dataset_name.to_s.empty?
-        if(event_name.nil? == false)
+        if (event_name.nil? == false)
           query['eventName'] = event_name
         end
         body = ''
-        if(column_metadata.nil? == false)
+        if (column_metadata.nil? == false)
           column_json = Column.to_json(column_metadata)
           body = {
             'dataSetName' => dataset_name,
             'columns' => column_json
           }
         end
-        response = self.class.post(session_url, :headers => @headers, :query => query, :body => body.to_json)
-        if(response.success?)
-          session_hash = {'session' => response.parsed_response}.merge(response.headers)
+        response = self.class.post(session_url, headers: @headers, query: query, body: body.to_json)
+        if (response.success?)
+          session_hash = { 'session' => response.parsed_response }.merge(response.headers)
           NexosisApi::SessionResponse.new(session_hash)
         else
           raise HttpException.new("Unable to create new #{type} session", "Create session for dataset #{dataset_name}",response)

data/lib/nexosis_api/column_role.rb

@@ -12,5 +12,9 @@ module NexosisApi
 
     # A feature to be included in analysis
     FEATURE = :feature
+
+    # This column will be used to uniquely identify rows during
+    # update and delete operations, but will not be used as a feature.
+    KEY = :key
   end
 end

data/lib/nexosis_api/dataset_data.rb

@@ -6,9 +6,7 @@ module NexosisApi
         if (k == 'data')
           @data = v
         elsif (k == 'links')
-          links = Array.new
-          v.each do |l| links << NexosisApi::Link.new(l) end
-          @links = links
+          @links = v.reject(&:nil?).map { |l| NexosisApi::Link.new(l) }
         end
       end
     end
@@ -17,7 +15,7 @@ module NexosisApi
     # @return [Array of NexosisApi::Link]
     attr_accessor :links
 
-    #The hash of data values from the dataset
+    # The hash of data values from the dataset
     # @return [Array of Hash] where each hash contains the dataset data
     attr_accessor :data
   end

data/lib/nexosis_api/dataset_summary.rb

@@ -3,15 +3,13 @@ module NexosisApi
   class DatasetSummary
     def initialize(data_hash)
       data_hash.each do |k, v|
-        if(k == 'dataSetName')
+        if (k == 'dataSetName')
           @dataset_name = v unless v.nil?
-        elsif(k == 'columns')
-          columns = []
-          next if v.nil?
-          v.keys.each do |col_key|
-            columns << NexosisApi::Column.new(col_key, v[col_key])
-          end
-          @column_metadata = columns
+        elsif (k == 'columns')
+          @column_metadata = v.reject { |_key, value| value.nil? }
+                              .map do |col_key, col_val|
+                                NexosisApi::Column.new(col_key, col_val)
+                              end
         end
       end
     end
@@ -23,5 +21,13 @@ module NexosisApi
     # Descriptive information about the columns
     # @return [Array of NexosisApi::Column]
     attr_accessor :column_metadata
+
+    # Helper method which tells you whether or not this dataset has a column with timestamp role.
+    # @note Often helpful for implmenters as non-timeseries datasets
+    # cannot be sent to forecast or impact sessions
+    # @since 1.3.0
+    def timeseries?
+      !@column_metadata.select { |dc| dc.role == NexosisApi::ColumnRole::TIMESTAMP }.empty?
+    end
   end
 end

data/lib/nexosis_api/imports_response.rb

@@ -18,6 +18,8 @@ module NexosisApi
           links = []
           v.each { |l| links << NexosisApi::Link.new(l) }
           instance_variable_set("@#{k}", links) unless v.nil?
+        elsif k == 'dataSetName'
+          @datasource_name = v
         else
           instance_variable_set("@#{k}", v) unless v.nil?
         end
@@ -37,10 +39,21 @@ module NexosisApi
     # @note The import will be performed in a FIFO queue. Check back on status before attempting to start a session using the dataset.
     attr_accessor :status
 
+    # Date and status of each status this session has entered
+    # @return [Hash]
+    # @since 1.3.0
+    attr_accessor :statusHistory
+
     # echo back the dataset name provided
     # @return [String]
+    # @deprecated use datasource_name instead
     attr_accessor :dataSetName
 
+    # echo back the name of the data source uploaded
+    # @return [String]
+    # @since 1.3.0
+    attr_accessor :datasource_name
+
     # The S3 parameters used to import a dataset
     # @return [Hash]
     # For an S3 response the keys of this hash should be 'bucket', 'path', and 'region'

data/lib/nexosis_api/model_summary.rb

@@ -0,0 +1,66 @@
+module NexosisApi
+  # class to hold the parsed results of model summary json
+  # @since 1.3.0
+  class ModelSummary
+    def initialize(model_hash)
+      model_hash.each do |k, v|
+        k = k.to_s
+        if (k == 'modelId')
+          @model_id = v
+        elsif (k == 'predictionDomain')
+          @prediction_domain = v
+        elsif (k == 'dataSourceName')
+          @datasource_name = v
+        elsif (k == 'createdDate')
+          @created_date = DateTime.parse(v) unless v.nil?
+        elsif (k == 'algorithm')
+          @algorithm = NexosisApi::Algorithm.new(v) unless v.nil?
+        elsif (k == 'columns')
+          @column_metadata = v.reject { |_key, value| value.nil? }
+                              .map do |col_key, col_val|
+                                NexosisApi::Column.new(col_key, col_val)
+                              end
+        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)
+                      end
+        elsif (k == 'sessionId')
+          @session_id = v
+        end
+      end
+    end
+
+    # Unique model id for this model in uuid/guid format.
+    # @return [String]
+    attr_accessor :model_id
+
+    # Unique id of the session used to create this model instance
+    # @return [String]
+    attr_accessor :session_id
+
+    # The type of prediction performed
+    # @return [String]
+    attr_reader :prediction_domain
+
+    # The data source used to create this model
+    # @return [String]
+    attr_accessor :datasource_name
+
+    # The date on which this model was created.
+    # @return [DateTime]
+    attr_accessor :created_date
+
+    # Information about the algorithm used to create the model
+    # @return [NexosisApi::Algorithm]
+    attr_accessor :algorithm
+
+    # Descriptive information about the columns
+    # @return [Array of NexosisApi::Column]
+    attr_accessor :column_metadata
+
+    # Algorithm and model specific metrics which may be of interest
+    # @return [Array of NexosisApi::Metric]
+    attr_accessor :metrics
+  end
+end

data/lib/nexosis_api/predict_response.rb

@@ -0,0 +1,35 @@
+module NexosisApi
+  # Class to hold the parsed response of a prediction request
+  # @since 1.3.0
+  class PredictResponse
+    def initialize(model_id, response_hash)
+      @model_id = model_id
+      @predictions = response_hash['data']
+      @message = response_hash['messages']
+    end
+
+    # The unique identifier for the model used to create these predictions
+    # @return [String]
+    attr_reader :model_id
+
+    # The feature data along with predicted target value
+    # @return [Array of Hash] each row of data as a hash in an array of values
+    # @note The result data includes an echo of the data sent to the predict request
+    # along with the target column containing the values predicted.
+    # [
+    #   {
+    #     "feature1": 23.33,
+    #     "target": 2.59
+    #   },
+    #   {
+    #     "feature1": 15.82,
+    #     "target": 1.75
+    #   }
+    # ]
+    attr_accessor :predictions
+
+    # A list of warning message optionally returned from prediction run
+    # @return [Array]
+    attr_accessor :messages
+  end
+end

data/lib/nexosis_api/session.rb

@@ -3,23 +3,25 @@ module NexosisApi
   class Session
     def initialize(sessionHash)
       sessionHash.each do |k,v|
-        if(k == 'links')
+        if (k == 'links')
           links = Array.new
-          v.each do |l| links << NexosisApi::Link.new(l) end
+          v.each { |l| links << NexosisApi::Link.new(l) }
           instance_variable_set("@#{k}", links) unless v.nil?
-        elsif(k == 'isEstimate')
+        elsif (k == 'isEstimate')
           instance_variable_set('@is_estimate', v) unless v.nil?
-        elsif(k == 'columns')
-          columns = []
-          next if v.nil?
-          v.keys.each do |col_key|
-            columns << NexosisApi::Column.new(col_key, v[col_key])
-          end
-          @column_metadata = columns
-        elsif(k == 'resultInterval')
+        elsif (k == 'columns')
+          @column_metadata = v.reject { |_key, value| value.nil? }
+                              .map do |col_key, col_val|
+                                NexosisApi::Column.new(col_key, v[col_key])
+                              end
+        elsif (k == 'resultInterval')
           @result_interval = v
         elsif (k == 'dataSourceName')
           @datasource_name = v
+        elsif (k == 'modelId')
+          @model_id = v
+        elsif (k == 'requestedDate')
+          @requested_date = DateTime.parse(v)
         else
           instance_variable_set("@#{k}", v) unless v.nil?
         end
@@ -48,7 +50,7 @@ module NexosisApi
     
     # the dataset used in this session
     # @return [String]
-    # @deprecated - Use the @data_source_name property instead
+    # @deprecated - Use the @datasource_name property instead
     attr_accessor :dataSetName
 
     # The column in the dataset for which this session ran predictions
@@ -84,5 +86,17 @@ module NexosisApi
     # @return [String] - the dataset or view name
     # @since 1.2.0
     attr_accessor :datasource_name
+
+    # The date this session was orginally submitted
+    # @since 1.3.0
+    attr_accessor :requested_date
+
+    # The id of the model created by this session if any
+    # @return [String] a uuid/buid format unique string for the model
+    # @since 1.3.0
+    # @note This is always empty in time-series sessions (forecast/impact)
+    # The model id returned here should be used in all future calls
+    # to model endpoints - primarily the /models/{modelId}/predict endpoint.
+    attr_accessor :model_id
   end
 end

data/lib/nexosis_api/session_result.rb

@@ -3,13 +3,15 @@ module NexosisApi
   class SessionResult < Session
     def initialize(session_hash)
       session_hash.each do |k, v|
-        if k == 'metrics'
-            instance_variable_set("@#{k}", NexosisApi::ImpactMetric.new(v)) unless v.nil?
-        else
-            instance_variable_set("@#{k}", v) unless v.nil?
+        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?
+        elsif k.to_s == 'data'
+          @data = v
         end
       end
-      super(session_hash.reject { |k,v| k == 'data' || k == 'metrics' })
+      super(session_hash.reject { |k, _v| k.to_s == 'data' || k.to_s == 'metrics' })
     end
 
     # The impact analysis if this session type is impact
@@ -17,7 +19,9 @@ module NexosisApi
     attr_accessor :metrics
 
     # The result data in a hash with the name of the target column
-    # @return [Hash]
+    # @return [Array of Hash]
+    # @note When retrieving a model creation session this field
+    # will contain the test data and results.
     attr_accessor :data
   end
 end

data/lib/nexosis_api/view_definition.rb

@@ -14,6 +14,8 @@ module NexosisApi
         elsif k == 'joins'
           next if v.nil?
           @joins = v.reject(&:nil?).map { |join| NexosisApi::Join.new(join) }
+        elsif k == 'isTimeSeries'
+          @is_timeseries = v
         end
       end
     end
@@ -34,6 +36,14 @@ module NexosisApi
     # @return [Array of NexosisApi::Join]
     attr_accessor :joins
 
+    # Is this view based on time series data?
+    # @since 1.3.0
+    attr_accessor :is_timeseries
+    
+    # Is this view based on time series data?
+    # @since 1.3.0
+    alias_method :timeseries?, :is_timeseries
+
     def to_json
       hash = {}
       hash['dataSetName'] = dataset_name

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.2.4'
+  spec.version = '1.3.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.2.4
+  version: 1.3.0
 platform: ruby
 authors:
 - Nexosis,Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-20 00:00:00.000000000 Z
+date: 2017-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,6 +53,7 @@ files:
 - lib/nexosis_api/client.rb
 - lib/nexosis_api/client/datasets.rb
 - lib/nexosis_api/client/imports.rb
+- lib/nexosis_api/client/models.rb
 - lib/nexosis_api/client/sessions.rb
 - lib/nexosis_api/client/views.rb
 - lib/nexosis_api/column.rb
@@ -69,6 +70,8 @@ files:
 - lib/nexosis_api/join.rb
 - lib/nexosis_api/link.rb
 - lib/nexosis_api/metric.rb
+- lib/nexosis_api/model_summary.rb
+- lib/nexosis_api/predict_response.rb
 - lib/nexosis_api/session.rb
 - lib/nexosis_api/session_response.rb
 - lib/nexosis_api/session_result.rb