mspire 0.4.9 → 0.5.0

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

@@ -1,218 +0,0 @@
-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(:bad_aa_est, opts)
-
-            op.val_opt(:tmm, opts)
-            op.val_opt(:fasta, 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) do |v| 
-              opts[:interactive] = 
-                if v
-                  v 
-                else
-                  true
-                end
-            end
-            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], opts[:postfilter], 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

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

@@ -1,148 +0,0 @@
-require 'yaml'
-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