mspire 0.2.4 → 0.3.0

data/lib/spec_id/precision/filter/cmdline.rb

@@ -0,0 +1,209 @@
+require 'validator/cmdline'
+require 'spec_id'
+
+
+module SpecID
+  module Precision
+    class Filter
+      class CmdlineParser
+
+       DEFAULTS = SpecID::Precision::Filter::FV_DEFAULTS.merge( { :output => [[:text_table,nil]], } )
+
+       
+        COMMAND_LINE = {
+          # SEQUEST
+          :xcorr1 => ["-1", "--xcorr1 N", Float, "xcorr at +1 charge  default: #{DEFAULTS[:sequest][:xcorr1]}"],
+          :xcorr2 => ["-2", "--xcorr2 N", Float, "xcorr at +2 charge  default: #{DEFAULTS[:sequest][:xcorr2]}"],
+          :xcorr3 => ["-3", "--xcorr3 N", Float, "xcorr at +3 charge  default: #{DEFAULTS[:sequest][:xcorr3]}"],
+
+          :deltacn => ["-d", "--deltacn N", Float, ">= deltacn          default: #{DEFAULTS[:sequest][:deltacn]}"],
+          :ppm => ["-p", "--ppm N", Float,     "<= ppm              default: #{DEFAULTS[:sequest][:ppm]}",
+                                               "if bioworks.xml, then ppm = deltamass*10^6/mass"],
+          :no_deltacnstar => ["--no_deltacnstar", "Do not pass deltacn of top hit with no 2nd hit",
+                                                  "(these are set at 1.1 by bioworks)"],
+
+          # OUTPUT
+          :proteins => ["--proteins", "includes proteins (and validation)"],
+          :output => ["-o", "--output format[:FILENAME]", "format to output filtering results.",
+                                                       "can be used multiple times", 
+                                                       ":FILENAME is the filename to use (defaults to STDOUT)",
+                                                       "valid formats are:",
+                                                       "    text_table      (default)",
+                                                       "    yaml",
+                                                       #"    protein_summary (need to implement)",
+                                                       #"    html_table      (need to implement)"
+                                               ],
+
+          # VALIDATION MODIFIERS:
+          :hits_separate => ["--hits_separate", "target/decoy hits are normally together when choosing",
+                                                "the top hit per peptide (in prefilter and postfilter)",
+                                                "in BOTH catenated and separate searches.  This flag",
+                                                "separates them when finding the top hit per scan.",
+                                                "[This option modifies behavior of --decoy options]"],
+
+          # OTHER:
+          :prefilter => ["--prefilter", "finds the top hit per file+scan+charge and removes",
+                                        "others.  Speeds up filtering with '--interactive'."],
+          :postfilter => ["--postfilter ARG", "ARG = top_per_scan | top_per_aaseq[_charge]",
+                                            "'top_per_scan' hashes on filename+scan.",
+                                            "'top_per_aaseq' hashes only on aaseq",
+                                            "'top_per_aaseq_charge' hashes on aaseq+charge."],
+          :top_hit_by => ["--top_hit_by ARG", "ARG = xcorr | probability    (xcorr default)"],
+
+
+
+          :interactive => ["-i", "--interactive [FILENAME]", "interactive filtering",
+                                                             "FILENAME given, then the interactive commands are",
+                                                             "read out of that file.  NOTE: The flag without the",
+                                                             "filename must not be placed in front of an input",
+                                                             "file argument!  e.g., -i bioworks.xml # -> bad!",
+                                                             "e.g., bioworks.xml -i # -> ok!"],
+
+          :interactive_verbose => ["--interactive_verbose", "give help and hints in interactive mode"],
+
+        }.merge( Validator::Cmdline::COMMAND_LINE )
+
+
+        # returns (spec_id_obj, options, option_parser_obj)
+        def parse(args)
+          opts = {}
+          opts[:output] = []
+          @out_used = false
+          opts[:sequest] = {}
+          opts[:validators] = []
+          # defaults
+
+          option_parser = OptionParser.new do |op|
+            def op.opt(arg, &block)
+              on(*COMMAND_LINE[arg], &block)
+            end
+
+            def op.val_opt(arg, opts)
+              on(*COMMAND_LINE[arg]) {|ar| Validator::Cmdline::PrepArgs[arg].call(ar, opts) }
+            end
+
+            def op.exact_opt(opts, arg)
+              on(*COMMAND_LINE[arg]) {|v| opts[arg] = v}
+            end
+
+            op.banner = "USAGE: #{File.basename($0)} [OPTS] <bioworks.xml | bioworks.srg | .srf ....srf>"
+            op.separator ""
+            op.separator "    EXPECTS: the multiconsensus XML export of Bioworks 3.X (bioworks.xml) -or- *.srf files"
+            op.separator "             grouped together (bioworks.srg) [type 'srf_group.rb' at the cmd line]"
+
+            op.separator "             multiple .srf files may also be entered."
+            op.separator "    RETURNS: the number of peptides/proteins ID'd at given thresholds with"
+            op.separator "             (optional) validation of the results."
+            op.separator ""
+
+            #op.separator("** 'dcn*' is the number of peptides with deltacn == 1.1")
+            #op.separator("   (these are peptides who are the only hit with xcorr > 0)")
+            op.separator "SEQUEST OPTIONS: "
+            op.exact_opt(opts[:sequest], :xcorr1)
+            op.exact_opt(opts[:sequest], :xcorr2)
+            op.exact_opt(opts[:sequest], :xcorr3)
+            op.exact_opt(opts[:sequest], :deltacn)
+            op.exact_opt(opts[:sequest], :ppm)
+            op.opt(:no_deltacnstar)     {|v| opts[:sequest][:include_deltacnstar] = false} 
+            op.separator ""
+            op.separator "OUTPUT OPTIONS: "
+            op.opt(:proteins) {|v| opts[:proteins] = true }
+            op.opt(:output) do |output|
+              # copied from rspec:
+              # This funky regexp checks whether we have a FILE_NAME or not
+              where = nil
+              if (output =~ /([a-zA-Z_]+(?:::[a-zA-Z_]+)*):?(.*)/) && ($2 != '')
+                output = $1
+                where = $2
+              else
+                raise "When using several --output options only one of them can be without a file" if @out_used
+                @out_used = true
+              end
+              opts[:output] << [output, where]
+            end
+
+            op.separator ""
+            op.separator "VALIDATION OPTIONS: "
+            op.separator "   each option will calculate the precision"
+            op.separator ""
+
+            op.val_opt(:decoy, opts)
+            op.val_opt(:digestion, opts)
+            op.val_opt(:bias, opts)
+            op.val_opt(:bad_aa, opts)
+
+            op.val_opt(:tmm, opts)
+            op.val_opt(:tps, opts)
+
+            op.separator ""
+            op.separator "VALIDATION MODIFIERS: "
+            op.val_opt(:false_on_tie, opts)  # sets opts[:ties] = false
+
+            op.opt(:hits_separate) { opts[:hits_together] = false } # :top_hits_together
+
+            op.separator ""
+            op.separator "OTHER OPTIONS: "
+            op.opt(:interactive) {|v| opts[:interactive] = v }
+            op.opt(:interactive_verbose) {|v| opts[:interactive_verbose] = v }
+            
+            op.opt(:top_hit_by) {|v| opts[:top_hit_by] = v.to_sym}
+            op.opt(:postfilter) {|v| opts[:postfilter] = v.to_sym}
+            op.opt(:prefilter) {|v| opts[:prefilter] = true }
+
+
+            #op.on("--yaml", "spits out yaml-ized data") {|v| opts[:tabulate = v }
+            #op.on("--combined_score", "shows the combined score") {|v| opts[:combined_score = v }
+            #op.on("--marshal", "will write marshaled data or read existing") {|v| opts[:marshal = v }
+            #op.on("--log <file>", "also writes all output to file") {|v| opts[:log = v }
+            ### NEED TO IMPLEMENT THIS:
+            ##op.on("--protein_summary", "writes passing proteins to .summary.html files") {|v| opts[:protein_summary = v }
+            #op.on("-z", "--occams_razor", "will show minimal set of proteins") {|v| opts[:occams_razor = v }
+
+          end
+          option_parser.parse!(args)
+
+          # prepare interactive object if necessary:
+          if v = opts[:interactive]
+            klass = SpecID::Precision::Filter::Interactive
+            if v.is_a? String
+              opts[:interactive] = klass.new(v, opts[:interactive_verbose])
+            else
+              opts[:interactive] = klass.new(nil, opts[:interactive_verbose])
+            end
+          end
+
+
+          opts[:sequest] = DEFAULTS[:sequest].merge(opts[:sequest])
+
+          # prepare validators
+
+          if args.size > 0
+            spec_id_obj = 
+              if args[0] =~ /\.srf$/i
+                ::SpecID.new(args)
+              else
+                ::SpecID.new(args[0])
+              end
+            if opts[:ties] == nil   # will be nil or false
+              opts[:ties] = Validator::Cmdline::DEFAULTS[:ties]
+            end
+            opts[:validators] = Validator::Cmdline.prepare_validators(opts, !opts[:ties], opts[:interactive], spec_id_obj)
+
+            if opts[:output].size == 0
+              opts[:output] = DEFAULTS[:output]
+            end
+          else
+            spec_id_obj = nil
+          end
+
+          [spec_id_obj, opts, option_parser]
+        end # parse
+      end # CmdlineParser
+    end # Filter
+  end # Precision
+end # SpecID
+
+
+
+
+

data/lib/spec_id/precision/filter/interactive.rb

@@ -0,0 +1,134 @@
+
+module SpecID ; end
+module SpecID::Precision ; end
+
+class SpecID::Precision::Filter
+  class Interactive
+    attr_accessor :file
+    attr_accessor :verbose
+
+    # the file contains the interactive commands
+    def initialize(file=nil, verbose=false)
+      @verbose = verbose
+      if file
+        @file = file
+        @lines = IO.readlines(file)
+      else
+        @lines = nil
+      end
+    end
+
+    def passing(opts, answer)
+      puts "****************************************************" if @verbose
+    end
+    # takes opts and modifies the keys in question, or returns nil
+    # shortcut map takes each proper key and designates a shortcut (if any)
+
+    def filter_args(opts_to_change, changing_keys, shortcut_map, casting_map)
+      shortcut_order = changing_keys.map {|k| shortcut_map[k] }
+      casting_array = changing_keys.map {|k| casting_map[k] }
+      return_val = true
+      reply = nil
+      base_args = opts_to_change.values_at( *changing_keys )
+      #b = base_args
+      current_values = changing_keys.map {|v| "#{shortcut_map[v]}:#{opts_to_change[v]}" }
+      out(current_values.join(" ")) if @verbose
+      #out "#{b[0]} #{b[1]} #{b[2]} dcn:#{b[3]} ppm:#{b[4]}"
+      loop do
+        reply = 
+          if @lines
+            if @lines.size > 0
+              @lines.shift.chomp
+            else
+              'q'
+            end
+          else
+            gets.chomp
+          end
+        answer = prep_reply(reply, base_args, shortcut_order, casting_array)
+        if answer == false
+          out(interactive_help(changing_keys, shortcut_map)) if @verbose
+        elsif answer == nil
+          return nil
+        else
+          answer.zip(changing_keys) do |newval,changing_key|
+            opts_to_change[changing_key] = newval
+          end
+          return_val = true
+          break
+        end
+      end
+      return_val
+    end
+
+    def out(string)
+      puts string
+    end
+
+    def interactive_help(changing_keys, shortcut_map)
+      shortcuts = changing_keys.map {|v| shortcut_map[v] }
+      as_array = shortcuts.map {|v| "<#{v}>" }
+      as_hash = shortcuts.map {|v| "#{v}:<#{v}>" }
+      string = []
+      string << "******************************************************************************"
+      string << "INTERACTIVE FILTERING HELP:"
+      string << "enter as an array of values    : #{as_array.join(' ')}"
+      string << "or as keys and values          : #{as_hash.join(' ')}"
+      string << "or some of the keys and values : #{as_hash.last}"
+      if changing_keys.size >= 3
+        string << "or mix array and keys/values   : #{as_array[0]} #{as_array[1]} #{as_hash.last}"
+      end
+      string << "etc..."
+      string << "<enter> to (re)run current values"
+      string << "'q' to quit"
+      string << "******************************************************************************"
+      string.join("\n")
+    end
+
+    # assumes its already chomped
+    # updates the 5 globals
+    # returns nil if 'q'
+    def prep_reply(reply, base, shortcut_order, casting_array)
+      if reply == 'q' 
+        return nil
+      end
+      if reply =~ /^\s*$/
+        base
+      elsif reply
+        arr = reply.split(/\s+/)
+        to_change_ar = []
+        to_change_hash = {}
+        arr.each do |it|
+          if it.include? ':'
+            (k,v) = it.split(':')
+            to_change_hash[k] = v
+          else
+            to_change_ar << it
+          end
+        end
+        to_change_ar.each_with_index do |tc,i|
+            base[i] = tc
+        end
+        to_change_hash.each do |k,v|
+          index = shortcut_order.index(k)
+          if index.nil?
+            out("BAD ARG: #{k}:#{v}") if @verbose
+          end
+          base[index] = v
+        end
+        base.zip(casting_array).map do |v,cast_proc| 
+          begin
+            cast_proc.call(v) 
+          rescue NoMethodError
+            out "BAD ARG: #{tc}" if @verbose
+            return false
+          end
+        end
+      else
+        false
+      end
+    end
+
+  end
+end
+

data/lib/spec_id/precision/filter/output.rb

@@ -0,0 +1,147 @@
+require 'table'
+require 'spec_id/precision/output'
+
+module SpecID ; end
+module SpecID::Precision ; end
+class SpecID::Precision::Filter ; end
+
+class SpecID::Precision::Filter::Output 
+  include SpecID::Precision::Output
+  
+  ProtPrecAbbr = {
+    :normal => 'nrm',
+    :normal_stdev => 'nrm_std',
+    :worst => 'worst',
+  }
+
+  GTE = '>='
+  LTE = '<='
+  MSial_operator = {
+    'xcorr1' => GTE,
+    'xcorr2' => GTE,
+    'xcorr3' => GTE,
+    'deltacn' => GTE,
+    'ppm' => LTE,
+  }
+
+  # takes a hash {:normal => x, :normal_stdev => y :worst => z }
+  # and returns a string
+  def protein_precision_to_s(hash)
+    "#{hash[:worst]}--#{hash[:normal]}+/-#{hash[:normal_stdev]}"
+  end
+
+  #      num tps tmm badAA decoy
+  # pep
+  # prot  
+  #
+  def params_as_string(params_hash)
+    hash = SpecID::Precision::Output.symbol_keys_to_string(params_hash)
+    cleanup_params_hash(hash)
+    hash_as_string(hash)
+  end
+
+  def text_table(fh, answer)
+    col_headings = ['num']
+    if answer[:params][:validators]
+      val_strings = answer[:params][:validators].map do |val|
+        Validator::Validator_to_string[val.class.to_s]
+      end
+      col_headings.push( *val_strings )
+    end
+
+    data_rows = []
+    # push on the peptide row
+    row_headings = ['peps']
+    pep_row = []
+    pep_row << answer[:pephits].size
+    if answer[:params][:validators]
+      answer[:params][:validators].zip( answer[:pephits_precision] ) do |val, precision|
+        pep_row << precision
+      end
+    end
+    data_rows << pep_row
+
+    # push on the protein row
+    if answer[:prothits]
+      [:worst, :normal, :normal_stdev].each do |guy|
+        prot_row = []
+        row_headings << "prots(#{ProtPrecAbbr[guy]})"
+        if guy == :worst
+          prot_row << answer[:prothits].size 
+        else
+          prot_row << '"'
+        end
+        answer[:prothits_precision].each do |precision|
+          prot_row.push(precision[guy])
+        end
+        data_rows << prot_row
+      end
+    end
+    params_string = params_as_string(answer[:params])
+    table = Table.new( data_rows, row_headings, col_headings )
+    fh.puts params_string
+    fh.puts ""
+    fh.puts( table.to_formatted_string )
+    fh.puts ""
+  end
+  
+  def yaml(fh, answer)
+    final_output = { :params => answer[:params].dup }
+    #"PEPHITS"
+    #answer[:pephits]
+    final_output[:pephits] = answer[:pephits].size 
+    if answer[:prothits]
+      final_output[:prothits_precision] = answer[:params][:validators].zip( answer[:prothits_precision] ).map do |val, precision|
+        {'validator' => Validator::Validator_to_string[val.class.to_s], 'values' => precision }
+      end
+      final_output[:prothits] = answer[:prothits].size 
+
+      #final_output[:prothits_precision] = {} if answer[:prothits_precision]
+      #final_output[:prothits] = answer[:prothits].size 
+      #answer[:params][:validators].zip( answer[:prothits_precision] ) do |val, precision|
+      #  final_output[:prothits_precision][Validator::Validator_to_string[val.class.to_s]] = precision
+      #end
+    end
+    final_output[:pephits_precision] = answer[:params][:validators].zip( answer[:pephits_precision] ).map do |val, precision|
+      { 'validator' => Validator::Validator_to_string[val.class.to_s], 'value' => precision }
+    end
+    final_output[:pephits] = answer[:pephits].size 
+    final_output_as_strings = SpecID::Precision::Output.symbol_keys_to_string(final_output)
+    cleanup_params_hash(final_output_as_strings['params'])
+    fh.print(final_output_as_strings.to_yaml )
+  end
+
+
+  # returns nil
+  def cleanup_params_hash(hash)
+    ################################
+    # OUTPUT
+    ################################
+    hash['output'] = hash['output'].map do |output|
+      if output[1] == nil
+        output[1] = 'STDOUT'
+      end
+      output.join(" => ")
+    end
+    %w(postfilter top_hit_by).each do |st|
+      hash[st] = hash[st].to_s
+    end
+    if hash['interactive']
+      if file = hash['interactive'].file
+        hash['interactive'] = file
+      else
+        hash['interactive'] = true
+      end
+    end
+    if hash['decoy']
+      if hash['decoy']['regexp']
+        hash['decoy']['regexp'] = hash['decoy']['regexp'].inspect
+      end
+    end
+    if x = hash['validators']
+      hash['validators'] = Validator.sensible_validator_hashes(x)
+    end
+    nil
+  end
+
+end