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

pertpy/metadata/_compound.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+import pandas as pd
+import pubchempy as pcp
+
+from ._look_up import LookUp
+from ._metadata import MetaData
+
+if TYPE_CHECKING:
+    from anndata import AnnData
+
+
+class Compound(MetaData):
+    """Utilities to fetch metadata for compounds."""
+
+    def __init__(self):
+        super().__init__()
+
+    def annotate_compounds(
+        self,
+        adata: AnnData,
+        query_id: str = "perturbation",
+        query_id_type: Literal["name", "cid"] = "name",
+        verbosity: int | str = 5,
+        copy: bool = False,
+    ) -> AnnData:
+        """Fetch compound annotation from pubchempy.
+
+        Args:
+            adata: The data object to annotate.
+            query_id: The column of `.obs` with compound identifiers. Defaults to 'perturbation'.
+            query_id_type: The type of compound identifiers, 'name' or 'cid'. Defaults to 'name'.
+            verbosity: The number of unmatched identifiers to print, can be either non-negative values or "all".
+                       Defaults to 5.
+            copy: Determines whether a copy of the `adata` is returned. Defaults to False.
+
+        Returns:
+            Returns an AnnData object with compound 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" f"Please check again. ")
+
+        query_dict = {}
+        not_matched_identifiers = []
+        for compound in adata.obs[query_id].dropna().astype(str).unique():
+            if query_id_type == "name":
+                cids = pcp.get_compounds(compound, "name")
+                if len(cids) == 0:  # search did not work
+                    not_matched_identifiers.append(compound)
+                if len(cids) >= 1:
+                    # If the name matches the first synonym offered by PubChem (outside of capitalization),
+                    # it is not changed (outside of capitalization). Otherwise, it is replaced with the first synonym.
+                    query_dict[compound] = [
+                        cids[0].synonyms[0],
+                        cids[0].cid,
+                        cids[0].canonical_smiles,
+                    ]
+            else:
+                try:
+                    cid = pcp.Compound.from_cid(compound)
+                    query_dict[compound] = [
+                        cid.synonyms[0],
+                        compound,
+                        cid.canonical_smiles,
+                    ]
+                except pcp.BadRequestError:
+                    # pubchempy throws badrequest if a cid is not found
+                    not_matched_identifiers.append(compound)
+
+        identifier_num_all = len(adata.obs[query_id].unique())
+        self._warn_unmatch(
+            total_identifiers=identifier_num_all,
+            unmatched_identifiers=not_matched_identifiers,
+            query_id=query_id,
+            reference_id=query_id_type,
+            metadata_type="compound",
+            verbosity=verbosity,
+        )
+
+        query_df = pd.DataFrame.from_dict(query_dict, orient="index", columns=["pubchem_name", "pubchem_ID", "smiles"])
+        # Merge and remove duplicate columns
+        # Column is converted to float after merging due to unmatches
+        # Convert back to integers
+        if query_id_type == "cid":
+            query_df.pubchem_ID = query_df.pubchem_ID.astype("Int64")
+            adata.obs = (
+                adata.obs.merge(
+                    query_df,
+                    left_on=query_id,
+                    right_on="pubchem_ID",
+                    how="left",
+                    suffixes=("", "_fromMeta"),
+                )
+                .filter(regex="^(?!.*_fromMeta)")
+                .set_index(adata.obs.index)
+            )
+        else:
+            adata.obs = (
+                adata.obs.merge(
+                    query_df,
+                    left_on=query_id,
+                    right_index=True,
+                    how="left",
+                    suffixes=("", "_fromMeta"),
+                )
+                .filter(regex="^(?!.*_fromMeta)")
+                .set_index(adata.obs.index)
+            )
+            adata.obs.pubchem_ID = adata.obs.pubchem_ID.astype("Int64")
+
+        return adata
+
+    def lookup(self) -> LookUp:
+        """Generate LookUp object for CompoundMetaData.
+
+        The LookUp object provides an overview of the metadata to annotate.
+        Each annotate_{metadata} function has a corresponding lookup function in the LookUp object,
+        where users can search the reference_id in the metadata and
+        compare with the query_id in their own data.
+
+        Returns:
+            Returns a LookUp object specific for compound annotation.
+        """
+        return LookUp(type="compound")

pertpy/metadata/_drug.py

@@ -0,0 +1,242 @@
+from __future__ import annotations
+
+import json
+from collections import ChainMap
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal
+
+import pandas as pd
+from rich import print
+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
+
+
+def _download_drug_annotation(
+    source: Literal["chembl", "dgidb", "pharmgkb"] = "chembl",
+) -> pd.DataFrame | dict[str, dict[str, list[str]]]:
+    if source == "chembl":
+        # Prepared in https://github.com/theislab/pertpy-datasets/blob/main/chembl_data.ipynb
+        chembl_path = Path(settings.cachedir) / "chembl.json"
+        if not Path(chembl_path).exists():
+            print("[bold yellow]No metadata file was found for chembl. Starting download now.")
+            _download(
+                url="https://figshare.com/ndownloader/files/43871718",
+                output_file_name="chembl.json",
+                output_path=settings.cachedir,
+                block_size=4096,
+                is_zip=False,
+            )
+        with chembl_path.open() as file:
+            chembl_json = json.load(file)
+        return chembl_json
+
+    elif source == "dgidb":
+        dgidb_path = Path(settings.cachedir) / "dgidb.tsv"
+        if not Path(dgidb_path).exists():
+            print("[bold yellow]No metadata file was found for dgidb. Starting download now.")
+            _download(
+                url="https://www.dgidb.org/data/latest/interactions.tsv",
+                output_file_name="dgidb.tsv",
+                output_path=settings.cachedir,
+                block_size=4096,
+                is_zip=False,
+            )
+        dgidb_df = pd.read_table(dgidb_path)
+        return dgidb_df
+
+    else:
+        pharmgkb_path = Path(settings.cachedir) / "pharmgkb.tsv"
+        if not Path(pharmgkb_path).exists():
+            print("[bold yellow]No metadata file was found for pharmGKB. Starting download now.")
+            _download(
+                url="https://api.pharmgkb.org/v1/download/file/data/relationships.zip",
+                output_file_name="pharmgkb.zip",
+                output_path=settings.cachedir,
+                block_size=4096,
+                is_zip=True,
+            )
+            Path.rename(Path(settings.cachedir) / "relationships.tsv", pharmgkb_path)
+
+        pharmgkb_df = pd.read_table(pharmgkb_path)
+        pharmgkb_df = pharmgkb_df[pharmgkb_df["Association"] != "not associated"]
+        pharmgkb_df = pharmgkb_df[
+            (pharmgkb_df["Entity1_type"] == "Gene")
+            & ((pharmgkb_df["Entity2_type"] == "Chemical") | (pharmgkb_df["Entity2_type"] == "Disease"))
+        ]
+        pharmgkb_df.rename(
+            columns={
+                "Entity2_name": "Compound|Disease",
+                "Entity1_name": "Gene",
+                "Entity2_type": "Type",
+            },
+            inplace=True,
+        )
+        pharmgkb_df.drop(["Entity1_type", "Entity1_id", "Entity2_id"], axis=1, inplace=True)
+
+        return pharmgkb_df
+
+
+class Drug(MetaData):
+    """Utilities to fetch metadata for drug studies."""
+
+    def __init__(self):
+        self.chembl = self.DrugDataBase(database="chembl")
+        self.dgidb = self.DrugDataBase(database="dgidb")
+        self.pharmgkb = self.DrugDataBase(database="pharmgkb")
+
+    def annotate(
+        self,
+        adata: AnnData,
+        source: Literal["chembl", "dgidb", "pharmgkb"] = "chembl",
+        copy: bool = False,
+    ) -> AnnData:
+        """Annotates genes by their involvement in applied drugs.
+
+        Genes need to be in HGNC format.
+
+        Args:
+            adata: AnnData object containing log-normalised data.
+            source: Source of the metadata, chembl, dgidb or pharmgkb. Defaults to chembl.
+            copy: Determines whether a copy of the `adata` is returned. Defaults to False.
+
+        Returns:
+            An AnnData object with a new column `drug` in the var slot.
+        """
+        if copy:
+            adata = adata.copy()
+
+        if source == "chembl":
+            if not self.chembl.loaded:
+                self.chembl.set()
+            interaction = self.chembl.dataframe
+        elif source == "dgidb":
+            if not self.dgidb.loaded:
+                self.dgidb.set()
+            interaction = self.dgidb.dataframe
+        else:
+            if not self.pharmgkb.loaded:
+                self.pharmgkb.set()
+            interaction = self.pharmgkb.data
+
+        if source != "pharmgkb":
+            exploded_df = interaction.explode("targets")
+            gene_compound_dict = (
+                exploded_df.groupby("targets")["compounds"]
+                .apply(lambda compounds: "|".join(sorted(set(compounds))))
+                .to_dict()
+            )
+
+            adata.var["compounds"] = adata.var_names.map(lambda gene: gene_compound_dict.get(gene, ""))
+        else:
+            compounds = interaction[interaction["Type"] == "Chemical"]
+            exploded_df = compounds.explode("Gene")
+            gene_compound_dict = (
+                exploded_df.groupby("Gene")["Compound|Disease"]
+                .apply(lambda compounds: "|".join(sorted(set(compounds))))
+                .to_dict()
+            )
+
+            adata.var["compounds"] = adata.var_names.map(lambda gene: gene_compound_dict.get(gene, ""))
+            diseases = interaction[interaction["Type"] == "Disease"]
+            exploded_df = diseases.explode("Gene")
+            gene_disease_dict = (
+                exploded_df.groupby("Gene")["Compound|Disease"]
+                .apply(lambda diseases: "|".join(sorted(set(diseases))))
+                .to_dict()
+            )
+
+            adata.var["diseases"] = adata.var_names.map(lambda gene: gene_disease_dict.get(gene, ""))
+        return adata
+
+    def lookup(self) -> LookUp:
+        """Generate LookUp object for Drug.
+
+        The LookUp object provides an overview of the metadata to annotate.
+        annotate function has a corresponding lookup function in the LookUp object,
+        where users can search the compound and targets in the metadata.
+
+        Returns:
+            Returns a LookUp object specific for drug annotation.
+        """
+        if not self.chembl.loaded:
+            self.chembl.set()
+        if not self.dgidb.loaded:
+            self.dgidb.set()
+        if not self.pharmgkb.loaded:
+            self.pharmgkb.set()
+
+        return LookUp(
+            type="drug",
+            transfer_metadata=[
+                self.chembl.dataframe,
+                self.dgidb.data,
+                self.pharmgkb.data,
+            ],
+        )
+
+    class DrugDataBase:
+        def __init__(self, database: Literal["chembl", "dgidb", "pharmgkb"] = "chembl"):
+            self.database = database
+            self.loaded = False
+
+        def set(self) -> None:
+            self.loaded = True
+            data = _download_drug_annotation(source=self.database)
+            self.data = data
+            if self.database == "chembl":
+                if not isinstance(data, dict):
+                    raise ValueError(
+                        "The chembl data is in a wrong format. Please clear the cache and reinitialize the object."
+                    )
+                self.dictionary = data
+                targets = dict(ChainMap(*[data[cat] for cat in data]))
+                self.dataframe = pd.DataFrame([{"Compound": k, "Targets": v} for k, v in targets.items()])
+                self.dataframe.rename(
+                    columns={"Targets": "targets", "Compound": "compounds"},
+                    inplace=True,
+                )
+            elif self.database == "dgidb":
+                if not isinstance(data, pd.DataFrame):
+                    raise ValueError(
+                        "The dgidb data is in a wrong format. Please clear the cache and reinitialize the object."
+                    )
+                self.dataframe = data.groupby("drug_claim_name")["gene_claim_name"].apply(list).reset_index()
+                self.dataframe.rename(
+                    columns={
+                        "gene_claim_name": "targets",
+                        "drug_claim_name": "compounds",
+                    },
+                    inplace=True,
+                )
+                self.dictionary = self.dataframe.set_index("compounds")["targets"].to_dict()
+            else:
+                if not isinstance(data, pd.DataFrame):
+                    raise ValueError(
+                        "The pharmGKB data is in a wrong format. Please clear the cache and reinitialize the object."
+                    )
+                self.dataframe = data.groupby("Compound|Disease")["Gene"].apply(list).reset_index()
+                self.dataframe.rename(
+                    columns={
+                        "Gene": "targets",
+                        "Compound|Disease": "compounds|diseases",
+                    },
+                    inplace=True,
+                )
+                self.dictionary = self.dataframe.set_index("compounds|diseases")["targets"].to_dict()
+
+        def df(self) -> pd.DataFrame:
+            if not self.loaded:
+                self.set()
+            return self.dataframe
+
+        def dict(self) -> dict[str, list[str]] | dict[str, dict[str, list[str]]]:
+            if not self.loaded:
+                self.set()
+            return self.dictionary