ms-ident 0.0.17 → 0.0.18

data/Rakefile

@@ -1,12 +1,4 @@
 require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
 require 'rake'
 
 require 'jeweler'
@@ -20,10 +12,13 @@ Jeweler::Tasks.new do |gem|
   gem.email = "jtprince@gmail.com"
   gem.authors = ["John T. Prince"]
   gem.rubyforge_project = 'mspire'
-  # Include your dependencies below. Runtime dependencies are required when using your gem,
-  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
-  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
-  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+  gem.add_runtime_dependency 'nokogiri'
+  gem.add_runtime_dependency 'ms-core', ">=0.0.12"
+  gem.add_runtime_dependency 'ms-in_silico'
+  gem.add_runtime_dependency 'andand'
+  gem.add_development_dependency 'spec-more'
+  gem.add_development_dependency 'jeweler'
+  #gem.add_development_dependency 'ms-testdata'
 end
 Jeweler::RubygemsDotOrgTasks.new
 

data/VERSION

@@ -1 +1 @@
-0.0.17
+0.0.18

data/lib/ms/ident/peptide/db.rb

@@ -0,0 +1,224 @@
+require 'ms/in_silico/digester'
+require 'ms/fasta'
+
+module Ms ; end
+module Ms::Ident ; end
+module Ms::Ident::Peptide ; end
+
+module Ms::Ident::Peptide::Db 
+  MAX_NUM_AA_EXPANSION = 3
+
+  # the twenty standard amino acids
+  STANDARD_AA = %w(A C D E F G H I K L M N P Q R S T V W Y)
+
+  DEFAULT_PEPTIDE_CENTRIC_DB = {:missed_cleavages => 2, :min_length => 4, :enzyme => Ms::InSilico::Digester::TRYPSIN, :id_regexp => nil, :remove_digestion_file => true, :cleave_initiator_methionine => true, :expand_aa => {'X' => STANDARD_AA}}
+
+  PROTEIN_DELIMITER = "\t"
+  KEY_VALUE_DELIMITER = ": "
+
+  def self.cmdline(argv)
+
+    opt = {
+      :remove_digestion_file => true,
+      :enzyme => Ms::InSilico::Digester::TRYPSIN
+    }
+    opts = OptionParser.new do |op|
+      op.banner = "usage: #{File.basename($0)} <file>.fasta ..."
+      op.separator "output: "
+      op.separator "    <file>.msd_clvg<missed_cleavages>.min_aaseq<min_length>.yml"
+      op.separator "format:"
+      op.separator "    PEPTIDE: ID1<tab>ID2<tab>ID3..."
+      op.separator ""    
+      op.separator "    Initiator Methionines - by default, will generate two peptides"
+      op.separator "    for any peptide found at the N-termini starting with 'M'"
+      op.separator "    (i.e., one with and one without the leading methionine)"
+      op.separator ""
+      op.on("--missed-cleavages <#{opt[:missed_cleavages]}>", Integer, "max num of missed cleavages") {|v| opt[:missed_cleavages] = v }
+      op.on("--min-length <#{opt[:min_length]}>", Integer, "the minimum peptide aaseq length") {|v| opt[:min_length] = v }
+      op.on("--no-cleaved-methionine", "does not cleave off initiator methionine") { opt[:cleave_initiator_methionine] = false }
+      op.on("--no-expand-x", "don't enumerate aa 'X' possibilities") { opt[:expand_aa] = nil }
+      op.on("-e", "--enzyme <name>", "enzyme for digestion") {|v| opt[:enzyme] = Ms::Insilico::Digester.const_get(v.upcase) }
+      op.on("--list-enzymes", "lists approved enzymes and exits") do
+        puts Ms::InSilico::Digester::ENZYMES.keys.join("\n")
+        exit
+      end
+    end
+
+    opts.parse!(argv)
+
+    if argv.size == 0
+      puts opts || exit
+    end
+
+    argv.map do |file|
+      Ms::Ident::Peptide::Db.peptide_centric_db(file, opt)
+    end
+  end
+
+  # writes a new file with the added 'min_aaseq<Integer>'
+  # creates a temporary digestion file that contains all peptides digesting
+  # with certain missed_cleavages (i.e., min_seq_length is not applied to
+  # this file but on the final peptide centric db)
+  # returns the full name of the written file.
+  def self.peptide_centric_db(fasta_file, opts={})
+    opts = DEFAULT_PEPTIDE_CENTRIC_DB.merge(opts)
+
+    (missed_cleavages, min_length, enzyme, id_regexp, remove_digestion_file, cleave_initiator_methionine, expand_aa) = opts.values_at(:missed_cleavages, :min_length, :enzyme, :id_regexp, :remove_digestion_file, :cleave_initiator_methionine, :expand_aa) 
+    start_time = Time.now
+    print "Digesting #{fasta_file} ..." if $VERBOSE
+
+    if expand_aa
+      letters_to_expand_re = Regexp.new("[" << Regexp.escape(expand_aa.keys.join) << "]")
+    end
+
+    base = fasta_file.chomp(File.extname(fasta_file))
+    digestion_file = base + ".msd_clvg#{missed_cleavages}.peptides"
+    File.open(digestion_file, "w") do |fh|
+      Ms::Fasta.open(fasta_file) do |fasta|
+        fasta.each do |prot|
+          peptides = enzyme.digest(prot.sequence, missed_cleavages)
+          if (cleave_initiator_methionine && (prot.sequence[0,1] == "M"))
+            m_peps = []
+            init_methionine_peps = []
+            peptides.each do |pep|
+              # if the peptide is at the beginning of the protein sequence
+              if prot.sequence[0,pep.size] == pep
+                m_peps << pep[1..-1]
+              end
+            end
+            peptides.push(*m_peps)
+          end
+          if expand_aa
+            peptides = peptides.map do |pep|
+              if pep =~ letters_to_expand_re
+                expand_peptides(pep, expand_aa)
+              else
+                pep
+              end
+            end.flatten
+          end
+          fh.puts( prot.header.split(/\s+/).first + "\t" + peptides.join(" ") )
+        end
+      end
+    end
+    puts "#{Time.now - start_time} sec" if $VERBOSE
+
+
+    start_time = Time.now
+    print "Organizing raw digestion #{digestion_file} ..." if $VERBOSE
+
+    hash = Hash.new {|h,k| h[k] = [] }
+    ::IO.foreach(digestion_file) do |line|
+      (prot, *peps) = line.chomp!.split(/\s+/)
+      # prot is something like this: "sp|P31946|1433B_HUMAN" in uniprot 
+      peps.each do |pep|
+        if pep.size >= min_length
+          hash[pep] << prot
+        end
+      end
+    end
+    puts "#{Time.now - start_time} sec" if $VERBOSE
+
+    base = digestion_file.chomp(File.extname(digestion_file))
+    final_outfile = base + ".min_aaseq#{min_length}" + ".yml"
+
+    start_time = Time.now
+    print "Writing results to #{} ..." if $VERBOSE
+
+    File.open(final_outfile, 'w') do |out|
+      hash.each do |k,v|
+        out.puts( [k, v.join(PROTEIN_DELIMITER)].join(KEY_VALUE_DELIMITER) )
+      end
+    end
+    puts "#{Time.now - start_time} sec" if $VERBOSE
+
+    if remove_digestion_file
+      File.unlink(digestion_file)
+    end
+    File.expand_path(final_outfile)
+  end
+
+  # does combinatorial expansion of all letters requesting it.
+  # expand_aa is hash like: {'X'=>STANDARD_AA}
+  # returns nil if there are more than MAX_NUM_AA_EXPANSION amino acids to
+  # be expanded
+  # returns an empty array if there is no expansion
+  def self.expand_peptides(peptide, expand_aa)
+    letters_in_order = expand_aa.keys.sort
+    index_and_key = []
+    peptide.split('').each_with_index do |char,i| 
+      if let_index = letters_in_order.index(char) 
+        index_and_key << [i, letters_in_order[let_index]]
+      end
+    end
+    if index_and_key.size > MAX_NUM_AA_EXPANSION
+      return nil
+    end
+    to_expand = [peptide]
+    index_and_key.each do |i,letter|
+      new_peps = []
+      while current_pep = to_expand.shift do
+        new_peps << expand_aa[letter].map {|v| dp = current_pep.dup ; dp[i] = v ; dp }
+      end
+      to_expand = new_peps.flatten
+    end
+    to_expand
+  end
+
+  # an object for on disk retrieval of db entries
+  # proteins are returned as an array.
+  # behaves much like a hash once it is opened.
+  class IO
+    include Enumerable
+    def self.open(filename, &block)
+      File.open(filename) do |io|
+        block.call(self.new(io))
+      end
+    end
+
+    attr_accessor :io
+    attr_accessor :index
+
+    def initialize(io)
+      @io = io
+      @index = {}
+      re = /^(\w+)#{Regexp.escape(KEY_VALUE_DELIMITER)}/
+        prev_io_pos = io.pos
+      triplets = io.each_line.map do |line|
+        key = re.match(line)[1]
+        [key, prev_io_pos + key.bytesize+KEY_VALUE_DELIMITER.bytesize, prev_io_pos=io.pos]
+      end
+      triplets.each do |key, start, end_pos|
+        @index[key] = [start, end_pos-start]
+      end
+    end
+    # returns an array of proteins for the given key (peptide aaseq)
+    def [](key)
+      (start, length) = @index[key]
+      @io.seek(start)
+      string = @io.read(length)
+      string.chomp!
+      string.split("\t")
+    end
+
+    # number of entries
+    def size ; @index.size end
+    alias_method :length, :size
+
+    def keys
+      @index.keys
+    end
+
+    # all the protein lists
+    def values
+      keys.map {|key| self[key] }
+    end
+
+    # yields a pair of aaseq and protein array
+    def each(&block)
+      @index.each do |key, start_length|
+        block.call([key, self[key]])
+      end
+    end
+  end
+end

data/lib/ms/ident/peptide.rb

@@ -1,4 +1,3 @@
-
 module Ms ; end
 module Ms::Ident ; end
 

data/lib/ms/ident/protein.rb

@@ -1,7 +1,8 @@
-
 module Ms ; end
 module Ms::Ident ; end
 
+require 'set'
+
 module Ms::Ident::Protein
   
   class << self
@@ -13,5 +14,57 @@ module Ms::Ident::Protein
     reference.split(/[\s\r]/)[0]
   end
 
+  PRIORITIZE_PROTEINS = lambda do |protein_group_and_peptide_hits|
+    peptide_hits = protein_group_and_peptide_hits.last
+    num_uniq_aaseqs = peptide_hits.map {|hit| hit.aaseq }.uniq.size
+    num_uniq_aaseqs_at_z = peptide_hits.map {|hit| [hit.aaseq, hit.charge] }.uniq.size
+    [num_uniq_aaseqs, num_uniq_aaseqs_at_z, peptide_hits.size]
+  end
+
+
+  module_function
+  # greedy algorithm to map a set of peptide_hits to protein groups.  each
+  # peptide hit should respond to :aaseq, :charge, :proteins if a block is
+  # given, yields a single argument: a doublet of protein_group and peptide
+  # set.  It expects a metric or array to sort by for creating greedy protein
+  # groups (the greediest proteins should sort to the back of the array).  if
+  # no block is given, the groups are sorted by [# uniq aaseqs, # uniq
+  # aaseq+charge, # peptide_hits] (see PRIORITIZE_PROTEINS).  Sets of
+  # peptide_hits and the objects returned by peptide_hit#proteins are used as
+  # hash keys.  As long as each peptide hit has a unique signature (like an
+  # id) then any object will work.  If they are Struct objects, you might
+  # consider redefining the #hash method to be object_id for performance and
+  # accuracy.
+  def peptide_hits_to_protein_groups(peptide_hits, &sort_by)
+    sort_by ||= PRIORITIZE_PROTEINS
+    # note to self: I wrote this in 2011, so I think I know what I'm doing now
+    protein_to_peptides = Hash.new {|h,k| h[k] = Set.new }
+    peptide_hits.each do |peptide_hit|
+      peptide_hit.proteins.each do |protein|
+        protein_to_peptides[protein] << peptide_hit
+      end
+    end
+    peptides_to_protein_group = Hash.new {|h,k| h[k] = [] }
+    protein_to_peptides.each do |protein, peptide_set|
+      peptides_to_protein_group[peptide_set] << protein
+    end
+    protein_group_to_peptides = peptides_to_protein_group.invert
+    greedy_first = protein_group_to_peptides.sort_by(&sort_by).reverse
+    accounted_for = Set.new
+    surviving_protein_groups = []
+    # we are discarding the subsumed sets, but we could get them with
+    # partition
+    greedy_first.select do |group, peptide_set|
+      has_an_unaccounted_peptide = false
+      peptide_set.each do |peptide_hit| 
+        unless accounted_for.include?(peptide_hit) 
+          has_an_unaccounted_peptide = true
+          accounted_for.add(peptide_hit)
+        end
+      end
+      has_an_unaccounted_peptide
+    end
+  end
+
 end
 

data/spec/ms/ident/peptide/db_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+require 'yaml'
+path = 'ms/ident/peptide/db'
+require path 
+
+module Kernel
+ 
+  def capture_stdout
+    out = StringIO.new
+    $stdout = out
+    yield
+    out.rewind
+    return out.read
+  ensure
+    $stdout = STDOUT
+  end
+ 
+end
+
+FASTA_FILE = [TESTFILES, path, 'uni_11_sp_tr.fasta'].join('/')
+
+describe 'amino acid expansion' do
+
+  it 'can expand out wildcard amino acid combinations' do
+    array = Ms::Ident::Peptide::Db.expand_peptides('ALXX', 'X' =>  %w(* % &), 'L' => %w(P Q) )
+    array.sort.is %w(AP** AP*% AP*& AP%* AP%% AP%& AP&* AP&% AP&& AQ** AQ*% AQ*& AQ%* AQ%% AQ%& AQ&* AQ&% AQ&&).sort
+  end
+
+  it 'will not expand explosive combinations (>MAX_NUM_AA_EXPANSION)' do
+    # this is from real data
+    worst_case = 'LTLLRPEKHEAATGVDTICTHRVDPIGPGLXXEXLYWELSXLTXXIXELGPYTLDR'
+    Ms::Ident::Peptide::Db.expand_peptides(worst_case, 'X' =>  %w(* % &)).nil?.is true
+  end
+
+  it 'returns the peptide in the array if no expansion' do
+    array = Ms::Ident::Peptide::Db.expand_peptides('ZZZZZ', 'X' =>  %w(* % &), 'L' => %w(P Q) )
+    array.is ['ZZZZZ']
+  end
+
+end
+
+describe 'creating a peptide centric database' do
+
+  before do
+    
+    #@output_file = [TESTFILES, path, 'uni_11_sp_tr.'].join('/')
+    @output_file = [TESTFILES, path, "uni_11_sp_tr.msd_clvg2.min_aaseq4.yml"].join('/')
+  end
+
+  it 'converts a fasta file into peptide centric db' do
+    output_files = Ms::Ident::Peptide::Db.cmdline([FASTA_FILE])
+    output_files.first.is File.expand_path(@output_file)
+    ok File.exist?(@output_file)
+    hash = {}
+    YAML.load_file(@output_file).each do |k,v|
+      hash[k] = v.split("\t")
+    end
+    sorted = hash.sort
+    # these are merely frozen, not perfectly defined
+    sorted.first.is ["AAFDDAIAELDTLSEESYK", ["sp|P62258|1433E_HUMAN"]]
+    sorted.last.is ["YWCRLGPPRWICQTIVSTNQYTHHR", ["tr|D2KTA8|D2KTA8_HUMAN"]]
+    sorted.size.is 728
+    File.unlink(@output_file)
+  end
+
+  it 'lists approved enzymes and exits' do
+    output = capture_stdout do
+      begin
+        Ms::Ident::Peptide::Db.cmdline(['--list-enzymes'])
+      rescue SystemExit
+        1.is 1 # we exited
+      end
+    end
+    lines = output.split("\n")
+    ok lines.include?("trypsin")
+    ok lines.include?("chymotrypsin")
+  end
+end
+
+describe 'reading a peptide centric database' do
+  outfiles = Ms::Ident::Peptide::Db.cmdline([FASTA_FILE])
+  @outfile = outfiles.first
+
+  it 'reads the file on disk with random access or is enumerable' do
+    Ms::Ident::Peptide::Db::IO.open(@outfile) do |io|
+      io["AVTEQGHELSNEER"].enums %w(sp|P31946|1433B_HUMAN	sp|P31946-2|1433B_HUMAN)
+      io["VRAAR"].enums ["tr|D3DX18|D3DX18_HUMAN"]
+      io.each_with_index do |key_prots, i|
+        key_prots.first.isa String
+        key_prots.last.isa Array
+      end
+    end
+  end
+end

data/spec/ms/ident/protein_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+require 'ms/ident/protein'
+
+PeptideHit = Struct.new(:aaseq, :charge, :proteins) do
+  def inspect # easier to read output
+    "<PeptideHit aaseq=#{self.aaseq} charge=#{self.charge} proteins(ids)=#{self.proteins.map(&:id).join(',')}>"
+  end
+  def hash ; self.object_id end
+end
+ProteinHit = Struct.new(:id) do
+  def inspect # easier to read output
+    "<Prt #{self.id}>"
+  end
+  def hash ; self.object_id end
+end
+
+describe 'creating minimal protein groups from peptide hits' do
+  before do
+    @pep_hits = [ ['AABBCCDD', 2], 
+      ['BBCC', 2],
+      ['DDEEFFGG', 2],
+      ['DDEEFFGG', 3],
+      ['HIYA', 2],
+    ].map {|ar| PeptideHit.new(ar[0], ar[1], []) }
+    @prot_hits_hash = { 
+      'big_guy' => @pep_hits,
+      'little_guy' => [@pep_hits.last],
+      'medium_guy1' => @pep_hits[0,4],
+      'medium_guy2' => @pep_hits[0,4],
+      'subsumed_by_medium' => @pep_hits[2,2],
+    }
+    @prot_hits = @prot_hits_hash.keys.map {|id| ProteinHit.new(id) }
+  end
+
+  it 'is a greedy algorithm' do
+    @prot_hits.each {|prthit| @prot_hits_hash[prthit.id].each {|pep| pep.proteins << prthit } }
+    # big_guy has all the peptides, so it takes them all
+    reply = Ms::Ident::Protein.peptide_hits_to_protein_groups(@pep_hits)
+    reply.first.size.is 2 # the group and the peptide set
+    reply.first.first.size.is 1 # the group
+    reply.first.first.first.id.is 'big_guy'
+  end
+
+  it 'removes proteins accounted for only as little pieces of larger proteins' do
+    @prot_hits[1..-1].each {|prthit| @prot_hits_hash[prthit.id].each {|pep| pep.proteins << prthit } }
+    reply = Ms::Ident::Protein.peptide_hits_to_protein_groups(@pep_hits)
+    # no subsumed_by_medium
+    reply.map(&:first).any? {|protein_list| protein_list.any? {|v| v.id == 'subsumed_by_medium' }}.is false
+  end
+
+  it 'allows alternate sorting algorithms for greediness' do
+    @prot_hits.each {|prthit| @prot_hits_hash[prthit.id].each {|pep| pep.proteins << prthit } }
+    reply = Ms::Ident::Protein.peptide_hits_to_protein_groups(@pep_hits) do |prot_and_peptide_hits|
+      # deliberate using a counterintuitive sorting method to give little guys
+      # a chance
+      -prot_and_peptide_hits.last.size
+    end
+    # because the little proteins are given priority, they 'survive'. Bigger
+    # proteins may also survive if they have at least one unique peptide
+    # to add to the mix.  This demonstrates how proteins can be weighted in
+    # different ways based on their peptide hits.
+    seen = []
+    reply.each {|pair| pair.first.each {|prot| seen << prot.id } }
+    # big guy is completely accounted for in the now prioritized little guy
+    # and medium guys, etc.
+    seen.sort.is @prot_hits_hash.keys[1..-1].sort
+  end
+end

data/spec/spec_helper.rb

@@ -1,18 +1,8 @@
 require 'rubygems'
-require 'bundler'
 
 $spec_large = ENV['SPEC_LARGE']
-development = $spec_large ? :development_large : :development
-
-begin
-  Bundler.setup(:default, development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'spec/more'
 
+require 'spec/more'
 
 load_testdata = lambda do 
   require 'ms/testdata'
@@ -26,7 +16,6 @@ $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 Bacon.summary_on_exit
 
-
 def spec_large(&block)
   if $spec_large
     block.call

data/spec/tfiles/ms/ident/peptide/db/uni_11_sp_tr.fasta

@@ -0,0 +1,69 @@
+>sp|P31946|1433B_HUMAN 14-3-3 protein beta/alpha OS=Homo sapiens GN=YWHAB PE=1 SV=3
+MTMDKSELVQKAKLAEQAERYDDMAAAMKAVTEQGHELSNEERNLLSVAYKNVVGARRSS
+WRVISSIEQKTERNEKKQQMGKEYREKIEAELQDICNDVLELLDKYLIPNATQPESKVFY
+LKMKGDYFRYLSEVASGDNKQTTVSNSQQAYQEAFEISKKEMQPTHPIRLGLALNFSVFY
+YEILNSPEKACSLAKTAFDEAIAELDTLNEESYKDSTLIMQLLRDNLTLWTSENQGDEGD
+AGEGEN
+>sp|P31946-2|1433B_HUMAN Isoform Short of 14-3-3 protein beta/alpha OS=Homo sapiens GN=YWHAB
+MDKSELVQKAKLAEQAERYDDMAAAMKAVTEQGHELSNEERNLLSVAYKNVVGARRSSWR
+VISSIEQKTERNEKKQQMGKEYREKIEAELQDICNDVLELLDKYLIPNATQPESKVFYLK
+MKGDYFRYLSEVASGDNKQTTVSNSQQAYQEAFEISKKEMQPTHPIRLGLALNFSVFYYE
+ILNSPEKACSLAKTAFDEAIAELDTLNEESYKDSTLIMQLLRDNLTLWTSENQGDEGDAG
+EGEN
+>sp|P62258|1433E_HUMAN 14-3-3 protein epsilon OS=Homo sapiens GN=YWHAE PE=1 SV=1
+MDDREDLVYQAKLAEQAERYDEMVESMKKVAGMDVELTVEERNLLSVAYKNVIGARRASW
+RIISSIEQKEENKGGEDKLKMIREYRQMVETELKLICCDILDVLDKHLIPAANTGESKVF
+YYKMKGDYHRYLAEFATGNDRKEAAENSLVAYKAASDIAMTELPPTHPIRLGLALNFSVF
+YYEILNSPDRACRLAKAAFDDAIAELDTLSEESYKDSTLIMQLLRDNLTLWTSDMQGDGE
+EQNKEALQDVEDENQ
+>sp|Q04917|1433F_HUMAN 14-3-3 protein eta OS=Homo sapiens GN=YWHAH PE=1 SV=4
+MGDREQLLQRARLAEQAERYDDMASAMKAVTELNEPLSNEDRNLLSVAYKNVVGARRSSW
+RVISSIEQKTMADGNEKKLEKVKAYREKIEKELETVCNDVLSLLDKFLIKNCNDFQYESK
+VFYLKMKGDYYRYLAEVASGEKKNSVVEASEAAYKEAFEISKEQMQPTHPIRLGLALNFS
+VFYYEIQNAPEQACLLAKQAFDDAIAELDTLNEDSYKDSTLIMQLLRDNLTLWTSDQQDE
+EAGEGN
+>sp|P61981|1433G_HUMAN 14-3-3 protein gamma OS=Homo sapiens GN=YWHAG PE=1 SV=2
+MVDREQLVQKARLAEQAERYDDMAAAMKNVTELNEPLSNEERNLLSVAYKNVVGARRSSW
+RVISSIEQKTSADGNEKKIEMVRAYREKIEKELEAVCQDVLSLLDNYLIKNCSETQYESK
+VFYLKMKGDYYRYLAEVATGEKRATVVESSEKAYSEAHEISKEHMQPTHPIRLGLALNYS
+VFYYEIQNAPEQACHLAKTAFDDAIAELDTLNEDSYKDSTLIMQLLRDNLTLWTSDQQDD
+DGGEGNN
+>sp|P31947|1433S_HUMAN 14-3-3 protein sigma OS=Homo sapiens GN=SFN PE=1 SV=1
+MERASLIQKAKLAEQAERYEDMAAFMKGAVEKGEELSCEERNLLSVAYKNVVGGQRAAWR
+VLSSIEQKSNEEGSEEKGPEVREYREKVETELQGVCDTVLGLLDSHLIKEAGDAESRVFY
+LKMKGDYYRYLAEVATGDDKKRIIDSARSAYQEAMDISKKEMPPTNPIRLGLALNFSVFH
+YEIANSPEEAISLAKTTFDEAMADLHTLSEDSYKDSTLIMQLLRDNLTLWTADNAGEEGG
+EAPQEPQS
+>tr|D2KLI3|D2KLI3_HUMAN Cytochrome b OS=Homo sapiens GN=CYTB PE=3 SV=1
+MTPTRKTNPLMKLINHSFIDLPTPSNISAWWNFGSLLGACLILQITTGLFLAMHYSPDAS
+TAFSSIAHITRDVNYGWIIRYLHANGASMFFICLFLHIGRGLYYGSFLYSETWNIGIILL
+LATMATAFMGYVLPWGQMSFWGATVITNLLSAIPYIGTDLVQWIWGGYSVDSPTLTRFFT
+FHFILPFIIAALAALHLLFLHETGSNNPLGITSHSDKITFHPYYTIKDALGLLLFLLSLM
+TLTLFSPDLLGDPDNYTLANPLNTPPHIKPEWYFLFAYTILRSVPNKLGGVLALLLSILI
+LAMIPILHMSKQQSMMFRPLSQSLYWLLAADLLILTWIGGQPVSYPFTIIGQVASVLYFT
+TILILMPTISLIENKMLKWA
+>tr|D2KTA8|D2KTA8_HUMAN Putative uncharacterized protein FCAMR OS=Homo sapiens GN=FCAMR PE=4 SV=1
+MDGEATVKPGEQVPLWTHGWPPDDPSPSFAAGSSFALPQKRPHPRWLWEGSLPSRTHLRA
+MGTLRPSSPLCWREESSFAAPNSLKGSRLVSGEPGGAVTIQCHYAPSSVNRHQRKYWCRL
+GPPRWICQTIVSTNQYTHHRYRDRVALTDFPQRGLFVVRLSQLSPDDIGCYLCGIGSENN
+MLFLSMNLTISAGPASTLPTATPAAGELTMRSYGTASPVANRWTPGTTQTLGQGTAWDTV
+ASTPGTSKTTASAEGRRTPGATRPAAPGTGSWAEGSVKAPAPIPESPPSKSRSMSNTTEG
+VWEGTRSSVTNRARASKDRREMTTTKADRPREDIEGVRIALDAAKKVLGTIGPPALVSET
+LAWEILPQATPVSKQQSQGSIGETTPAAGMWTLGTPAADVWILGTPAADVWTSMEAASGE
+GSAAGDLDAATGDRGPQATLSQTPAVGPWGPPGKESSVKRTFPEDESSSRTLAPVSTMLA
+LFMLMALVLLQRKLWRRRTSQEAERVTLIQMTHFLEVNPQADQLPHVERKMLQDDSLPAG
+ASLTAPERNPGP
+>tr|D2KTA9|D2KTA9_HUMAN Putative uncharacterized protein XKR5 OS=Homo sapiens GN=XKR5 PE=4 SV=1
+MHARLLGLSALLQAAEQSARLYTVAYYFTTGRLLWGWLALAVLLPGFLVQALSYLWFRAD
+GHPGHCSLMMLHLLQLGVWKRHWDAALTSLQKELEAPHRGWLQLQEADLSALRLLEALLQ
+TGPHLLLQTYVFLASDFTDIVPGVSTLFSWSSLSWALVSYTRFMGFMKPGHLAMPWAALF
+CQQLWRMGMLGTRVLSLVLFYKAYHFWVFVVAGAHWLVMTFWLVAQQSDIIDSTCHWRLF
+NLLVGAVYILCYLSFWDSPSRNRMVTFYMVMLLENIILLLLATDFLQGASVDQPADHSWG
+PVWISDWQCLTGNLLQPAASKIHRHLAGLPKEVLWHCRR
+>tr|D3DSH8|D3DSH8_HUMAN HCG2036819, isoform CRA_a OS=Homo sapiens GN=hCG_2036819 PE=4 SV=1
+MLGWIQPSRQPQLRAAPPTRTPSAKRCILCNFLPGCWLVGDVAGSRQPSAPQTLRQRQHT
+RPPPQERGSGRRSPLREARRANPHFKSFPVLEARGLPCGARRTGPRRPVREMTLPSDPER
+ATLPNPRLGAPAVPRRGPRSHGGRR
+>tr|D3DX18|D3DX18_HUMAN Putative uncharacterized protein LOC128977 OS=Homo sapiens GN=LOC128977 PE=4 SV=1
+MADGSGWQPPRPCEAYRAEWKLCRSARHFLHHYYVHGERPACEQWQRDLASCRDWEERRN
+AEAQQSLCESERARVRAARKHILVWAPRQSPPPDWHLPLPQEKDE