miga-base 0.7.26.0 → 0.7.26.1

data/utils/enveomics/Scripts/lib/enveomics_rb/og.rb

@@ -0,0 +1,182 @@
+
+##### CLASSES:
+# Gene.new(genome, id): Initializes a new Gene.
+# genome: A string uniquely identifying the parent genome.
+# id: A string uniquely identifying the gene within the genome. It can be
+#   non-unique across genomes.
+class Gene
+  attr_reader :genome_id, :id
+  @@genomes = []
+  def self.genomes
+    @@genomes
+  end
+  def initialize(genome, id)
+    if genome.is_a? Integer
+      abort "Internal error: Genome #{genome} does not exist yet." if
+        @@genomes[genome].nil?
+      @genome_id = genome
+    else
+      @@genomes << genome unless @@genomes.include? genome
+      @genome_id = @@genomes.index(genome)
+    end
+    @id = id
+  end
+  # Compare if two Gene objects refer to the same gene.
+  def ==(b)
+    self.genome_id==b.genome_id and self.id==b.id
+  end
+  # Get all genomes in the run as an array of strings.
+  def genome
+    @@genomes[self.genome_id]
+  end
+  def to_s
+    "#{self.genome}:#{self.id}"
+  end
+end
+
+# OG.new(): Initializes an empty OG.
+# OG.new(genomes, genes): Initializes a pre-computed OG.
+# genomes: List of genomes as an array of strings (as in Gene.genomes).
+# genes: List of genes as an array of strings, with '-' indicating no genes and
+#   multiple genes separated by ','.
+class OG
+  attr_reader :genes, :notes
+  def initialize(genomes=nil, genes=nil)
+    @genes = []
+    @notes = []
+    unless genomes.nil? or genes.nil?
+      (0 .. genes.length-1).each do |genome_i|
+        next if genes[genome_i]=="-"
+        genes[genome_i].split(/,/).each do |gene_id|
+          self << Gene.new(genomes[genome_i], gene_id)
+        end
+      end
+    end
+  end
+  # Add genes or combine another OG into the loaded OG (self).
+  def <<(obj)
+    if obj.is_a? Gene
+      @genes[obj.genome_id] = [] if @genes[obj.genome_id].nil?
+      @genes[obj.genome_id] << obj.id unless self.include? obj
+    elsif obj.is_a? OG
+      obj.genes_obj.each{ |gene| self << gene }
+    else
+      abort "Unsupported class for #{obj}"
+    end
+  end
+  # Get the list of genes as objects (internally saved as strings to save RAM).
+  def genes_obj
+    o = []
+    (0 .. Gene.genomes.length-1).map do |genome_id|
+      o += self.genes[genome_id].map{ |gene_id|
+        Gene.new(Gene.genomes[genome_id], gene_id) } unless
+          self.genes[genome_id].nil?
+    end
+    return o
+  end
+  # Evaluates if the OG contains the passed gene.
+  def include?(gene)
+    return false if self.genes[gene.genome_id].nil?
+    self.genes[gene.genome_id].include? gene.id
+  end
+  # Get the list of genomes containing genes in this OG.
+  def genomes
+    (0 .. Gene.genomes.length-1).select do |gno|
+      not(self.genes[gno].nil? or self.genes[gno].empty?)
+    end
+  end
+  # Adds a note that will be printed after the last column
+  def add_note note, note_idx=nil
+    if note_idx.nil?
+      @notes << note
+    else
+      @notes[note_idx] = (@notes[note_idx].nil? ? '' :
+        (@notes[note_idx]+' || ')) + note
+    end
+  end
+  def to_s
+    (0 .. Gene.genomes.length-1).map do |genome_id|
+      self.genes[genome_id].nil? ? "-" : self.genes[genome_id].join(",")
+    end.join("\t") + ((self.notes.size==0) ? '' :
+      ("\t#\t"+self.notes.join("\t")))
+  end
+  def to_bool_a
+    (0 .. Gene.genomes.length-1).map { |genome_id| not genes[genome_id].nil? }
+  end
+end
+
+# OGCollection.new(): Initializes an empty collection of OGs.
+class OGCollection
+  attr_reader :ogs, :note_srcs
+  def initialize
+    @ogs = []
+    @note_srcs = []
+  end
+  # Add an OG to the collection
+  def <<(og)
+    @ogs << og
+  end
+  # Compare OGs all-vs-all to identify groups that should be merged.
+  def consolidate!
+    old_ogs = self.ogs
+    @ogs = []
+    old_ogs.each do |og|
+      is_new = true
+      og.genes_obj.each do |gene|
+        o = self.get_og gene
+        unless o.nil?
+          o << og
+          is_new = false
+          break
+        end
+      end
+      self << og if is_new
+    end
+  end
+  # Removes OGs present in less than 'fraction' of the genomes
+  def filter_core!(fraction=1.0)
+    min_genomes = (fraction * Gene.genomes.size).ceil
+    @ogs.select! { |og| og.genomes.size >= min_genomes }
+  end
+  # Removes OGs present more than 'dups' number of times in any genome
+  def remove_inparalogs!(dups=1)
+    @ogs.select! do |og|
+      og.genes.map{ |pergenome| pergenome.size }.max <= dups
+    end
+  end
+  # Add a pair of RBM genes into the corresponding OG, or create a new OG.
+  def add_rbm(a, b)
+    og = self.get_og(a)
+    og = self.get_og(b) if og.nil?
+    if og.nil?
+      og = OG.new
+      @ogs << og
+    end
+    og << a
+    og << b
+  end
+  # Get the OG containing the gene (returns the first, if multiple).
+  def get_og(gene)
+    idx = self.ogs.index { |og| og.include? gene }
+    idx.nil? ? nil : self.ogs[idx]
+  end
+  # Get the genes from a given genome (returns an array of arrays)
+  def get_genome_genes(genome)
+    genome_id = Gene.genomes.index(genome)
+    self.ogs.map do |og|
+      g = og.genes[genome_id]
+      g.nil? ? [] : g
+    end
+  end
+  # Add annotation sources
+  def add_note_src src
+    @note_srcs << src
+  end
+  def to_s
+    Gene.genomes.join("\t") + ((self.note_srcs.length>0) ?
+        ("\t#\t"+self.note_srcs.join("\t")) : '') +
+      "\n" + self.ogs.map{ |og| og.to_s }.join("\n")
+  end
+  def to_bool_a ; ogs.map{ |og| og.to_bool_a } ; end
+end
+

data/utils/enveomics/Scripts/lib/enveomics_rb/remote_data.rb

@@ -0,0 +1,74 @@
+
+#
+# @author: Luis M. Rodriguez-R
+# @license: artistic license 2.0
+#
+
+require "enveomics_rb/enveomics"
+use "restclient"
+use "json"
+
+class RemoteData
+  # Class-level variables
+  @@EUTILS = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+  @@EBIREST = "http://www.ebi.ac.uk/Tools"
+   
+  # Class-level methods
+  def self.eutils(script, params={}, outfile=nil)
+    response = nil
+    10.times do
+      begin
+        response = RestClient.get "#{@@EUTILS}/#{script}", {:params=>params}
+      rescue => err
+        warn "Request failed #{response.nil? ? "without error code" :
+          "with error code #{response.code}"}."
+        next
+      end
+      break if response.code == 200
+    end
+    abort "Unable to reach NCBI EUtils, error code #{response.code}." unless
+      response.code == 200
+    unless outfile.nil?
+      ohf = File.open(outfile, "w")
+      ohf.print response.to_s
+      ohf.close
+    end
+    response.to_s
+  end
+  def self.efetch(*etc)
+    eutils "efetch.fcgi", *etc
+  end
+  def self.elink(*etc)
+    eutils "elink.fcgi", *etc
+  end
+  def self.esummary(*etc)
+    eutils "esummary.fcgi", *etc
+  end
+  def self.update_gi(db, old_gi)
+    summ = JSON.parse RemoteData.esummary({:db=>db, :id=>old_gi,
+      :retmode=>"json"})
+    return nil,nil if summ["result"].nil? or summ["result"][old_gi.to_s].nil?
+    new_acc = summ["result"][old_gi.to_s]["replacedby"]
+    new_gi = (new_acc.nil? ? nil :
+      RemoteData.efetch({:db=>db, :id=>new_acc, :rettype=>"gi"}))
+    return new_gi,summ["result"][old_gi.to_s]["status"]
+  end
+  def self.ebiFetch(db, id, format, outfile=nil)
+    url = "#{@@EBIREST}/dbfetch/dbfetch/#{db}/#{id}/#{format}"
+    response = RestClient::Request.execute(:method=>:get,
+      :url=>url, :timeout=>600)
+    raise "Unable to reach EBI REST client, error code " +
+      response.code.to_s + "." unless response.code == 200
+    response.to_s
+  end
+  def self.ebiseq2taxid(id,db)
+    doc = RemoteData.ebiFetch(db, id, "annot").split(/[\n\r]/)
+    ln = doc.grep(/^FT\s+\/db_xref="taxon:/).first
+    ln = doc.grep(/^OX\s+NCBI_TaxID=/).first if ln.nil?
+    return nil if ln.nil?
+    ln.sub!(/.*(?:"taxon:|NCBI_TaxID=)(\d+)["; ].*/, "\\1")
+    return nil unless ln =~ /^\d+$/
+    ln
+  end
+end
+

data/utils/enveomics/Scripts/lib/enveomics_rb/seq_range.rb

@@ -0,0 +1,237 @@
+
+##### CLASSES:
+# SeqRange.parse(str): Initializes a new SeqRange from a string. A SeqRange is a
+#    representation of any collection of coordinates in a given sequence.
+#    Coordinates here are 1-based and base-located. Admitedly, the
+#    0-based/interbase-located system is much more convenient for range
+#    operations, but GenBank (together with most common Software) is built on
+#    the 1-based/base-located system.
+# str: A string describing the sequence range as in GenBank records.
+#    Note that "ID:location" notation is NOT supported by this implementation,
+#    althought it is permitted by GenBank. Some examples of valid `str`:
+#       "<1..123"
+#       "complement(3..6)"
+#       "join(complement(join(13..43,complement(45..46),complement(1..12),
+#           <1..12)),12..15,13..22)"
+#    The last one is valid, but once parsed it's internally simplified as:
+#       "join(complement(<1..12),1..12,45..46,complement(13..43),12..15,13..22)"
+#    Which is exactly equivalent. The common (but non-GenBank-compliant)
+#    practice of inverting coordinates instead of using the `complement()`
+#    operator is also supported. For example:
+#       "123..3"
+#    Is interpreted as:
+#       "complement(3..123)"
+# See also http://www.insdc.org/files/feature_table.html
+# 
+# SeqRange.new(c): Initializes a new SeqRange from an object.
+# c: Any object supported by the `<<` operator, or `nil` to create an empty
+#    SeqRange.
+# 
+# See also ContigSeqRange.parse.
+class SeqRange
+   # Class-level
+   def self.parse(str)
+      str.gsub!(/[^A-Za-z0-9\.\(\)<>,]/,"")
+      sr = nil
+      if str =~ /^join\((.+)\)$/i
+	 str1 = $1
+	 str2 = ""
+	 sr = SeqRange.new
+	 parens = 0
+	 str1.each_char do |chr|
+	    if chr=="," and parens==0
+	       sr += SeqRange.parse(str2)
+	       str2 = ""
+	       next
+	    elsif chr=="("
+	       parens += 1
+	    elsif chr==")"
+	       parens -= 1
+	       raise "Unbalanced parenthesis in '#{str1}'." if parens < 0
+	    end
+	    str2 += chr
+	 end
+	 sr += SeqRange.parse(str2) unless str2.empty?
+	 sr
+      elsif str =~ /^complement\((.+)\)$/i
+	 sr = SeqRange.parse($1)
+	 sr.reverse!
+	 sr
+      else
+	 sr = SeqRange.new(ContigSeqRange.parse(str))
+      end
+      sr
+   end
+   # Instance-level
+   attr_reader :contig
+   def initialize(c=nil)
+      @contig = []
+      self << c unless c.nil?
+   end
+   def leftmost; contig.map{ |c| c.left }.min; end
+   def rightmost; contig.map{ |c| c.right }.max; end
+   def size; contig.map{ |c| c.size }.inject(0,:+); end
+   def +(sr)
+      return(self + SeqRange.new(sr)) if sr.is_a? ContigSeqRange
+      raise "Unsupported operation '+' with class #{sr.class.to_s}." unless
+	 sr.is_a? SeqRange
+      out = SeqRange.new(self)
+      out << sr
+      out
+   end
+   def /(sr)
+      if sr.is_a? SeqRange
+	 sr2 = sr.sort.compact
+	 raise "Denominator is not a contiguous domain." unless sr2.size==1
+	 return(self/sr2.contig.first)
+      end
+      raise "Unsupported operation '/' with class #{sr.class.to_s}" unless
+	 sr.is_a? ContigSeqRange
+      raise "Denominator doesn't span the whole domain of numerator." unless
+	 sr.left <= leftmost and sr.right >= rightmost
+      i = ContigSeqRange.IGNORE_STRAND
+      ContigSeqRange.IGNORE_STRAND = false
+      range = self.sort.compact.size
+      ContigSeqRange.IGNORE_STRAND = i
+      range.to_f / sr.size
+   end
+   def <<(c)
+      if c.is_a? ContigSeqRange
+	 @contig << c
+      elsif c.is_a? SeqRange
+	 @contig += c.contig
+      elsif c.is_a? Array
+	 raise "Array must contain only objects of class ContigSeqRange." unless
+	    c.map{ |cc| cc.is_a? ContigSeqRange }.all?
+	 @contig += c
+      else
+	 raise "Unsupported operation '<<' with class #{c.class.to_s}."
+      end
+   end
+   def reverse ; SeqRange.new(self).reverse! ; end
+   def sort ; SeqRange.new(self).sort! ; end
+   def compact ; SeqRange.new(self).compact! ; end
+   def reverse!
+      @contig.each{ |c| c.reverse! }
+      @contig.reverse!
+      self
+   end
+   def sort!
+      @contig.sort!{ |x,y| x.left <=> y.left }
+      self
+   end
+   def compact!
+      return self if contig.size < 2
+      clean = false
+      while not clean
+	 clean = true
+	 (2 .. contig.size).each do |i|
+	    next unless contig[i-2].reverse? == contig[i-1].reverse?
+	    next unless contig[i-2].contig? contig[i-1]
+	    contig[i-2] += contig[i-1]
+	    contig[i-1] = nil
+	    clean = false
+	    break
+	 end
+	 @contig.compact!
+      end
+      self
+   end
+   def to_s
+      o = contig.map{ |c| c.to_s }.join(",")
+      o = "join(#{o})" if contig.size > 1
+      o
+   end
+end
+
+
+# ContigSeqRange.parse(str): Initializes a new ContigSeqRange from a string. A 
+#    ContigSeqRange is a primitive of `SeqRange` that doesn't support the
+#    `join()` operator. Other than that, syntax is identical to `SeqRange`.
+# str: A string describing the sequence range as in GenBank records (except
+#    `join()`).
+#
+# ContigSeqRange.new(a,b): Initializes a new ContigSeqRange from the
+#    coordinates as integers.
+# a: Start of the range.
+# b: End of the range. If a>b, the `complement()` operator is assumed.
+#
+# ContigSeqRange.IGNORE_STRAND = true: Use this pragma to ignore strandness.
+#    If set, it globally affects the behavior of of the class. Note that
+#    `SeqRange` instances contain a collection of `ContigSeqRange` objects, so
+#    that class is also affected.
+class ContigSeqRange
+   # Class-level
+   @@IGNORE_STRAND = false
+   def self.IGNORE_STRAND=(v); @@IGNORE_STRAND = !!v ; end
+   def self.IGNORE_STRAND; @@IGNORE_STRAND ; end
+   def self.parse(str)
+      str.downcase!
+      m = %r{^
+	 (?<c>complement\()?	# Reverse
+	 (?<lt><?)		# Open-ended to the left
+	 (?<left>\d+)		# Left coordinate
+	 (
+	    \.\.\.?		# 2 or 3 dots
+	    (?<gt1>>?)		# Open-ended to the right
+	    (?<right>\d+)	# Right coordinate
+	 )?
+	 (?<gt2>>?)		# Open-ended to the right
+	 \)?			# If reverse
+      $}x.match(str)
+      raise "Cannot parse range: #{str}." if m.nil?
+      c = ContigSeqRange.new(m[:left].to_i, m[:right].to_i)
+      c.open_left = true if m[:lt]=="<"
+      c.open_right = true if m[:gt1]==">" or m[:gt2]==">"
+      c.reverse! if m[:c]=="complement("
+      c
+   end
+   # Instance-level
+   attr_accessor :open_left, :open_right
+   attr_reader :coords
+   def initialize(a,b)
+      @coords = [[a,b].min, [a,b].max]
+      @open_left = false
+      @open_right = false
+      @reverse = (a > b)
+   end
+   def from; coords[ reverse ? 1 : 0 ] ; end
+   def to; coords[ reverse ? 0 : 1 ] ; end
+   def left; coords[0] ; end
+   def right; coords[1] ; end
+   def size; right-left+1 ; end
+   def reverse?; @reverse ; end
+   def reverse!
+      @reverse = ! reverse? unless @@IGNORE_STRAND
+      self
+   end
+   def overlap?(sr) !(right < sr.left or left > sr.right) ; end
+   def contig?(sr) !(right+1 < sr.left or left-1 > sr.right) ; end
+   def +(sr)
+      raise "Unsupported operation '+' with class #{sr.class.to_s}" unless
+	 sr.is_a? ContigSeqRange
+      raise "Non-contiguous ranges cannot be added." unless contig? sr
+      raise "Ranges in different strands cannot be added." unless
+	 reverse? == sr.reverse?
+      out = ContigSeqRange.new([left,sr.left].min, [right,sr.right].max)
+      out.reverse! if reverse?
+      out.open_left=true if (left < sr.left ? self : sr).open_left
+      out.open_right=true if (right > sr.right ? self : sr).open_right
+      out
+   end
+   def to_s
+      o = ""
+      o += "<" if open_left
+      o += left.to_s
+      if left == right
+	 o += ">" if open_right
+      else
+	 o += ".."
+	 o += ">" if open_right
+	 o += right.to_s
+      end
+      o = "complement(#{o})" if reverse?
+      o
+   end
+end
+