rosetta-bioc 0.1.0__tar.gz

rosetta_bioc-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: rosetta-bioc
+Version: 0.1.0
+Summary: Pythonic API for R/Bioconductor statistical methods — calls validated R code, returns pandas DataFrames.
+Author: Catherine Chi Chung
+Author-email: John Muirhead-Gould <john@nodes.bio>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/rosetta-bioc/rosetta
+Project-URL: Documentation, https://github.com/rosetta-bioc/rosetta#readme
+Project-URL: Repository, https://github.com/rosetta-bioc/rosetta
+Project-URL: Issues, https://github.com/rosetta-bioc/rosetta/issues
+Keywords: bioinformatics,R,bioconductor,DESeq2,edgeR,limma,rpy2,RNA-seq,differential-expression,pathway-enrichment,clusterProfiler,genomics,pandas
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: rpy2>=3.5
+Requires-Dist: pandas>=1.5
+Requires-Dist: numpy>=1.23
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: ruff>=0.5; extra == "dev"
+Provides-Extra: posit
+Requires-Dist: rpy2>=3.5; extra == "posit"
+
+# 🪨 rosetta
+
+**Python interface to R/Bioconductor — pandas in, pandas out, `.report()` when you're done.**
+
+[![PyPI](https://img.shields.io/pypi/v/rosetta-bioc)](https://pypi.org/project/rosetta-bioc/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![Tests](https://img.shields.io/badge/tests-170%2B%20passing-brightgreen)]()
+
+```bash
+pip install rosetta-bioc
+```
+
+## 30-second demo
+
+```python
+import rosetta as rb
+
+# DESeq2 differential expression — one call, pandas out
+results = rb.deseq2(counts_df, metadata_df, design="~ condition")
+results.report()
+```
+```
+DESeq2 Results Summary
+──────────────────────────────
+Total genes tested:      12,000
+Significant (padj<0.05): 843 (7.0%)
+  ↑ Upregulated:         428
+  ↓ Downregulated:       415
+LFC range:               [-4.71, 3.50]
+```
+
+That's it. No R code. No rpy2 boilerplate. No type conversion. Just results.
+
+## What it wraps
+
+| R Package | Python | What it does |
+|-----------|--------|--------------|
+| DESeq2 | `rb.deseq2()` | Differential expression (negative binomial) |
+| edgeR | `rb.edger()` | Quasi-likelihood differential expression |
+| limma | `rb.limma_voom()` | Linear models + TREAT significance |
+| clusterProfiler | `rb.enrich_go()` | GO/KEGG/Reactome pathway enrichment |
+| phyloseq | `rb.phyloseq()` | Microbiome diversity analysis |
+| Seurat | `rb.seurat()` | Single-cell RNA-seq |
+
+All functions return a `RosettaDataFrame` (pandas DataFrame subclass) with a `.report()` method.
+
+## Modular DESeq2 API
+
+For more control, use the step-by-step interface:
+
+```python
+from rosetta.wrappers.deseq2 import run_deseq2, get_results, lfc_shrink
+
+dds = run_deseq2(counts_df, metadata_df, design="~ condition")
+res = get_results(dds, contrast=["condition", "treated", "control"], alpha=0.05)
+shrunk = lfc_shrink(dds, coef="condition_treated_vs_control", type="apeglm")
+
+res.report()
+shrunk.report()
+```
+
+## Enrichment analysis
+
+```python
+import rosetta as rb
+
+# Over-representation analysis
+go_results = rb.enrich_go(gene_list, org_db="org.Hs.eg.db", ont="BP")
+go_results.report()
+
+# KEGG pathways
+kegg = rb.enrich_kegg(gene_list, organism="hsa")
+kegg.report()
+```
+
+## Setup
+
+**Python side:**
+```bash
+pip install rosetta-bioc
+```
+
+**R side** (one-time):
+```bash
+Rscript install.R
+```
+
+Or manually:
+```r
+BiocManager::install(c("DESeq2", "edgeR", "limma", "clusterProfiler"))
+```
+
+**Posit Cloud:** See [docs/posit-cloud.md](docs/posit-cloud.md) for zero-config setup.
+
+## Requirements
+
+- Python 3.9+
+- R 4.0+ with Bioconductor
+- rpy2 ≥ 3.5
+
+## Philosophy
+
+1. **Rosetta calls R — it doesn't reimplement it.** All statistics run in the original, validated R packages.
+2. **Pandas in, pandas out.** No R objects leak into your Python workflow.
+3. **Fail early, fail clearly.** Input validation happens in Python before crossing the R boundary.
+4. **`.report()` everything.** Results should be immediately interpretable without manual inspection.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Good first issues are labeled — start with [Issue #1: `report()` enhancements](https://github.com/rosetta-bioc/rosetta/issues/1).
+
+## Acknowledgments
+
+Built on [rpy2](https://rpy2.github.io/) and the extraordinary R/Bioconductor ecosystem. All credit for the statistical methods goes to the original R package authors.
+
+GSoC 2026 · MIT License · [Nodes Bio](https://nodes.bio)

rosetta_bioc-0.1.0/README.md

@@ -0,0 +1,116 @@
+# 🪨 rosetta
+
+**Python interface to R/Bioconductor — pandas in, pandas out, `.report()` when you're done.**
+
+[![PyPI](https://img.shields.io/pypi/v/rosetta-bioc)](https://pypi.org/project/rosetta-bioc/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)
+[![Tests](https://img.shields.io/badge/tests-170%2B%20passing-brightgreen)]()
+
+```bash
+pip install rosetta-bioc
+```
+
+## 30-second demo
+
+```python
+import rosetta as rb
+
+# DESeq2 differential expression — one call, pandas out
+results = rb.deseq2(counts_df, metadata_df, design="~ condition")
+results.report()
+```
+```
+DESeq2 Results Summary
+──────────────────────────────
+Total genes tested:      12,000
+Significant (padj<0.05): 843 (7.0%)
+  ↑ Upregulated:         428
+  ↓ Downregulated:       415
+LFC range:               [-4.71, 3.50]
+```
+
+That's it. No R code. No rpy2 boilerplate. No type conversion. Just results.
+
+## What it wraps
+
+| R Package | Python | What it does |
+|-----------|--------|--------------|
+| DESeq2 | `rb.deseq2()` | Differential expression (negative binomial) |
+| edgeR | `rb.edger()` | Quasi-likelihood differential expression |
+| limma | `rb.limma_voom()` | Linear models + TREAT significance |
+| clusterProfiler | `rb.enrich_go()` | GO/KEGG/Reactome pathway enrichment |
+| phyloseq | `rb.phyloseq()` | Microbiome diversity analysis |
+| Seurat | `rb.seurat()` | Single-cell RNA-seq |
+
+All functions return a `RosettaDataFrame` (pandas DataFrame subclass) with a `.report()` method.
+
+## Modular DESeq2 API
+
+For more control, use the step-by-step interface:
+
+```python
+from rosetta.wrappers.deseq2 import run_deseq2, get_results, lfc_shrink
+
+dds = run_deseq2(counts_df, metadata_df, design="~ condition")
+res = get_results(dds, contrast=["condition", "treated", "control"], alpha=0.05)
+shrunk = lfc_shrink(dds, coef="condition_treated_vs_control", type="apeglm")
+
+res.report()
+shrunk.report()
+```
+
+## Enrichment analysis
+
+```python
+import rosetta as rb
+
+# Over-representation analysis
+go_results = rb.enrich_go(gene_list, org_db="org.Hs.eg.db", ont="BP")
+go_results.report()
+
+# KEGG pathways
+kegg = rb.enrich_kegg(gene_list, organism="hsa")
+kegg.report()
+```
+
+## Setup
+
+**Python side:**
+```bash
+pip install rosetta-bioc
+```
+
+**R side** (one-time):
+```bash
+Rscript install.R
+```
+
+Or manually:
+```r
+BiocManager::install(c("DESeq2", "edgeR", "limma", "clusterProfiler"))
+```
+
+**Posit Cloud:** See [docs/posit-cloud.md](docs/posit-cloud.md) for zero-config setup.
+
+## Requirements
+
+- Python 3.9+
+- R 4.0+ with Bioconductor
+- rpy2 ≥ 3.5
+
+## Philosophy
+
+1. **Rosetta calls R — it doesn't reimplement it.** All statistics run in the original, validated R packages.
+2. **Pandas in, pandas out.** No R objects leak into your Python workflow.
+3. **Fail early, fail clearly.** Input validation happens in Python before crossing the R boundary.
+4. **`.report()` everything.** Results should be immediately interpretable without manual inspection.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Good first issues are labeled — start with [Issue #1: `report()` enhancements](https://github.com/rosetta-bioc/rosetta/issues/1).
+
+## Acknowledgments
+
+Built on [rpy2](https://rpy2.github.io/) and the extraordinary R/Bioconductor ecosystem. All credit for the statistical methods goes to the original R package authors.
+
+GSoC 2026 · MIT License · [Nodes Bio](https://nodes.bio)

rosetta_bioc-0.1.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rosetta-bioc"
+version = "0.1.0"
+description = "Pythonic API for R/Bioconductor statistical methods — calls validated R code, returns pandas DataFrames."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+    {name = "John Muirhead-Gould", email = "john@nodes.bio"},
+    {name = "Catherine Chi Chung"},
+]
+keywords = ["bioinformatics", "R", "bioconductor", "DESeq2", "edgeR", "limma", "rpy2", "RNA-seq", "differential-expression", "pathway-enrichment", "clusterProfiler", "genomics", "pandas"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Bio-Informatics",
+    "Topic :: Scientific/Engineering :: Medical Science Apps.",
+]
+dependencies = [
+    "rpy2>=3.5",
+    "pandas>=1.5",
+    "numpy>=1.23",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "ruff>=0.5"]
+posit = ["rpy2>=3.5"]
+
+[project.urls]
+Homepage = "https://github.com/rosetta-bioc/rosetta"
+Documentation = "https://github.com/rosetta-bioc/rosetta#readme"
+Repository = "https://github.com/rosetta-bioc/rosetta"
+Issues = "https://github.com/rosetta-bioc/rosetta/issues"
+
+[tool.setuptools.packages.find]
+include = ["rosetta*"]
+exclude = ["tests*", "examples*"]

rosetta_bioc-0.1.0/rosetta/__init__.py

@@ -0,0 +1,23 @@
+"""rosetta — Seamless Python wrappers for R bioinformatics packages."""
+
+from ._errors import RDataError, RFormulaError, RPackageMissing
+from .results import RosettaDataFrame
+from .wrappers.deseq2 import deseq2
+from .wrappers.edger import edger
+from .wrappers.limma import limma_voom
+from .wrappers.clusterprofiler import enrich_go, enrich_kegg, enrich_pathway, enrich_custom
+from .wrappers.phyloseq import phyloseq, phyloseq_richness
+from .wrappers.seurat import seurat
+from . import pipelines
+
+# Alias for backward compatibility
+enrichment = enrich_go
+
+__all__ = [
+    "deseq2", "edger", "limma_voom", "enrichment",
+    "enrich_go", "enrich_kegg", "enrich_pathway", "enrich_custom",
+    "phyloseq", "phyloseq_richness", "seurat",
+    "pipelines",
+    "RosettaDataFrame",
+    "RDataError", "RFormulaError", "RPackageMissing",
+]

rosetta_bioc-0.1.0/rosetta/__main__.py

@@ -0,0 +1,3 @@
+"""python -m rosetta — run the quick-start demo."""
+from .example import main
+main()

rosetta_bioc-0.1.0/rosetta/_bridge.py

@@ -0,0 +1,64 @@
+"""R session management and bidirectional type conversion."""
+
+import numpy as np
+import pandas as pd
+import rpy2.robjects as ro
+from rpy2.robjects import numpy2ri, pandas2ri
+from rpy2.robjects.conversion import Converter, localconverter
+from rpy2.robjects.packages import importr
+
+_converter = Converter("rosetta")
+_converter += numpy2ri.converter
+_converter += pandas2ri.converter
+_converter += ro.default_converter
+
+_base = None
+
+
+def _get_base():
+    """Lazily import R base package."""
+    global _base
+    if _base is None:
+        _base = importr("base")
+    return _base
+
+
+def to_r_matrix(df: pd.DataFrame):
+    """Convert pandas DataFrame to R matrix."""
+    from ._errors import RDataError
+    if not isinstance(df, pd.DataFrame):
+        raise RDataError("Expected pandas DataFrame")
+    with localconverter(_converter):
+        return _get_base().as_matrix(ro.conversion.get_conversion().py2rpy(df))
+
+
+def to_r_dataframe(df: pd.DataFrame):
+    """Convert pandas DataFrame to R data.frame."""
+    from ._errors import RDataError
+    if not isinstance(df, pd.DataFrame):
+        raise RDataError("Expected pandas DataFrame")
+    with localconverter(_converter):
+        return ro.conversion.get_conversion().py2rpy(df)
+
+
+def to_pandas(r_obj) -> "pd.DataFrame":
+    """Convert R data.frame/matrix to pandas DataFrame (with .report() method)."""
+    from .results import RosettaDataFrame
+    with localconverter(_converter):
+        df = ro.conversion.get_conversion().rpy2py(r_obj)
+    if isinstance(df, pd.DataFrame):
+        return RosettaDataFrame(df)
+    return df
+
+
+def to_r_df(r_obj):
+    """Convert an R object to R data.frame via base::as.data.frame."""
+    with localconverter(_converter):
+        return _get_base().as_data_frame(r_obj)
+
+
+def r_nrow(r_obj):
+    """Get nrow of an R object via base::nrow."""
+    with localconverter(_converter):
+        result = _get_base().nrow(r_obj)
+        return int(result[0])  # Convert R vector to Python int

rosetta_bioc-0.1.0/rosetta/_deps.py

@@ -0,0 +1,19 @@
+"""R package detection and installation via BiocManager."""
+
+from rpy2.robjects.conversion import localconverter
+
+from ._bridge import _converter, _get_base
+from ._errors import RPackageMissing
+
+
+def is_installed(package: str) -> bool:
+    """Check if an R package is installed."""
+    with localconverter(_converter):
+        result = _get_base().requireNamespace(package, quietly=True)
+        return bool(result[0])
+
+
+def ensure_installed(package: str) -> None:
+    """Ensure an R package is installed, raising RPackageMissing if not."""
+    if not is_installed(package):
+        raise RPackageMissing(package)

rosetta_bioc-0.1.0/rosetta/_errors.py

@@ -0,0 +1,24 @@
+"""Rosetta exception classes for R error translation."""
+
+
+class RosettaError(Exception):
+    """Base exception for rosetta."""
+
+
+class RPackageMissing(RosettaError):
+    """Required R package is not installed."""
+
+    def __init__(self, package: str):
+        self.package = package
+        super().__init__(f"R package '{package}' is not installed. Install with: R -e 'BiocManager::install(\"{package}\")'")
+
+
+class RFormulaError(RosettaError):
+    """Invalid R design formula."""
+
+
+class RDataError(RosettaError):
+    """Incompatible input data for R function."""
+class RosettaSecurityError(RosettaError):
+    """Exception raised for security-related issues."""
+

rosetta_bioc-0.1.0/rosetta/example.py

@@ -0,0 +1,65 @@
+"""rosetta quick-start example — synthetic data, no files needed.
+
+Run: python -m rosetta.example
+"""
+
+import numpy as np
+import pandas as pd
+
+
+def main():
+    """Demonstrate rosetta with synthetic RNA-seq count data."""
+    from .results import RosettaDataFrame
+
+    print("🪨 rosetta — quick demo with synthetic data\n")
+
+    # Generate fake count matrix (1000 genes × 6 samples)
+    np.random.seed(42)
+    n_genes, n_samples = 1000, 6
+    gene_names = [f"Gene_{i:04d}" for i in range(n_genes)]
+    sample_names = [f"S{i+1}" for i in range(n_samples)]
+
+    # Base expression + condition effect for first 100 genes
+    base = np.random.negative_binomial(n=5, p=0.01, size=(n_genes, n_samples))
+    base[:100, 3:] += np.random.negative_binomial(n=3, p=0.01, size=(100, 3))  # upregulated in treated
+
+    counts = pd.DataFrame(base, index=gene_names, columns=sample_names)
+    metadata = pd.DataFrame(
+        {"condition": ["control"] * 3 + ["treated"] * 3},
+        index=sample_names,
+    )
+
+    print(f"Count matrix: {counts.shape[0]} genes × {counts.shape[1]} samples")
+    print(f"Conditions: {metadata['condition'].value_counts().to_dict()}\n")
+
+    # Simulate DESeq2-like results (without R, for demo purposes)
+    pvals = np.random.uniform(0, 1, n_genes)
+    pvals[:100] = np.random.uniform(0, 0.001, 100)  # truly DE genes
+    lfc = np.random.normal(0, 0.5, n_genes)
+    lfc[:100] = np.random.normal(2.0, 0.8, 100)
+
+    results = RosettaDataFrame({
+        "baseMean": counts.mean(axis=1).values,
+        "log2FoldChange": lfc,
+        "lfcSE": np.abs(np.random.normal(0.3, 0.1, n_genes)),
+        "stat": lfc / 0.3,
+        "pvalue": pvals,
+        "padj": np.minimum(pvals * n_genes / np.arange(1, n_genes + 1), 1.0),  # BH correction
+    }, index=gene_names)
+
+    print("─" * 40)
+    results.report()
+    print("─" * 40)
+
+    # Show top genes
+    sig = results[results["padj"] < 0.05].sort_values("log2FoldChange", ascending=False)
+    print(f"\nTop 5 upregulated genes:")
+    print(sig[["log2FoldChange", "padj"]].head().to_string())
+
+    print("\n✓ To run with real R packages:")
+    print("  results = rb.deseq2(counts, metadata, design='~ condition')")
+    print("  results.report()")
+
+
+if __name__ == "__main__":
+    main()

rosetta_bioc-0.1.0/rosetta/pipelines.py

@@ -0,0 +1,160 @@
+"""rosetta.pipelines — Complete analysis workflows in one call.
+
+These are the "I just want results" functions. Each one runs the full
+statistical pipeline and returns a RosettaDataFrame with .report().
+"""
+
+import pandas as pd
+from .results import RosettaDataFrame
+
+
+def diff_expr(
+    counts: pd.DataFrame,
+    metadata: pd.DataFrame,
+    design: str = "~ condition",
+    method: str = "deseq2",
+    alpha: float = 0.05,
+    lfc_threshold: float = 0.0,
+    shrinkage: str | None = None,
+    contrast: list | None = None,
+) -> RosettaDataFrame:
+    """Run differential expression — full pipeline, one call.
+
+    Args:
+        counts: Gene count matrix (genes × samples), raw integers.
+        metadata: Sample metadata with index matching count columns.
+        design: R formula string (e.g. "~ condition", "~ batch + treatment").
+        method: One of "deseq2", "edger", "limma".
+        alpha: FDR significance threshold.
+        lfc_threshold: Minimum absolute log2 fold change.
+        shrinkage: For DESeq2: "apeglm", "ashr", or "normal". None = no shrinkage.
+        contrast: For DESeq2: [factor, numerator, denominator].
+
+    Returns:
+        RosettaDataFrame with .report() method.
+
+    Example:
+        >>> results = rb.pipelines.diff_expr(counts, meta, method="deseq2")
+        >>> results.report()
+        >>> sig_genes = results[results["padj"] < 0.05]
+    """
+    if method == "deseq2":
+        from .wrappers.deseq2 import run_deseq2, get_results, lfc_shrink
+
+        dds = run_deseq2(counts, metadata, design)
+
+        if shrinkage:
+            # Need coefficient name for shrinkage
+            from rpy2.robjects.packages import importr
+            from ._bridge import _converter
+            from rpy2.robjects.conversion import localconverter
+            deseq2_pkg = importr("DESeq2")
+            with localconverter(_converter):
+                coefs = list(deseq2_pkg.resultsNames(dds))
+            # Use last coefficient (typically the treatment effect)
+            coef = coefs[-1] if coefs else None
+            if coef:
+                return lfc_shrink(dds, coef=coef, type=shrinkage)
+
+        return get_results(dds, contrast=contrast, lfc_threshold=lfc_threshold, alpha=alpha)
+
+    elif method == "edger":
+        from .wrappers.edger import edger
+        return edger(counts, metadata, design, lfc=lfc_threshold)
+
+    elif method == "limma":
+        from .wrappers.limma import limma_voom
+        return limma_voom(counts, metadata, design)
+
+    else:
+        raise ValueError(f"Unknown method '{method}'. Use 'deseq2', 'edger', or 'limma'.")
+
+
+def enrichment(
+    gene_list: list[str],
+    method: str = "go",
+    organism: str = "hsa",
+    org_db: str = "org.Hs.eg.db",
+    ont: str = "BP",
+    **kwargs,
+) -> RosettaDataFrame:
+    """Run pathway enrichment — full pipeline, one call.
+
+    Args:
+        gene_list: List of gene IDs (Entrez by default).
+        method: One of "go", "kegg", "reactome".
+        organism: KEGG organism code (default "hsa" for human).
+        org_db: OrgDb for GO (default "org.Hs.eg.db").
+        ont: GO ontology — "BP", "MF", or "CC".
+
+    Returns:
+        RosettaDataFrame with .report() method.
+
+    Example:
+        >>> results = rb.pipelines.enrichment(sig_genes, method="kegg")
+        >>> results.report()
+    """
+    if method == "go":
+        from .wrappers.clusterprofiler import enrich_go
+        return enrich_go(gene_list, organism=org_db, ont=ont, **kwargs)
+    elif method == "kegg":
+        from .wrappers.clusterprofiler import enrich_kegg
+        return enrich_kegg(gene_list, organism=organism, **kwargs)
+    elif method == "reactome":
+        from .wrappers.clusterprofiler import enrich_pathway
+        return enrich_pathway(gene_list, **kwargs)
+    else:
+        raise ValueError(f"Unknown method '{method}'. Use 'go', 'kegg', or 'reactome'.")
+
+
+def compare(
+    counts: pd.DataFrame,
+    metadata: pd.DataFrame,
+    design: str = "~ condition",
+    methods: list[str] | None = None,
+    alpha: float = 0.05,
+) -> RosettaDataFrame:
+    """Run multiple DE methods and return a comparison summary.
+
+    This is the "which genes do all methods agree on?" function.
+
+    Args:
+        counts: Gene count matrix (genes × samples).
+        metadata: Sample metadata.
+        design: R formula string.
+        methods: List of methods to compare. Default: ["deseq2", "edger", "limma"].
+        alpha: FDR significance threshold.
+
+    Returns:
+        RosettaDataFrame with columns for each method's significance call
+        and an 'n_methods' column showing agreement count.
+
+    Example:
+        >>> consensus = rb.pipelines.compare(counts, meta)
+        >>> robust_genes = consensus[consensus["n_methods"] == 3]
+    """
+    if methods is None:
+        methods = ["deseq2", "edger", "limma"]
+
+    results = {}
+    for method in methods:
+        try:
+            res = diff_expr(counts, metadata, design, method=method, alpha=alpha)
+            # Extract significance column
+            if "padj" in res.columns:
+                results[method] = res["padj"] < alpha
+            elif "FDR" in res.columns:
+                results[method] = res["FDR"] < alpha
+            elif "adj.P.Val" in res.columns:
+                results[method] = res["adj.P.Val"] < alpha
+        except Exception as e:
+            print(f"  ⚠ {method} failed: {e}")
+            continue
+
+    if not results:
+        raise RuntimeError("All methods failed")
+
+    comparison = pd.DataFrame(results)
+    comparison["n_methods"] = comparison.sum(axis=1)
+    comparison = comparison.sort_values("n_methods", ascending=False)
+    return RosettaDataFrame(comparison)