bel_parser 1.0.0.alpha.12 → 1.0.0.alpha.13

data/lib/bel_parser/resource/eager_reader.rb

@@ -0,0 +1,75 @@
+require 'concurrent/hash'
+
+module BELParser
+  module Resource
+    module EagerReader
+
+      EMPTY_ARRAY = [].freeze
+      CACHE_KEYS  = [:name, :identifier, :title, :synonyms].freeze
+
+      def resources
+        @resources ||= Concurrent::Hash.new
+      end
+
+      def locks
+        @locks ||= Concurrent::Hash.new
+      end
+
+      def retrieve_resource(resource_identifier)
+        if !resources.key?(resource_identifier)
+          load_all_values(resource_identifier)
+        end
+        super
+      end
+
+      def retrieve_value_from_resource(resource_identifier, value)
+        if !resources.key?(resource_identifier)
+          load_all_values(resource_identifier)
+        end
+
+        concepts = resources[resource_identifier]
+        return super unless concepts
+        CACHE_KEYS.each do |key|
+          cached_concept = concepts[key].fetch(value, nil)
+          return cached_concept if cached_concept
+        end
+        
+        EMPTY_ARRAY
+      end
+
+      def retrieve_values_from_resource(resource_identifier)
+        if !resources.key?(resource_identifier)
+          load_all_values(resource_identifier)
+        end
+
+        concepts = resources[resource_identifier]
+        return super unless concepts
+        concepts[:name].values
+      end
+
+      def load_all_values(identifier)
+        lock = locks[identifier] ||= Mutex.new
+        if lock.try_lock
+          Thread.new do
+            value_hash = {
+              :name       => Hash.new { |hash, key| hash[key] = [] },
+              :identifier => Hash.new { |hash, key| hash[key] = [] },
+              :title      => Hash.new { |hash, key| hash[key] = [] },
+              :synonyms   => Hash.new { |hash, key| hash[key] = [] }
+            }
+            retrieve_values_from_resource(identifier).each do |concept|
+              value_hash[:name][concept.name] << concept
+              value_hash[:identifier][concept.identifier] << concept
+              value_hash[:title][concept.title] << concept
+              concept.synonyms.each do |synonym|
+                value_hash[:synonyms][synonym] << concept
+              end
+            end
+            resources[identifier] = value_hash
+            lock.unlock
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/eager_sparql_reader.rb

@@ -0,0 +1,51 @@
+require 'concurrent/hash'
+
+require_relative 'sparql_reader'
+
+module BELParser
+  module Resource
+    # EagerSPARQLReader
+    class EagerSPARQLReader < SPARQLReader
+      def initialize(sparql_endpoint_url, validate_url = true)
+        @resources = Concurrent::Hash.new
+        @locks     = Concurrent::Hash.new
+        super
+      end
+
+      def retrieve_resource(resource_identifier)
+        if @resources.key?(resource_identifier)
+          concepts = @resources[resource_identifier]
+          concepts[value]
+        else
+          lock = @locks[resource_identifier] ||= Mutex.new
+          if lock.try_lock
+            Thread.new do
+              concepts = retrieve_values_from_resource(resource_identifier).to_a
+              @resources[resource_identifier] = 
+                Hash[
+                  concepts.map do |c|
+                    [c.name, c]
+                  end
+                ]
+              lock.unlock
+            end
+          end
+
+          super
+        end
+      end
+
+      def retrieve_value_from_resource(resource_identifier, value)
+        concepts = @resources[resource_identifier]
+        return super unless concepts
+        concepts[value]
+      end
+
+      def retrieve_values_from_resource(resource_identifier)
+        concepts = @resources[resource_identifier]
+        return super unless concepts
+        concepts
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/http_cache.rb

@@ -0,0 +1,71 @@
+require 'base64'
+require 'concurrent/hash'
+require 'digest'
+require 'fileutils'
+require 'net/http'
+require 'tempfile'
+
+module BELParser
+  module Resource
+    class HTTPCache
+
+      # Lock (per URL) ensures concurrent retrieval/caching is thread-safe.
+      URL_LOCKS = Concurrent::Hash.new do |hash, key|
+        hash[key] = Mutex.new
+      end
+      private_constant :URL_LOCKS
+
+      def initialize(base_dir="#{Dir.tmpdir}/bel-resources")
+        @base_dir  = FileUtils.mkdir_p(base_dir).first
+      end
+
+      def get(url)
+        cached_url_path = File.join(@base_dir, hash_url(url))
+        URL_LOCKS[url].synchronize do
+          if File.exists?(cached_url_path)
+            if block_given?
+              File.open(cached_url_path) do |cached_file|
+                yield cached_file
+              end
+            else
+              File.open(cached_url_path)
+            end
+          else
+            uri = URI.parse(url)
+            cached_file = File.open(cached_url_path, 'w')
+            begin
+              Net::HTTP.start(uri.host, uri.port) do |http|
+                http.request(Net::HTTP::Get.new(uri)) do |response|
+                  if block_given?
+                    response.read_body do |chunk|
+                      cached_file.write(chunk)
+                      yield StringIO.new(chunk)
+                    end
+                  else
+                    content = response.read_body
+                    cached_file.write(content)
+                    return StringIO.new(content)
+                  end
+                end
+              end
+            ensure
+              cached_file.close
+            end
+          end
+        end
+      end
+
+      protected
+
+      def hash_url(url)
+        Base64.encode64(Digest::SHA1.digest(url)).delete("/=\n")
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  BELParser::Resource::HTTPCache.new.get(ARGV.first) do |io|
+    io.each_line { |line| puts line }
+  end
+end

data/lib/bel_parser/resource/jena_tdb_reader.rb

@@ -0,0 +1,246 @@
+require 'erb'
+require 'rdf'
+require 'rdf/vocab'
+require 'rdf/jena'
+
+require_relative 'reader'
+require_relative 'lru_reader'
+require_relative 'concept'
+require_relative 'concept_scheme'
+
+module BELParser
+  module Resource
+    class JenaTDBReader
+      include Reader
+      prepend LRUReader
+
+      BELV = RDF::Vocabulary.new('http://www.openbel.org/vocabulary/')
+      SKOS = RDF::Vocab::SKOS
+      DC   = RDF::Vocab::DC
+      VALUE_PREDICATE_ORDER = [
+        SKOS.prefLabel,
+        DC.identifier,
+        DC.title,
+        SKOS.altLabel
+      ]
+
+      def initialize(tdb_directory_path)
+        @rdf = RDF::Jena::Repository.new(tdb_directory_path)
+      end
+
+      def retrieve_resource(identifier)
+        uri   = RDF::URI(identifier)
+        domain, prefix, pref_label = nil
+        types                      = []
+        @rdf.query([:subject => uri]).each do |solution|
+          case solution.predicate
+          when RDF.type
+            types << solution.object
+          when BELV.domain
+            domain = solution.object.to_s
+          when BELV.prefix
+            prefix = solution.object.to_s
+          when SKOS.prefLabel
+            pref_label = solution.object.to_s
+          end
+        end
+        return nil unless types.any? do |type_uri|
+          type_uri == BELV.AnnotationConceptScheme || type_uri == BELV.NamespaceConceptScheme
+        end
+        ConceptScheme.new(uri, domain, prefix, pref_label, types)
+      end
+
+      def retrieve_value_from_resource(identifier, value)
+        concept_scheme = retrieve_resource(identifier)
+        return nil unless concept_scheme
+
+        template_binding = binding
+        sparql_query     = RESOLVE_CONCEPT.result(template_binding)
+        to_concept       = method(:hash_to_concept).to_proc.curry[concept_scheme]
+
+        @rdf.query_execute(sparql_query).map(&to_concept)
+      end
+
+      def retrieve_values_from_resource(identifier)
+        concept_scheme = retrieve_resource(identifier)
+        return nil unless concept_scheme
+
+        template_binding = binding
+        sparql_query     = RESOLVE_CONCEPTS.result(template_binding)
+        to_concept       = method(:hash_to_concept).to_proc.curry[concept_scheme]
+
+        @rdf.query_execute(sparql_query).map(&to_concept)
+      end
+
+      private
+
+      def find_value_uris(resource_uri, value)
+        VALUE_PREDICATE_ORDER.each do |predicate|
+          subjects =
+            @rdf.query([:predicate => predicate, :object => value])
+            .select do |stmt|
+              @rdf.has_statement?(
+                RDF::Statement(stmt.subject, SKOS.inScheme, resource_uri))
+            end.map(&:subject)
+
+          if !subjects.empty?
+            return subjects
+          end
+        end
+
+        []
+      end
+
+      def hash_to_concept(concept_scheme, hash)
+        Concept.new(concept_scheme, 
+          *hash.values_at('concept', 'prefLabel', 'identifier', 'title',
+            'altLabels', 'types'))
+      end
+
+      RESOLVE_CONCEPT = ERB.new(<<-SPARQL)
+        prefix belv: <http://www.openbel.org/vocabulary/>
+        prefix dct:  <http://purl.org/dc/terms/>
+        prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+        prefix skos: <http://www.w3.org/2004/02/skos/core#>
+        select ?concept ?prefLabel ?identifier ?title
+          (group_concat(distinct(?type);separator='|') as ?types)
+          (group_concat(distinct(?altLabel);separator='|') as ?altLabels)
+        where {
+            {?concept    skos:prefLabel "<%= value %>"}
+              UNION
+            {?concept    dct:identifier "<%= value %>"}
+              UNION
+            {?concept    dct:title      "<%= value %>"}
+              UNION
+            {?concept    skos:altLabel  "<%= value %>"}
+
+            ?concept     skos:inScheme  <<%= identifier %>> .
+            ?concept     rdf:type       ?type .
+
+            ?concept     skos:prefLabel ?prefLabel .
+            ?concept     dct:identifier ?identifier .
+            optional {
+              ?concept     dct:title      ?title .
+              ?concept     skos:altLabel  ?altLabel .
+            }
+        }
+        group by ?concept ?prefLabel ?identifier ?title
+      SPARQL
+
+      RESOLVE_CONCEPTS = ERB.new(<<-SPARQL)
+        prefix belv: <http://www.openbel.org/vocabulary/>
+        prefix dct:  <http://purl.org/dc/terms/>
+        prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+        prefix skos: <http://www.w3.org/2004/02/skos/core#>
+        select ?concept ?prefLabel ?identifier ?title
+          (group_concat(distinct(?type);separator='|') as ?types)
+          (group_concat(distinct(?altLabel);separator='|') as ?altLabels)
+        where {
+            ?concept skos:inScheme  <<%= identifier %>> .
+            ?concept rdf:type       ?type .
+            ?concept skos:prefLabel ?prefLabel .
+            optional {
+              ?concept dct:identifier ?identifier .
+              ?concept dct:title      ?title .
+              ?concept skos:altLabel  ?altLabel
+            }
+        }
+        group by ?concept ?prefLabel ?identifier ?title
+      SPARQL
+
+      #ConceptScheme
+      class ConceptScheme
+        include Dataset
+
+        attr_reader :identifier, :domain, :keyword, :name, :types
+
+        def initialize(uri, domain, prefix, name, types)
+          @identifier = uri
+          @domain     = domain.to_s
+          @keyword    = prefix.to_s
+          @name       = name.to_s
+          @types      = convert_types(types)
+        end
+
+        private
+
+        def convert_types(types)
+          types.map do |type|
+            case type
+            when BELV.NamespaceConceptScheme
+              Dataset::NAMESPACE
+            when BELV.AnnotationConceptScheme
+              Dataset::ANNOTATION
+            end
+          end.compact
+        end
+      end
+
+      class Concept
+        include Value
+
+        attr_reader :dataset, :uri, :name, :identifier,
+                    :title,   :synonyms, :encodings
+
+        def initialize(dataset, uri, pref_label, identifier,
+                       title, alt_labels, types)
+
+          @dataset    = dataset
+          @uri        = uri
+          @name       = pref_label.to_s
+          @identifier = identifier.to_s
+          @title      = title.to_s
+          @synonyms   =
+            if alt_labels.respond_to?(:each)
+              alt_labels.map(&:to_s)
+            else
+              alt_labels.to_s.split('|')
+            end
+          @encodings  =
+            if types.respond_to?(:each)
+              convert_encoding_types(types.map(&:to_s))
+            else
+              convert_encoding_types(types.to_s.split('|'))
+            end
+        end
+
+        private
+
+        def convert_encoding_types(types)
+          types.map do |type|
+            case type
+            when BELV.AbundanceConcept
+              :A
+            when BELV.BiologicalProcessConcept
+              :B
+            when BELV.ComplexConcept
+              :C
+            when BELV.GeneConcept
+              :G
+            when BELV.LocationConcept
+              :L
+            when BELV.MicroRNAConcept
+              :M
+            when BELV.MolecularActivityConcept
+              :T
+            when BELV.PathologyConcept
+              :O
+            when BELV.ProteinConcept
+              :P
+            when BELV.ProteinModificationConcept
+              :E
+            when BELV.RNAConcept
+              :R
+            end
+          end.compact
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  reader = BELParser::Resource::JenaTDBReader.new(
+    '/home/tony/projects/openbel/resource-reasoner/biological-concepts-db')
+  reader.retrieve_resource('http://www.openbel.org/bel/namespace/hgnc-human-genes')
+end

data/lib/bel_parser/resource/lru_cache.rb

@@ -0,0 +1,111 @@
+require 'concurrent/hash'
+
+module BELParser
+  module Resource
+    # LRUCache implements a least recently used cache. This implementation was
+    # initially copied from https://github.com/SamSaffron/lru_redux.
+		class LRUCache
+			def initialize(max_size)
+				raise ArgumentError.new(:max_size) if max_size < 1
+
+				@max_size = max_size
+				@data = Concurrent::Hash.new
+			end
+
+			def max_size=(max_size)
+				max_size ||= @max_size
+
+				raise ArgumentError.new(:max_size) if max_size < 1
+
+				@max_size = max_size
+
+				@data.shift while @data.size > @max_size
+			end
+
+			def getset(key)
+				found = true
+				value = @data.delete(key){ found = false }
+				if found
+					@data[key] = value
+				else
+					result = @data[key] = yield
+					@data.shift if @data.length > @max_size
+					result
+				end
+			end
+
+			def fetch(key)
+				found = true
+				value = @data.delete(key){ found = false }
+				if found
+					@data[key] = value
+				else
+					yield if block_given?
+				end
+			end
+
+			def [](key)
+				found = true
+				value = @data.delete(key){ found = false }
+				if found
+					@data[key] = value
+				else
+					nil
+				end
+			end
+
+			def []=(key,val)
+				@data.delete(key)
+				@data[key] = val
+				@data.shift if @data.length > @max_size
+				val
+			end
+
+			def each
+				unless block_given?
+					return enum_for(:each)
+				end
+
+				array = @data.to_a
+				array.reverse!.each do |pair|
+					yield pair
+				end
+			end
+
+			# used further up the chain, non thread safe each
+			alias_method :each_unsafe, :each
+
+			def to_a
+				array = @data.to_a
+				array.reverse!
+			end
+
+			def delete(key)
+				@data.delete(key)
+			end
+
+			alias_method :evict, :delete
+
+			def key?(key)
+				@data.key?(key)
+			end
+
+			alias_method :has_key?, :key?
+
+			def clear
+				@data.clear
+			end
+
+			def count
+				@data.size
+			end
+
+			protected
+
+			# for cache validation only, ensures all is sound
+			def valid?
+				true
+			end
+		end
+	end
+end

data/lib/bel_parser/resource/lru_reader.rb

@@ -0,0 +1,38 @@
+require_relative 'lru_cache'
+
+module BELParser
+  module Resource
+    module LRUReader
+
+      LRU_MAX_SIZE = 500
+      private_constant :LRU_MAX_SIZE
+
+      def resources
+        @resources ||= Concurrent::Hash.new
+      end
+
+      def retrieve_resource(resource_identifier)
+        if !resources.key?(resource_identifier)
+          resources[resource_identifier] = LRUCache.new(LRU_MAX_SIZE)
+        end
+        super
+      end
+
+      def retrieve_value_from_resource(resource_identifier, value)
+        if !resources.key?(resource_identifier)
+          resources[resource_identifier] = LRUCache.new(LRU_MAX_SIZE)
+        end
+
+        concepts = resources[resource_identifier]
+        concepts.getset(value) {
+          puts "retrieving from RDF..."
+          super
+        }
+      end
+
+      def retrieve_values_from_resource(resource_identifier)
+        super
+      end
+    end
+  end
+end

data/lib/bel_parser/resource/reader.rb

@@ -0,0 +1,18 @@
+module BELParser
+  module Resource
+    # Reader represents the API for a reader of resource data.
+    module Reader
+      def retrieve_resource(resource_identifier)
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def retrieve_value_from_resource(resource_identifier, value)
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+
+      def retrieve_values_from_resource(resource_identifier)
+        raise NotImplementedError, "#{__method__} is not implemented."
+      end
+    end
+  end
+end