rbbt-util 6.0.4 → 6.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6312e564dc119b942bb279017a12bd3571f27b1caa57db746c62996e8c73407
-  data.tar.gz: f08802c255d5967bf211bf801fbeb7f91e9d2a82804f51393061ce422e7fc26e
+  metadata.gz: c5f392d8b49d9b1f3f0e2fc2a627654d7e0d8c8766277ab525c42f692d97eac4
+  data.tar.gz: 78026648894c3868852a01fb1a74bf9b554c9a28e121f51f77029fc6265019cd
 SHA512:
-  metadata.gz: 2f74e126c73d121853002d2918ef5cb8c9b181c7c2264d7eb7c9f4a4d78441fc6b026f1b27eca445613717fff6a8f0169f9aeb86d33afeafe2eebed696685cc3
-  data.tar.gz: 93ddc50c5c0f5b45e79449f81788405fada4ad9aabaeac1f6fd908765184a79220e2960472a460a973afedd31ae2ad389c60d67a80e4b82ae63ac70748bf8a25
+  metadata.gz: 43188e6b49995ee547e1c968ba1daca213e3204e20d0695dfd5b0a75b3788e866d04cba23e84ef59d794e58b2eaae8c7e8860ea07e7e7d71fab14df96dd6d583
+  data.tar.gz: 6656b4fb1a54e5c6b9711a3c5bc735a04335de2380bb93fcd18f923b54914b408640e4545167c7c1599122ae2685e8fca3375b4775c2b3c30f2bdc23146344c1

data/bin/rbbt

@@ -102,7 +102,7 @@ end
 $scout_command_dir = Scout.bin.scout
 $scout_command_dir.path_maps[:rbbt_bin] = File.join(File.dirname(__dir__), "{PATH/bin\\/scout/bin\\/rbbt}")
 $scout_command_dir.path_maps[:rbbt_commands] = File.join(File.dirname(__dir__), "{PATH/bin\\/scout/share\\/rbbt_commands}")
-$scout_command_dir.path_maps[:scout_commands] = File.join(Scout.root.find(:scout_gear), "{PATH/bin\\/scout/scout_commands}")
+$scout_command_dir.path_maps[:scout_commands] = File.join(Scout.root.find(:scout_gear_lib), "{PATH/bin\\/scout/scout_commands}")
 
 SOPT.description =<<EOF
 This command controls many aspects of the Scout framework, from configuration tasks to running applications. 

data/lib/rbbt/hpc/batch.rb

@@ -133,7 +133,7 @@ module HPC
       # Save inputs into inputs_dir
       inputs_dir = IndiferentHash.process_options options, :inputs_dir
       saved = job.save_inputs(inputs_dir)
-      options[:load_inputs] = inputs_dir if saved && saved.any?
+      options[:load_inputs] = inputs_dir if saved && !saved.nil? && !saved.empty?
 
       saved.each do |input|
         options.delete input

data/lib/rbbt/knowledge_base/enrichment.rb

@@ -1,9 +1,9 @@
-require 'rbbt/knowledge_base/registry'
-class KnowledgeBase
-  def enrichment(name, entities, options = {})
-    require 'rbbt/statistics/hypergeometric'
-    database = get_database(name, options)
-    entities = identify_source name, entities
-    database.enrichment entities, database.fields.first, :persist => false
-  end
-end
+#require 'rbbt/knowledge_base/registry'
+#class KnowledgeBase
+#  def enrichment(name, entities, options = {})
+#    require 'rbbt/statistics/hypergeometric'
+#    database = get_database(name, options)
+#    entities = identify_source name, entities
+#    database.enrichment entities, database.fields.first, :persist => false
+#  end
+#end

data/lib/rbbt/knowledge_base/entity.rb

@@ -1,128 +1,128 @@
-require 'rbbt/entity'
-require 'rbbt/knowledge_base/registry'
-
-class KnowledgeBase
-
-  def select_entities(name, entities, options = {})
-    index = get_index(name, options)
-
-    source_field = index.source_field
-    target_field = index.target_field
-
-    source_type = Entity.formats[source_field] 
-    target_type = Entity.formats[target_field]
-
-    source_entities = entities[:source] || entities[source_field] || entities[Entity.formats[source_field].to_s] || entities[:both]
-    target_entities = entities[:target] || entities[target_field] || entities[Entity.formats[target_field].to_s] || entities[:both]
-
-    [source_entities, target_entities]
-  end
-
-
-  def entity_options_for(type, database_name = nil)
-    entity_options = self.entity_options
-    IndiferentHash.setup entity_options if entity_options and not IndiferentHash === entity_options
-    options = entity_options[type.to_s] || entity_options[Entity.formats[type.to_s].to_s] || {}
-    options[:format] = @format[type] if Hash === @format && @format.include?(type)
-    namespace = self.namespace
-    namespace = db_namespace(database_name) if namespace.nil? and database_name
-    options = {:organism => namespace}.merge(options)
-    if database_name  
-      database = get_database(database_name)
-      if database.entity_options and (database.entity_options[type] or database.entity_options[Entity.formats[type.to_s].to_s])
-        options = options.merge(database.entity_options[type] || database.entity_options[Entity.formats[type.to_s].to_s])
-      end
-    end
-    options
-  end
-
-  def annotate(entities, type, database = nil)
-    format = @format[type] || type
-    entity_options = entity_options_for(type, database)
-    Entity.prepare_entity(entities, format, entity_options)
-  end
-
-  def translate(entities, type)
-    if format = @format[type] and (entities.respond_to? :format and format != entities.format)
-      entities.to format
-    else
-      entities
-    end
-  end
-
-  def source_type(name)
-    Entity.formats[source(name)]
-  end
-
-  def target_type(name)
-    Entity.formats[target(name)]
-  end
-
-  def entities
-    all_databases.inject([]){|acc,name| acc << source(name); acc << target(name)}.uniq
-  end
-
-  def entity_types
-    entities.collect{|entity| Entity.formats[entity] }.uniq
-  end
-
-  def identifier_files(name)
-    get_database(name).identifier_files.dup
-  end
-
-  def db_namespace(name)
-    get_database(name).namespace
-  end
-
-  def source_index(name)
-    Persist.memory("Source index #{name}: KB directory #{dir}") do
-      identifier_files = identifier_files(name)
-      identifier_files.concat Entity.identifier_files(source(name)) if defined? Entity
-      identifier_files.uniq!
-      identifier_files.collect!{|f| f.annotate(f.gsub(/\bNAMESPACE\b/, namespace))} if namespace
-      identifier_files.collect!{|f| f.annotate(f.gsub(/\bNAMESPACE\b/, db_namespace(name)))} if not namespace and db_namespace(name)
-      identifier_files.reject!{|f| f.match(/\bNAMESPACE\b/)}
-      TSV.translation_index identifier_files, nil, source(name), :persist => true
-    end
-  end
-  
-  def target_index(name)
-    Persist.memory("Target index #{name}: KB directory #{dir}") do
-      identifier_files = identifier_files(name)
-      identifier_files.concat Entity.identifier_files(target(name)) if defined? Entity
-      identifier_files.uniq!
-      identifier_files.collect!{|f| f.annotate(f.gsub(/\bNAMESPACE\b/, namespace))} if self.namespace
-      identifier_files.collect!{|f| f.annotate(f.gsub(/\bNAMESPACE\b/, db_namespace(name)))} if namespace.nil? and db_namespace(name)
-      identifier_files.reject!{|f| f.match(/\bNAMESPACE\b/)}
-      TSV.translation_index identifier_files, nil, target(name), :persist => true
-    end
-  end
-
-  def identify_source(name, entity)
-    return :all if entity == :all
-    index = source_index(name)
-    return entity if index.nil?
-    if Array === entity
-      entity.collect{|e| index[e] || e }
-    else
-      index[entity] || entity
-    end
-  end
-
-  
-  def identify_target(name, entity)
-    return :all if entity == :all
-    index = target_index(name)
-    return entity if index.nil?
-    if Array === entity
-      entity.collect{|e| index[e] || e }
-    else
-      index[entity] || entity
-    end
-  end
-
-  def identify(name, entity)
-    identify_source(name, entity) || identify_target(name, entity)
-  end
-end
-
+#require 'rbbt/entity'
+#require 'rbbt/knowledge_base/registry'
+#
+#class KnowledgeBase
+#
+#  def select_entities(name, entities, options = {})
+#    index = get_index(name, options)
+#
+#    source_field = index.source_field
+#    target_field = index.target_field
+#
+#    source_type = Entity.formats[source_field] 
+#    target_type = Entity.formats[target_field]
+#
+#    source_entities = entities[:source] || entities[source_field] || entities[Entity.formats[source_field].to_s] || entities[:both]
+#    target_entities = entities[:target] || entities[target_field] || entities[Entity.formats[target_field].to_s] || entities[:both]
+#
+#    [source_entities, target_entities]
+#  end
+#
+#
+#  def entity_options_for(type, database_name = nil)
+#    entity_options = self.entity_options
+#    IndiferentHash.setup entity_options if entity_options and not IndiferentHash === entity_options
+#    options = entity_options[type.to_s] || entity_options[Entity.formats[type.to_s].to_s] || {}
+#    options[:format] = @format[type] if Hash === @format && @format.include?(type)
+#    namespace = self.namespace
+#    namespace = db_namespace(database_name) if namespace.nil? and database_name
+#    options = {:organism => namespace}.merge(options)
+#    if database_name  
+#      database = get_database(database_name)
+#      if database.entity_options and (database.entity_options[type] or database.entity_options[Entity.formats[type.to_s].to_s])
+#        options = options.merge(database.entity_options[type] || database.entity_options[Entity.formats[type.to_s].to_s])
+#      end
+#    end
+#    options
+#  end
+#
+#  def annotate(entities, type, database = nil)
+#    format = @format[type] || type
+#    entity_options = entity_options_for(type, database)
+#    Entity.prepare_entity(entities, format, entity_options)
+#  end
+#
+#  def translate(entities, type)
+#    if format = @format[type] and (entities.respond_to? :format and format != entities.format)
+#      entities.to format
+#    else
+#      entities
+#    end
+#  end
+#
+#  def source_type(name)
+#    Entity.formats[source(name)]
+#  end
+#
+#  def target_type(name)
+#    Entity.formats[target(name)]
+#  end
+#
+#  def entities
+#    all_databases.inject([]){|acc,name| acc << source(name); acc << target(name)}.uniq
+#  end
+#
+#  def entity_types
+#    entities.collect{|entity| Entity.formats[entity] }.uniq
+#  end
+#
+#  def identifier_files(name)
+#    get_database(name).identifier_files.dup
+#  end
+#
+#  def db_namespace(name)
+#    get_database(name).namespace
+#  end
+#
+#  def source_index(name)
+#    Persist.memory("Source index #{name}: KB directory #{dir}") do
+#      identifier_files = identifier_files(name)
+#      identifier_files.concat Entity.identifier_files(source(name)) if defined? Entity
+#      identifier_files.uniq!
+#      identifier_files.collect!{|f| f.annotate(f.gsub(/\bNAMESPACE\b/, namespace))} if namespace
+#      identifier_files.collect!{|f| f.annotate(f.gsub(/\bNAMESPACE\b/, db_namespace(name)))} if not namespace and db_namespace(name)
+#      identifier_files.reject!{|f| f.match(/\bNAMESPACE\b/)}
+#      TSV.translation_index identifier_files, nil, source(name), :persist => true
+#    end
+#  end
+#  
+#  def target_index(name)
+#    Persist.memory("Target index #{name}: KB directory #{dir}") do
+#      identifier_files = identifier_files(name)
+#      identifier_files.concat Entity.identifier_files(target(name)) if defined? Entity
+#      identifier_files.uniq!
+#      identifier_files.collect!{|f| f.annotate(f.gsub(/\bNAMESPACE\b/, namespace))} if self.namespace
+#      identifier_files.collect!{|f| f.annotate(f.gsub(/\bNAMESPACE\b/, db_namespace(name)))} if namespace.nil? and db_namespace(name)
+#      identifier_files.reject!{|f| f.match(/\bNAMESPACE\b/)}
+#      TSV.translation_index identifier_files, nil, target(name), :persist => true
+#    end
+#  end
+#
+#  def identify_source(name, entity)
+#    return :all if entity == :all
+#    index = source_index(name)
+#    return entity if index.nil?
+#    if Array === entity
+#      entity.collect{|e| index[e] || e }
+#    else
+#      index[entity] || entity
+#    end
+#  end
+#
+#  
+#  def identify_target(name, entity)
+#    return :all if entity == :all
+#    index = target_index(name)
+#    return entity if index.nil?
+#    if Array === entity
+#      entity.collect{|e| index[e] || e }
+#    else
+#      index[entity] || entity
+#    end
+#  end
+#
+#  def identify(name, entity)
+#    identify_source(name, entity) || identify_target(name, entity)
+#  end
+#end
+#

data/lib/rbbt/knowledge_base/query.rb

@@ -1,94 +1,94 @@
-require 'rbbt/knowledge_base/registry'
-
-class KnowledgeBase
-
-  def _subset(name, source = :all, target = :all, options = {})
-    repo = get_index name, options
-
-    repo.subset(source, target)
-  end
-
-  def subset(name, entities, options = {}, &block)
-    entities, options = options, entities if entities.nil? and Hash === options
-
-    entities = case entities
-               when :all
-                 {:target => :all, :source => :all}
-               when AnnotatedArray
-                 format = entities.format if entities.respond_to? :format 
-                 format ||= entities.base_entity.to_s
-                 {format => entities.purge}
-               when Hash
-                 entities
-               else
-                 raise "Entities are not a Hash or an AnnotatedArray: #{Log.fingerprint entities}"
-               end
-
-    identify, identify_source, identify_target = entities.merge(options || {}).values_at :identify, :identify_source, :identify_target
-
-    source, target = select_entities(name, entities, options)
-    
-    source = identify_source(name, source) if identify_source
-    target = identify_target(name, target) if identify_target
-
-    source = identify(name, source) if identify && !identify_source
-    target = identify(name, target) if identify && !identify_target
-
-    return [] if source.nil? or target.nil?
-    return [] if Array === target and target.empty?
-    return [] if Array === source and source.empty?
-
-    matches = _subset name, source, target, options
-
-    setup(name, matches)
-
-    matches = matches.select(&block) if block_given? 
-
-    matches
-  end
-
-  def all(name, options={})
-    repo = get_index name, options
-    setup name, repo.keys
-  end
-
-  def _children(name, entity)
-    repo = get_index name
-    repo.match(entity)
-  end
-
-  def children(name, entity)
-    entity = identify_source(name, entity)
-    setup(name, _children(name, entity))
-  end
-
-  def _parents(name, entity)
-    repo = get_index name
-    repo.reverse.match(entity)
-  end
-
-  def parents(name, entity)
-    entity = identify_target(name, entity)
-    matches = _parents(name, entity)
-    #matches.each{|m| m.replace(m.partition("~").reverse*"") } unless undirected(name)
-    setup(name, matches, true)
-  end
-
-  def _neighbours(name, entity)
-    if undirected(name) and source(name) == target(name)
-      {:children => _children(name, entity)}
-    else
-      {:parents => _parents(name, entity), :children => _children(name, entity)}
-    end
-  end
-
-  def neighbours(name, entity)
-    hash = _neighbours(name, entity)
-    IndiferentHash.setup(hash)
-    setup(name, hash[:children]) if hash[:children] 
-    setup(name, hash[:parents], true) if hash[:parents]
-    hash
-  end
-
-end
-
+#require 'rbbt/knowledge_base/registry'
+#
+#class KnowledgeBase
+#
+#  def _subset(name, source = :all, target = :all, options = {})
+#    repo = get_index name, options
+#
+#    repo.subset(source, target)
+#  end
+#
+#  def subset(name, entities, options = {}, &block)
+#    entities, options = options, entities if entities.nil? and Hash === options
+#
+#    entities = case entities
+#               when :all
+#                 {:target => :all, :source => :all}
+#               when AnnotatedArray
+#                 format = entities.format if entities.respond_to? :format 
+#                 format ||= entities.base_entity.to_s
+#                 {format => entities.purge}
+#               when Hash
+#                 entities
+#               else
+#                 raise "Entities are not a Hash or an AnnotatedArray: #{Log.fingerprint entities}"
+#               end
+#
+#    identify, identify_source, identify_target = entities.merge(options || {}).values_at :identify, :identify_source, :identify_target
+#
+#    source, target = select_entities(name, entities, options)
+#    
+#    source = identify_source(name, source) if identify_source
+#    target = identify_target(name, target) if identify_target
+#
+#    source = identify(name, source) if identify && !identify_source
+#    target = identify(name, target) if identify && !identify_target
+#
+#    return [] if source.nil? or target.nil?
+#    return [] if Array === target and target.empty?
+#    return [] if Array === source and source.empty?
+#
+#    matches = _subset name, source, target, options
+#
+#    setup(name, matches)
+#
+#    matches = matches.select(&block) if block_given? 
+#
+#    matches
+#  end
+#
+#  def all(name, options={})
+#    repo = get_index name, options
+#    setup name, repo.keys
+#  end
+#
+#  def _children(name, entity)
+#    repo = get_index name
+#    repo.match(entity)
+#  end
+#
+#  def children(name, entity)
+#    entity = identify_source(name, entity)
+#    setup(name, _children(name, entity))
+#  end
+#
+#  def _parents(name, entity)
+#    repo = get_index name
+#    repo.reverse.match(entity)
+#  end
+#
+#  def parents(name, entity)
+#    entity = identify_target(name, entity)
+#    matches = _parents(name, entity)
+#    #matches.each{|m| m.replace(m.partition("~").reverse*"") } unless undirected(name)
+#    setup(name, matches, true)
+#  end
+#
+#  def _neighbours(name, entity)
+#    if undirected(name) and source(name) == target(name)
+#      {:children => _children(name, entity)}
+#    else
+#      {:parents => _parents(name, entity), :children => _children(name, entity)}
+#    end
+#  end
+#
+#  def neighbours(name, entity)
+#    hash = _neighbours(name, entity)
+#    IndiferentHash.setup(hash)
+#    setup(name, hash[:children]) if hash[:children] 
+#    setup(name, hash[:parents], true) if hash[:parents]
+#    hash
+#  end
+#
+#end
+#