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

pyobo/sources/icd11.py

@@ -1,105 +0,0 @@
-"""Convert ICD11 to OBO.
-
-Run with python -m pyobo.sources.icd11 -v
-"""
-
-import json
-import logging
-import os
-from collections.abc import Iterable, Mapping
-from typing import Any
-
-import click
-from more_click import verbose_option
-from tqdm.auto import tqdm
-
-from ..sources.icd_utils import (
-    ICD11_TOP_LEVEL_URL,
-    get_child_identifiers,
-    get_icd,
-    visiter,
-)
-from ..struct import Obo, Reference, Synonym, Term
-from ..utils.path import prefix_directory_join
-
-__all__ = [
-    "ICD11Getter",
-]
-
-logger = logging.getLogger(__name__)
-
-PREFIX = "icd11"
-
-
-class ICD11Getter(Obo):
-    """An ontology representation of ICD-11."""
-
-    ontology = PREFIX
-    dynamic_version = True
-
-    def iter_terms(self, force: bool = False) -> Iterable[Term]:
-        """Iterate over terms in the ontology."""
-        return iterate_icd11()
-
-
-def get_obo() -> Obo:
-    """Get ICD11 as OBO."""
-    return ICD11Getter()
-
-
-def iterate_icd11() -> Iterable[Term]:
-    """Iterate over the terms in ICD11.
-
-    The API doesn't seem to have a rate limit, but returns pretty slow.
-    This means that it only gets results at at about 5 calls/second.
-    Get ready to be patient - the API token expires every hour so there's
-    a caching mechanism with :mod:`cachier` that gets a new one every hour.
-    """
-    res = get_icd(ICD11_TOP_LEVEL_URL)
-    res_json = res.json()
-
-    version = res_json["releaseId"]
-    directory = prefix_directory_join(PREFIX, version=version)
-
-    with open(os.path.join(directory, "top.json"), "w") as file:
-        json.dump(res_json, file, indent=2)
-
-    tqdm.write(f'There are {len(res_json["child"])} top level entities')
-
-    visited_identifiers: set[str] = set()
-    for identifier in get_child_identifiers(ICD11_TOP_LEVEL_URL, res_json):
-        yield from visiter(
-            identifier,
-            visited_identifiers,
-            directory,
-            endpoint=ICD11_TOP_LEVEL_URL,
-            converter=_extract_icd11,
-        )
-
-
-def _extract_icd11(res_json: Mapping[str, Any]) -> Term:
-    identifier = res_json["@id"][len(ICD11_TOP_LEVEL_URL) :].lstrip("/")
-    definition = res_json["definition"]["@value"] if "definition" in res_json else None
-    name = res_json["title"]["@value"]
-    synonyms = [Synonym(synonym["label"]["@value"]) for synonym in res_json.get("synonym", [])]
-    parents = [
-        Reference(prefix=PREFIX, identifier=url[len("http://id.who.int/icd/entity/") :])
-        for url in res_json["parent"]
-        if url[len("http://id.who.int/icd/entity/") :]
-    ]
-    return Term(
-        reference=Reference(prefix=PREFIX, identifier=identifier, name=name),
-        definition=definition,
-        synonyms=synonyms,
-        parents=parents,
-    )
-
-
-@click.command()
-@verbose_option
-def _main():
-    get_obo().write_default(use_tqdm=True)
-
-
-if __name__ == "__main__":
-    _main()

pyobo/xrefdb/__init__.py

@@ -1 +0,0 @@
-"""Extraction of mappings from OBO documents."""

pyobo/xrefdb/canonicalizer.py

@@ -1,214 +0,0 @@
-"""Tools for canonicalizing a CURIE based on a priority list."""
-
-from collections.abc import Iterable, Mapping
-from dataclasses import dataclass, field
-from functools import lru_cache
-from typing import Optional
-
-import networkx as nx
-import pandas as pd
-from more_itertools import pairwise
-from tqdm.auto import tqdm
-
-from .priority import DEFAULT_PRIORITY_LIST
-from .xrefs_pipeline import get_graph_from_xref_df
-from .. import resource_utils
-from ..utils.io import get_reader, get_writer
-
-__all__ = [
-    "Canonicalizer",
-    "all_shortest_paths",
-    "single_source_shortest_path",
-    "get_equivalent",
-    "get_priority_curie",
-    "remap_file_stream",
-]
-
-
-@dataclass
-class Canonicalizer:
-    """Wraps a graph and priority list to allow getting the best identifier."""
-
-    #: A graph from :func:`get_graph_from_xref_df`
-    graph: nx.Graph
-
-    #: A list of prefixes. The ones with the lower index are higher priority
-    priority: Optional[list[str]] = None
-
-    #: Longest length paths allowed
-    cutoff: int = 5
-
-    _priority: Mapping[str, int] = field(init=False)
-
-    def __post_init__(self):
-        """Initialize the priority map based on the priority list."""
-        if self.priority is None:
-            self.priority = DEFAULT_PRIORITY_LIST
-        self._priority = {entry: len(self.priority) - i for i, entry in enumerate(self.priority)}
-
-    def _key(self, curie: str) -> Optional[int]:
-        prefix = self.graph.nodes[curie]["prefix"]
-        return self._priority.get(prefix)
-
-    def _get_priority_dict(self, curie: str) -> Mapping[str, int]:
-        return dict(self._iterate_priority_targets(curie))
-
-    def _iterate_priority_targets(self, curie: str) -> Iterable[tuple[str, int]]:
-        for target in nx.single_source_shortest_path(self.graph, curie, cutoff=self.cutoff):
-            priority = self._key(target)
-            if priority is not None:
-                yield target, priority
-            elif target == curie:
-                yield target, 0
-            else:
-                yield target, -1
-
-    def canonicalize(self, curie: str) -> str:
-        """Get the best CURIE from the given CURIE."""
-        if curie not in self.graph:
-            return curie
-        priority_dict = self._get_priority_dict(curie)
-        return max(priority_dict, key=priority_dict.get)  # type:ignore
-
-    @classmethod
-    def get_default(cls, priority: Optional[Iterable[str]] = None) -> "Canonicalizer":
-        """Get the default canonicalizer."""
-        if priority is not None:
-            priority = tuple(priority)
-        return cls._get_default_helper(priority=priority)
-
-    @classmethod
-    @lru_cache
-    def _get_default_helper(cls, priority: Optional[tuple[str, ...]] = None) -> "Canonicalizer":
-        """Help get the default canonicalizer."""
-        graph = cls._get_default_graph()
-        return cls(graph=graph, priority=list(priority) if priority else None)
-
-    @staticmethod
-    @lru_cache
-    def _get_default_graph() -> nx.Graph:
-        df = resource_utils.ensure_inspector_javert_df()
-        graph = get_graph_from_xref_df(df)
-        return graph
-
-    def iterate_flat_mapping(self, use_tqdm: bool = True) -> Iterable[tuple[str, str]]:
-        """Iterate over the canonical mapping from all nodes to their canonical CURIEs."""
-        nodes = self.graph.nodes()
-        if use_tqdm:
-            nodes = tqdm(
-                nodes,
-                total=self.graph.number_of_nodes(),
-                desc="building flat mapping",
-                unit_scale=True,
-                unit="CURIE",
-            )
-        for node in nodes:
-            yield node, self.canonicalize(node)
-
-    def get_flat_mapping(self, use_tqdm: bool = True) -> Mapping[str, str]:
-        """Get a canonical mapping from all nodes to their canonical CURIEs."""
-        return dict(self.iterate_flat_mapping(use_tqdm=use_tqdm))
-
-    def single_source_shortest_path(
-        self,
-        curie: str,
-        cutoff: Optional[int] = None,
-    ) -> Optional[Mapping[str, list[Mapping[str, str]]]]:
-        """Get all shortest paths between given entity and its equivalent entities."""
-        return single_source_shortest_path(graph=self.graph, curie=curie, cutoff=cutoff)
-
-    def all_shortest_paths(
-        self, source_curie: str, target_curie: str
-    ) -> list[list[Mapping[str, str]]]:
-        """Get all shortest paths between the two entities."""
-        return all_shortest_paths(
-            graph=self.graph, source_curie=source_curie, target_curie=target_curie
-        )
-
-    @classmethod
-    def from_df(cls, df: pd.DataFrame) -> "Canonicalizer":
-        """Instantiate from a dataframe."""
-        return cls(graph=get_graph_from_xref_df(df))
-
-
-def all_shortest_paths(
-    graph: nx.Graph, source_curie: str, target_curie: str
-) -> list[list[Mapping[str, str]]]:
-    """Get all shortest paths between the two CURIEs."""
-    _paths = nx.all_shortest_paths(graph, source=source_curie, target=target_curie)
-    return [
-        [
-            {"source": s, "target": t, "provenance": graph[s][t]["source"]}
-            for s, t in pairwise(_path)
-        ]
-        for _path in _paths
-    ]
-
-
-def single_source_shortest_path(
-    graph: nx.Graph,
-    curie: str,
-    cutoff: Optional[int] = None,
-) -> Optional[Mapping[str, list[Mapping[str, str]]]]:
-    """Get the shortest path from the CURIE to all elements of its equivalence class.
-
-    Things that didn't work:
-
-    Unresponsive
-    ------------
-    .. code-block:: python
-
-        for curies in tqdm(
-            nx.connected_components(graph), desc="filling connected components", unit_scale=True
-        ):
-            for c1, c2 in itt.combinations(curies, r=2):
-                if not graph.has_edge(c1, c2):
-                    graph.add_edge(c1, c2, inferred=True)
-
-    Way too slow
-    ------------
-    .. code-block:: python
-
-        for curie in tqdm(
-            graph, total=graph.number_of_nodes(), desc="mapping connected components", unit_scale=True
-        ):
-            for incident_curie in nx.node_connected_component(graph, curie):
-                if not graph.has_edge(curie, incident_curie):
-                    graph.add_edge(curie, incident_curie, inferred=True)
-
-    Also consider the condensation of the graph:
-    https://networkx.github.io/documentation/stable/reference/algorithms/generated/networkx.algorithms.components.condensation.html#networkx.algorithms.components.condensation
-    """
-    if curie not in graph:
-        return None
-    rv = nx.single_source_shortest_path(graph, curie, cutoff=cutoff)
-    return {
-        k: [
-            {"source": s, "target": t, "provenance": graph[s][t]["provenance"]}
-            for s, t in pairwise(v)
-        ]
-        for k, v in rv.items()
-        if k != curie  # don't map to self
-    }
-
-
-def get_equivalent(curie: str, cutoff: Optional[int] = None) -> set[str]:
-    """Get equivalent CURIEs."""
-    canonicalizer = Canonicalizer.get_default()
-    r = canonicalizer.single_source_shortest_path(curie=curie, cutoff=cutoff)
-    return set(r or [])
-
-
-def get_priority_curie(curie: str) -> str:
-    """Get the priority CURIE mapped to the best namespace."""
-    canonicalizer = Canonicalizer.get_default()
-    return canonicalizer.canonicalize(curie)
-
-
-def remap_file_stream(file_in, file_out, column: int, sep="\t") -> None:
-    """Remap a file."""
-    reader = get_reader(file_in, sep=sep)
-    writer = get_writer(file_out, sep=sep)
-    for row in reader:
-        row[column] = get_priority_curie(row[column])
-        writer.writerow(row)

pyobo/xrefdb/priority.py

@@ -1,59 +0,0 @@
-"""Configuration for the default priority list."""
-
-import bioregistry
-
-__all__ = [
-    "DEFAULT_PRIORITY_LIST",
-]
-
-_DEFAULT_PRIORITY_LIST = [
-    # Genes
-    "ncbigene",
-    "hgnc",
-    "rgd",
-    "mgi",
-    "ensembl",
-    "uniprot",
-    # Chemicals
-    # 'inchikey',
-    # 'inchi',
-    # 'smiles',
-    "pubchem.compound",
-    "chebi",
-    "drugbank",
-    "chembl.compound",
-    "zinc",
-    # protein families and complexes (and famplexes :))
-    "complexportal",
-    "fplx",
-    "ec-code",
-    "interpro",
-    "pfam",
-    "signor",
-    # Pathologies/phenotypes
-    "mondo",
-    "efo",
-    "doid",
-    "hp",
-    # Taxa
-    "ncbitaxon",
-    # If you can get away from MeSH, do it
-    "mesh",
-    "icd",
-]
-
-
-def _get_default_priority_list():
-    rv = []
-    for _entry in _DEFAULT_PRIORITY_LIST:
-        _prefix = bioregistry.normalize_prefix(_entry)
-        if not _prefix:
-            raise RuntimeError(f"unresolved prefix: {_entry}")
-        if _prefix in rv:
-            raise RuntimeError(f"duplicate found in priority list: {_entry}/{_prefix}")
-        rv.append(_prefix)
-    return rv
-
-
-DEFAULT_PRIORITY_LIST = _get_default_priority_list()
-del _get_default_priority_list

pyobo/xrefdb/sources/__init__.py

@@ -1,60 +0,0 @@
-"""Sources of xrefs not from OBO."""
-
-import logging
-from collections.abc import Iterable, Mapping
-from functools import lru_cache
-from typing import Callable, Optional
-
-import pandas as pd
-from class_resolver import FunctionResolver
-from tqdm.auto import tqdm
-
-__all__ = [
-    "iter_xref_plugins",
-    "has_xref_plugin",
-    "run_xref_plugin",
-    "iter_xref_plugins",
-]
-
-logger = logging.getLogger(__name__)
-
-XrefGetter = Callable[[], pd.DataFrame]
-
-
-@lru_cache
-def _get_xref_plugins() -> Mapping[str, XrefGetter]:
-    resolver: FunctionResolver[XrefGetter] = FunctionResolver.from_entrypoint("pyobo.xrefs")
-    return resolver.lookup_dict
-
-
-def has_xref_plugin(prefix: str) -> bool:
-    """Check if there's a plugin for converting the prefix."""
-    return prefix in _get_xref_plugins()
-
-
-def run_xref_plugin(prefix: str) -> pd.DataFrame:
-    """Get a converted PyOBO source."""
-    rv = _get_xref_plugins()[prefix]()
-
-    if isinstance(rv, pd.DataFrame):
-        return rv
-
-    logger.warning("can not load %s since it yields many dataframes", prefix)
-
-
-def iter_xref_plugins(
-    use_tqdm: bool = True, skip_below: Optional[str] = None
-) -> Iterable[pd.DataFrame]:
-    """Get all modules in the PyOBO sources."""
-    it = tqdm(sorted(_get_xref_plugins().items()), desc="Mapping Plugins", disable=not use_tqdm)
-    for prefix, get_df in it:
-        if skip_below and prefix < skip_below:
-            continue
-        it.set_postfix({"prefix": prefix})
-        rv = get_df()
-        if isinstance(rv, pd.DataFrame):
-            yield rv
-        elif isinstance(rv, Iterable):
-            yield from rv
-        else:
-            raise TypeError

pyobo/xrefdb/sources/biomappings.py

@@ -1,36 +0,0 @@
-"""Get the Biomappings manually curated equivalences."""
-
-import pandas as pd
-from pystow.utils import get_commit
-
-from pyobo.constants import (
-    PROVENANCE,
-    SOURCE_ID,
-    SOURCE_PREFIX,
-    TARGET_ID,
-    TARGET_PREFIX,
-    XREF_COLUMNS,
-)
-
-__all__ = [
-    "get_biomappings_df",
-]
-
-
-def get_biomappings_df() -> pd.DataFrame:
-    """Get biomappings equivalences."""
-    sha = get_commit("biopragmatics", "biomappings")
-    url = f"https://raw.githubusercontent.com/biopragmatics/biomappings/{sha}/src/biomappings/resources/mappings.tsv"
-    df = pd.read_csv(url, sep="\t")
-    df[PROVENANCE] = url
-    df.rename(
-        columns={
-            "source prefix": SOURCE_PREFIX,
-            "source identifier": SOURCE_ID,
-            "target prefix": TARGET_PREFIX,
-            "target identifier": TARGET_ID,
-        },
-        inplace=True,
-    )
-    df = df[XREF_COLUMNS]
-    return df

pyobo/xrefdb/sources/cbms2019.py

@@ -1,91 +0,0 @@
-"""Cross references from cbms2019.
-
-.. seealso:: https://github.com/pantapps/cbms2019
-"""
-
-import pandas as pd
-
-from pyobo.constants import (
-    PROVENANCE,
-    SOURCE_ID,
-    SOURCE_PREFIX,
-    TARGET_ID,
-    TARGET_PREFIX,
-    XREF_COLUMNS,
-)
-
-__all__ = [
-    "get_cbms2019_xrefs_df",
-]
-
-#: Columns: DOID, DO name, xref xb, xref ix
-base_url = "https://raw.githubusercontent.com/pantapps/cbms2019/master"
-doid_to_all = f"{base_url}/mesh_icd10cm_via_do_not_mapped_umls.tsv"
-#: Columns: SNOMEDCT_ID, SNOMEDCIT_NAME, ICD10CM_ID, ICD10CM_NAME, MESH_ID
-all_to_all = f"{base_url}/mesh_icd10cm_via_snomedct_not_mapped_umls.tsv"
-#: Columns: DOID, DO name, xref xb, xref ix
-doid_to_all_2 = f"{base_url}/mesh_snomedct_via_do_not_mapped_umls.tsv"
-#: Columns: SNOMEDCT_ID, SNOMEDCIT_NAME, ICD10CM_ID, ICD10CM_NAME, MESH_ID
-all_to_all_2 = f"{base_url}/mesh_snomedct_via_icd10cm_not_mapped_umls.tsv"
-
-NSM = {
-    "MESH": "mesh",
-    "ICD10CM": "icd",
-    "SNOMEDCT_US_2016_03_01": "snomedct",
-}
-
-
-def _get_doid(url: str) -> pd.DataFrame:
-    df = pd.read_csv(url, sep="\t", usecols=["DO_ID", "resource", "resource_ID"])
-    df.columns = [SOURCE_ID, TARGET_PREFIX, TARGET_ID]
-
-    df[SOURCE_PREFIX] = "doid"
-    df[SOURCE_ID] = df[SOURCE_ID].map(lambda s: s[len("DOID:") :])
-    df[PROVENANCE] = url
-    df[TARGET_PREFIX] = df[TARGET_PREFIX].map(NSM.get)
-    df = df[XREF_COLUMNS]
-    return df
-
-
-def _get_mesh_to_icd_via_doid() -> pd.DataFrame:
-    return _get_doid(doid_to_all)
-
-
-def _get_mesh_to_icd_via_snomedct() -> pd.DataFrame:
-    df = pd.read_csv(all_to_all, sep="\t", usecols=["SNOMEDCT_ID", "ICD10CM_ID", "MESH_ID"])
-    rows = []
-    for snomedct_id, icd_id, mesh_id in df.values:
-        rows.append(("mesh", mesh_id, "snomedct", snomedct_id, all_to_all))
-        rows.append(("snomedct", snomedct_id, "icd", icd_id, all_to_all))
-    return pd.DataFrame(rows, columns=XREF_COLUMNS)
-
-
-def _get_mesh_to_snomedct_via_doid() -> pd.DataFrame:
-    return _get_doid(doid_to_all_2)
-
-
-def _get_mesh_to_snomedct_via_icd() -> pd.DataFrame:
-    df = pd.read_csv(
-        all_to_all_2,
-        sep="\t",
-        usecols=["SNOMEDCT_ID", "ICD10CM_ID", "MESH_ID"],
-        dtype={"SNOMEDCT_ID": float},
-    )
-    rows = []
-    for snomedct_id, icd_id, mesh_id in df.values:
-        snomedct_id = str(int(snomedct_id))
-        rows.append(("mesh", mesh_id, "icd", icd_id, all_to_all))
-        rows.append(("icd", icd_id, "snomedct", snomedct_id, all_to_all))
-    return pd.DataFrame(rows, columns=XREF_COLUMNS)
-
-
-def get_cbms2019_xrefs_df() -> pd.DataFrame:
-    """Get all CBMS2019 xrefs."""
-    return pd.concat(
-        [
-            _get_mesh_to_icd_via_doid(),
-            _get_mesh_to_icd_via_snomedct(),
-            _get_mesh_to_snomedct_via_doid(),
-            _get_mesh_to_snomedct_via_icd(),
-        ]
-    ).drop_duplicates()

pyobo/xrefdb/sources/chembl.py

@@ -1,83 +0,0 @@
-"""Get ChEMBL xrefs."""
-
-from typing import Optional
-
-import pandas as pd
-
-from pyobo.api.utils import get_version
-from pyobo.constants import (
-    PROVENANCE,
-    SOURCE_ID,
-    SOURCE_PREFIX,
-    TARGET_ID,
-    TARGET_PREFIX,
-    XREF_COLUMNS,
-)
-from pyobo.utils.path import ensure_df
-
-CHEMBL_COMPOUND_PREFIX = "chembl.compound"
-CHEMBL_TARGET_PREFIX = "chembl.target"
-
-
-def get_chembl_compound_equivalences_raw(
-    usecols=None, version: Optional[str] = None
-) -> pd.DataFrame:
-    """Get the chemical representations raw dataframe."""
-    if version is None:
-        version = get_version("chembl")
-
-    base_url = f"ftp://ftp.ebi.ac.uk/pub/databases/chembl/ChEMBLdb/releases/chembl_{version}"
-    url = f"{base_url}/chembl_{version}_chemreps.txt.gz"
-    return ensure_df(CHEMBL_COMPOUND_PREFIX, url=url, sep="\t", usecols=usecols)
-
-
-def get_chembl_compound_equivalences(version: Optional[str] = None) -> pd.DataFrame:
-    """Get ChEMBL chemical equivalences."""
-    if version is None:
-        version = get_version("chembl")
-
-    df = get_chembl_compound_equivalences_raw(version=version)
-    rows = []
-    for chembl, _smiles, _inchi, inchi_key in df.values:
-        rows.extend(
-            [
-                # No smiles/inchi since they can have variable length
-                # ("chembl.compound", chembl, "smiles", smiles, f"chembl{version}"),
-                # ("chembl.compound", chembl, "inchi", inchi, f"chembl{version}"),
-                ("chembl.compound", chembl, "inchikey", inchi_key, f"chembl{version}"),
-            ]
-        )
-    return pd.DataFrame(rows, columns=XREF_COLUMNS)
-
-
-def get_chembl_protein_equivalences(version: Optional[str] = None) -> pd.DataFrame:
-    """Get ChEMBL protein equivalences."""
-    if version is None:
-        version = get_version("chembl")
-
-    url = f"ftp://ftp.ebi.ac.uk/pub/databases/chembl/ChEMBLdb/releases/chembl_{version}/chembl_uniprot_mapping.txt"
-    df = ensure_df(
-        CHEMBL_TARGET_PREFIX,
-        url=url,
-        sep="\t",
-        usecols=[0, 1],
-        names=[TARGET_ID, SOURCE_ID],  # switch around
-    )
-    df.loc[:, SOURCE_PREFIX] = "chembl.target"
-    df.loc[:, TARGET_PREFIX] = "uniprot"
-    df.loc[:, PROVENANCE] = f"chembl{version}"
-    df = df[XREF_COLUMNS]
-    return df
-
-
-def get_chembl_xrefs_df(version: Optional[str] = None) -> pd.DataFrame:
-    """Get all ChEBML equivalences."""
-    if version is None:
-        version = get_version("chembl")
-
-    return pd.concat(
-        [
-            get_chembl_compound_equivalences(version=version),
-            get_chembl_protein_equivalences(version=version),
-        ]
-    )