mspire 0.2.4 → 0.3.0

data/lib/transmem/toppred.rb

@@ -0,0 +1,368 @@
+require 'transmem'
+require 'xml_style_parser'
+
+class TopPred ; end
+
+
+class TopPred::Index < Hash
+  include TransmemIndex
+
+  # 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
+      ri = reference.index(' ')
+      frst =
+        if ri 
+          reference[0...reference.index(' ')]
+        else 
+          reference
+        end
+      if frst
+        frst.gsub(/[^0-9a-zA-Z]/,'_')
+      else
+        nil
+      end
+    else
+      nil
+    end
+  end
+
+  def initialize(file, kind=:default)
+    case kind
+    when :default
+      TopPred.default_index(file, self)
+    else
+      abort "can't do #{kind}"
+    end
+  end
+
+  # This class will probably change its interface some in the future
+  # That's the web portal
+  # http://bioweb.pasteur.fr/seqanal/interfaces/toppred.html
+  # How to run:
+  # uncheck 'Produce hydrophobicity graph image (-g)'
+  # choose 'Xml' or 'New: new text' output
+  # type in your email, then hit 'Run toppred'
+end
+
+class TopPred
+  include TransmemIndex
+
+  # returns the default index
+  def self.default_index(file, index={})
+    TopPred::Parser.new(TopPred::Parser.filetype(file)).file_to_index(file, index)
+  end
+
+end
+
+module TopPred::Parser
+  # returns :xml or :text
+  def self.filetype(file)
+    File.open(file) do |fh|
+      case fh.gets
+      when /<\?xml version.*>/
+        :xml 
+      when /Algorithm specific/
+        :text
+      else
+        nil
+      end
+    end
+  end
+
+  # type = :xml or :text
+  def self.new(parser_type=:xml)
+    klass = 
+      case parser_type
+      when :xml
+        TopPred::Parser_XML
+      when :text
+        TopPred::Parser_Text
+      else
+        abort "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
+
+  # where each segment = [prob, first, last] and aaseq is a string each
+  # segment may also be a hash => first, last, probability (adding key
+  # 'aaseq') 
+  # first/last '1' indexed returns segments where each is [prob,
+  # first, last, aaseq] or hash (above)
+  def add_sequences_to_segments(segments, aaseq)
+    if segments.first.is_a? Array
+      segments.each do |seg|
+        first_index = seg[1] - 1
+        length = (seg[2] - seg[1]) + 1
+        seg.push( aaseq[first_index, length] )
+      end
+    else
+      segments.each do |seg|
+        first_index = seg[:start] - 1
+        length = (seg[:stop] - seg[:start]) + 1
+        seg[:aaseq] = ( aaseq[first_index, length] )
+      end
+    end
+    segments
+  end
+
+
+
+end
+
+module TopPred::Parser_XML
+  include TopPred::Parser
+  include XMLStyleParser
+
+  def self.new(meth=:to_index)
+    parser = XMLStyleParser.choose_parser(self, meth).new
+    @method = meth
+    parser
+  end
+
+  def parse(file)
+    send(@method, file)
+  end
+end
+
+class TopPred::Parser_XML::DOM
+  include TopPred::Parser_XML
+  include XMLStyleParser
+
+=begin
+  YAL010C: 
+  num_putative_transmembrane_segments: 1
+  aaseq: MLPYMDQVLRAFYQSTHWSTQNSYEDITATSRTLLDFRIPSAIHLQISNKSTPNTFNSLDFSTRSRINGSLSYLYSDAQQLEKFMRNSTDIPLQDATETYRQLQPNLNFSVSSANTLSSDNTTVDNDKKLLHDSKFVKKSLYYGRMYYPSSDLEAMIIKRLSPQTQFMLKGVSSFKESLNVLTCYFQRDSHRNLQEWIFSTSDLLCGYRVLHNFLTTPSKFNTSLYNNSSLSLGAEFWLGLVSLSPGCSTTLRYYTHSTNTGRPLTLTLSWQPLFGHISSTYSAKTGTNSTFCAKYDFNLYSIESNLSFGCEFWQKKHHLLETNKNNNDKLEPISDELVDINPNSRATKLLHENVPDLNSAVNDIPSTLDIPVHKQKLLNDLTYAFSSSLRKIDEERSTIEKFDNKINSSIFTSVWKLSTSLRDKTLKLLWEGKWRGFLISAGTELVFTRGFQESLSDDEKNDNAISISATDTENGNIPVFPAKFGIQFQYST
+  best_structure_probability: 1.0
+  transmembrane_segments: 
+  - aaseq: SLGAEFWLGLVSLSPGCSTTL
+    stop: 252
+    start: 232
+    probability: 1.0
+  num_certain_transmembrane_segments: 1
+  num_found: 2
+=end
+
+  # should return a index
+  def to_index(io, index = {})
+    get_root_node_from_io(io) do |toppreds_n|
+
+      abort if toppreds_n.name != 'toppreds'
+      toppreds_n.find('child::toppred').each do |toppred_n|
+        att_hash = {}
+        sequence_n = toppred_n.find_first('child::sequence')
+        index[sequence_n['id']] = att_hash
+        att_hash[:aaseq] = sequence_n.content.gsub(/[\s\n]/,'')
+        abort if att_hash[:aaseq].size != sequence_n['size'].to_i
+        tmsummary_n = sequence_n.find_first('following-sibling::tmsummary')
+
+        num_found = tmsummary_n['segments'].to_i
+        att_hash[:num_found] = num_found
+        if num_found > 0
+
+          num_certain_transmembrane_segments = 0
+          num_putative_transmembrane_segments = 0
+          tmsummary_n.find('child::segment').each do |segment_n|
+            abort if segment_n.name != 'segment'
+            case segment_n['type']
+            when 'certain'
+              num_certain_transmembrane_segments += 1
+            else # putative
+              num_putative_transmembrane_segments += 1
+            end
+          end
+          att_hash[:num_putative_transmembrane_segments] = num_putative_transmembrane_segments
+          att_hash[:num_certain_transmembrane_segments] = num_certain_transmembrane_segments
+
+          topologies_n = tmsummary_n.next
+          abort if topologies_n.name != 'topologies'
+          # get the top probability topology:
+          top_prob_topology_n = topologies_n.find('child::topology').to_a.max {|a,b| a['prob'].to_f <=> b['prob'].to_f }
+          tmsegments = []
+          top_prob_topology_n.find('child::tmsegment').each do |tmsegment_n|
+            tmhash = {}
+            tmhash[:start] = tmsegment_n['start'].to_i
+            tmhash[:stop] = tmsegment_n['stop'].to_i
+            ## WARNING! it appears the probability is broken on xml output!!
+            tmhash[:probability] = tmsegment_n['prob'].to_f
+            tmsegments << tmhash
+          end
+          add_sequences_to_segments(tmsegments, att_hash[:aaseq])
+          att_hash[:transmembrane_segments] = tmsegments
+        end
+      end
+    end
+    index
+  end
+
+end
+
+class TopPred::Parser_Text
+  include TopPred::Parser
+
+
+  # returns a hash structure in this form: {identifier => {aaseq => String,
+  # num_found: Int, num_certain_transmembrane_segments => Int,
+  # num_putative_transmembrane_segments => Int, best_structure_probability =>
+  # Float, transmembrane_segments => [probability => Float, start => Int, stop
+  # => Int, aaseq => String] } }
+  def to_index(io, index={})
+    current_record = nil
+
+    io.each do |line|
+      if line =~ /^Sequence : (.*?) +\(/
+        current_identifier = $1.dup
+        index[current_identifier] = {}
+        current_record = index[current_identifier]
+        current_record[:aaseq] = read_aaseq(io)
+        read_segment_summary(io, current_record)
+      elsif line =~ /^HEADER\s+START\s+STOP/
+        top_struc = top_structure( read_structures(io) )
+        current_record[:best_structure_probability] = top_struc[:probability]
+        current_record[:transmembrane_segments] = top_struc[:tm]
+        add_sequences_to_segments(current_record[:transmembrane_segments], current_record[:aaseq])
+        segment_arrays_to_hashes(current_record[:transmembrane_segments])
+      end
+    end
+    index
+  end
+
+  private 
+
+  # returns a list of all structures given a filehandle starting just after
+  # the first "HEADER START STOP ..." line
+  def read_structures(fh)
+    structures = []
+    loop do
+      structures.push( read_structure(fh) )
+      break if fh.eof?
+      line = fh.readline
+      unless line =~ /^HEADER\s+START\s+STOP/
+        break
+      end
+    end
+    structures
+  end
+
+  # returns a hash with key :probability and key :tm contains an array of
+  # arrays: [prob(Float), start(Int), stop(Int)]
+  def read_structure(fh)
+    structure = {}
+    # READ the first line
+    line = fh.readline
+    structure[:probability] = line.split(/\s+/)[2].to_f
+    structure[:tm] = read_segments(fh)
+    structure
+  end
+
+  # returns an array of arrays of transmembrane segments: [prob(Float),
+  # start(Int), stop(Int)]
+  # returns after seeing '//'
+  def read_segments(fh)
+    segments = []
+    st = Regexp.escape('//') ; end_regex = /#{st}/
+    fh.each do |line|
+      if line =~ /^TRANSMEM/
+        (header, start, stop, len, prob) = line.split(/\s+/)[0,5]
+        segments << [prob.to_f, start.to_i, stop.to_i]
+      elsif line =~ end_regex
+        break
+      end
+    end
+    segments
+  end
+
+  # returns the top probability structure (first on tie)
+  def top_structure(list)
+    top_prob = list.first[:probability]
+    top_struc = list.first
+    list.each do |st|
+      if st[:probability] > top_prob 
+        top_struc = st
+        top_prob = st[:probability]
+      end
+    end
+    top_struc
+  end
+
+  def read_aaseq(fh)
+    aaseq = '' 
+    fh.each do |line|
+      line.chomp!
+      unless line =~ /[\w\*]/
+        break
+      end
+      aaseq << line 
+    end
+    aaseq
+  end
+
+  def segment_arrays_to_hashes(list)
+    list.map! do |ar|
+      { :probability => ar[0],
+      :start => ar[1],
+      :stop => ar[2],
+      :aaseq => ar[3],
+      }
+    end
+  end
+
+  # returns [certain, putative]
+  # expects first line to be a tm segment
+  def num_certain_putative(fh)
+    certain = 0
+    putative = 0
+    fh.each do |line|
+      certainty = line.chomp.split(/\s+/).last
+      if !certainty
+        break
+      else
+        certain += 1 if certainty == 'Certain'
+        putative += 1 if certainty == 'Putative'
+      end
+    end
+    [certain, putative]
+  end
+
+  def read_segment_summary(fh, rec)
+    fh.each do |line|
+      if line =~ /Found: (.*?) segments/
+        rec[:num_found] = $1.to_i
+        break if rec[:num_found] == 0
+      elsif line =~ /Helix\s+Begin/
+        (cert, putat) = num_certain_putative(fh) 
+        rec[:num_certain_transmembrane_segments] = cert
+        rec[:num_putative_transmembrane_segments] = putat
+        break
+      end
+    end
+  end
+end
+
+class TopPred::Parser_XML::LibXML < TopPred::Parser_XML::DOM
+  def get_root_node_from_io(io, &block)
+    # turn off warnings because this doesn't seem to work:
+    # XML::Parser.default_load_external_dtd = false
+    # (There is a warning about not finding DTD)
+    xml_parser_warnings = XML::Parser.default_warnings
+    XML::Parser.default_warnings = false
+    doc = XML::Parser.io(io).parse
+    root = doc.root
+    block.call(root)
+    # reset the warning level of XML::Parser:
+    XML::Parser.default_warnings = xml_parser_warnings
+  end
+end
+
+class TopPred::Parser_XML::AXML < TopPred::Parser_XML::DOM
+  def get_root_node_from_io(io, &block)
+    root = ::AXML.parse(io)
+    block.call(root)
+  end
+end
+

data/lib/transmem.rb

@@ -0,0 +1,157 @@
+
+# A transmemIndex is a hash that takes a fasta reference as key and returns
+# a structured hash containing the transmembrane information.
+module TransmemIndex
+  
+  # returns :toppred or :phobius
+  def self.filetype(file)
+    tp = nil
+    File.open(file) do |fh|
+      while (line = fh.gets)
+        case line
+        when /SEQENCE/
+          tp = :phobius 
+          break
+        when /    0  0 i/
+          tp = :phobius  # if they don't have the headers, 
+                         # this will pick it up if they have a 
+                         # single prot without tm or signal peptide.
+          break
+        when /Algorithm specific parameters/
+          tp = :toppred  # New text
+          break
+        when /<parameters>/
+          tp = :toppred  # XML
+          break
+        end
+      end
+    end
+    tp
+  end
+
+  def reference_to_key(reference)
+    # needs to be subclassed or written
+  end
+  
+  # right now accepts toppred.out files
+  # Phobius objects can use the fasta object to update their hash for methods
+  # like avg_overlap
+  def self.new(file, fasta=nil)
+    case x = filetype(file)
+    when :toppred
+      require 'transmem/toppred'
+      TopPred::Index.new(file)
+    when :phobius
+      require 'transmem/phobius'
+      # warn "WARNING: You have NO fasta object with Phobius based TransmemIndex! (which needs one to do proper indexing!)" unless fasta
+      Phobius::Index.new(file, fasta)
+    else 
+      raise ArgumentError, "#{x} filetype for #{file} not recognized!"
+    end
+  end
+
+  # returns a hash of key -> num certain transmembrane segments
+  def num_certain_index
+    hash = {}
+    self.each do |k,v|
+      hash[k] = v[:num_certain_transmembrane_segments] || 0
+    end
+    hash
+  end
+
+  # tp = :number or :fraction which is the fraction of the sequence size
+  # returns the average number of overlapping amino acids with transmembrane
+  # segments
+  # returns nil if there is no protein by that key
+  def avg_overlap(key, sequence, tp=:number)
+    if self.key? key
+      numbers = num_transmem_aa(self[key], sequence)
+      if numbers.size > 0
+        sum = 0
+        numbers.each {|num| sum += num}
+        avg_num = sum.to_f / numbers.size
+        # the one line way to do it
+        #avg_num = numbers.inject(0) {|memo,num| num + memo }.to_f / numbers.size
+        if tp == :fraction
+          avg_num / sequence.size
+          # this is the same as doing this:
+          #numbers.inject(0.0) {|memo,num| (num.to_f/seq_size + memo) } / numbers.size
+        else
+          avg_num
+        end
+      else
+        0.0
+      end
+    else  # what to do if the protein isn't there?? which happens on occasion
+      nil
+    end
+  end
+
+  # returns an array (usually length of 1) of the number of amino acids
+  # contained inside transmembrane spanning segments.
+  # assumes that tmhash has the key 'transmembrane_segments'
+  # if there are no transmembrane segments, returns empty array.
+  def num_transmem_aa(tmhash, sequence)
+    if tmhash.key? :transmembrane_segments
+      ranges = tmhash[:transmembrane_segments].map do |tmseg|
+        Range.new( tmseg[:start]-1, tmseg[:stop]-1 )
+      end
+      num_overlapping_chars(tmhash[:aaseq], ranges, sequence)
+    else
+      []
+    end
+  end
+
+  # returns an array of the number of overlapping sequences in substring with
+  # the substrings defined in start_stop_doublets within full_sequence
+  # start_stop_doublets should be 0 indexed!!!
+  # the span includes the 'stop' position i.e., full_sequence[start..stop]
+  def num_overlapping_chars(full_sequence, ranges, substring)
+    #start_positions = aaseq.enum_for(:scan, substring).map { $~.offset(0)[0]}
+    if ranges.size == 0
+      []
+      #full_sequence.enum_for(:scan, substring).map { 0 }
+    else
+      substring_ranges = []
+      pos = 0
+      slen = substring.size
+      while i=full_sequence.index(substring,pos)
+        substring_ranges << Range.new(i, i+slen-1)
+        pos = i + slen
+      end
+      # brute force way
+      last_tm_range = ranges.last.last
+      to_return = substring_ranges.map do |sb|
+        overlap = 0
+        # there's got to be a much simpler way to do this, but this does work...
+        ranges.each do |tm|
+          (frst, lst) = 
+            if tm.include?( sb.first )
+              [tm, sb]
+            elsif tm.include?( sb.last )
+              [sb, tm]
+            else
+              nil
+            end
+          if frst
+            if lst.last <= frst.last
+              overlap += (frst.last+1 - frst.first) - (lst.first - frst.first) - (frst.last - lst.last)
+            else 
+              overlap += (frst.last+1 - frst.first) - (lst.first - frst.first)
+            end
+          end
+        end
+        overlap
+      end
+    end
+  end
+
+
+end
+
+
+#substring_ranges = full_sequence.enum_for(:scan, substring).map do 
+#        (ofirst, olast) = $~.offset(0) 
+#        Range.new(ofirst, olast - 1)
+#      end
+

data/lib/validator/aa.rb

@@ -0,0 +1,135 @@
+require 'validator'  # I'm not sure why I need this declaration here when I include it in the following digestion_based declaration??? (but I get a name error if I don't)
+require 'validator/digestion_based'
+require 'fasta'
+require 'spec_id/aa_freqs'
+
+# Constraints on aaseq attribute of peptides (the bare amino acid sequence)
+# works by calculating amino acid frequencies in the fasta file used.
+class Validator::AA < Validator::DigestionBased
+  include Precision::Calculator
+
+  attr_accessor :constraint
+
+  # it is a false hit if the amino acid is located in the peptide
+  attr_accessor :false_if_found
+
+  # if given, the frequency of the amino acid is used to estimate the false to
+  # total ratio based on the pephits given for pephit_precision.
+  # see Validator::AA.calc_frequency to calculate a frequency
+  attr_accessor :frequency
+
+  DEFAULTS = Validator::DigestionBased::DEFAULTS.merge( {
+    :false_if_found => true,
+  } )
+
+  # returns tp, fp
+  def partition(peps)
+    (found, not_found) = peps.partition do |pep|
+      pep.aaseq.include?(@constraint)
+    end
+    if @false_if_found
+      [not_found, found] 
+    else
+      [found, not_found]
+    end
+  end
+
+  # takes a fasta object and sets the frequency based on constraint.
+  # constraint is one acceptable to initialize!
+  # returns self
+  def set_frequency(fasta_obj)
+    table = SpecID::AAFreqs.new.calculate_frequencies(fasta_obj)
+    @frequency = table[@constraint.to_sym]
+    self
+  end
+
+  # right now only accepts single amino acids as constraints (as a string,
+  # e.g. 'C', or symbol, e.g. :C)
+  # options:
+  #  :frequency OR :false_to_total_ratio should be used (NOT both)
+  #  :frequency => Float, if the frequency of the amino acid is known (see
+  #                Validator::AA.calc_frequency)
+  #  :false_to_total_ratio => if a true digestion was already performed (see
+  #                           Validator::AA.calc_false_to_total_ratio)
+  #  :false_if_found => it is a false positive if the amino acid is found.
+  #  :background => the background level of amino acid Float
+  def initialize(constraint, options={})
+    @constraint = constraint.to_s
+    opts = DEFAULTS.merge(options)
+    (@frequency, @false_to_total_ratio, @false_if_found, @background) = opts.values_at(:frequency, :false_to_total_ratio, :false_if_found, :background)
+  end
+
+  # if expected is 0 then will return precision = 1.0
+  def pephit_precision(peps)
+    if @frequency
+      (actual, expected) = at_least_one(@constraint, @frequency, peps.map {|v| v.aaseq })
+      if expected == 0.0
+        1.0
+      else
+        # what's this guy ?? good for??
+        fraction_of_expected = actual.to_f/expected
+        pephit_precision_from_actual_and_expected(actual, expected, peps.size, @background)
+      end
+    elsif @false_to_total_ratio
+      super(peps)
+    else
+      raise ArgumentError, "@frequency or @false_to_total_ratio must be defined!"
+    end
+  end
+
+  # returns (Actual(Int), Expected(Float)) based on how many peptides have at
+  # least one amino_acid, the frequency it is observed in background (then we
+  # can look at the size of each peptide and determine the likelihood of
+  # having the peptide with at least one amino acid).
+  # amino_acid should be a string (e.g., 'C')
+  def at_least_one(amino_acid, freq, amino_acid_seqs)
+    one_minus_freq = 1.0 - freq
+    probs = []
+    actual = 0
+    expected = 0.0
+    amino_acid_seqs.each do |aaseq|
+      expected += (1.0 - (one_minus_freq**aaseq.size))
+      if aaseq.include?(amino_acid)
+        actual += 1
+      end
+    end
+    [actual, expected] 
+  end
+
+
+  # given: (actual # with 'AA', expected # with 'AA', total#peptides,
+  # mean_fraction_of_cysteines_true)
+  #
+  # PepHit('AA') = Peptide containing at least one 'AA'
+  #   # expected PepHit('AA')                 # observed Bad Pep ('AA')
+  #   ----------------------- proportional_to ------------------------- 
+  #   # total PepHits                         # Total Bad PepHit
+  #
+  #  returns the precision
+  #  the background correction factor will not reduce the actual count of
+  #  peptides to < 0.  One can still get negative precision scores, however,
+  #  depending on the other variables.
+  #  background is the number of peptides with the amino acid in the purest
+  #  sample over the total number of peps.
+  #---
+  # this is thoroughly explained in my 2007_09 presentations (inkscape)
+  #+++
+  def pephit_precision_from_actual_and_expected(actual, expected, total_peps, background=DEFAULTS[:background]) 
+    actual = actual.to_f
+    @calculated_background = actual / total_peps
+    actual -= (total_peps * background)
+    # We were doing it compared to the number expected.. but this is more
+    # clear
+    # actual/false_hits = expected/total_peps_passing
+    # false_hits = (total_peps_passing * actual) / expected
+    if actual < 0.0 ; actual = 0.0 end
+    total_number_false = (actual * total_peps).to_f / expected
+    #fppr = total_number_false / total_peps
+    prec = (total_peps - total_number_false) / total_peps
+  end
+
+  def to_param_string
+    "aminoacid(bad_aa)=" + ["{constraint=#{@constraint}", "frequency=#{@frequency}", "bkg=#{(@background ? @background : 0.0) }}"].join(", ")
+  end
+end
+