miga-base 0.7.25.2 → 0.7.25.3

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/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
-

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

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