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

pertpy/plot/_guide_rna.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
+import warnings
 from typing import TYPE_CHECKING
 
-import numpy as np
-import scanpy as sc
-
 if TYPE_CHECKING:
+    import numpy as np
     from anndata import AnnData
-    from matplotlib.axes import Axes
 
 
 class GuideRnaPlot:
@@ -17,8 +15,8 @@ class GuideRnaPlot:
         layer: str | None = None,
         order_by: np.ndarray | str | None = None,
         key_to_save_order: str = None,
-        **kwds,
-    ) -> list[Axes]:
+        **kwargs,
+    ):
         """Heatmap plotting of guide RNA expression matrix.
 
         Assuming guides have sparse expression, this function reorders cells
@@ -36,7 +34,7 @@ class GuideRnaPlot:
                        If a string is provided, adata.obs[order_by] will be used as the order.
                        If a numpy array is provided, the array will be used for ordering.
              key_to_save_order: The obs key to save cell orders in the current plot. Only saves if not None.
-             kwds: Are passed to sc.pl.heatmap.
+             kwargs: Are passed to sc.pl.heatmap.
 
          Returns:
              List of Axes. Alternatively you can pass save or show parameters as they will be passed to sc.pl.heatmap.
@@ -47,36 +45,20 @@ class GuideRnaPlot:
             visualized using a heatmap.
 
             >>> import pertpy as pt
-            >>> mdata = pt.data.papalexi_2021()
-            >>> gdo = mdata.mod['gdo']
+            >>> mdata = pt.dt.papalexi_2021()
+            >>> gdo = mdata.mod["gdo"]
             >>> ga = pt.pp.GuideAssignment()
             >>> ga.assign_by_threshold(gdo, assignment_threshold=5)
-            >>> pt.pl.guide.heatmap(gdo)
+            >>> ga.plot_heatmap(gdo)
         """
-        data = adata.X if layer is None else adata.layers[layer]
+        warnings.warn(
+            "This function is deprecated and will be removed in pertpy 0.8.0!"
+            " Please use the corresponding 'pt.tl' object",
+            FutureWarning,
+            stacklevel=2,
+        )
 
-        if order_by is None:
-            max_guide_index = np.where(
-                np.array(data.max(axis=1)).squeeze() != data.min(), np.array(data.argmax(axis=1)).squeeze(), -1
-            )
-            order = np.argsort(max_guide_index)
-        elif isinstance(order_by, str):
-            order = adata.obs[order_by]
-        else:
-            order = order_by
+        from pertpy.preprocessing import GuideAssignment
 
-        adata.obs["_tmp_pertpy_grna_plot_dummy_group"] = ""
-        if key_to_save_order is not None:
-            adata.obs[key_to_save_order] = order
-        axis_group = sc.pl.heatmap(
-            adata[order],
-            adata.var.index.tolist(),
-            groupby="_tmp_pertpy_grna_plot_dummy_group",
-            cmap="viridis",
-            use_raw=False,
-            dendrogram=False,
-            layer=layer,
-            **kwds,
-        )
-        del adata.obs["_tmp_pertpy_grna_plot_dummy_group"]
-        return axis_group
+        ga = GuideAssignment()
+        ga.plot_heatmap(adata=adata, layer=layer, order_by=order_by, key_to_save_order=key_to_save_order, kwargs=kwargs)

pertpy/plot/_milopy.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import warnings
 from typing import TYPE_CHECKING
 
 import matplotlib.pyplot as plt
@@ -52,44 +53,29 @@ class MilopyPlot:
             >>> sc.tl.umap(mdata["rna"])
             >>> milo.make_nhoods(mdata["rna"])
             >>> mdata = milo.count_nhoods(mdata, sample_col="orig.ident")
-            >>> milo.da_nhoods(mdata, design="~label")
+            >>> milo.da_nhoods(mdata,
+            >>>            design='~label',
+            >>>            model_contrasts='labelwithdraw_15d_Cocaine-labelwithdraw_48h_Cocaine')
             >>> milo.build_nhood_graph(mdata)
-            >>> pt.pl.milo.nhood_graph(mdata)
-            # TODO: If necessary adjust after fixing StopIteration error, which is currently thrown
+            >>> milo.plot_nhood_graph(mdata)
         """
-        nhood_adata = mdata["milo"].T.copy()
-
-        if "Nhood_size" not in nhood_adata.obs.columns:
-            raise KeyError(
-                'Cannot find "Nhood_size" column in adata.uns["nhood_adata"].obs -- \
-                    please run milopy.utils.build_nhood_graph(adata)'
-            )
-
-        nhood_adata.obs["graph_color"] = nhood_adata.obs["logFC"]
-        nhood_adata.obs.loc[nhood_adata.obs["SpatialFDR"] > alpha, "graph_color"] = np.nan
-        nhood_adata.obs["abs_logFC"] = abs(nhood_adata.obs["logFC"])
-        nhood_adata.obs.loc[nhood_adata.obs["abs_logFC"] < min_logFC, "graph_color"] = np.nan
+        warnings.warn(
+            "This function is deprecated and will be removed in pertpy 0.8.0!"
+            " Please use the corresponding 'pt.tl' object",
+            FutureWarning,
+            stacklevel=2,
+        )
 
-        # Plotting order - extreme logFC on top
-        nhood_adata.obs.loc[nhood_adata.obs["graph_color"].isna(), "abs_logFC"] = np.nan
-        ordered = nhood_adata.obs.sort_values("abs_logFC", na_position="first").index
-        nhood_adata = nhood_adata[ordered]
+        from pertpy.tools import Milo
 
-        vmax = np.max([nhood_adata.obs["graph_color"].max(), abs(nhood_adata.obs["graph_color"].min())])
-        vmin = -vmax
+        milo = Milo()
 
-        sc.pl.embedding(
-            nhood_adata,
-            "X_milo_graph",
-            color="graph_color",
-            cmap="RdBu_r",
-            size=nhood_adata.obs["Nhood_size"] * min_size,
-            edges=plot_edges,
-            neighbors_key="nhood",
-            sort_order=False,
-            frameon=False,
-            vmax=vmax,
-            vmin=vmin,
+        return milo.plot_nhood_graph(
+            madata=mdata,
+            alpha=alpha,
+            min_logFC=min_logFC,
+            min_size=min_size,
+            plot_edges=plot_edges,
             title=title,
             show=show,
             save=save,
@@ -127,12 +113,19 @@ class MilopyPlot:
             >>> milo.make_nhoods(mdata["rna"])
             >>> pt.pl.milo.nhood(mdata, ix=0)
         """
-
-        mdata[feature_key].obs["Nhood"] = mdata[feature_key].obsm["nhoods"][:, ix].toarray().ravel()
-        sc.pl.embedding(
-            mdata[feature_key], basis, color="Nhood", size=30, title="Nhood" + str(ix), show=show, save=save, **kwargs
+        warnings.warn(
+            "This function is deprecated and will be removed in pertpy 0.8.0!"
+            " Please use the corresponding 'pt.tl' object",
+            FutureWarning,
+            stacklevel=2,
         )
 
+        from pertpy.tools import Milo
+
+        milo = Milo()
+
+        milo.plot_nhood(mdata=mdata, ix=ix, feature_key=feature_key, basis=basis, show=show, save=save, **kwargs)
+
     @staticmethod
     def da_beeswarm(
         mdata: MuData,
@@ -146,7 +139,7 @@ class MilopyPlot:
 
         Args:
             mdata: MuData object
-            anno_col: Column in adata.uns['nhood_adata'].obs to use as annotation. (default: 'nhood_annotation'.)
+            anno_col: Column in mdata['milo'].var 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. (default: None)
             palette: Name of Seaborn color palette for violinplots.
@@ -162,84 +155,28 @@ class MilopyPlot:
             >>> milo.make_nhoods(mdata["rna"])
             >>> mdata = milo.count_nhoods(mdata, sample_col="orig.ident")
             >>> milo.da_nhoods(mdata, design="~label")
-            >>> milo.annotate_nhoods(mdata, anno_col='cell_type')
-            >>> pt.pl.milo.da_beeswarm(mdata)
+            >>> milo.annotate_nhoods(mdata, anno_col="cell_type")
+            >>> milo.plot_da_beeswarm(mdata)
         """
-        try:
-            nhood_adata = mdata["milo"].T.copy()
-        except KeyError:
-            raise RuntimeError(
-                "mdata should be a MuData object with two slots: feature_key and 'milo'. Run 'milopy.count_nhoods(adata)' first."
-            ) from None
-
-        if subset_nhoods is not None:
-            nhood_adata = nhood_adata[subset_nhoods]
-
-        try:
-            nhood_adata.obs[anno_col]
-        except KeyError:
-            raise RuntimeError(
-                f"Unable to find {anno_col} in mdata.uns['nhood_adata']. Run 'milopy.utils.annotate_nhoods(adata, anno_col)' first"
-            ) from None
-
-        try:
-            nhood_adata.obs["logFC"]
-        except KeyError:
-            raise RuntimeError(
-                "Unable to find 'logFC' in mdata.uns['nhood_adata'].obs. Run 'core.da_nhoods(adata)' first."
-            ) from None
-
-        sorted_annos = (
-            nhood_adata.obs[[anno_col, "logFC"]].groupby(anno_col).median().sort_values("logFC", ascending=True).index
+        warnings.warn(
+            "This function is deprecated and will be removed in pertpy 0.8.0!"
+            " Please use the corresponding 'pt.tl' object",
+            FutureWarning,
+            stacklevel=2,
         )
 
-        anno_df = nhood_adata.obs[[anno_col, "logFC", "SpatialFDR"]].copy()
-        anno_df["is_signif"] = anno_df["SpatialFDR"] < alpha
-        anno_df = anno_df[anno_df[anno_col] != "nan"]
+        from pertpy.tools import Milo
 
-        try:
-            obs_col = nhood_adata.uns["annotation_obs"]
-            if palette is None:
-                palette = dict(
-                    zip(mdata[feature_key].obs[obs_col].cat.categories, mdata[feature_key].uns[f"{obs_col}_colors"])
-                )
-            sns.violinplot(
-                data=anno_df,
-                y=anno_col,
-                x="logFC",
-                order=sorted_annos,
-                size=190,
-                inner=None,
-                orient="h",
-                palette=palette,
-                linewidth=0,
-                scale="width",
-            )
-        except BaseException:  # noqa: BLE001
-            sns.violinplot(
-                data=anno_df,
-                y=anno_col,
-                x="logFC",
-                order=sorted_annos,
-                size=190,
-                inner=None,
-                orient="h",
-                linewidth=0,
-                scale="width",
-            )
-        sns.stripplot(
-            data=anno_df,
-            y=anno_col,
-            x="logFC",
-            order=sorted_annos,
-            size=2,
-            hue="is_signif",
-            palette=["grey", "black"],
-            orient="h",
-            alpha=0.5,
+        milo = Milo()
+
+        milo.plot_da_beeswarm(
+            mdata=mdata,
+            feature_key=feature_key,
+            anno_col=anno_col,
+            alpha=alpha,
+            subset_nhoods=subset_nhoods,
+            palette=palette,
         )
-        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="--")
 
     @staticmethod
     def nhood_counts_by_cond(
@@ -256,29 +193,17 @@ class MilopyPlot:
             subset_nhoods: List of obs_names for neighbourhoods to include in plot. If None, plot all nhoods. (default: None)
             log_counts: Whether to plot log1p of cell counts. (default: False)
         """
-        try:
-            nhood_adata = mdata["milo"].T.copy()
-        except KeyError:
-            raise RuntimeError(
-                "mdata should be a MuData object with two slots: feature_key and 'milo'. Run milopy.count_nhoods(mdata) first"
-            ) from None
+        warnings.warn(
+            "This function is deprecated and will be removed in pertpy 0.8.0!"
+            " Please use the corresponding 'pt.tl' object",
+            FutureWarning,
+            stacklevel=2,
+        )
 
-        if subset_nhoods is None:
-            subset_nhoods = nhood_adata.obs_names
+        from pertpy.tools import Milo
 
-        pl_df = pd.DataFrame(nhood_adata[subset_nhoods].X.A, columns=nhood_adata.var_names).melt(
-            var_name=nhood_adata.uns["sample_col"], value_name="n_cells"
-        )
-        pl_df = pd.merge(pl_df, nhood_adata.var)
-        pl_df["log_n_cells"] = np.log1p(pl_df["n_cells"])
-        if not log_counts:
-            sns.boxplot(data=pl_df, x=test_var, y="n_cells", color="lightblue")
-            sns.stripplot(data=pl_df, x=test_var, y="n_cells", color="black", s=3)
-            plt.ylabel("# cells")
-        else:
-            sns.boxplot(data=pl_df, x=test_var, y="log_n_cells", color="lightblue")
-            sns.stripplot(data=pl_df, x=test_var, y="log_n_cells", color="black", s=3)
-            plt.ylabel("log(# cells + 1)")
+        milo = Milo()
 
-        plt.xticks(rotation=90)
-        plt.xlabel(test_var)
+        milo.plot_nhood_counts_by_cond(
+            mdata=mdata, test_var=test_var, subset_nhoods=subset_nhoods, log_counts=log_counts
+        )