rbbt-util 5.44.1 → 6.0.4

data/lib/rbbt/hpc/batch.rb

@@ -24,7 +24,7 @@ module HPC
       when 'pbs'
         HPC::PBS
       else
-        case Rbbt::Config.get(:batch_system, :batch, :batch_system, :hpc, :HPC, :BATCH).to_s.downcase
+        case Scout::Config.get(:batch_system, :batch, :batch_system, :hpc, :HPC, :BATCH).to_s.downcase
         when 'slurm'
           HPC::SLURM
         when 'lsf'
@@ -47,8 +47,9 @@ module HPC
 
   module TemplateGeneration
     def exec_cmd(job, options = {})
-      env_cmd     = Misc.process_options options, :env_cmd
-      development = Misc.process_options options, :development
+      options = IndiferentHash.add_defaults options, :launcher => :srun if HPC.batch_system == SLURM
+
+      launcher, env_cmd, development = IndiferentHash.process_options options, :launcher, :env_cmd, :development
 
       if contain = options[:contain]
         contain = File.expand_path(contain)
@@ -87,10 +88,16 @@ module HPC
         singularity_cmd << " #{singularity_img} "
       end
 
+      base_cmd = if launcher
+                   %(#{launcher} rbbt)
+                 else
+                   %(rbbt)
+                 end
+
       if env_cmd
-        exec_cmd = %(env #{env_cmd} rbbt)
+        exec_cmd = %(env #{env_cmd} #{ base_cmd })
       else
-        exec_cmd = %(rbbt)
+        exec_cmd = base_cmd
       end
 
       exec_cmd << "--dev '#{development}'" if development
@@ -103,36 +110,29 @@ module HPC
     def rbbt_job_exec_cmd(job, options)
 
       jobname  = job.clean_name
-      workflow = job.original_workflow || job.workflow
-      task     = job.original_task_name || job.task_name
-
-      Misc.add_defaults options, :jobname => jobname
-
-      task = Symbol === job.overriden ? job.overriden : job.task_name
-
-      override_deps = job.overriden_deps.collect do |dep| 
-        name = [dep.workflow.to_s, dep.task_name] * "#"
-        [name, dep.path] * "="  
-      end.uniq * ","
-
-      options[:override_deps] = override_deps unless override_deps.empty?
-
-      #if job.overriden?
-      #  #override_deps = job.rec_dependencies.
-      #  #  select{|dep| Symbol === dep.overriden }.
-      #  
-      #  override_deps = job.overriden_deps.
-      #    collect do |dep| 
-      #    name = [dep.workflow.to_s, dep.task_name] * "#"
-      #    [name, dep.path] * "="  
-      #  end.uniq * ","
-
-      #  options[:override_deps] = override_deps unless override_deps.empty?
-      #end
+      workflow = job.workflow
+      task     = job.task_name
+
+      IndiferentHash.add_defaults options, :jobname => jobname
+
+      task = job.task_name
+
+      if job.recursive_overriden_deps.any?
+        override_deps = job.recursive_overriden_deps.
+          select do |dep| Symbol === dep.overriden end.
+          collect do |dep| 
+            o_workflow = dep.overriden_workflow || dep.workflow
+            o_workflow = o_workflow.name if o_workflow.respond_to?(:name)
+            o_task_name = dep.overriden_task || dep.task.name
+            name = [o_workflow, o_task_name] * "#"
+            [name, dep.path] * "="  
+          end.uniq * ","
+          options[:override_deps] = override_deps unless override_deps.empty?
+      end
 
       # Save inputs into inputs_dir
-      inputs_dir = Misc.process_options options, :inputs_dir
-      saved = Step.save_job_inputs(job, inputs_dir) if 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?
 
       saved.each do |input|
@@ -181,8 +181,10 @@ EOF
         :sync,
         :contain_and_sync,
         :copy_image,
-        :drbbt,
+        :launcher,
+        :development,
         :env_cmd,
+        :env,
         :manifest,
         :user_group,
         :wipe_container,
@@ -197,7 +199,7 @@ EOF
 
       keys.each do |key|
         next if options[key].nil?
-        batch_options[key] = Misc.process_options options, key
+        batch_options[key] = IndiferentHash.process_options options, key
       end
 
       batch_dir = batch_options[:batch_dir]
@@ -209,7 +211,10 @@ EOF
         :queue,
         :highmem,
         :exclusive,
+        :launcher,
+        :development,
         :env_cmd,
+        :env,
         :user_group,
         :singularity_img,
         :singularity_mounts,
@@ -220,9 +225,9 @@ EOF
 
       keys_from_config.each do |key|
         next unless batch_options.include? key
-        default_value = Rbbt::Config.get(key, "batch_#{key}", "batch")
+        default_value = Scout::Config.get(key, "batch_#{key}", "batch")
         next if default_value.nil? 
-        Misc.add_defaults batch_options, default_value
+        IndiferentHash.add_defaults batch_options, default_value
       end
 
       user = batch_options[:user] ||= ENV['USER'] || `whoami`.strip
@@ -234,7 +239,7 @@ EOF
 
       if batch_options[:contain_and_sync]
         if batch_options[:contain].nil?
-          contain_base = Rbbt::Config.get(:contain_base_dir, :batch_contain, :batch, :default => "/scratch/tmp/rbbt-[USER]")
+          contain_base = Scout::Config.get(:contain_base_dir, :batch_contain, :batch, :default => "/scratch/tmp/rbbt-[USER]")
           contain_base = contain_base.sub('[USER]', user)
           random_file = TmpFile.random_name
           batch_options[:contain] = File.join(contain_base, random_file)
@@ -248,14 +253,14 @@ EOF
         options[:workdir_all] = batch_options[:contain]
       end
 
-      Misc.add_defaults batch_options, 
+      IndiferentHash.add_defaults batch_options, 
         :batch_name => batch_name,
         :inputs_dir => inputs_dir, 
         :nodes => 1, 
         :step_path => job.path,
         :task_cpus => 1,
         :time => '2min', 
-        :env_cmd => '_JAVA_OPTIONS="-Xms1g -Xmx${MAX_MEMORY}m"',
+        :env => {'JDK_JAVA_OPTIONS' => "-Xms1g -Xmx${MAX_MEMORY}m"},
         :singularity_img => ENV["SINGULARITY_IMG"] || "~/rbbt.singularity.img",
         :singularity_ruby_inline => ENV["SINGULARITY_RUBY_INLINE"] || "~/.singularity_ruby_inline",
         :singularity_opt_dir => ENV["SINGULARITY_OPT_DIR"] || "~/singularity_opt",
@@ -264,13 +269,13 @@ EOF
       exec_cmd = exec_cmd(job, batch_options)
       rbbt_cmd = rbbt_job_exec_cmd(job, options)
 
-      Misc.add_defaults batch_options, 
+      IndiferentHash.add_defaults batch_options, 
         :exec_cmd => exec_cmd,
         :rbbt_cmd => rbbt_cmd
 
       batch_dir = batch_options[:batch_dir]
 
-      Misc.add_defaults batch_options,
+      IndiferentHash.add_defaults batch_options,
         :fout   => File.join(batch_dir, 'std.out'),
         :ferr   => File.join(batch_dir, 'std.err'),
         :fjob   => File.join(batch_dir, 'job.id'),
@@ -380,6 +385,13 @@ function batch_sync_contain_dir(){
         EOF
       end
 
+      if options[:env]
+        prepare_environment +=<<-EOF
+# Set ENV variables 
+#{options[:env].collect{|n,v| "export #{n}=\"#{v}\"" } * "\n"}
+        EOF
+      end
+
       if options[:singularity]
 
         group, user, user_group, scratch_group_dir, projects_group_dir = options.values_at :group, :user, :user_group, :scratch_group_dir, :projects_group_dir
@@ -421,7 +433,7 @@ echo "user_scratch: #{scratch_group_dir}/#{user}/{PKGDIR}/{TOPLEVEL}/{SUBPATH}"
         end
       end
 
-      batch_system_variables + load_modules(modules) + "\n" + load_conda(conda) + "\n"  + functions + "\n" + prepare_environment
+      [batch_system_variables, load_modules(modules), load_conda(conda), functions, prepare_environment].reject{|s| s.empty? } * "\n"
     end
 
     def execute(options)
@@ -433,9 +445,11 @@ step_path=$(
 )
 exit_status=$?
 
-[[ -z $BATCH_JOB_ID ]] || #{exec_cmd} workflow write_info --recursive --force=false --check_pid "$step_path" batch_job $BATCH_JOB_ID
-[[ -z $BATCH_SYSTEM ]] || #{exec_cmd} workflow write_info --recursive --force=false --check_pid "$step_path" batch_system $BATCH_SYSTEM
-#{exec_cmd} workflow write_info --recursive --force=false --check_pid "$step_path" batch_cpus #{task_cpus}
+if [ $exit_status -eq 0 ]; then
+  [[ -z $BATCH_JOB_ID ]] || #{exec_cmd} workflow write_info --recursive --force=false --check_pid "$step_path" batch_job $BATCH_JOB_ID
+  [[ -z $BATCH_SYSTEM ]] || #{exec_cmd} workflow write_info --recursive --force=false --check_pid "$step_path" batch_system $BATCH_SYSTEM
+  #{exec_cmd} workflow write_info --recursive --force=false --check_pid "$step_path" batch_cpus #{task_cpus}
+fi
       EOF
 
       script
@@ -528,7 +542,7 @@ exit $exit_status
 #{meta_data}
 
 # #{Log.color :green, "1. Prepare environment"}
-#{prepare_environment}
+#{prepare_environment(batch_options)}
 env > #{batch_options[:fenv]}
 
 # #{Log.color :green, "2. Execute"}
@@ -575,7 +589,7 @@ env > #{batch_options[:fenv]}
     def run_job(job, options = {})
       system = self.to_s.split("::").last
 
-      batch_base_dir, clean_batch_job, remove_batch_dir, procpath, tail, batch_dependencies, dry_run, orchestration_rules_file = Misc.process_options options, 
+      batch_base_dir, clean_batch_job, remove_batch_dir, procpath, tail, batch_dependencies, dry_run, orchestration_rules_file = IndiferentHash.process_options options, 
         :batch_base_dir, :clean_batch_job, :remove_batch_dir, :batch_procpath, :tail, :batch_dependencies, :dry_run, :orchestration_rules,
         :batch_base_dir => File.expand_path(File.join('~/rbbt-batch')) 
 
@@ -594,15 +608,15 @@ env > #{batch_options[:fenv]}
         end
       end
 
-      workflow = job.original_workflow ||job.workflow
-      task_name = job.original_task_name || job.task_name
+      workflow = job.workflow
+      task_name = job.task_name
 
-      options = options.merge(HPC::Orchestration.job_rules(HPC::Orchestration.orchestration_rules(orchestration_rules_file), job)) if orchestration_rules_file
+      options = IndiferentHash.setup(HPC::Orchestration.job_rules(HPC::Orchestration.orchestration_rules(orchestration_rules_file), job, true)).merge(options) if orchestration_rules_file
 
       workflows_to_load = job.rec_dependencies.select{|d| Step === d}.collect{|d| d.workflow }.compact.collect(&:to_s) - [workflow.to_s]
 
       TmpFile.with_file(nil, remove_batch_dir, :tmpdir => batch_base_dir, :prefix => "#{system}_rbbt_job-#{workflow.to_s}-#{task_name}-") do |batch_dir|
-        Misc.add_defaults options, 
+        IndiferentHash.add_defaults options, 
           :batch_dir => batch_dir, 
           :inputs_dir => File.join(batch_dir, "inputs_dir"),
           :workflows => workflows_to_load.any? ? workflows_to_load.uniq * "," : nil
@@ -638,6 +652,7 @@ env > #{batch_options[:fenv]}
     end
 
     def hold_dependencies(job, batch_job)
+      job.init_info
       job.set_info :batch_job, batch_job
       job.set_info :batch_system, self.batch_system
       job.dependencies.each do |dep|
@@ -696,7 +711,7 @@ env > #{batch_options[:fenv]}
               sleep 1
             end
             status_txt = job_status(job)
-            lines.times do
+            (lines + 1).times do
               Log.clear_line(STDERR)
             end
             Log.clear_line(STDERR)
@@ -741,6 +756,10 @@ env > #{batch_options[:fenv]}
       job_status(job).split(/[\s\.]+/).include?(job.to_s)
     end
 
+    def jobs
+      job_status.split("\n").collect{|l| l.scan(/\d{5,}/).first}.compact.flatten.uniq
+    end
+
     def wait_for_job(batch_dir, time = 1)
       fexit = File.join(batch_dir, 'exit.status')
       fjob = File.join(batch_dir, 'job.id')

data/lib/rbbt/hpc/lsf.rb

@@ -98,8 +98,8 @@ export BATCH_SYSTEM=#{batch_system}
           return
         elsif dry_run
           STDERR.puts Log.color(:magenta, "To execute run: ") + Log.color(:blue, cmd)
-          STDERR.puts Log.color(:magenta, "To monitor progress run (needs local rbbt): ") + Log.color(:blue, "rbbt lsf tail '#{batch_dir}'")
-          raise HPC::BATCH_DRY_RUN, batch_dir
+          STDERR.puts Log.color(:magenta, "To monitor progress run (needs local scout): ") + Log.color(:blue, "scout lsf tail '#{batch_dir}'")
+          raise HPC::SBATCH, batch_dir
         else
           Open.rm fsync
           Open.rm fexit

data/lib/rbbt/hpc/orchestrate/batches.rb

@@ -101,8 +101,8 @@ module HPC
 
       batches.each do |batch|
         job_rules = batch[:jobs].inject(nil) do |acc,job|
-          workflow = job.original_workflow || job.workflow
-          task_name = job.original_task_name || job.task_name
+          workflow = job.workflow
+          task_name = job.task_name
           task_rules = task_specific_rules(rules, workflow, task_name)
           acc = accumulate_rules(acc, task_rules.dup)
         end

data/lib/rbbt/hpc/orchestrate/chains.rb

@@ -1,11 +1,11 @@
 module HPC
   module Orchestration
     def self.check_chains(chains, job)
-      return [] if Symbol === job.overriden
+      return [] if Symbol === job.overriden_task
       matches = []
       chains.each do |name, chain|
-        workflow = job.original_workflow || job.workflow
-        task_name = job.original_task_name || job.task_name
+        workflow = job.overriden_workflow || job.workflow
+        task_name = job.overriden_workflow || job.task_name
         next unless chain[:tasks].include?(workflow.to_s)
         next unless chain[:tasks][workflow.to_s].include?(task_name.to_s)
         matches << name
@@ -14,9 +14,28 @@ module HPC
     end
 
     def self.parse_chains(rules)
-      return {} if rules["chains"].nil?
-
       chains = IndiferentHash.setup({})
+
+      rules.each do |workflow,rules|
+        next unless rules["chains"]
+        rules["chains"].each do |name,rules|
+          rules  = IndiferentHash.setup(rules.dup)
+          chain_tasks = rules.delete(:tasks).split(/,\s*/)
+          workflow = rules.delete(:workflow) if rules.include?(:workflow)
+
+          chain_tasks.each do |task|
+            chain_workflow, chain_task = task.split("#")
+            chain_task, chain_workflow = chain_workflow, workflow if chain_task.nil? or chain_tasks.empty?
+
+            chains[name] ||= IndiferentHash.setup({:tasks => {}, :rules => rules })
+            chains[name][:tasks][chain_workflow] ||= []
+            chains[name][:tasks][chain_workflow] << chain_task
+          end
+        end
+      end
+
+      return chains if rules["chains"].nil?
+
       rules["chains"].each do |name,rules|
         rules  = IndiferentHash.setup(rules.dup)
         chain_tasks = rules.delete(:tasks).split(/,\s*/)
@@ -32,6 +51,7 @@ module HPC
         end
       end
 
+
       chains
     end
 

data/lib/rbbt/hpc/orchestrate/rules.rb

@@ -65,8 +65,8 @@ module HPC
       merge_rules(rules[workflow][task], workflow_rules)
     end
 
-    def self.job_rules(rules, job)
-      return {} if job.done? or job.error?
+    def self.job_rules(rules, job, force = false)
+      return {} if (job.done? or job.error?) && ! force
       job_rules = task_specific_rules(rules, job.workflow.to_s, job.task_name.to_s)
       job.dependencies.each do |dep|
         job_rules = accumulate_rules(job_rules, job_rules(rules, dep))

data/lib/rbbt/hpc/orchestrate.rb

@@ -14,12 +14,12 @@ module HPC
 
       all_deps.each do |dep|
         begin
-          Step.prepare_for_execution(dep)
+          dep.clean if (dep.error? && dep.recoverable_error?) ||
+            dep.aborted? || (dep.done? && dep.updated?)
         rescue RbbtException
           next
         end
       end
-
     end
 
     def self.orchestration_rules(orchestration_rules_file = nil)
@@ -41,7 +41,7 @@ module HPC
       IndiferentHash.setup(rules)
     end
 
-    def orchestrate_job(job, options)
+    def orchestrate_job(job, options = {})
       options.delete "recursive_clean"
       options.delete "clean_task"
       options.delete "clean"
@@ -65,7 +65,7 @@ module HPC
       last_id = nil
       last_dir = nil
       while batches.any?
-        top = batches.select{|b| b[:deps].nil? || (b[:deps] - batch_ids.keys).empty? }.first
+        top = batches.select{|b| b[:deps].nil? || (b[:deps].collect{|d| d[:top_level]} - batch_ids.keys).empty? }.first
         raise "No batch without unmet dependencies" if top.nil?
         batches.delete top
 
@@ -78,16 +78,16 @@ module HPC
 
           batch_dependencies = top[:deps].collect{|d| 
             target = d[:top_level]
-            canfail = false
+            canfail = target.canfail?
 
-            top_jobs.each do |job|
-              canfail = true if job.canfail_paths.include?(target.path)
-            end
+            #top_jobs.each do |job|
+            #  canfail = true if job.canfail? # job.canfail_paths.include?(target.path)
+            #end
 
             if canfail
-              'canfail:' + batch_ids[d].to_s
+              'canfail:' + batch_ids[d[:top_level]].to_s
             else
-              batch_ids[d].to_s
+              batch_ids[d[:top_level]].to_s
             end
           }
         end
@@ -99,11 +99,11 @@ module HPC
           puts Log.color(:magenta, "Manifest: ") + Log.color(:blue, job_options[:manifest] * ", ") + " - tasks: #{job_options[:task_cpus] || 1} - time: #{job_options[:time]} - config: #{job_options[:config_keys]}"
           puts Log.color(:yellow, "Deps: ") + Log.color(:blue, job_options[:batch_dependencies]*", ")
           puts Log.color(:yellow, "Path: ") + top[:top_level].path
-          puts Log.color(:yellow, "Options: ") + job_options.inspect
-          batch_ids[top] = top[:top_level].task_signature
+          puts Log.color(:yellow, "Options: ") + job_options.reject{|k,v| k == :batch_dependencies || k == :manifest }.inspect
+          batch_ids[top[:top_level]] = top[:top_level].task_signature
         else
           id, dir = run_job(top[:top_level], job_options)
-          last_id = batch_ids[top] = id
+          last_id = batch_ids[top[:top_level]] = id
           last_dir = dir
         end
       end
@@ -111,5 +111,11 @@ module HPC
       [last_id, last_dir]
     end
 
+    def produce_jobs(jobs, options = {})
+      jobs.each do |job|
+        self.orchestrate_job(job, options)
+      end
+      Step.wait_for_jobs jobs
+    end
   end
 end

data/lib/rbbt/hpc/slurm.rb

@@ -27,26 +27,26 @@ export BATCH_SYSTEM=#{batch_system}
     def self.header(options = {})
       options = options.dup
 
-      queue      = Misc.process_options options, :queue
-      account    = Misc.process_options options, :account
-      partition  = Misc.process_options options, :partition
-      task_cpus  = Misc.process_options options, :task_cpus
-      time       = Misc.process_options options, :time
-      nodes      = Misc.process_options options, :nodes
-      workdir    = Misc.process_options options, :workdir
-      exclusive  = Misc.process_options options, :exclusive
-      highmem    = Misc.process_options options, :highmem
-      licenses   = Misc.process_options options, :licenses
-      constraint = Misc.process_options options, :constraint
-      gres       = Misc.process_options options, :gres
+      queue      = IndiferentHash.process_options options, :queue
+      account    = IndiferentHash.process_options options, :account
+      partition  = IndiferentHash.process_options options, :partition
+      task_cpus  = IndiferentHash.process_options options, :task_cpus
+      time       = IndiferentHash.process_options options, :time
+      nodes      = IndiferentHash.process_options options, :nodes
+      workdir    = IndiferentHash.process_options options, :workdir
+      exclusive  = IndiferentHash.process_options options, :exclusive
+      highmem    = IndiferentHash.process_options options, :highmem
+      licenses   = IndiferentHash.process_options options, :licenses
+      constraint = IndiferentHash.process_options options, :constraint
+      gres       = IndiferentHash.process_options options, :gres
 
       constraint     = [constraint, "highmem"].compact * "&" if highmem
 
-      mem            = Misc.process_options options, :mem
-      mem_per_cpu    = Misc.process_options options, :mem_per_cpu
+      mem            = IndiferentHash.process_options options, :mem
+      mem_per_cpu    = IndiferentHash.process_options options, :mem_per_cpu
 
-      batch_dir  = Misc.process_options options, :batch_dir
-      batch_name = Misc.process_options options, :batch_name
+      batch_dir  = IndiferentHash.process_options options, :batch_dir
+      batch_name = IndiferentHash.process_options options, :batch_name
 
       fout       = File.join(batch_dir, 'std.out')
       ferr       = File.join(batch_dir, 'std.err')
@@ -129,8 +129,8 @@ export BATCH_SYSTEM=#{batch_system}
           return
         elsif dry_run
           STDERR.puts Log.color(:magenta, "To execute run: ") + Log.color(:blue, "sbatch '#{fcmd}'")
-          STDERR.puts Log.color(:magenta, "To monitor progress run (needs local rbbt): ") + Log.color(:blue, "rbbt slurm tail '#{batch_dir}'")
-          raise HPC::BATCH_DRY_RUN, batch_dir
+          STDERR.puts Log.color(:magenta, "To monitor progress run (needs local scout): ") + Log.color(:blue, "scout slurm tail '#{batch_dir}'")
+          raise HPC::SBATCH, batch_dir
         else
           Open.rm fsync
           Open.rm fexit

data/lib/rbbt/knowledge_base/entity.rb

@@ -39,7 +39,7 @@ class KnowledgeBase
   def annotate(entities, type, database = nil)
     format = @format[type] || type
     entity_options = entity_options_for(type, database)
-    Misc.prepare_entity(entities, format, entity_options)
+    Entity.prepare_entity(entities, format, entity_options)
   end
 
   def translate(entities, type)
@@ -82,7 +82,7 @@ class KnowledgeBase
       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, source(name), nil, :persist => true
+      TSV.translation_index identifier_files, nil, source(name), :persist => true
     end
   end
   
@@ -94,7 +94,7 @@ class KnowledgeBase
       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, target(name), nil, :persist => true
+      TSV.translation_index identifier_files, nil, target(name), :persist => true
     end
   end
 
@@ -102,7 +102,11 @@ class KnowledgeBase
     return :all if entity == :all
     index = source_index(name)
     return entity if index.nil?
-    Array === entity ? index.values_at(*entity) : index[entity]
+    if Array === entity
+      entity.collect{|e| index[e] || e }
+    else
+      index[entity] || entity
+    end
   end
 
   
@@ -110,7 +114,11 @@ class KnowledgeBase
     return :all if entity == :all
     index = target_index(name)
     return entity if index.nil?
-    Array === entity ? index.values_at(*entity) : index[entity]
+    if Array === entity
+      entity.collect{|e| index[e] || e }
+    else
+      index[entity] || entity
+    end
   end
 
   def identify(name, entity)

data/lib/rbbt/knowledge_base/query.rb

@@ -17,11 +17,11 @@ class KnowledgeBase
                when AnnotatedArray
                  format = entities.format if entities.respond_to? :format 
                  format ||= entities.base_entity.to_s
-                 {format => entities.clean_annotations}
+                 {format => entities.purge}
                when Hash
                  entities
                else
-                 raise "Entities are not a Hash or an AnnotatedArray: #{Misc.fingerprint entities}"
+                 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