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

pertpy/metadata/_moa.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import numpy as np
+import pandas as pd
+from scanpy import settings
+
+from pertpy.data._dataloader import _download
+
+from ._look_up import LookUp
+from ._metadata import MetaData
+
+if TYPE_CHECKING:
+    from anndata import AnnData
+
+
+class Moa(MetaData):
+    """Utilities to fetch metadata for mechanism of action studies."""
+
+    def __init__(self):
+        self.clue = None
+
+    def _download_clue(self) -> None:
+        clue_path = Path(settings.cachedir) / "repurposing_drugs_20200324.txt"
+        if not Path(clue_path).exists():
+            _download(
+                url="https://s3.amazonaws.com/data.clue.io/repurposing/downloads/repurposing_drugs_20200324.txt",
+                output_file_name="repurposing_drugs_20200324.txt",
+                output_path=settings.cachedir,
+                block_size=4096,
+                is_zip=False,
+            )
+        self.clue = pd.read_csv(clue_path, sep="	", skiprows=9)
+        self.clue = self.clue[["pert_iname", "moa", "target"]]
+
+    def annotate(
+        self,
+        adata: AnnData,
+        query_id: str = "perturbation",
+        target: str | None = None,
+        verbosity: int | str = 5,
+        copy: bool = False,
+    ) -> AnnData:
+        """Annotate cells affected by perturbations by mechanism of action.
+
+        For each cell, we fetch the mechanism of action and molecular targets of the compounds sourced from clue.io.
+
+        Args:
+            adata: The data object to annotate.
+            query_id: The column of `.obs` with the name of a perturbagen.
+            target: The column of `.obs` with target information. If set to None, all MoAs are retrieved without comparing molecular targets.
+            verbosity: The number of unmatched identifiers to print, can be either non-negative values or 'all'.
+            copy: Determines whether a copy of the `adata` is returned.
+
+        Returns:
+            Returns an AnnData object with MoA annotation.
+        """
+        if copy:
+            adata = adata.copy()
+
+        if query_id not in adata.obs.columns:
+            raise ValueError(f"The requested query_id {query_id} is not in `adata.obs`.\n" "Please check again.")
+
+        if self.clue is None:
+            self._download_clue()
+
+        identifier_num_all = len(adata.obs[query_id].unique())
+        not_matched_identifiers = list(set(adata.obs[query_id].str.lower()) - set(self.clue["pert_iname"].str.lower()))
+        self._warn_unmatch(
+            total_identifiers=identifier_num_all,
+            unmatched_identifiers=not_matched_identifiers,
+            query_id=query_id,
+            reference_id="pert_iname",
+            metadata_type="moa",
+            verbosity=verbosity,
+        )
+
+        adata.obs = (
+            adata.obs.merge(
+                self.clue,
+                left_on=adata.obs[query_id].str.lower(),
+                right_on=self.clue["pert_iname"].str.lower(),
+                how="left",
+                suffixes=("", "_fromMeta"),
+            )
+            .set_index(adata.obs.index)
+            .drop("key_0", axis=1)
+        )
+
+        # If target column is given, check whether it is one of the targets listed in the metadata
+        # If inconsistent, treat this perturbagen as unmatched and overwrite the annotated metadata with NaN
+        if target is not None:
+            target_meta = "target" if target != "target" else "target_fromMeta"
+            adata.obs[target_meta] = adata.obs[target_meta].mask(
+                ~adata.obs.apply(lambda row: str(row[target]) in str(row[target_meta]), axis=1)
+            )
+            pertname_meta = "pert_iname" if query_id != "pert_iname" else "pert_iname_fromMeta"
+            adata.obs.loc[adata.obs[target_meta].isna(), [pertname_meta, "moa"]] = np.nan
+
+        # If query_id and reference_id have different names, there will be a column for each of them after merging
+        # which is redundant as they refer to the same information.
+        if query_id != "pert_iname":
+            del adata.obs["pert_iname"]
+
+        return adata
+
+    def lookup(self) -> LookUp:
+        """Generate LookUp object for Moa metadata.
+
+        The LookUp object provides an overview of the metadata to annotate.
+        annotate_moa function has a corresponding lookup function in the LookUp object,
+        where users can search the query_ids and targets in the metadata.
+
+        Returns:
+            Returns a LookUp object specific for MoA annotation.
+        """
+        if self.clue is None:
+            self._download_clue()
+
+        return LookUp(
+            type="moa",
+            transfer_metadata=[self.clue],
+        )

pertpy/plot/__init__.py

@@ -1,13 +0,0 @@
-from pertpy.plot._augur import AugurpyPlot as ag
-from pertpy.plot._dialogue import DialoguePlot as dl
-
-try:
-    from pertpy.plot._coda import CodaPlot as coda
-except ImportError:
-    pass
-
-from pertpy.plot._cinemaot import CinemaotPlot as cot
-from pertpy.plot._guide_rna import GuideRnaPlot as guide
-from pertpy.plot._milopy import MilopyPlot as milo
-from pertpy.plot._mixscape import MixscapePlot as ms
-from pertpy.plot._scgen import JaxscgenPlot as scg

pertpy/preprocessing/__init__.py

@@ -1 +1,3 @@
 from ._guide_rna import GuideAssignment
+
+__all__ = ["GuideAssignment"]

pertpy/preprocessing/_guide_rna.py

@@ -1,12 +1,16 @@
 from __future__ import annotations
 
+import uuid
 from typing import TYPE_CHECKING
 
 import numpy as np
+import pandas as pd
+import scanpy as sc
 import scipy
 
 if TYPE_CHECKING:
     from anndata import AnnData
+    from matplotlib.axes import Axes
 
 
 class GuideAssignment:
@@ -30,16 +34,15 @@ class GuideAssignment:
             assignment_threshold: The count threshold that is required for an assignment to be viable.
             layer: Key to the layer containing raw count values of the gRNAs.
                    adata.X is used if layer is None. Expects count data.
-            output_layer: Assigned guide will be saved on adata.layers[output_key]. Defaults to `assigned_guides`.
+            output_layer: Assigned guide will be saved on adata.layers[output_key].
             only_return_results: If True, input AnnData is not modified and the result is returned as an np.ndarray.
-                                 Defaults to False.
 
         Examples:
             Each cell is assigned to gRNA that occurs at least 5 times in the respective cell.
 
             >>> import pertpy as pt
             >>> mdata = pt.data.papalexi_2021()
-            >>> gdo = mdata.mod['gdo']
+            >>> gdo = mdata.mod["gdo"]
             >>> ga = pt.pp.GuideAssignment()
             >>> ga.assign_by_threshold(gdo, assignment_threshold=5)
         """
@@ -71,7 +74,6 @@ class GuideAssignment:
 
         Args:
             adata: Annotated data matrix containing gRNA values
-                   assignment_threshold: If a gRNA is available for at least `assignment_threshold`, it will be recognized as assigned.
             assignment_threshold: The count threshold that is required for an assignment to be viable.
             layer: Key to the layer containing raw count values of the gRNAs.
                    adata.X is used if layer is None. Expects count data.
@@ -83,8 +85,8 @@ class GuideAssignment:
             Each cell is assigned to the most expressed gRNA if it has at least 5 counts.
 
             >>> 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_to_max_guide(gdo, assignment_threshold=5)
         """
@@ -103,3 +105,84 @@ class GuideAssignment:
         adata.obs[output_key] = assigned_grna
 
         return None
+
+    def plot_heatmap(
+        self,
+        adata: AnnData,
+        layer: str | None = None,
+        order_by: np.ndarray | str | None = None,
+        key_to_save_order: str = None,
+        **kwargs,
+    ) -> list[Axes]:
+        """Heatmap plotting of guide RNA expression matrix.
+
+        Assuming guides have sparse expression, this function reorders cells
+        and plots guide RNA expression so that a nice sparse representation is achieved.
+        The cell ordering can be stored and reused in future plots to obtain consistent
+        plots before and after analysis of the guide RNA expression.
+        Note: This function expects a log-normalized or binary data.
+
+        Args:
+            adata: Annotated data matrix containing gRNA values
+            layer: Key to the layer containing log normalized count values of the gRNAs.
+                   adata.X is used if layer is None.
+            order_by: The order of cells in y axis.
+                      If None, cells will be reordered to have a nice sparse representation.
+                      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.
+            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.
+            Order of cells in the y-axis will be saved on adata.obs[key_to_save_order] if provided.
+
+        Examples:
+            Each cell is assigned to gRNA that occurs at least 5 times in the respective cell, which is then
+            visualized using a heatmap.
+
+            >>> import pertpy as pt
+            >>> mdata = pt.dt.papalexi_2021()
+            >>> gdo = mdata.mod["gdo"]
+            >>> ga = pt.pp.GuideAssignment()
+            >>> ga.assign_by_threshold(gdo, assignment_threshold=5)
+            >>> ga.plot_heatmap(gdo)
+        """
+        data = adata.X if layer is None else adata.layers[layer]
+
+        if order_by is None:
+            if scipy.sparse.issparse(data):
+                max_values = data.max(axis=1).A.squeeze()
+                data_argmax = data.argmax(axis=1).A.squeeze()
+                max_guide_index = np.where(max_values != data.min(axis=1).A.squeeze(), data_argmax, -1)
+            else:
+                max_guide_index = np.where(
+                    data.max(axis=1).squeeze() != data.min(axis=1).squeeze(), data.argmax(axis=1).squeeze(), -1
+                )
+            order = np.argsort(max_guide_index)
+        elif isinstance(order_by, str):
+            order = np.argsort(adata.obs[order_by])
+        else:
+            order = order_by
+
+        temp_col_name = f"_tmp_pertpy_grna_plot_{uuid.uuid4()}"
+        adata.obs[temp_col_name] = pd.Categorical(["" for _ in range(adata.shape[0])])
+
+        if key_to_save_order is not None:
+            adata.obs[key_to_save_order] = pd.Categorical(order)
+
+        try:
+            axis_group = sc.pl.heatmap(
+                adata[order, :],
+                var_names=adata.var.index.tolist(),
+                groupby=temp_col_name,
+                cmap="viridis",
+                use_raw=False,
+                dendrogram=False,
+                layer=layer,
+                **kwargs,
+            )
+        finally:
+            del adata.obs[temp_col_name]
+
+        return axis_group

pertpy/tools/__init__.py

@@ -1,24 +1,57 @@
-from rich import print
-
 from pertpy.tools._augur import Augur
 from pertpy.tools._cinemaot import Cinemaot
+from pertpy.tools._coda._sccoda import Sccoda
+from pertpy.tools._coda._tasccoda import Tasccoda
 from pertpy.tools._dialogue import Dialogue
-from pertpy.tools._differential_gene_expression import DifferentialGeneExpression
+from pertpy.tools._differential_gene_expression import (
+    DGEEVAL,
+    EdgeR,
+    PyDESeq2,
+    Statsmodels,
+    TTest,
+    WilcoxonTest,
+)
 from pertpy.tools._distances._distance_tests import DistanceTest
 from pertpy.tools._distances._distances import Distance
-from pertpy.tools._metadata._cell_line import CellLineMetaData
+from pertpy.tools._enrichment import Enrichment
 from pertpy.tools._milo import Milo
 from pertpy.tools._mixscape import Mixscape
 from pertpy.tools._perturbation_space._clustering import ClusteringSpace
-from pertpy.tools._perturbation_space._discriminator_classifier import DiscriminatorClassifierSpace
-from pertpy.tools._perturbation_space._simple import CentroidSpace, DBSCANSpace, KMeansSpace, PseudobulkSpace
-from pertpy.tools._scgen import SCGEN
+from pertpy.tools._perturbation_space._comparison import PerturbationComparison
+from pertpy.tools._perturbation_space._discriminator_classifiers import (
+    LRClassifierSpace,
+    MLPClassifierSpace,
+)
+from pertpy.tools._perturbation_space._simple import (
+    CentroidSpace,
+    DBSCANSpace,
+    KMeansSpace,
+    PseudobulkSpace,
+)
+from pertpy.tools._scgen import Scgen
 
-try:
-    from pertpy.tools._coda._sccoda import Sccoda
-    from pertpy.tools._coda._tasccoda import Tasccoda
-except ImportError as e:
-    if "ete3" in str(e):
-        print("[bold yellow]To use sccoda or tasccoda please install ete3 with [green]pip install ete3")
-    else:
-        raise e
+__all__ = [
+    "Augur",
+    "Cinemaot",
+    "Sccoda",
+    "Tasccoda",
+    "Dialogue",
+    "EdgeR",
+    "PyDESeq2",
+    "WilcoxonTest",
+    "TTest",
+    "Statsmodels",
+    "DistanceTest",
+    "Distance",
+    "Enrichment",
+    "Milo",
+    "Mixscape",
+    "ClusteringSpace",
+    "LRClassifierSpace",
+    "MLPClassifierSpace",
+    "CentroidSpace",
+    "DBSCANSpace",
+    "KMeansSpace",
+    "PseudobulkSpace",
+    "Scgen",
+]