miga-base 1.2.15.2 → 1.2.15.3

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

@@ -1,17 +0,0 @@
-
-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

@@ -1,30 +0,0 @@
-
-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

@@ -1,253 +0,0 @@
-
-#
-# @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

@@ -1,88 +0,0 @@
-
-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

@@ -1,182 +0,0 @@
-
-##### 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

@@ -1,49 +0,0 @@
-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

@@ -1,74 +0,0 @@
-
-#
-# @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
-