ncbo_resource_index_client 1.4

data/lib/ncbo_resource_index/data.rb

@@ -0,0 +1,17 @@
+module NCBO
+  class ResourceIndex
+
+    class Annotations
+      attr_accessor :resource, :annotations, :total_annotation_count, :offset, :limit
+    end
+    
+    class Annotation
+      attr_accessor :score, :concept, :context, :element
+    end
+
+    class RankedElements
+      attr_accessor :concepts, :resources
+    end
+
+  end
+end

data/lib/ncbo_resource_index/parser.rb

@@ -0,0 +1,229 @@
+module NCBO
+  module Parser
+    
+    class BaseParser
+      def parse_xml(xml)
+        if xml.kind_of?(String)
+          parser = XML::Parser.string(xml, :options => LibXML::XML::Parser::Options::NOBLANKS)
+        else
+          parser = XML::Parser.io(xml, :options => LibXML::XML::Parser::Options::NOBLANKS)
+        end
+        parser.parse
+      end
+      
+      def safe_to_i(str)
+        Integer(str) rescue str
+      end
+    end
+    
+    class ResourceIndex < BaseParser
+      def initialize(results)
+        @root = "/success/data/annotatorResultBean"
+        @results = parse_xml(results)
+      end
+      
+      def self.parse_included_ontologies(ontologies)
+        new(ontologies).parse_included_ontologies
+      end
+        
+      def parse_included_ontologies
+        @root = "/success/data/set"
+        ontologies = parse_ontologies("ontology")
+      end
+      
+      def self.parse_resources(resources)
+        new(resources).parse_resources
+      end
+        
+      def parse_resources
+        resources = []
+        @results.find("/success/data/set/resource").each do |resource|
+          a = {}
+          resource.children.each {|child| a[child.name.to_sym] = safe_to_i(child.content) if !child.first.nil? && !child.first.children?}
+          a[:contexts] = parse_resource_structure(resource.find_first("resourceStructure"))
+          resources << a
+        end
+        resources
+      end
+      
+      def self.parse_results(results, options = {})
+        new(results).parse_results(options)
+      end
+      
+      def parse_results(options = {})
+        resource ||= options[:resource]
+        annotation_location ||= options[:annotation_location]
+        
+        results = []
+        @results.find("/success/data/list/*").each do |result|
+          resource_annotations = NCBO::ResourceIndex::Annotations.new
+          resource_annotations.resource = resource ||= result.find_first("resourceId").content
+
+          # Check to see if parameters are enabled that will change how we process the output
+          with_context = result.find_first("withContext").content.eql?("true") rescue false
+          counts = result.find_first("counts").content.eql?("true") rescue false
+
+          # Update total count (if available)
+          resource_annotations.total_annotation_count = result.find_first("resultStatistics/statistics/annotationCount").content.to_i if counts
+          
+          resource_annotations.annotations = parse_annotations(result, with_context, annotation_location)
+          results << resource_annotations
+        end
+        results = results[0] if results.kind_of?(Array) && results.length == 1
+        results
+      end
+      
+      def self.parse_ranked_element_results(results)
+        new(results).parse_ranked_element_results
+      end
+
+      def parse_ranked_element_results
+        ranked_elements = NCBO::ResourceIndex::RankedElements.new
+
+        ranked_elements.concepts = []
+        @results.find("/success/data/map/entry[string='concepts']/list/*").each do |concept|
+          concept = parse_concept(concept, ".")
+          ranked_elements.concepts << concept
+        end
+
+        ranked_elements.resources = []
+        @results.find("/success/data/map/entry[string='elements']/list/resourceElements").each do |resource|
+          r = {}
+          r[:resourceId] = resource.find_first("resourceId").content
+          r[:offset] = resource.find_first("offset").content.to_i
+          r[:limit] = resource.find_first("limit").content.to_i
+          r[:totalResults] = resource.find_first("totalResults").content.to_i
+          r[:elements] = []
+          resource.find("./elementResults/elementResult").each do |element|
+            r[:elements] << parse_element(element)
+          end
+          ranked_elements.resources << r
+        end
+
+        ranked_elements
+      end
+
+      def self.parse_popular_concepts(results)
+        new(results).parse_popular_concepts
+      end
+
+      def parse_popular_concepts
+        concepts = []
+        @results.find("/success/data/list/*").each do |concept_frequency|
+          concept = {}
+          concept[:counts] = concept_frequency.find_first("counts").content.to_i
+          concept[:score] = concept_frequency.find_first("score").content.to_i
+          concept[:concept] = parse_concept(concept_frequency)
+          concepts << concept
+        end
+        concepts
+      end
+
+      def self.parse_element_annotations(results)
+        new(results).parse_element_annotations
+      end
+      
+      def parse_element_annotations
+        annotation_location = "annotation"
+        with_context = false
+        
+        annotations = NCBO::ResourceIndex::Annotations.new
+        annotations.annotations = parse_annotations(@results.find_first("/success/data/list"), with_context, annotation_location)
+        annotations
+      end
+
+      private
+
+      def parse_annotations(result, with_context = false, annotation_location = "annotations/*")
+        annotations = []
+        if with_context
+          result.find("mgrepAnnotations/*").each do |annotation|
+            annotations << parse_annotation(annotation)
+          end
+          result.find("reportedAnnotations/*").each do |annotation|
+            annotations << parse_annotation(annotation)
+          end
+          result.find("isaAnnotations/*").each do |annotation|
+            annotations << parse_annotation(annotation)
+          end
+          result.find("mappingAnnotations/*").each do |annotation|
+            annotations << parse_annotation(annotation)
+          end
+        else
+          result.find(annotation_location).each do |annotation|
+            annotations << parse_annotation(annotation)
+          end
+        end
+        annotations
+      end
+      
+      def parse_annotation(annotation, context = false)
+        new_annotation = NCBO::ResourceIndex::Annotation.new
+        new_annotation.score = annotation.find_first("score").content.to_f
+        new_annotation.concept = parse_concept(annotation)
+        new_annotation.context = parse_context(annotation)
+        new_annotation.element = parse_element(annotation)
+        new_annotation
+      end
+      
+      # The only thing we care about from here is the contexts, everything else is internal info
+      def parse_resource_structure(resource_structure)
+        contexts = []
+        resource_structure.find_first("contexts").each {|context| contexts << context.first.content}
+        contexts
+      end
+      
+      def parse_ontologies(ontology_location = "ontologies/ontologyUsedBean")
+        ontologies = []
+        @results.find(@root + "/#{ontology_location}").each do |ontology|
+          ont = {}
+          ontology.children.each {|child| ont[child.name.to_sym] = safe_to_i(child.content)}
+          ontologies << ont
+        end
+        ontologies
+      end
+      
+      def parse_concept(annotation, concept_location = "concept")
+        a = {}
+        annotation.find("#{concept_location}/*").each {|child| a[child.name.to_sym] = safe_to_i(child.content) if !child.first.nil? && !child.first.children?}
+        a[:synonyms] = annotation.find("#{concept_location}/synonyms/string").map {|syn| safe_to_i(syn.content)}
+        semantic_types = parse_semantic_types(annotation.find_first("#{concept_location}/localSemanticTypeIds"))
+        a[:semantic_types] = semantic_types
+        a
+      end
+
+      def parse_semantic_types(semantic_types_xml)
+        return Array.new if semantic_types_xml.nil?
+        
+        semantic_types = []
+        semantic_types_xml.each do |semantic_type_bean|
+          semantic_type_bean.children.each { |child| semantic_types << safe_to_i(child.content) }
+        end
+        semantic_types
+      end
+      
+      def parse_context(annotation)
+        a = {}
+        annotation.find("context/*").each {|child| a[child.name.to_sym] = safe_to_i(child.content) if !child.first.nil? && !child.first.children?}
+        a[:contextType] = annotation.find_first("context").attributes["class"] unless annotation.find_first("context").nil?
+        a
+      end
+      
+      def parse_element(annotation)
+        a = {}
+        a[:localElementId] = annotation.find_first("element/localElementId").content unless annotation.find_first("element/localElementId").nil?
+        # element text
+        a[:text] = {}
+        annotation.find("element/elementStructure/contexts/*").each {|context| a[:text][context.children[0].content] = context.children[1].content}
+        # element weights
+        a[:weights] = []
+        annotation.find("element/elementStructure/weights/*").each {|weight| a[:weights] << {:name => weight.children[0].content, :weight => weight.children[1].content.to_f} }
+        # which element portions are associated with an ontology
+        a[:ontoIds] = {}
+        annotation.find("element/elementStructure/ontoIds/*").each {|ont_id| a[:ontoIds][ont_id.children[0].content] = ont_id.children[1].content.to_i}
+        return a
+      end
+    end
+    
+  end
+end

data/lib/ncbo_resource_index.rb

@@ -0,0 +1,258 @@
+require 'net/http'
+require 'xml'
+require 'uri'
+require 'open-uri'
+require 'cgi'
+require 'ncbo_resource_index/parser'
+require 'ncbo_resource_index/data'
+
+
+module NCBO
+  class ResourceIndex
+
+    def initialize(args = {})
+      @options = {}
+  
+      # Shared with Annotator
+      @options[:resource_index_location] = "http://rest.bioontology.org/resource_index/"
+      @options[:filterNumber] = true
+      @options[:isStopWordsCaseSensitive] = false
+      @options[:isVirtualOntologyId] = true
+      @options[:levelMax] = 0
+      @options[:longestOnly] = false
+      @options[:ontologiesToExpand] = []
+      @options[:ontologiesToKeepInResult] = []
+      @options[:mappingTypes] = []
+      @options[:minTermSize] = 3
+      @options[:scored] = true
+      @options[:semanticTypes] = []
+      @options[:stopWords] = []
+      @options[:wholeWordOnly] = true
+      @options[:withDefaultStopWords] = true
+      @options[:withSynonyms] = true
+      
+      # RI-specific
+      @options[:conceptids] = []
+      @options[:mode] = :union
+      @options[:elementid] = []
+      @options[:resourceids] = []
+      @options[:elementDetails] = false
+      @options[:withContext] = true
+      @options[:offset] = 0
+      @options[:limit] = 10
+      @options[:format] = :xml
+      @options[:counts] = false
+      @options[:request_timeout] = 300
+      
+      @options.merge!(args)
+      
+      @ontologies = nil
+      @options[:resourceids] ||= []
+      
+      # Check to make sure mappingTypes are capitalized
+      fix_params
+    
+      raise ArgumentError, ":apikey is required, you can obtain one at http://bioportal.bioontology.org/accounts/new" if @options[:apikey].nil?
+    end
+
+    def self.find_by_concept(concepts, options = {})
+      new(options).find_by_concept(concepts)
+    end
+  
+    def find_by_concept(concepts = [], options = {})
+      @options[:conceptids] = concepts unless concepts.nil? || concepts.empty?
+      @options.merge!(options) unless options.empty?
+      fix_params
+      
+      raise ArgumentError, ":conceptids must be included" if @options[:conceptids].nil? || @options[:conceptids].empty?
+      
+      result_xml = resource_index_post
+      Parser::ResourceIndex.parse_results(result_xml)
+    end
+    
+    def self.find_by_element(element, resource, options = {})
+      new(options).find_by_element(element, resource)
+    end
+    
+    def find_by_element(element, resource, options = {})
+      @options[:elementid] = element unless element.nil? || element.empty?
+      @options[:resourceids] = [resource] unless resource.nil? || resource.empty?
+      @options.merge!(options) unless options.empty?
+      fix_params
+      raise ArgumentError, ":elementid must be included" if @options[:elementid].nil? || @options[:elementid].empty?
+      raise ArgumentError, ":resourceids must be included" if @options[:resourceids].nil? || @options[:resourceids].empty?
+      Parser::ResourceIndex.parse_results(resource_index_post)
+    end
+    
+    def self.element_annotations(element, concepts, resource, options = {})
+      new(options).element_annotations(element, concepts)
+    end
+    
+    def element_annotations(element, concepts, resource)
+      @options[:conceptids] = concepts unless concepts.nil? || concepts.empty?
+      raise ArgumentError, ":conceptids must be included" if @options[:conceptids].nil? || @options[:conceptids].empty?
+      raise ArgumentError, ":resourceids must be an array" unless @options[:resourceids].kind_of? Array
+      resource = resource.upcase
+      
+      concept_annotations = []
+      concepts.each do |concept|
+        split_concept = concept.split("/")
+        ontology_id = split_concept[0]
+        concept_id = split_concept[1]
+        virtual = @options[:isVirtualOntologyId] ? "/virtual" : ""
+        result_xml = open(["#{@options[:resource_index_location]}",
+                           "details/#{@options[:elementDetails]}",
+                           virtual,
+                           "/concept/#{ontology_id}",
+                           "/resource/#{resource}",
+                           "/#{@options[:offset]}",
+                           "/#{@options[:limit]}",
+                           "?conceptid=#{CGI.escape(concept_id)}",
+                           "&elementid=#{CGI.escape(element)}",
+                           "&apikey=#{@options[:apikey]}"].join("")).read
+
+        annotations = Parser::ResourceIndex.parse_element_annotations(result_xml)
+        concept_annotations << annotations
+      end
+
+      if concept_annotations.length > 1
+        # Merge the two result sets
+        primary_annotations = Annotations.new
+        primary_annotations.annotations = []
+        primary_annotations.resource = resource
+        concept_annotations.each do |result|
+          primary_annotations.annotations.concat result.annotations
+        end
+      elsif concept_annotations.length == 1
+        primary_annotations = concept_annotations[0]
+      else
+        primary_annotations = nil
+      end
+      primary_annotations
+    end
+
+    def self.ranked_elements(concepts, options = {})
+      new(options).ranked_elements(concepts)
+    end
+  
+    def ranked_elements(concepts = [], options = {})
+      @options[:conceptids] = concepts unless concepts.nil? || concepts.empty?
+      @options[:resourceids] ||= []
+      @options.merge!(options) unless options.empty?
+      fix_params
+      
+      raise ArgumentError, ":conceptids must be included" if @options[:conceptids].nil? || @options[:conceptids].empty?
+      raise ArgumentError, ":resourceids must be an array" unless @options[:resourceids].kind_of? Array
+      
+      result_url = ["#{@options[:resource_index_location]}",
+                         "elements-ranked-by-concepts/#{@options[:resourceids].join(",")}",
+                         "?offset=#{@options[:offset]}",
+                         "&limit=#{@options[:limit]}",
+                         "&conceptids=#{@options[:conceptids].join(",")}",
+                         "&ontologiesToKeepInResult=#{@options[:ontologiesToKeepInResult].join(",")}",
+                         "&isVirtualOntologyId=#{@options[:isVirtualOntologyId]}",
+                         "&apikey=#{@options[:apikey]}",
+                         "&mode=#{@options[:mode]}"].join("")
+      result_xml = open(result_url).read
+      Parser::ResourceIndex.parse_ranked_element_results(result_xml)
+    end
+    
+    def self.popular_concepts(resources = nil, options = {})
+      new(options).popular_concepts(resources)
+    end
+    
+    def popular_concepts(resources = nil, options = {})
+      @options[:resourceids] = resources
+      @options[:resourceids] = [resources] unless resources.nil? || resources.empty? || resources.kind_of?(Array)
+      @options.merge!(options) unless options.empty?
+      fix_params
+      
+      if @options[:resourceids].nil? || @options[:resourceids].empty?
+        @options[:resourceids] = self.resources.collect {|resource| resource[:resourceId]}
+      end
+      
+      popular_concepts = {}
+      @options[:resourceids].each do |resource|
+        popular_concepts_xml = open("#{@options[:resource_index_location]}most-used-concepts/#{resource}?apikey=#{@options[:apikey]}&offset=#{@options[:offset]}&limit=#{@options[:limit]}").read
+        popular_concepts[resource] = Parser::ResourceIndex.parse_popular_concepts(popular_concepts_xml)
+      end
+      popular_concepts
+    end
+
+    def self.ontologies(options)
+      new(options).ontologies
+    end
+    
+    def ontologies(options = {})
+      @options.merge!(options) unless options.empty?
+
+      if @ontologies.nil?
+        ontologies_xml = open("#{@options[:resource_index_location]}ontologies?apikey=#{@options[:apikey]}").read
+        @ontologies = Parser::ResourceIndex.parse_included_ontologies(ontologies_xml)
+      else
+        @ontologies
+      end
+    end
+
+    def self.resources(options)
+      new(options).resources
+    end
+    
+    def resources(options = {})
+      @options.merge!(options) unless options.empty?
+
+      if @resources.nil?
+        resources_xml = open("#{@options[:resource_index_location]}resources?apikey=#{@options[:apikey]}").read
+        @resources = Parser::ResourceIndex.parse_resources(resources_xml)
+      else
+        @resources
+      end
+    end
+    
+    def self.resources_hash(options)
+      new(options).resources_hash
+    end
+
+    def resources_hash(options = {})
+      @options.merge!(options) unless options.empty?
+      resources = resources()
+      resources_hash = {}
+      resources.each {|res| resources_hash[res[:resourceId].downcase.to_sym] = res}
+      resources_hash
+    end
+    
+    def options
+      @options
+    end
+    
+    private
+    
+    def fix_params
+      @options[:mappingTypes] = @options[:mappingTypes].split(",") if @options[:mappingTypes].kind_of?(String)
+      @options[:ontologiesToExpand] = @options[:ontologiesToExpand].split(",") if @options[:ontologiesToExpand].kind_of?(String)
+      @options[:ontologiesToKeepInResult] = @options[:ontologiesToKeepInResult].split(",") if @options[:ontologiesToKeepInResult].kind_of?(String)
+      @options[:semanticTypes] = @options[:semanticTypes].split(",") if @options[:semanticTypes].kind_of?(String)
+      @options[:stopWords] = @options[:stopWords].split(",") if @options[:stopWords].kind_of?(String)
+      @options[:mappingTypes].collect! {|e| e.capitalize} unless @options[:mappingTypes].nil?
+    end
+
+    def resource_index_post
+      url = URI.parse(@options[:resource_index_location])
+      request_body = []
+      @options.each do |k,v|
+        next if v.kind_of?(Array) && v.empty?
+        if v.kind_of?(Array)
+          request_body << "#{k}=#{v.collect {|val| CGI.escape(val)}.join(",")}"
+        else
+          request_body << "#{k}=#{v}"
+        end
+      end
+      req = Net::HTTP::Post.new(url.path)
+      req.body = request_body.join("&")
+      http = Net::HTTP.new(url.host, url.port)
+      http.read_timeout = @options[:request_timeout]
+      res = http.start {|http| http.request(req)}
+      res.body
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification
+name: ncbo_resource_index_client
+version: !ruby/object:Gem::Version
+  prerelease: 
+  version: '1.4'
+platform: ruby
+authors:
+- Paul R Alexander
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: libxml-ruby
+  type: :runtime
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+description: The NCBO Resource Index Gem is a Ruby client for NCBO's Resource Index
+  Web service. The NCBO Resource Index is a system for ontology based annotation and
+  indexing of biomedical data; the key functionality of this system is to enable users
+  to locate biomedical data resources related to particular concepts. A set of annotations
+  is generated automatically and presented through integration with BioPortal, enabling
+  researchers to search for biomedical resources associated (annotated) with specific
+  ontology terms. This service uses a concept recognizer (developed by the National
+  Center for Integrative Biomedical Informatics, University of Michigan) to produce
+  a set of annotations and expand them using ontology is_a relations.
+email: support@bioontology.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ncbo_resource_index/data.rb
+- lib/ncbo_resource_index/parser.rb
+- lib/ncbo_resource_index.rb
+homepage: http://github.com/ncbo/resource_index_ruby_client
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: The NCBO Resource Index Gem is a Ruby client for NCBO's Resource Index Web
+  service
+test_files: []
+has_rdoc: