monkeylearn 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b8b41d5910d61c77645da60123ad508a1e444eb0
+  data.tar.gz: 6d385382a783204a3e8cfa9d8044a755815e206f
+SHA512:
+  metadata.gz: 5138110e12266e1fc4841a75ddf8928b5c3aa222d09236773cf76172443857451de6ede605201f99f488ccba5b7d03485fd96d52b8e7dac5802e12040f71548c
+  data.tar.gz: 551435a4e5a476e335d67db0631db44dfea2f663df04a6f19ca7b199b4355c3d3d5859b85b9757c732f8668024f2e5b95cd4b80bb8bc521b841c529b1c4b7ce5

data/README.md

@@ -0,0 +1,142 @@
+# monkeylearn-ruby
+
+Official Ruby client for the MonkeyLearn API. Build and consume machine learning models for language processing from your Ruby apps.
+
+Installation
+------------
+
+Install with rubygems:
+
+    gem install monkeylearn
+
+Or add this line to your Gemfile
+
+    gem "monkeylearn"
+
+Quick start
+-----------
+
+First require and configure the lib:
+
+```ruby
+require 'monkeylearn'
+
+# Basic configuration
+Monkeylearn.configure do |c|
+  c.token = 'INSERT_YOUR_API_TOKEN_HERE'
+end
+```
+
+Classification:
+
+```ruby
+r = Monkeylearn.classifiers.classify('cl_hDDngsX8', ['Hola te va amigo?', 'How are you doing mate?'], sandbox: false)
+r.result
+# =>  [[{"probability"=>0.461, "label"=>"Spanish"}], [{"probability"=>0.996, "label"=>"English"}]]
+```
+
+Extraction:
+
+```ruby
+r = Monkeylearn.extractors.extract('ex_y7BPYzNG', ['A panel of Goldman Sachs employees spent a recent Tuesday night at the Columbia University faculty club'])
+r.result
+# => [[{"relevance"=>"0.962", "count"=>1, "positions_in_text"=>[80], "keyword"=>"University faculty club"}, {"relevance"=>"0.962", "count"=>1, "positions_in_text"=>[43], "keyword"=>"recent Tuesday night"}, {"relevance"=>"0.962", "count"=>1, "positions_in_text"=>[11], "keyword"=>"Goldman Sachs employees"}, {"relevance"=>"0.385", "count"=>1, "positions_in_text"=>[2], "keyword"=>"panel"}]]
+```
+
+Pipelines:
+
+```ruby
+data = {
+  input: [
+    { text: "Friendly service, superior room! Loved the high ceiling. Housekeeping service should have been a little better. Excellent breakfast and fitness room." }
+  ]
+}
+r = Monkeylearn.pipelines.run('pi_WNo4z7fJ', data, sandbox: false)
+r.result
+# => {"result"=>{"sentiment_labels"=>[{"sentiment"=>[{"probability"=>1.0, "label"=>"Good"}], "sentence"=>"Friendly service, superior room!"}, {"sentiment"=>[{"probability"=>1.0, "label"=>"Good"}], "sentence"=>"Loved the high ceiling."}, {"sentiment"=>[{"probability"=>0.5, "label"=>"Bad"}], "sentence"=>"Housekeeping service should have been a little better."}, {"sentiment"=>[{"probability"=>0.912, "label"=>"Good"}], "sentence"=>"Excellent breakfast and fitness room."}]}}
+```
+
+Classifiers endpoints example
+-----------------------------
+
+Create a new classifier:
+
+```ruby
+r = Monkeylearn.classifiers.create('Test API sentiment classifier',
+                                   description: 'This is a sentiment classifier created with the monkeylearn ruby API client',
+                                   language: 'en')
+classifier_id = r.result['result']['classifier']['hashed_id']
+```
+
+Get the details from the new classifier and the root category id:
+
+```ruby
+r = Monkeylearn.classifiers.detail(classifier_id)
+root_category_id = r.result['result']['sandbox_categories'][0]['id']
+```
+
+Create two child categories:
+
+```ruby
+r = Monkeylearn.classifiers.categories.create(classifier_id, 'Positive', root_category_id)
+positive_category_id = r.result['result']['category']['id']
+
+r = Monkeylearn.classifiers.categories.create(classifier_id, 'Negative', root_category_id)
+negative_category_id = r.result['result']['category']['id']
+```
+
+Upload some samples to each category:
+
+```ruby
+samples = {
+  positive_category_id => ['Nice beatiful', 'awesome excelent'],
+  negative_category_id => ['Awful bad', 'sad pale'],
+}
+r = Monkeylearn.classifiers.upload_samples(classifier_id, samples)
+```
+
+Train the classifier:
+
+```ruby
+Monkeylearn.classifiers.train(classifier_id)
+```
+
+Classify using the sandbox:
+
+```ruby
+r = Monkeylearn.classifiers.classify(classifier_id, ['Awesome excelence'], sandbox: true)
+r.result
+# => [[{"probability"=>0.998, "label"=>"Positive"}]]
+```
+
+Deploy a live version:
+
+```ruby
+Monkeylearn.classifiers.deploy(classifier_id)
+```
+
+Classify using the live classifier:
+
+```ruby
+r = Monkeylearn.classifiers.classify(classifier_id, ['Awesome excelence'], sandbox: false)
+r.result
+# => [[{"probability"=>0.998, "label"=>"Positive"}]]
+```
+
+Edit a category, rename and move the negative category:
+
+```ruby
+r = Monkeylearn.classifiers.categories.edit(classifier_id, negative_category_id, 'Positive child', positive_category_id)
+```
+
+Delete a category:
+
+```ruby
+r = Monkeylearn.classifiers.categories.delete(classifier_id, negative_category_id)
+```
+
+Delete the classifier:
+
+```ruby
+r = Monkeylearn.classifiers.delete(classifier_id)
+```

data/lib/monkeylearn.rb

@@ -0,0 +1,14 @@
+require 'monkeylearn/configurable'
+require 'monkeylearn/exceptions'
+require 'monkeylearn/classifiers'
+require 'monkeylearn/extractors'
+require 'monkeylearn/pipelines'
+
+
+module Monkeylearn
+  class << self
+    include Monkeylearn::Configurable
+  end
+end
+
+Monkeylearn.reset!

data/lib/monkeylearn/classifiers.rb

@@ -0,0 +1,135 @@
+require 'monkeylearn/requests'
+
+module Monkeylearn
+  class << self
+    def classifiers
+      return Classifiers
+    end
+  end
+
+  module Classifiers
+    class << self
+      include Monkeylearn::Requests
+
+      def categories
+        return Categories
+      end
+
+      def build_endpoint(*args)
+        File.join('classifiers', *args) + '/'
+      end
+
+      def validate_batch_size(batch_size)
+        max_size = Monkeylearn::Defaults.max_batch_size
+        if batch_size >  max_size
+          raise MonkeylearnError, "The param batch_size is too big, max value is #{max_size}."
+        end
+        min_size = Monkeylearn::Defaults.min_batch_size
+        if batch_size <  min_size
+          raise MonkeylearnError, "The param batch_size is too small, min value is #{min_size}."
+        end
+        true
+      end
+
+      def classify(module_id, texts, options = {})
+        options[:batch_size] ||= Monkeylearn::Defaults.default_batch_size
+        batch_size = options[:batch_size]
+        validate_batch_size batch_size
+
+        endpoint = build_endpoint(module_id, 'classify')
+        query_params = { sandbox: true } if options[:sandbox]
+
+        responses = (0...texts.length).step(batch_size).collect do |start_idx|
+          data = { text_list: texts.slice(start_idx, batch_size) }
+          response = request :post, endpoint, data, query_params
+        end
+
+        Monkeylearn::MultiResponse.new(responses)
+      end
+
+      def create(name, options = {})
+        data = {
+            name: name,
+            description: options[:description],
+            language: options[:language],
+            ngram_range: options[:ngram_range],
+            use_stemmer: options[:use_stemmer],
+            stop_words: options[:stop_words],
+            max_features: options[:max_features],
+            strip_stopwords: options[:strip_stopwords],
+            is_multilabel: options[:is_multilabel],
+            is_twitter_data: options[:is_twitter_data],
+            normalize_weights: options[:normalize_weights],
+            classifier: options[:classifier],
+            industry: options[:industry],
+            classifier_type: options[:classifier_type],
+            text_type: options[:text_type],
+            permissions: options[:permissions]
+        }.delete_if { |k,v| v.nil? }
+        request :post, build_endpoint, data
+      end
+
+      def detail(module_id)
+        request :get, build_endpoint(module_id)
+      end
+
+      def upload_samples(module_id, samples_with_categories)
+        endpoint = build_endpoint(module_id, 'samples')
+        data = {
+          samples: samples_with_categories.collect do |category_id, texts|
+            texts.collect { |text| {text: text, category_id: category_id} }
+          end.flatten(1)
+        }
+        request :post, endpoint, data
+      end
+
+      def train(module_id)
+        request :post, build_endpoint(module_id, 'train')
+      end
+
+      def deploy(module_id)
+        request :post, build_endpoint(module_id, 'deploy')
+      end
+
+      def delete(module_id)
+        request :delete, build_endpoint(module_id)
+      end
+    end
+  end
+
+  module Categories
+    class << self
+      include Monkeylearn::Requests
+
+      def build_endpoint(module_id, *args)
+        File.join('classifiers', module_id, 'categories', *args.collect { |x| x.to_s }) + '/'
+      end
+
+      def create(module_id, name, parent_id)
+        data = {
+          name: name,
+          parent_id: parent_id
+        }
+        request :post, build_endpoint(module_id), data
+      end
+
+      def edit(module_id, category_id, name = nil, parent_id = nil)
+        endpoint = build_endpoint(module_id, category_id)
+        data = {
+          name: name,
+          parent_id: parent_id
+        }.delete_if { |k,v| v.nil? }
+        request :patch, endpoint, data
+      end
+
+      def delete(module_id, category_id, samples_strategy = nil, samples_category_id = nil)
+        endpoint = build_endpoint(module_id, category_id)
+        data = {
+          'samples-strategy'.to_s => samples_strategy,
+          'samples-category-id'.to_s => samples_category_id
+        }.delete_if { |k,v| v.nil? }
+        request :delete, endpoint, data
+      end
+    end
+  end
+end

data/lib/monkeylearn/configurable.rb

@@ -0,0 +1,37 @@
+require 'monkeylearn/defaults'
+
+module Monkeylearn
+  module Configurable
+    attr_accessor :token, :api_endpoint
+    attr_writer :api_endpoint
+
+    class << self
+      def keys
+        @keys ||= [
+          :api_endpoint,
+          :token,
+          :wait_on_throttle
+        ]
+      end
+    end
+
+    def configure
+      yield self
+    end
+
+    def reset!
+      Monkeylearn::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Monkeylearn::Defaults.options[key])
+      end
+      self
+    end
+
+    def wait_on_throttle
+      @wait_on_throttle
+    end
+
+    def api_endpoint
+      File.join(@api_endpoint, "")
+    end
+  end
+end

data/lib/monkeylearn/defaults.rb

@@ -0,0 +1,41 @@
+module Monkeylearn
+  module Defaults
+    # Constants
+    DEFAULT_BATCH_SIZE = 200
+    MAX_BATCH_SIZE = 500
+    MIN_BATCH_SIZE = 100
+    # Configurable options
+    API_ENDPOINT = 'https://api.monkeylearn.com/v2/'
+    WAIT_ON_THROTTLE = true
+
+    class << self
+      def options
+        Hash[Monkeylearn::Configurable.keys.map{|key| [key, send(key)]}]
+      end
+
+      def api_endpoint
+        ENV['MONKEYLEARN_API_ENDPOINT'] || API_ENDPOINT
+      end
+
+      def token
+        ENV['MONKEYLEARN_TOKEN'] || nil
+      end
+
+      def wait_on_throttle
+        ENV['MONKEYLEARN_WAIT_ON_THROTTLE'] || WAIT_ON_THROTTLE
+      end
+
+      def max_batch_size
+        MAX_BATCH_SIZE
+      end
+
+      def min_batch_size
+        MIN_BATCH_SIZE
+      end
+
+      def default_batch_size
+        DEFAULT_BATCH_SIZE
+      end
+    end
+  end
+end

data/lib/monkeylearn/exceptions.rb

@@ -0,0 +1,2 @@
+class MonkeylearnError < StandardError
+end

data/lib/monkeylearn/extractors.rb

@@ -0,0 +1,46 @@
+require 'monkeylearn/requests'
+
+module Monkeylearn
+  class << self
+    def extractors
+      return Extractors
+    end
+  end
+
+  module Extractors
+    class << self
+      include Monkeylearn::Requests
+
+      def build_endpoint(*args)
+        File.join('extractors', *args) + '/'
+      end
+
+      def validate_batch_size(batch_size)
+        max_size = Monkeylearn::Defaults.max_batch_size
+        if batch_size >  max_size
+          raise MonkeylearnError, "The param batch_size is too big, max value is #{max_size}."
+        end
+        min_size = Monkeylearn::Defaults.min_batch_size
+        if batch_size <  min_size
+          raise MonkeylearnError, "The param batch_size is too small, min value is #{min_size}."
+        end
+        true
+      end
+
+      def extract(module_id, texts, options = {})
+        options[:batch_size] ||= Monkeylearn::Defaults.default_batch_size
+        batch_size = options[:batch_size]
+        validate_batch_size batch_size
+
+        endpoint = build_endpoint(module_id, 'extract')
+
+        responses = (0...texts.length).step(batch_size).collect do |start_idx|
+          data = { text_list: texts.slice(start_idx, batch_size) }
+          response = request :post, endpoint, data
+        end
+
+        Monkeylearn::MultiResponse.new(responses)
+      end
+    end
+  end
+end

data/lib/monkeylearn/pipelines.rb

@@ -0,0 +1,29 @@
+require 'monkeylearn/requests'
+
+module Monkeylearn
+  class << self
+    def pipelines
+      return Pipelines
+    end
+  end
+
+  module Pipelines
+    class << self
+      include Monkeylearn::Requests
+
+      def build_endpoint(*args)
+        File.join('pipelines', *args) + '/'
+      end
+
+      def run(module_id, data, options = {})
+        query_params = { sandbox: true } if options[:sandbox]
+        endpoint = build_endpoint(module_id, 'run')
+        unless data.is_a?(Hash)
+          raise MonkeylearnError, 'The data param must be a hash'
+        end
+        puts endpoint
+        request :post, endpoint, data
+      end
+    end
+  end
+end

data/lib/monkeylearn/requests.rb

@@ -0,0 +1,41 @@
+require 'faraday'
+require 'json'
+require 'monkeylearn/response'
+
+module Monkeylearn
+  module Requests
+    def request(method, path, data = nil, query_params = nil)
+      response = get_connection.send(method) do |req|
+        url = path.to_s
+        if query_params
+          url += '?' + URI.encode_www_form(query_params)
+        end
+        req.url url
+        req.headers['Authorization'] = 'Token ' + Monkeylearn.token
+        req.headers['Content-Type'] = 'application/json'
+        if data
+          req.body = data.to_json
+        end
+      end
+      if Monkeylearn.wait_on_throttle && seconds = throttled?(response)
+        # Request was throttled, wait 'seconds' seconds and retry
+        sleep seconds
+        response = request(method, path, data)
+      end
+      Monkeylearn::Response.new(response)
+    end
+
+    def throttled?(response)
+      return false if response.status != 429
+      error_detail = JSON.parse(response.body)['detail']
+      match = /available in ([\d]+) seconds/.match(error_detail)
+       if match then match[1].to_i else false end
+    end
+
+    def get_connection
+      @conn ||= Faraday.new(url: Monkeylearn.api_endpoint) do |faraday|
+        faraday.adapter Faraday.default_adapter # Net::HTTP
+      end
+    end
+  end
+end

data/lib/monkeylearn/response.rb

@@ -0,0 +1,31 @@
+module Monkeylearn
+  class Response
+    attr_reader :raw_response, :result, :query_limit_remaining
+
+    def initialize(raw_response)
+      self.raw_response = raw_response
+    end
+
+    def raw_response=(raw_response)
+      @raw_response = raw_response
+      @result = JSON.parse(raw_response.body)
+      @query_limit_remaining = raw_response.headers['X-Query-Limit-Remaining'].to_i
+    end
+  end
+
+  class MultiResponse
+    attr_reader :responses, :result, :query_limit_remaining
+
+    def initialize(responses)
+      self.responses = responses
+    end
+
+    def responses=(responses)
+      @responses = responses
+      @query_limit_remaining = responses[-1].raw_response.headers['X-Query-Limit-Remaining'].to_i
+      @result = responses.collect do |r|
+        r.result['result']
+      end.reduce(:+)
+    end
+  end
+end

data/monkeylearn.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name = 'monkeylearn'
+  spec.summary = 'Ruby client for the MonkeyLearn API'
+  spec.description = 'A simple client for the MonkeyLearn API'
+  spec.authors = ['Monkeylearn']
+  spec.email = ['hello@monkeylearn.com']
+  spec.homepage = 'https://github.com/monkeylearn/monkeylearn-ruby'
+
+  spec.version = '0.1'
+  spec.add_dependency 'faraday', '>= 0.9.2'
+
+  spec.licenses = ['MIT']
+
+  spec.files = %w(README.md monkeylearn.gemspec)
+  spec.files += Dir.glob('lib/**/*.rb')
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 1.9.2'
+  spec.required_rubygems_version = '>= 1.3.5'
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: monkeylearn
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Monkeylearn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+description: A simple client for the MonkeyLearn API
+email:
+- hello@monkeylearn.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- monkeylearn.gemspec
+- lib/monkeylearn/classifiers.rb
+- lib/monkeylearn/configurable.rb
+- lib/monkeylearn/defaults.rb
+- lib/monkeylearn/exceptions.rb
+- lib/monkeylearn/extractors.rb
+- lib/monkeylearn/pipelines.rb
+- lib/monkeylearn/requests.rb
+- lib/monkeylearn/response.rb
+- lib/monkeylearn.rb
+homepage: https://github.com/monkeylearn/monkeylearn-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.5
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Ruby client for the MonkeyLearn API
+test_files: []