pyobo 0.11.2__py3-none-any.whl → 0.12.0__py3-none-any.whl

pyobo/sources/biogrid.py

@@ -2,7 +2,6 @@
 
 from collections.abc import Mapping
 from functools import partial
-from typing import Optional
 
 import pandas as pd
 
@@ -43,7 +42,7 @@ taxonomy_remapping = {  # so much for official names
 }
 
 
-def _lookup(name: str) -> Optional[str]:
+def _lookup(name: str) -> str | None:
     if name in taxonomy_remapping:
         return taxonomy_remapping[name]
     return get_ncbitaxon_id(name)

pyobo/sources/ccle.py

@@ -3,7 +3,6 @@
 import tarfile
 from collections.abc import Iterable
 from pathlib import Path
-from typing import Optional
 
 import pandas as pd
 import pystow
@@ -11,7 +10,6 @@ import pystow
 from pyobo import Obo, Reference, Term
 
 __all__ = [
-    "get_obo",
     "CCLEGetter",
 ]
 
@@ -23,21 +21,18 @@ class CCLEGetter(Obo):
     """An ontology representation of the Cancer Cell Line Encyclopedia's cell lines."""
 
     ontology = bioregistry_key = PREFIX
+    name = "Cancer Cell Line Encyclopedia Cell Line"
 
     def __post_init__(self):
         self.data_version = VERSION
+        super().__post_init__()
 
     def iter_terms(self, force: bool = False) -> Iterable[Term]:
         """Iterate over terms in the ontology."""
         return iter_terms(version=self._version_or_raise, force=force)
 
 
-def get_obo(*, force: bool = False) -> Obo:
-    """Get CCLE Cells as OBO."""
-    return CCLEGetter(force=force)
-
-
-def iter_terms(version: Optional[str] = None, force: bool = False) -> Iterable[Term]:
+def iter_terms(version: str | None = None, force: bool = False) -> Iterable[Term]:
     """Iterate over CCLE Cells."""
     df = ensure_df(version=version, force=force)
     for identifier, depmap_id, name in df.values:
@@ -54,21 +49,21 @@ def get_ccle_static_version() -> str:
     return "2019"
 
 
-def get_url(version: Optional[str] = None) -> str:
+def get_url(version: str | None = None) -> str:
     """Get the cBioPortal URL for the given version of CCLE's cell lines."""
     if version is None:
         version = get_ccle_static_version()
     return f"https://cbioportal-datahub.s3.amazonaws.com/ccle_broad_{version}.tar.gz"
 
 
-def get_inner(version: Optional[str] = None) -> str:
+def get_inner(version: str | None = None) -> str:
     """Get the inner tarfile path."""
     if version is None:
         version = get_ccle_static_version()
     return f"ccle_broad_{version}/data_clinical_sample.txt"
 
 
-def ensure(version: Optional[str] = None, **kwargs) -> Path:
+def ensure(version: str | None = None, **kwargs) -> Path:
     """Ensure the given version is downloaded."""
     if version is None:
         version = get_ccle_static_version()
@@ -76,7 +71,7 @@ def ensure(version: Optional[str] = None, **kwargs) -> Path:
     return pystow.ensure("pyobo", "raw", PREFIX, version, url=url, **kwargs)
 
 
-def ensure_df(version: Optional[str] = None, force: bool = False) -> pd.DataFrame:
+def ensure_df(version: str | None = None, force: bool = False) -> pd.DataFrame:
     """Get the CCLE clinical sample dataframe."""
     if version is None:
         version = get_ccle_static_version()

pyobo/sources/cgnc.py

@@ -31,11 +31,6 @@ class CGNCGetter(Obo):
         return get_terms(force=force)
 
 
-def get_obo(force: bool = False) -> Obo:
-    """Get CGNC as OBO."""
-    return CGNCGetter(force=force)
-
-
 HEADER = [
     "cgnc_id",
     "ncbigene_id",

pyobo/sources/chebi.py

@@ -7,9 +7,9 @@ from ..struct import Reference, TypeDef
 from ..utils.io import multisetdict
 
 __all__ = [
-    "get_chebi_smiles_id_mapping",
     "get_chebi_id_smiles_mapping",
     "get_chebi_role_to_children",
+    "get_chebi_smiles_id_mapping",
 ]
 
 

pyobo/sources/chembl/__init__.py

@@ -0,0 +1,9 @@
+"""Resources from ChEMBL."""
+
+from .chembl_compound import ChEMBLCompoundGetter
+from .chembl_target import ChEMBLTargetGetter
+
+__all__ = [
+    "ChEMBLCompoundGetter",
+    "ChEMBLTargetGetter",
+]

pyobo/sources/{chembl.py → chembl/chembl_compound.py}

@@ -1,11 +1,7 @@
-"""Converter for ChEMBL.
-
-Run with ``python -m pyobo.sources.chembl -vv``.
-"""
+"""Converter for ChEMBL Compounds."""
 
 import logging
 from collections.abc import Iterable
-from contextlib import closing
 
 import chembl_downloader
 
@@ -50,28 +46,20 @@ class ChEMBLCompoundGetter(Obo):
         return iter_terms(version=self._version_or_raise)
 
 
-def get_obo(force: bool = False) -> Obo:
-    """Return ChEMBL Compounds as OBO."""
-    return ChEMBLCompoundGetter(force=force)
-
-
 def iter_terms(version: str) -> Iterable[Term]:
     """Iterate over ChEMBL compounds."""
-    with chembl_downloader.connect(version=version) as conn:
-        logger.info("using connection %s", conn)
-        with closing(conn.cursor()) as cursor:
-            logger.info("using cursor %s", cursor)
-            cursor.execute(QUERY)
-            for chembl_id, name, smiles, inchi, inchi_key in cursor.fetchall():
-                # TODO add xrefs?
-                term = Term.from_triple(prefix=PREFIX, identifier=chembl_id, name=name)
-                if smiles:
-                    term.append_property(has_smiles, smiles)
-                if inchi:
-                    term.append_property(has_inchi, inchi)
-                if inchi_key:
-                    term.append_exact_match(Reference(prefix="inchikey", identifier=inchi_key))
-                yield term
+    with chembl_downloader.cursor(version=version) as cursor:
+        cursor.execute(QUERY)
+        for chembl_id, name, smiles, inchi, inchi_key in cursor.fetchall():
+            # TODO add xrefs?
+            term = Term.from_triple(prefix=PREFIX, identifier=chembl_id, name=name)
+            if smiles:
+                term.annotate_string(has_smiles, smiles)
+            if inchi:
+                term.annotate_string(has_inchi, inchi)
+            if inchi_key:
+                term.append_exact_match(Reference(prefix="inchikey", identifier=inchi_key))
+            yield term
 
 
 if __name__ == "__main__":

pyobo/sources/chembl/chembl_target.py

@@ -0,0 +1,160 @@
+"""Converter for ChEMBL targets."""
+
+import logging
+from collections import defaultdict
+from collections.abc import Iterable
+
+import chembl_downloader
+from tqdm import tqdm
+
+from pyobo import default_reference
+from pyobo.struct import Obo, Reference, Term
+from pyobo.struct.typedef import (
+    exact_match,
+    has_component,
+    has_member,
+    has_participant,
+)
+
+__all__ = [
+    "ChEMBLTargetGetter",
+]
+
+from pyobo.utils.path import ensure_df
+
+logger = logging.getLogger(__name__)
+
+PREFIX = "chembl.target"
+
+TTYPE_QUERY = """\
+SELECT TARGET_TYPE, TARGET_DESC, PARENT_TYPE
+FROM TARGET_TYPE
+"""
+
+QUERY = """\
+SELECT
+    CHEMBL_ID,
+    PREF_NAME,
+    TARGET_TYPE,
+    TAX_ID
+FROM TARGET_DICTIONARY
+"""
+
+
+class ChEMBLTargetGetter(Obo):
+    """An ontology representation of ChEMBL targets."""
+
+    ontology = PREFIX
+    bioversions_key = "chembl"
+    typedefs = [exact_match, has_component, has_member, has_participant]
+    root_terms = [
+        default_reference(PREFIX, "undefined"),
+        default_reference(PREFIX, "molecular"),
+        default_reference(PREFIX, "non-molecular"),
+    ]
+
+    def iter_terms(self, force: bool = False) -> Iterable[Term]:
+        """Iterate over terms in the ontology."""
+        return iter_terms(version=self._version_or_raise)
+
+
+def iter_terms(version: str) -> Iterable[Term]:
+    """Iterate over ChEMBL targets."""
+    chembl_to_uniprots = get_chembl_protein_equivalences(version=version)
+    target_types: dict[str, Term] = {}
+    parents: dict[str, str] = {}
+    with chembl_downloader.cursor(version=version) as cursor:
+        cursor.execute(TTYPE_QUERY)
+        for target_type, desc, parent in cursor.fetchall():
+            identifier = target_type.lower().replace(" ", "-")
+            target_types[target_type] = Term(
+                reference=default_reference(PREFIX, identifier, name=target_type),
+                definition=desc,
+            )
+            if parent:
+                parents[target_type] = parent
+
+        for child, parent in parents.items():
+            target_types[child].append_parent(target_types[parent])
+
+        yield from target_types.values()
+
+    with chembl_downloader.cursor(version=version) as cursor:
+        cursor.execute(QUERY)
+        for chembl_id, name, target_type, ncbitaxon_id in cursor.fetchall():
+            term = Term.from_triple(prefix=PREFIX, identifier=chembl_id, name=name)
+            if ncbitaxon_id:
+                term.set_species(str(ncbitaxon_id))
+            term.append_parent(target_types[target_type])
+
+            uniprot_ids = chembl_to_uniprots.get(chembl_id)
+            if uniprot_ids is None:
+                pass
+            elif target_type in {
+                "PROTEIN COMPLEX",
+                "CHIMERIC PROTEIN",
+                "PROTEIN COMPLEX GROUP",
+                "PROTEIN NUCLEIC-ACID COMPLEX",
+                "SELECTIVITY GROUP",
+            }:
+                for uniprot_id in uniprot_ids:
+                    term.annotate_object(
+                        has_component, Reference(prefix="uniprot", identifier=uniprot_id)
+                    )
+            elif target_type == "PROTEIN FAMILY":
+                for uniprot_id in uniprot_ids:
+                    term.annotate_object(
+                        has_member, Reference(prefix="uniprot", identifier=uniprot_id)
+                    )
+            elif target_type == "PROTEIN-PROTEIN INTERACTION":
+                for uniprot_id in uniprot_ids:
+                    term.annotate_object(
+                        has_participant, Reference(prefix="uniprot", identifier=uniprot_id)
+                    )
+            elif target_type == "SINGLE PROTEIN":
+                if len(uniprot_ids) == 1:
+                    term.append_exact_match(Reference(prefix="uniprot", identifier=uniprot_ids[0]))
+                else:
+                    tqdm.write(
+                        f"[chembl.target:{chembl_id}] multiple mappings found to single protein: {uniprot_ids}"
+                    )
+                    for uniprot_id in uniprot_ids:
+                        term.append_xref(Reference(prefix="uniprot", identifier=uniprot_id))
+            elif len(uniprot_ids) == 1:
+                luid = uniprot_ids[0]
+                if luid.startswith("ENSG"):
+                    reference = Reference(prefix="ensembl", identifier=luid)
+                else:
+                    reference = Reference(prefix="uniprot", identifier=luid)
+                term.append_exact_match(reference)
+            else:
+                tqdm.write(
+                    f"[chembl.target:{chembl_id}] need to handle multiple uniprots for {target_type} - {uniprot_ids}"
+                )
+
+            yield term
+
+
+def get_chembl_protein_equivalences(version: str | None = None) -> dict[str, list[str]]:
+    """Get ChEMBL protein equivalences."""
+    if version is None:
+        version = chembl_downloader.latest()
+    url = f"ftp://ftp.ebi.ac.uk/pub/databases/chembl/ChEMBLdb/releases/chembl_{version}/chembl_uniprot_mapping.txt"
+    df = ensure_df(
+        PREFIX,
+        url=url,
+        sep="\t",
+        skiprows=1,
+        usecols=[0, 1],
+        names=["uniprot", "chembl"],
+        header=None,
+        # names=[TARGET_ID, SOURCE_ID],  # switch around
+    )
+    dd = defaultdict(list)
+    for uniprot, chembl in df.values:
+        dd[chembl].append(uniprot)
+    return dict(dd)
+
+
+if __name__ == "__main__":
+    ChEMBLTargetGetter.cli()

pyobo/sources/civic_gene.py

@@ -1,11 +1,12 @@
 """Converter for CiVIC Genes."""
 
+import datetime
 from collections.abc import Iterable
-from typing import Optional
 
 import pandas as pd
 
-from pyobo.struct import Obo, Reference, Term
+from pyobo import default_reference
+from pyobo.struct import Obo, Reference, Term, TypeDef
 from pyobo.utils.path import ensure_df
 
 __all__ = [
@@ -15,38 +16,77 @@ __all__ = [
 PREFIX = "civic.gid"
 URL = "https://civicdb.org/downloads/nightly/nightly-GeneSummaries.tsv"
 
+GENE = Term(reference=default_reference(PREFIX, "gene", name="gene"))
+FACTOR = Term(reference=default_reference(PREFIX, "factor", name="factor"))
+FUSION = Term(reference=default_reference(PREFIX, "fusion", name="fusion"))
+HAS_3P = TypeDef.default(PREFIX, "has3p", name="has 3' gene", is_metadata_tag=False)
+HAS_5P = TypeDef.default(PREFIX, "has5p", name="has 5' gene", is_metadata_tag=False)
 
-def _sort(_o, t):
-    return int(t.identifier)
+TYPES = {"Gene": GENE, "Factor": FACTOR, "Fusion": FUSION}
 
 
 class CIVICGeneGetter(Obo):
     """An ontology representation of CiVIC's gene nomenclature."""
 
     bioversions_key = ontology = PREFIX
-    term_sort_key = _sort
+    typedefs = [HAS_3P, HAS_5P]
+    root_terms = [GENE.reference, FACTOR.reference, FUSION.reference]
 
     def iter_terms(self, force: bool = False) -> Iterable[Term]:
         """Iterate over gene terms for CiVIC."""
-        yield from get_terms(self.data_version, force=force)
+        yield from (GENE, FACTOR, FUSION)
+        yield from get_terms(self._version_or_raise, force=force)
 
 
-def get_terms(version: Optional[str] = None, force: bool = False) -> Iterable[Term]:
+def get_terms(version: str, force: bool = False) -> Iterable[Term]:
     """Get CIVIC terms."""
-    # if version is not None:
-    #     version_dt: datetime.date = dateutil.parser.parse(version)
-    # else:
-    #     version_dt: datetime.date = datetime.today()
-    # version = version_dt.strftime("01-%b-%Y")
+    dt = datetime.datetime.strptime(version, "%Y-%m-%d")
     # version is like 01-Feb-2024
-    url = f"https://civicdb.org/downloads/{version}/{version}-GeneSummaries.tsv"
+    dt2 = datetime.datetime.strftime(dt, "%d-%b-%Y")
+    url = f"https://civicdb.org/downloads/{dt2}/{dt2}-GeneSummaries.tsv"
     df = ensure_df(prefix=PREFIX, url=url, sep="\t", force=force, dtype=str, version=version)
-    for identifier, _, name, entrez_id, description, _last_review, _flag in df.values:
+    for (
+        identifier,
+        _,
+        type,
+        name,
+        aliases,
+        description,
+        _last_review_date,
+        _flag,
+        entrez_id,
+        ncit_id,
+        _5p_status,
+        _3p_status,
+        five_p_id,
+        _5p_name,
+        _5p_ncbigene,
+        three_p_id,
+        _3p_name,
+        _3p_ncbigene,
+    ) in df.values:
         term = Term(
             reference=Reference(prefix=PREFIX, identifier=identifier, name=name),
             definition=description if pd.notna(description) else None,
         )
-        term.append_exact_match(Reference(prefix="ncbigene", identifier=entrez_id))
+        term.append_parent(TYPES[type])
+        if pd.notna(entrez_id):
+            term.append_exact_match(Reference(prefix="ncbigene", identifier=entrez_id))
+        if pd.notna(ncit_id):
+            term.append_exact_match(Reference(prefix="ncit", identifier=ncit_id))
+        if pd.notna(aliases):
+            for alias in aliases.split(","):
+                if alias != name:
+                    term.append_synonym(alias.strip())
+        if pd.notna(five_p_id):
+            term.append_relationship(
+                HAS_5P, Reference(prefix=PREFIX, identifier=five_p_id, name=_5p_name)
+            )
+        if pd.notna(three_p_id):
+            term.append_relationship(
+                HAS_3P, Reference(prefix=PREFIX, identifier=three_p_id, name=_3p_name)
+            )
+
         yield term
 
 

pyobo/sources/clinicaltrials.py

@@ -0,0 +1,160 @@
+"""A source for ClinicalTrials.gov."""
+
+from collections.abc import Iterable
+
+from clinicaltrials_downloader import get_studies_slim
+
+from pyobo import Obo, Reference, Term, TypeDef, default_reference
+from pyobo.struct.struct import CHARLIE_TERM, HUMAN_TERM, PYOBO_INJECTED
+from pyobo.struct.typedef import has_contributor
+
+__all__ = [
+    "ClinicalTrialsGetter",
+]
+
+PREFIX = "clinicaltrials"
+
+INVESTIGATES_CONDITION = TypeDef(
+    reference=default_reference(
+        prefix=PREFIX, identifier="investigates_condition", name="investigates condition"
+    ),
+    is_metadata_tag=True,
+)
+HAS_INTERVENTION = TypeDef(
+    reference=default_reference(
+        prefix=PREFIX, identifier="has_intervention", name="has intervention"
+    ),
+    is_metadata_tag=True,
+)
+
+STUDY_TERM = Term(reference=default_reference(PREFIX, "study", name="study"))
+
+CLINICAL_TRIAL_TERM = Term(
+    reference=default_reference(PREFIX, "clinical-trial", name="clinical trial")
+).append_parent(STUDY_TERM)
+
+INTERVENTIONAL_CLINICAL_TRIAL_TERM = Term(
+    reference=default_reference(
+        PREFIX, "interventional-clinical-trial", name="interventional clinical trial"
+    )
+).append_parent(CLINICAL_TRIAL_TERM)
+
+RANDOMIZED_INTERVENTIONAL_CLINICAL_TRIAL_TERM = Term(
+    reference=default_reference(
+        PREFIX,
+        "randomized-interventional-clinical-trial",
+        name="randomized interventional clinical trial",
+    )
+).append_parent(INTERVENTIONAL_CLINICAL_TRIAL_TERM)
+
+NON_RANDOMIZED_INTERVENTIONAL_CLINICAL_TRIAL_TERM = Term(
+    reference=default_reference(
+        PREFIX,
+        "non-randomized-interventional-clinical-trial",
+        name="non-randomized interventional clinical trial",
+    )
+).append_parent(INTERVENTIONAL_CLINICAL_TRIAL_TERM)
+
+OBSERVATIONAL_CLINICAL_TRIAL_TERM = Term(
+    reference=default_reference(
+        PREFIX, "observational-clinical-trial", name="observational clinical trial"
+    )
+).append_parent(CLINICAL_TRIAL_TERM)
+
+EXPANDED_ACCESS_STUDY_TERM = Term(
+    reference=default_reference(PREFIX, "expanded-access-study", name="expanded access study")
+).append_parent(STUDY_TERM)
+
+TERMS = [
+    STUDY_TERM,
+    CLINICAL_TRIAL_TERM,
+    OBSERVATIONAL_CLINICAL_TRIAL_TERM,
+    INTERVENTIONAL_CLINICAL_TRIAL_TERM,
+    EXPANDED_ACCESS_STUDY_TERM,
+    RANDOMIZED_INTERVENTIONAL_CLINICAL_TRIAL_TERM,
+    NON_RANDOMIZED_INTERVENTIONAL_CLINICAL_TRIAL_TERM,
+]
+
+# These were identified as the 4 possibilities for study
+# types in ClinicalTrials.gov. See summary script at
+# https://gist.github.com/cthoyt/12a3cb3c63ad68d73fe5a2f0d506526f
+PARENTS: dict[tuple[str | None, str | None], Term] = {
+    ("INTERVENTIONAL", None): INTERVENTIONAL_CLINICAL_TRIAL_TERM,
+    ("INTERVENTIONAL", "NA"): INTERVENTIONAL_CLINICAL_TRIAL_TERM,
+    ("INTERVENTIONAL", "RANDOMIZED"): RANDOMIZED_INTERVENTIONAL_CLINICAL_TRIAL_TERM,
+    ("INTERVENTIONAL", "NON_RANDOMIZED"): NON_RANDOMIZED_INTERVENTIONAL_CLINICAL_TRIAL_TERM,
+    ("OBSERVATIONAL", None): OBSERVATIONAL_CLINICAL_TRIAL_TERM,
+    ("EXPANDED_ACCESS", None): EXPANDED_ACCESS_STUDY_TERM,
+    (None, None): STUDY_TERM,
+}
+
+
+class ClinicalTrialsGetter(Obo):
+    """Get the ClinicalTrials.gov database as an ontology."""
+
+    ontology = PREFIX
+    dynamic_version = True
+    typedefs = [has_contributor, INVESTIGATES_CONDITION, HAS_INTERVENTION]
+    root_terms = [STUDY_TERM.reference]
+
+    def iter_terms(self, force: bool = False) -> Iterable[Term]:
+        """Iterate over terms for studies."""
+        yield CHARLIE_TERM
+        yield HUMAN_TERM
+        for term in TERMS:
+            term.append_contributor(CHARLIE_TERM)
+            term.append_comment(PYOBO_INJECTED)
+            yield term
+        yield from iterate_studies()
+
+
+def iterate_studies(*, force: bool = False) -> Iterable[Term]:
+    """Iterate over terms for studies."""
+    studies = get_studies_slim(force=force)
+    for study in studies:
+        yield _process_study(study)
+
+
+def _process_study(raw_study) -> Term:
+    protocol_section = raw_study["protocolSection"]
+    identification_module = protocol_section["identificationModule"]
+    identifier = identification_module["nctId"]
+
+    name = identification_module.get("officialTitle")
+    synonym = identification_module.get("briefTitle")
+    if synonym and not name:
+        name, synonym = synonym, None
+
+    term = Term(
+        reference=Reference(prefix=PREFIX, identifier=identifier, name=name), type="Instance"
+    )
+    if synonym:
+        term.append_synonym(synonym)
+
+    design_module = protocol_section.get("designModule", {})
+    study_type = design_module.get("studyType")
+    allocation = design_module.get("designInfo", {}).get("allocation")
+    term.append_parent(PARENTS[study_type, allocation])
+
+    references_module = protocol_section.get("referencesModule", {})
+    for reference in references_module.get("references", []):
+        if pubmed_id := reference.get("pmid"):
+            term.append_see_also(Reference(prefix="pubmed", identifier=pubmed_id))
+
+    derived_section = raw_study["derivedSection"]
+    for mesh_record in derived_section.get("conditionBrowseModule", {}).get("meshes", []):
+        term.annotate_object(INVESTIGATES_CONDITION, _mesh(mesh_record))
+
+    for mesh_record in derived_section.get("interventionBrowseModule", {}).get("meshes", []):
+        term.annotate_object(HAS_INTERVENTION, _mesh(mesh_record))
+    return term
+
+
+def _mesh(mesh_record: dict[str, str]) -> Reference:
+    return Reference(
+        prefix="mesh", identifier=mesh_record["id"], name=mesh_record.get("term") or None
+    )
+
+
+if __name__ == "__main__":
+    ClinicalTrialsGetter.cli()