metahq-core 0.1.2__py3-none-any.whl → 1.0.0rc1__py3-none-any.whl

metahq_core/ontology/base.py

@@ -1,376 +0,0 @@
-"""
-Operations for ontologies. Currently, only UBERON, CL, and MONDO are supported.
-
-Authors: Parker Hicks, Hao Yuan
-Date: 2025-01-16
-
-Last updated: 2025-09-01 by Parker Hicks
-"""
-
-import numpy as np
-import polars as pl
-
-from metahq_core.util.alltypes import FilePath
-from metahq_core.util.helpers import reverse_dict
-
-
-class Ontology:
-    """
-    This class contains functionalities for working with ontologies. Currently only supports
-    ontologies stored in obo files.
-
-    Attributes
-    ----------
-    ontology: str
-        Name of the ontology (e.g., mondo, MONDO, uberon, CL).
-
-    entries: list
-        Entries from the ontology that begin with the pattern [Term].
-
-    _class_dict: dict
-    Term ID to term name mapping (e.g., {MONDO:0006858: 'mouth disorder'}).
-
-    Methods
-    -------
-    get_class_dict()
-        Retrieves ID: name pairs for terms in the ontology.
-
-    xref()
-        Retrives cross referenced terms from another ontology that are equivalent to terms
-        in self.ontology.
-
-    mesh_to_mondo()
-        Given a MESH ID and an xref map, will find the corresponding MONDO ID.
-
-    read()
-        Opens and reads the ontology file.
-
-    Static Methods
-    --------------
-    get_entries()
-        Finds ontology term entries from lines in the ontology file.
-
-    map_terms()
-        Given a list of terms from another ontology, will map those to self.ontology terms.
-
-    obo_reader()
-        Opens and read the .obo file.
-
-    Class Methods
-    -------------
-    mapping_func()
-        Assigns the correct mapping function for `map_terms`.
-
-    from_obo()
-        Initializes the class by loading the ontology from an .obo file.
-
-    Example
-    -------
-    >>> from ontology.ontology import Ontology
-    >>> op = Ontology.from_obo("mondo.obo", ontology="mondo")
-
-    """
-
-    def __init__(self, ontology: str):
-        self.ontology = ontology
-        self.entries = []
-        self._class_dict = {}
-
-    def get_class_dict(self, verbose=False) -> None:
-        """
-        Fills the _class_dict attribute with id: name pairs.
-
-        :param verbose: If True, will print redundant terms.
-        """
-        for entry in self.entries:
-            lines = entry.split("\n")
-            for line in lines:
-                line = line.rstrip()
-                if line.startswith("id:"):
-                    _id = line.split("id: ")[1]
-                elif line.startswith("name:"):
-                    name = line.split("name: ")[1]
-                    if _id not in self._class_dict:
-                        self._class_dict[_id] = name.lower()
-                    elif verbose:
-                        print(f"{_id} showing up more than once")
-
-    def xref(self, ref: str, reverse=False, verbose=False) -> dict:
-        """
-        Finds cross references to other ontology terms within self.ontology.
-
-        If there are cross references, this function will just choose the first
-        one it comes across.
-
-        :param ref: The cross referenced ontology (e.g., MESH).
-        :param reverse: If True, will return {xref: term} instead of {term: xref}.
-        :param verbose: If True, will print redundant cross references.
-        :returns _map: Mapping between terms from self.ontology and the xref ontology.
-
-        Example
-        -------
-        >>> from ontology.ontology import Ontology
-        >>> op = Ontology.from_obo("mondo.obo", ontology="mondo")
-        >>> op.xref("MESH").pop("MONDO:0100340")
-        MESH:C565561
-
-        >>> op.xref("MESH", verbose=True)
-        MESH:D006966 showing up more than once (duplicate: MONDO:0024305)
-        MESH:C537897 showing up more than once (duplicate: MONDO:0043176)
-        ...
-        MESH:D000086382 showing up more than once (duplicate: MONDO:0100096)
-
-        """
-        _map = {}
-        for entry in self.entries:
-            lines = entry.split("\n")
-            for line in lines:
-                line = line.rstrip()
-                if line.startswith("id:"):
-                    _id = line.split("id: ")[1]
-                elif line.startswith(f"xref: {ref}:"):
-                    __id = line.split(" ")[1]
-                    if _id not in _map:
-                        _map[_id] = __id
-                    elif verbose:
-                        print(f"{__id} showing up more than once (duplicate: {_id})")
-        if reverse:
-            _map = reverse_dict(_map)
-
-        return _map
-
-    def map_terms(self, terms: np.ndarray, _from: str, _to: str) -> dict:
-        """
-        Maps term IDs from a list of terms to another ontology.
-
-        :param terms: Array of term IDs to map.
-        :param _from: The ontology type of the IDs in terms.
-        :param _to: The ontology type you want to map those terms to.
-        :returns mapped: Mapping between terms in terms to _to.
-
-        Example
-        -------
-        >>> from ontology.ontology import Ontology
-        >>> op = Ontology.from_obo("mondo.obo", ontology="mondo")
-        >>> op.map_terms(mesh, _from="MESH", _to="MONDO").pop("MESH:D007680")
-        MONDO:0002367
-
-        >>> op.map_terms(mesh, _from="MONDO", _to="MESH").pop("MONDO:0002367")
-        MESH:D007680
-
-        """
-        if _to == self.ontology:
-            reverse = True
-            ref = _from
-        else:
-            reverse = False
-            ref = _to
-
-        _map = self.xref(ref=ref, reverse=reverse)
-
-        mapped = {}
-        mapper = self.mapping_func(_from, _to, self.ontology)
-        for term in terms:
-            mapped[term] = mapper(term, _map)
-
-        return mapped
-
-    def read(self, file: FilePath, reader="obo") -> None:
-        """
-        Loads and reads an ontology file.
-
-        :param file: Path to ontology file.
-        :param reader: File type to read from.
-
-        Example
-        -------
-        >>> from ontology.ontology import Ontology
-        >>> op = Ontology(ontology="mondo")
-        >>> op.read("mondo.obo", reader="obo")
-        >>> op.entries[0]
-        [Term]
-        id: MONDO:0000001
-        name: disease
-        def: "A diease is a disposition to ..."
-        ...
-        property_value: exactMatch Orphannet:377788
-
-        """
-        if isinstance(reader, str):
-            if reader == "obo":
-                _reader = self.obo_reader
-                loaded = _reader(file)
-                self.entries = self.get_entries(loaded)
-            else:
-                raise ValueError(
-                    f"Unknown reader {reader!r}, available options are [obo]",
-                )
-
-    def id_map(self, fmt: str = "polars") -> dict[str, str] | pl.DataFrame:
-        """Returns class_dict as specified data structure."""
-        supported = ["polars", "dict"]
-
-        if fmt not in supported:
-            raise ValueError(f"Expected struct in {supported}, got {fmt}.")
-
-        if fmt == "polars":
-            return self._id_map_to_polars()
-
-        return self.class_dict
-
-    def _id_map_to_polars(self):
-        """Convert self.class_dict to polars DataFrame."""
-        d = {"id": list(self.class_dict.keys()), "name": list(self.class_dict.values())}
-        return pl.DataFrame(d)
-
-    @property
-    def class_dict(self) -> dict:
-        """Returns the dictionary storing terms IDs and their names."""
-        if len(self._class_dict) == 0:
-            self.get_class_dict()
-
-        return self._class_dict
-
-    @property
-    def entries(self) -> list:
-        """Returns entries from the ontology."""
-        return self._entries
-
-    @entries.setter
-    def entries(self, val):
-        """Sets self.entries value."""
-        if not isinstance(val, list):
-            raise TypeError(f"Expected list, not {type(val)}.")
-        self._entries = val
-
-    @staticmethod
-    def get_entries(obo_text: str) -> list:
-        """Returns a list of entries from entries combined by \n\n"""
-        entries = [
-            entry
-            for entry in obo_text.split("\n\n")
-            if (entry.startswith("[Term]")) and ("is_obsolete: true" not in entry)
-        ]
-
-        return entries
-
-    @staticmethod
-    def doid_to_mondo(doid: str, _map: dict[str, str]) -> str:
-        """
-        Maps a single DOID to MONDO id.
-
-        Args
-        ----
-        doid: str
-            DOID id (e.g. D000324)
-        _map: dict[str, str]
-            Dict with DOID keys and MONDO values
-
-        Returns
-        -------
-        _id:  str
-            Mapped id
-
-        Example
-        -------
-        >>> from ontology_parser import Ontology
-        >>> op = Ontology.from_obo("mondo.obo", ontology="mondo")
-        >>> _map = op.xref("DOID")
-        >>> op.mesh_to_mondo("DOID:299", _map)
-        MONDO:0004970
-
-        """
-        if doid == "DOID:0000000":
-            _id = "control"
-        elif doid in _map.keys():
-            _id = _map[doid]
-        else:
-            _id = "NA"
-
-        return _id
-
-    @staticmethod
-    def mesh_to_mondo(mesh: str, _map: dict) -> str:
-        """
-        Maps a single MESH to MONDO id.
-        :param mesh: MESH id (e.g. D000324)
-        :param _map: Dict with MESH keys and MONDO values
-        :return _id: Mapped id
-        Example
-        -------
-        >>> from ontology_parser import Ontology
-        >>> op = Ontology.from_obo("mondo.obo", ontology="mondo")
-        >>> _map = op.xref("MESH")
-        >>> op.mesh_to_mondo("MESH:D007680", _map)
-        MONDO:0002367
-        """
-        if mesh == "MESH:D000000":
-            _id = "control"
-        elif mesh in _map.keys():
-            _id = _map[mesh]
-        else:
-            _id = "NA"
-
-        return _id
-
-    @staticmethod
-    def umls_to_mondo(umls: str, _map: dict) -> str:
-        """
-        Maps a single UMLS to MONDO id.
-        :param mesh: UMLS id (e.g. D000324)
-        :param _map: Dict with UMLS keys and MONDO values
-        :return _id: Mapped id
-        Example
-        -------
-        >>> from ontology_parser import Ontology
-        >>> op = Ontology.from_obo("mondo.obo", ontology="mondo")
-        >>> _map = op.xref("UMLS")
-        >>> op.mesh_to_mondo("UMLS:C2673913", _map)
-        MONDO:0000104
-        """
-        if umls == "UMLS:C0000000":
-            _id = "MONDO:0000000"
-        elif umls in _map.keys():
-            _id = _map[umls]
-        else:
-            _id = "NA"
-
-        return _id
-
-    @staticmethod
-    def obo_reader(obo: FilePath) -> str:
-        """Reads text from an obo file."""
-        with open(obo, "r", encoding="utf-8") as f:
-            text = f.read()
-        return text
-
-    @staticmethod
-    def select_from_xref(term: str, _map: dict) -> str:
-        """Pulls the xref for a query term."""
-        if term in _map.keys():
-            _id = _map[term]
-        else:
-            _id = "NA"
-
-        return _id
-
-    @classmethod
-    def from_obo(cls, obo: FilePath, ontology: str):
-        """Create Ontology class from an obo file."""
-        parser = cls(ontology=ontology.upper())
-        parser.read(obo, reader="obo")
-        return parser
-
-    @classmethod
-    def mapping_func(cls, _from: str, _to: str, ontology: str) -> object:
-        """Assigns the correct mapping function for mapping xref terms."""
-        if _from == "MESH" and _to == "MONDO" and ontology == "MONDO":
-            return cls.mesh_to_mondo
-        if _from == "UMLS" and _to == "MONDO" and ontology == "MONDO":
-            return cls.umls_to_mondo
-        if _from == "MONDO" and _to == "MESH" and ontology == "MONDO":
-            return cls.select_from_xref
-        if _from == "DOID" and _to == "MONDO" and ontology == "MONDO":
-            return cls.doid_to_mondo
-
-        raise NotImplementedError()

metahq_core/ontology/graph.py

@@ -1,252 +0,0 @@
-"""
-Operations for creating and using directed acyclic graphs (DAGs) constructed from ontologies.
-
-Authors: Parker Hicks, Hao Yuan
-Date: 2025-01-18
-
-Last updated: 2025-09-01 by Parker Hicks
-"""
-
-import re
-
-import networkx as nx
-import numpy as np
-
-from metahq_core.ontology.base import Ontology
-from metahq_core.util.alltypes import IdArray
-
-
-class Graph(Ontology):
-    """
-    This class provides functionalities for creating and operating on ontology knowledge graphs.
-    See Ontology documentation for inherited attributes and methods.
-
-    Methods
-    -------
-    ancestors()
-        Returns the ancestors of a single node.
-
-    ancestors_from()
-        Returns ancestors for each node in a list of nodes.
-
-    construct_graph()
-        Constructs the ontology directed acyclic graph.
-
-    descendants()
-        Returns the descendants of a single node.
-
-    descendants_from()
-        Returns descendants from a list of nodes.
-
-    propagate_term()
-        Will return a -1,0,1 label given a query term and reference term.
-
-    Example
-    -------
-    >>> from ontology.graph import Graph
-    >>> ontograph = Graph.from_obo("mondo.obo", ontology="mondo")
-    >>> ontograph.graph
-    DiGraph with 23314 nodes and 35351 edges
-
-    >>> ontograph.nodes
-    ['MONDO:0002816' 'MONDO:0000004' 'MONDO:0021034' ... 'MONDO:8000019'
-     'MONDO:8000023' 'MONDO:8000024']
-
-    >>> ontograph.leaves
-    ['MONDO:0000082' 'MONDO:0000138' 'MONDO:0000208' ... 'MONDO:8000019'
-     'MONDO:8000023' 'MONDO:8000024']
-
-    >>> ontograph.class_dict["MONDO:0021054"]
-    bone sarcoma
-
-    """
-
-    def __init__(self, ontology: str):
-        """Initialize Graph object as a child of Ontology"""
-        super().__init__(ontology=ontology)
-        self._graph = nx.DiGraph()
-
-    def construct_graph(self):
-        """
-        Constructs an ontology graph from entries from an ontology file.
-
-        A simple cycle occurs between 2 nodes UBERON:8000009 and UBERON:0002354
-        (cardiac Purkinje fiber network and cardiac Purkinje fiber)
-        They are both parents and children of eachother, so to preserve the
-        directed acyclic structure of the edgelist, we intentionally keep only one
-        edge (fiber network is parent of fiber) on Line 100.
-        """
-        # ID entries have at least 1 capital letter, a colon, and at least 1 digit
-        id_pattern = re.compile(r"[A-Za-z]+:\S+")
-
-        for entry in self.entries:
-            if "is_obsolete: true" in entry:
-                continue  # skip obsolete entries
-
-            lines = entry.split("\n")
-            for line in lines:
-
-                # Get ID of the term
-                if line.startswith("id:"):
-                    _id = line.split("id: ")[1]
-                    if ("UBERON" in _id) or ("CL" in _id) or ("MONDO" in _id):
-                        pass
-                    else:
-                        break
-
-                # Get is_a connection from the reference term to another
-                elif line.startswith("is_a:"):
-                    parent = id_pattern.search(line).group(0)
-                    if ("UBERON" in parent) or ("CL" in parent) or ("MONDO" in _id):
-                        self._graph.add_edge(parent, _id)
-
-                # Get part_of connections
-                # Ignoring 'develops from' and 'related to'
-                elif line.startswith("relationship: part_of"):
-                    parent = id_pattern.search(line).group(0)
-                    if ("UBERON" in parent) or ("CL" in parent) or ("MONDO" in _id):
-                        # If parent is the fiber and child is the fiber network, then leave that edge out
-                        if _id == "UBERON:8000009" and parent == "UBERON:0002354":
-                            continue
-                        self._graph.add_edge(parent, _id)
-
-    def descendants_from(self, nodes: np.ndarray | list, verbose=False) -> dict:
-        """
-        Retrieves descendants from an array of parent nodes.
-
-        :param nodes: IDs in self.nodes for which to find desendants.
-        :param verbose: If True, will print nodes not in the graph
-        :returns _map: Mapping between parents (keys) and their children (values).
-
-        Example
-        -------
-        >>> from ontology.graph import Graph
-        >>> ontograph = Graph.from_obo("mondo.obo", ontology="mondo")
-        >>> ontograph.descendants_from(['MONDO:0005071', 'MONDO:0043543'])
-        {'MONDO:0005071': ['MONDO:0019438' ... 'MONDO:0100070'],
-         'MONDO:0043543': ['MONDO:0043544' ... 'MONDO:0005188']}
-
-        """
-        _map = {}
-        for node in nodes:
-            if node in self.nodes:
-                _map[node] = list(nx.descendants(self.graph, node))
-            elif verbose:
-                print(f"{node} not in graph.")
-
-        return _map
-
-    def ancestors_from(self, nodes: np.ndarray | list, verbose=False) -> dict:
-        """
-        Retrieves ancestors from an array of parent nodes.
-
-        :param nodes: IDs in self.nodes for which to find desendants.
-        :param verbose: If True, will print nodes not in the graph
-        :returns _map: Mapping between parents (keys) and their children (values).
-
-        Example
-        -------
-        >>> from ontology.graph import Graph
-        >>> ontograph = Graph.from_obo("mondo.obo", ontology="mondo")
-        >>> ontograph.ancestors_from(['MONDO:0008791', 'MONDO:0043209'])
-        {'MONDO:0008791': ['MONDO:0019042' ... 'MONDO:0021147'],
-         'MONDO:0043209': ['MONDO:0700096' ... 'MONDO:0004736']}
-
-        """
-
-        _map = {}
-        for node in nodes:
-            if node in self.nodes:
-                _map[node] = list(nx.ancestors(self.graph, node))
-            elif verbose:
-                print(f"{node} not in graph.")
-
-        return _map
-
-    def deepest_node(self, query: IdArray) -> str:
-        """
-        Find the deepest node using breadth first search from root nodes.
-
-        Args
-        ----
-        query: (IdArray)
-            An array of nodes for which to find the deepest node.
-
-        Returns
-        -------
-        deepest: (str)
-            The deepest node out of all query nodes.
-
-        """
-        subset_nodes = set(node for node in query if node in self.graph)
-
-        # Find roots
-        roots = [node for node in self.graph if self.graph.in_degree(node) == 0]
-        if not roots:
-            roots = list(self.graph.nodes())[0:1]
-
-        # Track depths from all roots
-        depths = {node: 0 for node in self.graph}
-
-        # Run BFS from each root
-        for root in roots:
-            visited = {node: False for node in self.graph}
-            visited[root] = True
-            queue = [(root, 0)]  # (node, depth)
-
-            while queue:
-                current, depth = queue.pop(0)
-                depths[current] = max(depths[current], depth)
-
-                for neighbor in self.graph.successors(current):
-                    if not visited[neighbor]:
-                        visited[neighbor] = True
-                        queue.append((neighbor, depth + 1))
-
-        # Find deepest node from the subset
-        max_depth = -1
-        deepest = None
-
-        for node in subset_nodes:
-            if depths[node] > max_depth:
-                max_depth = depths[node]
-                deepest = node
-
-        return deepest
-
-    def propagate_term(self, query: str, ref_term: str) -> int:
-        """Sets label for ontology terms"""
-        if query in self.descendants(ref_term):
-            return 1
-        elif query in self.ancestors(ref_term):
-            return 0
-        else:
-            return -1
-
-    def ancestors(self, term: str) -> list:
-        """Gets ancestors of a single term"""
-        return list(nx.ancestors(self.graph, term))
-
-    def descendants(self, term: str) -> list:
-        """Gets descendants of a single term"""
-        return list(nx.descendants(self.graph, term))
-
-    @property
-    def graph(self) -> nx.DiGraph:
-        """Return the ontology DiGraph"""
-        if self._graph.number_of_nodes() == 0:
-            self.construct_graph()
-
-        return self._graph
-
-    @property
-    def nodes(self) -> np.ndarray:
-        """Return the IDs of the graph nodes"""
-        return np.array(self.graph.nodes())
-
-    @property
-    def leaves(self) -> np.ndarray:
-        """Return leaf nodes of the ontology"""
-        return np.array(
-            [node for node in self.nodes if self.graph.out_degree(node) == 0]
-        )

metahq_core-0.1.2.dist-info/RECORD

@@ -1,30 +0,0 @@
-metahq_core/README.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-metahq_core/__init__.py,sha256=YvuYzWnKtqBb-IqG8HAu-nhIYAsgj9Vmc_b9o7vO-js,22
-metahq_core/logger.py,sha256=06QrC5msnehVLZ40T8oBFIUrlmBB-ysNiF5zo7Ms4fw,1319
-metahq_core/query.py,sha256=B8oyh_vKps02QXW3MgBQmZgCK20tdy2bUB4tTmNfBXk,18526
-metahq_core/search.py,sha256=XEyZqqAIE5GPK-kUw2YQFnntvcsjMmZkAR_xjRJjuYI,9549
-metahq_core/curations/_multiprocess_propagator.py,sha256=KUiTgcOSLJv0VskzEk2kOpSFHZsUCyupdpOCVdN8vwM,3510
-metahq_core/curations/annotation_converter.py,sha256=RjJs0HiLuScYma4yxo1mB6suDpUayNPopvi_lym_OSA,8879
-metahq_core/curations/annotations.py,sha256=vp3omRRN1VCdKHvhug1zq_nVjoHXH5OpM2bBPshiOuA,13576
-metahq_core/curations/base.py,sha256=3Q3gd9G7K4J9rewg7Cn9rAfml1N2Xgor-V2C3OHWeuI,1829
-metahq_core/curations/index.py,sha256=iKJaBD5fZ_4BmgPFl-yRaxc50AgMucRsX3ghOaIVN0I,2334
-metahq_core/curations/labels.py,sha256=h1Pf5DMqw0BECHsxd580hh3N6k_70vILIr5ZWhsi-fA,9207
-metahq_core/curations/propagator.py,sha256=fYnH77-VAjaJbxaN1OzfP1wNJFNGh9Z3T6kSnUpl3a0,9577
-metahq_core/export/annotations.py,sha256=PygcnCx1BPiIuhooaeiRehxz5_-WUDGirws_pwP4ruo,12702
-metahq_core/export/base.py,sha256=j7cKc-ru0ggAXEmGFYiaxBn_OROahQ9HPiR1tK-VX94,1394
-metahq_core/export/labels.py,sha256=pvS5_WIa2Aau7s4rpnSAm7OlD57Ht6Qln8-91GbNNao,13060
-metahq_core/ontology/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-metahq_core/ontology/base.py,sha256=DtdIb18aerwi3sX_B6opmkaoSuO_sVEKFTWbEY3MZHg,11545
-metahq_core/ontology/graph.py,sha256=47S_kfO6h6Np6i2g90Zizehq9yZiE4sXbuZzukyoDVE,8430
-metahq_core/ontology/loader.py,sha256=epSiBAjiJa2KFe4Tfm3dxtjPcPgxTIHwOpN3VV03iTI,4687
-metahq_core/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-metahq_core/util/alltypes.py,sha256=zYrBKvtkAhR7lmqDlGp7BOh2bUNI-toQfd7o7isDCxw,721
-metahq_core/util/checkers.py,sha256=_7Aw2bO1PNg-9TPYOwKwvTqFtmb5vMyYU-omfUID_DE,508
-metahq_core/util/exceptions.py,sha256=FlYUN8g4lNB3OSwQ20dfnSDmgX8NKZV5Yx7xERurrWc,115
-metahq_core/util/helpers.py,sha256=sak1A7gp2qvnbhCBYHNQ5IUxIZeljgyRSu5U7C8a7bU,949
-metahq_core/util/io.py,sha256=3JY04VjxuWA1TSx59iIQaON1LG-ZZp2zxSLkuFDoHWg,3075
-metahq_core/util/progress.py,sha256=NF158KVFO9pO3vrsl7OrPAhYtd-cXaXRavL0iOV5XeM,2128
-metahq_core/util/supported.py,sha256=RRMCaNh5xKBL8zNDW_7oR7v0bWRXyhI4FgWmiUH4_i4,10995
-metahq_core-0.1.2.dist-info/METADATA,sha256=lcjV5sxKOWdTV69O1FSgWbVN-fa4DJu7Cy1YcTCT5RI,1836
-metahq_core-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-metahq_core-0.1.2.dist-info/RECORD,,