biocypher 0.5.35__py3-none-any.whl → 0.5.37__py3-none-any.whl

biocypher/_logger.py

@@ -48,7 +48,7 @@ def get_logger(name: str = "biocypher") -> logging.Logger:
         # create logger
         logger = logging.getLogger(name)
         logger.setLevel(logging.DEBUG)
-        logger.propagate = False
+        logger.propagate = True
 
         # formatting
         file_formatter = logging.Formatter(

biocypher/_metadata.py

@@ -19,7 +19,7 @@ import importlib.metadata
 
 import toml
 
-_VERSION = "0.5.35"
+_VERSION = "0.5.37"
 
 
 def get_metadata():

biocypher/_misc.py

@@ -76,56 +76,80 @@ def ensure_iterable(value: Any) -> Iterable:
     return value if isinstance(value, LIST_LIKE) else (value,)
 
 
-def create_tree_visualisation(inheritance_tree: Union[dict, nx.Graph]) -> str:
+def create_tree_visualisation(inheritance_graph: Union[dict, nx.Graph]) -> Tree:
     """
     Creates a visualisation of the inheritance tree using treelib.
     """
+    inheritance_tree = _get_inheritance_tree(inheritance_graph)
+    classes, root = _find_root_node(inheritance_tree)
+
+    tree = Tree()
+    tree.create_node(root, root)
+    while classes:
+        for child in classes:
+            parent = inheritance_tree[child]
+            if parent in tree.nodes.keys() or parent == root:
+                tree.create_node(child, child, parent=parent)
+
+        for node in tree.nodes.keys():
+            if node in classes:
+                classes.remove(node)
+
+    return tree
+
+
+def _get_inheritance_tree(inheritance_graph: Union[dict, nx.Graph]) -> dict:
+    """Transforms an inheritance_graph into an inheritance_tree.
+
+    Args:
+        inheritance_graph: A dict or nx.Graph representing the inheritance graph.
+
+    Returns:
+        A dict representing the inheritance tree.
+    """
+    if isinstance(inheritance_graph, nx.Graph):
+        inheritance_tree = nx.to_dict_of_lists(inheritance_graph)
+
+        multiple_parents_present = _multiple_inheritance_present(
+            inheritance_tree
+        )
+        if multiple_parents_present:
+            logger.warning(
+                "The ontology contains multiple inheritance (one child node has multiple parent nodes). This is not visualized in the following hierarchy tree (the child node is only added once). If you want to browse all relationships of the parsed ontology write a graphml file to disk and view this file."
+            )
 
-    if isinstance(inheritance_tree, nx.Graph):
-        inheritance_tree = nx.to_dict_of_lists(inheritance_tree)
         # unlist values
         inheritance_tree = {k: v[0] for k, v in inheritance_tree.items() if v}
+        return inheritance_tree
+    elif not _multiple_inheritance_present(inheritance_graph):
+        return inheritance_graph
+
 
-    # find root node
+def _multiple_inheritance_present(inheritance_tree: dict) -> bool:
+    """Checks if multiple inheritance is present in the inheritance_tree."""
+    return any(len(value) > 1 for value in inheritance_tree.values())
+
+
+def _find_root_node(inheritance_tree: dict) -> tuple[set, str]:
     classes = set(inheritance_tree.keys())
     parents = set(inheritance_tree.values())
     root = list(parents - classes)
-
     if len(root) > 1:
         if "entity" in root:
-            root = "entity"  # default: good standard? TODO
-
+            root = "entity"  # TODO: default: good standard?
         else:
             raise ValueError(
                 "Inheritance tree cannot have more than one root node. "
                 f"Found {len(root)}: {root}."
             )
-
     else:
         root = root[0]
-
     if not root:
         # find key whose value is None
         root = list(inheritance_tree.keys())[
             list(inheritance_tree.values()).index(None)
         ]
-
-    tree = Tree()
-
-    tree.create_node(root, root)
-
-    while classes:
-        for child in classes:
-            parent = inheritance_tree[child]
-
-            if parent in tree.nodes.keys() or parent == root:
-                tree.create_node(child, child, parent=parent)
-
-        for node in tree.nodes.keys():
-            if node in classes:
-                classes.remove(node)
-
-    return tree
+    return classes, root
 
 
 # string conversion, adapted from Biolink Model Toolkit

biocypher/_ontology.py

@@ -93,7 +93,7 @@ class OntologyAdapter:
         self._reverse_labels = reverse_labels
         self._remove_prefixes = remove_prefixes
 
-        # Load the ontology into an rdflib Graph according to the file extension
+        # Load the ontology into a rdflib Graph according to the file extension
         self._rdf_graph = self._load_rdf_graph(ontology_file)
 
         self._nx_graph = self._rdf_to_nx(
@@ -107,56 +107,77 @@ class OntologyAdapter:
         G = nx.DiGraph()
 
         # Define a recursive function to add subclasses to the graph
-        def add_subclasses(node):
-            # Only add nodes that have a label
-            if (node, rdflib.RDFS.label, None) not in g:
+        def add_subclasses(parent_node):
+            if not has_label(parent_node, g):
                 return
 
-            nx_id, nx_label = _get_nx_id_and_label(node)
-
-            if nx_id not in G:
-                G.add_node(nx_id)
-                G.nodes[nx_id]["label"] = nx_label
-
-            # Recursively add all subclasses of the node to the graph
-            for s, _, o in g.triples((None, rdflib.RDFS.subClassOf, node)):
-                # Only add nodes that have a label
-                if (s, rdflib.RDFS.label, None) not in g:
-                    continue
-
-                s_id, s_label = _get_nx_id_and_label(s)
-                G.add_node(s_id)
-                G.nodes[s_id]["label"] = s_label
+            nx_parent_node_id, nx_parent_node_label = _get_nx_id_and_label(
+                parent_node
+            )
 
-                G.add_edge(s_id, nx_id)
-                add_subclasses(s)
-                add_parents(s)
+            if nx_parent_node_id not in G:
+                add_node(nx_parent_node_id, nx_parent_node_label)
+
+            child_nodes = get_child_nodes(parent_node, g)
+
+            if child_nodes:
+                for child_node in child_nodes:
+                    if not has_label(child_node, g):
+                        continue
+                    (
+                        nx_child_node_id,
+                        nx_child_node_label,
+                    ) = _get_nx_id_and_label(child_node)
+                    add_node(nx_child_node_id, nx_child_node_label)
+                    G.add_edge(nx_child_node_id, nx_parent_node_id)
+                for child_node in child_nodes:
+                    add_subclasses(child_node)
+                    add_parents(child_node)
 
         def add_parents(node):
-            # Only add nodes that have a label
-            if (node, rdflib.RDFS.label, None) not in g:
+            if not has_label(node, g):
                 return
 
             nx_id, nx_label = _get_nx_id_and_label(node)
 
             # Recursively add all parents of the node to the graph
             for s, _, o in g.triples((node, rdflib.RDFS.subClassOf, None)):
-                # Only add nodes that have a label
-                if (o, rdflib.RDFS.label, None) not in g:
+                if not has_label(o, g):
                     continue
 
                 o_id, o_label = _get_nx_id_and_label(o)
 
-                # Skip nodes already in the graph
+                # Skip if node already in the graph
                 if o_id in G:
                     continue
 
-                G.add_node(o_id)
-                G.nodes[o_id]["label"] = o_label
+                add_node(o_id, o_label)
 
                 G.add_edge(nx_id, o_id)
                 add_parents(o)
 
+        def has_label(node: rdflib.URIRef, g: rdflib.Graph) -> bool:
+            """Does the node have a label in g?
+
+            Args:
+                node (rdflib.URIRef): The node to check
+                g (rdflib.Graph): The graph to check in
+
+            Returns:
+                bool: True if the node has a label, False otherwise
+            """
+            return (node, rdflib.RDFS.label, None) in g
+
+        def add_node(nx_node_id: str, nx_node_label: str):
+            """Add a node to the graph.
+
+            Args:
+                nx_node_id (str): The ID of the node
+                nx_node_label (str): The label of the node
+            """
+            G.add_node(nx_node_id)
+            G.nodes[nx_node_id]["label"] = nx_node_label
+
         def _get_nx_id_and_label(node):
             node_id_str = self._remove_prefix(str(node))
             node_label_str = str(g.value(node, rdflib.RDFS.label)).replace(
@@ -168,6 +189,79 @@ class OntologyAdapter:
             nx_label = node_id_str if switch_id_and_label else node_label_str
             return nx_id, nx_label
 
+        def get_child_nodes(
+            parent_node: rdflib.URIRef, g: rdflib.Graph
+        ) -> list:
+            """Get the child nodes of a node in the ontology.
+            Accounts for the case of multiple parents defined in intersectionOf.
+
+            Args:
+                parent_node (rdflib.URIRef): The parent node to get the children of
+                g (rdflib.Graph): The graph to get the children from
+
+            Returns:
+                list: A list of the child nodes
+            """
+            child_nodes = []
+            for s, p, o in g.triples((None, rdflib.RDFS.subClassOf, None)):
+                if (o, rdflib.RDF.type, rdflib.OWL.Class) in g and (
+                    o,
+                    rdflib.OWL.intersectionOf,
+                    None,
+                ) in g:
+                    # Check if node has multiple parent nodes defined in intersectionOf (one of them = parent_node)
+                    parent_nodes = get_nodes_in_intersectionof(o)
+                    if parent_node in parent_nodes:
+                        child_nodes.append(s)
+                        for node in parent_nodes:
+                            add_parents(node)
+                elif o == parent_node:
+                    # only one parent node
+                    child_nodes.append(s)
+            return child_nodes
+
+        def get_nodes_in_intersectionof(o: rdflib.URIRef) -> list:
+            """Get the nodes in an intersectionOf node.
+
+            Args:
+                o (rdflib.URIRef): The intersectionOf node
+
+            Returns:
+                list: A list of the nodes in the intersectionOf node
+            """
+            anonymous_intersection_nodes = []
+            for _, _, anonymous_object in g.triples(
+                (o, rdflib.OWL.intersectionOf, None)
+            ):
+                anonymous_intersection_nodes.append(anonymous_object)
+            anonymous_intersection_node = anonymous_intersection_nodes[0]
+            nodes_in_intersection = retrieve_rdf_linked_list(
+                anonymous_intersection_node
+            )
+            return nodes_in_intersection
+
+        def retrieve_rdf_linked_list(subject: rdflib.URIRef) -> list:
+            """Recursively retrieves a linked list from RDF.
+            Example RDF list with the items [item1, item2]:
+            list_node - first -> item1
+            list_node - rest -> list_node2
+            list_node2 - first -> item2
+            list_node2 - rest -> nil
+
+            Args:
+                subject (rdflib.URIRef): One list_node of the RDF list
+
+            Returns:
+                list: The items of the RDF list
+            """
+            rdf_list = []
+            for s, p, o in g.triples((subject, rdflib.RDF.first, None)):
+                rdf_list.append(o)
+            for s, p, o in g.triples((subject, rdflib.RDF.rest, None)):
+                if o != rdflib.RDF.nil:
+                    rdf_list.extend(retrieve_rdf_linked_list(o))
+            return rdf_list
+
         # Add all subclasses of the root node to the graph
         add_subclasses(root)
 

biocypher/_write.py

@@ -13,6 +13,7 @@ BioCypher 'offline' module. Handles the writing of node and edge representations
 suitable for import into a DBMS.
 """
 
+import re
 import glob
 
 from ._logger import logger
@@ -22,7 +23,6 @@ logger.debug(f"Loading module {__name__}.")
 from abc import ABC, abstractmethod
 from types import GeneratorType
 from typing import TYPE_CHECKING, Union, Optional
-from datetime import datetime
 from collections import OrderedDict, defaultdict
 import os
 
@@ -34,7 +34,6 @@ from ._create import BioCypherEdge, BioCypherNode, BioCypherRelAsNode
 __all__ = ["get_writer"]
 
 if TYPE_CHECKING:
-    from ._ontology import Ontology
     from ._translate import Translator
     from ._deduplicate import Deduplicator
 
@@ -954,7 +953,9 @@ class _BatchWriter(ABC):
             bool: The return value. True for success, False otherwise.
         """
         # translate label to PascalCase
-        label_pascal = self.translator.name_sentence_to_pascal(label)
+        label_pascal = self.translator.name_sentence_to_pascal(
+            parse_label(label)
+        )
 
         # list files in self.outdir
         files = glob.glob(
@@ -1086,7 +1087,9 @@ class _Neo4jBatchWriter(_BatchWriter):
             _id = ":ID"
 
             # translate label to PascalCase
-            pascal_label = self.translator.name_sentence_to_pascal(label)
+            pascal_label = self.translator.name_sentence_to_pascal(
+                parse_label(label)
+            )
 
             header = f"{pascal_label}-header.csv"
             header_path = os.path.join(
@@ -1165,7 +1168,9 @@ class _Neo4jBatchWriter(_BatchWriter):
 
         for label, props in self.edge_property_dict.items():
             # translate label to PascalCase
-            pascal_label = self.translator.name_sentence_to_pascal(label)
+            pascal_label = self.translator.name_sentence_to_pascal(
+                parse_label(label)
+            )
 
             # paths
             header = f"{pascal_label}-header.csv"
@@ -1310,6 +1315,43 @@ class _Neo4jBatchWriter(_BatchWriter):
         return import_call
 
 
+def parse_label(label: str) -> str:
+    """
+
+    Check if the label is compliant with Neo4j naming conventions,
+    https://neo4j.com/docs/cypher-manual/current/syntax/naming/, and if not,
+    remove non-compliant characters.
+
+    Args:
+        label (str): The label to check
+    Returns:
+        str: The compliant label
+    """
+    # Check if the name contains only alphanumeric characters, underscore, or dollar sign
+    # and dot (for class hierarchy of BioCypher)
+    allowed_chars = r"a-zA-Z0-9_$ ."
+    matches = re.findall(f"[{allowed_chars}]", label)
+    non_matches = re.findall(f"[^{allowed_chars}]", label)
+    if non_matches:
+        non_matches = list(set(non_matches))
+        logger.warning(
+            f"Label is not compliant with Neo4j naming rules. Removed non compliant characters: {non_matches}"
+        )
+
+    def first_character_compliant(character: str) -> bool:
+        return character.isalpha() or character == "$"
+
+    if not first_character_compliant(matches[0]):
+        for c in matches:
+            if first_character_compliant(c):
+                matches = matches[matches.index(c) :]
+                break
+        logger.warning(
+            "Label does not start with an alphabetic character or with $. Removed non compliant characters."
+        )
+    return "".join(matches).strip()
+
+
 class _ArangoDBBatchWriter(_Neo4jBatchWriter):
     """
     Class for writing node and edge representations to disk using the format

{biocypher-0.5.35.dist-info → biocypher-0.5.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: biocypher
-Version: 0.5.35
+Version: 0.5.37
 Summary: A unifying framework for biomedical research knowledge graphs
 Home-page: https://github.com/biocypher/biocypher
 License: MIT

{biocypher-0.5.35.dist-info → biocypher-0.5.37.dist-info}/RECORD

@@ -10,15 +10,15 @@ biocypher/_core.py,sha256=2o3hhhM6kfaZI6TU3ZmzoBJc-RJgFFGWGe0MZW-oA3U,22301
 biocypher/_create.py,sha256=vpUchUdEpWupZi1LgFLxAWMtqoBwnWbP7PwEDUCBS4A,10202
 biocypher/_deduplicate.py,sha256=BBvfpXzu6L5YDY5FdtXxnf8YlsbJpbCE8RdUoKsm0n0,4949
 biocypher/_get.py,sha256=3Kpky3blfNf1JwxKWLsZxTU2aTP_C4sUe8OpiyYj63I,10810
-biocypher/_logger.py,sha256=rEn_-ESh9cPxk6vdWZ1a25escCWHBWX4D1gtpNowyvI,3186
+biocypher/_logger.py,sha256=NGXe3hZA79WSujfOgpcxHBf8N2QAfrmvM1LFDpsGK2U,3185
 biocypher/_mapping.py,sha256=ERSNH2Bg19145KytxbFE4BInPaiP-LWW7osOBot29Eo,9304
-biocypher/_metadata.py,sha256=a3jidpC5ah-BbwXswfG9q21ifIobi_4q6ztctXQbrbg,1658
-biocypher/_misc.py,sha256=wsjGVOqBDVM5hxbE_TEaZ69u1kJc8HXwRAtQHUgE8XQ,4545
-biocypher/_ontology.py,sha256=di0_v5Z99bmv4iiBybbdwZDKGIP05jof0nRL3OED2pw,23047
+biocypher/_metadata.py,sha256=-yWk0B2JDJXt34dPea_5x4t2YASfP8wc6iRVvRKdB1A,1658
+biocypher/_misc.py,sha256=g5B-PO_XJlYEJC7kEVRdCXeB2NW0ZSVr_5KqTEk2ldk,5877
+biocypher/_ontology.py,sha256=53hHroH4K9MbwueK2pAbdkidMRBVH2adlQ66QbI_BiE,26734
 biocypher/_pandas.py,sha256=GVCFM68J7yBjh40MpkNVgD8qT1RFMrrIjMOtD3iKsf4,3040
 biocypher/_translate.py,sha256=nj4Y60F0U3JBH36N2dh5pFcC8Ot86rskJ2ChJwje9dI,16494
-biocypher/_write.py,sha256=nvb75OwElu8fLUp0FjEBqQ1VNpx6iRrk-t7v_TOlDhg,68165
-biocypher-0.5.35.dist-info/LICENSE,sha256=SjUaQkq671iQUZOxEUpC4jvJxXOlfSiHTTueyz9kXJM,1065
-biocypher-0.5.35.dist-info/METADATA,sha256=vYgbyXQI7F633kx5IPZDZQ1wSpw1nyLS07OEUK8dHts,10573
-biocypher-0.5.35.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
-biocypher-0.5.35.dist-info/RECORD,,
+biocypher/_write.py,sha256=EjAnNzayVKvBuIVLw3gY8T9fTnfIPaTGODu275IaRJ8,69554
+biocypher-0.5.37.dist-info/LICENSE,sha256=SjUaQkq671iQUZOxEUpC4jvJxXOlfSiHTTueyz9kXJM,1065
+biocypher-0.5.37.dist-info/METADATA,sha256=iD1g7a9FH1JRfhVynse5qctOAsazZxa0_YDxr-OCDkc,10573
+biocypher-0.5.37.dist-info/WHEEL,sha256=Zb28QaM1gQi8f4VCBhsUklF61CTlNYfs9YAZn-TOGFk,88
+biocypher-0.5.37.dist-info/RECORD,,