From 24ba0fb28b049fb73da96602f6e8eb40d4f053b5 Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 23 Oct 2026 06:05:16 +0000 Subject: [PATCH] Add cRAP contaminants to the search database, flag and hide them in results A new "Add common contaminants (cRAP)" option (on by default) appends the 116 cRAP proteins to the search database with CON__ accessions. With generated decoys, DecoyDatabase reads the FASTA and the contaminants together, so contaminants get decoys too. A FASTA with its own decoys gets contaminant decoys in its decoy style. The database step is now its own method, prepare_search_database(). PSM tables gain a Contaminant column. get_abundance_data() leaves contaminant proteins out by default, so downstream analysis never sees them. The Abundance page flags them and has a "Show contaminants" toggle. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01D5Wo2FHPpi5a8X6GppNxEk --- content/results_abundance.py | 33 +- example-data/db/contaminants/crap.fasta | 945 ++++++++++++++++++++++++ src/WorkflowTest.py | 115 ++- src/common/contaminants.py | 71 ++ src/common/results_helpers.py | 21 +- tests/test_contaminants.py | 164 ++++ 6 files changed, 1319 insertions(+), 30 deletions(-) create mode 100644 example-data/db/contaminants/crap.fasta create mode 100644 src/common/contaminants.py create mode 100644 tests/test_contaminants.py diff --git a/content/results_abundance.py b/content/results_abundance.py index 4c98cb5..1a5fd8b 100644 --- a/content/results_abundance.py +++ b/content/results_abundance.py @@ -6,6 +6,7 @@ from src.common.results_helpers import get_workflow_dir, get_abundance_data from src.workflow.ParameterManager import ParameterManager from src.common.insight_tables import show_insight_table +from src.common.contaminants import CONTAMINANT_PREFIX, contaminant_mask params = page_setup() st.title("Abundance Quantification") @@ -43,6 +44,16 @@ cache_dir = workflow_dir / "results" / "insight_cache" table_sources = [csv_file, workflow_dir / "params.json"] +show_contaminants = st.toggle( + "Show contaminants", + value=False, + key="abundance-show-contaminants", + help=f"Proteins with {CONTAMINANT_PREFIX} accessions come from the cRAP contaminants added to the " + "search database. They are hidden here and left out of the downstream analysis.", +) +# The tables differ with the toggle, so it is part of their cache key +contaminant_key = f"contaminants={show_contaminants}" + def render_protein_table(pivot_df, is_lfq=True): """Common function to render the protein-level abundance table""" pivot_df = pivot_df.copy() @@ -69,13 +80,15 @@ def render_protein_table(pivot_df, is_lfq=True): # Filter to available columns, then sort and display available_cols = [c for c in display_cols if c in pivot_df.columns] - view_df = pivot_df[available_cols] + view_df = pivot_df[available_cols].copy() + view_df.insert(1, "Contaminant", contaminant_mask(view_df[id_col]).to_numpy()) show_insight_table( view_df, name="abundance_protein", cache_dir=cache_dir, source_files=table_sources, + extra_key=contaminant_key, title="protein_abundance", ) @@ -86,7 +99,13 @@ def render_protein_table(pivot_df, is_lfq=True): st.info("No data found in this file.") st.stop() - result = get_abundance_data(st.session_state["workspace"]) + result = get_abundance_data(st.session_state["workspace"], include_contaminants=show_contaminants) + if not show_contaminants: + all_proteins = get_abundance_data(st.session_state["workspace"], include_contaminants=True) + if all_proteins is not None and result is not None: + hidden = len(all_proteins[0]) - len(result[0]) + if hidden: + st.caption(f"{hidden} contaminant protein(s) hidden.") if analysis_mode == "LFQ": protein_tab, psm_tab = st.tabs(["Protein Table", "PSM-level Quantification Table"]) @@ -106,11 +125,18 @@ def render_protein_table(pivot_df, is_lfq=True): "peptide sequences, charge states, and intensities across samples. " "Each row represents one peptide-spectrum match detected from the MS/MS analysis." ) + psm_df = df.copy() + if "ProteinName" in psm_df.columns: + is_con = contaminant_mask(psm_df["ProteinName"]).to_numpy() + psm_df.insert(1, "Contaminant", is_con) + if not show_contaminants: + psm_df = psm_df[~is_con] show_insight_table( - df, + psm_df, name="abundance_psm", cache_dir=cache_dir, source_files=table_sources, + extra_key=contaminant_key, title="psm_quantification", ) @@ -130,6 +156,7 @@ def render_protein_table(pivot_df, is_lfq=True): name="abundance_intensity_matrix", cache_dir=cache_dir, source_files=table_sources, + extra_key=contaminant_key, title="intensity_matrix", ) diff --git a/example-data/db/contaminants/crap.fasta b/example-data/db/contaminants/crap.fasta new file mode 100644 index 0000000..7ac4ddb --- /dev/null +++ b/example-data/db/contaminants/crap.fasta @@ -0,0 +1,945 @@ +>sp|ALBU_BOVIN| +MKWVTFISLLLLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIA +FSQYLQQCPFDEHVKLVNELTEFAKTCVADESHAGCEKSLHTLFGDELCK +VASLRETYGDMADCCEKQEPERNECFLSHKDDSPDLPKLKPDPNTLCDEF +KADEKKFWGKYLYEIARRHPYFYAPELLYYANKYNGVFQECCQAEDKGAC +LLPKIETMREKVLASSARQRLRCASIQKFGERALKAWSVARLSQKFPKAE +FVEVTKLVTDLTKVHKECCHGDLLECADDRADLAKYICDNQDTISSKLKE +CCDKPLLEKSHCIAEVEKDAIPENLPPLTADFAEDKDVCKNYQEAKDAFL +GSFLYEYSRRHPEYAVSVLLRLAKEYEATLEECCAKDDPHACYSTVFDKL +KHLVDEPQNLIKQNCDQFEKLGEYGFQNALIVRYTRKVPQVSTPTLVEVS +RSLGKVGTRCCTKPESERMPCTEDYLSLILNRLCVLHEKTPVSEKVTKCC +TESLVNRRPCFSALTPDETYVPKAFDEKLFTFHADICTLPDTEKQIKKQT +ALVELLKHKPKATEEQLKTVMENFVAFVDKCCAADDKEACFAVEGPKLVV +STQTALA +>sp|AMYS_HUMAN| +MKLFWLLFTIGFCWAQYSSNTQQGRTSIVHLFEWRWVDIALECERYLAPK +GFGGVQVSPPNENVAIHNPFRPWWERYQPVSYKLCTRSGNEDEFRNMVTR +CNNVGVRIYVDAVINHMCGNAVSAGTSSTCGSYFNPGSRDFPAVPYSGWD +FNDGKCKTGSGDIENYNDATQVRDCRLSGLLDLALGKDYVRSKIAEYMNH +LIDIGVAGFRIDASKHMWPGDIKAILDKLHNLNSNWFPEGSKPFIYQEVI +DLGGEPIKSSDYFGNGRVTEFKYGAKLGTVIRKWNGEKMSYLKNWGEGWG +FMPSDRALVFVDNHDNQRGHGAGGASILTFWDARLYKMAVGFMLAHPYGF +TRVMSSYRWPRYFENGKDVNDWVGPPNDNGVTKEVTINPDTTCGNDWVCE +HRWRQIRNMVNFRNVVDGQPFTNWYDNGSNQVAFGRGNRGFIVFNNDDWT +FSLTLQTGLPAGTYCDVISGDKINGNCTGIKIYVSDDGKAHFSISNSAED +PFIAIHAESKL +>sp|CAS1_BOVIN| +MKLLILTCLVAVALARPKHPIKHQGLPQEVLNENLLRFFVAPFPEVFGKE +KVNELSKDIGSESTEDQAMEDIKQMEAESISSSEEIVPNSVEQKHIQKED +VPSERYLGYLEQLLRLKKYKVPQLEIVPNSAEERLHSMKEGIHAQQKEPM +IGVNQELAYFYPELFRQFYQLDAYPSGAWYYVPLGTQYTDAPSFSDIPNP +IGSENSEKTTMPLW +>sp|CAS2_BOVIN| +MKFFIFTCLLAVALAKNTMEHVSSSEESIISQETYKQEKNMAINPSKENL +CSTFCKEVVRNANEEEYSIGSSSEESAEVATEEVKITVDDKHYQKALNEI +NQFYQKFPQYLQYLYQGPIVLNPWDQVKRNAVPITPTLNREQLSTSEENS +KKTVDMESTEVFTKKTKLTEEEKNRLNFLKKISQRYQKFALPQYLKTVYQ +HQKAMKPWIQPKTKVIPYVRYL +>sp|CASB_BOVIN| +MKVLILACLVALALARELEELNVPGEIVESLSSSEESITRINKKIEKFQS +EEQQQTEDELQDKIHPFAQTQSLVYPFPGPIPNSLPQNIPPLTQTPVVVP +PFLQPEVMGVSKVKEAMAPKHKEMPFPKYPVEPFTESQSLTLTDVENLHL +PLPLLQSWMHQPHQPLPPTVMFPPQSVLSLSQSKVLPVPQKAVPYPQRDM +PIQAFLLYQEPVLGPVRGPFPIIV +>sp|CASK_BOVIN| +MMKSFFLVVTILALTLPFLGAQEQNQEQPIRCEKDERFFSDKIAKYIPIQ +YVLSRYPSYGLNYYQQKPVALINNQFLPYPYYAKPAAVRSPAQILQWQVL +SNTVPAKSCQAQPTTMARHPHPHLSFMAIPPKKNQDKTEIPTINTIASGE +PTSTPTTEAVESTVATLEDSPEVIESPPEINTVQVTSTAV +>sp|CTRA_BOVIN| +CGVPAIQPVLSGLSRIVNGEEAVPGSWPWQVSLQDKTGFHFCGGSLINEN +WVVTAAHCGVTTSDVVVAGEFDQGSSSEKIQKLKIAKVFKNSKYNSLTIN +NDITLLKLSTAASFSQTVSAVCLPSASDDFAAGTTCVTTGWGLTRYTNAN +TPDRLQQASLPLLSNTNCKKYWGTKIKDAMICAGASGVSSCMGDSGGPLV +CKKNGAWTLVGIVSWGSSTCSTSTPGVYARVTALVNWVQQTLAAN +>sp|CTRB_BOVIN| +CGVPAIQPVLSGLARIVNGEDAVPGSWPWQVSLQDSTGFHFCGGSLISED +WVVTAAHCGVTTSDVVVAGEFDQGLETEDTQVLKIGKVFKNPKFSILTVR +NDITLLKLATPAQFSETVSAVCLPSADEDFPAGMLCATTGWGKTKYNALK +TPDKLQQATLPIVSNTDCRKYWGSRVTDVMICAGASGVSSCMGDSGGPLV +CQKNGAWTLAGIVSWGSSTCSTSTPAVYARVTALMPWVQETLAAN +>sp|K1C10_HUMAN| +MSVRYSSSKHYSSSRSGGGGGGGGCGGGGGVSSLRISSSKGSLGGGFSSG +GFSGGSFSRGSSGGGCFGGSSGGYGGLGGFGGGSFHGSYGSSSFGGSYGG +SFGGGNFGGGSFGGGSFGGGGFGGGGFGGGFGGGFGGDGGLLSGNEKVTM +QNLNDRLASYLDKVRALEESNYELEGKIKEWYEKHGNSHQGEPRDYSKYY +KTIDDLKNQILNLTTDNANILLQIDNARLAADDFRLKYENEVALRQSVEA +DINGLRRVLDELTLTKADLEMQIESLTEELAYLKKNHEEEMKDLRNVSTG +DVNVEMNAAPGVDLTQLLNNMRSQYEQLAEQNRKDAEAWFNEKSKELTTE +IDNNIEQISSYKSEITELRRNVQALEIELQSQLALKQSLEASLAETEGRY +CVQLSQIQAQISALEEQLQQIRAETECQNTEYQQLLDIKIRLENEIQTYR +SLLEGEGSSGGGGRGGGSFGGGYGGGSSGGGSSGGGYGGGHGGSSGGGYG +GGSSGGGSSGGGYGGGSSSGGHGGGSSSGGHGGSSSGGYGGGSSGGGGGG +YGGGSSGGGSSSGGGYGGGSSSGGHKSSSSGSVGESSSKGPRY +>sp|K1C15_SHEEP| +MATTLLQTSSSTFGGSSTRGGSLLAGGGGFGGGSLYGGGGSRTISASSAR +FVSSGSAGGYGGGFGGGAGSGYGGGFGGGFGGGFGSGFGDFGGGDGGLLS +GNEKITMQNLNDRLASYLEKVRALEEANADLEVKIRDWYQRQSPTSPERD +YSPYFKTTDELRDKILAAAIDNSRVILEIDNARLAADDFRLKYENEMALR +QSVEADINGLRRVLDELTLTKTDLEMQIESLNEELAYLKKNHEEEMKEFS +NQLAGQVNVEMDAAPGVDLTRVLSEMREQYEAMAEKNRRDAEAWFFSKTE +ELNKEVASNTEMIQTSKSEITDLRRTIQGLEIELQSQLSMKAGLESTLAE +TDGRYAAQLQQIQGLISSIEAQLSELRSEMEAQNQEYKMLLDIKTRLEQE +IATYHSLLEGQDARMAGIGTGEASLGGGGGGKVRINVEESVDGKVVSSRK +REI +>sp|K1C9_HUMAN| +MSCRQFSSSYLSRSGGGGGGGLGSGGSIRSSYSRFSSSGGRGGGGRFSSS +SGYGGGSSRVCGRGGGGSFGYSYGGGSGGGFSASSLGGGFGGGSRGFGGA +SGGGYSSSGGFGGGFGGGSGGGFGGGYGSGFGGLGGFGGGAGGGDGGILT +ANEKSTMQELNSRLASYLDKVQALEEANNDLENKIQDWYDKKGPAAIQKN +YSPYYNTIDDLKDQIVDLTVGNNKTLLDIDNTRMTLDDFRIKFEMEQNLR +QGVDADINGLRQVLDNLTMEKSDLEMQYETLQEELMALKKNHKEEMSQLT +GQNSGDVNVEINVAPGKDLTKTLNDMRQEYEQLIAKNRKDIENQYETQIT +QIEHEVSSSGQEVQSSAKEVTQLRHGVQELEIELQSQLSKKAALEKSLED +TKNRYCGQLQMIQEQISNLEAQITDVRQEIECQNQEYSLLLSIKMRLEKE +IETYHNLLEGGQEDFESSGAGKIGLGGRGGSGGSYGRGSRGGSGGSYGGG +GSGGGYGGGSGSRGGSGGSYGGGSGSGGGSGGGYGGGSGGGHSGGSGGGH +SGGSGGNYGGGSGSGGGSGGGYGGGSGSRGGSGGSHGGGSGFGGESGGSY +GGGEEASGSGGGYGGGSGKSSHS +>sp|K1H1_HUMAN| +MPYNFCLPSLSCRTSCSSRPCVPPSCHSCTLPGACNIPANVSNCNWFCEG +SFNGSEKETMQFLNDRLASYLEKVRQLERDNAELENLIRERSQQQEPLLC +PSYQSYFKTIEELQQKILCTKSENARLVVQIDNAKLAADDFRTKYQTELS +LRHVVESDINGLRRILDELTLCKSDLEAQVESLKEELLCLKSNHEQEVNT +LRCQLGDRLNVEVDAAPTVDLNRVLNETRSQYEALVETNRREVEQWFTTQ +TEELNKQVVSSSEQLQSYQAEIIELRRTVNALEIELQAQHNLRDSLENTL +TESEARYSSQLSQVQSLITNVESQLAEIRSDLERQNQEYQVLLDVRARLE +CEINTYRSLLESEDCNLPSNPCATTNACSKPIGPCLSNPCTSCVPPAPCT +PCAPRPRCGPCNSFVR +>sp|K1H2_HUMAN| +MTSSCCVTNNLQASLKSCPRPASVCSSGVNCRPELCLGYVCQPMACLPSV +CLPTTFRPASCLSKTYLSSSCQAASGISGSMGPGSWYSEGAFNGNEKETM +QFLNDRLASYLTRVRQLEQENAELESRIQEASHSQVLTMTPDYQSHFRTI +DQLQQKILCTKAENARMVVNIDNAKLAADDFRAKYEAELAMRQLVEADIN +GLRRILDDLTLCKADLEAQVESLKEELMCLKKNHEEEVGSLRCQLGDRLN +IEVDAAPPVDLTRVLEEMRCQYEAMVEANRRDVEEWFNMQMEELNQQVAT +SSEQLQNYQSDIIDLRRTVNTLEIELQAQHSLRDSLENTLTESEARYSSQ +LAQMQCMITNVEAQLAEIRAELERQNQEYQVLLDVRARLEGEINTYRSLL +ESEDCKLPCNPCSTPSCTTCVPSPCVTRTVCVPRTVGMPCSPCPQGRY +>sp|K1H4_HUMAN| +MSYSCCLPSLGCRTSCSSRPCVPPSCHGYTLPGACNIPANVSNCNWFCEG +SFNGSEKETMQFLNDRLASYLEKVRQLERDNAELEKLIQERSQQQEPLLC +PSYQSYFKTIEELQQKILCAKAENARLVVNIDNAKLASDDFRSKYQTEQS +LRLLVESDINSIRRILDELTLCKSDLESQVESLREELICLKKNHEEEVNT +LRSPLGDRLNVEVDTAPTVDLNQVLNETRSQYEALVEINRREVEQWFATQ +TEELNKQVVSSSEQLQSCQAEIIELRRTVNALEIELQAQHNLRDSLENTL +TESEAHYSSQLSQVQSLITNVESQLAEIRCDLERQNQEYQVLLDVRARLE +CEINTYRSLLESEDCKLPCNPCATTNASGNSCGPCGTSQKGCCN +>sp|K1H5_HUMAN| +MYSSSPCKLPSLSPVARSFSACSVGLGRSSYRATSCLPALCLPAGGFATS +YSGGGGWFGEGILTGNEKETMQSLNDRLAGYLEKVRHVEQENASLESRIR +EWCEQQVPYMCPDYQSYFRTIEELQKKTLCSKAENARLVVEIDNAKLAAD +DFRTKYETEVSLRQLVESDINGLRRILDDLTLCKSDLEAQVESLKEELLC +LKKNHEEEVNSLRCQLGDRLNVEVDAAPPVDLNRVLEEMRCQYETLVENN +RRDAEDWLDTQSEELNQQVVSSSEQLQSCQAEIIELRRTVNALEIELQAQ +HSMRDALESTLAETEARYSSQLAQMQCMITNVEAQLAEIRADLERQNQEY +QVLLDVRARLECEINTYRGLLESEDSKLPCNPCAPDYSPSKSCLPCLPAA +SCGPSAARTNCSPRPICVPCPGGRF +>sp|K1H6_HUMAN| +MATQTCTPTFSTGSIKGLCGTAGGISRVSSIRSVGSCRVPSLAGAAGYIS +SARSGLSGLGSCLPGSYLSSECHTSGFVGSGGWFCEGSFNGSEKETMQFL +NDRLANYLEKVRQLERENAELESRIQEWYEFQIPYICPDYQSYFKTIEDF +QQKILLTKSENARLVLQIDNAKLAADDFRTKYETELSLRQLVEADINGLR +RILDELTLCKADLEAQVESLKEELMCLKKNHEEEVSVLRCQLGDRLNVEV +DAAPPVDLNKILEDMRCQYEALVENNRRDVEAWFNTQTEELNQQVVSSSE +QLQCCQTEIIELRRTVNALEIELQAQHSMRNSLESTLAETEARYSSQLAQ +MQCLISNVEAQLSEIRCDLERQNQEYQVLLDVKARLEGEIATYRHLLEGE +DCKLPPQPCATACKPVIRVPSVPPVPCVPSVPCTPAPQVGTQIRTITEEI +RDGKVISSREHVQSRPL +>sp|K1H7_HUMAN| +MTSFYSTSSCPLGCTMAPGARNVFVSPIDVGCQPVAEANAASMCLLANVA +HANRVRVGSTPLGRPSLCLPPTSHTACPLPGTCHIPGNIGICGAYGKNTL +NGHEKETMKFLNDRLANYLEKVRQLEQENAELETTLLERSKCHESTVCPD +YQSYFRTIEELQQKILCSKAENARLIVQIDNAKLAADDFRIKLESERSLH +QLVEADKCGTQKLLDDATLAKADLEAQQESLKEEQLSLKSNHEQEVKILR +SQLGEKFRIELDIEPTIDLNRVLGEMRAQYEAMVETNHQDVEQWFQAQSE +GISLQAMSCSEELQCCQSEILELRCTVNALEVERQAQHTLKDCLQNSLCE +AEDRYGTELAQMQSLISNLEEQLSEIRADLERQNQEYQVLLDVKARLENE +IATYRNLLESEDCKLPCNPCSTPASCTSCPSCGPVTGGSPSGHGASMGR +>sp|K1H8_HUMAN| +MTSSYSSSSCPLGCTMAPGARNVSVSPIDIGCQPGAEANIAPMCLLANVA +HANRVRVGSTPLGRPSLCLPPTCHTACPLPGTCHIPGNIGICGAYGENTL +NGHEKETMQFLNDRLANYLEKVRQLEQENAELEATLLERSKCHESTVCPD +YQSYFHTIEELQQKILCSKAENARLIVQIDNAKLAADDFRIKLESERSLR +QLVEADKCGTQKLLDDATLAKADLEAQQESLKEEQLSLKSNHEQEVKILR +SQLGEKLRIELDIEPTIDLNRVLGEMRAQYEAMLETNRQDVEQWFQAQSE +GISLQDMSCSEELQCCQSEILELRCTVNALEVERQAQHTLKDCLQNSLCE +AEDRFGTELAQMQSLISNVEEQLSEIRADLERQNQEYQVLLDVKTRLENE +IATYRNLLESEDCKLPCNPCSTPPSCVTAPCAPRPSCGPCTTCGPTCGAS +TTGSRF +>sp|K1HA_HUMAN| +MSYSCGLPSLSCRTSCSSRPCVPPSCHGCTLPGACNIPANVSNCNWFCEG +SFNGSEKETMQFLNDRLASYLEKVRQLERDNAELENLIRERSQQQEPLVC +ASYQSYFKTIEELQQKILCSKSENARLVVQIDNAKLASDDFRTKYETELS +LRHVVESDINGLRRILDELTLCRSDLEAQVESLKEELLCLKQNHEQEVNT +LRCQLGDRLNVEVDAAPTVDLNQVLNETRSQYEALVETNRREVEQWFATQ +TEELNKQVVSSSEQLQSYQAEIIELRRTVNALEIELQAQHNLRDSLENTL +TESEARYSSQLSQVQRLITNVESQLAEIRSDLERQNQEYQVLLDVRARLE +CEINTYRSLLESEDCKLPSNPCATTNACDKSTGPCISNPCGLRARCGPCN +TFGY +>sp|K1HB_HUMAN| +MPYNFCLPSLSCRTSCSSRPCVPPSCHGYTLPGACNIPANVSNCNWFCEG +SFNGSEKETMQFLNDRLASYLEKVRQLERDNAELENLIRERSQQQEPLLC +PSYQSYFKTIEELQQKILCSKSENARLVVQIDNAKLAADDFRTKYQTEQS +LRQLVESDINSLRRILDELTLCRSDLEAQMESLKEELLSLKQNHEQEVNT +LRCQLGDRLNVEVDAAPAVDLNQVLNETRNQYEALVETNRREVEQWFATQ +TEELNKQVVSSSEQLQSYQAEIIELRRTVNALEIELQAQHNLRYSLENTL +TESEARYSSQLSQVQSLITNVESQLAEIRSDLERQNQEYQVLLDVRARLE +CEINTYRSLLESEDCKLPSNPCATTNACEKPIGSCVTNPCGPRSRCGPCN +TFGY +>sp|K1M1_SHEEP| +SFNFCLPNLSFRSSCSSRPCVPSSCCGTTLPGACNIPANVGSCNWFCEGS +FDGNEKETMQFLNDRLASYLEKVRQLERENAELESRILERSQQQEPLVCP +NYQSYFRTIEELQQKILCAKSENARLVVQIDNAKLAADDFRTKYETELGL +RQLVESDINGLRRILDELTLCKSDLEAQVESLKEELICLKSNHEEEVNTL +RSQLGDRLNVEVDAAPTVDLNRVLNETRAQYEALVETNRRDVEEWYIRQT +EELNKQVVSSSEQLQSCQTEIIELRRTVNALEVELQAQHNLRDSLENTLT +ETEARYSCQLNQVQSLISNVESQLAEIRGDLERQNQEYQVLLDVRARLEC +EINTYRGLLDSEDCKLPCNPCATTNACGKTITPCISSPCAPAAPCTPCVP +RSRCGPCNSYVR +>sp|K1M2_SHEEP| +SFNFCLPNLSFRSSCSSRPCVPSSCCGTTLPGACNIPASVGSCNWFCEGS +FNGNEKETMQFLNDRLASYLEKVRQLERENAELERRILERSQQQEPLVCP +NYQSYFRTIEELQQKILCGKSENARLVVQIDNAKLASDDFRTKYETEVSL +RQLVEADLNGLRRILDELTLCKSDLEARVESLKEELICLKQNHEQEVNTL +RSQLGDRLNVEVDAAPTVDLNHVLNETRAQYEALVETNRRDVEEWYIRQT +EELNKQVVSSSEQLQSCQAEIIELRRTVNALEVELQAQHNLRDSLENTLT +ETEARYSCQLNQVQSLIVSVESQLAEIRSDLERQNQEYQVLLDVRARLEC +EINTYRGLLDSEDCKLPCNPCATTNTCGKPIGPCISNPCVSRTRCGPCNT +FVH +>sp|K22E_HUMAN| +MSCQISCKSRGRGGGGGGFRGFSSGSAVVSGGSRRSTSSFSCLSRHGGGG +GGFGGGGFGSRSLVGLGGTKSISISVAGGGGGFGAAGGFGGRGGGFGGGS +GFGGGSGFGGGSGFSGGGFGGGGFGGGRFGGFGGPGGVGGLGGPGGFGPG +GYPGGIHEVSVNQSLLQPLNVKVDPEIQNVKAQEREQIKTLNNKFASFID +KVRFLEQQNQVLQTKWELLQQMNVGTRPINLEPIFQGYIDSLKRYLDGLT +AERTSQNSELNNMQDLVEDYKKKYEDEINKRTAAENDFVTLKKDVDNAYM +IKVELQSKVDLLNQEIEFLKVLYDAEISQIHQSVTDTNVILSMDNSRNLD +LDSIIAEVKAQYEEIAQRSKEEAEALYHSKYEELQVTVGRHGDSLKEIKI +EISELNRVIQRLQGEIAHVKKQCKNVQDAIADAEQRGEHALKDARNKLND +LEEALQQAKEDLARLLRDYQELMNVKLALDVEIATYRKLLEGEECRMSGD +LSSNVTVSVTSSTISSNVASKAAFGGSGGRGSSSGGGYSSGSSSYGSGGR +QSGSRGGSGGGGSISGGGYGSGGGSGGRYGSGGGSKGGSISGGGYGSGGG +KHSSGGGSRGGSSSGGGYGSGGGGSSSVKGSSGEAFGSSVTFSFR +>sp|K2C1_HUMAN| +SRQFSSRSGYRSGGGFSSGSAGIINYQRRTTSSSTRRSGGGGGRFSSCGG +GGGSFGAGGGFGSRSLVNLGGSKSISISVARGGGRGSGFGGGYGGGGFGG +GGFGGGGFGGGGIGGGGFGGFGSGGGGFGGGGFGGGGYGGGYGPVCPPGG +IQEVTINQSLLQPLNVEIDPEIQKVKSREREQIKSLNNQFASFIDKVRFL +EQQNQVLQTKWELLQQVDTSTRTHNLEPYFESFINNLRRRVDQLKSDQSR +LDSELKNMQDMVEDYRNKYEDEINKRTNAENEFVTIKKDVDGAYMTKVDL +QAKLDNLQQEIDFLTALYQAELSQMQTQISETNVILSMDNNRSLDLDSII +AEVKAQNEDIAQKSKAEAESLYQSKYEELQITAGRHGDSVRNSKIEISEL +NRVIQRLRSEIDNVKKQISNLQQSISDAEQRGENALKDAKNKLNDLEDAL +QQAKEDLARLLRDYQELMNTKLALDLEIATYRTLLEGEESRMSGECAPNV +SVSVSTSHTTISGGGSRGGGGGGYGSGGSSYGSGGGSYGSGGGGGGGRGS +YGSGGSSYGSGGGSYGSGGGGGGHGSYGSGSSSGGYRGGSGGGGGGSSGG +RGSGGGSSGGSIGGRGSSSGGVKSSGGSSSVRFVSTTYSGVTR +>sp|K2M1_SHEEP| +QNRQCCESNLEPLFSGYIETLRREAECAEADSGRLSSELNSLQEVLEGYK +RRYEEEVALRATAENEFVALKKDVDCAYLRKSDLEANVEALIQETDFLRR +LYEEEIRVL +>sp|K2M2_SHEEP| +CGFSTVGSGFGSRAFSCVSACGPRPGRCCITAAPYRGISCYRGLTGGFGS +RSVCGGFRAGSCGRSFGYRSGGVCGPSPPCITTVSVNESLLTPLNLEIDP +NAQCVKQEEKEQIKCLNNRFAAFIDKVRFLEQQNKLLETKLQFFQNRQCC +ESNLEPLFEGYIETLRREAECVEADSGRLSSELNHVQEVLEGYKKKYEQE +VALRATAENEFVALKKDVDCAYVRKSDLEANSEALIQEIDFLRRLYQEEI +RVLQANISDTSVIVKMDNSRDLNMDCIVAEIKAQYDDIASRSRAEAESWY +RSKCEEIKATVIRHGETLRRTKEEINELNRVIQRLTAEVENAKCQNSKLE +AAVTQAEQQGEVALNDARCKLAGLEEALQKAKQDMACLLKEYQEVMNSKL +GLDIEIATYRRLLEGEEQRLCEGVGAVNVCVSSSRGGVVCGDLCVSGSRP +VTGSVCSAPCSGNLAVSTGLCAPCGQLNTTCGGGSCSLGRC +>sp|K2M3_SHEEP| +SCRSYRISPGYSVTRTFSSCSAVAPKTGSRCCISAAPYRGVSCYRGLTGF +GSRSVSALGSCGPRIAVSGFRAGSCGRSFGYRSGGVGGLSPSCITTVSVN +ESLLTPLNLEIDPNAQCVKHQEKEQIKNLNSRFAAFIDKVRFLEQQNKLL +ETKWQFYQNQRCCESNLEPLFNGYIETLRREAEHVEADSGRLASELDHVQ +EVLEGYKKKYEEEVALRATAENEFVVLKKDVDCAYLRKSDLEANVEALVE +ESNFLKRLYDEEIQILNAHISDTSVIVKMDNSRDLNMDCVVAEIKAQYDD +IASRSRAEAESWYRSKCEEMKATVIRHGETLRRTKEEINELNRVIQRLTA +EIENAKCQRTKLEAAVAEAEQQGEAALNDARSKLAGLEEALQKAKQDMAC +LLKEYQEVMNSKLGLDIEIATYRRLLEGEEQRLCEGVGSVNVCVSSRGGV +ACGGLTYSSTAGRQIASGPVATGGSITVLAPDSCQPRASSFSCGSSRSVR +FA +>sp|KRA33_SHEEP| +ACCARLCCSVPTSPATTICSSDKFCRCGVCLPSTCPHTVWLLQPTCCCDN +RPPPYHVPQPSVPTCFLLNSSQPTPGLESINLTTYTQSSCEPCIPSCC +>sp|KRA34_SHEEP| +ACCARLCCSVPTSPATTICSSDKFCRCGVCLPSTCPHTVWFLQPTCCCDN +RPPPCHIPQPSVPTCFLLNSSQPTPGLESINLTTYTQPSCEPCIPSCC +>sp|KRA3A_SHEEP| +TGSCCGPTFSSLSCGGGCLQPCCYRDPCCCRPVSSTQTVSRPVTFVSRCT +RPICEPCRRPVCCDPCSLQEGCCRPITCCPTSCQAVVCRPCCWATTCCQP +VSVQCPCCRPTSCPSAPRTTCRTFRTSPCC +>sp|KRA3_SHEEP| +TGSCCGPTFSSLSCGGGCLQPRYYRDPCCCRPVSCQTVSRPVTFVPRCTR +PICEPCRRPVCCDPCSLQEGCCRPITCCPTSCQAVVCRPCCWATTCCQPV +SVQCPCCRPTSCQPAPCSRTTCRTFRTSPCC +>sp|KRA61_SHEEP| +CGYYGNYYGGLGCGSYSYGGLGCGYGSCYGSGFRRLGCGYGCGYGYGSRS +LCGSGYGYGSRSLCGSGYGCGSGYGSGFGYYY +>sp|KRB2A_SHEEP| +ACCSTSFCGFPICSTGGTCGSSPCQPTCCQTSCCQPTSIQTSCCQPISIQ +TSCCQPTSIQTSCCQPTCLQTSGCETGCGIGGSIGYGQVGSSGAVSSRTR +WCRPDCRVEGTSLPPCCVVSCTPPSCCQLYYAQASCCRPSYCGQSCCRPA +CCCQPTCIEPICEPSCCEPTC +>sp|KRB2B_SHEEP| +ACCSTSFCGFPICSSVGTCGSSCGQPTCSQTSCCQPTSIQTSCCQPISIQ +TSCCQPTCLQTSGCETGCGIGGSIGYDQVGSSGAVSSRTRWCRPDCRVEG +TSLPPCCVVSCTSPSCCQLYYAQASCCRPSYCGQSCCRPACCCQPTCIEP +VCEPTC +>sp|KRB2C_SHEEP| +ACCSTSFCGFPICSTAGTCGSSCCRSTCSQTSCCQPTSIQTSCCQPTCLQ +TSGCETGCGIGGSTGYGQVGSSGAVSSRTRWCRPDCRVEGTSLPPCCVVS +CTSPSCCQLYYAQASCCRPSYCGQSCCRPACCCQPTCTEPVCEPTCSQPI +C +>sp|KRB2D_SHEEP| +ACCSTSFCGFPTCSTGGTCGSNFCQPTCCQTSCCQPTSIQTSCCQPTSIQ +TSCCQPTSIQTSCCQPISIQTSCCQPTCLQTSGCETGCGIGGSIGYGQVG +SSGAVSSRTKWCRPDCRVEGTSLPPCCVVSCTSPSCCQLYYAQASCCRPS +YCGQSCCRPACCCQPTCIEPVCEPTCCEPTC +>sp|KRHB1_HUMAN| +MTCGSGFGGRAFSCISACGPRPGRCCITAAPYRGISCYRGLTGGFGSHSV +CGGFRAGSCGRSFGYRSGGVCGPSPPCITTVSVNESLLTPLNLEIDPNAQ +CVKQEEKEQIKSLNSRFAAFIDKVRFLEQQNKLLETKLQFYQNRECCQSN +LEPLFEGYIETLRREAECVEADSGRLASELNHVQEVLEGYKKKYEEEVSL +RATAENEFVALKKDVDCAYLRKSDLEANVEALIQEIDFLRRLYEEEIRIL +QSHISDTSVVVKLDNSRDLNMDCIIAEIKAQYDDIVTRSRAEAESWYRSK +CEEMKATVIRHGETLRRTKEEINELNRMIQRLTAEVENAKCQNSKLEAAV +AQSEQQGEAALSDARCKLAELEGALQKAKQDMACLIREYQEVMNSKLGLD +IEIATYRRLLEGEEQRLCEGIGAVNVCVSSSRGGVVCGDLCVSGSRPVTG +SVCSAPCNGNVAVSTGLCAPCGQLNTTCGGGSCGVGSCGISSLGVGSCGS +SCRKC +>sp|KRHB2_HUMAN| +MSYHSFQPGSRCGSQSFSSYSAVMPRMVTHYAVSKGPCRPGGGRGLRALG +CLGSRSLCNVGFGRPRVASRCGGTLPGFGYRLGATCGPSACITPVTINES +LLVPLALEIDPTVQRVKRDEKEQIKCLNNRFASFINKVRFLEQKNKLLET +KWNFMQQQRCCQTNIEPIFEGYISALRRQLDCVSGDRVRLESELCSLQAA +LEGYKKKYEEELSLRPCVENEFVALKKDVDTAFLMKADLETNAEALVQEI +DFLKSLYEEEICLLQSQISETSVIVKMDNSRELDVDGIIAEIKAQYDDIA +SRSKAEAEAWYQCRYEELRVTAGNHCDNLRNRKNEILEMNKLIQRLQQET +ENVKAQRCKLEGAIAEAEQQGEAALNDAKCKLAGLEEALQKAKQDMACLL +KEYQEVMNSKLGLDIEIATYRRLLEGEEHRLCEGIGPVNISVSSSKGAFL +YEPCGVSMPVLSTGVLRSNGGCSIVGTGELYVPCEPQGLLSCGSGRKSSM +TLGAGGSSPSHKH +>sp|KRHB3_HUMAN| +MTCGFNSIGCGFRPGNFSCVSACGPRPSRCCITAAPYRGISCYRGLTGGF +GSHSVCGGFRAGSCGRDFGYRSGGVCGPSPPCITTVSVNESLLTPLNLEI +DPNAQCVKQEEKEQIKSLNSRFAAFIDKVRFLEQQNKLLETKLQFYQNCE +CCQSNLEPLFAGYIETLRREAECVEADSGRLASELNHVQEVLEGYKKKYE +EEVALRATAENEFVALKKDVDCAYLRKSDLEANVEALIQEIDFLRRLYEE +EIRILQSHISDTSVVVKLDNSRDLNMDCMVAEIKAQYDDIATRSRAEAES +WYRSKCEEMKATVIRHGETLRRTKEEINELNRMIQRLTAEVENAKCQNSK +LEAAVAQSEQQGEAALSDARCKLAELEGALQKAKQDMACLIREYQEVMNS +KLGLDIEIATYRRLLEGEEQRLCEGVEAVNVCVSSSRGGVVCGDLCVSGS +RPVTGSVCSAPCNGNLVVSTGLCKPCGQLNTTCGGGSCGQGRY +>sp|KRHB4_HUMAN| +MSCRSYRVSSGHRVGNFSSCSAMTPQNLNRFRANSVSCWSGPGFRGLGSF +GSRSVITFGSYSPRIAAVGSRPIHCGVRFGAGCGMGFGDGRGVGLGPRAD +SCVGLGFGAGSGIGYGFGGPGFGYRVGGVGVPAAPSITAVTVNKSLLTPL +NLEIDPNAQRVKKDEKEQIKTLNNKFASFIDKVRFLEQQNKLLETKWSFL +QEQKCIRSNLEPLFESYITNLRRQLEVLVSDQARLQAERNHLQDVLEGFK +KKYEEEVVCRANAENEFVALKKDVDAAFMNKSDLEANVDTLTQEIDFLKT +LYMEEIQLLQSHISETSVIVKMDNSRDLNLDGIIAEVKAQYEEVARRSRA +DAEAWYQTKYEEMQVTAGQHCDNLRNIRNEINELTRLIQRLKAEIEHAKA +QRAKLEAAVAEAEQQGEATLSDAKCKLADLECALQQAKQDMARQLREYQE +LMNAKLGLDIEIATYRRLLEGEESRLCEGVGPVNISVSSSRGGLVCGPEP +LVAGSTLSRGGVTFSGSSSVCATSGVLASCGPSLGGARVAPATGDLLSTG +TRSGSMLISEACVPSVPCPLPTQGGFSSCSGGRSSSVRFVSTTTSCRTKY + +>sp|KRHB5_HUMAN| +MSCRSYRISSGCGVTRNFSSCSAVAPKTGNRCCISAAPYRGVSCYRGLTG +FGSRSLCNLGSCGPRIAVGGFRAGSCGRSFGYRSGGVCGPSPPCITTVSV +NESLLTPLNLEIDPNAQCVKQEEKEQIKSLNSRFAAFIDKVRFLEQQNKL +LETKWQFYQNQRCCESNLEPLFSGYIETLRREAECVEADSGRLASELNHV +QEVLEGYKKKYEEEVALRATAENEFVVLKKDVDCAYLRKSDLEANVEALV +EESSFLRRLYEEEIRVLQAHISDTSVIVKMDNSRDLNMDCIIAEIKAQYD +DVASRSRAEAESWYRSKCEEMKATVIRHGETLRRTKEEINELNRMIQRLT +AEIENAKCQRAKLEAAVAEAEQQGEAALSDARCKLAELEGALQKAKQDMA +CLLKEYQEVMNSKLGLDIEIATYRRLLEGEEHRLCEGVGSVNVCVSSSRG +GVSCGGLSYSTTPGRQITSGPSAIGGSITVVAPDSCAPCQPRSSSFSCGS +SRSVRFA +>sp|KRHB6_HUMAN| +MTCGSYCGGRAFSCISACGPRPGRCCITAAPYRGISCYRGLTGGFGSHSV +CGGFRAGSCGRSFGYRSGGVCGPSPPCITTVSVNESLLTPLNLEIDPNAQ +CVKQEEKEQIKSLNSRFAAFIDKVRFLEQQNKLLETKLQFYQNRECCQSN +LEPLFEGYIETLRREAECVEADSGRLASELNHVQEVLEGYKKKYEEEVSL +RATAENEFVALKKDVDCAYLRKSDLEANVEALIQEIDFLRRLYEEEIRVL +QSHISDTSVVVKLDNSRDLNMDCIIAEIKAQYDDIVTRSRAEAESWYRSK +CEEMKATVIRHGETLRRTKEEINELNRMIQRLTAEVENAKCQNSKLEAAV +AQSEQQGEAALSDARCKLAELEGALQKAKQDMACLIREYQEVMNSKLGLD +IEIATYRRLLEGEEQRLCEGVGSVNVCVSSSRGGVVCGDLCASTTAPVVS +TRVSSVPSNSNVVVGTTNACAPSARVGVCGGSCKRC +>sp|KRUC_SHEEP| +MGCSGCSGGCGSSCGGCGSRCGGCSSSCCVPVCCCKPVCCCVPACSCSSC +GKGGCGSSCGGSKGGCGSCGGSKGGCGSCGGCGSSCCKPVCCCVPACSCS +SCGKGGCGSCGGSKGGCGSCGGSKGGCGSCGGCGSGCGSSCCVPVCCCVP +ACSCSSCGKGGCGSCGCSQSSCCVPVCCQRKI +>sp|LALBA_BOVIN| +MMSFVSLLLVGILFHATQAEQLTKCEVFRELKDLKGYGGVSLPEWVCTTF +HTSGYDTQAIVQNNDSTEYGLFQINNKIWCKDDQNPHSSNICNISCDKFL +DDDLTDDIMCVKKILDKVGINYWLAHKALCSEKLDQWLCEKL +>sp|LYSC_LYSEN| +GVSGSCNIDVVCPEGNGHRDVIRSVAAYSKQGTMWCTGSLVNNSANDKKM +YFLTANHCGMTTAAIASSMVVYWNYQNSTCRAPGSSSSGANGDGSLAQSQ +TGAVVRATNAASDFTLLELNTAANPAYNLFWAGWDRRDQNFAGATAIHHP +NVAEKRISHSTVATEISGYNGATGTSHLHVFWQASGGVTEPGSSGSPIYS +PEKRVLGQLHGGPSSCSATGADRSDYYGRVFTSWTGGGTSATRLSDWLDA +AGTGAQFIDGLDSTGTPPV +>sp|PEPA_BOVIN| +MSVVKIPLVKKKSLRQNLIENGKLKEFMRTHKYNLGSKYIREAATLVSEQ +PLQNYLDTEYFGTIGIGTPAQDFTVIFDTGSSNLWVPSIYCSSEACTNHN +RFNPQDSSTYEATSETLSITYGTGSMTGILGYDTVQVGGISDTNQIFGLS +ETEPGSFLYYAPFDGILGLAYPSISSSGATPVFDNIWDQGLVSQDLFSVY +LSSNEESGSVVIFGDIDSSYYSGSLNWVPVSVEGYWQITVDSITMNGESI +ACSDGCQAIVDTGTSLLAGPTTAISNIQSYIGASEDSSGEVVISCSSIDS +LPDIVFTINGVQYPVPPSAYILQSNGICSSGFEGMDISTSSGDLWILGDV +FIRQYFTVFDRGNNQIGLAPVA +>sp|PEPA_PIG| +MKWLLLLSLVVLSECLVKVPLVRKKSLRQNLIKNGKLKDFLKTHKHNPAS +KYFPEAAALIGDEPLENYLDTEYFGTIGIGTPAQDFTVIFDTGSSNLWVP +SVYCSSLACSDHNQFNPDDSSTFEATSQELSITYGTGSMTGILGYDTVQV +GGISDTNQIFGLSETEPGSFLYYAPFDGILGLAYPSISASGATPVFDNLW +DQGLVSQDLFSVYLSSNDDSGSVVLLGGIDSSYYTGSLNWVPVSVEGYWQ +ITLDSITMDGETIACSGGCQAIVDTGTSLLTGPTSAIAINIQSDIGASEN +SDGEMVISCSSIDSLPDIVFTINGVQYPLSPSAYILQDDDSCTSGFEGMD +VPTSSGELWILGDVFIRQYYTVFDRANNKVGLAPVA +>sp|PEPB_PIG| +MERIILRKGKSIREAMEEQGVLEKFLKNRPKIDPAAKYHFNNDAVAYEPF +TNYLDSFYFGEISIGTP +>sp|PEPC_PIG| +SVIKVPLKKLKSIRQAMKEKGLLEEFLKTHKYDPAQRYRIGDISVALEPM +AYLEAAYFGEISIGTPPQNFLVL +>sp|SSPA_STAAU| +MKGKFLKVSSLFVATLTTATLVSSPAANALSSKAMDNHPQQTQSSKQQTP +KIQKGGNLKPLEQREHANVILPNNDRHQITDTTNGHYAPVTYIQVEAPTG +TFIASGVVVGKDTLLTNKHVVDATHGDPHALKAFPSAINQDNYPNGGFTA +EQITKYSGEGDLAIVKFSPNEQNKHIGEVVKPATMSNNAETQVNQNITVT +GYPGDKPVATMWESKGKITYLKGEAMQYDLSTTGGNSGSPVFNEKNEVIG +IHWGGVPNEFNGAVFINENVRNFLKQNIEDIHFANDDQPNNPDNPDNPNN +PDNPNNPDEPNNPDNPNNPDNPDNGDNNNSDNPDAA +>sp|TRY1_BOVIN| +FIFLALLGAAVAFPVDDDDKIVGGYTCGANTVPYQVSLNSGYHFCGGSLI +NSQWVVSAAHCYKSGIQVRLGEDNINVVEGNEQFISASKSIVHPSYNSNT +LNNDIMLIKLKSAASLNSRVASISLPTSCASAGTQCLISGWGNTKSSGTS +YPDVLKCLKAPILSDSSCKSAYPGQITSNMFCAGYLEGGKDSCQGDSGGP +VVCSGKLQGIVSWGSGCAQKNKPGVYTKVCNYVSWIKQTIASN +>sp|TRY2_BOVIN| +MHPLLILAFVGAAVAFPSDDDDKIVGGYTCAENSVPYQVSLNAGYHFCGG +SLINDQWVVSAAHCYQYHIQVRLGEYNIDVLEGGEQFIDASKIIRHPKYS +SWTLDNDILLIKLSTPAVINARVSTLLLPSACASAGTECLISGWGNTLSS +GVNYPDLLQCLVAPLLSHADCEASYPGQITNNMICAGFLEGGKDSCQGDS +GGPVACNGQLQGIVSWGYGCAQKGKPGVYTKVCNYVDWIQETIAANS +>sp|TRYP_PIG| +FPTDDDDKIVGGYTCAANSIPYQVSLNSGSHFCGGSLINSQWVVSAAHCY +KSRIQVRLGEHNIDVLEGNEQFINAAKIITHPNFNGNTLDNDIMLIKLSS +PATLNSRVATVSLPRSCAAAGTECLISGWGNTKSSGSSYPSLLQCLKAPV +LSDSSCKSSYPGQITGNMICVGFLEGGKDSCQGDSGGPVVCNGQLQGIVS +WGYGCAQKNKPGVYTKVCNYVNWIQQTIAAN +>sp|ALBU_HUMAN| +MKWVTFISLLFLFSSAYSRGVFRRDAHKSEVAHRFKDLGEENFKALVLIA +FAQYLQQCPFEDHVKLVNEVTEFAKTCVADESAENCDKSLHTLFGDKLCT +VATLRETYGEMADCCAKQEPERNECFLQHKDDNPNLPRLVRPEVDVMCTA +FHDNEETFLKKYLYEIARRHPYFYAPELLFFAKRYKAAFTECCQAADKAA +CLLPKLDELRDEGKASSAKQRLKCASLQKFGERAFKAWAVARLSQRFPKA +EFAEVSKLVTDLTKVHTECCHGDLLECADDRADLAKYICENQDSISSKLK +ECCEKPLLEKSHCIAEVENDEMPADLPSLAADFVESKDVCKNYAEAKDVF +LGMFLYEYARRHPDYSVVLLLRLAKTYETTLEKCCAAADPHECYAKVFDE +FKPLVEEPQNLIKQNCELFEQLGEYKFQNALLVRYTKKVPQVSTPTLVEV +SRNLGKVGSKCCKHPEAKRMPCAEDYLSVVLNQLCVLHEKTPVSDRVTKC +CTESLVNRRPCFSALEVDETYVPKEFNAETFTFHADICTLSEKERQIKKQ +TALVELVKHKPKATKEQLKAVMDDFAAFVEKCCKADDKETCFAEEGKKLV +AASQAALGL +>sp|ANT3_HUMAN| +MYSNVIGTVTSGKRKVYLLSLLLIGFWDCVTCHGSPVDICTAKPRDIPMN +PMCIYRSPEKKATEDEGSEQKIPEATNRRVWELSKANSRFATTFYQHLAD +SKNDNDNIFLSPLSISTAFAMTKLGACNDTLQQLMEVFKFDTISEKTSDQ +IHFFFAKLNCRLYRKANKSSKLVSANRLFGDKSLTFNETYQDISELVYGA +KLQPLDFKENAEQSRAAINKWVSNKTEGRITDVIPSEAINELTVLVLVNT +IYFKGLWKSKFSPENTRKELFYKADGESCSASMMYQEGKFRYRRVAEGTQ +VLELPFKGDDITMVLILPKPEKSLAKVEKELTPEVLQEWLDELEEMMLVV +HMPRFRIEDGFSLKEQLQDMGLVDLFSPEKSKLPGIVAEGRDDLYVSDAF +HKAFLEVNEEGSEAAASTAVVIAGRSLNPNRVTFKANRPFLVFIREVPLN +TIIFMGRVANPCVK +>sp|ANXA5_HUMAN| +AQVLRGTVTDFPGFDERADAETLRKAMKGLGTDEESILTLLTSRSNAQRQ +EISAAFKTLFGRDLLDDLKSELTGKFEKLIVALMKPSRLYDAYELKHALK +GAGTNEKVLTEIIASRTPEELRAIKQVYEEEYGSSLEDDVVGDTSGYYQR +MLVVLLQANRDPDAGIDEAQVEQDAQALFQAGELKWGTDEEKFITIFGTR +SVSHLRKVFDKYMTISGFQIEETIDRETSGNLEQLLLAVVKSIRSIPAYL +AETLYYAMKGAGTDDHTLIRVMVSRSEIDLFNIRKEFRKNFATSLYSMIK +GDTSGDYKKALLLLCGEDD +>sp|B2MG_HUMAN| +MSRSVALAVLALLSLSGLEAIQRTPKIQVYSRHPAENGKSNFLNCYVSGF +HPSDIEVDLLKNGERIEKVEHSDLSFSKDWSFYLLYYTEFTPTEKDEYAC +RVNHVTLSQPKIVKWDRDM +>sp|BID_HUMAN| +MDCEVNNGSSLRDECITNLLVFGFLQSCSDNSFRRELDALGHELPVLAPQ +WEGYDELQTDGNRSSHSRLGRIEADSESQEDIIRNIARHLAQVGDSMDRS +IPPGLVNGLALQLRNTSRSEEDRNRDLATALEQLLQAYPRDMEKEKTMLV +LALLLAKKVASHTPSLLRDVFHTTVNFINQNLRTYVRSLARNGMD +>sp|CAH1_HUMAN| +ASPDWGYDDKNGPEQWSKLYPIANGNNQSPVDIKTSETKHDTSLKPISVS +YNPATAKEIINVGHSFHVNFEDNDNRSVLKGGPFSDSYRLFQFHFHWGST +NEHGSEHTVDGVKYSAELHVAHWNSAKYSSLAEAASKADGLAVIGVLMKV +GEANPKLQKVLDALQAIKTKGKRAPFTNFDPSTLLPSSLDFWTYPGSLTH +PPLYESVTWIICKESISVSSEQLAQFRSLLSNVEGDNAVPMQHNNRPTQP +LKGRTVRASF +>sp|CAH2_HUMAN| +SHHWGYGKHNGPEHWHKDFPIAKGERQSPVDIDTHTAKYDPSLKPLSVSY +DQATSLRILNNGHAFNVEFDDSQDKAVLKGGPLDGTYRLIQFHFHWGSLD +GQGSEHTVDKKKYAAELHLVHWNTKYGDFGKAVQQPDGLAVLGIFLKVGS +AKPGLQKVVDVLDSIKTKGKSADFTNFDPRGLLPESLDYWTYPGSLTTPP +LLECVTWIVLKEPISVSSEQVLKFRKLNFNGEGEPEELMVDNWRPAQPLK +NRQIKASFK +>sp|CATA_HUMAN| +ADSRDPASDQMQHWKEQRAAQKADVLTTGAGNPVGDKLNVITVGPRGPLL +VQDVVFTDEMAHFDRERIPERVVHAKGAGAFGYFEVTHDITKYSKAKVFE +HIGKKTPIAVRFSTVAGESGSADTVRDPRGFAVKFYTEDGNWDLVGNNTP +IFFIRDPILFPSFIHSQKRNPQTHLKDPDMVWDFWSLRPESLHQVSFLFS +DRGIPDGHRHMNGYGSHTFKLVNANGEAVYCKFHYKTDQGIKNLSVEDAA +RLSQEDPDYGIRDLFNAIATGKYPSWTFYIQVMTFNQAETFPFNPFDLTK +VWPHKDYPLIPVGKLVLNRNPVNYFAEVEQIAFDPSNMPPGIEASPDKML +QGRLFAYPDTHRHRLGPNYLHIPVNCPYRARVANYQRDGPMCMQDNQGGA +PNYYPNSFGAPEQQPSALEHSIQYSGEVRRFNTANDDNVTQVRAFYVNVL +NEEQRKRLCENIAGHLKDAQIFIQKKAVKNFTEVHPDYGSHIQALLDKYN +AEKPKNAIHTFVQSGSHLAAREKANL +>sp|CATD_HUMAN| +MQPSSLLPLALCLLAAPASALVRIPLHKFTSIRRTMSEVGGSVEDLIAKG +PVSKYSQAVPAVTEGPIPEVLKNYMDAQYYGEIGIGTPPQCFTVVFDTGS +SNLWVPSIHCKLLDIACWIHHKYNSDKSSTYVKNGTSFDIHYGSGSLSGY +LSQDTVSVPCQSASSASALGGVKVERQVFGEATKQPGITFIAAKFDGILG +MAYPRISVNNVLPVFDNLMQQKLVDQNIFSFYLSRDPDAQPGGELMLGGT +DSKYYKGSLSYLNVTRKAYWQVHLDQVEVASGLTLCKEGCEAIVDTGTSL +MVGPVDEVRELQKAIGAVPLIQGEYMIPCEKVSTLPAITLKLGGKGYKLS +PEDYTLKVSQAGKTLCLSGFMGMDIPPPSGPLWILGDVFIGRYYTVFDRD +NNRVGFAEAARL +>sp|CATG_HUMAN| +MQPLLLLLAFLLPTGAEAGEIIGGRESRPHSRPYMAYLQIQSPAGQSRCG +GFLVREDFVLTAAHCWGSNINVTLGAHNIQRRENTQQHITARRAIRHPQY +NQRTIQNDIMLLQLSRRVRRNRNVNPVALPRAQEGLRPGTLCTVAGWGRV +SMRRGTDTLREVQLRVQRDRQCLRIFGSYDPRRQICVGDRRERKAAFKGD +SGGPLLCNNVAHGIVSYGKSSGVPPEVFTRVSSFLPWIRTTMRSFKLLDQ +METPL +>sp|CO5_HUMAN| +MGLLGILCFLIFLGKTWGQEQTYVISAPKIFRVGASENIVIQVYGYTEAF +DATISIKSYPDKKFSYSSGHVHLSSENKFQNSAILTIQPKQLPGGQNPVS +YVYLEVVSKHFSKSKRMPITYDNGFLFIHTDKPVYTPDQSVKVRVYSLND +DLKPAKRETVLTFIDPEGSEVDMVEEIDHIGIISFPDFKIPSNPRYGMWT +IKAKYKEDFSTTGTAYFEVKEYVLPHFSVSIEPEYNFIGYKNFKNFEITI +KARYFYNKVVTEADVYITFGIREDLKDDQKEMMQTAMQNTMLINGIAQVT +FDSETAVKELSYYSLEDLNNKYLYIAVTVIESTGGFSEEAEIPGIKYVLS +PYKLNLVATPLFLKPGIPYPIKVQVKDSLDQLVGGVPVILNAQTIDVNQE +TSDLDPSKSVTRVDDGVASFVLNLPSGVTVLEFNVKTDAPDLPEENQARE +GYRAIAYSSLSQSYLYIDWTDNHKALLVGEHLNIIVTPKSPYIDKITHYN +YLILSKGKIIHFGTREKFSDASYQSINIPVTQNMVPSSRLLVYYIVTGEQ +TAELVSDSVWLNIEEKCGNQLQVHLSPDADAYSPGQTVSLNMATGMDSWV +ALAAVDSAVYGVQRGAKKPLERVFQFLEKSDLGCGAGGGLNNANVFHLAG +LTFLTNANADDSQENDEPCKEILRPRRTLQKKIEEIAAKYKHSVVKKCCY +DGACVNNDETCEQRAARISLGPRCIKAFTECCVVASQLRANISHKDMQLG +RLHMKTLLPVSKPEIRSYFPESWLWEVHLVPRRKQLQFALPDSLTTWEIQ +GIGISNTGICVADTVKAKVFKDVFLEMNIPYSVVRGEQIQLKGTVYNYRT +SGMQFCVKMSAVEGICTSESPVIDHQGTKSSKCVRQKVEGSSSHLVTFTV +LPLEIGLHNINFSLETWFGKEILVKTLRVVPEGVKRESYSGVTLDPRGIY +GTISRRKEFPYRIPLDLVPKTEIKRILSVKGLLVGEILSAVLSQEGINIL +THLPKGSAEAELMSVVPVFYVFHYLETGNHWNIFHSDPLIEKQKLKKKLK +EGMLSIMSYRNADYSYSVWKGGSASTWLTAFALRVLGQVNKYVEQNQNSI +CNSLLWLVENYQLDNGSFKENSQYQPIKLQGTLPVEARENSLYLTAFTVI +GIRKAFDICPLVKIDTALIKADNFLLENTLPAQSTFTLAISAYALSLGDK +THPQFRSIVSALKREALVKGNPPIYRFWKDNLQHKDSSVPNTGTARMVET +TAYALLTSLNLKDINYVNPVIKWLSEEQRYGGGFYSTQDTINAIEGLTEY +SLLVKQLRLSMDIDVSYKHKGALHNYKMTDKNFLGRPVEVLLNDDLIVST +GFGSGLATVHVTTVVHKTSTSEEVCSFYLKIDTQDIEASHYRGYGNSDYK +RIVACASYKPSREESSSGSSHAVMDISLPTGISANEEDLKALVEGVDQLF +TDYQIKDGHVILQLNSIPSSDFLCVRFRIFELFEVGFLSPATFTVYEYHR +PDKQCTMFYSTSNIKIQKVCEGAACKCVEADCGQMQEELDLTISAETRKQ +TACKPEIAYAYKVSITSITVENVFVKYKATLLDIYKTGEAVAEKDSEITF +IKKVTCTNAELVKGRQYLIMGKEALQIKYNFSFRYIYPLDSLTWIEYWPR +DTTCSSCQAFLANLDEFAEDIFLNGC +>sp|CRP_HUMAN| +MEKLLCFLVLTSLSHAFGQTDMSRKAFVFPKESDTSYVSLKAPLTKPLKA +FTVCLHFYTELSSTRGYSIFSYATKRQDNEILIFWSKDIGYSFTVGGSEI +LFEVPEVTVAPVHICTSWESASGIVEFWVDGKPRVRKSLKKGYTVGAEAS +IILGQEQDSFGGNFEGSQSLVGDIGNVNMWDFVLSPDEINTIYLGGPFSP +NVLNWRALKYEVQGEVFTKPQLWP +>sp|CYB5_HUMAN| +AEQSDEAVKYYTLEEIQKHNHSKSTWLILHHKVYDLTKFLEEHPGGEEVL +REQAGGDATENFEDVGHSTDAREMSKTFIIGELHPDDRPKLNKPPETLIT +TIDSSSSWWTNWVIPAISAVAVALMYRLYMAED +>sp|CYC_HUMAN| +GDVEKGKKIFIMKCSQCHTVEKGGKHKTGPNLHGLFGRKTGQAPGYSYTA +ANKNKGIIWGEDTLMEYLENPKKYIPGTKMIFVGIKKKEERADLIAYLKK +ATNE +>sp|EGF_HUMAN| +MLLTLIILLPVVSKFSFVSLSAPQHWSCPEGTLAGNGNSTCVGPAPFLIF +SHGNSIFRIDTEGTNYEQLVVDAGVSVIMDFHYNEKRIYWVDLERQLLQR +VFLNGSRQERVCNIEKNVSGMAINWINEEVIWSNQQEGIITVTDMKGNNS +HILLSALKYPANVAVDPVERFIFWSSEVAGSLYRADLDGVGVKALLETSE +KITAVSLDVLDKRLFWIQYNREGSNSLICSCDYDGGSVHISKHPTQHNLF +AMSLFGDRIFYSTWKMKTIWIANKHTGKDMVRINLHSSFVPLGELKVVHP +LAQPKAEDDTWEPEQKLCKLRKGNCSSTVCGQDLQSHLCMCAEGYALSRD +RKYCEDVNECAFWNHGCTLGCKNTPGSYYCTCPVGFVLLPDGKRCHQLVS +CPRNVSECSHDCVLTSEGPLCFCPEGSVLERDGKTCSGCSSPDNGGCSQL +CVPLSPVSWECDCFPGYDLQLDEKSCAASGPQPFLLFANSQDIRHMHFDG +TDYGTLLSQQMGMVYALDHDPVENKIYFAHTALKWIERANMDGSQRERLI +EEGVDVPEGLAVDWIGRRFYWTDRGKSLIGRSDLNGKRSKIITKENISQP +RGIAVHPMAKRLFWTDTGINPRIESSSLQGLGRLVIASSDLIWPSGITID +FLTDKLYWCDAKQSVIEMANLDGSKRRRLTQNDVGHPFAVAVFEDYVWFS +DWAMPSVIRVNKRTGKDRVRLQGSMLKPSSLVVVHPLAKPGADPCLYQNG +GCEHICKKRLGTAWCSCREGFMKASDGKTCLALDGHQLLAGGEVDLKNQV +TPLDILSKTRVSEDNITESQHMLVAEIMVSDQDDCAPVGCSMYARCISEG +EDATCQCLKGFAGDGKLCSDIDECEMGVPVCPPASSKCINTEGGYVCRCS +EGYQGDGIHCLDIDECQLGVHSCGENASCTNTEGGYTCMCAGRLSEPGLI +CPDSTPPPHLREDDHHYSVRNSDSECPLSHDGYCLHDGVCMYIEALDKYA +CNCVVGYIGERCQYRDLKWWELRHAGHGQQQKVIVVAVCVVVLVMLLLLS +LWGAHYYRTQKLLSKNPKNPYEESSRDVRSRRPADTEDGMSSCPQPWFVV +IKEHQDLKNGGQPVAGEDGQAADGSMQPTSWRQEPQLCGMGTEQGCWIPV +SSDKGSCPQVMERSFHMPSYGTQTLEGGVEKPHSLLSANPLWQQRALDPP +HQMELTQ +>sp|FABPH_HUMAN| +VDAFLGTWKLVDSKNFDDYMKSLGVGFATRQVASMTKPTTIIEKNGDILT +LKTHSTFKNTEISFKLGVEFDETTADDRKVKSIVTLDGGKLVHLQKWDGQ +ETTLVRELIDGKLILTLTHGTAVCTRTYEKEA +>sp|GELS_HUMAN| +MAPHRPAPALLCALSLALCALSLPVRAATASRGASQAGAPQGRVPEARPN +SMVVEHPEFLKAGKEPGLQIWRVEKFDLVPVPTNLYGDFFTGDAYVILKT +VQLRNGNLQYDLHYWLGNECSQDESGAAAIFTVQLDDYLNGRAVQHREVQ +GFESATFLGYFKSGLKYKKGGVASGFKHVVPNEVVVQRLFQVKGRRVVRA +TEVPVSWESFNNGDCFILDLGNNIHQWCGSNSNRYERLKATQVSKGIRDN +ERSGRARVHVSEEGTEPEAMLQVLGPKPALPAGTEDTAKEDAANRKLAKL +YKVSNGAGTMSVSLVADENPFAQGALKSEDCFILDHGKDGKIFVWKGKQA +NTEERKAALKTASDFITKMDYPKQTQVSVLPEGGETPLFKQFFKNWRDPD +QTDGLGLSYLSSHIANVERVPFDAATLHTSTAMAAQHGMDDDGTGQKQIW +RIEGSNKVPVDPATYGQFYGGDSYIILYNYRHGGRQGQIIYNWQGAQSTQ +DEVAASAILTAQLDEELGGTPVQSRVVQGKEPAHLMSLFGGKPMIIYKGG +TSREGGQTAPASTRLFQVRANSAGATRAVEVLPKAGALNSNDAFVLKTPS +AAYLWVGTGASEAEKTGAQELLRVLRAQPVQVAEGSEPDGFWEALGGKAA +YRTSPRLKDKKMDAHPPRLFACSNKIGRFVIEEVPGELMQEDLATDDVML +LDTWDQVFVWVGKDSQEEEKTEALTSAKRYIETDPANRDRRTPITVVKQG +FEPPSFVGWFLGWDDDYWSVDPLDRAMAELAA +>sp|GSTA1_HUMAN| +AEKPKLHYFNARGRMESTRWLLAAAGVEFEEKFIKSAEDLDKLRNDGYLM +FQQVPMVEIDGMKLVQTRAILNYIASKYNLYGKDIKERALIDMYIEGIAD +LGEMILLLPVCPPEEKDAKLALIKEKIKNRYFPAFEKVLKSHGQDYLVGN +KLSRADIHLVELLYYVEELDSSLISSFPLLKALKTRISNLPTVKKFLQPG +SPRKPPMDEKSLEEARKIFRF +>sp|GSTP1_HUMAN| +PPYTVVYFPVRGRCAALRMLLADQGQSWKEEVVTVETWQEGSLKASCLYG +QLPKFQDGDLTLYQSNTILRHLGRTLGLYGKDQQEAALVDMVNDGVEDLR +CKYISLIYTNYEAGKDDYVKALPGQLKPFETLLSQNQGGKTFIVGDQISF +ADYNLLDLLLIHEVLAPGCLDAFPLLSAYVGRLSARPKLKAFLASPEYVN +LPINGNGKQ +>sp|HBA_HUMAN| +VLSPADKTNVKAAWGKVGAHAGEYGAEALERMFLSFPTTKTYFPHFDLSH +GSAQVKGHGKKVADALTNAVAHVDDMPNALSALSDLHAHKLRVDPVNFKL +LSHCLLVTLAAHLPAEFTPAVHASLDKFLASVSTVLTSKYR +>sp|HBB_HUMAN| +VHLTPEEKSAVTALWGKVNVDEVGGEALGRLLVVYPWTQRFFESFGDLST +PDAVMGNPKVKAHGKKVLGAFSDGLAHLDNLKGTFATLSELHCDKLHVDP +ENFRLLGNVLVCVLAHHFGKEFTPPVQAAYQKVVAGVANALAHKYH +>sp|IGF2_HUMAN| +MGIPMGKSMLVLLTFLAFASCCIAAYRPSETLCGGELVDTLQFVCGDRGF +YFSRPASRVSRRSRGIVEECCFRSCDLALLETYCATPAKSERDVSTPPTV +LPDNFPRYPVGKFFQYDTWKQSTQRLRRGLPALLRARRGHVLAKELEAFR +EAKRHRPLIALPTQDPAHGGAPPEMASNRK +>sp|IL8_HUMAN| +MTSKLAVALLAAFLISAALCEGAVLPRSAKELRCQCIKTYSKPFHPKFIK +ELRVIESGPHCANTEIIVKLSDGRELCLDPKENWVQRVVEKFLKRAENS +>sp|KCRM_HUMAN| +MPFGNTHNKFKLNYKPEEEYPDLSKHNNHMAKVLTLELYKKLRDKETPSG +FTVDDVIQTGVDNPGHPFIMTVGCVAGDEESYEVFKELFDPIISDRHGGY +KPTDKHKTDLNHENLKGGDDLDPNYVLSSRVRTGRSIKGYTLPPHCSRGE +RRAVEKLSVEALNSLTGEFKGKYYPLKSMTEKEQQQLIDDHFLFDKPVSP +LLLASGMARDWPDARGIWHNDNKSFLVWVNEEDHLRVISMEKGGNMKEVF +RRFCVGLQKIEEIFKKAGHPFMWNQHLGYVLTCPSNLGTGLRGGVHVKLA +HLSKHPKFEEILTRLRLQKRGTGGVDTAAVGSVFDVSNADRLGSSEVEQV +QLVVDGVKLMVEMEKKLEKGQSIDDMIPAQK +>sp|LALBA_HUMAN| +MRFFVPLFLVGILFPAILAKQFTKCELSQLLKDIDGYGGIALPELICTMF +HTSGYDTQAIVENNESTEYGLFQISNKLWCKSSQVPQSRNICDISCDKFL +DDDITDDIMCAKKILDIKGIDYWLAHKALCTEKLEQWLCEKL +>sp|LEP_HUMAN| +MHWGTLCGFLWLWPYLFYVQAVPIQKVQDDTKTLIKTIVTRINDISHTQS +VSSKQKVTGLDFIPGLHPILTLSKMDQTLAVYQQILTSMPSRNVIQISND +LENLRDLLHVLAFSKSCHLPWASGLETLDSLGGVLEASGYSTEVVALSRL +QGSLQDMLWQLDLSPGC +>sp|LYSC_HUMAN| +MKALIVLGLVLLSVTVQGKVFERCELARTLKRLGMDGYRGISLANWMCLA +KWESGYNTRATNYNAGDRSTDYGIFQINSRYWCNDGKTPGAVNACHLSCS +ALLQDNIADAVACAKRVVRDPQGIRAWVAWRNRCQNRDVRQYVQGCGV +>sp|MYG_HUMAN| +GLSDGEWQLVLNVWGKVEADIPGHGQEVLIRLFKGHPETLEKFDKFKHLK +SEDEMKASEDLKKHGATVLTALGGILKKKGHHEAEIKPLAQSHATKHKIP +VKYLEFISECIIQVLQSKHPGDFGADAQGAMNKALELFRKDMASNYKELG +FQG +>sp|NEDD8_HUMAN| +MLIKVKTLTGKEIEIDIEPTDKVERIKERVEEKEGIPPQQQRLIYSGKQM +NDEKTAADYKILGGSVLHLVLALRGGGGLRQ +>sp|NQO1_HUMAN| +MVGRRALIVLAHSERTSFNYAMKEAAAAALKKKGWEVVESDLYAMNFNPI +ISRKDITGKLKDPANFQYPAESVLAYKEGHLSPDIVAEQKKLEAADLVIF +QFPLQWFGVPAILKGWFERVFIGEFAYTYAAMYDKGPFRSKKAVLSITTG +GSGSMYSLQGIHGDMNVILWPIQSGILHFCGFQVLEPQLTYSIGHTPADA +RIQILEGWKKRLENIWDETPLYFAPSSLFDLNFQAGFLMKKEVQDEEKNK +KFGLSVGHHLGKSIPTDNQIKARK +>sp|NQO2_HUMAN| +AGKKVLIVYAHQEPKSFNGSLKNVAVDELSRQGCTVTVSDLYAMNFEPRA +TDKDITGTLSNPEVFNYGVETHEAYKQRSLASDITDEQKKVREADLVIFQ +FPLYWFSVPAILKGWMDRVLCQGFAFDIPGFYDSGLLQGKLALLSVTTGG +TAEMYTKTGVNGDSRYFLWPLQHGTLHFCGFKVLAPQISFAPEIASEEER +KGMVAAWSQRLQTIWKEEPIPCTAHWHFGQ +>sp|PDGFB_HUMAN| +MNRCWALFLSLCCYLRLVSAEGDPIPEELYEMLSDHSIRSFDDLQRLLHG +DPGEEDGAELDLNMTRSHSGGELESLARGRRSLGSLTIAEPAMIAECKTR +TEVFEISRRLIDRTNANFLVWPPCVEVQRCSGCCNNRNVQCRPTQVQLRP +VQVRKIEIVRKKPIFKKATVTLEDHLACKCETVAAARPVTRSPGGSQEQR +AKTPQTRVTIRTVRVRRPPKGKHRKFKHTHDKTALKETLGA +>sp|PPIA_HUMAN| +VNPTVFFDIAVDGEPLGRVSFELFADKVPKTAENFRALSTGEKGFGYKGS +CFHRIIPGFMCQGGDFTRHNGTGGKSIYGEKFEDENFILKHTGPGILSMA +NAGPNTNGSQFFICTAKTEWLDGKHVVFGKVKEGMNIVEAMERFGSRNGK +TSKKITIADCGQLE +>sp|PRDX1_HUMAN| +MSSGNAKIGHPAPNFKATAVMPDGQFKDISLSDYKGKYVVFFFYPLDFTF +VCPTEIIAFSDRAEEFKKLNCQVIGASVDSHFCHLAWVNTPKKQGGLGPM +NIPLVSDPKRTIAQDYGVLKADEGISFRGLFIIDDKGILRQITVNDLPVG +RSVDETLRLVQAFQFTDKHGEVCPAGWKPGSDTIKPDVQKSKEYFSKQK +>sp|RASH_HUMAN| +MTEYKLVVVGAGGVGKSALTIQLIQNHFVDEYDPTIEDSYRKQVVIDGET +CLLDILDTAGQEEYSAMRDQYMRTGEGFLCVFAINNTKSFEDIHQYREQI +KRVKDSDDVPMVLVGNKCDLAARTVESRQAQDLARSYGIPYIETSAKTRQ +GVEDAFYTLVREIRQHKLRKLNPPDESGPGCMSCKCVLS +>sp|RETBP_HUMAN| +MKWVWALLLLAALGSGRAERDCRVSSFRVKENFDKARFSGTWYAMAKKDP +EGLFLQDNIVAEFSVDETGQMSATAKGRVRLLNNWDVCADMVGTFTDTED +PAKFKMKYWGVASFLQKGNDDHWIVDTDYDTYAVQYSCRLLNLDGTCADS +YSFVFSRDPNGLPPEAQKIVRQRQEELCLARQYRLIVHNGYCDGRSERNL +L +>sp|SODC_HUMAN| +ATKAVCVLKGDGPVQGIINFEQKESNGPVKVWGSIKGLTEGLHGFHVHEF +GDNTAGCTSAGPHFNPLSRKHGGPKDEERHVGDLGNVTADKDGVADVSIE +DSVISLSGDHCIIGRTLVVHEKADDLGKGGNEESTKTGNAGSRLACGVIG +IAQ +>sp|SUMO1_HUMAN| +MSDQEAKPSTEDLGDKKEGEYIKLKVIGQDSSEIHFKVKMTTHLKKLKES +YCQRQGVPMNSLRFLFEGQRIADNHTPKELGMEEEDVIEVYQEQTGGHST +V +>sp|SYH_HUMAN| +MAERAALEELVKLQGERVRGLKQQKASAELIEEEVAKLLKLKAQLGPDES +KQKFVLKTPKGTRDYSPRQMAVREKVFDVIIRCFKRHGAEVIDTPVFELK +ETLMGKYGEDSKLIYDLKDQGGELLSLRYDLTVPFARYLAMNKLTNIKRY +HIAKVYRRDNPAMTRGRYREFYQCDFDIAGNFDPMIPDAECLKIMCEILS +SLQIGDFLVKVNDRRILDGMFAICGVSDSKFRTICSSVDKLDKVSWEEVK +NEMVGEKGLAPEVADRIGDYVQQHGGVSLVEQLLQDPKLSQNKQALEGLG +DLKLLFEYLTLFGIDDKISFDLSLARGLDYYTGVIYEAVLLQTPAQAGEE +PLGVGSVAAGGRYDGLVGMFDPKGRKVPCVGLSIGVERIFSIVEQRLEAL +EEKIRTTETQVLVASAQKKLLEERLKLVSELWDAGIKAELLYKKNPKLLN +QLQYCEEAGIPLVAIIGEQELKDGVIKLRSVTSREEVDVRREDLVEEIKR +RTGQPLCIC +>sp|TAU_HUMAN| +AEPRQEFEVMEDHAGTYGLGDRKDQGGYTMHQDQEGDTDAGLKESPLQTP +TEDGSEEPGSETSDAKSTPTAEDVTAPLVDEGAPGKQAAAQPHTEIPEGT +TAEEAGIGDTPSLEDEAAGHVTQEPESGKVVQEGFLREPGPPGLSHQLMS +GMPGAPLLPEGPREATRQPSGTGPEDTEGGRHAPELLKHQLLGDLHQEGP +PLKGAGGKERPGSKEEVDEDRDVDESSPQDSPPSKASPAQDGRPPQTAAR +EATSIPGFPAEGAIPLPVDFLSKVSTEIPASEPDGPSVGRAKGQDAPLEF +TFHVEITPNVQKEQAHSEEHLGRAAFPGAPGEGPEARGPSLGEDTKEADL +PEPSEKQPAAAPRGKPVSRVPQLKARMVSKSKDGTGSDDKKAKTSTRSSA +KTLKNRPCLSPKLPTPGSSDPLIQPSSPAVCPEPPSSPKHVSSVTSRTGS +SGAKEMKLKGADGKTKIATPRGAAPPGQKGQANATRIPAKTPPAPKTPPS +SGEPPKSGDRSGYSSPGSPGTPGSRSRTPSLPTPPTREPKKVAVVRTPPK +SPSSAKSRLQTAPVPMPDLKNVKSKIGSTENLKHQPGGGKVQIINKKLDL +SNVQSKCGSKDNIKHVPGGGSVQIVYKPVDLSKVTSKCGSLGNIHHKPGG +GQVEVKSEKLDFKDRVQSKIGSLDNITHVPGGGNKKIETHKLTFRENAKA +KTDHGAEIVYKSPVVSGDTSPRHLSNVSSTGSIDMVDSPQLATLADEVSA +SLAKQGL +>sp|THIO_HUMAN| +VKQIESKTAFQEALDAAGDKLVVVDFSATWCGPCKMIKPFFHSLSEKYSN +VIFLEVDVDDCQDVASECEVKCMPTFQFFKKGQKVGEFSGANKEKLEATI +NELV +>sp|TNFA_HUMAN| +MSTESMIRDVELAEEALPKKTGGPQGSRRCLFLSLFSFLIVAGATTLFCL +LHFGVIGPQREEFPRDLSLISPLAQAVRSSSRTPSDKPVAHVVANPQAEG +QLQWLNRRANALLANGVELRDNQLVVPSEGLYLIYSQVLFKGQGCPSTHV +LLTHTISRIAVSYQTKVNLLSAIKSPCQRETPEGAEAKPWYEPIYLGGVF +QLEKGDRLSAEINRPDYLDFAESGQVYFGIIAL +>sp|TRFE_HUMAN| +MRLAVGALLVCAVLGLCLAVPDKTVRWCAVSEHEATKCQSFRDHMKSVIP +SDGPSVACVKKASYLDCIRAIAANEADAVTLDAGLVYDAYLAPNNLKPVV +AEFYGSKEDPQTFYYAVAVVKKDSGFQMNQLRGKKSCHTGLGRSAGWNIP +IGLLYCDLPEPRKPLEKAVANFFSGSCAPCADGTDFPQLCQLCPGCGCST +LNQYFGYSGAFKCLKDGAGDVAFVKHSTIFENLANKADRDQYELLCLDNT +RKPVDEYKDCHLAQVPSHTVVARSMGGKEDLIWELLNQAQEHFGKDKSKE +FQLFSSPHGKDLLFKDSAHGFLKVPPRMDAKMYLGYEYVTAIRNLREGTC +PEAPTDECKPVKWCALSHHERLKCDEWSVNSVGKIECVSAETTEDCIAKI +MNGEADAMSLDGGFVYIAGKCGLVPVLAENYNKSDNCEDTPEAGYFAVAV +VKKSASDLTWDNLKGKKSCHTAVGRTAGWNIPMGLLYNKINHCRFDEFFS +EGCAPGSKKDSSLCKLCMGSGLNLCEPNNKEGYYGYTGAFRCLVEKGDVA +FVKHQTVPQNTGGKNPDPWAKNLNEKDYELLCLDGTRKPVEEYANCHLAR +APNHAVVTRKDKEACVHKILRQQQHLFGSNVTDCSGNFCLFRSETKDLLF +RDDTVCLAKLHDRNTYEKYLGEEYVKAVGNLRKCSTSSLLEACTFRRP +>sp|TRFL_HUMAN| +MKLVFLVLLFLGALGLCLAGRRRSVQWCAVSQPEATKCFQWQRNMRKVRG +PPVSCIKRDSPIQCIQAIAENRADAVTLDGGFIYEAGLAPYKLRPVAAEV +YGTERQPRTHYYAVAVVKKGGSFQLNELQGLKSCHTGLRRTAGWNVPIGT +LRPFLNWTGPPEPIEAAVARFFSASCVPGADKGQFPNLCRLCAGTGENKC +AFSSQEPYFSYSGAFKCLRDGAGDVAFIRESTVFEDLSDEAERDEYELLC +PDNTRKPVDKFKDCHLARVPSHAVVARSVNGKEDAIWNLLRQAQEKFGKD +KSPKFQLFGSPSGQKDLLFKDSAIGFSRVPPRIDSGLYLGSGYFTAIQNL +RKSEEEVAARRARVVWCAVGEQELRKCNQWSGLSEGSVTCSSASTTEDCI +ALVLKGEADAMSLDGGYVYTAGKCGLVPVLAENYKSQQSSDPDPNCVDRP +VEGYLAVAVVRRSDTSLTWNSVKGKKSCHTAVDRTAGWNIPMGLLFNQTG +SCKFDEYFSQSCAPGSDPRSNLCALCIGDEQGENKCVPNSNERYYGYTGA +FRCLAENAGDVAFVKDVTVLQNTDGNNNEAWAKDLKLADFALLCLDGKRK +PVTEARSCHLAMAPNHAVVSRMDKVERLKQVLLHQQAKFGRNGSDCPDKF +CLFQSETKNLLFNDNTECLARLHGKTTYEKYLGPQYVAGITNLKKCSTSP +LLEACEFLRK +>sp|UB2E1_HUMAN| +MSDDDSRASTSSSSSSSSNQQTEKETNTPKKKESKVSMSKNSKLLSTSAK +RIQKELADITLDPPPNCSAGPKGDNIYEWRSTILGPPGSVYEGGVFFLDI +TFTPEYPFKPPKVTFRTRIYHCNINSQGVICLDILKDNWSPALTISKVLL +SICSLLTDCNPADPLVGSIATQYMTNRAEHDRMARQWTKRYAT +>sp|UBE2C_HUMAN| +MASQNRDPAATSVAAARKGAEPSGGAARGPVGKRLQQELMTLMMSGDKGI +SAFPESDNLFKWVGTIHGAAGTVYEDLRYKLSLEFPSGYPYNAPTVKFLT +PCYHPNVDTQGNICLDILKEKWSALYDVRTILLSIQSLLGEPNIDSPLNT +HAAELWKNPTAFKKYLQETYSKQVTSQEP +>sp|UBE2I_HUMAN| +MSGIALSRLAQERKAWRKDHPFGFVAVPTKNPDGTMNLMNWECAIPGKKG +TPWEGGLFKLRMLFKDDYPSSPPKCKFEPPLFHPNVYPSGTVCLSILEED +KDWRPAITIKQILLGIQELLNEPNIQDPAQAEAYTIYCQNRVEYEKRVRA +QAKKFAPS +>sp|RS27A_HUMAN| +MQIFVKTLTGKTITLEVEPSDTIENVKAKIQDKEGIPPDQQRLIFAGKQL +EDGRTLSDYNIQKESTLHLVLRLRGGAKKRKKKSYTTPKKNKHKRKKVKL +AVLKYYKVDENGKISRLRRECPSDECGAGVFMASHFDRHYCGKCCLTYCF +NKPEDK +>sp|GAG_SCVLA| +MLRFVTKNSQDKSSDLFSICSDRGTFVAHNRVRTDFKFDNLVFNRVYGVS +QKFTLVGNPTVCFNEGSSYLEGIAKKYLTLDGGLAIDNVLNELRSTCGIP +GNAVASHAYNITSWRWYDNHVALLMNMLRAYHLQVLTEQGQYSAGDIPMY +HDGHVKIKLPVTIDDTAGPTQFAWPSDRSTDSYPDWAQFSESFPSIDVPY +LDVRPLTVTEVNFVLMMMSKWHRRTNLAIDYEAPQLADKFAYRHALTVQD +ADEWIEGDRTDDQFRPPSSKVMLSALRKYVNHNRLYNQFYTAAQLLAQIM +MKPVPNCAEGYAWLMHDALVNIPKFGSIRGRYPFLLSGDAALIQATALED +WSAIMAKPELVFTYAMQVSVALNTGLYLRRVKKTGFGTTIDDSYEDGAFL +QPETFVQAALACCTGQDAPLNGMSDVYVTYPDLLEFDAVTQVPITVIEPA +GYNIVDDHLVVVGVPVACSPYMIFPVAAFDTANPYCGNFVIKAANKYLRK +GAVYDKLEAWKLAWALRVAGYDTHFKVYGDTHGLTKFYADNGDTWTHIPE +FVTDGDVMEVFVTAIERRARHFVELPRLNSPAFFRSVEVSTTIYDTHVQA +GAHAVYHASRINLDYVKPVSTGIQVINAGELKNYWGSVRRTQQGLGVVGL +TMPAVMPTGEPTAGAAHEELIEQADNVLVE +>sp|CYC_HORSE| +MGDVEKGKKIFVQKCAQCHTVEKGGKHKTGPNLHGLFGRKTGQAPGFTYT +DANKNKGITWKEETLMEYLENPKKYIPGTKMIFAGIKKKTEREDLIAYLK +KATNE +>sp|CAH2_BOVIN| +MSHHWGYGKHNGPEHWHKDFPIANGERQSPVDIDTKAVVQDPALKPLALV +YGEATSRRMVNNGHSFNVEYDDSQDKAVLKDGPLTGTYRLVQFHFHWGSS +DDQGSEHTVDRKKYAAELHLVHWNTKYGDFGTAAQQPDGLAVVGVFLKVG +DANPALQKVLDALDSIKTKGKSTDFPNFDPGSLLPNVLDYWTYPGSLTTP +PLLESVTWIVLKEPISVSSQQMLKFRTLNFNAEGEPELLMLANWRPAQPL +KNRQVRGFPK +>sp|ADH1_YEAST| +MSIPETQKGVIFYESHGKLEHKDIPVPKPKANELLINVKYSGVCHTDLHA +WHGDWPLPVKLPLVGGHEGAGVVVGMGENVKGWKIGDYAGIKWLNGSCMA +CEYCELGNESNCPHADLSGYTHDGSFQQYATADAVQAAHIPQGTDLAQVA +PILCAGITVYKALKSANLMAGHWVAISGAAGGLGSLAVQYAKAMGYRVLG +IDGGEGKEELFRSIGGEVFIDFTKEKDIVGAVLKATDGGAHGVINVSVSE +AAIEASTRYVRANGTTVLVGMPAGAKCCSDVFNQVVKSISIVGSYVGNRA +DTREALDFFARGLVKSPIKVVGLSTLPEIYEKMEKGQIVGRYVVDTSK +>sp|ALDOA_RABIT| +MPHSHPALTPEQKKELSDIAHRIVAPGKGILAADESTGSIAKRLQSIGTE +NTEENRRFYRQLLLTADDRVNPCIGGVILFHETLYQKADDGRPFPQVIKS +KGGVVGIKVDKGVVPLAGTNGETTTQGLDGLSERCAQYKKDGADFAKWRC +VLKIGEHTPSALAIMENANVLARYASICQQNGIVPIVEPEILPDGDHDLK +RCQYVTEKVLAAVYKALSDHHIYLEGTLLKPNMVTPGHACTQKYSHEEIA +MATVTALRRTVPPAVTGVTFLSGGQSEEEASINLNAINKCPLLKPWALTF +SYGRALQASALKAWGGKKENLKAAQEEYVKRALANSLACQGKYTPSGQAG +AAASESLFIS +>sp|LYSC_CHICK| +MRSLLILVLCFLPLAALGKVFGRCELAAAMKRHGLDNYRGYSLGNWVCAA +KFESNFNTQATNRNTDGSTDYGILQINSRWWCNDGRTPGSRNLCNIPCSA +LLSSDITASVNCAKKIVSDGNGMNAWVAWRNRCKGTDVQAWIRGCRL +>sp|MYG_HORSE| +MGLSDGEWQQVLNVWGKVEADIAGHGQEVLIRLFTGHPETLEKFDKFKHL +KTEAEMKASEDLKKHGTVVLTALGGILKKKGHHEAELKPLAQSHATKHKI +PIKYLEFISDAIIHVLHSKHPGDFGADAQGAMTKALELFRNDIAAKYKEL +GFQG +>sp|OVAL_CHICK| +MGSIGAASMEFCFDVFKELKVHHANENIFYCPIAIMSALAMVYLGAKDST +RTQINKVVRFDKLPGFGDSIEAQCGTSVNVHSSLRDILNQITKPNDVYSF +SLASRLYAEERYPILPEYLQCVKELYRGGLEPINFQTAADQARELINSWV +ESQTNGIIRNVLQPSSVDSQTAMVLVNAIVFKGLWEKAFKDEDTQAMPFR +VTEQESKPVQMMYQIGLFRVASMASEKMKILELPFASGTMSMLVLLPDEV +SGLEQLESIINFEKLTEWTSSNVMEERKIKVYLPRMKMEEKYNLTSVLMA +MGITDVFSSSANLSGISSAESLKISQAVHAAHAEINEAGREVVGSAEAGV +DAASVSEEFRADHPFLFCIKHIATNAVLFFGRCVSP +>sp|BGAL_ECOLI| +MTMITDSLAVVLQRRDWENPGVTQLNRLAAHPPFASWRNSEEARTDRPSQ +QLRSLNGEWRFAWFPAPEAVPESWLECDLPEADTVVVPSNWQMHGYDAPI +YTNVTYPITVNPPFVPTENPTGCYSLTFNVDESWLQEGQTRIIFDGVNSA +FHLWCNGRWVGYGQDSRLPSEFDLSAFLRAGENRLAVMVLRWSDGSYLED +QDMWRMSGIFRDVSLLHKPTTQISDFHVATRFNDDFSRAVLEAEVQMCGE +LRDYLRVTVSLWQGETQVASGTAPFGGEIIDERGGYADRVTLRLNVENPK +LWSAEIPNLYRAVVELHTADGTLIEAEACDVGFREVRIENGLLLLNGKPL +LIRGVNRHEHHPLHGQVMDEQTMVQDILLMKQNNFNAVRCSHYPNHPLWY +TLCDRYGLYVVDEANIETHGMVPMNRLTDDPRWLPAMSERVTRMVQRDRN +HPSVIIWSLGNESGHGANHDALYRWIKSVDPSRPVQYEGGGADTTATDII +CPMYARVDEDQPFPAVPKWSIKKWLSLPGETRPLILCEYAHAMGNSLGGF +AKYWQAFRQYPRLQGGFVWDWVDQSLIKYDENGNPWSAYGGDFGDTPNDR +QFCMNGLVFADRTPHPALTEAKHQQQFFQFRLSGQTIEVTSEYLFRHSDN +ELLHWMVALDGKPLASGEVPLDVAPQGKQLIELPELPQPESAGQLWLTVR +VVQPNATAWSEAGHISAWQQWRLAENLSVTLPAASHAIPHLTTSEMDFCI +ELGNKRWQFNRQSGFLSQMWIGDKKQLLTPLRDQFTRAPLDNDIGVSEAT +RIDPNAWVERWKAAGHYQAEAALLQCTADTLADAVLITTAHAWQHQGKTL +FISRKTYRIDGSGQMAITVDVEVASDTPHPARIGLNCQLAQVAERVNWLG +LGPQENYPDRLTAACFDRWDLPLSDMYTPYVFPSENGLRCGTRELNYGPH +QWRGDFQFNISRYSQQQLMETSHRHLLHAEEGTWLNIDGFHMGIGGDDSW +SPSVSAEFQLSAGRYHYQLVWCQK +>sp|DHE3_BOVIN| +MYRYLGEALLLSRAGPAALGSASADSAALLGWARGQPAAAPQPGLVPPAR +RHYSEAAADREDDPNFFKMVEGFFDRGASIVEDKLVEDLKTRETEEQKRN +RVRSILRIIKPCNHVLSLSFPIRRDDGSWEVIEGYRAQHSQHRTPCKGGI +RYSTDVSVDEVKALASLMTYKCAVVDVPFGGAKAGVKINPKNYTDNELEK +ITRRFTMELAKKGFIGPGVDVPAPDMSTGEREMSWIADTYASTIGHYDIN +AHACVTGKPISQGGIHGRISATGRGVFHGIENFINEASYMSILGMTPGFG +DKTFVVQGFGNVGLHSMRYLHRFGAKCITVGESDGSIWNPDGIDPKELED +FKLQHGTILGFPKAKIYEGSILEVDCDILIPAASEKQLTKSNAPRVKAKI +IAEGANGPTTPEADKIFLERNIMVIPDLYLNAGGVTVSYFEWLNNLNHVS +YGRLTFKYERDSNYHLLMSVQESLERKFGKHGGTIPIVPTAEFQDRISGA +SEKDIVHSGLAYTMERSARQIMRTAMKYNLGLDLRTAAYVNAIEKVFRVY +NEAGVTFT +>sp|GFP_AEQVI| +MSKGEELFTGVVPILVELDGDVNGHKFSVSGEGEGDATYGKLTLKFICTT +GKLPVPWPTLVTTFSYGVQCFSRYPDHMKQHDFFKSAMPEGYVQERTIF +FKDDGNYKTRAEVKFEGDTLVNRIELKGIDFKEDGNILGHKLEYNYNSH +NVYIMADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPD +NHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK +>sp|SRPP_HEVBR| +MAEEVEEERLKYLDFVRAAGVYAVDSFSTLYLYAKDISGPLKPGVDTIEN +VVKTVVTPVYYIPLEAVKFVDKTVDVSVTSLDGVVPPVIKQVSAQTYSVA +QDAPRIVLDVASSVFNTGVQEGAKALYANLEPKAEQYAVITWRALNKLPL +VPQVANVVVPTAVYFSEKYNDVVRGTTEQGYRVSSYLPLLPTEKITKVFG +DEAS +>sp|REF_HEVBR| +MAEDEDNQQGQGEGLKYLGFVQDAATYAVTTFSNVYLFAKDKSGPLQPGV +DIIEGPVKNVAVPLYNRFSYIPNGALKFVDSTVVASVTIIDRSLPPIVKD +ASIQVVSAIRAAPEAARSLASSLPGQTKILAKVFYGEN +>sp|PLMP_GRIFR| +MFSSVMVALVSLAVAVSANPGLSLKVSGPEAVDGVNNLKVVTTITNTGDE +TLKLLNDPRGALHTMPTDTFAITNESGETPSFIGVKVKYVPSMAAKSTGE +NVFAVIAPGQSVNVEHDLSAAYNFTSSGAGTYALEALNVFNYIDPETNEP +VEIWADAEAHTTAVSGKLAVVRATPTLTRPVTYNGCSSSEQSALAAAASA +AQSYVAESLSYLQTHTAATPRYTTWFGSYISSRHSTVLQHYTDMNSNDFS +SYSFDCTCTAAGTFAYVYPNRFGTVYLCGAFWKAPTTGTDSQAGTLVHES +SHFTRNGGTKDYAYGQAAAKSLATMDPDKAVMNADNHEYFSENNPAQS +>KKA1_ECOLX +MSHIQRETSCSRPRLNSNLDADLYGYKWARDNVGQSGATIYRLYGKPDAP +ELFLKHGKGSVANDVTDEMVRLNWLTEFMPLPTIKHFIRTPDDAWLLTTA +IPGKTAFQVLEEYPDSGENIVDALAVFLRRLHSIPVCNCPFNSDRVFRLA +QAQSRMNNGLVDASDFDDERNGWPVEQVWKEMHKLLPFSPDSVVTHGDFS +LDNLIFDEGKLIGCIDVGRVGIADRYQDLAILWNCLGEFSPSLQKRLFQK +YGIDNPDMNKLQFHLMLDEFF diff --git a/src/WorkflowTest.py b/src/WorkflowTest.py index 30d19b4..149ec68 100644 --- a/src/WorkflowTest.py +++ b/src/WorkflowTest.py @@ -16,6 +16,7 @@ from src.common.common import page_setup from src.common.results_helpers import get_abundance_data from src.common.results_helpers import parse_idxml, build_spectra_cache, load_idxml, write_psm_exports +from src.common.contaminants import CONTAMINANT_PREFIX, append_fasta, write_contaminants from openms_insight import Table, Heatmap, LinePlot, SequenceView # Accession prefixes that mark decoy entries in a FASTA database. @@ -169,6 +170,21 @@ def filter_psms(self, in_files: list, out_files: list, tool_instance_name: str = tool_instance_name=tool_instance_name, ) + def render_contaminant_option(self): + """Checkbox for appending the cRAP contaminants to the search database.""" + self.ui.input_widget( + key="add-contaminants", + default=True, + name="Add common contaminants (cRAP)", + widget_type="checkbox", + help=( + "Search the 116 proteins of the common Repository of Adventitious Proteins " + "(keratins, trypsin, BSA, ...) with your database. Their accessions start with " + f"{CONTAMINANT_PREFIX}; they are flagged in the PSM tables and left out of the " + "protein tables and the downstream analysis unless you show them." + ), + ) + def render_lfq_tabs(self): st.subheader("LFQ Analysis Mode") t = st.tabs(["**Identification**", "**Rescoring**", "**Filtering**", "**Library Generation**", "**Quantification**", "**Group Selection**"]) @@ -185,6 +201,7 @@ def render_lfq_tabs(self): help="Generate decoy sequences for FDR calculation. Switched off automatically when the selected FASTA already contains decoys (e.g. DECOY_ or rev_ accessions).", reactive=True, ) + self.render_contaminant_option() # Reload params to get current checkbox value after it was saved self.params = self.parameter_manager.get_parameters_from_json() @@ -447,6 +464,7 @@ def render_tmt_tabs(self): help="Generate decoy sequences for FDR calculation. Switched off automatically when the selected FASTA already contains decoys (e.g. DECOY_ or rev_ accessions).", reactive=True, ) + self.render_contaminant_option() # Reload params to get current checkbox value after it was saved self.params = self.parameter_manager.get_parameters_from_json() @@ -744,6 +762,69 @@ def _has_identifications(self, idxml_files: list, stage: str) -> bool: self.logger.log("Workflow stopped due to error") return False + def prepare_search_database(self, fasta_path: Path): + """Build the database to search: the FASTA, the cRAP contaminants and decoys. + + Returns ``(database_fasta, decoy_string)``, or None when a TOPP tool failed. + """ + # Contaminants (cRAP with CON__ accessions) are searched with the targets + add_contaminants = self.params.get("add-contaminants", True) + db_dir = Path(self.workflow_dir, "results", "database") + con_fasta = db_dir / "contaminants.fasta" + if add_contaminants: + n_con = write_contaminants(con_fasta) + self.logger.log(f"🧫 Adding {n_con} contaminant proteins (cRAP, {CONTAMINANT_PREFIX} accessions)") + + if self.params.get("generate-decoys", True): + # Get decoy_string from DecoyDatabase params + decoy_string = self.params.get("DecoyDatabase", {}).get("decoy_string", "rev_") + if add_contaminants: + # DecoyDatabase reads both files, so the contaminants get decoys too + decoy_fasta = db_dir / f"{fasta_path.stem}.con.decoy.fasta" + decoy_inputs = [str(fasta_path), str(con_fasta)] + stale = decoy_fasta.exists() and decoy_fasta.stat().st_mtime < fasta_path.stat().st_mtime + else: + decoy_fasta = fasta_path.with_suffix(".decoy.fasta") + decoy_inputs = [str(fasta_path)] + stale = False + + if not decoy_fasta.exists() or stale: + self.logger.log("🧬 Generating decoy database...") + st.info("Generating decoy FASTA database...") + db_dir.mkdir(parents=True, exist_ok=True) + if not self.executor.run_topp( + "DecoyDatabase", + {"in": [decoy_inputs], "out": [str(decoy_fasta)]}, + ): + self.logger.log("Workflow stopped due to error") + return None + self.logger.log("✅ Decoy database ready") + st.success(f"Using decoy FASTA: {decoy_fasta.name}") + database_fasta = decoy_fasta + else: + # Get decoy_string from the active mode's CometAdapter params + comet_instance = "CometAdapter-TMT" if self.params.get("analysis-mode", "LFQ") == "TMT" else "CometAdapter" + decoy_string = self.params.get(comet_instance, {}).get("PeptideIndexing:decoy_string", "rev_") + self.logger.log("📄 Using existing FASTA database") + st.info(f"Using original FASTA: {fasta_path.name}") + database_fasta = fasta_path + if add_contaminants: + # The FASTA has its own decoys; give the contaminants decoys in the same style. + # Own instance name, so stored DecoyDatabase settings don't repeat these options. + con_decoy_fasta = db_dir / "contaminants.decoy.fasta" + if not self.executor.run_topp( + "DecoyDatabase", + {"in": [str(con_fasta)], "out": [str(con_decoy_fasta)]}, + {"decoy_string": decoy_string, "decoy_string_position": "prefix"}, + tool_instance_name="DecoyDatabase-contaminants", + ): + self.logger.log("Workflow stopped due to error") + return None + database_fasta = db_dir / f"{fasta_path.stem}.con.fasta" + append_fasta([fasta_path, con_decoy_fasta], database_fasta) + st.info(f"Added contaminants: {database_fasta.name}") + return database_fasta, decoy_string + def execution(self) -> bool: """ Refactored TOPP workflow execution: @@ -772,31 +853,11 @@ def execution(self) -> bool: self.logger.log(f"📂 Loaded {len(in_mzML)} sample(s)") - if self.params.get("generate-decoys", True): - decoy_fasta = fasta_path.with_suffix(".decoy.fasta") - # Get decoy_string from DecoyDatabase params - decoy_string = self.params.get("DecoyDatabase", {}).get("decoy_string", "rev_") + prepared = self.prepare_search_database(fasta_path) + if prepared is None: + return False + database_fasta, decoy_string = prepared - if not decoy_fasta.exists(): - self.logger.log("🧬 Generating decoy database...") - st.info("Generating decoy FASTA database...") - if not self.executor.run_topp( - "DecoyDatabase", - {"in": [str(fasta_path)], "out": [str(decoy_fasta)]}, - ): - self.logger.log("Workflow stopped due to error") - return False - self.logger.log("✅ Decoy database ready") - st.success(f"Using decoy FASTA: {decoy_fasta.name}") - database_fasta = decoy_fasta - else: - # Get decoy_string from the active mode's CometAdapter params - comet_instance = "CometAdapter-TMT" if self.params.get("analysis-mode", "LFQ") == "TMT" else "CometAdapter" - decoy_string = self.params.get(comet_instance, {}).get("PeptideIndexing:decoy_string", "rev_") - self.logger.log("📄 Using existing FASTA database") - st.info(f"Using original FASTA: {fasta_path.name}") - database_fasta = fasta_path - current_mode = self.params.get("analysis-mode", "LFQ") st.write(f"Current analysis mode: **{current_mode}**") @@ -904,6 +965,7 @@ def execution(self) -> bool: {"field": "rt", "title": "RT", "sorter": "number"}, {"field": "score", "title": "Score", "sorter": "number"}, {"field": "protein_accession", "title": "Proteins"}, + {"field": "contaminant", "title": "Contaminant", "formatter": "tickCross", "sorter": "boolean"}, ], initial_sort=[{"column": "score", "dir": "asc"}], index_field="id_idx", @@ -1004,6 +1066,7 @@ def execution(self) -> bool: {"field": "rt", "title": "RT", "sorter": "number"}, {"field": "score", "title": "Score", "sorter": "number"}, {"field": "protein_accession", "title": "Proteins"}, + {"field": "contaminant", "title": "Contaminant", "formatter": "tickCross", "sorter": "boolean"}, ], initial_sort=[{"column": "score", "dir": "asc"}], index_field="id_idx", @@ -1097,6 +1160,7 @@ def execution(self) -> bool: {"field": "rt", "title": "RT", "sorter": "number"}, {"field": "score", "title": "Score", "sorter": "number"}, {"field": "protein_accession", "title": "Proteins"}, + {"field": "contaminant", "title": "Contaminant", "formatter": "tickCross", "sorter": "boolean"}, ], initial_sort=[{"column": "score", "dir": "asc"}], index_field="id_idx", @@ -1417,6 +1481,7 @@ def execution(self) -> bool: {"field": "rt", "title": "RT", "sorter": "number"}, {"field": "score", "title": "Score", "sorter": "number"}, {"field": "protein_accession", "title": "Proteins"}, + {"field": "contaminant", "title": "Contaminant", "formatter": "tickCross", "sorter": "boolean"}, ], initial_sort=[{"column": "score", "dir": "asc"}], index_field="id_idx", @@ -1513,6 +1578,7 @@ def execution(self) -> bool: {"field": "rt", "title": "RT", "sorter": "number"}, {"field": "score", "title": "Score", "sorter": "number"}, {"field": "protein_accession", "title": "Proteins"}, + {"field": "contaminant", "title": "Contaminant", "formatter": "tickCross", "sorter": "boolean"}, ], initial_sort=[{"column": "score", "dir": "asc"}], index_field="id_idx", @@ -1603,6 +1669,7 @@ def execution(self) -> bool: {"field": "rt", "title": "RT", "sorter": "number"}, {"field": "score", "title": "Score", "sorter": "number"}, {"field": "protein_accession", "title": "Proteins"}, + {"field": "contaminant", "title": "Contaminant", "formatter": "tickCross", "sorter": "boolean"}, ], initial_sort=[{"column": "score", "dir": "asc"}], index_field="id_idx", diff --git a/src/common/contaminants.py b/src/common/contaminants.py new file mode 100644 index 0000000..5b7ccc1 --- /dev/null +++ b/src/common/contaminants.py @@ -0,0 +1,71 @@ +"""Common contaminants (cRAP) for the search database. + +The workflow appends the cRAP proteins to the user's FASTA with ``CON__`` before +their accessions, so every protein and PSM table can flag them, and the +protein-level results and downstream analysis leave them out by default. +""" +from pathlib import Path + +import pandas as pd +from pyopenms import FASTAFile + +# Accession prefix of the contaminants appended to the database (as MaxQuant and ProSE) +CONTAMINANT_PREFIX = "CON__" + +# The common Repository of Adventitious Proteins (cRAP, thegpm.org/crap), 116 entries +CRAP_FASTA = Path("example-data", "db", "contaminants", "crap.fasta") + +# Separators between the accessions of a protein group or of a PSM's proteins +_ACCESSION_SEPARATORS = (";", ",", "/") + + +def write_contaminants(out_path, crap_path=CRAP_FASTA) -> int: + """Write the cRAP entries with ``CON__`` accessions to ``out_path``. + + Entries that already carry the prefix keep it. Returns the number of entries. + """ + entries = [] + FASTAFile().load(str(crap_path), entries) + for entry in entries: + if not entry.identifier.startswith(CONTAMINANT_PREFIX): + entry.identifier = CONTAMINANT_PREFIX + entry.identifier + Path(out_path).parent.mkdir(parents=True, exist_ok=True) + FASTAFile().store(str(out_path), entries) + return len(entries) + + +def append_fasta(parts, out_path) -> None: + """Write the entries of the FASTA files ``parts``, in order, to ``out_path``.""" + entries = [] + for part in parts: + part_entries = [] + FASTAFile().load(str(part), part_entries) + entries.extend(part_entries) + Path(out_path).parent.mkdir(parents=True, exist_ok=True) + FASTAFile().store(str(out_path), entries) + + +def is_contaminant(accessions) -> bool: + """Whether a protein, protein group or PSM maps to a contaminant. + + ``accessions`` is one accession or several joined by ``;``, ``,`` or ``/`` + (ProteinQuantifier groups). A group counts as a contaminant when any of its + members is one, as in MaxQuant. + """ + if not isinstance(accessions, str) or not accessions: + return False + for sep in _ACCESSION_SEPARATORS[1:]: + accessions = accessions.replace(sep, _ACCESSION_SEPARATORS[0]) + return any(a.strip().startswith(CONTAMINANT_PREFIX) for a in accessions.split(_ACCESSION_SEPARATORS[0])) + + +def contaminant_mask(accessions: pd.Series) -> pd.Series: + """Boolean Series: True where the row's accessions include a contaminant.""" + return accessions.map(is_contaminant).astype(bool) + + +def drop_contaminants(df: pd.DataFrame, column: str) -> pd.DataFrame: + """``df`` without the rows whose ``column`` names a contaminant.""" + if df is None or column not in df.columns: + return df + return df[~contaminant_mask(df[column])] diff --git a/src/common/results_helpers.py b/src/common/results_helpers.py index c434b23..ce7df01 100644 --- a/src/common/results_helpers.py +++ b/src/common/results_helpers.py @@ -12,6 +12,7 @@ except ImportError: # pyOpenMS <= 3.4.x PeptideIdentificationList = None from src.workflow.ParameterManager import ParameterManager +from src.common.contaminants import drop_contaminants, is_contaminant def get_workflow_dir(workspace): """Get the workflow directory path.""" @@ -141,6 +142,7 @@ def extract_filename_from_idxml(idxml_path: Path, mzml_names=None) -> str: "rt": pl.Float64, "score": pl.Float64, "protein_accession": pl.Utf8, + "contaminant": pl.Boolean, } @@ -179,6 +181,7 @@ def parse_idxml(idxml_path: Path, filename_to_index: dict | None = None) -> tupl filename = spectra_data[0] for h in pep.getHits(): + accessions = ";".join([ev.getProteinAccession() for ev in h.getPeptideEvidences()]) records.append({ "id_idx": len(records), "scan_id": scan_id, @@ -189,7 +192,8 @@ def parse_idxml(idxml_path: Path, filename_to_index: dict | None = None) -> tupl "mz": pep.getMZ(), "rt": pep.getRT(), "score": h.getScore(), - "protein_accession": ";".join([ev.getProteinAccession() for ev in h.getPeptideEvidences()]), + "protein_accession": accessions, + "contaminant": is_contaminant(accessions), }) # Keep the columns when nothing was identified, so callers selecting @@ -441,11 +445,13 @@ def load_abundance_data(workspace_path: str, csv_mtime: float, params_mtime: flo return pivot_df, expr_df, group_map -def get_abundance_data(workspace: Path) -> tuple | None: +def get_abundance_data(workspace: Path, include_contaminants: bool = False) -> tuple | None: """Wrapper that handles cache key (workspace + CSV mtime + params mtime). Args: workspace: Path to the workspace directory + include_contaminants: Keep the proteins with CON__ accessions (cRAP). + They are left out by default, so downstream analysis never sees them. Returns: Tuple of (pivot_df, expr_df, group_map) or None if data unavailable @@ -465,7 +471,16 @@ def get_abundance_data(workspace: Path) -> tuple | None: params_file = workflow_dir / "params.json" params_mtime = params_file.stat().st_mtime if params_file.exists() else 0.0 - return load_abundance_data(str(workspace), csv_mtime, params_mtime) + result = load_abundance_data(str(workspace), csv_mtime, params_mtime) + if result is None or include_contaminants: + return result + pivot_df, expr_df, group_map = result + id_col = pivot_df.columns[0] + return ( + drop_contaminants(pivot_df, id_col), + expr_df[~expr_df.index.to_series().map(is_contaminant).to_numpy(dtype=bool)], + group_map, + ) def get_id_column(workspace: Path, pivot_df: pd.DataFrame) -> str: diff --git a/tests/test_contaminants.py b/tests/test_contaminants.py new file mode 100644 index 0000000..12dfd3d --- /dev/null +++ b/tests/test_contaminants.py @@ -0,0 +1,164 @@ +"""Tests for the cRAP contaminants: database preparation and flagging in results.""" +import json +from pathlib import Path +from types import SimpleNamespace + +import pandas as pd +import pyopenms as poms + +from src.common.contaminants import ( + CONTAMINANT_PREFIX, + CRAP_FASTA, + append_fasta, + contaminant_mask, + drop_contaminants, + is_contaminant, + write_contaminants, +) + + +def _fasta(path, entries): + out = [] + for identifier, sequence in entries: + e = poms.FASTAEntry() + e.identifier = identifier + e.sequence = sequence + out.append(e) + poms.FASTAFile().store(str(path), out) + + +def _ids(path): + entries = [] + poms.FASTAFile().load(str(path), entries) + return [e.identifier for e in entries] + + +def test_write_contaminants_prefixes_every_crap_entry(tmp_path): + out = tmp_path / "con.fasta" + n = write_contaminants(out) + ids = _ids(out) + assert n == len(ids) == len(_ids(CRAP_FASTA)) == 116 + assert all(i.startswith(CONTAMINANT_PREFIX) for i in ids) + # An already prefixed entry is not prefixed twice + write_contaminants(tmp_path / "again.fasta", crap_path=out) + assert _ids(tmp_path / "again.fasta") == ids + + +def test_append_fasta_keeps_order(tmp_path): + _fasta(tmp_path / "a.fasta", [("sp|P1|A", "PEPTIDEK")]) + _fasta(tmp_path / "b.fasta", [("CON__sp|K1|B", "ELVISK"), ("rev_CON__sp|K1|B", "KSIVLE")]) + append_fasta([tmp_path / "a.fasta", tmp_path / "b.fasta"], tmp_path / "out" / "ab.fasta") + assert _ids(tmp_path / "out" / "ab.fasta") == ["sp|P1|A", "CON__sp|K1|B", "rev_CON__sp|K1|B"] + + +def test_is_contaminant(): + assert is_contaminant("CON__sp|ALBU_BOVIN|") + assert is_contaminant("sp|P1|A;CON__sp|K2C1_HUMAN|") + assert is_contaminant("sp|P1|A,CON__X") + assert is_contaminant("sp|P1|A/CON__X") + assert not is_contaminant("sp|P1|A") + assert not is_contaminant("rev_CON__X") # a decoy, not a contaminant + assert not is_contaminant(None) + assert not is_contaminant(float("nan")) + mask = contaminant_mask(pd.Series(["CON__X", "P1", None])) + assert mask.tolist() == [True, False, False] + df = pd.DataFrame({"ProteinName": ["CON__X", "P1"], "s1": [1.0, 2.0]}) + assert drop_contaminants(df, "ProteinName")["ProteinName"].tolist() == ["P1"] + + +def _workflow(tmp_path, params): + """A WorkflowTest with only what prepare_search_database touches.""" + from src.WorkflowTest import WorkflowTest + + calls = [] + + def run_topp(tool, io, custom_params={}, tool_instance_name=None): + calls.append((tool, io, custom_params, tool_instance_name)) + # Stand in for DecoyDatabase: the targets, then each entry reversed with the decoy string + decoy = custom_params.get("decoy_string", "rev_") + inputs = io["in"][0] if isinstance(io["in"][0], list) else io["in"] + entries = [] + for part in inputs: + part_entries = [] + poms.FASTAFile().load(str(part), part_entries) + entries.extend(part_entries) + decoys = [] + for e in entries: + d = poms.FASTAEntry() + d.identifier = decoy + e.identifier + d.sequence = e.sequence[::-1] + decoys.append(d) + poms.FASTAFile().store(io["out"][0], entries + decoys) + return True + + wf = object.__new__(WorkflowTest) + wf.params = params + wf.workflow_dir = tmp_path / "topp-workflow" + wf.logger = SimpleNamespace(log=lambda *a, **k: None) + wf.executor = SimpleNamespace(run_topp=run_topp) + return wf, calls + + +def test_generated_decoys_cover_the_contaminants(tmp_path): + fasta = tmp_path / "db.fasta" + _fasta(fasta, [("sp|P1|A", "PEPTIDEK")]) + wf, calls = _workflow(tmp_path, {"generate-decoys": True}) + + database, decoy_string = wf.prepare_search_database(fasta) + + assert decoy_string == "rev_" + assert len(calls) == 1 and len(calls[0][1]["in"][0]) == 2 # FASTA and contaminants in one call + ids = _ids(database) + assert "sp|P1|A" in ids and "rev_sp|P1|A" in ids + assert sum(i.startswith(CONTAMINANT_PREFIX) for i in ids) == 116 + assert sum(i.startswith("rev_" + CONTAMINANT_PREFIX) for i in ids) == 116 + # The user's FASTA is left alone + assert _ids(fasta) == ["sp|P1|A"] + + +def test_fasta_with_decoys_gets_contaminants_in_its_decoy_style(tmp_path): + fasta = tmp_path / "db.fasta" + _fasta(fasta, [("sp|P1|A", "PEPTIDEK"), ("DECOY_sp|P1|A", "KEDITPEP")]) + params = {"generate-decoys": False, "CometAdapter": {"PeptideIndexing:decoy_string": "DECOY_"}} + wf, calls = _workflow(tmp_path, params) + + database, decoy_string = wf.prepare_search_database(fasta) + + assert decoy_string == "DECOY_" + assert calls[0][2]["decoy_string"] == "DECOY_" + assert calls[0][3] == "DecoyDatabase-contaminants" + ids = _ids(database) + assert ids[:2] == ["sp|P1|A", "DECOY_sp|P1|A"] + assert sum(i.startswith("DECOY_" + CONTAMINANT_PREFIX) for i in ids) == 116 + + +def test_contaminants_can_be_switched_off(tmp_path): + fasta = tmp_path / "db.fasta" + _fasta(fasta, [("sp|P1|A", "PEPTIDEK"), ("rev_sp|P1|A", "KEDITPEP")]) + wf, calls = _workflow(tmp_path, {"generate-decoys": False, "add-contaminants": False}) + + database, _ = wf.prepare_search_database(fasta) + + assert database == fasta and calls == [] + + +def test_abundance_data_leaves_contaminants_out_by_default(tmp_path): + from src.common.results_helpers import get_abundance_data + + workflow_dir = tmp_path / "topp-workflow" + quant_dir = workflow_dir / "results" / "quant_results" + quant_dir.mkdir(parents=True) + (workflow_dir / "params.json").write_text(json.dumps({"analysis-mode": "LFQ"})) + rows = [] + for protein in ("sp|P1|A", "CON__sp|ALBU_BOVIN|", "sp|P2|B;CON__sp|TRYP_PIG|"): + for sample in ("s1", "s2"): + rows.append({"ProteinName": protein, "PeptideSequence": "PEPTIDEK", + "Reference": f"{sample}.mzML", "Intensity": 1000.0}) + pd.DataFrame(rows).to_csv(quant_dir / "quant.csv", index=False) + + pivot_df, expr_df, _ = get_abundance_data(Path(tmp_path)) + assert pivot_df["ProteinName"].tolist() == ["sp|P1|A"] + assert expr_df.index.tolist() == ["sp|P1|A"] + + pivot_all, expr_all, _ = get_abundance_data(Path(tmp_path), include_contaminants=True) + assert len(pivot_all) == len(expr_all) == 3