pertpy 0.7.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

pertpy/tools/_differential_gene_expression/_dge_comparison.py

@@ -0,0 +1,86 @@
+import numpy as np
+import pandas as pd
+from anndata import AnnData
+
+
+class DGEEVAL:
+    def compare(
+        self,
+        adata: AnnData | None = None,
+        de_key1: str = None,
+        de_key2: str = None,
+        de_df1: pd.DataFrame | None = None,
+        de_df2: pd.DataFrame | None = None,
+        shared_top: int = 100,
+    ) -> dict[str, float]:
+        """Compare two differential expression analyses.
+
+        Compare two sets of DE results and evaluate the similarity by the overlap of top DEG and
+        the correlation of their scores and adjusted p-values.
+
+        Args:
+            adata: AnnData object containing DE results in `uns`. Required if `de_key1` and `de_key2` are used.
+            de_key1: Key for DE results in `adata.uns`, e.g., output of `tl.rank_genes_groups`.
+            de_key2: Another key for DE results in `adata.uns`, e.g., output of `tl.rank_genes_groups`.
+            de_df1: DataFrame containing DE results, e.g. output from pertpy differential gene expression interface.
+            de_df2: DataFrame containing DE results, e.g. output from pertpy differential gene expression interface.
+            shared_top: The number of top DEG to compute the proportion of their intersection.
+
+        """
+        if (de_key1 or de_key2) and (de_df1 is not None or de_df2 is not None):
+            raise ValueError(
+                "Please provide either both `de_key1` and `de_key2` with `adata`, or `de_df1` and `de_df2`, but not both."
+            )
+
+        if de_df1 is None and de_df2 is None:  # use keys
+            if not de_key1 or not de_key2:
+                raise ValueError("Both `de_key1` and `de_key2` must be provided together if using `adata`.")
+
+        else:  # use dfs
+            if de_df1 is None or de_df2 is None:
+                raise ValueError("Both `de_df1` and `de_df2` must be provided together if using DataFrames.")
+
+        if de_key1:
+            if not adata:
+                raise ValueError("`adata` should be provided with `de_key1` and `de_key2`. ")
+            assert all(
+                k in adata.uns for k in [de_key1, de_key2]
+            ), "Provided `de_key1` and `de_key2` must exist in `adata.uns`."
+            vars = adata.var_names
+
+        if de_df1 is not None:
+            for df in (de_df1, de_df2):
+                if not {"variable", "log_fc", "adj_p_value"}.issubset(df.columns):
+                    raise ValueError("Each DataFrame must contain columns: 'variable', 'log_fc', and 'adj_p_value'.")
+
+            assert set(de_df1["variable"]) == set(de_df2["variable"]), "Variables in both dataframes must match."
+            vars = de_df1["variable"].sort_values()
+
+        shared_top = min(shared_top, len(vars))
+        vars_ranks = np.arange(1, len(vars) + 1)
+        results = pd.DataFrame(index=vars)
+        top_names = []
+
+        if de_key1 and de_key2:
+            for i, k in enumerate([de_key1, de_key2]):
+                label = adata.uns[k]["names"].dtype.names[0]
+                srt_idx = np.argsort(adata.uns[k]["names"][label])
+                results[f"scores_{i}"] = adata.uns[k]["scores"][label][srt_idx]
+                results[f"pvals_adj_{i}"] = adata.uns[k]["pvals_adj"][label][srt_idx]
+                results[f"ranks_{i}"] = vars_ranks[srt_idx]
+                top_names.append(adata.uns[k]["names"][label][:shared_top])
+        else:
+            for i, df in enumerate([de_df1, de_df2]):
+                srt_idx = np.argsort(df["variable"])
+                results[f"scores_{i}"] = df["log_fc"].values[srt_idx]
+                results[f"pvals_adj_{i}"] = df["adj_p_value"].values[srt_idx]
+                results[f"ranks_{i}"] = vars_ranks[srt_idx]
+                top_names.append(df["variable"][:shared_top])
+
+        metrics = {}
+        metrics["shared_top_genes"] = len(set(top_names[0]).intersection(top_names[1])) / shared_top
+        metrics["scores_corr"] = results["scores_0"].corr(results["scores_1"], method="pearson")
+        metrics["pvals_adj_corr"] = results["pvals_adj_0"].corr(results["pvals_adj_1"], method="pearson")
+        metrics["scores_ranks_corr"] = results["ranks_0"].corr(results["ranks_1"], method="spearman")
+
+        return metrics

pertpy/tools/_differential_gene_expression/_edger.py

@@ -0,0 +1,125 @@
+from collections.abc import Sequence
+
+import numpy as np
+import pandas as pd
+from scanpy import logging
+from scipy.sparse import issparse
+
+from ._base import LinearModelBase
+from ._checks import check_is_integer_matrix
+
+
+class EdgeR(LinearModelBase):
+    """Differential expression test using EdgeR"""
+
+    def _check_counts(self):
+        check_is_integer_matrix(self.data)
+
+    def fit(self, **kwargs):  # adata, design, mask, layer
+        """Fit model using edgeR.
+
+        Note: this creates its own AnnData object for downstream.
+
+        Args:
+            **kwargs: Keyword arguments specific to glmQLFit()
+        """
+        # For running in notebook
+        # pandas2ri.activate()
+        # rpy2.robjects.numpy2ri.activate()
+        try:
+            import rpy2.robjects.numpy2ri
+            import rpy2.robjects.pandas2ri
+            from rpy2 import robjects as ro
+            from rpy2.robjects import numpy2ri, pandas2ri
+            from rpy2.robjects.conversion import localconverter
+            from rpy2.robjects.packages import importr
+
+            pandas2ri.activate()
+            rpy2.robjects.numpy2ri.activate()
+
+        except ImportError:
+            raise ImportError("edger requires rpy2 to be installed.") from None
+
+        try:
+            edger = importr("edgeR")
+        except ImportError as e:
+            raise ImportError(
+                "edgeR requires a valid R installation with the following packages:\n"
+                "edgeR, BiocParallel, RhpcBLASctl"
+            ) from e
+
+        # Convert dataframe
+        with localconverter(ro.default_converter + numpy2ri.converter):
+            expr = self.adata.X if self.layer is None else self.adata.layers[self.layer]
+            if issparse(expr):
+                expr = expr.T.toarray()
+            else:
+                expr = expr.T
+
+        expr_r = ro.conversion.py2rpy(pd.DataFrame(expr, index=self.adata.var_names, columns=self.adata.obs_names))
+
+        dge = edger.DGEList(counts=expr_r, samples=self.adata.obs)
+
+        logging.info("Calculating NormFactors")
+        dge = edger.calcNormFactors(dge)
+
+        logging.info("Estimating Dispersions")
+        dge = edger.estimateDisp(dge, design=self.design)
+
+        logging.info("Fitting linear model")
+        fit = edger.glmQLFit(dge, design=self.design, **kwargs)
+
+        ro.globalenv["fit"] = fit
+        self.fit = fit
+
+    def _test_single_contrast(self, contrast: Sequence[float], **kwargs) -> pd.DataFrame:
+        """Conduct test for each contrast and return a data frame
+
+        Args:
+            contrast: numpy array of integars indicating contrast i.e. [-1, 0, 1, 0, 0]
+        """
+        ## -- Check installations
+        # For running in notebook
+        # pandas2ri.activate()
+        # rpy2.robjects.numpy2ri.activate()
+
+        # ToDo:
+        #  parse **kwargs to R function
+        #  Fix mask for .fit()
+
+        try:
+            import rpy2.robjects.numpy2ri
+            import rpy2.robjects.pandas2ri
+            from rpy2 import robjects as ro
+            from rpy2.robjects import numpy2ri, pandas2ri
+            from rpy2.robjects.conversion import localconverter
+            from rpy2.robjects.packages import importr
+
+        except ImportError:
+            raise ImportError("edger requires rpy2 to be installed.") from None
+
+        try:
+            importr("edgeR")
+        except ImportError:
+            raise ImportError(
+                "edgeR requires a valid R installation with the following packages: " "edgeR, BiocParallel, RhpcBLASctl"
+            ) from None
+
+        # Convert vector to R, which drops a category like `self.design_matrix` to use the intercept for the left out.
+        contrast_vec_r = ro.conversion.py2rpy(np.asarray(contrast))
+        ro.globalenv["contrast_vec"] = contrast_vec_r
+
+        # Test contrast with R
+        ro.r(
+            """
+            test = edgeR::glmQLFTest(fit, contrast=contrast_vec)
+            de_res =  edgeR::topTags(test, n=Inf, adjust.method="BH", sort.by="PValue")$table
+            """
+        )
+
+        # Convert results to pandas
+        de_res = ro.conversion.rpy2py(ro.globalenv["de_res"])
+        de_res.index.name = "variable"
+        de_res = de_res.reset_index()
+
+        return de_res.rename(columns={"PValue": "p_value", "logFC": "log_fc", "FDR": "adj_p_value"})

pertpy/tools/_differential_gene_expression/_formulaic.py

@@ -0,0 +1,189 @@
+"""Helpers to interact with Formulaic Formulas
+
+Some helpful definitions for working with formulaic formulas (e.g. `~ 0 + C(donor):treatment + np.log1p(continuous)`):
+ * A *term* refers to an expression in the formula, separated by `+`, e.g. `C(donor):treatment`, or `np.log1p(continuous)`.
+ * A *variable* refers to a column of the data frame passed to formulaic, e.g. `donor`.
+ * A *factor* is the specification of how a certain variable is represented in the design matrix, e.g. treatment coding with base level "A" and reduced rank.
+"""
+
+from collections import defaultdict
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+from formulaic import FactorValues, ModelSpec
+from formulaic.materializers import PandasMaterializer
+from formulaic.materializers.types import EvaluatedFactor
+from formulaic.parser.types import Factor
+from interface_meta import override
+
+
+@dataclass
+class FactorMetadata:
+    """Store (relevant) metadata for a factor of a formula."""
+
+    name: str
+    """The unambiguous factor name as specified in the formula. E.g. `donor`, or `C(donor, contr.treatment(base="A"))`"""
+
+    reduced_rank: bool
+    """Whether a column will be dropped because it is redundant"""
+
+    custom_encoder: bool
+    """Whether or not a custom encoder (e.g. `C(...)`) was used."""
+
+    categories: Sequence[str]
+    """The unique categories in this factor (after applying `drop_rows`)"""
+
+    kind: Factor.Kind
+    """Type of the factor"""
+
+    drop_field: str = None
+    """The category that is dropped.
+
+    Note that
+      * this may also be populated if `reduced_rank = False`
+      * this is only populated when no encoder was used (e.g. `~ donor` but NOT `~ C(donor)`.
+    """
+
+    column_names: Sequence[str] = None
+    """The column names for this factor included in the design matrix.
+
+    This may be the same as `categories` if the default encoder is used, or
+    categories without the base level if a custom encoder (e.g. `C(...)`) is used.
+    """
+
+    colname_format: str = None
+    """A formattable string that can be used to generate the column name in the design matrix, e.g. `{name}[T.{field}]`"""
+
+    @property
+    def base(self) -> str | None:
+        """
+        The base category for this categorical factor.
+
+        This is derived from `drop_field` (for default encoding) or by comparing the column names in
+        the design matrix with all categories (for custom encoding, e.g. `C(...)`).
+        """
+        if not self.reduced_rank:
+            return None
+        else:
+            if self.custom_encoder:
+                tmp_base = set(self.categories) - set(self.column_names)
+                assert len(tmp_base) == 1
+                return tmp_base.pop()
+            else:
+                assert self.drop_field is not None
+                return self.drop_field
+
+
+def get_factor_storage_and_materializer() -> tuple[dict[str, list[FactorMetadata]], dict[str, set[str]], type]:
+    """Keeps track of categorical factors used in a model specification by generating a custom materializer.
+
+    This materializer reports back metadata upon materialization of the model matrix.
+
+    Returns:
+        - A dictionary storing metadata for each factor processed by the custom materializer, named `factor_storage`.
+        - A dictionary mapping variables to factor names, which works similarly to model_spec.variable_terms
+            but maps to factors rather than terms, named `variable_to_factors`.
+        - A materializer class tied to the specific instance of `factor_storage`.
+    """
+    # There can be multiple FactorMetadata entries per sample, for instance when formulaic generates an interaction
+    # term, it generates the factor with both full rank and reduced rank.
+    factor_storage: dict[str, list[FactorMetadata]] = defaultdict(list)
+    variable_to_factors: dict[str, set[str]] = defaultdict(set)
+
+    class CustomPandasMaterializer(PandasMaterializer):
+        """An extension of the PandasMaterializer that records all categorical variables and their (base) categories."""
+
+        REGISTER_NAME = "custom_pandas"
+        REGISTER_INPUTS = ("pandas.core.frame.DataFrame",)
+        REGISTER_OUTPUTS = ("pandas", "numpy", "sparse")
+
+        def __init__(
+            self,
+            data: Any,
+            context: Mapping[str, Any] | None = None,
+            record_factor_metadata: bool = False,
+            **params: Any,
+        ):
+            """Initialize the Materializer.
+
+            Args:
+                data: Passed to PandasMaterializer.
+                context: Passed to PandasMaterializer
+                record_factor_metadata: Flag that tells whether this particular instance of the custom materializer class
+                    is supposed to record factor metadata. Only the instance that is used for building the design
+                    matrix should record the metadata. All other instances (e.g. used to generate contrast vectors)
+                    should not record metadata to not overwrite the specifications from the design matrix.
+                **params: Passed to PandasMaterializer
+            """
+            self.factor_metadata_storage = factor_storage if record_factor_metadata else None
+            self.variable_to_factors = variable_to_factors if record_factor_metadata else None
+            # temporary pointer to metadata of factor that is currently evaluated
+            self._current_factor: FactorMetadata = None
+            super().__init__(data, context, **params)
+
+        @override
+        def _encode_evaled_factor(
+            self, factor: EvaluatedFactor, spec: ModelSpec, drop_rows: Sequence[int], reduced_rank: bool = False
+        ) -> dict[str, Any]:
+            """Function is called just before the factor is evaluated.
+
+            We can record some metadata, before we call the original function.
+            """
+            assert (
+                self._current_factor is None
+            ), "_current_factor should always be None when we start recording metadata"
+            if self.factor_metadata_storage is not None:
+                # Don't store if the factor is cached (then we should already have recorded it)
+                if factor.expr in self.encoded_cache or (factor.expr, reduced_rank) in self.encoded_cache:
+                    assert factor.expr in self.factor_metadata_storage, "Factor should be there since it's cached"
+                else:
+                    for var in factor.variables:
+                        self.variable_to_factors[var].add(factor.expr)
+                    self._current_factor = FactorMetadata(
+                        name=factor.expr,
+                        reduced_rank=reduced_rank,
+                        categories=tuple(sorted(factor.values.drop(index=factor.values.index[drop_rows]).unique())),
+                        custom_encoder=factor.metadata.encoder is not None,
+                        kind=factor.metadata.kind,
+                    )
+            return super()._encode_evaled_factor(factor, spec, drop_rows, reduced_rank)
+
+        @override
+        def _flatten_encoded_evaled_factor(self, name: str, values: FactorValues[dict]) -> dict[str, Any]:
+            """
+            Function is called at the end, before the design matrix gets materialized.
+
+            Here we have access to additional metadata, such as `drop_field`.
+            """
+            if self._current_factor is not None:
+                assert self._current_factor.name == name
+                self._current_factor.drop_field = values.__formulaic_metadata__.drop_field
+                self._current_factor.column_names = values.__formulaic_metadata__.column_names
+                self._current_factor.colname_format = values.__formulaic_metadata__.format
+                self.factor_metadata_storage[name].append(self._current_factor)
+                self._current_factor = None
+
+            return super()._flatten_encoded_evaled_factor(name, values)
+
+    return factor_storage, variable_to_factors, CustomPandasMaterializer
+
+
+class AmbiguousAttributeError(ValueError):
+    pass
+
+
+def resolve_ambiguous(objs: Sequence[Any], attr: str) -> Any:
+    """Given a list of objects, return an attribute if it is the same between all object. Otherwise, raise an error."""
+    if not objs:
+        raise ValueError("Collection is empty")
+
+    first_obj_attr = getattr(objs[0], attr)
+
+    # Check if the attribute is the same for all objects
+    for obj in objs[1:]:
+        if getattr(obj, attr) != first_obj_attr:
+            raise AmbiguousAttributeError(f"Ambiguous attribute '{attr}': values differ between objects")
+
+    # If attribute is the same for all objects, return it
+    return first_obj_attr

pertpy/tools/_differential_gene_expression/_pydeseq2.py

@@ -0,0 +1,95 @@
+import os
+import re
+import warnings
+
+import pandas as pd
+from anndata import AnnData
+from numpy import ndarray
+from pydeseq2.dds import DeseqDataSet
+from pydeseq2.default_inference import DefaultInference
+from pydeseq2.ds import DeseqStats
+from scipy.sparse import issparse
+
+from ._base import LinearModelBase
+from ._checks import check_is_integer_matrix
+
+
+class PyDESeq2(LinearModelBase):
+    """Differential expression test using a PyDESeq2"""
+
+    def __init__(
+        self, adata: AnnData, design: str | ndarray, *, mask: str | None = None, layer: str | None = None, **kwargs
+    ):
+        super().__init__(adata, design, mask=mask, layer=layer, **kwargs)
+        # work around pydeseq2 issue with sparse matrices
+        # see also https://github.com/owkin/PyDESeq2/issues/25
+        if issparse(self.data):
+            if self.layer is None:
+                self.adata.X = self.adata.X.toarray()
+            else:
+                self.adata.layers[self.layer] = self.adata.layers[self.layer].toarray()
+
+    def _check_counts(self):
+        check_is_integer_matrix(self.data)
+
+    def fit(self, **kwargs) -> pd.DataFrame:
+        """Fit dds model using pydeseq2.
+
+        Note: this creates its own AnnData object for downstream processing.
+
+        Args:
+            **kwargs: Keyword arguments specific to DeseqDataSet(), except for `n_cpus` which will use all available CPUs minus one if the argument is not passed.
+        """
+        inference = DefaultInference(n_cpus=kwargs.pop("n_cpus", os.cpu_count() - 1))
+        covars = self.design.columns.tolist()
+        if "Intercept" not in covars:
+            warnings.warn(
+                "Warning: Pydeseq is hard-coded to use Intercept, please include intercept into the model", stacklevel=2
+            )
+        processed_covars = list({re.sub(r"\[T\.(.*)\]", "", col) for col in covars if col != "Intercept"})
+        dds = DeseqDataSet(
+            adata=self.adata, design_factors=processed_covars, refit_cooks=True, inference=inference, **kwargs
+        )
+        # workaround code to insert design array
+        des_mtx_cols = dds.obsm["design_matrix"].columns
+        dds.obsm["design_matrix"] = self.design
+        if dds.obsm["design_matrix"].shape[1] == len(des_mtx_cols):
+            dds.obsm["design_matrix"].columns = des_mtx_cols.copy()
+
+        dds.deseq2()
+        self.dds = dds
+
+    # TODO: PyDeseq2 doesn't support arbitrary designs and contrasts yet
+    # see https://github.com/owkin/PyDESeq2/issues/213
+
+    # Therefore these functions are overridden in a way to make it work with PyDESeq2,
+    # ingoring the inconsistency of function signatures. Once arbitrary design
+    # matrices and contrasts are supported by PyDEseq2, we can fully support the
+    # Linear model interface.
+    def _test_single_contrast(self, contrast: list[str], alpha=0.05, **kwargs) -> pd.DataFrame:  # type: ignore
+        """Conduct a specific test and returns a Pandas DataFrame.
+
+        Args:
+            contrast: list of three strings of the form `["variable", "tested level", "reference level"]`.
+            alpha: p value threshold used for controlling fdr with independent hypothesis weighting
+            **kwargs: extra arguments to pass to DeseqStats()
+        """
+        stat_res = DeseqStats(self.dds, contrast=contrast, alpha=alpha, **kwargs)
+        # Calling `.summary()` is required to fill the `results_df` data frame
+        stat_res.summary()
+        res_df = (
+            pd.DataFrame(stat_res.results_df)
+            .rename(columns={"pvalue": "p_value", "padj": "adj_p_value", "log2FoldChange": "log_fc"})
+            .sort_values("p_value")
+        )
+        res_df.index.name = "variable"
+        res_df = res_df.reset_index()
+        return res_df
+
+    def cond(self, **kwargs) -> ndarray:
+        raise NotImplementedError(
+            "PyDESeq2 currently doesn't support arbitrary contrasts, see https://github.com/owkin/PyDESeq2/issues/213"
+        )
+
+    def contrast(self, column: str, baseline: str, group_to_compare: str) -> tuple[str, str, str]:  # type: ignore
+        return (column, group_to_compare, baseline)

pertpy/tools/_differential_gene_expression/_simple_tests.py

@@ -0,0 +1,162 @@
+"""Simple tests such as t-test, wilcoxon"""
+
+import warnings
+from abc import abstractmethod
+from collections.abc import Mapping, Sequence
+from types import MappingProxyType
+
+import numpy as np
+import pandas as pd
+import scipy.stats
+import statsmodels
+from anndata import AnnData
+from pandas.core.api import DataFrame as DataFrame
+from scipy.sparse import diags, issparse
+from tqdm.auto import tqdm
+
+from ._base import MethodBase
+
+
+def fdr_correction(
+    df: pd.DataFrame, pvalue_col: str = "p_value", *, key_added: str = "adj_p_value", inplace: bool = False
+):
+    """Adjust p-values in a DataFrame with test results using FDR correction."""
+    if not inplace:
+        df = df.copy()
+
+    df[key_added] = statsmodels.stats.multitest.fdrcorrection(df[pvalue_col].values)[1]
+
+    if not inplace:
+        return df
+
+
+class SimpleComparisonBase(MethodBase):
+    @staticmethod
+    @abstractmethod
+    def _test(x0: np.ndarray, x1: np.ndarray, paired: bool, **kwargs) -> float:
+        """Perform a statistical test between values in x0 and x1.
+
+        If `paired` is True, x0 and x1 must be of the same length and ordered such that
+        paired elements have the same position.
+
+        Args:
+            x0: Array with baseline values.
+            x1: Array with values to compare.
+            paired: Indicates whether to perform a paired test
+            **kwargs: kwargs passed to the test function
+        """
+        ...
+
+    def _compare_single_group(
+        self, baseline_idx: np.ndarray, comparison_idx: np.ndarray, *, paired: bool, **kwargs
+    ) -> DataFrame:
+        """Perform a single comparison between two groups.
+
+        Args:
+            baseline_idx: Numeric indices indicating which observations are in the baseline group.
+            comparison_idx: Numeric indices indicating which observations are in the comparison/treatment group
+            paired: Whether to perform a paired test. Note that in the case of a paired test,
+                the indices must be ordered such that paired observations appear at the same position.
+            **kwargs: kwargs passed to the test function
+        """
+        if paired:
+            assert len(baseline_idx) == len(comparison_idx), "For a paired test, indices must be of the same length"
+
+        x0 = self.data[baseline_idx, :]
+        x1 = self.data[comparison_idx, :]
+
+        # In the following loop, we are doing a lot of column slicing -- which is significantly
+        # more efficient in csc format.
+        if issparse(self.data):
+            x0 = x0.tocsc()
+            x1 = x1.tocsc()
+
+        res = []
+        for var in tqdm(self.adata.var_names):
+            tmp_x0 = x0[:, self.adata.var_names == var]
+            tmp_x0 = np.asarray(tmp_x0.todense()).flatten() if issparse(tmp_x0) else tmp_x0.flatten()
+            tmp_x1 = x1[:, self.adata.var_names == var]
+            tmp_x1 = np.asarray(tmp_x1.todense()).flatten() if issparse(tmp_x1) else tmp_x1.flatten()
+            pval = self._test(tmp_x0, tmp_x1, paired, **kwargs)
+            mean_x0 = np.mean(tmp_x0)
+            mean_x1 = np.mean(tmp_x1)
+            res.append({"variable": var, "p_value": pval, "log_fc": np.log2(mean_x1) - np.log2(mean_x0)})
+        return pd.DataFrame(res).sort_values("p_value")
+
+    @classmethod
+    def compare_groups(
+        cls,
+        adata: AnnData,
+        column: str,
+        baseline: str,
+        groups_to_compare: str | Sequence[str],
+        *,
+        paired_by: str | None = None,
+        mask: str | None = None,
+        layer: str | None = None,
+        fit_kwargs: Mapping = MappingProxyType({}),
+        test_kwargs: Mapping = MappingProxyType({}),
+    ) -> DataFrame:
+        if len(fit_kwargs):
+            warnings.warn("fit_kwargs not used for simple tests.", UserWarning, stacklevel=2)
+        paired = paired_by is not None
+        model = cls(adata, mask=mask, layer=layer)
+        if groups_to_compare is None:
+            # compare against all other
+            groups_to_compare = sorted(set(model.adata.obs[column]) - {baseline})
+        if isinstance(groups_to_compare, str):
+            groups_to_compare = [groups_to_compare]
+
+        def _get_idx(column, value):
+            mask = model.adata.obs[column] == value
+            if paired:
+                dummies = pd.get_dummies(model.adata.obs[paired_by], sparse=True).sparse.to_coo().tocsr()
+                if not np.all(np.sum(dummies, axis=0) == 2):
+                    raise ValueError("Pairing is only possible with exactly two values per group")
+                # Use matrix multiplication to only retreive those dummy entries that are associated with the current `value`.
+                # Convert to COO matrix to get rows/cols
+                # row indices refers to the indices of rows that have `column == value` (equivalent to np.where(mask)[0])
+                # col indices refers to the numeric index of each "pair" in obs_names
+                ind_mat = diags(mask.values, dtype=bool) @ dummies
+                if not np.all(np.sum(ind_mat, axis=0) == 1):
+                    raise ValueError("Pairing is only possible with exactly two values per group")
+                ind_mat = ind_mat.tocoo()
+                return ind_mat.row[np.argsort(ind_mat.col)]
+            else:
+                return np.where(mask)[0]
+
+        res_dfs = []
+        baseline_idx = _get_idx(column, baseline)
+        for group_to_compare in groups_to_compare:
+            comparison_idx = _get_idx(column, group_to_compare)
+            res_dfs.append(
+                model._compare_single_group(baseline_idx, comparison_idx, paired=paired, **test_kwargs).assign(
+                    comparison=f"{group_to_compare}_vs_{baseline if baseline is not None else 'rest'}"
+                )
+            )
+        return fdr_correction(pd.concat(res_dfs))
+
+
+class WilcoxonTest(SimpleComparisonBase):
+    """Perform a unpaired or paired Wilcoxon test.
+
+    (the former is also known as "Mann-Whitney U test", the latter as "wilcoxon signed rank test")
+    """
+
+    @staticmethod
+    def _test(x0: np.ndarray, x1: np.ndarray, paired: bool, **kwargs) -> float:
+        if paired:
+            return scipy.stats.wilcoxon(x0, x1, **kwargs).pvalue
+        else:
+            return scipy.stats.mannwhitneyu(x0, x1, **kwargs).pvalue
+
+
+class TTest(SimpleComparisonBase):
+    """Perform a unpaired or paired T-test"""
+
+    @staticmethod
+    def _test(x0: np.ndarray, x1: np.ndarray, paired: bool, **kwargs) -> float:
+        if paired:
+            return scipy.stats.ttest_rel(x0, x1, **kwargs).pvalue
+        else:
+            return scipy.stats.ttest_ind(x0, x1, **kwargs).pvalue