rbbt-util 4.4.0 → 5.0.0

data/README.rdoc

@@ -75,3 +75,6 @@
     mkdir -p ~/git/workflows
     echo "~/git/workflows/" > ~/.rbbt/etc/workflow_dir
 
+6- - Place some other files
+
+    /home/mvazquezg/.rbbt/share/databases/InterPro/pfam_names

data/bin/rbbt_exec.rb

@@ -1,5 +1,6 @@
 #!/usr/bin/env ruby
 
+
 code_file = ARGV[0]
 output = ARGV[1]
 
@@ -13,7 +14,11 @@ code = case
        end
 
 begin
-  data = eval code
+  if code_file.nil?
+    data = instance_eval code
+  else
+    data = instance_eval code, code_file
+  end
 rescue Exception
   puts "#:rbbt_exec Error"
   puts $!.message

data/bin/rbbt_monitor.rb

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+
+require 'rbbt-util'
+require 'fileutils'
+require 'rbbt/util/simpleopt'
+require 'rbbt/workflow/step'
+
+options = SOPT.get("-l--list:-z--zombies:-e--errors:-c--clean:-n--name:-a--all:-w--wipe:-f--file*")
+
+def info_files
+  Dir.glob('**/*.info')
+end
+
+def running?(info)
+  begin
+    Process.kill 0, info[:pid]
+    true
+  rescue
+    false
+  end
+end
+
+def print_job(file, info, severity_color = nil)
+  clean_file = file.sub('.info','')
+  if $name
+    puts clean_file
+  else
+    info ||= {:status => :missing_info_file}
+    str = [clean_file, info[:status].to_s] * " [ STATUS = " + " ]" 
+    str += " (#{running?(info)? :running : :zombie} #{info[:pid]})" if info.include? :pid
+
+    str = "#{severity_color}" <<  str  << "\033[0m" if severity_color
+    puts str
+  end
+end
+
+def list_jobs(options)
+
+  omit_ok = options[:zombies] || options[:errors]
+
+  info_files.each do |file|
+    clean_file = file.sub('.info','')
+    next if File.exists? clean_file
+    begin
+      info = YAML.load(Open.read(file))
+    rescue Exception
+      Log.debug "Error parsing info file: #{ file }"
+      info = nil
+    end
+
+    color = case
+            when info[:status] == :error
+              Log::SEVERITY_COLOR[3]
+            when (info[:pid] and not running? info)
+              Log::SEVERITY_COLOR[2]
+            end
+
+    case
+    when (not omit_ok)
+      print_job file, info, color
+    when options[:zombies]
+      print_job file, info, color if info[:pid] and not running? info
+    when options[:errors]
+      print_job file, info, color if info[:status] == :error
+    end
+
+  end
+end
+
+def remove_job(file)
+  clean_file = file.sub('.info','')
+  FileUtils.rm file if File.exists? file
+  FileUtils.rm clean_file if File.exists? clean_file
+  FileUtils.rm_rf clean_file + '.files' if File.exists? clean_file + '.files'
+end
+
+def clean_jobs(options)
+  info_files.each do |file|
+    clean_file = file.sub('.info','')
+    next if File.exists? clean_file
+    info = nil
+    begin
+      info = YAML.load(Open.read(file))
+    rescue
+      Log.debug "Error process #{ file }"
+      raise $!
+    end
+    case
+    when options[:all]
+      remove_job file
+    when (options[:zombies] and info[:pid] and not running? info)
+      remove_job file
+    when (options[:errors] and info[:status] == :error)
+      remove_job file
+    end
+
+  end
+end
+
+
+
+$name = options.delete :name
+case
+when (options[:clean] and not options[:list])
+  if options[:file]
+    remove_job options[:file]
+  else
+    clean_jobs options
+  end
+else
+  if options[:file]
+    info = YAML.load(Open.read(options[:file]))
+    print_job options[:file], info
+  else
+    list_jobs options
+  end
+end

data/bin/run_workflow.rb

@@ -85,6 +85,7 @@ options = SOPT.get "-t--task*:-l--log*:-h--help:-n--name*:-cl--clean:-rcl-recurs
 workflow = ARGV.first
 
 if options[:server]
+
   require 'rbbt/util/log'
   require 'rbbt/workflow'
   require 'rbbt/workflow/rest'
@@ -98,10 +99,16 @@ if options[:server]
 
   Sinatra::Application.port = options[:port] || 4567
   Sinatra::Application.run = true
+
   if File.exists? workflow
     Sinatra::Application.views = File.join(File.dirname(workflow), 'www/views')
   end
 
+  sinatra_file = './lib/sinatra.rb'
+  if File.exists? sinatra_file
+    require sinatra_file
+  end
+
 else
 
   # Set log, fork, clean, recursive_clean and help
@@ -182,9 +189,6 @@ else
     Log.low "Job name: #{job.name}"
   end
 
-  #- error
-
-  #print
   case
   when Array === res
     puts res * "\n"

data/lib/rbbt/annotations.rb

@@ -20,9 +20,16 @@ module Annotated
     end.flatten.uniq
   end
 
-  def info
+  def unmasked_annotations
+    raise "Annotation types is nil for object: #{self.inspect}" if annotation_types.nil?
+    annotation_types.collect do |mod|
+      mod.unmasked_annotations
+    end.flatten.uniq
+  end
+
+  def info(masked = false)
     hash = {:annotation_types => annotation_types}
-    annotations.each do |annotation|
+    (masked ? unmasked_annotations : annotations).each do |annotation|
       value = self.send(annotation)
       hash[annotation] = value unless value.nil?
     end
@@ -39,12 +46,17 @@ module Annotated
 
     return object if annotation_types.nil? or annotation_types.empty?
 
+    annotated_array = info.delete(:annotated_array) || false
+
     annotation_types.each do |mod|
       mod = Misc.string2const(mod) if String === mod
       mod.setup(object, *info.values_at(*mod.all_annotations))
     end
 
     object.id = info[:entity_id] if info.include? :entity_id
+
+    object.extend AnnotatedArray if annotated_array
+
     object
   end
 
@@ -54,6 +66,7 @@ module Annotated
     else
       fields = fields.flatten
       info = self.info
+      info[:annotated_array] = true if AnnotatedArray === self
       values = []
 
       fields.each do |field|
@@ -79,6 +92,14 @@ module Annotated
     end
   end
 
+  def self.resolve_array(entry)
+    if entry =~ /^Array:/
+      entry["Array:".length..-1].split("|")
+    else
+      entry
+    end
+  end
+
   def self.load_tsv_values(id, values, *fields)
     fields = fields.flatten
     info = {}
@@ -91,7 +112,7 @@ module Annotated
                id.dup
              end
 
-    object = object["Array:".length..-1].split("|") if object =~ /^Array:/
+    object = resolve_array(object)
 
     if Array === values.first
       Misc.zip_fields(values).collect do |list|
@@ -101,7 +122,7 @@ module Annotated
               info[key.to_sym] = value
             end
           else
-            info[field.to_sym] = list[i]
+            info[field.to_sym] = resolve_array(list[i])
           end
         end
       end
@@ -112,7 +133,7 @@ module Annotated
             info[key.to_sym] = value
           end
         else
-          info[field.to_sym] = values[i]
+          info[field.to_sym] = resolve_array(values[i])
         end
       end
     end
@@ -162,11 +183,13 @@ module Annotated
     case
     when (Annotated === annotations and not (AnnotatedArray === annotations and annotations.double_array))
       tsv = TSV.setup({}, :key_field => "List", :fields => fields, :type => :list, :unnamed => true)
-      tsv[annotations.id] = annotations.tsv_values(*fields)
+      annot_id = annotations.id
+      tsv[annot_id] = annotations.tsv_values(*fields)
     when Array === annotations 
       tsv = TSV.setup({}, :key_field => "ID", :fields => fields, :type => :list, :unnamed => true)
-      annotations.compact.each do |annotation|
-        tsv[annotation.id] = annotation.tsv_values(*fields)
+      annotations.compact.each_with_index do |annotation,i|
+        tsv[annotation.id + ":" << i.to_s] = annotation.tsv_values(*fields)
+        #tsv[annotation.id] = annotation.tsv_values(*fields)
       end
     else
       raise "Annotations need to be an Array to create TSV"
@@ -214,11 +237,16 @@ module Annotation
   def self.extended(base)
     if not base.respond_to? :annotations
       class << base
-        attr_accessor :annotations, :inheritance, :all_inheritance, :all_annotations
+        attr_accessor :annotations, :inheritance, :all_inheritance, :all_annotations, :masked_annotations
+
+        def unmasked_annotations
+          annotations - masked_annotations
+        end
         self
       end
 
       base.annotations = []
+      base.masked_annotations = []
       base.inheritance = []
       base.all_annotations = []
       base.all_inheritance = []
@@ -230,12 +258,12 @@ module Annotation
 
         def self.extended(object)
           self.send(:prev_annotation_extended, object)
-            object.extend Annotated unless Annotated == object
-            if not object.annotation_types.include? self
-              object.annotation_types.concat self.inheritance 
-              object.annotation_types << self
-              object.annotation_types.uniq!
-            end
+          object.extend Annotated unless Annotated === object
+          if not object.annotation_types.include? self
+            object.annotation_types.concat self.inheritance 
+            object.annotation_types << self
+            object.annotation_types.uniq!
+          end
         end
 
         def self.included(base)
@@ -271,17 +299,26 @@ module Annotation
   end
 
   def setup(object, *values)
+    return nil if object.nil?
+
     object.extend self unless self === object
 
-    inputs = Misc.positional2hash(all_annotations, *values)
-    inputs.each do |name, value|
-      value = value.split("|") if String === value and value.index "|"
-      object.send(name.to_s + '=', value)
+    if Hash === values.last
+      values.last.each do |name, value|
+        setter = "#{name}="
+        next unless object.respond_to? setter
+        value = value.split("|") if String === value and value.index "|"
+        object.send("#{name}=", value)
+      end
+    else
+      all_annotations.zip(values).each do |name, value|
+        value = value.split("|") if String === value and value.index "|"
+        object.send("#{name}=", value)
+      end
     end
 
     object
   end
-
 end
 
 module AnnotatedArray
@@ -290,57 +327,74 @@ module AnnotatedArray
   self.chain_prefix = :annotated_array
 
   def double_array
-    AnnotatedArray === self.annotated_array_clean_get_brackets(0)
+    AnnotatedArray === self.send(:[], 0, true)
   end
 
-  def annotated_array_first
+  def first
     self[0]
   end
 
-  def annotated_array_last
+  def last
     self[-1]
   end
 
-  def annotated_array_get_brackets(pos)
-    value = annotated_array_clean_get_brackets(pos)
+  def [](pos, clean = false)
+    value = super(pos)
+    return nil if value.nil?
+    return value if clean
+    return value unless String === value or Array === value
+
     value = value.dup if value.frozen?
-    annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.all_annotations))
-    end
-    if Annotated === value
-      value.context = self.context
-      value.container = self
-      value.container_index = pos
+
+    annotation_types.each do |mod| 
+      value.extend mod  unless mod === value
+      mod.annotations.each do |annotation| value.send(annotation.to_s << "=", self.send(annotation)) end
     end
+
+    value.context         = self.context
+    value.container       = self
+    value.container_index = pos
+
+    value.extend AnnotatedArray if Array === value and AnnotatedArray === self
+
     value
   end
 
-  def annotated_array_each
+  def each
     i = 0
-    annotated_array_clean_each do |value|
-      value = value.dup if value.frozen?
-      annotation_types.each do |mod|
-        mod.setup(value, info)
-      end
-      if Annotated === value
+    info = info
+    super do |value|
+      if String === value or Array === value
+        value = value.dup if value.frozen? and not value.nil?
+
+        annotation_types.each do |mod| 
+          value.extend mod  unless mod === value
+          mod.annotations.each do |annotation| value.send(annotation.to_s << "=", self.send(annotation)) end
+        end
+        
+        value.extend AnnotatedArray if Array === value and AnnotatedArray === self
+      
         value.context = self.context
         value.container = self
         value.container_index = i
+
       end
+
       i += 1
+
       yield value
     end
   end
 
-  def annotated_array_collect
+  def collect
     res = []
 
     if block_given?
-      annotated_array_each do |value|
+      each do |value|
         res << yield(value)
       end
     else
-      annotated_array_each do |value|
+      each do |value|
         res << value
       end
     end
@@ -348,18 +402,19 @@ module AnnotatedArray
     res
   end
 
-  def annotated_array_select(method = nil, *args)
+  def select(method = nil, *args)
     res = []
     if method
       res = self.zip(self.send(method, *args)).select{|e,result| result}.collect{|element,r| element}
     else
-      annotated_array_each do |value|
+      each do |value|
         res << value if yield(value)
       end
     end
 
-    annotation_types.each do |mod|
-      mod.setup(res, *info.values_at(*mod.annotations))
+    annotation_types.each do |mod| 
+      res.extend mod  unless mod === res
+      mod.annotations.each do |annotation| res.send(annotation.to_s + "=", self.send(annotation)) end
     end
 
     res.context = self.context
@@ -370,15 +425,17 @@ module AnnotatedArray
     res
   end
 
-  def annotated_array_reject
+  def reject
     res = []
-    annotated_array_each do |value|
+    each do |value|
       res << value unless yield(value)
     end
 
-    annotation_types.each do |mod|
-      mod.setup(res, *info.values_at(*mod.annotations))
+    annotation_types.each do |mod| 
+      res.extend mod  unless mod === res
+      mod.annotations.each do |annotation| res.send(annotation.to_s + "=", self.send(annotation)) end
     end
+
     res.context = self.context
     res.container = self.container
 
@@ -387,11 +444,12 @@ module AnnotatedArray
     res
   end
 
-  def annotated_array_subset(list)
+  def subset(list)
     value = (self & list)
 
-    annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.all_annotations))
+    annotation_types.each do |mod| 
+      value.extend mod  unless mod === value
+      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
     end
 
     value.context = self.context
@@ -402,11 +460,12 @@ module AnnotatedArray
     value
   end
 
-  def annotated_array_remove(list)
+  def remove(list)
     value = (self - list)
 
-    annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.annotations))
+    annotation_types.each do |mod| 
+      value.extend mod  unless mod === value
+      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
     end
 
     value.context = self.context
@@ -417,11 +476,12 @@ module AnnotatedArray
     value
   end
 
-  def annotated_array_compact
-    value = self.annotated_array_clean_compact
+  def compact
+    value = super
 
-    annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.annotations))
+    annotation_types.each do |mod| 
+      value.extend mod  unless mod === value
+      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
     end
 
     value.context = self.context
@@ -432,11 +492,12 @@ module AnnotatedArray
     value
   end
  
-  def annotated_array_uniq
-    value = self.annotated_array_clean_uniq
+  def uniq
+    value = super
 
-    annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.annotations))
+    annotation_types.each do |mod| 
+      value.extend mod  unless mod === value
+      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
     end
 
     value.context = self.context
@@ -447,11 +508,12 @@ module AnnotatedArray
     value
   end
 
-  def annotated_array_flatten
-    value = self.annotated_array_clean_flatten.dup
+  def flatten
+    value = super.dup
 
-    annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.annotations))
+    annotation_types.each do |mod| 
+      value.extend mod  unless mod === value
+      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
     end
 
     value.context = self.context
@@ -462,11 +524,12 @@ module AnnotatedArray
     value
   end
 
-  def annotated_array_reverse
-    value = self.annotated_array_clean_reverse
+  def reverse
+    value = super
 
-    annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.annotations))
+    annotation_types.each do |mod| 
+      value.extend mod  unless mod === value
+      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
     end
 
     value.context = self.context
@@ -477,11 +540,12 @@ module AnnotatedArray
     value
   end
 
-  def annotated_array_sort_by(&block)
-    value = self.annotated_array_clean_sort_by &block
+  def sort_by(&block)
+    value = super &block
 
-    annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.annotations))
+    annotation_types.each do |mod| 
+      value.extend mod  unless mod === value
+      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
     end
 
     value.context = self.context
@@ -492,11 +556,12 @@ module AnnotatedArray
     value
   end
 
-  def annotated_array_sort(&block)
+  def sort(&block)
     value = self.collect.sort(&block).collect{|value| value.respond_to?(:clean_annotations) ? value.clean_annotations.dup : value.dup }
 
-    annotation_types.each do |mod|
-      mod.setup(value, *info.values_at(*mod.annotations))
+    annotation_types.each do |mod| 
+      value.extend mod  unless mod === value
+      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
     end
 
     value.extend AnnotatedArray if AnnotatedArray === self
@@ -504,7 +569,7 @@ module AnnotatedArray
     value
   end
 
-  def annotated_array_select_by(method)
+  def select_by(method)
     case
     when (Symbol === method or String === method)
       method = self.send(method) 
@@ -516,7 +581,7 @@ module AnnotatedArray
 
     value = []
     
-    self.annotated_array_clean_each do |e|
+    super do |e|
       value << e if method.shift
     end
 
@@ -530,3 +595,4 @@ module AnnotatedArray
   end
 
 end
+