scaleapi 0.1.0

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "scaleapi/ruby"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

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/scale.rb

@@ -0,0 +1,94 @@
+class Scale
+  attr_accessor :api_key, :callback_auth_key, :default_request_params, :logging
+
+  def self.validate_api_key(api_key)
+    if api_key.length < 5 || !(api_key.start_with?('live') || api_key.start_with?('test')) 
+      raise Api::APIKeyInvalid
+    end
+  end
+
+  def initialize(api_key: nil, callback_auth_key: nil, default_request_params: {}, logging: false, callback_url: nil)
+    Scale.validate_api_key(api_key)
+
+    self.api_key = api_key
+    self.callback_auth_key = callback_auth_key
+    self.default_request_params = default_request_params.merge(callback_url: callback_url)
+    self.logging = logging
+  end
+
+  def live?
+    api_key.start_with?('live')
+  end
+
+  def test?
+    api_key.start_with?('test')
+  end
+
+  def client
+    @client ||= Api.new(api_key, callback_auth_key, default_request_params, logging)
+  end
+
+  def tasks
+    @tasks ||= Scale::Api::Tasks.new(client)
+  end
+
+  def create_datacollection_task(args = {})
+    Api::Tasks::Datacollection.create(args.merge(client: client))
+  end
+
+  def create_categorization_task(args = {})
+    Api::Tasks::Categorization.create(args.merge(client: client))
+  end
+
+  def create_comparison_task(args = {})
+    Api::Tasks::Comparison.create(args.merge(client: client))
+  end
+
+  def create_image_recognition_task(args = {})
+    Api::Tasks::ImageRecognition.create(args.merge(client: client))
+  end
+
+  def create_phone_call_task(args = {})
+    Api::Tasks::PhoneCall.create(args.merge(client: client))
+  end
+
+  def create_transcription_task(args = {})
+    Api::Tasks::Transcription.create(args.merge(client: client))
+  end
+
+  def create_audio_transcription_task(args = {})
+    Api::Tasks::AudioTranscription.create(args.merge(client: client))
+  end
+
+  def build_callback(params, callback_key: nil)
+    callback = Api::Callback.new(params, callback_key: callback_key, client: client)
+    
+    if block_given?
+      yield callback
+    else 
+      callback
+    end
+  end
+
+  alias_method :live, :live?
+  alias_method :test, :test?
+  alias_method :live_mode?, :live?
+  alias_method :test_mode?, :test?
+  alias_method :create_annotation_task, :create_image_recognition_task
+  alias_method :create_phonecall_task, :create_phone_call_task
+  alias_method :create_audiotranscription_task, :create_audio_transcription_task
+end
+
+require 'scale/api'
+require 'scale/api/errors'
+require 'scale/api/callback'
+require 'scale/api/tasks'
+require 'scale/api/tasks/audio_transcription'
+require 'scale/api/tasks/base_task'
+require 'scale/api/tasks/datacollection'
+require 'scale/api/tasks/categorization'
+require 'scale/api/tasks/comparison'
+require 'scale/api/tasks/image_recognition'
+require 'scale/api/tasks/phone_call'
+require 'scale/api/tasks/transcription'
+require 'scale/api/task_list'

data/lib/scale/api.rb

@@ -0,0 +1,75 @@
+require 'uri'
+require 'faraday'
+require 'json'
+
+class Scale
+  class Api < Struct.new(:api_key, :callback_auth_key, :default_request_params, :logging)
+    SCALE_API_URL = 'https://api.scaleapi.com/v1/'
+
+    def connection
+      @connection ||= Faraday.new(:url => SCALE_API_URL) do |faraday|
+        faraday.request  :basic_auth, self.api_key, ''
+        faraday.request  :url_encoded             # form-encode POST params
+        faraday.response :logger if logging       # log requests to STDOUT
+        faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+      end
+    end
+
+    def get(url, params = {})
+      response = connection.get do |req|
+        req.url "#{SCALE_API_URL}#{url}"
+        req.params.merge!(default_request_params.merge(params))
+        req.headers['X-API-Client'] = "Ruby"
+        req.headers["X-API-Client-Version"] = '0.1.0'
+      end
+
+      if response.status != 200
+        return handle_error(response)
+      end
+
+      response
+    rescue Faraday::Error::ConnectionFailed
+      raise Scale::Api::ConnectionError
+    end
+
+    def post(url, body = {})
+      body.delete(:callback_url) if body.keys.include?(:callback_url) && body[:callback_url].nil?
+      body = default_request_params.merge(body)
+
+      response = connection.post do |req|
+        req.url "#{SCALE_API_URL}#{url}"
+        req.headers['Content-Type'] = 'application/json'
+        req.body = body.to_json
+        req.headers['X-API-Client'] = "Ruby"
+        req.headers["X-API-Client-Version"] = '0.1.0'
+      end
+
+      if response.status != 200
+        return handle_error(response)
+      end
+
+      response
+    rescue Faraday::Error::ConnectionFailed
+      raise Scale::Api::ConnectionError
+    end
+
+    def handle_error(response)
+      error_body = JSON.parse(response.body)
+      if response.status == 404
+        raise Scale::Api::NotFound.new(error_body['error'], response.status)
+      elsif response.status == 429
+        raise Scale::Api::TooManyRequests.new(error_body['error'], response.status)
+      elsif response.status > 499
+        raise Scale::Api::InternalServerError.new(error_body['error'], response.status)
+      elsif response.status == 401
+        raise Scale::Api::Unauthorized.new(error_body['error'], response.status)
+      else
+        raise Scale::Api::BadRequest.new(error_body['error'], response.status)
+      end
+    rescue JSON::ParserError
+      raise Scale::Api::InternalServerError
+    end
+  end
+end
+
+require 'scale/api/errors'

data/lib/scale/api/callback.rb

@@ -0,0 +1,29 @@
+class Scale
+  class Api
+    class Callback
+      attr_reader :client, :response, :task, :task_id, :request_callback_key
+
+      def initialize(params, callback_key: nil, client: nil)
+        @client = client
+        @response = params[:response]
+        @request_callback_key = callback_key
+
+        if params['task']
+          @task_id = params['task']['id']
+          @task = Scale::Api::Tasks::BaseTask.from_hash(params['task'].merge('client' => client))
+        end
+      end
+
+      def verified?
+        Callback.valid_callback_auth_key?(request_callback_key, client.callback_auth_key)
+      end
+
+      def self.valid_callback_auth_key?(callback_key, request_callback_key)
+        !!(callback_key && request_callback_key && request_callback_key == callback_key)
+      end
+    end
+  end
+end
+
+require 'scale/api/tasks'
+require 'scale/api/tasks/base_task'

data/lib/scale/api/errors.rb

@@ -0,0 +1,46 @@
+class Scale
+  class Api
+    class Error < StandardError
+      attr_accessor :status_code
+
+      def initialize(message = 'Please double check the request was properly formed and try again', status_code = 400)
+        super(message)
+        self.status_code = status_code
+      end
+    end
+
+    class BadRequest < Error
+    end
+
+    class TooManyRequests < Error
+    end
+
+    class NotFound < Error
+    end
+
+    class Unauthorized < Error
+      def initialize(message = "Please ensure that the api_key provided is correct. To find your API key, go to your Scale Dashboard", status_code = 401)
+        super(message, status_code)
+      end
+    end
+
+    class InternalServerError < Error
+      def initialize(message = "Scale's servers are currently experiencing issues. Please wait a moment and try again.", status_code = 500)
+        super(message, status_code)
+      end
+    end
+
+    class ConnectionError < Error
+      def initialize(message = "There's an issue connecting to Scale's servers. Please check you're connected to the internet, and try again.'", status_code = nil)
+        super(message, status_code)
+      end
+    end
+
+    class APIKeyInvalid < Error
+      def initialize(message = "Provided api_key is invalid. Please double check you passed it in correctly and try again. If you're having trouble finding it, check your Scale Dashboard", status_code = nil)
+        super(message, status_code)
+      end
+    end
+
+  end
+end

data/lib/scale/api/task_list.rb

@@ -0,0 +1,55 @@
+require 'scale/api/tasks/base_task'
+require 'scale/api/tasks/audio_transcription'
+require 'scale/api/tasks/datacollection'
+require 'scale/api/tasks/categorization'
+require 'scale/api/tasks/comparison'
+require 'scale/api/tasks/image_recognition'
+require 'scale/api/tasks/phone_call'
+require 'scale/api/tasks/transcription'
+
+class Scale
+  class Api
+    class TaskList
+      include Enumerable
+      extend Forwardable
+      def_delegators :@docs, :each, :<<, :[], :[]=, :length, :count
+      attr_accessor :client, :docs, :limit, :offset, :has_more, :params
+      TASK_TYPES_TO_CLASSNAMES = {
+        'audiotranscription' => ::Scale::Api::Tasks::AudioTranscription,
+        'categorization' => ::Scale::Api::Tasks::Categorization,
+        'comparison' => ::Scale::Api::Tasks::Comparison,
+        'datacollection' => ::Scale::Api::Tasks::Datacollection,
+        'annotation' => ::Scale::Api::Tasks::ImageRecognition,
+        'phonecall' => ::Scale::Api::Tasks::PhoneCall,
+        'transcription' => ::Scale::Api::Tasks::Transcription
+      }.freeze
+
+      def initialize(client: nil, docs: [], limit: 99, offset: 0, has_more: false, params: {})
+        self.client = client
+        self.docs = docs.map do |doc|
+          ::Scale::Api::Tasks::BaseTask.from_hash(doc.merge('client' => client))
+        end
+
+        self.limit = limit
+        self.offset = offset
+        self.has_more = has_more
+        self.params = params # Used to get next page
+      end
+
+      def has_more?
+        !!has_more
+      end
+
+      def page
+        (offset + (limit * 1)) / limit
+      end
+
+      def next_page
+        next_page_params = params.dup
+        params[:offset] = params[:limit] + params[:offset]
+        Scale::Api::Tasks.new(client).list(params)
+      end
+
+    end
+  end
+end

data/lib/scale/api/tasks.rb

@@ -0,0 +1,55 @@
+class Scale
+  class Api
+    class Tasks < Struct.new(:client)
+      def list(start_time: nil, end_time: nil, limit: 99, offset: 0, type: nil, status: nil)
+        params = {
+          start_time: start_time ? start_time.iso8601 : nil,
+          end_time: end_time ? end_time.iso8601 : nil,
+          limit: limit,
+          offset: offset,
+          status: status,
+          type: type
+        }
+
+        response = client.get('tasks', params)
+        body = JSON.parse(response.body)
+
+        TaskList.new({
+          client: client,
+          docs: body['docs'],
+          limit: body['limit'],
+          offset: body['offset'],
+          has_more: body['has_more'],
+          params: params
+        })
+      end
+      
+      def find(task_id)
+        response = client.get("task/#{task_id}")
+        BaseTask.from_hash(JSON.parse(response.body).merge('client' => client))
+      end
+
+      def cancel(task_id)
+        response = client.post("task/#{task_id}/cancel")
+        BaseTask.from_hash(JSON.parse(response.body).merge('client' => client))
+      end
+
+      def create(args = {})
+        raise ArgumentError.new('Task type is required') if (args[:type].nil? && args['type'].nil?)
+        klass = ::Scale::Api::TaskList::TASK_TYPES_TO_CLASSNAMES[(args[:type] || args['type']).to_s]
+        
+        unless klass
+          raise ArgumentError.new('Unsupported task type. Supported task types: ' + ::Scale::Api::TaskList::TASK_TYPES_TO_CLASSNAMES.keys.join(','))
+        end
+
+        args.delete(:type)
+        klass.create(args.merge(client: client))
+      end
+
+      alias_method :all, :list
+      alias_method :where, :list
+    end
+  end
+end
+
+require 'scale/api/task_list'

data/lib/scale/api/tasks/audio_transcription.rb

@@ -0,0 +1,26 @@
+require 'json'
+require 'scale/api/tasks/base_task'
+
+class Scale
+  class Api
+    class Tasks
+      class AudioTranscription < BaseTask
+        CREATE_PATH = 'task/audiotranscription'.freeze
+
+        def self.create(callback_url: nil, instruction: nil, attachment_type: 'audio', attachment: nil, verbatim: false, urgency: 'day', metadata: {}, client: nil)
+          response = client.post(CREATE_PATH, {
+            callback_url: callback_url,
+            instruction: instruction,
+            attachment_type: attachment_type,
+            attachment: attachment,
+            verbatim: verbatim,
+            urgency: urgency,
+            metadata: metadata
+          })
+
+          AudioTranscription.new(JSON.parse(response.body))
+        end
+      end
+    end
+  end
+end

data/lib/scale/api/tasks/base_task.rb

@@ -0,0 +1,71 @@
+require 'time'
+
+class Scale
+  class Api
+    class Tasks
+      class BaseTask
+        attr_accessor :client
+        ATTRIBUTES = %w(task_id type instruction params urgency response callback_url created_at status completed_at callback_succeeded_at metadata).freeze
+        ATTRIBUTES.each { |attr| attr_reader attr }
+
+        alias_method :id, :task_id
+
+        def self.from_hash(hash)
+          klass = ::Scale::Api::TaskList::TASK_TYPES_TO_CLASSNAMES[(hash[:type] || hash['type']).to_s] || self
+          klass.new(hash)
+        end
+
+        def cancel!
+          Tasks.new(client).cancel(id)
+        end
+
+        def initialize(json = {})
+
+          ATTRIBUTES.each do |attr|
+            instance_variable_set "@#{attr}", json[attr]
+          end
+
+          @client = (json[:client] || json['client'])
+
+          tweak_attributes
+        end
+
+        def day?
+          urgency == 'day'
+        end
+
+        def week?
+          urgency == 'week'
+        end
+
+        def immediate?
+          urgency == 'immediate'
+        end
+
+        def pending?
+          status == 'pending'
+        end
+
+        def completed?
+          status == 'completed'
+        end
+
+        def canceled?
+          status == 'canceled'
+        end
+
+        def callback_succeeded?
+          !!callback_succeeded_at
+        end
+
+        protected
+
+        def tweak_attributes
+          @created_at = Time.parse(created_at) rescue nil
+          @completed_at = Time.parse(completed_at) rescue nil
+        end
+
+      end
+    end
+  end
+end