textrazor 0.0.8 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a18bfa0d8979cd6af68c481ff1200802d989dfc
-  data.tar.gz: 71666356571e6e4d6cad269ad6f7f6da306d90d0
+  metadata.gz: 2996a5abb8a9c7d3113db4c9f64daf10c20e7360
+  data.tar.gz: cf7010d2573ada02239d021a960e6543627f5ea5
 SHA512:
-  metadata.gz: 653c8e38cf0d1ab4b42796eec8853bc1104c5122ba6e87e6073f74fb2e75b76b75911136a2583f0f0320ab93711da5d269a6ee67280a6c90b3884ca1b7c24961
-  data.tar.gz: c65e0182196f36cf12a080772dd4953ec8d239a6bc66cd3897ef97e2bb83c8bdea5823ef14c91e76d0249980628ca762ae734f1d445c3238f6a5de86c88bc990
+  metadata.gz: cd8f18e796b07f1ac921c95bf45d1d829a913c2442e0155dbab01d863f4f1ce0611856eb228766ebc192aafcbb85f2ae61d012eeaa8a6079dc16a7b6139ebf99
+  data.tar.gz: 362e74c53aef5bbe198ef7b79a95ff179d605b20e89a43de05d47669e4b07f3515476d4756aa471bd8064cc1625eab720dcfd53ef9df30c1b0645aa426c59674

data/.ruby-gemset

@@ -0,0 +1 @@
+textrazor

data/.ruby-version

@@ -0,0 +1 @@
+2.2.0

data/README.md

@@ -4,8 +4,6 @@ This is a gem wrapper for TextRazor REST API reference.
 
 ## Installation
 
-
-
 Add this line to your application's Gemfile:
 
     gem 'textrazor', :git => 'git://github.com/andhapp/textrazor.git'
@@ -76,6 +74,32 @@ TextRazor.phrases('api_key', 'text')
 Only implemented this for topics, entities, words and phrases. Also, implement
 it for other information that we can retrieve from the public API.
 
+### API Issues (To investigate)
+
+#### Response
+
+* error - Descriptive error message of any problems that may have occurred during analysis, or an empty string if there was no error.
+
+Missing from the successful response.
+
+* message - Any warning or informational messages returned from the server, or an empty string if there was no message.
+
+Missing from the successful response.
+
+* cleanedText
+
+Missing from the successful response.
+
+* customAnnotationOutput
+
+Missing from the successful response.
+
+### Specs
+
+#### Prolog rules
+
+Specs around custom prolog rules need to be added.
+
 
 ## Contributing
 

data/Rakefile

@@ -2,6 +2,14 @@ require 'bundler/gem_tasks'
 require 'bundler/setup'
 require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new(:spec)
+desc 'Run all the specs'
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.pattern = "spec/lib/**/*_spec.rb"
+end
 
-task :default => :spec
+desc 'Run all the functional specs'
+RSpec::Core::RakeTask.new(:specf) do |task|
+  task.pattern = "spec/functional/*_spec.rb"
+end
+
+task :default => [:spec, :specf]

data/lib/textrazor.rb

@@ -5,9 +5,14 @@ require "textrazor/client"
 require "textrazor/request"
 require "textrazor/response"
 require "textrazor/topic"
+require "textrazor/entailment"
 require "textrazor/entity"
 require "textrazor/word"
 require "textrazor/phrase"
+require "textrazor/property"
+require "textrazor/sentence"
+require "textrazor/relation_param"
+require "textrazor/relation"
 
 module TextRazor
 

data/lib/textrazor/client.rb

@@ -5,15 +5,24 @@ module TextRazor
     EmptyApiKey = Class.new(StandardError)
     EmptyText = Class.new(StandardError)
     TextTooLong = Class.new(StandardError)
+    UnsupportedExtractor = Class.new(StandardError)
+    UnsupportedCleanupMode = Class.new(StandardError)
 
     DEFAULT_EXTRACTORS = ['entities', 'topics', 'words', 'phrases', 'dependency-trees',
                           'relations', 'entailments', 'senses']
 
-    REQUEST_OPTIONS = [:extractors, :cleanup_html, :language, 
-                       :filter_dbpedia_types, :filter_freebase_types]
+    DEFAULT_CLEANUP_MODE = 'raw'
+
+    VALID_CLEANUP_MODE_VALUES = [DEFAULT_CLEANUP_MODE, 'stripTags', 'cleanHTML']
+
+    REQUEST_OPTIONS = [:extractors, :rules, :cleanup_mode, :cleanup_return_cleaned, :cleanup_return_raw,
+                       :language, :filter_dbpedia_types, :filter_freebase_types, :allow_overlap,
+                       :enrichment_queries]
 
     attr_reader :response, :api_key, :request_options
 
+    private_constant :DEFAULT_EXTRACTORS, :VALID_CLEANUP_MODE_VALUES, :DEFAULT_CLEANUP_MODE, :REQUEST_OPTIONS
+
     def initialize(api_key, options = {})
       assign_api_key(api_key)
       assign_request_options(options)
@@ -21,7 +30,9 @@ module TextRazor
 
     def analyse(text)
       assert_text(text)
-      options = {api_key: api_key}.merge(request_options)
+      options = {
+        api_key: api_key
+      }.merge(request_options)
 
       Response.new(Request.post(text, options))
     end
@@ -67,9 +78,31 @@ module TextRazor
     end
 
     def assign_request_options(options)
-      @request_options = { extractors: DEFAULT_EXTRACTORS }
+      extractors = options.delete(:extractors)
+      assert_extractors(extractors)
+
+      cleanup_mode = options.delete(:cleanup_mode)
+      assert_cleanup_mode(cleanup_mode)
+
+      @request_options = {
+        extractors: extractors || DEFAULT_EXTRACTORS,
+        cleanup_mode: cleanup_mode || DEFAULT_CLEANUP_MODE
+      }
+
       REQUEST_OPTIONS.each do |key|
-        @request_options[key] = options[key] if options[key]
+        @request_options[key] = options[key] unless options[key].nil?
+      end
+    end
+
+    def assert_extractors(extractors)
+      if extractors && !extractors.all? { |extractor| DEFAULT_EXTRACTORS.include?(extractor) }
+        raise UnsupportedExtractor.new('Unsupported extractor')
+      end
+    end
+
+    def assert_cleanup_mode(cleanup_mode)
+      if cleanup_mode && !VALID_CLEANUP_MODE_VALUES.include?(cleanup_mode)
+        raise UnsupportedCleanupMode.new('Unsupported clean up mode')
       end
     end
 

data/lib/textrazor/configuration.rb

@@ -6,4 +6,4 @@ module TextRazor
       @secure = true
     end
   end
-end
+end

data/lib/textrazor/entailment.rb

@@ -0,0 +1,24 @@
+module TextRazor
+
+  class Entailment
+
+    extend Util
+
+    attr_reader :id, :word_positions, :prior_score, :context_score,
+                :score, :entailed_tree, :entailed_words
+
+    def initialize(params = {})
+      @type = []
+      params.each do |k, v|
+        instance_variable_set(:"@#{k}", v) if v && self.respond_to?(:"#{k}")
+      end
+    end
+
+    def self.create_from_hash(params)
+      params = Hash[params.map {|k, v| [standardize(k), v] }]
+      new(params)
+    end
+
+  end
+
+end

data/lib/textrazor/property.rb

@@ -0,0 +1,22 @@
+module TextRazor
+
+  class Property
+
+    extend Util
+
+    attr_reader :id, :word_positions, :property_positions
+
+    def initialize(params = {})
+      params.each do |k, v|
+        instance_variable_set(:"@#{k}", v) if v && self.respond_to?(:"#{k}")
+      end
+    end
+
+    def self.create_from_hash(params)
+      params = Hash[params.map {|k, v| [standardize(k), v] }]
+      new(params)
+    end
+
+  end
+
+end

data/lib/textrazor/relation.rb

@@ -0,0 +1,25 @@
+module TextRazor
+
+  class Relation
+
+    attr_reader :id, :word_positions, :relation_params
+
+    def initialize(params = {})
+      @id = params[:id]
+      @word_positions = params[:wordPositions]
+      @relation_params = params[:params].map do |relation_param_hash|
+        RelationParam.create_from_hash(relation_param_hash)
+      end
+    end
+
+    def number_of_relation_params
+      @relation_params.size
+    end
+
+    def self.create_from_hash(params)
+      new(params)
+    end
+
+  end
+
+end

data/lib/textrazor/relation_param.rb

@@ -0,0 +1,18 @@
+module TextRazor
+
+  class RelationParam
+
+    attr_reader :relation, :word_positions
+
+    def initialize(params = {})
+      @relation = params[:relation]
+      @word_positions = params[:wordPositions]
+    end
+
+    def self.create_from_hash(params)
+      new(params)
+    end
+
+  end
+
+end

data/lib/textrazor/request.rb

@@ -9,10 +9,14 @@ module TextRazor
 
     OPTIONS_MAPPING = {
       extractors: 'extractors',
-      cleanup_html: 'cleanupHTML',
+      cleanup_mode: 'cleanup.mode',
+      cleanup_return_cleaned: 'cleanup.returnCleaned',
+      cleanup_return_raw: 'cleanup.returnRaw',
       language: 'languageOverride',
       filter_dbpedia_types: 'entities.filterDbpediaTypes',
-      filter_freebase_types: 'entities.filterFreebaseTypes'
+      filter_freebase_types: 'entities.filterFreebaseTypes',
+      allow_overlap: 'entities.allowOverlap',
+      enrichment_queries: 'entities.enrichmentQueries'
     }
 
     def self.post(text, options)

data/lib/textrazor/response.rb

@@ -8,7 +8,7 @@ module TextRazor
     Unauthorised = Class.new(StandardError)
     RequestEntityTooLong = Class.new(StandardError)
 
-    attr_reader :raw_response
+    attr_reader :raw_response, :time
 
     def initialize(http_response)
       code = http_response.code
@@ -18,45 +18,78 @@ module TextRazor
       raise Unauthorised.new(body) if unauthorised?(code)
       raise RequestEntityTooLong.new(body) if request_entity_too_long?(code)
 
-      @raw_response = ::JSON.parse(body)["response"]
+      json_body = ::JSON::parse(body, symbolize_names: true)
+
+      @time = json_body[:time].to_f
+      @ok = json_body[:ok]
+      @raw_response = json_body[:response]
     end
 
-    def topics
-      @topics ||= parse_topics(raw_response["topics"])
+    def ok?
+      @ok
     end
 
-     def coarse_topics
-      @coarse_topics ||= parse_topics(raw_response["coarseTopics"])
+    #TODO: Not in a successful response
+    #def error
+    #end
+
+    #def message
+    #end
+
+    def custom_annotation_output
+      @custom_annotation_output ||= raw_response[:customAnnotationOutput]
+    end
+
+    def cleaned_text
+      @cleaned_text ||= raw_response[:cleanedText]
+    end
+
+    def raw_text
+      @raw_text||= raw_response[:rawText]
+    end
+
+    def entailments
+      @entailments ||= parse_entailments
     end
 
     def entities
-      raw_entities = raw_response["entities"]
-      return nil if raw_entities.nil?
+      @entities ||= parse_entities
+    end
 
-      @entities ||= begin
-        raw_entities.map do |entity_hash|
-          Entity.create_from_hash(entity_hash)
-        end
-      end
+    def coarse_topics
+      @coarse_topics ||= parse_coarse_topics
     end
 
-    def words
-      raw_sentences = raw_response["sentences"]
-      return nil if raw_sentences.nil?
-
-      @words ||= begin
-        words = []
-        raw_sentences.each do |sentence_hash|
-          sentence_hash["words"].each do |word_hash|
-            words << Word.create_from_hash(word_hash)
-          end
-        end
-        words
-      end
+    def topics
+      @topics ||= parse_topics
     end
 
     def phrases
-      @phrases ||= parse_phrases(raw_response["nounPhrases"], words)
+      @phrases ||= parse_phrases
+    end
+
+    def words
+      @words ||= parse_words
+    end
+
+    def properties
+      @properties ||= parse_properties
+    end
+
+    def relations
+      @relations ||= parse_relations
+    end
+
+    def sentences
+       @sentences ||= parse_sentences
+    end
+
+    def language
+      raw_response[:language]
+    end
+
+    def language_is_reliable?
+      raw_response[:languageIsReliable]
     end
 
     private
@@ -73,22 +106,65 @@ module TextRazor
       code == 413
     end
 
-    def parse_topics(raw_topics)
-      return nil if raw_topics.nil?
+    def parse_entailments
+      parse(:entailment, raw_response[:entailments])
+    end
 
-      raw_topics.map do |topic_hash|
-        Topic.create_from_hash(topic_hash)
-      end
+    def parse_entities
+      parse(:entity, raw_response[:entities])
     end
 
-    def parse_phrases(raw_phrases, words)
-      return nil if raw_phrases.nil?
+    def parse_coarse_topics
+      parse(:topic, raw_response[:coarseTopics])
+    end
+
+    def parse_topics
+      parse(:topic, raw_response[:topics])
+    end
+
+    def parse_phrases
+      raw_phrases = raw_response[:nounPhrases]
+      return if raw_phrases.nil?
 
       raw_phrases.map do |phrase_hash|
         Phrase.create_from_hash(phrase_hash, words)
       end
     end
 
+    def parse_words
+      raw_sentences = raw_response[:sentences]
+      return if raw_sentences.nil?
+
+      words = []
+      raw_sentences.each do |sentence_hash|
+        sentence_hash[:words].each do |word_hash|
+          words << Word.create_from_hash(word_hash)
+        end
+      end
+      words
+    end
+
+    def parse_properties
+      parse(:property, raw_response[:properties])
+    end
+
+    def parse_relations
+      parse(:relation, raw_response[:relations])
+    end
+
+    def parse_sentences
+      parse(:sentence, raw_response[:sentences])
+    end
+
+    def parse(type, data)
+      return nil if data.nil?
+
+      klass = Object.const_get("TextRazor::#{type.capitalize}")
+
+      data.map do |data_hash|
+        klass.create_from_hash(data_hash)
+      end
+    end
   end
 
 end