algorithmia 0.2.0 → 0.9.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/algorithmia.rb

@@ -1,18 +1,31 @@
-# Algorithmia Ruby wrapper.
-# Released under the MIT License
-# http://github.com/bih/algorithmia
+require_relative 'algorithmia/algorithm'
+require_relative 'algorithmia/client'
+require_relative 'algorithmia/unauthenticated_client'
+require_relative 'algorithmia/errors'
+require_relative 'algorithmia/requester'
+require_relative 'algorithmia/response'
+require_relative 'algorithmia/version'
+require_relative 'algorithmia/data_object'
+require_relative 'algorithmia/data_file'
+require_relative 'algorithmia/data_directory'
 
-$:.push File.expand_path("../lib", __FILE__)
+module Algorithmia
 
-require 'algorithmia/base'
-require 'algorithmia/version'
-require 'algorithmia/errors'
-require 'algorithmia/authentication'
-require 'algorithmia/result'
-require 'algorithmia/http'
+  class << self
+    def algo(endpoint)
+      Algorithmia::UnauthenticatedClient.new.algo(endpoint)
+    end
 
-class Algorithmia
-	def self.call(endpoint, input)
-		post_http("/#{endpoint}", input.to_json)
-	end
-end
+    def file(data_uri)
+      Algorithmia::UnauthenticatedClient.new.file(data_uri)
+    end
+
+    def dir(data_uri)
+      Algorithmia::UnauthenticatedClient.new.dir(data_uri)
+    end
+
+    def client(api_key)
+      Algorithmia::Client.new(api_key)
+    end
+  end
+end

data/lib/algorithmia/algorithm.rb

@@ -0,0 +1,49 @@
+module Algorithmia
+  class Algorithm
+
+    def initialize(client, endpoint)
+      @client = client
+      @endpoint = '/v1/algo/' + endpoint
+      @query = {
+        timeout: 300,
+        stdout: false,
+        output: 'default'
+      }
+    end
+
+    def set_options(options_hash)
+      @query_options.update(options_hash)
+    end
+
+    def set_timeout(timeout)
+      @query_options[:timeout] = timeout.to_i
+    end
+
+    def enable_stdout
+      @query_options[:stdout] = true
+    end
+
+    def pipe(input)
+      content_type = case
+        when input.kind_of?(String) && input.encoding == Encoding::ASCII_8BIT
+          'application/octet-stream'
+        when input.kind_of?(String)
+          'text/plain'
+        else
+          'application/json'
+        end
+
+      headers = {
+        'Content-Type' => content_type
+      }
+
+      response = Algorithmia::Requester.new(@client).post(@endpoint, input, query: @query, headers: headers)
+      Algorithmia::Response.new(response.parsed_response)
+    end
+
+    def pipe_json(input)
+      response = Algorithmia::Requester.new(@client).post(@endpoint, input, query: @query, headers: {})
+      Algorithmia::Response.new(response.parsed_response)
+    end
+  end
+end

data/lib/algorithmia/client.rb

@@ -0,0 +1,21 @@
+module Algorithmia
+  class Client
+    attr_reader :api_key
+
+    def initialize(api_key)
+      @api_key = api_key
+    end
+
+    def algo(endpoint)
+      Algorithmia::Algorithm.new(self, endpoint)
+    end
+
+    def file(endpoint)
+      Algorithmia::DataFile.new(self, endpoint)
+    end
+
+    def dir(endpoint)
+      Algorithmia::DataDirectory.new(self, endpoint)
+    end
+  end
+end

data/lib/algorithmia/data_directory.rb

@@ -0,0 +1,91 @@
+require 'uri'
+
+module Algorithmia
+  class DataDirectory < DataObject
+
+    def exists?
+      Algorithmia::Requester.new(@client).get(@url)
+      true
+    rescue Errors::NotFoundError
+      false
+    end
+
+    def create
+      parent, name = File.split(@url)
+      Algorithmia::Requester.new(@client).post(parent, name: name)
+      true
+    end
+
+    def delete(force = false)
+      query = {}
+      query[:force] = true if force
+      Algorithmia::Requester.new(@client).delete(@url, query: query)
+      true
+    end
+
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      list(block) do |dir|
+        extract_files(dir) + extract_folders(dir)
+      end
+    end
+
+    def each_file(&block)
+      return enum_for(:each_file) unless block_given?
+
+      list(block) do |dir|
+        extract_files(dir)
+      end
+    end
+
+    def each_dir(&block)
+      return enum_for(:each_dir) unless block_given?
+
+      list(block) do |dir|
+        extract_folders(dir)
+      end
+    end
+
+    def file(file_name)
+      @client.file(URI.encode(File.join(@data_uri, file_name)))
+    end
+
+    def put_file(file_path)
+      file(File.basename(file_path)).put_file(file_path)
+    end
+
+    private
+
+    def extract_files(dir)
+      files = dir.parsed_response['files'] || []
+      files.map do |f|
+        file(f['filename'])
+      end
+    end
+
+    def extract_folders(dir)
+      folders = dir.parsed_response['folders'] || []
+      folders.map do |f|
+        @client.dir(URI.encode(File.join(@data_uri, f['name'])))
+      end
+    end
+
+    def list(each_proc)
+      marker = nil
+
+      loop do
+        query = {}
+        query[:marker] = marker if marker
+
+        dir = Algorithmia::Requester.new(@client).get(@url, query: query)
+
+        items = yield dir
+        items.each(&each_proc)
+
+        marker = dir.parsed_response['marker']
+        break unless marker && !marker.empty?
+      end
+    end
+  end
+end

data/lib/algorithmia/data_file.rb

@@ -0,0 +1,55 @@
+require 'tempfile'
+
+module Algorithmia
+  class DataFile < DataObject
+
+    def exists?
+      Algorithmia::Requester.new(@client).head(@url)
+      true
+    rescue Errors::NotFoundError
+      false
+    end
+
+    def get_file
+      response = get
+
+      tempfile = Tempfile.open(File.basename(@url)) do |f|
+        f.write response
+        f
+      end
+
+      File.new(tempfile.path)
+    end
+
+    def get
+      Algorithmia::Requester.new(@client).get(@url).body
+    end
+
+    def put(data)
+      content_type = case
+        when data.kind_of?(String) && data.encoding == Encoding::ASCII_8BIT
+          'application/octet-stream'
+        when data.kind_of?(String)
+          'text/plain'
+        else
+          'application/json'
+      end
+
+      headers = {'Content-Type' => content_type }
+      Algorithmia::Requester.new(@client).put(@url, data, headers: headers)
+      true
+    end
+
+    alias_method :put_json, :put
+
+    def put_file(file_path)
+      data = File.binread(file_path)
+      put(data)
+    end
+
+    def delete
+      Algorithmia::Requester.new(@client).delete(@url)
+      true
+    end
+  end
+end

data/lib/algorithmia/data_object.rb

@@ -0,0 +1,26 @@
+module Algorithmia
+  class DataObject
+    attr_reader :data_uri
+
+    def initialize(client, data_uri)
+      @client = client
+      @data_uri = data_uri
+      sanitize_data_uri
+    end
+
+    def basename
+      File.basename(@url)
+    end
+
+    def parent
+      @client.dir(File.split(@data_uri).first)
+    end
+
+    private
+
+    def sanitize_data_uri
+      file_path = @data_uri.gsub('data://', '')
+      @url = File.join('/v1/data/', file_path)
+    end
+  end
+end

data/lib/algorithmia/errors.rb

@@ -1,6 +1,20 @@
-# Algorithmia Ruby wrapper.
-# Released under the MIT License
-# http://github.com/bih/algorithmia
+module Algorithmia
+  module Errors
+    class Error < StandardError
+      attr_reader :response
 
-class AlgorithmiaException < Exception; end
-class AlgorithmiaApiKeyTooShort < Exception; end
+      def initialize(message, response)
+        super(message)
+        @response = response
+      end
+    end
+
+    class ApiKeyEmptyError < Error; end
+    class ApiKeyInvalidError < Error; end
+    class InternalServerError < Error; end
+    class JsonParseError < Error; end
+    class NotFoundError < Error; end
+    class UnauthorizedError < Error; end
+    class UnknownError < Error; end
+  end
+end

data/lib/algorithmia/requester.rb

@@ -0,0 +1,104 @@
+require 'httparty'
+
+module Algorithmia
+  class Requester
+    include HTTParty
+    base_uri "https://api.algorithmia.com"
+
+    def initialize(client)
+      @client = client
+      @default_headers = {
+        'Authorization' => @client.api_key || '',
+        'Content-Type' => 'application/json',
+        'User-Agent' => 'Algorithmia Ruby Client'
+      }
+    end
+
+    def get(endpoint, query: {}, headers: {})
+      headers = merge_headers(headers)
+      response = self.class.get(endpoint, query: query, headers: headers)
+      check_for_errors(response)
+      response
+    end
+
+    def post(endpoint, body, query: {}, headers: {})
+      headers = merge_headers(headers)
+
+      if headers['Content-Type'] == 'application/json'
+        body = body.to_json
+      end
+
+      response = self.class.post(endpoint, body: body, query: query, headers: headers)
+      check_for_errors(response)
+      response
+    end
+
+    def put(endpoint, body, query: {}, headers: {})
+      headers = merge_headers(headers)
+
+      if headers['Content-Type'] == 'application/json'
+        body = body.to_json
+      end
+
+      response = self.class.put(endpoint, body: body, query: query, headers: headers)
+      check_for_errors(response)
+      response
+    end
+
+    def head(endpoint)
+      response = self.class.head(endpoint, headers: @default_headers)
+      check_for_errors(response)
+      response
+    end
+
+    def delete(endpoint, query: {})
+      response = self.class.delete(endpoint, query: query, headers: @default_headers)
+      check_for_errors(response)
+      response
+    end
+
+    private
+
+    def check_for_errors(response)
+      if response.code >= 200 && response.code < 300
+        parse_error_message(response) if response['error']
+        return
+      end
+
+
+      case response.code
+      when 401
+        raise Errors::UnauthorizedError.new("The request you are making requires authorization. Please check that you have permissions & that you've set your API key.", response)
+      when 400
+        parse_error_message(response)
+      when 404
+        raise Errors::NotFoundError.new("The URI requested is invalid or the resource requested does not exist.", response)
+      when 500
+        raise Errors::InternalServerError.new("Whoops! Something is broken.", response)
+      else
+        raise Errors::UnknownError.new("The error you encountered returned the message: #{response["error"]["message"]} with stacktrace: #{error["stacktrace"]}", response)
+      end
+    end
+
+    def parse_error_message(response)
+      error = response['error']
+
+      case error["message"]
+      when 'authorization required'
+        raise Errors::ApiKeyInvalidError.new("The API key you sent is invalid! Please set `Algorithmia::Client.api_key` with the key provided with your account.", response)
+      when 'Failed to parse input, input did not parse as valid json'
+        raise Errors::JsonParseError.new("Unable to parse the input. Please make sure it matches the expected input of the algorithm and can be parsed into JSON.", response)
+      else
+        if error["stacktrace"].nil?
+          raise Errors::UnknownError.new("The error you encountered returned the message: #{error["message"]}", response)
+        else
+          raise Errors::UnknownError.new("The error you encountered returned the message: #{error["message"]} with stacktrace: #{error["stacktrace"]}", response)
+        end
+      end
+    end
+
+    def merge_headers(headers = {})
+      @default_headers.merge(headers)
+    end
+  end
+end

data/lib/algorithmia/response.rb

@@ -0,0 +1,39 @@
+require "base64"
+
+module Algorithmia
+  class Response
+    attr_reader :json
+
+    def initialize(result)
+      @json = result
+    end
+
+    def result
+      if content_type == 'binary'
+        Base64.decode64(@json["result"])
+      else
+        @json["result"]
+      end
+    end
+
+    def metadata
+      @json["metadata"]
+    end
+
+    def duration
+      metadata["duration"]
+    end
+
+    def content_type
+      metadata["content_type"]
+    end
+
+    def stdout
+      metadata["stdout"]
+    end
+
+    def alerts
+      metadata["alerts"]
+    end
+  end
+end