pertpy 0.9.4__py3-none-any.whl → 0.9.5__py3-none-any.whl

pertpy/tools/_differential_gene_expression/_edger.py

@@ -2,7 +2,7 @@ from collections.abc import Sequence
 
 import numpy as np
 import pandas as pd
-from scanpy import logging
+from lamin_utils import logger
 from scipy.sparse import issparse
 
 from ._base import LinearModelBase
@@ -27,16 +27,11 @@ class EdgeR(LinearModelBase):
         # 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.conversion import get_conversion, 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
 
@@ -49,25 +44,30 @@ class EdgeR(LinearModelBase):
             ) from e
 
         # Convert dataframe
-        with localconverter(ro.default_converter + numpy2ri.converter):
+        with localconverter(get_conversion() + 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))
+        with localconverter(get_conversion() + pandas2ri.converter):
+            expr_r = ro.conversion.py2rpy(pd.DataFrame(expr, index=self.adata.var_names, columns=self.adata.obs_names))
+            samples_r = ro.conversion.py2rpy(self.adata.obs)
 
-        dge = edger.DGEList(counts=expr_r, samples=self.adata.obs)
+        dge = edger.DGEList(counts=expr_r, samples=samples_r)
 
-        logging.info("Calculating NormFactors")
+        logger.info("Calculating NormFactors")
         dge = edger.calcNormFactors(dge)
 
-        logging.info("Estimating Dispersions")
-        dge = edger.estimateDisp(dge, design=self.design)
+        with localconverter(get_conversion() + numpy2ri.converter):
+            design_r = ro.conversion.py2rpy(self.design.values)
+
+        logger.info("Estimating Dispersions")
+        dge = edger.estimateDisp(dge, design=design_r)
 
-        logging.info("Fitting linear model")
-        fit = edger.glmQLFit(dge, design=self.design, **kwargs)
+        logger.info("Fitting linear model")
+        fit = edger.glmQLFit(dge, design=design_r, **kwargs)
 
         ro.globalenv["fit"] = fit
         self.fit = fit
@@ -88,11 +88,9 @@ class EdgeR(LinearModelBase):
         #  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.conversion import get_conversion, localconverter
             from rpy2.robjects.packages import importr
 
         except ImportError:
@@ -106,7 +104,8 @@ class EdgeR(LinearModelBase):
             ) 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))
+        with localconverter(get_conversion() + numpy2ri.converter):
+            contrast_vec_r = ro.conversion.py2rpy(np.asarray(contrast))
         ro.globalenv["contrast_vec"] = contrast_vec_r
 
         # Test contrast with R
@@ -117,8 +116,18 @@ class EdgeR(LinearModelBase):
             """
         )
 
-        # Convert results to pandas
-        de_res = ro.conversion.rpy2py(ro.globalenv["de_res"])
+        # Retrieve the `de_res` object
+        de_res = ro.globalenv["de_res"]
+
+        # If already a Pandas DataFrame, return it directly
+        if isinstance(de_res, pd.DataFrame):
+            de_res.index.name = "variable"
+            return de_res.reset_index().rename(columns={"PValue": "p_value", "logFC": "log_fc", "FDR": "adj_p_value"})
+
+        # Convert to Pandas DataFrame if still an R object
+        with localconverter(get_conversion() + pandas2ri.converter):
+            de_res = ro.conversion.rpy2py(de_res)
+
         de_res.index.name = "variable"
         de_res = de_res.reset_index()
 

pertpy/tools/_differential_gene_expression/_pydeseq2.py

@@ -2,6 +2,7 @@ import os
 import re
 import warnings
 
+import numpy as np
 import pandas as pd
 from anndata import AnnData
 from numpy import ndarray
@@ -40,33 +41,25 @@ class PyDESeq2(LinearModelBase):
         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"})
+        try:
+            usable_cpus = len(os.sched_getaffinity(0))
+        except AttributeError:
+            usable_cpus = os.cpu_count()
+
+        inference = DefaultInference(n_cpus=kwargs.pop("n_cpus", usable_cpus))
+
         dds = DeseqDataSet(
-            adata=self.adata, design_factors=processed_covars, refit_cooks=True, inference=inference, **kwargs
+            adata=self.adata,
+            design=self.design,  # initialize using design matrix, not formula
+            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
+    def _test_single_contrast(self, contrast, alpha=0.05, **kwargs) -> pd.DataFrame:
         """Conduct a specific test and returns a Pandas DataFrame.
 
         Args:
@@ -74,6 +67,7 @@ class PyDESeq2(LinearModelBase):
             alpha: p value threshold used for controlling fdr with independent hypothesis weighting
             **kwargs: extra arguments to pass to DeseqStats()
         """
+        contrast = np.array(contrast)
         stat_res = DeseqStats(self.dds, contrast=contrast, alpha=alpha, **kwargs)
         # Calling `.summary()` is required to fill the `results_df` data frame
         stat_res.summary()
@@ -85,11 +79,3 @@ class PyDESeq2(LinearModelBase):
         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/_statsmodels.py

@@ -59,14 +59,3 @@ class Statsmodels(LinearModelBase):
                 }
             )
         return pd.DataFrame(res).sort_values("p_value")
-
-    def contrast(self, column: str, baseline: str, group_to_compare: str) -> np.ndarray:
-        """Build a simple contrast for pairwise comparisons.
-
-        This is equivalent to
-
-        ```
-        model.cond(<column> = baseline) - model.cond(<column> = group_to_compare)
-        ```
-        """
-        return self.cond(**{column: baseline}) - self.cond(**{column: group_to_compare})

pertpy/tools/_distances/_distances.py

@@ -344,9 +344,9 @@ class Distance:
             else:
                 embedding = adata.obsm[self.obsm_key].copy()
             for index_x, group_x in enumerate(fct(groups)):
-                cells_x = embedding[grouping == group_x].copy()
+                cells_x = embedding[np.asarray(grouping == group_x)].copy()
                 for group_y in groups[index_x:]:  # type: ignore
-                    cells_y = embedding[grouping == group_y].copy()
+                    cells_y = embedding[np.asarray(grouping == group_y)].copy()
                     if not bootstrap:
                         # By distance axiom, the distance between a group and itself is 0
                         dist = 0.0 if group_x == group_y else self(cells_x, cells_y, **kwargs)
@@ -478,9 +478,9 @@ class Distance:
             else:
                 embedding = adata.obsm[self.obsm_key].copy()
             for group_x in fct(groups):
-                cells_x = embedding[grouping == group_x].copy()
+                cells_x = embedding[np.asarray(grouping == group_x)].copy()
                 group_y = selected_group
-                cells_y = embedding[grouping == group_y].copy()
+                cells_y = embedding[np.asarray(grouping == group_y)].copy()
                 if not bootstrap:
                     # By distance axiom, the distance between a group and itself is 0
                     dist = 0.0 if group_x == group_y else self(cells_x, cells_y, **kwargs)
@@ -691,17 +691,18 @@ class MMD(AbstractDistance):
 
 
 class WassersteinDistance(AbstractDistance):
-    """Wasserstein distance metric (solved with entropy regularized Sinkhorn)."""
-
     def __init__(self) -> None:
         super().__init__()
         self.accepts_precomputed = False
 
     def __call__(self, X: np.ndarray, Y: np.ndarray, **kwargs) -> float:
+        X = np.asarray(X, dtype=np.float64)
+        Y = np.asarray(Y, dtype=np.float64)
         geom = PointCloud(X, Y)
         return self.solve_ot_problem(geom, **kwargs)
 
     def from_precomputed(self, P: np.ndarray, idx: np.ndarray, **kwargs) -> float:
+        P = np.asarray(P, dtype=np.float64)
         geom = Geometry(cost_matrix=P[idx, :][:, ~idx])
         return self.solve_ot_problem(geom, **kwargs)
 
@@ -709,7 +710,13 @@ class WassersteinDistance(AbstractDistance):
         ot_prob = LinearProblem(geom)
         solver = Sinkhorn()
         ot = solver(ot_prob, **kwargs)
-        return ot.reg_ot_cost.item()
+        cost = float(ot.reg_ot_cost)
+
+        # Check for NaN or invalid cost
+        if not np.isfinite(cost):
+            return 1.0
+        else:
+            return cost
 
 
 class EuclideanDistance(AbstractDistance):
@@ -981,7 +988,7 @@ class NBLL(AbstractDistance):
             try:
                 nb_params = NegativeBinomialP(x, np.ones_like(x)).fit(disp=False).params
                 return _compute_nll(y, nb_params, epsilon)
-            except np.linalg.linalg.LinAlgError:
+            except np.linalg.LinAlgError:
                 if x.mean() < 10 and y.mean() < 10:
                     return 0.0
                 else:

pertpy/tools/_enrichment.py

@@ -3,6 +3,7 @@ from collections.abc import Sequence
 from typing import Any, Literal
 
 import blitzgsea
+import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
 import scanpy as sc
@@ -14,6 +15,7 @@ from scipy.sparse import issparse
 from scipy.stats import hypergeom
 from statsmodels.stats.multitest import multipletests
 
+from pertpy._doc import _doc_params, doc_common_plot_args
 from pertpy.metadata import Drug
 
 
@@ -290,9 +292,11 @@ class Enrichment:
 
         return enrichment
 
+    @_doc_params(common_plot_args=doc_common_plot_args)
     def plot_dotplot(
         self,
         adata: AnnData,
+        *,
         targets: dict[str, dict[str, list[str]]] = None,
         source: Literal["chembl", "dgidb", "pharmgkb"] = "chembl",
         category_name: str = "interaction_type",
@@ -300,10 +304,10 @@ class Enrichment:
         groupby: str = None,
         key: str = "pertpy_enrichment",
         ax: Axes | None = None,
-        save: bool | str | None = None,
-        show: bool | None = None,
+        show: bool = True,
+        return_fig: bool = False,
         **kwargs,
-    ) -> DotPlot | dict | None:
+    ) -> DotPlot | None:
         """Plots a dotplot by groupby and categories.
 
         Wraps scanpy's dotplot but formats it nicely by categories.
@@ -319,11 +323,11 @@ class Enrichment:
             category_name: The name of category used to generate a nested drug target set when `targets=None` and `source=dgidb|pharmgkb`.
             groupby: dotplot groupby such as clusters or cell types.
             key: Prefix key of enrichment results in `uns`.
+            {common_plot_args}
             kwargs: Passed to scanpy dotplot.
 
         Returns:
-            If `return_fig` is `True`, returns a :class:`~scanpy.pl.DotPlot` object,
-            else if `show` is false, return axes dict.
+            If `return_fig` is `True`, returns the figure, otherwise `None`.
 
         Examples:
             >>> import pertpy as pt
@@ -403,21 +407,27 @@ class Enrichment:
             "var_group_labels": var_group_labels,
         }
 
-        return sc.pl.dotplot(
+        fig = sc.pl.dotplot(
             enrichment_score_adata,
             groupby=groupby,
             swap_axes=True,
             ax=ax,
-            save=save,
-            show=show,
+            show=False,
             **plot_args,
             **kwargs,
         )
 
+        if show:
+            plt.show()
+        if return_fig:
+            return fig
+        return None
+
     def plot_gsea(
         self,
         adata: AnnData,
         enrichment: dict[str, pd.DataFrame],
+        *,
         n: int = 10,
         key: str = "pertpy_enrichment_gsea",
         interactive_plot: bool = False,

pertpy/tools/_milo.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import logging
 import random
 import re
 from typing import TYPE_CHECKING, Literal
@@ -14,6 +13,8 @@ from anndata import AnnData
 from lamin_utils import logger
 from mudata import MuData
 
+from pertpy._doc import _doc_params, doc_common_plot_args
+
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
@@ -125,7 +126,7 @@ class Milo:
             try:
                 use_rep = adata.uns["neighbors"]["params"]["use_rep"]
             except KeyError:
-                logging.warning("Using X_pca as default embedding")
+                logger.warning("Using X_pca as default embedding")
                 use_rep = "X_pca"
             try:
                 knn_graph = adata.obsp["connectivities"].copy()
@@ -136,7 +137,7 @@ class Milo:
             try:
                 use_rep = adata.uns[neighbors_key]["params"]["use_rep"]
             except KeyError:
-                logging.warning("Using X_pca as default embedding")
+                logger.warning("Using X_pca as default embedding")
                 use_rep = "X_pca"
             knn_graph = adata.obsp[neighbors_key + "_connectivities"].copy()
 
@@ -182,7 +183,7 @@ class Milo:
             knn_dists = adata.obsp[neighbors_key + "_distances"]
 
         nhood_ixs = adata.obs["nhood_ixs_refined"] == 1
-        dist_mat = knn_dists[nhood_ixs, :]
+        dist_mat = knn_dists[np.asarray(nhood_ixs), :]
         k_distances = dist_mat.max(1).toarray().ravel()
         adata.obs["nhood_kth_distance"] = 0
         adata.obs["nhood_kth_distance"] = adata.obs["nhood_kth_distance"].astype(float)
@@ -703,8 +704,8 @@ class Milo:
         pvalues = sample_adata.var["PValue"]
         keep_nhoods = ~pvalues.isna()  # Filtering in case of test on subset of nhoods
         o = pvalues[keep_nhoods].argsort()
-        pvalues = pvalues[keep_nhoods][o]
-        w = w[keep_nhoods][o]
+        pvalues = pvalues.loc[keep_nhoods].iloc[o]
+        w = w.loc[keep_nhoods].iloc[o]
 
         adjp = np.zeros(shape=len(o))
         adjp[o] = (sum(w) * pvalues / np.cumsum(w))[::-1].cummin()[::-1]
@@ -713,9 +714,11 @@ class Milo:
         sample_adata.var["SpatialFDR"] = np.nan
         sample_adata.var.loc[keep_nhoods, "SpatialFDR"] = adjp
 
+    @_doc_params(common_plot_args=doc_common_plot_args)
     def plot_nhood_graph(
         self,
         mdata: MuData,
+        *,
         alpha: float = 0.1,
         min_logFC: float = 0,
         min_size: int = 10,
@@ -724,10 +727,10 @@ class Milo:
         color_map: Colormap | str | None = None,
         palette: str | Sequence[str] | None = None,
         ax: Axes | None = None,
-        show: bool | None = None,
-        save: bool | str | None = None,
+        show: bool = True,
+        return_fig: bool = False,
         **kwargs,
-    ) -> None:
+    ) -> Figure | None:
         """Visualize DA results on abstracted graph (wrapper around sc.pl.embedding)
 
         Args:
@@ -737,9 +740,7 @@ class Milo:
             min_size: Minimum size of nodes in visualization. (default: 10)
             plot_edges: If edges for neighbourhood overlaps whould be plotted.
             title: Plot title.
-            show: Show the plot, do not return axis.
-            save: If `True` or a `str`, save the figure. A string is appended to the default filename.
-                  Infer the filetype if ending on {`'.pdf'`, `'.png'`, `'.svg'`}.
+            {common_plot_args}
             **kwargs: Additional arguments to `scanpy.pl.embedding`.
 
         Examples:
@@ -782,7 +783,7 @@ class Milo:
         vmax = np.max([nhood_adata.obs["graph_color"].max(), abs(nhood_adata.obs["graph_color"].min())])
         vmin = -vmax
 
-        sc.pl.embedding(
+        fig = sc.pl.embedding(
             nhood_adata,
             "X_milo_graph",
             color="graph_color",
@@ -798,33 +799,42 @@ class Milo:
             color_map=color_map,
             palette=palette,
             ax=ax,
-            show=show,
-            save=save,
+            show=False,
             **kwargs,
         )
 
+        if show:
+            plt.show()
+        if return_fig:
+            return fig
+        return None
+
+    @_doc_params(common_plot_args=doc_common_plot_args)
     def plot_nhood(
         self,
         mdata: MuData,
         ix: int,
+        *,
         feature_key: str | None = "rna",
         basis: str = "X_umap",
         color_map: Colormap | str | None = None,
         palette: str | Sequence[str] | None = None,
-        return_fig: bool | None = None,
         ax: Axes | None = None,
-        show: bool | None = None,
-        save: bool | str | None = None,
+        show: bool = True,
+        return_fig: bool = False,
         **kwargs,
-    ) -> None:
+    ) -> Figure | None:
         """Visualize cells in a neighbourhood.
 
         Args:
             mdata: MuData object with feature_key slot, storing neighbourhood assignments in `mdata[feature_key].obsm['nhoods']`
             ix: index of neighbourhood to visualize
+            feature_key: Key in mdata to the cell-level AnnData object.
             basis: Embedding to use for visualization.
-            show: Show the plot, do not return axis.
-            save: If True or a str, save the figure. A string is appended to the default filename. Infer the filetype if ending on {'.pdf', '.png', '.svg'}.
+            color_map: Colormap to use for coloring.
+            palette: Color palette to use for coloring.
+            ax: Axes to plot on.
+            {common_plot_args}
             **kwargs: Additional arguments to `scanpy.pl.embedding`.
 
         Examples:
@@ -842,7 +852,7 @@ class Milo:
             .. image:: /_static/docstring_previews/milo_nhood.png
         """
         mdata[feature_key].obs["Nhood"] = mdata[feature_key].obsm["nhoods"][:, ix].toarray().ravel()
-        sc.pl.embedding(
+        fig = sc.pl.embedding(
             mdata[feature_key],
             basis,
             color="Nhood",
@@ -852,32 +862,43 @@ class Milo:
             palette=palette,
             return_fig=return_fig,
             ax=ax,
-            show=show,
-            save=save,
+            show=False,
             **kwargs,
         )
 
+        if show:
+            plt.show()
+        if return_fig:
+            return fig
+        return None
+
+    @_doc_params(common_plot_args=doc_common_plot_args)
     def plot_da_beeswarm(
         self,
         mdata: MuData,
+        *,
         feature_key: str | None = "rna",
         anno_col: str = "nhood_annotation",
         alpha: float = 0.1,
         subset_nhoods: list[str] = None,
         palette: str | Sequence[str] | dict[str, str] | None = None,
-        return_fig: bool | None = None,
-        save: bool | str | None = None,
-        show: bool | None = None,
-    ) -> Figure | Axes | None:
+        show: bool = True,
+        return_fig: bool = False,
+    ) -> Figure | None:
         """Plot beeswarm plot of logFC against nhood labels
 
         Args:
             mdata: MuData object
+            feature_key: Key in mdata to the cell-level AnnData object.
             anno_col: Column in adata.uns['nhood_adata'].obs to use as annotation. (default: 'nhood_annotation'.)
             alpha: Significance threshold. (default: 0.1)
             subset_nhoods: List of nhoods to plot. If None, plot all nhoods.
             palette: Name of Seaborn color palette for violinplots.
                      Defaults to pre-defined category colors for violinplots.
+            {common_plot_args}
+
+        Returns:
+            If `return_fig` is `True`, returns the figure, otherwise `None`.
 
         Examples:
             >>> import pertpy as pt
@@ -973,29 +994,23 @@ class Milo:
         plt.legend(loc="upper left", title=f"< {int(alpha * 100)}% SpatialFDR", bbox_to_anchor=(1, 1), frameon=False)
         plt.axvline(x=0, ymin=0, ymax=1, color="black", linestyle="--")
 
-        if save:
-            plt.savefig(save, bbox_inches="tight")
-            return None
         if show:
             plt.show()
-            return None
         if return_fig:
             return plt.gcf()
-        if (not show and not save) or (show is None and save is None):
-            return plt.gca()
-
         return None
 
+    @_doc_params(common_plot_args=doc_common_plot_args)
     def plot_nhood_counts_by_cond(
         self,
         mdata: MuData,
         test_var: str,
+        *,
         subset_nhoods: list[str] = None,
         log_counts: bool = False,
-        return_fig: bool | None = None,
-        save: bool | str | None = None,
-        show: bool | None = None,
-    ) -> Figure | Axes | None:
+        show: bool = True,
+        return_fig: bool = False,
+    ) -> Figure | None:
         """Plot boxplot of cell numbers vs condition of interest.
 
         Args:
@@ -1003,6 +1018,10 @@ class Milo:
             test_var: Name of column in adata.obs storing condition of interest (y-axis for boxplot)
             subset_nhoods: List of obs_names for neighbourhoods to include in plot. If None, plot all nhoods.
             log_counts: Whether to plot log1p of cell counts.
+            {common_plot_args}
+
+        Returns:
+            If `return_fig` is `True`, returns the figure, otherwise `None`.
         """
         try:
             nhood_adata = mdata["milo"].T.copy()
@@ -1031,15 +1050,8 @@ class Milo:
         plt.xticks(rotation=90)
         plt.xlabel(test_var)
 
-        if save:
-            plt.savefig(save, bbox_inches="tight")
-            return None
         if show:
             plt.show()
-            return None
         if return_fig:
             return plt.gcf()
-        if not (show or save):
-            return plt.gca()
-
         return None