nexosis_api 1.1.2 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: babec4e434789fc5e16d0aebaf206b09245d46a5
-  data.tar.gz: 7f7c90dfea83768cc956929d650292fe14c7f63a
+  metadata.gz: 4c023f2428d99d8724c7f278b96e71b1faf560c1
+  data.tar.gz: 2baabb2e8f32f47f9ddb19f33059f5b6643b5ad9
 SHA512:
-  metadata.gz: 01d35de5a51e9d863e909ec0973147a0870b37d62faa1e3fe6f6b956204591dd97f9fe752a561d176a135223d9908a67aafe651397cf3637db39abaa470750a1
-  data.tar.gz: ab7f428b1ca8d396d79c5c449be6bba536999daac704ceedf3724c83a79e8ce3a21e867fdf1226c3e886a0fdf9c1ce1dc1365b41646fc675b6714b0611538a31
+  metadata.gz: 67fa1be6df48ed79569ad3cbc0f698bc381f2a61139f8c39ea7b51f5c27d637c2d59548362521d41fb783fa3e221464d9fccbdd940f889e4c65ac0b3447c6ea1
+  data.tar.gz: 92dd19462ab7bda527ff2bc6ea7ffbab4de7cec87cb0d748a828b195467393e2a19955993c47912a1ff133f505f3be7ee4b3ccfa163c088821e7a5de573f13cc

data/lib/nexosis_api.rb

@@ -1,12 +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
+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

@@ -1,18 +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
+module NexosisApi
+  # Class to parse an individual algorithm
+  class Algorithm
+    def initialize(algo_hash)
+      algo_hash.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

@@ -1,32 +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
+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 +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
+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

data/lib/nexosis_api/client.rb

@@ -1,72 +1,98 @@
-require 'nexosis_api/algorithm_run'
-require 'nexosis_api/algorithm_selection'
-require 'nexosis_api/algorithm'
-require 'nexosis_api/column_role'
-require 'nexosis_api/column_type'
-require 'nexosis_api/dataset_column'
-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/imports_response'
-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/time_interval'
-require 'nexosis_api/client/sessions'
-require 'nexosis_api/client/datasets'
-require 'nexosis_api/client/imports'
-
-module NexosisApi
-    # Primary entry point to working with Nexosis API
-    class Client
-        include HTTParty
-        base_uri 'https://ml.nexosis.com/v1'
-        include Client::Sessions
-        include Client::Datasets
-        include Client::Imports
-
-        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
+require 'nexosis_api/algorithm_run'
+require 'nexosis_api/algorithm_selection'
+require 'nexosis_api/algorithm'
+require 'nexosis_api/column'
+require 'nexosis_api/column_options'
+require 'nexosis_api/column_role'
+require 'nexosis_api/column_type'
+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/imports_response'
+require 'nexosis_api/join'
+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/time_interval'
+require 'nexosis_api/view_definition'
+require 'nexosis_api/view_data'
+require 'nexosis_api/client/sessions'
+require 'nexosis_api/client/datasets'
+require 'nexosis_api/client/imports'
+require 'nexosis_api/client/views'
+
+module NexosisApi
+  # Primary entry point to working with Nexosis API
+  class Client
+    include HTTParty
+    base_uri 'https://ml.nexosis.com/v1'
+    include Client::Sessions
+    include Client::Datasets
+    include Client::Imports
+    include Client::Views
+
+    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
+
+    # @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
+
+    # @private
+    def create_query(page_number, page_size, options = {})
+      options.store(:page_number, page_number)
+      options.store(:page_size, page_size)
+      query = {
+        'page' => [page_number],
+        'pageSize' => [page_size]
+      }
+      query['startDate'] = [options[:start_date].iso8601.gsub(/\+/,'%2B')] unless options[:start_date].nil?
+      query['endDate'] = [options[:end_date].iso8601.gsub(/\+/,'%2B')] unless options[:end_date].nil?
+      query['include'] = options[:include] unless options[:include].nil?
+      query
+    end
+
+    def array_query_normalizer(query_set)
+      query_set.map { |key, value| value.map { |v| "#{key}=#{v}" } }.join('&') 
+    end
+  end
+end

data/lib/nexosis_api/client/datasets.rb

@@ -1,162 +1,157 @@
-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 1000).
-            # @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 1000).
-            # @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_name [String] the name of the dataset from which to remove data
-            # @param filter_options [Hash] filtering which data to remove
-            # @note 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
-                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]
-                }
-                query
-            end
-        end
-    end
-end
+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
+      # @note input json is to be a hash, do not send a json string via to_json.
+      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}"
+        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 1000).
+      # @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 1000).
+      # @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_name [String] the name of the dataset from which to remove data
+      # @param filter_options [Hash] filtering which data to remove
+      # @note 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_session - will cascade deletes to all related sessions
+      #    - cascade_view - will cascade deletes to all related views (any part of join - think twice)
+      #    - 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 ' if dataset_name.to_s.empty?
+        dataset_remove_url = "/data/#{dataset_name}"
+        query = {}
+        if filter_options.empty? == false
+          cascade_query = create_cascade_options(filter_options)
+          query['cascade'] = cascade_query unless cascade_query.nil?
+          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('&') }
+        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
+      end
+
+      private
+
+      # @private
+      def create_dataset(dataset_name, content, content_type)
+        raise ArgumentError 'dataset_name was not provided and is not optional ' if dataset_name.to_s.empty?
+        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
+
+      # @private
+      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}"
+        headers = { 'api-key' => @api_key, 'Accept' => content_type }
+        self.class.get(dataset_url, headers: headers,
+                                    query: create_query(page_number, page_size, query_options),
+                                    query_string_normalizer: ->(query_map) { array_query_normalizer(query_map) })
+      end
+
+      # @private
+      def create_cascade_options(option_hash)
+        return nil if option_hash.nil?
+        return %w[session view forecast] 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
+        options_set.map { |s| s.chomp('s') }
+      end
+    end
+  end
+end