miga-base 1.2.17.0 → 1.2.17.1

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

@@ -0,0 +1,17 @@
+
+module Enveomics
+  class Error < RuntimeError
+  end
+
+  class CommandError < Error
+  end
+
+  class OptionError < Error
+  end
+
+  class UnimplementedError < Error
+  end
+
+  class ParseError < Error
+  end
+end

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

@@ -0,0 +1,30 @@
+
+require 'enveomics_rb/stats/sample'
+
+module Enveomics
+  # Calculate Gaussian Mixture Models by Expectation Maximization
+  class GmmEm
+    attr :sample
+    attr :components
+    attr :opts
+
+    # Initialize Enve::GmmEm object from numeric array +x+, +components+
+    # gaussian components (an Integer), and options hash +opts+ with supported
+    # Symbol keys:
+    # - ll_delta_converge: Maximum change in LL to consider convergence
+    #   (by default: 1e-15)
+    # - max_iter: Maximum number of EM iterations (by default: 1_000)
+    # - init_mu: Initial components means as numeric array
+    # - init_sigma: Initial components standard deviation as numeric array
+    # - init_alpha: Initial components fractions as numeric array adding up to 1
+    def initialize(x, components = 2, opts = {})
+      @sample = Enve::Stats::Sample.new(x)
+      @opts = opts
+      @opts[:ll_delta_convergence] ||= 1e-15
+      @opts[:max_iter] ||= 1_000
+    end
+
+    
+  end
+end
+

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

@@ -0,0 +1,253 @@
+
+#
+# @author: Luis M. Rodriguez-R
+# @update: Jul-14-2015
+# @license: artistic license 2.0
+#
+
+module JPlace
+   ##### CLASSES:
+   # Placement.new(placement[, fields]): Initializes a new read placement.
+   # placement: A hash containing the placement.
+   # fields: If passed, sets the field order for all subsequent placements.
+   class Placement
+      attr_writer :flag # This attribute is used by JPlace.distances.rb as a placeholder
+      attr_reader :p, :n, :m, :flag
+      @@fields = nil
+      def self.fields=(fields)
+	 @@fields=fields
+      end
+      def self.fields
+	 @@fields
+      end
+      def initialize(placement, fields=nil)
+	 @@fields = fields if @@fields.nil? and not fields.nil?
+	 # Save only the best (first) placement:
+	 abort "Placements must contain a 'p' field.\n" if placement["p"].nil?
+	 abort "Placements must contain a 'p' field with at least one entry.\n" if placement["p"][0].nil?
+	 @p = [placement["p"][0]]
+	 # Find name-only placements (EPA-style):
+	 unless placement["n"].nil?
+	    @n = placement["n"]
+	    @m = @n.map{ |n| 1 }
+	 end
+	 # Find multiplicity placements (pplacer-style):
+	 unless placement["nm"].nil?
+	    @n = placement["nm"].map{ |nm| nm[0] }
+	    @m = placement["nm"].map{ |nm| nm[1].to_i }
+	 end
+	 abort "Placements must contain one of 'n' or 'nm' fields.\n" if @n.nil? or @m.nil?
+      end
+      def nm
+	 (0 .. (self.n.length-1)).map{ |i| {:n=>self.n[i], :m=>self.m[i]} }
+      end
+      def get_field_value(field)
+	 abort "Impossible to read placement with undefined fields." if @@fields.nil?
+	 f = @@fields.find_index(field)
+	 abort "Undefined field #{field}." if f.nil?
+	 self.p[0][f]
+      end
+      def set_field_value(field, value)
+	 f = @@fields.find_index(field)
+	 abort "Undefined field #{field}." if f.nil?
+	 self.p[0][f] = value
+      end
+      def edge_num
+	 self.get_field_value('edge_num').to_i
+      end
+      def likelihood
+	 self.get_field_value('likelihood').to_f
+      end
+      def like_weight_ratio
+	 self.get_field_value('like_weight_ratio').to_f
+      end
+      def distal_length
+	 (self.get_field_value('distal_length') || 0).to_f
+      end
+      def pendant_length
+	 (self.get_field_value('pendant_length') || 0).to_f
+      end
+      def to_s
+	 "#<Placement of #{self.n}: #{self.p}>"
+      end
+   end
+
+   # Ancilliary class Tree
+   class Tree
+      @@HAS_ICONV = nil
+      def self.has_iconv?
+	 if @@HAS_ICONV.nil?
+	    @@HAS_ICONV = true
+	    begin
+	       require 'rubygems'
+	       require 'iconv'
+	    rescue LoadError
+	       @@HAS_ICONV = false
+	    end
+	 end
+	 @@HAS_ICONV
+      end
+      def self.from_nwk(nwk)
+	 if Tree.has_iconv?
+	    ic = Iconv.new('UTF-8//IGNORE','UTF-8')
+	    nwk = ic.iconv(nwk + ' ')[0..-2]
+	 end
+	 Node.new(nwk)
+      end
+   end
+   
+   # Node.new(nwk[, parent]): Initializes a new Node.
+   # nwk: Node's description in Newick format.
+   # parent: Node's parent, or nil if root node.
+   class Node
+      # Class
+      @@edges = []
+      def self.edges
+	 @@edges
+      end
+      def self.register(node)
+	 @@edges[node.index] = node unless node.index.nil?
+      end
+      # Class-level functions related to JPlace
+      def self.link_placement(placement)
+	 abort "Trying to link placement in undefined edge #{placement.edge_num}: #{placement.to_s}" if @@edges[placement.edge_num].nil?
+	 @@edges[placement.edge_num].add_placement!(placement)
+      end
+      def self.unlink_placement(placement)
+	 @@edges[placement.edge_num].delete_placement!(placement)
+      end
+      # Instance
+      attr_reader :children, :length, :name, :label, :index, :nwk, :parent, :placements, :collapsed
+      def initialize(nwk, parent=nil)
+	 abort "Empty newick.\n" if nwk.nil? or nwk==''
+	 nwk.gsub! /;(.)/, '--\1'
+	 @nwk = nwk
+	 @parent = parent
+	 @placements = []
+	 @collapsed = false
+	 # Find index
+	 index_m = /^(?<pre>.*){(?<idx>[0-9]+)}(?<post>[^\(\),;]*);?$/.match(nwk)
+	 if index_m.nil? and parent.nil? and nwk[nwk.length-1]==';'
+	    @index = nil
+	 else
+	    abort "Unindexed edge found:\n#{@nwk}\n" if index_m.nil?
+	    nwk = index_m[:pre]+index_m[:post]
+	    @index = index_m[:idx].to_i
+	 end
+	 # Find name, label, and length
+	 meta_m = /^(\((?<cont>.+)\))?(?<name>[^:\(\);]*)(:(?<length>[0-9\.Ee+-]*)(?<label>\[[^\[\]\(\);]+\])?)?;?$/.match(nwk) or
+	    abort "Cannot parse node metadata (index #{@index}):\n#{@nwk}\n"
+	 nwk = meta_m[:cont]
+	 @name = meta_m[:name]
+	 @length = meta_m[:length]
+	 @label = meta_m[:label]
+	 # Find children
+	 @children = []
+	 nwk ||= ''
+	 quote = nil
+	 while nwk != ''
+	    i = 0
+	    j = 0
+	    nwk.each_char do |chr|
+	       if quote.nil?
+		  if chr=='"' or chr=="'"
+		     quote = chr
+		  else
+		     i += 1 if chr=='('
+		     i -= 1 if chr==')'
+		     if i==0 and chr==','
+			i=nil
+			break
+		     end
+		  end
+	       else
+		  quote = nil if chr==quote
+	       end
+	       j += 1
+	    end
+	    abort "Unbalanced node at edge {#{@index}}, with leftness #{i}:\n#{@nwk}\n" unless i.nil? or i==0
+	    @children << Node.new(nwk[0 .. j-1],self)
+	    nwk = nwk.length==j ? '' : nwk[j+1 .. -1]
+	 end
+	 Node.register(self)
+      end
+      # Accessors/Setters
+      def name=(new_name)
+	 @name = new_name.gsub(/[\s\(\),;:]/, '_')
+      end
+      # Tree algorithms
+      def post_order &blk
+	 self.children.each { |n| n.post_order &blk }
+	 blk[self]
+      end
+      def in_order &blk
+	 abort "Tree must be dycotomic to traverse in_order, node #{self.cannonical_name} "+
+	    "has #{self.children.lenght} children." unless [0,2].include? self.children.length
+	 self.children[0].in_order &blk unless self.children[0].nil?
+	 blk[self]
+	 self.children[1].in_order &blk unless self.children[1].nil?
+      end
+      def pre_order &blk
+	 blk[self]
+	 self.children.each { |n| n.pre_order &blk }
+      end
+      def path_to_root
+	 if @path_to_root.nil?
+	    @path_to_root = [self]
+	    @path_to_root += self.parent.path_to_root unless self.parent.nil?
+	 end
+	 @path_to_root
+      end
+      def distance_to_root
+	 if @distance_to_root.nil?
+	    @distance_to_root = path_to_root.map{ |n| n.length.nil? ? 0.0 : n.length.to_f }.reduce(0.0, :+)
+	 end
+	 @distance_to_root
+      end
+      def lca(node)
+	 p1 = self.path_to_root
+	 p2 = node.path_to_root
+	 p1.find{ |n| p2.include? n }
+      end
+      def distance(node)
+	 self.distance_to_root + node.distance_to_root - (2.0 * self.lca(node).distance_to_root)
+      end
+      def ==(node) self.index == node.index ; end
+      # Tree representation
+      def cannonical_name
+	 return(self.name) unless self.name.nil? or self.name == ""
+	 return(self.label) unless self.label.nil? or self.label == ""
+	 return("{#{self.index.to_s}}") unless self.index.nil?
+	 ""
+      end
+      def to_s
+	 o = ""
+	 o += "(" + self.children.map{ |c| c.to_s }.join(",") + ")" if self.children.length > 0
+	 o += self.cannonical_name
+	 u = "#{self.length.nil? ? "" : self.length}#{self.label.nil? ? "" : self.label}"
+	 o += ":#{u}" unless u==""
+	 o
+      end
+      # Instance-level functions related to JPlace
+      def collapse!
+	 self.pre_order do |n|
+	    if n!=self
+	       while n.placements.length > 0
+		  p = Node.unlink_placement(n.placements[0])
+		  p.set_field_value('edge_num', self.index)
+		  Node.link_placement(p)
+	       end
+	    end
+	 end
+	 @collapsed = true
+      end
+      def add_placement!(placement)
+	 @placements << placement
+      end
+      def delete_placement!(placement)
+	 @placements.delete(placement)
+      end
+   end
+
+end # module JPlace
+

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

@@ -0,0 +1,88 @@
+
+module Enveomics
+  ##
+  # A simple object representing a sequence match from a search engine
+  # supporting tabular BLAST output
+  class Match
+    class << self
+      def column_types
+        {
+          qseqid: String,    sseqid: String,    pident: Float,
+          length: Integer,   mismatch: Integer, gapopen: Integer,
+          q_start: Integer,  q_end: Integer,    s_start: Integer,
+          s_end: Integer,    evalue: Float,     bitscore: Float,
+          # Non-standard (but frequently used in Enveomics Collection):
+          qry_len: Integer,  sbj_len: Integer
+        }
+      end
+
+      def column_type(sym)
+        column_types[colname(sym)]
+      end
+
+      def to_column_type(sym, value)
+        case column_type(sym).to_s
+        when 'String' ; value.to_s
+        when 'Float'  ; value.to_f
+        when 'Integer'; value.to_i
+        end
+      end
+
+      def columns
+        column_types.keys
+      end
+
+      def column(sym)
+        columns.index(colname(sym))
+      end
+
+      def colsynonyms
+        {
+          qry: :qseqid, sbj: :sseqid,
+          id: :pident, len: :length, score: :bitscore
+        }
+      end
+
+      def colnames
+        columns + colsynonyms.keys
+      end
+
+      def colname(sym)
+        s = sym.to_sym
+        column_types[s] ? s : colsynonyms[s]
+      end
+    end
+
+    ####--- Instance Level ---###
+
+    attr :row
+
+    ##
+    # Initialize Enveomics::Match object from a tabular blast line String +ln+
+    def initialize(ln)
+      @row = ln.chomp.split("\t")
+    end
+
+    colnames.each do |sym|
+      define_method sym do
+        self.class.to_column_type(sym, row[self.class.column(sym)])
+      end
+    end
+
+    def qry_fract
+      return 0.0 unless qry_len.zero?
+      @fract ||= len.to_f / qry_len
+    end
+
+    alias fract qry_fract
+
+    def sbj_fract
+      return 0.0 unless sbj_len.zero?
+      @fract ||= len.to_f / sbj_len
+    end
+
+    def to_s
+      row.join("\t")
+    end
+  end
+end

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/rbm.rb

@@ -0,0 +1,49 @@
+require 'enveomics_rb/bm_set'
+
+module Enveomics
+  class RBM
+    attr :seq1, :seq2, :bms1, :bms2
+
+    ##
+    # Initialize RBM object with sequence paths +seq1+ and +seq2+, and
+    # Enveomics::BMset options Hash +bm_opts+
+    def initialize(seq1, seq2, bm_opts = {})
+      @seq1 = seq1
+      @seq2 = seq2
+      @bms1 = Enveomics::BMset.new(seq1, seq2, bm_opts)
+      @bms2 = Enveomics::BMset.new(seq2, seq1, bm_opts)
+      @set = nil
+    end
+
+    ##
+    # Array of Reciprocal Best Enveomics::Match objects
+    def set
+      @set ||= reciprocate!
+    end
+
+    ##
+    # Number of reciprocal best matches found
+    def count
+      set.count
+    end
+
+    ##
+    # Find reciprocal best matches and return the subset of +bms1+ that
+    # is reciprocal with +bms2+
+    def reciprocate!
+      bms1.each.select do |bm|
+        bms2[bm.sbj] && bm.qry == bms2[bm.sbj].sbj
+      end
+    end
+
+    ##
+    # Enumerate RBMs and yield +blk+
+    def each(&blk)
+      if block_given?
+        set.each { |bm| blk.call(bm) }
+      else
+        to_enum(:each)
+      end
+    end
+  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
+