mspire 0.2.4 → 0.3.0

data/lib/spec_id.rb

@@ -1,75 +1,19 @@
 require 'ostruct'
 require 'set'
 require 'hash_by'
-require 'spec_id/precision'
 require 'roc'
 require 'sample_enzyme'  # for others
 require 'spec_id/bioworks'
 require 'spec_id/sequest'
-require 'spec_id/proph'
+require 'spec_id/proph/prot_summary'
 require 'spec_id_xml'
+require 'spec_id/mass'
+require 'fasta'
+
+module ProteinReferenceable ; end
 
 class SampleEnzyme ; end
 
-class Mass
-  # http://expasy.org/tools/findmod/findmod_masses.html
-  # still need to add the modifications
-  MONO = {
-    :A => 71.03711,
-    :R => 156.10111,
-    :N => 114.04293,
-    :D => 115.02694,
-    :C => 103.00919,
-    :E => 129.04259,
-    :Q => 128.05858,
-    :G => 57.02146,
-    :H => 137.05891,
-    :I => 113.08406,
-    :L => 113.08406,
-    :K => 128.09496,
-    :M => 131.04049,
-    :F => 147.06841,
-    :P => 97.05276,
-    :S => 87.03203,
-    :T => 101.04768,
-    :W => 186.07931,
-    :Y => 163.06333,
-    :V => 99.06841,
-
-    :h => 1.00783,
-    :h_plus => 1.00728,
-    :o => 15.9949146,
-    :h2o => 18.01056,
-
-  }
-  AVG = {
-    :A => 71.0788,
-    :R => 156.1875,
-    :N => 114.1038,
-    :D => 115.0886,
-    :C => 103.1388,
-    :E => 129.1155,
-    :Q => 128.1307,
-    :G => 57.0519,
-    :H => 137.1411,
-    :I => 113.1594,
-    :L => 113.1594,
-    :K => 128.1741,
-    :M => 131.1926,
-    :F => 147.1766,
-    :P => 97.1167,
-    :S => 87.0782,
-    :T => 101.1051,
-    :W => 186.2132,
-    :Y => 163.1760,
-    :V => 99.1326,
-
-    :h => 1.00794,
-    :h_plus => 1.00739,
-    :o => 15.9994,
-    :h2o => 18.01524,
-  }
-end
 
 module SpecID ; end
 
@@ -91,8 +35,14 @@ module SpecID
   # Will return a SpecID object (really, the object corresponding to the
   # file type which mixes in SpecID [is_a?(SpecID) == true])
   # If no file is given, will return a GenericSpecID object.
+  # If file is an array, this is assumed to be a group of srf files which is
+  # converted into an SRFGroup Ojbect and run.
   def self.new(file=nil, tp=nil)
-    if file 
+    # this will need to be specialized for other groups later
+    if file.is_a?(Array)
+      # takes an array of srf filenames
+      SRFGroup.new(file)
+    elsif file 
       from_file(file, tp)
     else
       GenericSpecID.new      
@@ -100,22 +50,27 @@ module SpecID
   end
 
   # tp = file_type
-  # only takes an array if they are srf files!
+  # a single srf file will be packaged into an SRFGroup object
   def self.from_file(file, tp=nil)
     obj = nil
     unless tp
       tp = file_type(file)
     end
     obj = case tp
+    when 'srf'
+      #@hi_prob_best = false
+      SRFGroup.new([file])
     when 'srg'
-      @hi_prob_best = false
+      #@hi_prob_best = false
       SRFGroup.new(file)
     when 'bioworks'
-      @hi_prob_best = false
+      #@hi_prob_best = false
       Bioworks.new(file)
     when 'protproph'
-      @hi_prob_best = true
+      #@hi_prob_best = true
       Proph::ProtSummary.new(file)
+    when 'pepproph'
+      Proph::PepSummary.new(file)
     else
       abort "UNRECOGNIZED file type for #{file}"
     end
@@ -123,9 +78,76 @@ module SpecID
   end
 
   def inspect
-    "<#{self.class} #peps=\"#{peps.size}\">"
+    peps_string =
+      if peps
+        "peps(#)=#{peps.size}"
+      else
+        "peps=(nil)"
+      end
+    "<#{self.class} #{peps_string}>"
+  end
+
+  # given some list of SpecID::Pep based objects, returns the list of proteins
+  # associated with those peptides
+  # kind must be a symbol:
+  # :no_update (current proteins are returned, but their peps attribute
+  # is not updated)
+  # :update (current proteins returned with peps attribute updated)
+  # :new (new proteins are created complete with peps attribute)
+  def self.protein_list(pephits, kind=:no_update)
+
+    orig_pephits_prts = []
+    if kind == :new
+      new_prots = {}
+      pephits.each_with_index do |pep,i|
+        orig_pephits_prts[i] = pep.prots
+        peps_new_prts = pep.prots.map do |prt|
+          if new_prots.key? prt.reference
+            already_exists = new_prots[prt.reference]
+          else
+            np = prt.dup
+            np.peps = []
+            new_prots[np.reference] = np
+            np
+          end
+        end
+        pep.prots = peps_new_prts
+      end
+    end
+
+    if kind == :update
+      pephits.each do |pep|
+        pep.prots.each do |prt|
+          prt.peps = []
+        end
+      end
+    end
+
+    prot_set = {}
+    pephits.each do |pep|
+      prts = pep.prots
+      prts.each do |prt|
+        prot_set[ prt.reference ] = prt 
+      end
+      if (kind == :update || kind == :new)
+        prts.each do |prt|
+          prt.peps << pep
+        end
+      end
+    end
+
+    ## Reset the original protein hits
+    if kind == :new
+      pephits.each_with_index do |pep,i|
+        pep.prots = orig_pephits_prts[i]
+      end
+    end
+
+    prot_set.values
   end
 
+
+
   # takes a comma separated list  or array and extends the last to create an
   # array of desired size
   def self.extend_args(arg, desired_size)
@@ -193,13 +215,6 @@ module SpecID
     prot_triplets
   end
 
-
-  ## basically, this is the command line wrapper
-  def self.precision(argv)
-    Prec.new.run_cmd_line(argv)
-  end
-
-
   # returns number of true positives (array) and the specified output (as
   # parallel array).  Requires the classification method and a sorted array of
   # tp values and an array fp values.
@@ -223,55 +238,100 @@ module SpecID
     pps
   end
 
-  def classify_by_regex(items, regex, fp_on_match=true)
-    case items
-    when :prots
+  def self.prots?(ar)
+    ar.first.is_a? SpecID::Prot
+  end
+
+  def self.peps?(ar)
+    ar.first.is_a? SpecID::Pep
+  end
+
+  # for older stuff
+  def classify_by_regex(items, regex, decoy_on_match=true, ties=:both)
+    objects = 
+      case items
+      when :prots
+        prots
+      when :peps
+        peps
+      end
+    SpecID.classify_by_prot(objects, regex, decoy_on_match, ties)
+  end
+
+  # includes the peptide hit in both
+  # returns (target, decoy)
+  # (for peps) ties can be :both, true (target wins), false (decoy wins)
+  # regardless of ties behavior, will partition out the proteins to be
+  # appropriate for the peptide
+  def self.classify_by_prot(items, regex, decoy_on_match=true, ties=:both)
+    if items.size == 0
+      return [[],[]]
+    elsif prots?(items)
       myproc = proc { |prt| 
-        if prt.reference =~ regex ; !fp_on_match
-        else ; fp_on_match end 
+        if prt.reference =~ regex ; !decoy_on_match
+        else ; decoy_on_match end 
       }
       return classify(items, myproc)
-    when :peps
+    elsif peps?(items)
       match = [] ; nomatch = []
-      peps.each do |pep| 
-        match_prots = [] ; nomatch_prots = []
-        (hit, nohit) = pep.prots.partition do |prot|
+      items.each do |pep| 
+        (match_prots, nomatch_prots) = pep.prots.partition do |prot|
           prot.reference =~ regex
         end
-        if hit.size == 0
+        if match_prots.size == 0
           nomatch << pep
-        elsif nohit.size == 0
+        elsif nomatch_prots.size == 0
           match << pep
         else ## both have hits
           pep.prots = match_prots
           nomatch_pep = pep.dup
           nomatch_pep.prots = nomatch_prots
-          match << pep
-          nomatch << pep
+
+          # resolve ties
+          case ties
+          when true
+            if decoy_on_match
+              nomatch << pep
+            else
+              match << pep
+            end
+          when false
+            if decoy_on_match
+              match << pep
+            else
+              nomatch << pep
+            end
+          when :both
+            match << pep
+            nomatch << pep
+          else ; raise ArgumentError
+          end
         end
       end
-      if fp_on_match
+      if decoy_on_match
         return [nomatch , match]
       else
         return [match, nomatch]
       end
     else
-      abort "don't recognize "
+      raise ArgumentError, "arg1 is ar of objects descended from SpecID::Prot/Pep"
     end
   end
 
+
+
   # returns [tp, fp] based on the protein prefix for items where items =
   # (:prot|:peps)
   # this may result in a duplication of some peptides if they match both
   # normal and decoy proteins.  In this case, the protein arrays are split,
   # too, so that each points only to its breed of protein. 
-  def classify_by_false_flag(items, flag, fp_on_match=true, prefix=false)
+  def classify_by_decoy_flag(items, flag, decoy_on_match=true, prefix=false)
     if prefix
       regex = /^#{Regexp.escape(flag)}/ 
     else
       regex = /#{Regexp.escape(flag)}/ 
     end
-    classify_by_regex(items, regex, fp_on_match)
+    classify_by_regex(items, regex, decoy_on_match)
   end
 
   # Returns (match, nomatch)
@@ -303,7 +363,7 @@ module SpecID
         classify_item_by.call(item) ]
     end
     roc = ROC.new
-    tp, fp = roc.prep_list(doublets)
+    tp, fp = roc.doublets_to_separate(doublets)
     return tp, fp
   end
 
@@ -393,11 +453,13 @@ module SpecID
     end
     File.open(file) do |fh|
       lines = ""
-      4.times { lines << fh.readline }
+      8.times { lines << fh.readline }
       if lines =~ /<bioworksinfo>/
         return 'bioworks'
-      elsif lines =~ /<protein_summary/ && lines =~ /xmlns="http:\/\/regis-web.systemsbiology.net\/protXML"/
+      elsif ((lines =~ /<protein_summary/) and ((lines =~ Proph::ProtSummary::Filetype_and_version_re_old) or (lines =~ Proph::ProtSummary::Filetype_and_version_re_new)))
         return 'protproph'
+      elsif lines =~ /<msms_pipeline_analysis.*<peptideprophet_summary/m
+        return 'pepproph'
       end
     end
   end
@@ -521,9 +583,10 @@ module SpecID
   end
 end
 
-
 # A Generic spectraID protein
 module SpecID::Prot
+  include ProteinReferenceable
+
   # probability is always a float!
   attr_accessor :probability, :reference, :peps
 
@@ -531,6 +594,14 @@ module SpecID::Prot
     self.reference <=> other.reference
   end
 
+  def inspect
+    pep_string = 
+      if peps
+      ", @peps(#)=#{peps.size}"
+      end
+    "<#{self.class} @probability=#{probability}, @reference=#{reference}#{pep_string}>"
+  end
+ 
 end
 
 module SpecID::Pep
@@ -653,6 +724,23 @@ module SpecID::Pep
     when :mmu
     end
   end
+
+  # calls the method associated with each key and returns the value
+  def values_at(*args)
+    args.map do |arg|
+      send(arg)
+    end
+  end
+
+  def inspect
+
+    prot_string = 
+      if prots
+      ", @prots(#)=#{prots.size}"
+      end
+    "<#{self.class} @probability=#{probability}, @sequence=#{sequence}, @aaseq=#{aaseq}, @charge=#{charge}#{prot_string}>"
+  end
+
 end
 
 class SpecID::GenericProt

data/lib/spec_id_xml.rb

@@ -6,7 +6,7 @@
 # concatenation into a file
 module SpecIDXML
 
-  Special_chrs_hash = {
+  MSial_chrs_hash = {
     '"' => '"',
     '&' => '&',
     "'" => ''',
@@ -17,8 +17,8 @@ module SpecIDXML
   # substitutes special xml chars
   def escape_special_chars(string)
     string.split('').map do |char|
-      if Special_chrs_hash.key? char ; Special_chrs_hash[char] 
-        # if x = Special_chrs_hash[char] ; x  # <-- that's slightly slower
+      if MSial_chrs_hash.key? char ; MSial_chrs_hash[char] 
+        # if x = MSial_chrs_hash[char] ; x  # <-- that's slightly slower
       else ; char end
     end.join
   end
@@ -33,13 +33,13 @@ module SpecIDXML
   end
 
 
-  def param_xml(symbol)
-    tabs + '<parameter name="' + "#{symbol}" + '" value="' + "#{send(symbol)}" + '"/>'
+  def param_xml(obj, symbol)
+    tabs + '<parameter name="' + "#{symbol}" + '" value="' + "#{obj.send(symbol)}" + '"/>'
   end
 
-  def params_xml(*symbol_list)
+  def params_xml(obj, *symbol_list)
     symbol_list.collect { |sy|
-      param_xml(sy)
+      param_xml(obj, sy)
     }.join("\n") + "\n"
   end
 
@@ -92,9 +92,7 @@ module SpecIDXML
   end
 
   def attrs_xml(list_of_symbols)
-    list_of_symbols.collect {|sy|
-      attr_xml(sy)
-    }.join(" ")
+    list_of_symbols.collect {|sy| attr_xml(sy) }.join(" ")
   end
 
 end

data/lib/transmem/phobius.rb

@@ -0,0 +1,147 @@
+require 'transmem'
+
+class Phobius ; end
+
+# This class will probably change its interface some in the future
+# That's the web portal
+# http://phobius.cgb.ki.se/
+# How to run:
+# Select output format as 'Short'
+# then hit 'Submit Query'
+
+# note: to implement some of the TransmemIndex features, the update_aaseq
+# method must be called!
+class Phobius::Index < Hash
+  include TransmemIndex
+
+  # will update_aaseq if given a fasta_obj
+  def initialize(file, fasta_obj = nil )
+    Phobius.default_index(file, self)
+    if fasta_obj
+      update_aaseq(fasta_obj)  
+    end
+  end
+
+  # we need to match whatever function toppred uses to generate identifiers if
+  # we want derivative processes to be fast and accurate
+  def reference_to_key(reference)
+    if reference
+      if reference.size > 0
+        index = reference.index(' ')
+        string = 
+          if index
+            reference[0...index]
+          else
+            reference
+          end
+        string.gsub('"','')
+      else
+        ''
+      end
+    else
+      nil
+    end
+  end
+
+  # adds an :aaseq key to each hash (necessary for avg_overlap method)
+  # these are shallow references to the aaseq in the fasta obj
+  def update_aaseq(fasta)
+    fasta.each do |prot|
+      self[reference_to_key(prot.reference)][:aaseq] = prot.aaseq
+    end
+  end
+
+end
+
+class Phobius
+  include TransmemIndex
+
+  # returns the default index
+  def self.default_index(file, index={})
+    parser = Phobius::Parser.new(:short)
+    parser.file_to_index(file, index)
+  end
+
+end
+
+module Phobius::Parser
+
+  def self.new(parser_type=:short)
+    klass = 
+      case parser_type
+      when :short
+        Phobius::ParserShort
+      else
+        raise ArgumentError, "don't recognize parser type: #{parser_type}"
+      end
+    klass.new
+  end
+
+  def file_to_index(file, index={})
+    File.open(file) {|fh| to_index(fh, index) }
+  end
+
+end
+
+
+class Phobius::ParserShort
+  include Phobius::Parser
+
+  # takes a phobius prediction string (e.g., i12-31o37-56i63-84o96-116i123-143o149-169i)
+  # and returns an array of hashes with the keys :start and :stop
+  def prediction_to_array(string)
+    segments = []
+    string.scan(/[io](\d+)-(\d+)/) do |m1, m2|
+      segments << { :start => m1.to_i, :stop => m2.to_i }
+    end
+    segments
+  end
+
+  # returns a hash structure in this form: { identifier => {
+  # :num_certain_transmembrane_segments => Int,
+  # :transmembrane_segments => [:start => Int, :stop
+  # => Int] }
+  # can parse io even if there is no header to key in on.
+  def to_index(io, index={})
+    init_pos = io.pos
+    cnt = 0
+    found_header = false
+    loop do
+      if io.gets =~ /SEQENCE/ 
+        found_header = true
+        break
+      end
+      cnt += 1
+      break if cnt > 10
+    end
+    if !found_header
+      io.pos = init_pos
+    end
+    current_record = nil
+    io.each do |line|
+      line.chomp!
+      # grab values
+      ar = line.split(/\s+/)
+      next if ar.size != 4
+      (key, num_tms, signal_peptide, prediction) = ar
+      # cast the values
+      num_tms = num_tms.to_i
+      signal_peptide = 
+        case signal_peptide
+        when 'Y'
+          true
+        when '0'
+          false
+        end
+      index[key] = { 
+        :num_certain_transmembrane_segments => num_tms, 
+        :signal_peptide => signal_peptide,
+      }
+      if num_tms > 0
+        index[key][:transmembrane_segments] = prediction_to_array(prediction)
+      end
+    end
+    index
+  end
+
+end