matroid 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e311cca9b0b9f72f9994186dfeb1a76e952fc41f
-  data.tar.gz: e5b62490467df16bc98777257a1a6ecf5f43667e
+  metadata.gz: c7bcfdbc2cb07e551d37703c5a5468151c64b4df
+  data.tar.gz: b5375b70f1fd8e3e7fb6575f72ba6befde09764c
 SHA512:
-  metadata.gz: 3707dda8b144fcaa1655d72521b6cb62c13299317de4b72694d42b9cea102dfb750b40994453e154e414af1f1d80bb0ed0c20685b95886c751664c1041e6c05f
-  data.tar.gz: cfa3cf1bc429630535df13f89914b2cc890bd838e0d650f2dcf59f4bb2d6ebe5bd6c276d1aa9ac0cb32e171aa7e945b5d85acfdb3dc92d074957963d40528194
+  metadata.gz: d1185974ff919bd69527b1fdbc361578af8aef7ae1551e7742ab088c2740361f027f44ee982877741a65a1bafb08de0dcc12c32c9bba3c4c86c9273f92d05d83
+  data.tar.gz: ddafcc63bcce5582ee7a3a71d13787cfc9ce70c562466db077ce220fcd588e33ba312554862f330c64044cec4ad4a50830e0def32d220598bfd69910a45f6dc2

data/.gitignore

@@ -7,3 +7,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+*.gem
+*.rbc
+.rspec
+.env

data/Gemfile

@@ -1,4 +1,3 @@
 source 'https://rubygems.org'
-
 # Specify your gem's dependencies in matroid.gemspec
 gemspec

data/README.md

@@ -1,8 +1,7 @@
-# Matroid
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/matroid`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+## Features
+* API endpoint coverage
+* Automatic authenticated work flow
+* [Full documentation](http://www.rubydoc.info/github/matroid/matroid-ruby)
 
 ## Installation
 
@@ -21,11 +20,116 @@ Or install it yourself as:
     $ gem install matroid
 
 ## Usage
+This API wrapper allows you to easily create and use Matroid detectors for classifying various media.
+It is designed to allow you to use detectors without any notion of the API.
+
+Check the [documentation](http://www.rubydoc.info/github/matroid/matroid-ruby) for the complete reference of available methods.
+
+# Authenticate your session
+The Matroid API relies on the use of access tokens.
+The easiest way to automatically authenticate your usage and handle access tokens
+is to declare `MATROID_CLIENT_ID` and `MATROID_CLIENT_SECRET` in your environment.
+For example, place the following in your `.env` file (this library includes the `dotenv` gem):
+```
+MATROID_CLIENT_ID=XXXXXXXXXXXXXXXXXXX
+MATROID_CLIENT_SECRET=XXXXXXXXXXXXXXXXXXXXXXXXXXX
+```
+Also, you may call `Matroid.authenticate(MATROID_CLIENT_ID, MATROID_CLIENT_SECRET)` before
+any other methods and the token will be stored in the instance and refreshed as needed.
+
+# Example API usage
+### Authentication
+```ruby
+require 'matroid'
+
+MATROID_CLIENT_ID=XXXXXXXXXXXXXXXXXXX
+MATROID_CLIENT_SECRET=XXXXXXXXXXXXXXXXXXXXXXXXXXX
+
+Matroid.authenticate(MATROID_CLIENT_ID, MATROID_CLIENT_SECRET)
+
+# Check user account info like Matroid Credits balance
+Matroid.account_info
+```
+
+### Query for Detectors
+```ruby
+# Get detector by id
+detector = Matroid::Detector.find_by_id('5893f98530c1c00d0063835b')
+
+# Get detectors by query
+# Search by one or more of :labels, :name, :state, :id, :permission_level, :owner, :detector_type
+# :labels and :name queries can be String or Regexp
+detector = Matroid::Detector.find(id: '5893f98530c1c00d0063835b').first
+cat_detectors = Matroid::Detector.find(name: 'cat')
+cat_detector_id = Matroid::Detector.find(labels: 'cat', owner: true, state: 'trained').first.id
 
-Check your account status on Matroid with this client. More functionality coming soon.
+# Find published detectors
+cat_detectors = Matroid::Detector.find(name: 'cat', published: true)
+cat_detector_id = Matroid::Detector.find(labels: 'cat', state: 'trained', published: true).first.id
+
+# convenience methods
+#  .find_by_id(String)
+#  .find_one(Hash)
+#  .find_by_<attribute>(String)
+#  .find_one_by_<attribute>(String)
+
+# View cached detectors from previous searches
+all_detectors = Matroid::Detector.cached
+```
+
+### Use Detector class methods
+```ruby
+# Get detector details
+detector.to_hash #=> Hash of all the details (or you can get them separately as below)
+detector.info #=> displays detector attributes in a nice printout
+
+detector.id #=> "5893f98530c1c00d0063835b"
+detector.name #=> "My cool detector"
+detector.state #=> "trained"
+detector.labels #=> ["label 1", "label 2", ...]
+detector.permission_level #=> "private"
+detector.owner #=> true
+detector.training #=> "successful"
+detector.type #=> "object", "face", "facial_characteristics"
+
+# Create a detector
+detector = Matroid::Detector.create('PATH/TO/ZIP/FILE', 'My awesome detector', 'general') # uploads labels and images
+detector.id #=> "XxXxXxXxXxXxXxXxXxXxXxXxXxXxXx"
+detector.name #=> "My awesome detector"
+detector.state #=> "pending"
+detector.labels #=> ["label 1", "label 2", ...]
+detector.permission_level #=> "private"
+detector.owner #=> true
+detector.type #=> "general"
+detector.train # submits the detector for training
+# You can repeatedly call detector.info to get the updates on the training
+
+# Use a detector
+detector = Matroid::Detector.find_by_id('5893f98530c1c00d0063835b')
+
+# Classifying an image returns a hash of the detected labels (with probabilities)
+# along with bounding box information (if applicable)
+image_file_path = 'PATH/TO/IMAGE/FILE'
+image_url = 'https://www.example.com/images/some_image.jpg'
+detector.classify_image_url(image_url)
+detector.classify_image_file(image_file_path)
+
+# Classifying a video returns a hash { "video_id" => "dfoguhd078yd7dg87dfvsdf7" }
+# which can later be used to check on the classification.
+# A video takes some time to classify depending on the length and size of the video uploaded.
+youtube_url = 'https://www.youtube.com/watch?v=0qVOUD76JOg'
+video_file_path = 'PATH/TO/VIDEO/FILE'
+detector.classify_video_url(youtube_url)
+detector.classify_video_file(video_file_path)
+
+# Call the following repeatedly to check the progress on the video classification results
+detector_id = 'dfoguhd078yd7dg87dfvsdf7'
+Matroid.get_video_results(detector_id) #=> details of timestamps with labels, etc.
+
+```
+
+More functionality coming soon.
 
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).

data/lib/matroid/connection.rb

@@ -0,0 +1,148 @@
+require 'base64'
+require 'json'
+require 'httpclient/webagent-cookie' # stops warning found here: https://github.com/nahi/httpclient/issues/252
+require 'httpclient'
+require 'date'
+
+BASE_API_URI       = 'https://www.matroid.com/api/0.1/'
+DEFAULT_GRANT_TYPE = 'client_credentials'
+TOKEN_RESOURCE     = 'oauth/token'
+VERBS              = %w(get post)
+
+module Matroid
+
+  # @attr_reader [Token] The current stored token object
+  class << self
+    attr_reader :token, :base_api_uri, :client
+
+    # Changes the default base api uri. This is used primarily for testing purposes.
+    # @param uri [String]
+    def set_base_uri(uri)
+      @base_api_uri = uri
+    end
+
+    VERBS.each do |verb|
+      define_method verb do |endpoint, *params|
+        send_request(verb, endpoint, *params)
+      end
+    end
+
+    def parse_response(response)
+      if valid_json?(response.body)
+        status = response.status_code
+        parsed_response = JSON.parse(response.body)
+        if status != 200
+          err_msg = JSON.pretty_generate(parsed_response)
+          raise Error::RateLimitError.new(err_msg) if status == 429
+          raise Error::InvalidQueryError.new(err_msg) if status == 422
+          raise Error::PaymentError.new(err_msg) if status == 402
+          raise Error::ServerError.new(err_msg) if status / 100 == 5
+          raise Error::APIError.new(err_msg)
+        end
+
+        parsed_response
+      else
+        p response
+        raise Error::APIError.new(response.body)
+      end
+    end
+
+    private
+
+    def get_token(client_id, client_secret)
+      @base_api_uri = BASE_API_URI if @base_api_uri.nil?
+      url = @base_api_uri + TOKEN_RESOURCE
+      params = auth_params(client_id, client_secret)
+      @client = HTTPClient.new
+      response = @client.post(url, body: params)
+      return false unless response.status_code == 200
+      @token = Token.new(JSON.parse(response.body))
+      @client.base_url = @base_api_uri
+      @client.default_header = { 'Authorization' => @token.authorization_header }
+    end
+
+    def send_request(verb, path, params = {})
+      path = URI.escape(path)
+
+      # refreshes token with each call
+      authenticate
+
+      case verb
+      when 'get'
+        response = @client.get(path, body: params)
+      when 'post'
+        response = @client.post(path, body: params)
+      end
+
+      parse_response(response)
+    end
+
+    def valid_json?(json)
+      begin
+        JSON.parse(json)
+        return true
+      rescue JSON::ParserError => e
+        return false
+      end
+    end
+
+    def auth_params(client_id, client_secret)
+      {
+        'client_id' => client_id,
+        'client_secret' => client_secret,
+        'grant_type' => DEFAULT_GRANT_TYPE
+      }
+    end
+
+    def environment_variables?
+      !ENV['MATROID_CLIENT_ID'].nil? && !ENV['MATROID_CLIENT_SECRET'].nil?
+    end
+
+  end
+
+  # Represents an OAuth access token
+  # @attr [String]   token_type     ex: "Bearer"
+  # @attr [String]   token_str      The actual access token
+  # @attr [DateTime] born           When the token was created
+  # @attr [String]   lifetime       Seconds until token expired
+  class Token
+    attr_reader :born, :lifetime, :acces_token
+    def initialize(options = {})
+      @token_type = options['token_type']
+      @access_token = options['access_token']
+      @born = DateTime.now
+      @lifetime = options['expires_in']
+    end
+
+    def authorization_header
+      "#{@token_type} #{@access_token}"
+    end
+
+    # Checks if the current token is expired
+    # @return [Boolean]
+    def expired?
+      lifetime_in_days = time_in_seconds(@lifetime)
+      @born + lifetime_in_days < DateTime.now
+    end
+
+
+    # @return [Numeric] Time left before token expires (in seconds).
+    def time_remaining
+      lifetime_in_days = time_in_seconds(@lifetime)
+      remaining = lifetime_in_days - (DateTime.now - @born)
+      remaining > 0 ? time_in_seconds(remaining) : 0
+    end
+
+    def time_in_seconds(t)
+      t * 24.0 * 60 * 60
+    end
+
+    def to_s
+      JSON.pretty_generate({
+        access_token: @access_token,
+        born: @born,
+        lifetime: @lifetime
+      })
+    end
+  end
+end

data/lib/matroid/detector.rb

@@ -0,0 +1,293 @@
+# size limit constants
+IMAGE_FILE_SIZE_LIMIT = 50 * 1024 * 1024
+VIDEO_FILE_SIZE_LIMIT = 300 * 1024 * 1024
+BATCH_FILE_SIZE_LIMIT = 50 * 1024 * 1024
+ZIP_FILE_SIZE_LIMIT   = 300 * 1024 * 1024
+SEARCH_PARAMETERS     = %w(name label permission_level owner training type state)
+module Matroid
+
+
+  # Represents a Matroid detector
+  # @attr [String]          id                Detector id
+  # @attr [String]          name              Detector name
+  # @attr [Array<Hash><String>]   labels
+  # @attr [String]          permission_level  'private', 'readonly', 'open', 'stock'
+  # @attr [Bool]            owner             is the current authicated user the owner
+  class Detector
+    # HASH { <id> => Detector }
+    @@instances = {}
+    @@ids = []
+
+    attr_reader :id, :name, :labels, :label_ids, :permission_level, :owner, :training,
+                :type, :state
+
+    # Looks up the detector by matching fields.
+    # :label and :name get matched according the the regular expression /\b(<word>)/i
+    # @example
+    #   Matroid::Detector.find(label: 'cat', state: 'trained')
+    # @example
+    #   Matroid::Detector.find(name: 'cat')
+    # @example
+    #   Matroid::Detector.find(name: 'cat', published: true)
+    # @example
+    #   Matroid::Detector.find(label: 'puppy').first.id
+    # @note The detector must either be created by the current authenticated user or published for general use.
+    # @return [Array<Hash><Detector>] Returns the detector instances that match the query.
+    def self.find(args)
+      raise Error::InvalidQueryError.new('Argument must be a hash.') unless args.class == Hash
+      query = args.keys.map{|key| key.to_s + '=' + args[key].to_s }.join('&')
+      detectors = Matroid.get('detectors/search?' + query)
+      detectors.map{|params| register(params) }
+    end
+
+    # Chooses first occurence of the results from {#find}
+    def self.find_one(args)
+      args['limit'] = 1
+      find(args).first
+    end
+
+    # Finds a single document based on the id
+    def self.find_by_id(id, args = {})
+      detector = @@instances[id]
+      is_trained =  detector.class == Detector && detector.is_trained?
+      return detector if is_trained
+
+      args[:id] = id
+      find_one(args)
+    end
+
+    SEARCH_PARAMETERS.each do |param|
+      # Search for detectors using the "find_one_by_" method prefix
+      define_singleton_method "find_one_by_#{param}" do |arg, opts = {}|
+        opts[param.to_sym] = arg
+        find_one(opts)
+      end
+
+      # Search for detectors using the "find_by_" method prefix
+      define_singleton_method "find_by_#{param}" do |arg, opts = {}|
+        opts[param.to_sym] = arg
+        find(opts)
+      end
+    end
+
+    #  List of cached detectors that have been returned by search requests as hashes or Detector instances.
+    # @param type [String] Indicate how you want the response
+    # @return [Array<Hash, Detector>]
+    def self.cached(type = 'instance')
+      case type
+      when 'hash'
+        @@ids.map{|id| find_by_id(id).to_hash }
+      when 'instance'
+        @@ids.map{|id| find_by_id(id) }
+      end
+    end
+
+    # Removes all cached detector instances
+    def self.reset
+      @@instances = {}
+      @@ids = []
+    end
+
+    # Creates a new detector with the contents of a zip file.
+    # The root folder should contain only directories which will become the labels for detection.
+    # Each of these directories should contain only a images corresponding to that label.
+    # Zip file structure example:
+    #    cat/
+    #      garfield.jpg
+    #      nermal.png
+    #    dog/
+    #      odie.tiff
+    # @note Max 1 GB zip file upload.
+    # @param zip_file      [String]     Path to zip file containing the images to be used in the detector creation
+    # @param name          [String]     The detector's display name
+    # @param detector_type [String]     Options: "general", "face_detector", or "facial_characteristics"
+    # @return [Detector]
+    def self.create(zip_file, name, detector_type='general')
+      case zip_file
+      when String
+        file = File.new(zip_file, 'rb')
+      when File
+        file = zip_file
+      else
+        err_msg = 'First argument must be a zip file of the image folders, or a string of the path to the file'
+        raise Error::InvalidQueryError.new(err_msg)
+      end
+      params = {
+        file: file,
+        name: name,
+        detector_type: detector_type
+      }
+      response = Matroid.post('detectors', params)
+      id = response['detector_id']
+      find_by_id(id)
+    end
+
+    def initialize(params)
+      update_params(params)
+    end
+
+    # Detector attributes in a nicely printed format for viewing
+    def info
+      puts JSON.pretty_generate(to_hash)
+    end
+
+    # Detector attributes as a hash
+    # @return [Hash]
+    def to_hash
+      instance_variables.each_with_object(Hash.new(0)) do |element, hash|
+        hash["#{element}".delete("@").to_sym] = instance_variable_get(element)
+      end
+    end
+
+    # Submits detector instance for training
+    # @note
+    #   Fails if detector is not qualified to be trained.
+    def train
+      raise Error::APIError.new("This detector is already trained.") if is_trained?
+      response = Matroid.post("detectors/#{@id}/finalize")
+      response['detector']
+    end
+
+    # @return [Boolean]
+    def is_trained?
+      @state == 'trained'
+    end
+
+    # Updates the the detector data. Used when training to see the detector training progress.
+    # @return [Detector]
+    def update
+      self.class.find_by_id(@id)
+    end
+
+    # Submits an image file via url to be classified with the detector
+    # @param url [String] Url for image file
+    # @return Hash containing the classification data.
+    # @example
+    #     det = Matroid::Detector.find_by_id "5893f98530c1c00d0063835b"
+    #     det.classify_image_url "https://www.allaboutbirds.org/guide/PHOTO/LARGE/common_tern_donnalynn.jpg"
+    #     ### returns hash of results ###
+    #     # {
+    #     #   "results": [
+    #     #     {
+    #     #       "file": {
+    #     #         "name": "image1.png",
+    #     #         "url": "https://myimages.1.png",
+    #     #         "thumbUrl": "https://myimages.1_t.png",
+    #     #         "filetype": "image/png"
+    #     #       },
+    #     #       "predictions": [
+    #     #         {
+    #     #           "bbox": {
+    #     #             "left": 0.7533333333333333,
+    #     #             "top": 0.4504347826086956,
+    #     #             "height": 0.21565217391304348,
+    #     #             "aspectRatio": 1.0434782608695652
+    #     #           },
+    #     #           "labels": {
+    #     #             "cat face": 0.7078468322753906,
+    #     #             "dog face": 0.29215322732925415
+    #     #           }
+    #     #         },
+    #     #         {
+    #     #           "bbox": {
+    #     #             "left": 0.4533333333333333,
+    #     #             "top": 0.6417391304347826,
+    #     #             "width": 0.20833333333333334,
+    #     #             "height": 0.21739130434782608,
+    #     #             "aspectRatio": 1.0434782608695652
+    #     #           },
+    #     #           "labels": {
+    #     #             "cat face": 0.75759859402753906,
+    #     #             "dog face": 0.45895322732925415
+    #     #           }
+    #     #         }, {
+    #     #           ...
+    #     #         }
+    #     #       ]
+    #     #     }
+    #     #   ]
+    #     # }
+    def classify_image_url(url)
+      classify('image', url: url)
+    end
+
+    # Submits an image file via url to be classified with the detector
+    # @param url [String] Url for image file
+    # @return Hash containing the classification data see {#classify_image_url }
+    # @example
+    #     det = Matroid::Detector.find_by_id "5893f98530c1c00d0063835b"
+    #     det.classify_image_file "path/to/file.jpg"
+    def classify_image_file(file_path)
+      size_err = "Individual file size must be under #{IMAGE_FILE_SIZE_LIMIT / 1024 / 1024}MB"
+      raise Error::InvalidQueryError.new(size_err) if File.size(file_path) > IMAGE_FILE_SIZE_LIMIT
+      classify('image', file: File.new(file_path, 'rb'))
+    end
+
+    # The plural of {#classify_image_file}
+    # @param file_paths [Array<String>] An array of images in the form of paths from the current directory
+    # @return Hash containing the classification data
+    def classify_image_files(file_paths)
+      arg_err = "Error: Argument must be an array of image file paths"
+      size_err = "Error: Total batch size must be under #{BATCH_FILE_SIZE_LIMIT / 1024 / 1024}MB"
+      raise arg_err unless file_paths.is_a?(Array)
+      batch_size = file_paths.inject(0){ |sum, file| sum + File.size(file) }
+      raise size_err unless batch_size < BATCH_FILE_SIZE_LIMIT
+      files = file_paths.map{ |file_path| ['file', File.new(file_path, 'rb')] }
+
+      url = "#{Matroid.base_api_uri}detectors/#{@id}/classify_image"
+
+      client = HTTPClient.new
+      response = client.post(url, body: files, header: {'Authorization' => Matroid.token.authorization_header})
+      Matroid.parse_response(response)
+      # Matroid.post("detectors/#{@id}/classify_image", files) # responds with 'request entity too large' for some reason
+    end
+
+    # Submits a video file via url to be classified with the detector
+    # @param url [String] Url for video file
+    # @return Hash containing the registered video's id; ex: { "video_id" => "58489472ff22bb2d3f95728c" }. Needed for Matroid.get_video_results(video_id)
+    def classify_video_url(url)
+      classify('video', url: url)
+    end
+
+    # Submits a local video file to be classified with the detector
+    # @param file_path [String] Path to file
+    # @return Hash containing the registered video's id ex: { "video_id" => "58489472ff22bb2d3f95728c" }. Needed for Matroid.get_video_results(video_id)
+    def classify_video_file(file_path)
+      size_err = "Video file size must be under #{VIDEO_FILE_SIZE_LIMIT / 1024 / 1024}MB"
+      raise Error::InvalidQueryError.new(size_err) if File.size(file_path) > VIDEO_FILE_SIZE_LIMIT
+      classify('video', file: File.new(file_path, 'rb'))
+    end
+
+    def update_params(params)
+      @id = params['id'] if params['id']
+      @name = params['name'] if params['name']
+      @labels = params['labels'] if params['labels']
+      @label_ids = params['label_ids'] if params['label_ids']
+      @permission_level = params['permission_level'] if params['permission_level']
+      @owner = params['owner'] if params['owner']
+      @type = params['type'] if params['type']
+      @training = params['training'] if params['training']
+      @state = params['state'] if params['state']
+      self
+    end
+
+    private
+
+    def classify(type, params)
+      not_trained_err = "This detector's training is not complete."
+      raise Error::InvalidQueryError.new(not_trained_err) unless is_trained?
+      Matroid.post("detectors/#{@id}/classify_#{type}", params)
+    end
+
+    def self.register(obj)
+      id = obj['id']
+      @@ids.push(id) if @@instances[id].nil?
+      if  @@instances[id].class == Detector
+        @@instances[id].update_params(obj)
+      else
+        @@instances[id] = Detector.new(obj)
+      end
+    end
+
+  end
+end

data/lib/matroid/error.rb

@@ -0,0 +1,12 @@
+module Matroid
+  module Error
+    class APIError < StandardError; end
+    class APIConnectionError < APIError; end
+    class AuthorizationError < APIError; end
+    class InvalidQueryError < APIError; end
+    class ServerError < APIError; end
+    class RateLimitError < APIError; end
+    class PaymentError < APIError; end
+    class MediaError < APIError; end
+  end
+end

data/lib/matroid/version.rb

@@ -1,3 +1,3 @@
 module Matroid
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/matroid.rb

@@ -1,43 +1,82 @@
-require "matroid/version"
-require 'httparty'
-require 'pry'
+require 'dotenv/load'
+require 'matroid/connection'
+require 'matroid/version'
+require 'matroid/detector'
+require 'matroid/error'
 
 module Matroid
-  class MatroidClient
-    def initialize(options)
-      @base_url = options[:base_url]
-      @client_id = options[:client_id]
-      @client_secret = options[:client_secret]
-      @request = HTTParty
-
-      @endpoints = {
-        token: { method: :post, uri: "#{@base_url}/oauth/token" },
-        account_info: { method: :get, uri: "#{@base_url}/account" }
-      }
+  @client_id = ENV['MATROID_CLIENT_ID']
+  @client_secret = ENV['MATROID_CLIENT_SECRET']
+
+  class << self
+
+    # Authenticates access for Matroid API
+    # @example
+    #  Matroid.authenticate("<your_client_id>", "<your_client_secret>")
+    # @param client_id [String]
+    # @param client_secret [String]
+    # @return [Boolean] If the the access token is successfully created.
+    def authenticate(client_id = nil, client_secret = nil)
+      return true unless @token.nil? || @token.expired?
+      if client_id && client_secret
+        err_msg = 'problem using environment variables "MATROID_CLIENT_ID" and "MATROID_CLIENT_SECRET"'
+        new_token = get_token(client_id, client_secret)
+        raise Error::AuthorizationError.new(err_msg) if new_token.nil?
+        @client_id, @client_secret = client_id, client_secret
+      elsif (@client_id.nil? || @client_secret.nil?) && !environment_variables?
+        err_msg = '"MATROID_CLIENT_ID" and "MATROID_CLIENT_SECRET" not found in environment'
+        raise Error::AuthorizationError.new(err_msg)
+      else
+        err_msg = 'Problem using client variables provided'
+        raise Error::AuthorizationError.new(err_msg) if get_token(@client_id, @client_secret).nil?
+      end
+
+      true
     end
 
-    def retrieve_token
-      endpoint = @endpoints[:token]
-      opts = {
-        body: {
-          client_id: @client_id,
-          client_secret: @client_secret,
-          grant_type: 'client_credentials'
-        }
-      }
-      response = @request.send(endpoint[:method], endpoint[:uri], opts)
-      @authorization_header = "#{response['token_type']} #{response['access_token']}"
-      response.parsed_response
+    # Calls ::show on the current token (if it exists).
+    def show_token
+      if @token
+        @token.show
+      end
     end
 
+    # Retrieves the authenticated user's account information
+    # @return The account info as a parsed JSON
+    # @example
+    #   {
+    #     "account" => {
+    #       "credits" => {
+    #         "concurrentTrainLimit" =>1,
+    #         "held" => 3496,
+    #         "plan" => "premium",
+    #         "daily" => {
+    #           "used" => 36842,
+    #           "available" => 100000
+    #         },
+    #         "monthly" => {
+    #           "used" => 36842,
+    #           "available" => 1000000
+    #         }
+    #       }
+    #     }
+    #   }
     def account_info
-      endpoint = @endpoints[:account_info]
-      headers = { "Authorization" => @authorization_header }
-      opts = {
-        headers: headers
-      }
-      response = @request.send(endpoint[:method], endpoint[:uri], opts)
-      response.parsed_response
+      get('account')
     end
+
+    # Retrieves video classification data. Requires a video_id from
+    # {Detector#classify_video_file} or {Detector#classify_video_url}
+    # format 'json'/'csv'
+    # @note A "video_id" is needed to get the classification results
+    # @example
+    #   <Detector >.get_video_results(video_id: "23498503uf0dd09", threshold: 30, format: 'json')
+    # @param video_id [String]
+    # @param threshold [Numeric, nil]
+    # @param
+    def get_video_results(video_id, *args)
+      get("videos/#{video_id}", *args)
+    end
+
   end
 end

data/matroid.gemspec

@@ -30,7 +30,18 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency 'omniauth-oauth2', '~> 1.3.1'
+  spec.add_dependency 'httpclient'
+
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_runtime_dependency 'httparty', "~> 0.14.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "fakeweb"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency "dotenv"
+  spec.add_dependency "faraday"
+  spec.add_dependency "json"
 end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: matroid
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Matroid
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-17 00:00:00.000000000 Z
+date: 2017-04-24 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: omniauth-oauth2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -39,19 +67,117 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
-  name: httparty
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.14.0
+        version: '0'
 description: Check your account status on Matroid. More features coming soon.
 email:
 - solutions@matroid.com
@@ -67,6 +193,9 @@ files:
 - bin/console
 - bin/setup
 - lib/matroid.rb
+- lib/matroid/connection.rb
+- lib/matroid/detector.rb
+- lib/matroid/error.rb
 - lib/matroid/version.rb
 - matroid.gemspec
 homepage: http://www.matroid.com
@@ -90,7 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Matroid API Ruby Library