ProteoPy: an AnnData-based framework for integrated proteomics analysis

ProteoPy is a lightweight, AnnData-based Python framework that streamlines integrated proteomics analysis by enabling seamless data handling, re-implementing the COPF algorithm for proteoform inference, and facilitating reproducible multi-omics workflows through integration with the scanpy and muon ecosystems.

The Gist

Imagine you are trying to understand a massive, bustling city. In the past, scientists studying this city (which represents the human body) had to use different maps, different languages, and different rulebooks for every single neighborhood they visited. If you wanted to study the "proteomics" neighborhood (the world of proteins, the tiny machines that keep our cells running), you needed a specific tool. If you wanted to study the "genomics" neighborhood (DNA), you needed a completely different one.

This made it incredibly hard to see the big picture or to connect the dots between different parts of the city.

Enter ProteoPy: The "Universal Translator" and "City Planner" for Proteins.

This paper introduces a new, free software tool called ProteoPy. Think of it as a super-smart, all-in-one app that finally brings the protein world into the same digital ecosystem that scientists already use for studying cells and genes.

Here is how it works, broken down with some everyday analogies:

1. The "Universal Filing Cabinet" (AnnData)

Before ProteoPy, protein data was like a messy pile of loose papers, sticky notes, and spreadsheets scattered across a desk. You had to manually glue them together to see how they related.

ProteoPy uses a system called AnnData. Imagine a super-organized, digital filing cabinet.

• It holds the main data (the numbers) in the center.
• It keeps all the "notes" about the data (like patient names, experiment dates, or protein types) attached directly to the files.
• Why it matters: You never lose a piece of paper. Everything stays together in one neat package, making it impossible to mix up which data belongs to which experiment.

2. The "Swiss Army Knife" (The Workflow)

The tool is designed to feel familiar to scientists who already use tools for genetic data (like Scanpy). It's like giving a carpenter a new power drill that looks and feels exactly like their old one, so they don't have to relearn how to hold it.

It handles the whole process in four simple steps:

• Read (The Import): It grabs data from different machines (like a universal USB cable) and puts it into your filing cabinet.
• Preprocess (The Cleanup): It washes the data, removes the "dirt" (bad samples), and fixes missing pieces (imputation) so the picture is clear.
• Tools (The Detective Work): This is where the magic happens. It can find hidden patterns and run tests to see what changed between healthy and sick samples.
• Plot (The Storyteller): It instantly turns complex numbers into beautiful, easy-to-read charts and graphs, ready for a presentation.

3. The "Proteoform" Superpower (Seeing the Details)

This is the coolest feature. Usually, scientists look at a protein and say, "Okay, we have 100 units of Protein A." It's like looking at a car and just saying, "It's a Ford."

But proteins are tricky. A single protein can change its shape or wear a different "hat" (called a proteoform) to do different jobs. It's like the same Ford car being a police cruiser, a taxi, or a family van depending on how it's equipped.

ProteoPy has a special "microscope" (a reimagined algorithm called COPF) that looks at the tiny parts of the protein (peptides) to figure out exactly which version of the protein is active. It helps scientists realize, "Oh, it's not just 'Protein A' changing; it's specifically the 'Taxi version' of Protein A that is causing the problem."

4. Why This Changes Everything

• For the Experts: It stops them from reinventing the wheel. They can use powerful, proven tools they already know to analyze protein data.
• For the Beginners: It lowers the barrier to entry. You don't need to be a coding wizard to get started; the tool guides you through the steps.
• For the Future: It paves the road for "Multi-Omics." Imagine being able to look at the DNA, the RNA, and the Proteins all in the same window at the same time, seeing how they all talk to each other. ProteoPy is the bridge that makes this possible.

In a nutshell:
ProteoPy is like taking a chaotic, messy workshop full of different tools and organizing it into a sleek, modern garage where everything has its place, the tools talk to each other, and you can finally build a complete, clear picture of how life works at the molecular level.

Technical Summary

1. Problem Statement

Mass spectrometry (MS)-based proteomics has advanced significantly, yet the field suffers from fragmentation in data analysis.

• Lack of Unified Standards: Unlike transcriptomics, which has coalesced around the AnnData data structure and the scanpy ecosystem, proteomics relies on disparate tools (e.g., MaxQuant, DIA-NN, Perseus) with distinct data formats and scripting environments.
• Barriers to Reproducibility: Researchers must maintain multiple analysis ecosystems, leading to overlapping functionality and increased barriers to correct, reproducible use.
• Integration Challenges: Integrating proteomics with other omics layers (genomics, transcriptomics) is cumbersome due to the lack of a shared data model.
• Limited Peptide-Level Analysis: Conventional workflows often summarize data at the protein level, potentially obscuring biological insights regarding proteoforms (distinct molecular forms of a protein) and isoform usage. While algorithms like COPF exist to infer proteoforms from peptide data, they have been niche and difficult to integrate into general workflows.

2. Methodology

The authors developed ProteoPy, a lightweight Python library designed to bridge these gaps by adapting the AnnData framework for proteomics.

• Core Architecture:

  • Built on Python (≥3.10) and the AnnData class, which stores quantitative matrices alongside rich metadata in a single object.
  • Leverages established scientific libraries: NumPy, SciPy, scikit-learn, pandas, matplotlib, and seaborn.
  • API Design: Follows the scanpy convention with modular namespaces:
    • read: Data import.
    • pp: Preprocessing.
    • tl: Tools (analysis).
    • pl: Plotting.

• Key Functional Modules:

  • Data Import (read): Supports quantitative data from tools like DIA-NN and other tabular formats. It merges sample annotations (clinical, batch) and feature annotations (gene names, GO categories) directly into the AnnData object.
  • Preprocessing (pp):
    • Quality Control: Evaluates metrics like quantified protein/peptide fractions, missing value distributions, and coefficients of variation.
    • Filtering: Allows user-defined thresholds for coverage and variability.
    • Normalization & Correction: Implements median normalization (default) and batch correction via the scanpy ecosystem (e.g., ComBat).
    • Imputation: Uses a downshifted Gaussian distribution (similar to Perseus) for missing values.
    • Transparency: All steps are stored as separate layers within AnnData to ensure reversibility.
  • Tools (tl):
    • Proteoform Inference: A Python reimplementation of the COPF algorithm. It analyzes peptide-level covariation across samples to infer proteoform groups, enabling the identification of isoform-specific regulation.
    • Downstream Analysis: Includes unsupervised clustering and a flexible framework for differential abundance testing (t-tests, Welch's t-test, ANOVA) with multiple testing corrections (Bonferroni, Benjamini-Hochberg). Results are stored directly in the AnnData object.
  • Visualization (pl): Provides publication-ready plots for all workflow stages.

• Interoperability:

  • Fully compatible with the scverse ecosystem (scanpy, muon, squidpy).
  • Enables seamless integration of proteomics with single-cell and spatial transcriptomics via the MuData container for multi-omics analysis.

3. Key Contributions

1. Unified Data Structure: Introduces AnnData as the standard data container for bulk proteomics, aligning proteomics with the mature single-cell transcriptomics ecosystem.
2. Proteoform Inference at Scale: Provides a user-friendly, accessible implementation of the COPF algorithm, allowing researchers to move beyond protein-level summaries to identify proteoform-specific regulation directly from peptide data.
3. Extensible Workflow: Creates a foundation for future single-cell and spatial proteomics by utilizing a framework already proven in those fields.
4. Accessibility: Lowers the barrier to entry for non-specialists by providing a familiar API syntax (similar to scanpy) and integrated tutorials.

4. Results & Validation

The authors validated ProteoPy using two distinct datasets:

• Human Erythropoiesis (Karayel et al., 2020):
  • Goal: Demonstrate general protein-level workflow.
  • Outcome: Successfully reproduced the complete pipeline from Spectronaut output through QC, normalization, imputation, and differential analysis.
• Mouse Tissue Dataset (Original COPF Study, Bludau et al., 2021):
  • Goal: Demonstrate peptide-level functionality and proteoform inference.
  • Outcome: Recapitulated original results within a low-barrier, reproducible framework, confirming the efficacy of the Python reimplementation of COPF.

All analyses were performed using ProteoPy v0.1.1, with Jupyter notebooks provided as supplementary material.

5. Significance

• Standardization: ProteoPy addresses the fragmentation in proteomics by providing a unified, open-source framework that standardizes data handling and analysis.
• Cross-Omics Integration: By adopting the AnnData/MuData ecosystem, it facilitates the direct integration of proteomics with genomics and transcriptomics, enabling true multi-omics exploration.
• Biological Depth: The ability to infer proteoforms from peptide data allows for a more granular understanding of molecular regulation and diversity, which is often lost in protein-level aggregation.
• Future-Proofing: The framework is explicitly designed to support the transition from bulk to single-cell and spatially resolved proteomics, ensuring that the computational infrastructure evolves alongside experimental technologies.

In summary, ProteoPy represents a critical step toward modernizing proteomics analysis, making it more reproducible, accessible, and integrable with the broader landscape of computational biology.