datarobot-ai_api 0.0.3

data/lib/datarobot/ai_api/dataset.rb

@@ -0,0 +1,99 @@
+module Datarobot
+  module AiApi
+    class Dataset
+      include Datarobot::AiApi::Refreshable
+      attr_accessor :name
+      attr_reader :task, :created_at, :id, :ai_id
+
+      # Retrieves all datasets as a paginated resource.
+      #
+      # @param [Integer] limit Number of datasets per page
+      # @param [Integer] offset How many datasets to skip before this page
+      #
+      # @return [Datarobot::AiApi::Page(Datarobot::AiApi::Dataset)]
+      def self.all(limit: 50, offset: 0)
+        Datarobot::AiApi.request_endpoint('/aiapi/datasets/', params: {limit: limit, offset: offset}) do |data|
+          Datarobot::AiApi::Page.new(self, data)
+        end
+      end
+
+      # Retrieves an dataset given an ID.
+      #
+      # @param [String] id The ID of the dataset to retrieve
+      #
+      # @return [Datarobot::AiApi::Dataset]
+      def self.find(id, &block)
+        raise Datarobot::AiApi::NotFoundError, "Cannot find Dataset with id: nil" if id.nil?
+        Datarobot::AiApi.request_endpoint("/aiapi/datasets/#{id}") do |data|
+          if block_given?
+            yield data
+          else
+            self.new(data)
+          end
+        end
+      end
+
+      # Deletes a dataset. Returns `nil` if the action was successful. Will
+      # raise an error if the action was unsuccessful
+      #
+      # @param [String] id The ID of the dataset to delete
+      #
+      # @return [nil]
+      def self.delete(id)
+        Datarobot::AiApi.request_endpoint("/aiapi/datasets/#{id}", method: "delete")
+      end
+
+      # Creates a dataset from the file at the given (local) path
+      #
+      # @param [String] file_path The path to the file to upload
+      #
+      # @return [Datarobot::AiApi::Dataset]
+      def self.create_from_file(file_path)
+        Datarobot::AiApi.upload_to_endpoint('/aiapi/datasets/fileImports', file_path) do |data|
+          task = Datarobot::AiApi::Task.new(data)
+          task.wait_until_complete
+        end
+      end
+
+      # Creates a dataset from the file at the given (publicly accessible) url
+      #
+      # @param [String] url The url to the file to upload
+      #
+      # @return [Datarobot::AiApi::Dataset]
+      def self.create_from_url(url)
+        uri = URI.parse(url)
+        name = File.basename(uri.path)
+        Datarobot::AiApi.request_endpoint("/aiapi/datasets/urlImports/", method: "post", body: {url: url}) do |data|
+          dataset = new(data)
+          dataset.name = name
+          dataset
+        end
+      end
+
+      # Given a parsed response body from the API, will create a new Dataset object
+      def initialize(options = {})
+        # Suppresses warnings about uninitialized variables
+        @ai_id = nil
+        @name = nil
+        @created_at = nil
+
+        set_from_options(options)
+      end
+
+      # Takes a response body from the API. Will set all Dataset attributes from the
+      # response body
+      #
+      # @param [Hash] options A parsed response body
+      # @return [void]
+      def set_from_options(options = {})
+        # one-liner replacement for `stringify_keys`
+        options = options.collect{|k,v| [k.to_s, v]}.to_h
+
+        @created_at = options.dig("createdOn") || @created_at
+        @name = options.dig("datasetName") || options.dig("name") || @name
+        @id = options.dig("id") || options.dig("datasetId") || @id
+        @ai_id = options.dig("aiId") || @ai_id
+      end
+    end
+  end
+end

data/lib/datarobot/ai_api/deployment.rb

@@ -0,0 +1,20 @@
+module Datarobot
+  module AiApi
+    class Deployment
+      attr_reader :datarobotKey, :deployment_id, :url, :target
+
+      # Takes a response body from the API. Will set all deployment attributes
+      # from the response body
+      #
+      # @param [Hash] options A parsed response body
+      def initialize(options={})
+        options = options.collect{|k,v| [k.to_s, v]}.to_h
+
+        @datarobotKey ||= options.dig("datarobot-key")
+        @deploymentId ||= options.dig("deploymentId")
+        @url ||= options.dig("url")
+        @target ||= options.dig("target")
+      end
+    end
+  end
+end

data/lib/datarobot/ai_api/evaluation.rb

@@ -0,0 +1,21 @@
+module Datarobot
+  module AiApi
+    class Evaluation
+      attr_reader :summary, :score, :label
+
+      # Takes a response body from the API. Will set all prediction attributes
+      # from the response body
+      #
+      # @param [Hash] options A parsed response body
+      def initialize(options={})
+        # one-liner replacement for `stringify_keys`
+        options = options.collect{|k,v| [k.to_s, v]}.to_h
+
+        @summary = options.dig("summary")
+        @score = options.dig("score")
+        @label = options.dig("label")
+      end
+    end
+  end
+end
+

data/lib/datarobot/ai_api/learning_session.rb

@@ -0,0 +1,112 @@
+module Datarobot
+  module AiApi
+    class LearningSession
+      include Datarobot::AiApi::Refreshable
+      attr_reader :name, :id, :created_at, :dataset_id, :target, :evaluation
+
+      # Retrieves all learning sessions as a paginated resource.
+      #
+      # @param [Integer] limit Number of learning sessions per page
+      # @param [Integer] offset How many learning sessions to skip before this page
+      #
+      # @return [Datarobot::AiApi::Page(Datarobot::AiApi::LearningSession)]
+      def self.all(limit: 50, offset: 0)
+        Datarobot::AiApi.request_endpoint('/aiapi/learningSessions/', params: {limit: limit, offset: offset}) do |data|
+          Datarobot::AiApi::Page.new(self, data)
+        end
+      end
+
+      # Retrieves a leanring sessoin given an ID.
+      #
+      # @param [String] id The ID of the learning session to retrieve
+      #
+      # @return [Datarobot::AiApi::LearningSession]
+      def self.find(id, &block)
+        raise Datarobot::AiApi::NotFoundError, "Cannot find LearningSession with id: nil" if id.nil?
+        Datarobot::AiApi.request_endpoint("/aiapi/learningSessions/#{id}") do |data|
+          if block_given?
+            yield data
+          else
+            self.new(data)
+          end
+        end
+      end
+
+      # Creates a new learning session on the given target for a given dataset
+      #
+      # @param [String] dataset_id The ID of the dataset to learn on
+      # @param [String] target Name of the target feature
+      # @return [Datarobot::AiApi::LearningSession]
+      def self.create(dataset_id:, target:)
+        raise "Need both dataset_id and target" unless dataset_id && target
+
+        name ||= "Learning #{target}"
+        Datarobot::AiApi.request_endpoint('/aiapi/learningSessions/', method: 'post', body: { datasetId: dataset_id, target: target }) do |data|
+          task_data = Datarobot::AiApi.get(data["links"]["result"])
+          task = Datarobot::AiApi::Task.new(task_data)
+          task.wait_until_complete
+        end
+      end
+
+      # Deletes a learning session. Returns `nil` if the action was successful.
+      # Will raise an error if the action was unsuccessful
+      #
+      # @param [String] id The ID of the learning session to delete
+      #
+      # @return [nil]
+      def self.delete(id)
+        Datarobot::AiApi.request_endpoint("/aiapi/learningSessions/#{id}", method: "delete")
+      end
+
+      # Given a parsed response body from the API, will create a new leanring sessoin object
+      def initialize(options = {})
+        # Suppresses warnings about uninitialized variables
+        @id = nil
+        @name = nil
+        @dataset_id = nil
+        @target = nil
+        @created_at = nil
+
+        set_from_options(options)
+        @features = nil
+        @deployment = nil
+      end
+
+      # Takes a response body from the API. Will set all learning session
+      # attributes from the response body
+      #
+      # @param [Hash] options A parsed response body
+      # @return [void]
+      def set_from_options(options = {})
+        # one-liner replacement for `stringify_keys`
+        options = options.collect{|k,v| [k.to_s, v]}.to_h
+
+        @name = options.dig("name") || @name
+        @id = options.dig("id") || @id
+        @created_at = options.dig("created") || @created_at
+        @dataset_id = options.dig("datasetId") || @dataset_id
+        @target = options.dig("target") || @target
+        @evaluation = Datarobot::AiApi::Evaluation.new(options.dig("evaluation") || {})
+      end
+
+      # gets all feature metadata for learned features of the associated
+      # dataset
+      #
+      # @return [Array]
+      def features
+        Datarobot::AiApi.request_endpoint("/aiapi/learningSessions/#{id}/features/") do |data|
+          data = data.collect{|k,v| [k.to_s, v]}.to_h
+          @features = data["features"]
+        end
+      end
+
+      # Gets the deployment for the learning session
+      # @return Datarobot::AiApi::Deployment
+      def deployment
+        Datarobot::AiApi.request_endpoint("/aiapi/learningSessions/#{id}/deployment") do |data|
+          @deployment = Datarobot::AiApi::Deployment.new(data)
+        end
+      end
+    end
+  end
+end

data/lib/datarobot/ai_api/output.rb

@@ -0,0 +1,58 @@
+module Datarobot
+  module AiApi
+    class Output
+      attr_accessor :name, :target
+      attr_reader :evaluation, :ai_id, :links, :source
+
+      # Given a parsed response body from the API, will create a new ouptut object
+      def initialize(options = {})
+        set_from_options(options)
+        @features = nil
+      end
+
+      # Takes a response body from the API. Will set all output attributes from the
+      # response body
+      #
+      # @param [Hash] options A parsed response body
+      # @return [void]
+      def set_from_options(options = {})
+        # one-liner replacement for `stringify_keys`
+        options = options.collect{|k,v| [k.to_s, v]}.to_h
+
+        @name ||= options.dig("name")
+        @target ||= options.dig("target")
+        @source ||= options.dig("source")
+        @links ||= options.dig("links")
+        @ai_id ||= options.dig("aiId")
+        @evaluation ||= Datarobot::AiApi::Evaluation.new(options.dig("evaluation") || {})
+      end
+
+      # Creates a new output on the given target for a given dataset
+      #
+      # @param [String] ai_id The ID of the AI to associate this output with
+      # @param [String] learning_session_id The ID of the learning session
+      # assocaite this output with
+      # @param [String] output_name The name of the output
+      # @return [Datarobot::AiApi::Output]
+      def self.create(ai_id:, learning_session_id:, output_name:)
+        req_body = {learningSessionId: learning_session_id, outputName: output_name}
+        Datarobot::AiApi.request_endpoint("/aiapi/ais/#{ai_id}/outputs/", method: "put", body: req_body) do |data|
+          output = new(data)
+          output.name = output_name
+          output
+        end
+      end
+
+      # gets all feature metadata for learned features of the associated
+      # dataset
+      #
+      # @return [Array]
+      def features
+        raise "no ai id" unless @ai_id
+        Datarobot::AiApi.request_endpoint("/aiapi/ais/#{@ai_id}/outputs/#{@name}/features") do |data|
+          @features = data["features"]
+        end
+      end
+    end
+  end
+end

data/lib/datarobot/ai_api/page.rb

@@ -0,0 +1,50 @@
+module Datarobot
+  module AiApi
+    class Page < Delegator
+      attr_reader :total, :items, :klass, :links
+
+      # Creates a paginated collectoin of objects of type klass. Uses a parsed
+      # response body of paginated data to initialize group of objects
+      def initialize(klass, param_collection)
+        @items = param_collection["data"].map do |params|
+          klass.new(params)
+        end
+        @klass = klass
+        @total = param_collection["total"]
+        if param_collection["links"] # predictions don't have pages
+          @links = param_collection["links"]
+          @next_page = param_collection["links"]["next"]
+          @previous_page = param_collection["links"]["previous"]
+        end
+      end
+
+      # Goes to the next page in the dataset if there is one. Otherwise,
+      # returns the current page
+      # @return [Datarobot::AiApi::Page[klass]]
+      def next_page
+        return self if @next_page.nil?
+
+        Datarobot::AiApi.get(@next_page) do |data|
+          self.class.new(@klass, data)
+        end
+      end
+
+      # Goes to the prevoius page in the dataset if there is one. Otherwise,
+      # returns the current page
+      # @return [Datarobot::AiApi::Page[klass]]
+      def previous_page
+        return self if @previous_page.nil?
+
+        Datarobot::AiApi.get(@previous_page) do |data|
+          self.class.new(@klass, data)
+        end
+      end
+
+      # Allows all Array-like methods to be called on this class. They will be
+      # delegated to @items
+      def __getobj__
+        @items
+      end
+    end
+  end
+end

data/lib/datarobot/ai_api/prediction.rb

@@ -0,0 +1,20 @@
+module Datarobot
+  module AiApi
+    class Prediction
+      attr_reader :prediction, :row_id, :data
+
+      # Takes a response body from the API. Will set all prediction attributes
+      # from the response body
+      #
+      # @param [Hash] options A parsed response body
+      def initialize(options={})
+        # one-liner replacement for `stringify_keys`
+        options = options.collect{|k,v| [k.to_s, v]}.to_h
+
+        @prediction = options.dig("prediction")
+        @row_id = options.dig("rowId")
+        @data = options.dig("data")
+      end
+    end
+  end
+end

data/lib/datarobot/ai_api/refreshable.rb

@@ -0,0 +1,20 @@
+module Datarobot::AiApi::Refreshable
+  # This was initially written to closely align with the other datarobot clients, but `reload` is much more activerecord-y
+  def refresh!
+    raise "cannot refresh #{self.class} - no method `find'" unless self.class.respond_to? :find
+    raise "cannot refresh #{self.class} - no method `set_from_options'" unless respond_to? :set_from_options
+    raise "cannot refresh #{self.class} - object does not have an id" unless @id
+    self.class.find(@id) do |data|
+      set_from_options(data)
+    end
+  end
+
+  def refresh
+    raise "cannot refresh #{self.class} - no method `find'" unless self.class.respond_to? :find
+    raise "cannot refresh #{self.class} - object does not have an id" unless @id
+    self.class.find(@id)
+  end
+
+  alias_method :reload!, :refresh!
+  alias_method :reload, :refresh
+end

data/lib/datarobot/ai_api/task.rb

@@ -0,0 +1,86 @@
+module Datarobot
+  module AiApi
+    class Task
+      include Datarobot::AiApi::Refreshable
+
+      attr_reader :id, :code, :status_type, :status_id, :created_at,
+      :description, :message, :status, :links
+
+      # Given a parsed response body from the API, will create a new leanring sessoin object
+      def initialize(options = {})
+        # Suppresses warnings about uninitialized variables
+        @code = nil
+        @status = nil
+        @status_type = nil
+        @status_id = nil
+        @id = nil
+        @created_at = nil
+        @description = nil
+        @message = nil
+        @links = nil
+
+        set_from_options(options)
+      end
+
+      # Takes a response body from the API. Will set all task attributes from
+      # the response body
+      #
+      # @param [Hash] options A parsed response body
+      # @return [void]
+      def set_from_options(options = {})
+        # one-liner replacement for `stringify_keys`
+        options = options.collect{|k,v| [k.to_s, v]}.to_h
+
+        @code = options.dig("code") || @code
+        @status = options.dig("status") || @status
+        @status_type = options.dig("statusType") || @status_type
+        @status_id = options.dig("statusId") || @status_id
+        @id = options.dig("statusId") || @id
+        @created_at = options.dig("created") || @created_at
+        @description = options.dig("description") || @description
+        @message = options.dig("message") || @message
+        @links = options.dig("links") || @links
+      end
+
+      # Finds a task by id
+      #
+      # @param [String] id The id of the task to find
+      # @return [Datarobot::AiApi::Task]
+      def self.find(id, &block)
+        raise Datarobot::AiApi::NotFoundError, "Cannot find Task with id: nil" if id.nil?
+        Datarobot::AiApi.request_endpoint("/aiapi/status/#{id}") do |data|
+          if block_given?
+            yield data
+          else
+            self.new(data)
+          end
+        end
+      end
+
+      # Stops a task by id
+      #
+      # @param [String] id The id of the task to stop
+      # @return [Datarobot::AiApi::Task]
+      def self.stop(id)
+        Datarobot::AiApi.request_endpoint("/aiapi/status/#{id}", method: "delete")
+      end
+
+      # Waits for a task to complete and returns the resulting object.
+      #
+      # @return [Datarobot::AiApi::*]
+      def wait_until_complete
+        refreshed = self
+        until refreshed.status == 'COMPLETED'
+          sleep 1 unless ENV['FAST_TEST_RESPONSE'] == 'true'
+          refreshed = Datarobot::AiApi::Task.find(@id)
+        end
+
+        result = refreshed.links["result"]
+        Datarobot::AiApi.get(result) do |data|
+          klass = Datarobot::AiApi.determine_object(result)
+          klass.new(data)
+        end
+      end
+    end
+  end
+end