nexosis_api 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea8420a0cc83927171b7767fb1d94bd3a5079afa
+  data.tar.gz: 440f6ff9e8af3ca49723fbb44b8284f632df58b8
+SHA512:
+  metadata.gz: fbe33013ff7623c70db259af4f46f070a913987197a8f5740cba1e5ab541cdec4d3f33a43397d3ffe7ee2816e7f2920deec4b4f856475a2ec5db35148f5e739e
+  data.tar.gz: cb0c8cf3defc7381ce444ebe0f46a64518c3a2a1377e396361b500afb45805e5887d1cdc9e52440843bfa40857870b2745b3c7ae7840393479c7772e4d726300

data/lib/nexosis_api.rb

@@ -0,0 +1,12 @@
+require 'httparty'
+require 'nexosis_api/client'
+
+# The container for the Nexosis API Client
+module NexosisApi
+  class << self
+    def client options = {}
+      return @client if defined?(@client)
+      @client = NexosisApi::Client.new(options)
+    end
+  end
+end

data/lib/nexosis_api/algorithm.rb

@@ -0,0 +1,18 @@
+module NexosisApi
+    #Class to parse an individual algorithm
+    class Algorithm
+        def initialize(algoHash)
+           algoHash.each do |k,v|
+               instance_variable_set("@#{k}", v) unless v.nil?
+           end
+        end
+
+        # A friendly name for the algorithm
+        # @return [String]
+        attr_accessor :name
+
+        # Descriptive explanation of the algorithm implementation
+        # @return [String] 
+        attr_accessor :description
+    end
+end

data/lib/nexosis_api/algorithm_run.rb

@@ -0,0 +1,32 @@
+module NexosisApi
+    # Class to parse results of an algorithm run
+    class AlgorithmRun
+        def initialize(runHash)
+           runHash.each do |k,v|
+               if k == "metrics"
+                   @metricSet = Array.new
+                   v.each{|m| @metricSet << NexosisApi::Metric.new(m) unless m.nil?}
+                   instance_variable_set("@#{k}", @metricSet)
+               elsif k == "links"
+                   @linkSet = Array.new
+                   v.each{|l| @linkSet << NexosisApi::Link.new(l) unless l.nil?}
+                   instance_variable_set("@#{k}", @linkSet)
+               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

@@ -0,0 +1,34 @@
+module NexosisApi
+    #Class to parse the model data results from a session 
+    class AlgorithmSelection
+        def initialize(dataHash)
+           dataHash.each do |k,v|
+               if k == "champion"
+                   instance_variable_set("@#{k}", NexosisApi::AlgorithmRun.new(v))
+               elsif k == "contestants"
+                    @contestantArray = Array.new
+                    v.each {|c| @contestantArray << NexosisApi::AlgorithmRun.new(c)}
+                    instance_variable_set("@#{k}", @contestantArray)
+               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

data/lib/nexosis_api/client.rb

@@ -0,0 +1,65 @@
+require 'nexosis_api/algorithm_run'
+require 'nexosis_api/algorithm_selection'
+require 'nexosis_api/algorithm'
+require 'nexosis_api/dataset_data'
+require 'nexosis_api/dataset_model'
+require 'nexosis_api/dataset_summary'
+require 'nexosis_api/http_exception'
+require 'nexosis_api/impact_metric'
+require 'nexosis_api/link'
+require 'nexosis_api/metric'
+require 'nexosis_api/session_response'
+require 'nexosis_api/session_result'
+require 'nexosis_api/session'
+require 'nexosis_api/client/sessions'
+require 'nexosis_api/client/datasets'
+
+module NexosisApi
+    # Primary entry point to working with Nexosis API
+    class Client
+        include HTTParty
+        base_uri 'https://ml.nexosis.com/api'
+        include Client::Sessions
+        include Client::Datasets
+
+        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}
+        end
+
+        # Gets the current account balance.
+        #
+        # @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'
+			response = self.class.get(session_url,@options)
+			response.headers["nexosis-account-balance"]
+        end
+
+        private
+        def process_csv_to_s csv
+            content = ""
+            if(csv.is_a?(CSV))
+                csv.each do |row|
+                    if(csv.headers.nil?)
+                        #not using row.to_csv because it uses non-compliant '\n' newline
+                        content.concat(row.join(',')).concat("\r\n")
+                    else
+                        content.concat(row.fields.join(',')).concat("\r\n")
+                    end
+                end
+                if(csv.headers.nil? == false)
+                    content.prepend(csv.headers.join(',').concat("\r\n")) unless csv.headers.nil?
+                end
+            else
+                content = csv
+            end
+            content
+        end
+    end
+end

data/lib/nexosis_api/client/datasets.rb

@@ -0,0 +1,165 @@
+require 'csv'
+
+module NexosisApi
+	class Client
+		# Dataset-based API operations
+		#
+		# @see http://docs.nexosis.com/
+		module Datasets
+
+            # save data in a named dataset
+            #
+            # @param dataset_name [String] name to save the dataset
+            # @param json_data [Hash] parsed json data
+            # @return [NexosisApi::DatasetSummary] information about your upload
+            def create_dataset_json(dataset_name, json_data)
+                create_dataset dataset_name, json_data.to_json, 'application/json'
+            end
+
+            # save data in a named dataset from csv content
+            #
+            # @param dataset_name [String] name to save the dataset
+            # @param csv [CSV] csv content ready for reading
+            # @return [NexosisApi::DatasetSummary] information about your upload
+            def create_dataset_csv(dataset_name, csv)
+                content = process_csv_to_s csv
+                create_dataset dataset_name, content, 'text/csv'
+            end
+
+            # Gets the list of data sets that have been saved to the system, optionally filtering by partial name match.
+            #
+            # @param partial_name [String] if provided, all datasets returned will contain this string
+            # @return [Array of NexosisApi::DatasetSummary] array of datasets found
+            def list_datasets(partial_name = '')
+                list_dataset_url = "/data?partialName=#{partial_name.to_s}"
+                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)
+                    end
+                    results
+                else
+                    raise HttpException.new("There was a problem listing datasets: #{response.code}.", "listing datasets with partial name #{partial_name}" ,response)
+                end
+            end
+            
+            # Get the data in the set, with paging, and optional projection.
+            #
+            # @param dataset_name [String] name of the dataset for which to retrieve data.
+            # @param page_number [Integer] zero-based page number of results to retrieve
+            # @param page_size [Integer] Count of results to retrieve in each page (max 100).
+            # @param query_options [Hash] options hash for limiting and projecting returned results
+            # @note Query Options includes start_date as a DateTime or ISO 8601 compliant string,
+            #    end_date, also as a DateTime or string, and :include as an Array of strings indicating the columns to return.
+            #    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
+            end
+
+            # Get the data in the set, written to a CSV file, optionally filtering it.
+            #
+            # @param dataset_name [String] name of the dataset for which to retrieve data.
+            # @param page_number [Integer] zero-based page number of results to retrieve
+            # @param page_size [Integer] Count of results to retrieve in each page (max 100).
+            # @param query_options [Hash] options hash for limiting and projecting returned results
+            # @note Query Options includes start_date as a DateTime or ISO 8601 compliant string,
+            #    end_date, also as a DateTime or string, and :include as an Array of strings indicating the columns to return.
+            #    The dates can be used independently and are inclusive. Lack of options returns all values within the given page.
+            # @example get page 1 with 20 results each page
+            #    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
+            end
+            
+            # Remove data from a data set or the entire set.
+            #
+            # @param dataset [String] the name of the dataset from which to remove data
+            # @param filter_options [Hash] filtering which data to remove
+            # @Options - start_date, end_date, cascade_forecast, cascade_sessions, cascade
+            #    start_date - the first date on which to start removing data
+            #    end_date - the last date on which to finish removing data
+            #    cascade_forecast - will cascade deletes to all related forecasts
+            #    cascade_sessions - will cascade deletes to all related sessions
+            #    cascade - will cascade deletes to all related forecasts and sessions
+            # @example - request delete with cascade forecast
+            #    NexosisApi.client.remove_dataset('mydataset', {:cascade_forecast => true})
+            def remove_dataset(dataset_name, filter_options = {})
+             raise ArgumentError "dataset_name was not provided and is not optional " unless dataset_name.to_s.empty? == false
+                dataset_remove_url = "/data/#{dataset_name}"
+                query = {}
+                cascade_options = filter_options.each {|k,v| 
+                    if(k.to_s.include?('cascade') && v)
+                        if(k.to_s == 'cascade')
+                            #hack here to handle two-keyed api query param
+                            query["cascade"] = "forecast"
+                            query[:cascade] = "session"
+                        elsif(k.to_s == 'cascade_forecast')
+                             query["cascade"] = "forecast"
+                        else
+                             query["cascade"] = "session"
+                        end
+                    end
+                }
+                
+                if(filter_options.empty? == false)
+                    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
+                if(query.values.all?{|v|v.to_s.empty?})
+                    query = nil
+                end
+                response  = self.class.delete(dataset_remove_url, :headers => @headers, :query => query)
+                if(response.success?)
+                    return
+                else
+                    raise HttpException.new("There was a problem removing the dataset: #{response.code}.", "removing dataset #{dataset_name}", response)
+                end
+            end
+
+            private
+            def create_dataset dataset_name, content, content_type
+                raise ArgumentError "dataset_name was not provided and is not optional " unless dataset_name.to_s.empty? == false
+                dataset_url = "/data/#{dataset_name}"
+                headers = {"api-key" => @api_key, "content-type" => content_type}
+                response = self.class.put(dataset_url, {:headers => headers, :body => content})
+                if(response.success?)
+                    NexosisApi::DatasetSummary.new(response)
+                else
+                    raise HttpException.new("There was a problem uploading the dataset: #{response.code}.", "uploading dataset #{dataset_name}" ,response)
+			    end
+            end
+
+            def get_dataset_internal(dataset_name, page_number = 0, page_size = 50, query_options = {}, content_type = "application/json")
+                raise ArgumentError "page size must be <= 100 items per page" unless page_size <= 100
+                raise ArgumentError "dataset_name was not provided and is not optional" unless dataset_name.to_s.empty? == false
+                dataset_url = "/data/#{dataset_name.to_s}"
+                headers = {"api-key" => @api_key, "Accept" => content_type}
+                self.class.get(dataset_url, :headers => headers, :query => create_query(page_number, page_size, query_options))
+            end
+
+            def create_query page_number, page_size, options = {}
+                options.store(:page_number,page_number)
+                options.store(:page_size,page_size)
+                query = {
+                    "startDate" => options[:start_date].to_s,
+                    "endDate" => options[:end_date].to_s,
+                    "page" => options[:page_number],
+                    "pageSize" => options[:page_size],
+                    "include" => options[:include].to_s
+                }
+            end
+            
+        end
+    end
+end

data/lib/nexosis_api/client/sessions.rb

@@ -0,0 +1,226 @@
+require 'csv'
+
+module NexosisApi
+	class Client
+		# Session-based API operations
+		#
+		# @see http://docs.nexosis.com/
+		module Sessions
+
+			# List sessions previously submitted
+			#
+			# @param query_options [Hash] optionally provide query parameters to limit the search of sessions. 
+			# @return[Array of NexosisApi::SessionResponse] with all sessions matching the query or all if no query
+			# @note query parameters hash members are dataset_name, event_name, start_date, and end_date. 
+			#    Start and end dates refer to the session requested date.
+			# @example query for just one dataset
+			#   sessions = NexosisApi.client.list_sessions :dataset_name => 'MyDataset'
+			def list_sessions(query_options = {})
+				sessions_url = '/sessions'
+				response = self.class.get(sessions_url, :headers => @headers, :query => get_query_from_options(query_options))
+				if(response.success?)
+					all_responses = []
+					response.parsed_response["items"].each do |session_hash|
+						response_hash = {"session" => session_hash}.merge(response.headers)
+						all_responses << NexosisApi::SessionResponse.new(response_hash)
+					end
+					all_responses
+				else
+					raise HttpException.new("Could not retrieve sessions","Get all sessions with query #{query_options.to_s}",response)
+				end
+			end
+
+			# Remove a session
+			# @param session_id [String] required session identifier
+			def remove_session(session_id)
+				if(session_id.to_s.empty?)
+					raise ArgumentError 'session_id cannot be empty or nil'
+				end
+				session_url = '/session/#{session_id.to_s}'
+				response = self.class.delete(session_url)	
+				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
+			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. 
+			#    Start and end dates refer to the session requested date.
+			#    Results are not removed but then can only be accessed by dataset name
+			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
+			end
+		
+			# 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 target_column [String] The name of the column for which you want predictions.
+			# @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.
+			# @return [NexosisApi::SessionResponse] providing information about the sesssion
+			def create_forecast_session(dataset_name, target_column, start_date, end_date)
+				create_session dataset_name, target_column, start_date, end_date
+			end
+
+			# Forecast from CSV formatted data.
+			#
+			# @param csv [CSV] initialized CSV object ready for reading.
+			# @param target_column [String] The name of the column for which you want predictions.
+			# @param start_date [DateTime] The starting date of the forecast period. Can be ISO 8601 parseable string. 
+			# @param end_date [DateTime] The ending date of the forecast period. Can be ISO 8601 parseable string.
+			# @return [NexosisApi::SessionResponse] providing information about the sesssion
+			# @example load and send local file
+			#    mycsv = CSV.read('.\mylocal.csv')
+			#    NexosisApi.client(:api_key=>mykey).create_forecast_session_csv(mycsv,'sales','01-01-2017','02-01-2017')
+            def create_forecast_session_csv(csv, target_column, start_date, end_date)
+				content = process_csv_to_s csv
+                create_session(nil, target_column, start_date, end_date, false, nil, "forecast", content)
+            end
+
+			# Forecast from data posted in the request.
+			#
+			# @param json_data [String] Json dataset matching the dataset input schema.
+			# @param target_column [String] The name of the column for which you want predictions.
+			# @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.
+			# @return [NexosisApi::SessionResponse] providing information about the sesssion
+			# @see https://developers.nexosis.com/docs/services/98847a3fbbe64f73aa959d3cededb3af/operations/5919ef80a730020dd851f233
+			def create_forecast_session_data(json_data, target_column, start_date, end_date)
+				create_session nil, target_column, start_date, end_date, false, nil, "forecast", json_data, "application/json"
+			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 target_column [String] The name of the column for which you want predictions.
+			# @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.
+			# @return [NexosisApi::SessionResponse] providing information about the sesssion, including the cost
+            def estimate_forecast_session(dataset_name, target_column, start_date, end_date)
+                create_session dataset_name, target_column, start_date, end_date, true
+            end
+			
+			# Analyze impact 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 target_column [String] The name of the column for which you want predictions.
+			# @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.
+			# @return [NexosisApi::SessionResponse] providing information about the sesssion
+            def create_impact_session(dataset_name, target_column, start_date, end_date, event_name)
+                create_session dataset_name, target_column, start_date, end_date, false, event_name, "impact"
+            end
+
+			# Analyze impact for an event with data in json format.
+			#
+			# @param json_data [String] Json dataset matching the dataset input schema.
+			# @param target_column [String] The name of the column for which you want predictions.
+			# @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.
+			# @return [NexosisApi::SessionResponse] providing information about the sesssion
+			# @see https://developers.nexosis.com/docs/services/98847a3fbbe64f73aa959d3cededb3af/operations/5919ef80a730020dd851f233
+			def create_impact_session_data(json_data, target_column, start_date, end_date, event_name)
+				create_session nil, target_column, start_date, end_date, false, event_name, "impact", json_data, "application/json"
+			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 target_column [String] The name of the column for which you want predictions.
+			# @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.
+			# @return [NexosisApi::SessionResponse] providing information about the sesssion, including the cost
+            def estimate_impact_session(dataset_name, target_column, start_date, end_date, event_name)
+                create_session dataset_name, target_column, start_date, end_date, true, event_name, "impact"
+            end
+            
+			# Get the results of the session.
+			#
+			# @param session_id [String] the Guid string returned in a previous session request
+			# @param as_csv [Boolean] indicate whether results should be returned in csv format
+			# @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
+			    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
+                else
+                    raise HttpException.new("There was a problem getting the session: #{response.code}.", "get results for session #{session_id}" ,response)
+			    end
+		    end
+
+			# Get a specific session by id.
+			#
+			# @param session_id [String] the Guid string returned in a previous session request
+			# @return [NexosisApi::Session] a Session object populated with the session's data
+            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)
+                else
+                    raise HttpException.new("There was a problem getting the session: #{response.code}.", "getting session #{session_id}" ,response)
+			    end
+            end
+        private
+			def create_session(dataset_name, target_column, start_date, end_date, is_estimate=false, event_name = nil, type = "forecast", content = nil, content_type = "text/csv")
+				session_url = "/sessions/#{type}"
+				query = { 
+					"dataSetName" => dataset_name,
+					"targetColumn" => target_column,
+					"startDate" => start_date.to_s,
+					"endDate" => end_date.to_s,
+					"isestimate" => is_estimate.to_s
+				}
+				if(event_name.nil? == false)
+					query["eventName"] = event_name
+				end
+                if content.nil? == false
+                    headers = {"api-key" => @api_key, "content-type" => content_type}
+                    response = self.class.post(session_url, {:headers => headers, :query => query, :body => content})
+                else
+                    response = self.class.post(session_url, :headers => @headers, :query => query)
+                end
+				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)
+				end
+			end
+
+			def get_query_from_options(options)
+				query = { 
+					"dataSetName" => options[:dataset_name],
+					"eventName" => options[:event_name],
+					"startDate" => options[:start_date],
+					"endDate" => options[:end_date],
+					"type" => options[:type]
+				}
+				query
+			end
+		end
+	end
+end

data/lib/nexosis_api/dataset_data.rb

@@ -0,0 +1,24 @@
+module NexosisApi
+    # class to hold the parsed results of a dataset
+    class DatasetData
+        def initialize(data_hash)
+            data_hash.each do |k,v|
+                if(k == "data")
+                    @data = v
+                elsif(k == "links")
+                    links = Array.new
+					v.each do |l| links << NexosisApi::Link.new(l) end
+					@links = links
+                end
+            end
+        end
+    
+        # Helpful links to more information about this dataset
+        # @return [Array of NexosisApi::Link]
+        attr_accessor :links
+
+        #The hash of data values from the dataset
+        # @return [Array of Hash] where each hash contains the dataset data
+        attr_accessor :data
+    end
+end

data/lib/nexosis_api/dataset_model.rb

@@ -0,0 +1,26 @@
+module NexosisApi
+    # Class to parse the model results calculated for a dataset
+    class DatasetModel
+        def initialize(dataHash)
+           dataHash.each do |k,v|
+               if k == "championContest"
+                    instance_variable_set("@#{k}", NexosisApi::AlgorithmSelection.new(v))
+               else
+                    instance_variable_set("@#{k}", v) unless v.nil?
+               end
+           end
+        end
+        
+        # The name of the dataset used in the evaluation
+        # @return [String]
+        attr_accessor :datasetName
+
+        # The column targeted for prediction
+        # @return [String] 
+        attr_accessor :targetColumn
+
+        # The details of the winning algorithm
+        # @return [NexosisApi::AlgorithmSelection]
+        attr_accessor :championContest
+    end
+end

data/lib/nexosis_api/dataset_summary.rb

@@ -0,0 +1,15 @@
+module NexosisApi
+    # class to hold the parsed results of a dataset
+    class DatasetSummary
+        def initialize(data_hash)
+            data_hash.each do |k,v|
+                if(k == "dataSetName")
+                    @dataset_name = v unless v.nil?
+                end
+            end
+        end
+    
+        # The name of the dataset uploaded and saved
+        attr_accessor :dataset_name
+    end
+end

data/lib/nexosis_api/http_exception.rb

@@ -0,0 +1,28 @@
+module NexosisApi
+  # encapsulate errors from the Nexosis API
+  class HttpException < StandardError
+      attr_reader :message,:action,:response,:request
+      def initialize(message = "", action = nil, http_obj)
+        @message = message
+        if(http_obj.is_a?(Hash))
+        @message.prepend(http_obj["message"].concat(": ")) unless http_obj["message"].nil?
+        @action = action
+          if(http_obj.instance_of?(HTTParty::Response))
+            @message = message.concat("|| Explanation: ").concat(http_obj["errorDetails"]["message"]) unless http_obj["errorDetails"]["message"].nil?
+            @code = http_obj.parsed_response["statusCode"]
+            @type = http_obj.parsed_response["errorType"]
+            @response = http_obj.response
+            @request = http_obj.request
+          end
+        else
+          @code = http_obj.code
+        end
+      end
+
+      attr_reader :code
+      attr_reader :response
+      attr_reader :request
+      attr_reader :message
+      attr_reader :type      
+  end
+end

data/lib/nexosis_api/impact_metric.rb

@@ -0,0 +1,22 @@
+module NexosisApi
+    # Class to parse the metric results of an impact analysis
+    class ImpactMetric
+        def initialize(metricHash)
+           metricHash.each do |k,v|
+               instance_variable_set("@#{k}", v) unless v.nil?
+           end
+        end
+
+        # Statistical value used to determine the significance of the impact.
+        # @return [Float]
+        attr_accessor :pValue
+
+        # Total absolute effect of the event on the dataset.
+        # @return [Float]
+        attr_accessor :absoluteEffect
+
+        # Percentage impact of the event on the dataset.
+        # @return [Float]
+        attr_accessor :relativeEffect
+    end
+end

data/lib/nexosis_api/link.rb

@@ -0,0 +1,18 @@
+module NexosisApi
+    # Class to parse hypermedia resutls
+    class Link
+        def initialize(linkHash)
+           linkHash.each do |k,v|
+               instance_variable_set("@#{k}", v) unless v.nil?
+           end
+        end
+
+        # relation type of the link
+        # @return [String]
+        attr_accessor :rel
+
+        # resource url
+        # @return [String]
+        attr_accessor :href
+    end
+end

data/lib/nexosis_api/metric.rb

@@ -0,0 +1,22 @@
+module NexosisApi
+    # Class to parse algorithm metrics from model results
+    class Metric
+        def initialize(metricHash)
+           metricHash.each do |k,v|
+               instance_variable_set("@#{k}", v) unless v.nil?
+           end
+        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
+    end
+end

data/lib/nexosis_api/session.rb

@@ -0,0 +1,63 @@
+module NexosisApi
+	# Class for parsing the results of a session based request
+	class Session
+		def initialize(sessionHash)
+			sessionHash.each do |k,v|
+				if(k == "links")
+					links = Array.new
+					v.each do |l| links << NexosisApi::Link.new(l) end
+					instance_variable_set("@#{k}", links) unless v.nil?
+				elsif(k == "isEstimate")
+                    instance_variable_set("@is_estimate", v) unless v.nil?
+				else
+					instance_variable_set("@#{k}", v) unless v.nil?
+				end
+			end
+		end
+
+		# identifier for this sesssion
+		# @return [String]
+		attr_accessor :sessionId
+
+		# What type of analysis was run during this session
+		# @return [String]
+		attr_accessor :type
+
+		# Is this session requested, estimated, started, or completed
+		# @return [String]
+		attr_accessor :status
+
+		# Date and status of each status this session has entered
+		# @return [Hash]
+		attr_accessor :statusHistory
+
+		# reserved for future extensions
+		# @return [Hash]
+		attr_accessor :extraParameters
+
+		# the dataset used in this session
+		# @return [String]
+		attr_accessor :dataSetName
+
+		# 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]
+		attr_accessor :startDate
+
+		# The end date of analysis in this session
+		# @return [DateTime]
+		attr_accessor :endDate
+
+		# associated hypermedia
+		# @return [Array of NexosisApi::Link]
+		attr_accessor :links
+
+		# Is this session an estimate only session
+		# @return [Boolean]
+		attr_accessor :is_estimate
+	end
+end
+

data/lib/nexosis_api/session_response.rb

@@ -0,0 +1,26 @@
+require 'nexosis_api/session'
+
+module NexosisApi
+    #Class to parse the results from a new session
+    class SessionResponse < Session
+        def initialize(forecast_hash)
+            forecast_hash.each do |k,v|
+				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?
+				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
+    end
+end

data/lib/nexosis_api/session_result.rb

@@ -0,0 +1,23 @@
+module NexosisApi
+    # Class for parsing the results of a completed session
+    class SessionResult < Session
+        def initialize(sessionHash)
+           sessionHash.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?
+               end
+            end
+            super(sessionHash.reject {|k,v| k == "data" || k == "metrics"})
+        end
+
+        # The impact analysis if this session type is impact
+        # @return [NexosisApi::ImpactMetric]
+        attr_accessor :metrics
+
+        # The result data in a hash with the name of the target column
+        # @return [Hash]
+        attr_accessor :data
+    end
+end

data/nexosisapi.gemspec

@@ -0,0 +1,21 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.add_development_dependency 'bundler', '~> 1.0'
+  spec.add_dependency 'httparty', '>= 0.15'
+  spec.authors = ["Nexosis,Inc"]
+  spec.description = %q{Nexosis API client}
+  spec.email = ['support@nexosis.com']
+  spec.files = %w(nexosisapi.gemspec)
+  spec.files += Dir.glob("lib/**/*.rb")
+  spec.homepage = 'https://github.com/nexosis/apiclient-rb'
+  spec.licenses = ['MIT']
+  spec.name = 'nexosis_api'
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.0.0'
+  spec.summary = "Ruby client for working with the Nexosis API"
+  spec.version = '1.0.0'
+  spec.metadata["yard.run"] = "yri"
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: nexosis_api
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Nexosis,Inc
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.15'
+description: Nexosis API client
+email:
+- support@nexosis.com
+executables: []
+extensions: []
+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/client.rb
+- lib/nexosis_api/client/datasets.rb
+- lib/nexosis_api/client/sessions.rb
+- lib/nexosis_api/dataset_data.rb
+- lib/nexosis_api/dataset_model.rb
+- lib/nexosis_api/dataset_summary.rb
+- lib/nexosis_api/http_exception.rb
+- lib/nexosis_api/impact_metric.rb
+- lib/nexosis_api/link.rb
+- lib/nexosis_api/metric.rb
+- lib/nexosis_api/session.rb
+- lib/nexosis_api/session_response.rb
+- lib/nexosis_api/session_result.rb
+- nexosisapi.gemspec
+homepage: https://github.com/nexosis/apiclient-rb
+licenses:
+- MIT
+metadata:
+  yard.run: yri
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Ruby client for working with the Nexosis API
+test_files: []