clarinet 0.5.1

data/lib/clarinet/inputs.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Clarinet
+  class Inputs
+    extend Forwardable
+
+    # @!method []
+    #   @see Array#[]
+    #   @return [Clarinet::Model]
+    # @!method each
+    #   @see Array#each
+    # @!method map
+    #   @see Array#map
+    # @!method find
+    #   @see Array#find
+    # @!method select
+    #   @see Array#select
+    # @!method select
+    #   @see Array#select
+    delegate [:[], :each, :map, :find, :select, :reject] => :@inputs
+
+    # @!visibility private
+    def initialize(app, raw_data = [])
+      @app = app
+
+      @raw_data = raw_data
+
+      @inputs = raw_data.map do |input_data|
+        Clarinet::Input.new app, input_data
+      end
+    end
+
+    # Adds an input or multiple inputs
+    # @return [Clarinet::Inputs] Instance of Inputs
+    def create(inputs)
+      inputs = [inputs] unless inputs.is_a? Array
+      inputs = inputs.map { |input| Clarinet::Utils.format_input(input) }
+
+      data = @app.client.inputs_create inputs
+      Clarinet::Inputs.new data[:inputs]
+    end
+
+    # Delete an input or a list of inputs by id
+    # @return [Hash] API response
+    def delete(id)
+      @app.client.input_delete id if id.is_a? String
+      @app.client.inputs_delete id if id.is_a? Array
+    end
+
+    # Delete all inputs
+    # @return [Hash] API response
+    def delete_all
+      @app.client.inputs_delete_all
+    end
+
+    # Get all inputs in app
+    # @param options [Hash] Listing options
+    # @option options [Int] :page (1) The page number
+    # @option options [Int] :per_page (20) Number of models to return per page
+    # @return [Clarinet::Inputs] Inputs instance
+    def list(options = { page: 1, per_page: 20 })
+      data = @app.client.inputs options
+      Clarinet::Inputs.new @app, data[:inputs]
+    end
+
+    # Get input by id
+    # @param id [String] The input id
+    # @return [Clarinet::Input] Input instance
+    def get(id)
+      data = @app.client.input id
+      Clarinet::Input.new @app, data[:input]
+    end
+
+    # Get inputs status (number of uploaded, in process or failed inputs)
+    # @return [Hash] API response
+    def status
+      @app.client.inputs_status
+    end
+
+    def merge_concepts(inputs)
+      update 'merge', inputs
+    end
+
+    def overwrite_concepts(inputs)
+      update 'overwrite', inputs
+    end
+
+    def delete_concepts(inputs)
+      update 'remove', inputs
+    end
+
+    private
+
+      def update(action, inputs)
+        inputs = [inputs] unless inputs.is_a? Array
+        inputs = inputs.map { |input| Clarinet::Utils.format_input(input) }
+
+        data = {
+          action: action,
+          inputs: inputs
+        }
+
+        response_data = @app.client.inputs_update data
+        Clarinet::Inputs.new @app, response_data[:inputs]
+      end
+
+  end
+end

data/lib/clarinet/model.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'httparty'
+
+module Clarinet
+  class Model
+
+    GENERAL = 'aaa03c23b3724a16a56b629203edc62c'
+    FOOD = 'bd367be194cf45149e75f01d59f77ba7'
+    TRAVEL = 'eee28c313d69466f836ab83287a54ed9'
+    NSFW = 'e9576d86d2004ed1a38ba0cf39ecb4b1'
+    WEDDINGS = 'c386b7a870114f4a87477c0824499348'
+    COLOR = 'eeed0b6733a644cea07cf4c60f87ebb7'
+
+    MAX_INPUT_COUNT = 128
+
+    # @return [Hash] Raw API data used to construct this instance
+    attr_reader :raw_data
+
+    # @return [String] Model id
+    attr_reader :id
+
+    # @return [String] Model name
+    attr_reader :name
+
+    # @return [String] Created at timestamp
+    attr_reader :created_at
+
+    # @return [String]
+    attr_reader :app_id
+
+    # @return [Hash]
+    attr_reader :output_info
+
+    # @return [String]
+    attr_reader :model_version
+
+    # @!visibility private
+    def initialize(app, raw_data)
+      @app = app
+
+      @raw_data = raw_data
+
+      @id = raw_data[:id]
+      @name = raw_data[:name]
+      @created_at = raw_data[:created_at]
+      @app_id = raw_data[:app_id]
+      @output_info = raw_data[:output_info]
+
+      @model_version = raw_data[:model_version]
+    end
+
+    # Returns all the model's output info
+    # @return [Clarinet::Model] Model instance with complete output_info data
+    def get_output_info
+      response_data = @app.client.model_output_info @id
+      Clarinet::Model.new @app, response_data[:model]
+    end
+
+    # Returns model ouputs according to inputs
+    # @param inputs [String, Hash, Array<String>, Array<Hash>] An array of objects/object/string pointing to
+    #   an image resource. A string can either be a url or base64 image bytes. Object keys explained below:
+    # @!macro predict_inputs
+    #   @option inputs [Hash] :image Object with at least +:url+ or +:base64+ key as explained below:
+    #     * +:url+ (String) A publicly accessibly
+    #     * +:base64+ (String) Base64 string representing image bytes
+    #     * +:crop+ (Array<Float>) An array containing the percent to be cropped from top, left, bottom and right
+    # @return [Hash] API response
+    def predict(inputs, config = {})
+      video = config[:video] || false
+      config.delete :video
+
+      inputs = [inputs] unless inputs.is_a? Array
+      inputs = inputs.map { |input| Clarinet::Utils.format_media_predict(input) }
+
+      @app.client.outputs id, inputs, config
+    end
+
+    # Returns a list of versions of the model
+    # @param options [Hash] Listing options
+    # @option options [Int] :page (1) The page number
+    # @option options [Int] :per_page (20) Number of models to return per page
+    # @return [Hash] API response
+    def versions(options = { page: 1, per_page: 20 })
+      @app.client.model_versions @id, options
+    end
+
+    # Remove concepts from a model
+    # @param concepts [Array<Hash>] List of concept hashes with id
+    # @return [Clarinet::Model] Model instance
+    def delete_concepts(concepts)
+      concepts = [concepts] unless concepts.is_a? Array
+      update 'remove', { concepts: concepts }
+    end
+
+    # Merge concepts to a model
+    # @param (see #delete_concepts)
+    # @return (see #delete_concepts)
+    def merge_concepts(concepts)
+      concepts = [concepts] unless concepts.is_a? Array
+      update 'merge', { concepts: concepts }
+    end
+
+    # Overwrite concepts in a model
+    # @param (see #delete_concepts)
+    # @return (see #delete_concepts)
+    def overwrite_concepts(concepts)
+      concepts = [concepts] unless concepts.is_a? Array
+      update 'merge', { concepts: concepts }
+    end
+
+    # Create a new model version
+    # @note Training takes some time and the new version will not be immediately available.
+    # @return [Clarinet::Model] Model instance
+    def train
+      response_data = @app.client.model_train @id
+      Clarinet::Model.new @app, response_data[:model]
+    end
+
+    private
+
+      def update(action, obj)
+        model_data = obj.merge id: @id
+        data = {
+          models: [Clarinet::Utils.format_model(model_data)]
+        }
+
+        response_data = @app.client.models_update data
+        Clarinet::Model.new @app, response_data[:models].first
+      end
+
+  end
+end

data/lib/clarinet/models.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Clarinet
+  class Models
+    extend Forwardable
+
+    # @!method []
+    #   @see Array#[]
+    #   @return [Clarinet::Model]
+    # @!method each
+    #   @see Array#each
+    # @!method map
+    #   @see Array#map
+    # @!method find
+    #   @see Array#find
+    # @!method first
+    #   @see Array#first
+    # @!method last
+    #   @see Array#last
+    # @!method select
+    #   @see Array#select
+    # @!method select
+    #   @see Array#select
+    delegate [:[], :each, :map, :find, :first, :last, :select, :reject, :size] => :@models
+
+    # @return [Hash] Raw API data used to construct this instance
+    attr_reader :raw_data
+
+    # @!visibility private
+    def initialize(app, raw_data = [])
+      @app = app
+      @raw_data = raw_data
+
+      @models = raw_data.map do |model_data|
+        Clarinet::Model.new app, model_data
+      end
+    end
+
+    # Returns a Model instance given model id or name. It will call search if name is given.
+    # @param model [String, Hash, Clarinet::Model]
+    #   If String, it is assumed to be model id. Otherwise, if Hash is given, it can have any of the following keys:
+    # @option model [String] :id Model id
+    # @option model [String] :name Model name
+    # @option model [String] :version Model version
+    # @option model [String] :type (nil) This can be "concept", "color", "embed", "facedetect", "cluster" or "blur"
+    # @return [Clarinet::Model] Model instance corresponding to the given id
+    #   or the first search result
+    def init_model(model)
+      model_data = {}
+
+      model_data[:id] = model if model.is_a? String
+      model_data = model if model.is_a? Hash
+      model_data = model.raw_data if model.is_a? Clarinet::Model
+
+      return Clarinet::Model.new @app, model_data if model_data[:id]
+
+      search_results = search model_data[:name], model_data[:type]
+
+      return search_results.find { |result| result.model_version.id == model_data[:version] }.first if model_data[:version]
+
+      search_results.first
+    end
+
+    # Predict using a specific model
+    # @param model (see #init_model)
+    # @param inputs (see Clarinet::Model#predict)
+    # @macro predict_inputs
+    # @return [Hash] Data returned by the API with symbolized keys
+    def predict(model, inputs)
+      init_model(model).predict(inputs)
+    end
+
+    # Return all the models
+    # @param options [Hash] Listing options
+    # @option options [Int] :page (1) The page number
+    # @option options [Int] :per_page (20) Number of models to return per page
+    # @return [Clarinet::Models]
+    def list(options = { page: 1, per_page: 20 })
+      data = @app.client.models options
+      Clarinet::Models.new @app, data[:models]
+    end
+
+    # Returns a model specified by ID
+    # @param id [String] The model's id
+    # @return [Clarinet::Model] Model instance
+    def get(id)
+      data = @app.client.model id
+      Clarinet::Model.new @app, data[:model]
+    end
+
+    # Search for models by name or type
+    # @param name [String] The model name
+    # @param type [String] This can be "concept", "color", "embed", "facedetect", "cluster" or "blur"
+    # @return [Clarinet::Models] Models instance
+    def search(name, type = nil)
+      query = {
+        name: name,
+        type: type
+      }
+
+      data = @app.client.models_search query
+      Clarinet::Models.new @app, data[:models]
+    end
+
+  end
+end

data/lib/clarinet/status.rb

@@ -0,0 +1,13 @@
+module Clarinet
+  module Status
+    SUCCESS = 10000
+
+    INVALID_AUTH_TOKEN = 11001
+    API_KEY_NOT_FOUND = 11009
+
+    BAD_REQUEST_FORMAT = 11100
+    INVALID_REQUEST = 11102
+
+    IMAGE_DECODING_FAILED = 30300
+  end
+end

data/lib/clarinet/utils.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'addressable/uri'
+
+module Clarinet
+  # @!visibility private
+  class Utils
+
+    def self.check_response_status(status)
+      status_code = status[:code]
+
+      return if status_code == Clarinet::Status::SUCCESS
+
+      error_class = Clarinet::Error::ApiError
+      error_class = Clarinet::Error::InvalidAuthTokenError if status_code == Clarinet::Status::INVALID_AUTH_TOKEN
+      error_class = Clarinet::Error::ApiKeyNotFoundError if status_code == Clarinet::Status::API_KEY_NOT_FOUND
+      error_class = Clarinet::Error::BadRequestFormatError if status_code == Clarinet::Status::BAD_REQUEST_FORMAT
+      error_class = Clarinet::Error::InvalidRequestError if status_code == Clarinet::Status::INVALID_REQUEST
+      error_class = Clarinet::Error::ImageDecodingError if status_code == Clarinet::Status::IMAGE_DECODING_FAILED
+
+      new_error = error_class.new status[:description]
+      new_error.code = status_code
+      new_error.description = status[:description]
+      new_error.details = status[:details]
+      raise new_error
+    end
+
+    def self.format_model(model_data)
+      formatted = {
+        id: model_data[:id]
+      }
+
+      formatted[:name] = model_data[:name] if model_data.key? :name
+
+      output_info = {}
+      if model_data.key? :concepts_mutually_exclusive
+        output_info[:output_config] = output_info[:output_config] || {}
+        output_info[:output_config][:concepts_mutually_exclusive] = model_data[:concepts_mutually_exclusive]
+      end
+
+      if model_data.key? :closed_environment
+        output_info[:output_config] = output_info[:output_config] || {}
+        output_info[:output_config][:closed_environment] = model_data[:closed_environment]
+      end
+
+      if model_data.key? :concepts
+        output_info[:data] = {
+          concepts: model_data[:concepts].map { |c| format_concept(c) }
+        }
+      end
+
+      formatted[:output_info] = output_info
+      formatted
+    end
+
+    def self.format_concept(concept_data)
+      return { id: concept_data } if concept_data.is_a? String
+      concept_data
+    end
+
+    def self.format_input(input_data, include_image = true)
+      input_data = { url: input_data } if input_data.is_a? String
+
+      formatted = {
+        id: input_data[:id],
+        data: {}
+      }
+
+      formatted[:data][:concepts] = input_data.concepts if input_data.key? :concepts
+      formatted[:data][:metadata] = input_data.metadata if input_data.key? :metadata
+      formatted[:data][:geo] = { geo_point: input_data.geo } if input_data.key? :geo
+
+      if include_image
+        formatted[:data][:image] = {
+          url: input_data[:url],
+          base64: input_data[:base64],
+          crop: input_data[:crop],
+          allow_duplicate_url: input_data.fetch(:allow_duplicate_url, false)
+        }
+      end
+
+      formatted
+    end
+
+    def self.format_media_predict(input_data, type = :image)
+      if input_data.is_a? String
+        input_data = { base64: input_data } unless valid_url? input_data
+        input_data = { url: input_data } if valid_url? input_data
+      end
+
+      data = {}
+      data[type] = input_data
+      { data: data }
+    end
+
+    private_class_method def self.valid_url?(url)
+      uri = Addressable::URI.parse url
+      uri.scheme == 'http' || uri.scheme == 'https'
+    end
+
+  end
+end