biocypher 0.5.41__py3-none-any.whl → 0.5.43__py3-none-any.whl

biocypher/_config/biocypher_config.yaml

@@ -27,6 +27,7 @@ biocypher:
   head_ontology:
     url: https://github.com/biolink/biolink-model/raw/v3.2.1/biolink-model.owl.ttl
     root_node: entity
+    # switch_label_and_id: true
 
   ### Optional parameters ###
 
@@ -53,10 +54,12 @@ biocypher:
   #     url: test/ontologies/so.owl
   #     head_join_node: sequence variant
   #     tail_join_node: sequence_variant
+  #     switch_label_and_id: true
   #   mondo:
   #     url: test/ontologies/mondo.owl
   #     head_join_node: disease
   #     tail_join_node: disease
+  #     switch_label_and_id: true
 
 ### DBMS configuration ###
 
@@ -113,6 +116,10 @@ postgresql:
   # import_call_bin_prefix: '' # path to "psql"
   # import_call_file_prefix: '/path/to/files'
 
+rdf:
+  ### RDF configuration ###
+  rdf_format: turtle
+
 sqlite:
   ### SQLite configuration ###
 
@@ -124,3 +131,11 @@ sqlite:
   delimiter: '\t'
   # import_call_bin_prefix: '' # path to "sqlite3"
   # import_call_file_prefix: '/path/to/files'
+
+csv:
+  ### CSV/Pandas configuration ###
+  delimiter: ","
+
+networkx:
+  ### NetworkX configuration ###
+  some_config: some_value # placeholder for technical reasons TODO

biocypher/_core.py

@@ -26,17 +26,17 @@ from ._logger import logger
 
 logger.debug(f"Loading module {__name__}.")
 
-from biocypher.write._write import DBMS_TO_CLASS, get_writer
 from ._get import Downloader
 from ._config import config as _config
 from ._config import update_from_file as _file_update
 from ._create import BioCypherEdge, BioCypherNode, BioCypherRelAsNode
-from ._pandas import Pandas
-from ._connect import get_driver
 from ._mapping import OntologyMapping
 from ._ontology import Ontology
 from ._translate import Translator
 from ._deduplicate import Deduplicator
+from .output.in_memory._pandas import Pandas
+from .output.write._get_writer import DBMS_TO_CLASS, get_writer
+from .output.connect._neo4j_driver import get_driver
 
 __all__ = ["BioCypher"]
 

biocypher/_metadata.py

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

biocypher/_misc.py

@@ -115,7 +115,12 @@ def _get_inheritance_tree(inheritance_graph: Union[dict, nx.Graph]) -> dict:
         )
         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."
+                "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 wish to browse all relationships of the parsed "
+                "ontologies, write a graphml file to disk using "
+                "`to_disk = <directory>` and view this file."
             )
 
         # unlist values

biocypher/_ontology.py

@@ -43,19 +43,19 @@ class OntologyAdapter:
     ontology is represented by a networkx.DiGraph object; an RDFlib graph is
     also kept. By default, the DiGraph reverses the label and identifier of the
     nodes, such that the node name in the graph is the human-readable label. The
-    edges are oriented from child to parent. Going from the Biolink example,
-    labels are formatted in lower sentence case. In some cases, this means that
-    we replace underscores with spaces.
+    edges are oriented from child to parent.
+    Labels are formatted in lower sentence case and underscores are replaced by spaces.
+    Identifiers are taken as defined and the prefixes are removed by default.
     """
 
     def __init__(
         self,
         ontology_file: str,
         root_label: str,
-        format: Optional[str] = None,
-        head_join_node: Optional[str] = None,
+        ontology_file_format: Optional[str] = None,
+        head_join_node_label: Optional[str] = None,
         merge_nodes: Optional[bool] = True,
-        reverse_labels: bool = True,
+        switch_label_and_id: bool = True,
         remove_prefixes: bool = True,
     ):
         """
@@ -68,7 +68,10 @@ class OntologyAdapter:
             root_label (str): The label of the root node in the ontology. In
                 case of a tail ontology, this is the tail join node.
 
-            head_join_node (str): Optional variable to store the label of the
+            ontology_file_format (str): The format of the ontology file (e.g. "application/rdf+xml")
+                If format is not passed, it is determined automatically.
+
+            head_join_node_label (str): Optional variable to store the label of the
                 node in the head ontology that should be used to join to the
                 root node of the tail ontology. Defaults to None.
 
@@ -77,7 +80,7 @@ class OntologyAdapter:
                 tail join node will be attached as a child of the head join
                 node.
 
-            reverse_labels (bool): If True, the node names in the graph will be
+            switch_label_and_id (bool): If True, the node names in the graph will be
                 the human-readable labels. If False, the node names will be the
                 identifiers. Defaults to True.
 
@@ -89,33 +92,37 @@ class OntologyAdapter:
 
         self._ontology_file = ontology_file
         self._root_label = root_label
-        self._format = format
+        self._format = ontology_file_format
         self._merge_nodes = merge_nodes
-        self._head_join_node = head_join_node
-        self._reverse_labels = reverse_labels
+        self._head_join_node = head_join_node_label
+        self._switch_label_and_id = switch_label_and_id
         self._remove_prefixes = remove_prefixes
 
         self._rdf_graph = self._load_rdf_graph(ontology_file)
 
         self._nx_graph = self._rdf_to_nx(
-            self._rdf_graph, root_label, reverse_labels
+            self._rdf_graph, root_label, switch_label_and_id
         )
 
     def _rdf_to_nx(
-        self, _rdf_graph: rdflib.Graph, root_label: str, reverse_labels: bool
+        self,
+        _rdf_graph: rdflib.Graph,
+        root_label: str,
+        switch_label_and_id: bool,
+        rename_nodes: bool = True,
     ) -> nx.DiGraph:
         one_to_one_triples, one_to_many_dict = self._get_relevant_rdf_triples(
             _rdf_graph
         )
         nx_graph = self._convert_to_nx(one_to_one_triples, one_to_many_dict)
-        nx_graph_with_labels = self._add_labels_to_nodes(
-            nx_graph, reverse_labels
+        nx_graph = self._add_labels_to_nodes(nx_graph, switch_label_and_id)
+        nx_graph = self._change_nodes_to_biocypher_format(
+            nx_graph, switch_label_and_id, rename_nodes
         )
-        renamed_graph = self._rename_nodes(nx_graph_with_labels, reverse_labels)
-        filtered_graph = self._get_all_ancestors(
-            renamed_graph, root_label, reverse_labels
+        nx_graph = self._get_all_ancestors(
+            nx_graph, root_label, switch_label_and_id, rename_nodes
         )
-        return nx.DiGraph(filtered_graph)
+        return nx.DiGraph(nx_graph)
 
     def _get_relevant_rdf_triples(self, g: rdflib.Graph) -> tuple:
         one_to_one_inheritance_graph = self._get_one_to_one_inheritance_triples(
@@ -239,19 +246,21 @@ class OntologyAdapter:
         return nx_graph
 
     def _add_labels_to_nodes(
-        self, nx_graph: nx.DiGraph, reverse_labels: bool
+        self, nx_graph: nx.DiGraph, switch_label_and_id: bool
     ) -> nx.DiGraph:
         """Add labels to the nodes in the networkx graph.
 
         Args:
             nx_graph (nx.DiGraph): The networkx graph
-            reverse_labels (bool): If True, id and label are switched
+            switch_label_and_id (bool): If True, id and label are switched
 
         Returns:
             nx.DiGraph: The networkx graph with labels
         """
         for node in list(nx_graph.nodes):
-            nx_id, nx_label = self._get_nx_id_and_label(node, reverse_labels)
+            nx_id, nx_label = self._get_nx_id_and_label(
+                node, switch_label_and_id
+            )
             if nx_id == "none":
                 # remove node if it has no id
                 nx_graph.remove_node(node)
@@ -260,39 +269,56 @@ class OntologyAdapter:
             nx_graph.nodes[node]["label"] = nx_label
         return nx_graph
 
-    def _rename_nodes(
-        self, nx_graph: nx.DiGraph, reverse_labels: bool
+    def _change_nodes_to_biocypher_format(
+        self,
+        nx_graph: nx.DiGraph,
+        switch_label_and_id: bool,
+        rename_nodes: bool = True,
     ) -> nx.DiGraph:
-        """Rename the nodes in the networkx graph (remove prefix and switch id and label).
+        """Change the nodes in the networkx graph to BioCypher format:
+            - remove the prefix of the identifier
+            - switch id and label
+            - adapt the labels (replace _ with space and convert to lower sentence case)
 
         Args:
             nx_graph (nx.DiGraph): The networkx graph
-            reverse_labels (bool): If True, id and label are switched
+            switch_label_and_id (bool): If True, id and label are switched
+            rename_nodes (bool): If True, the nodes are renamed
 
         Returns:
-            nx.DiGraph: The renamed networkx graph
+            nx.DiGraph: The networkx ontology graph in BioCypher format
         """
         mapping = {
-            node: self._get_nx_id_and_label(node, reverse_labels)[0]
+            node: self._get_nx_id_and_label(
+                node, switch_label_and_id, rename_nodes
+            )[0]
             for node in nx_graph.nodes
         }
         renamed = nx.relabel_nodes(nx_graph, mapping, copy=False)
         return renamed
 
     def _get_all_ancestors(
-        self, renamed: nx.DiGraph, root_label: str, reverse_labels: bool
+        self,
+        renamed: nx.DiGraph,
+        root_label: str,
+        switch_label_and_id: bool,
+        rename_nodes: bool = True,
     ) -> nx.DiGraph:
         """Get all ancestors of the root node in the networkx graph.
 
         Args:
             renamed (nx.DiGraph): The renamed networkx graph
             root_label (str): The label of the root node in the ontology
+            switch_label_and_id (bool): If True, id and label are switched
+            rename_nodes (bool): If True, the nodes are renamed
 
         Returns:
             nx.DiGraph: The filtered networkx graph
         """
         root = self._get_nx_id_and_label(
-            self._find_root_label(self._rdf_graph, root_label), reverse_labels
+            self._find_root_label(self._rdf_graph, root_label),
+            switch_label_and_id,
+            rename_nodes,
         )[0]
         ancestors = nx.ancestors(renamed, root)
         ancestors.add(root)
@@ -300,7 +326,7 @@ class OntologyAdapter:
         return filtered_graph
 
     def _get_nx_id_and_label(
-        self, node, switch_id_and_label: bool
+        self, node, switch_id_and_label: bool, rename_nodes: bool = True
     ) -> tuple[str, str]:
         """Rename node id and label for nx graph.
 
@@ -312,10 +338,10 @@ class OntologyAdapter:
             tuple[str, str]: The renamed node id and label
         """
         node_id_str = self._remove_prefix(str(node))
-        node_label_str = str(
-            self._rdf_graph.value(node, rdflib.RDFS.label)
-        ).replace("_", " ")
-        node_label_str = to_lower_sentence_case(node_label_str)
+        node_label_str = str(self._rdf_graph.value(node, rdflib.RDFS.label))
+        if rename_nodes:
+            node_label_str = node_label_str.replace("_", " ")
+            node_label_str = to_lower_sentence_case(node_label_str)
         nx_id = node_label_str if switch_id_and_label else node_id_str
         nx_label = node_id_str if switch_id_and_label else node_label_str
         return nx_id, nx_label
@@ -330,8 +356,14 @@ class OntologyAdapter:
                 root = label_subject
                 break
         else:
+            labels_in_ontology = []
+            for label_subject, _, label_in_ontology in g.triples(
+                (None, rdflib.RDFS.label, None)
+            ):
+                labels_in_ontology.append(str(label_in_ontology))
             raise ValueError(
-                f"Could not find root node with label {root_label}"
+                f"Could not find root node with label '{root_label}'. "
+                f"The ontology contains the following labels: {labels_in_ontology}"
             )
         return root
 
@@ -398,11 +430,29 @@ class OntologyAdapter:
         """
         return self._rdf_graph
 
-    def get_root_label(self):
+    def get_root_node(self):
         """
-        Get the label of the root node in the ontology.
+        Get root node in the ontology.
+
+        Returns:
+            root_node: If _switch_label_and_id is True, the root node label is returned,
+                otherwise the root node id is returned.
         """
-        return self._root_label
+
+        root_node = None
+        root_label = self._root_label.replace("_", " ")
+
+        if self._switch_label_and_id:
+            root_node = to_lower_sentence_case(root_label)
+        elif not self._switch_label_and_id:
+            for node, data in self.get_nx_graph().nodes(data=True):
+                if "label" in data and data["label"] == to_lower_sentence_case(
+                    root_label
+                ):
+                    root_node = node
+                    break
+
+        return root_node
 
     def get_ancestors(self, node_label):
         """
@@ -465,8 +515,8 @@ class Ontology:
 
         if self._tail_ontologies:
             for adapter in self._tail_ontologies.values():
-                self._assert_join_node(adapter)
-                self._join_ontologies(adapter)
+                head_join_node = self._get_head_join_node(adapter)
+                self._join_ontologies(adapter, head_join_node)
         else:
             self._nx_graph = self._head_ontology.get_nx_graph()
 
@@ -489,7 +539,10 @@ class Ontology:
         self._head_ontology = OntologyAdapter(
             ontology_file=self._head_ontology_meta["url"],
             root_label=self._head_ontology_meta["root_node"],
-            format=self._head_ontology_meta.get("format", None),
+            ontology_file_format=self._head_ontology_meta.get("format", None),
+            switch_label_and_id=self._head_ontology_meta.get(
+                "switch_label_and_id", True
+            ),
         )
 
         if self._tail_ontology_meta:
@@ -498,12 +551,13 @@ class Ontology:
                 self._tail_ontologies[key] = OntologyAdapter(
                     ontology_file=value["url"],
                     root_label=value["tail_join_node"],
-                    head_join_node=value["head_join_node"],
-                    format=value.get("format", None),
+                    head_join_node_label=value["head_join_node"],
+                    ontology_file_format=value.get("format", None),
                     merge_nodes=value.get("merge_nodes", True),
+                    switch_label_and_id=value.get("switch_label_and_id", True),
                 )
 
-    def _assert_join_node(self, adapter: OntologyAdapter) -> None:
+    def _get_head_join_node(self, adapter: OntologyAdapter) -> str:
         """
         Tries to find the head join node of the given ontology adapter in the
         head ontology. If the join node is not found, the method will raise an
@@ -514,15 +568,41 @@ class Ontology:
                 join node in the head ontology.
         """
 
-        head_join_node = adapter.get_head_join_node()
+        head_join_node = None
+        user_defined_head_join_node_label = adapter.get_head_join_node()
+        head_join_node_label_in_bc_format = to_lower_sentence_case(
+            user_defined_head_join_node_label.replace("_", " ")
+        )
+
+        if self._head_ontology._switch_label_and_id:
+            head_join_node = head_join_node_label_in_bc_format
+        elif not self._head_ontology._switch_label_and_id:
+            for node_id, data in self._head_ontology.get_nx_graph().nodes(
+                data=True
+            ):
+                if (
+                    "label" in data
+                    and data["label"] == head_join_node_label_in_bc_format
+                ):
+                    head_join_node = node_id
+                    break
 
         if head_join_node not in self._head_ontology.get_nx_graph().nodes:
+            head_ontology = self._head_ontology._rdf_to_nx(
+                self._head_ontology.get_rdf_graph(),
+                self._head_ontology._root_label,
+                self._head_ontology._switch_label_and_id,
+                rename_nodes=False,
+            )
             raise ValueError(
-                f"Head join node {head_join_node} not found in "
-                f"head ontology."
+                f"Head join node '{head_join_node}' not found in head ontology. "
+                f"The head ontology contains the following nodes: {head_ontology.nodes}."
             )
+        return head_join_node
 
-    def _join_ontologies(self, adapter: OntologyAdapter) -> None:
+    def _join_ontologies(
+        self, adapter: OntologyAdapter, head_join_node
+    ) -> None:
         """
         Joins the ontologies by adding the tail ontology as a subgraph to the
         head ontology at the specified join nodes.
@@ -535,8 +615,7 @@ class Ontology:
         if not self._nx_graph:
             self._nx_graph = self._head_ontology.get_nx_graph().copy()
 
-        head_join_node = to_lower_sentence_case(adapter.get_head_join_node())
-        tail_join_node = to_lower_sentence_case(adapter.get_root_label())
+        tail_join_node = adapter.get_root_node()
         tail_ontology = adapter.get_nx_graph()
 
         # subtree of tail ontology at join node
@@ -695,8 +774,9 @@ class Ontology:
         Args:
 
             to_disk (str): If specified, the ontology structure will be saved
-                to disk as a GRAPHML file, to be opened in your favourite
-                graph visualisation tool.
+                to disk as a GRAPHML file at the location (directory) specified
+                by the `to_disk` string, to be opened in your favourite graph
+                visualisation tool.
 
             full (bool): If True, the full ontology structure will be shown,
                 including all nodes and edges. If False, only the nodes and

biocypher/{_connect.py → output/connect/_neo4j_driver.py}

@@ -13,7 +13,7 @@ BioCypher 'online' mode. Handles connection and manipulation of a running DBMS.
 """
 import subprocess
 
-from ._logger import logger
+from biocypher._logger import logger
 
 logger.debug(f"Loading module {__name__}.")
 
@@ -22,10 +22,10 @@ import itertools
 
 import neo4j_utils
 
-from . import _misc
-from ._config import config as _config
-from ._create import BioCypherEdge, BioCypherNode
-from ._translate import Translator
+from biocypher import _misc
+from biocypher._config import config as _config
+from biocypher._create import BioCypherEdge, BioCypherNode
+from biocypher._translate import Translator
 
 __all__ = ["_Neo4jDriver"]
 

biocypher/{_pandas.py → output/in_memory/_pandas.py}

@@ -1,6 +1,6 @@
 import pandas as pd
 
-from ._create import BioCypherEdge, BioCypherNode, BioCypherRelAsNode
+from biocypher._create import BioCypherEdge, BioCypherNode, BioCypherRelAsNode
 
 
 class Pandas:
@@ -87,3 +87,4 @@ class Pandas:
             self.dfs[_type] = pd.concat(
                 [self.dfs[_type], df], ignore_index=True
             )
+        return self.dfs[_type]

biocypher/{write → output/write}/_batch_writer.py

@@ -12,9 +12,12 @@ from biocypher._create import BioCypherEdge, BioCypherNode, BioCypherRelAsNode
 from biocypher._logger import logger
 from biocypher._translate import Translator
 from biocypher._deduplicate import Deduplicator
+from biocypher.output.write._writer import _Writer
 
 
-class _BatchWriter(ABC):
+class _BatchWriter(_Writer, ABC):
+    """Abstract batch writer class"""
+
     @abstractmethod
     def _get_default_import_call_bin_prefix(self):
         """
@@ -40,7 +43,7 @@ class _BatchWriter(ABC):
             str: The database-specific string representation of an array
         """
         raise NotImplementedError(
-            "Database writer must override '_write_node_headers'"
+            "Database writer must override '_write_array_string'"
         )
 
     @abstractmethod
@@ -117,6 +120,8 @@ class _BatchWriter(ABC):
         db_password: str = None,
         db_host: str = None,
         db_port: str = None,
+        rdf_format: str = None,
+        rdf_namespaces: dict = {},
     ):
         """
 
@@ -196,12 +201,26 @@ class _BatchWriter(ABC):
 
             db_port:
                 The database port.
+
+            rdf_format:
+                The format of RDF.
+
+            rdf_namespaces:
+                The namespaces for RDF.
         """
+        super().__init__(
+            translator=translator,
+            deduplicator=deduplicator,
+            output_directory=output_directory,
+            strict_mode=strict_mode,
+        )
         self.db_name = db_name
         self.db_user = db_user
         self.db_password = db_password
         self.db_host = db_host or "localhost"
         self.db_port = db_port
+        self.rdf_format = rdf_format
+        self.rdf_namespaces = rdf_namespaces
 
         self.delim, self.escaped_delim = self._process_delimiter(delimiter)
         self.adelim, self.escaped_adelim = self._process_delimiter(
@@ -228,32 +247,15 @@ class _BatchWriter(ABC):
         self.import_call_nodes = set()
         self.import_call_edges = set()
 
-        self._outdir = output_directory
+        self.outdir = output_directory
 
         self._import_call_file_prefix = import_call_file_prefix
 
-        if os.path.exists(self.outdir):
-            logger.warning(
-                f"Output directory `{self.outdir}` already exists. "
-                "If this is not planned, file consistency may be compromised."
-            )
-        else:
-            logger.info(f"Creating output directory `{self.outdir}`.")
-            os.makedirs(self.outdir)
-
         self.parts = {}  # dict to store the paths of part files for each label
 
         # TODO not memory efficient, but should be fine for most cases; is
         # there a more elegant solution?
 
-    @property
-    def outdir(self):
-        """
-        Property for output directory path.
-        """
-
-        return self._outdir
-
     @property
     def import_call_file_prefix(self):
         """
@@ -261,7 +263,7 @@ class _BatchWriter(ABC):
         """
 
         if self._import_call_file_prefix is None:
-            return self._outdir
+            return self.outdir
         else:
             return self._import_call_file_prefix
 
@@ -994,7 +996,9 @@ class _BatchWriter(ABC):
         """
 
         file_path = os.path.join(self.outdir, self._get_import_script_name())
-        logger.info(f"Writing {self.db_name} import call to `{file_path}`.")
+        logger.info(
+            f"Writing {self.db_name + ' ' if self.db_name else ''}import call to `{file_path}`."
+        )
 
         with open(file_path, "w", encoding="utf-8") as f:
             f.write(self._construct_import_call())

biocypher/{write/_write.py → output/write/_get_writer.py}

@@ -14,10 +14,13 @@ suitable for import into a DBMS.
 """
 
 from biocypher._logger import logger
-from biocypher.write.graph._neo4j import _Neo4jBatchWriter
-from biocypher.write.graph._arangodb import _ArangoDBBatchWriter
-from biocypher.write.relational._sqlite import _SQLiteBatchWriter
-from biocypher.write.relational._postgresql import _PostgreSQLBatchWriter
+from biocypher.output.write.graph._rdf import _RDFWriter
+from biocypher.output.write.graph._neo4j import _Neo4jBatchWriter
+from biocypher.output.write.graph._arangodb import _ArangoDBBatchWriter
+from biocypher.output.write.graph._networkx import _NetworkXWriter
+from biocypher.output.write.relational._csv import _PandasCSVWriter
+from biocypher.output.write.relational._sqlite import _SQLiteBatchWriter
+from biocypher.output.write.relational._postgresql import _PostgreSQLBatchWriter
 
 logger.debug(f"Loading module {__name__}.")
 
@@ -43,6 +46,14 @@ DBMS_TO_CLASS = {
     "ArangoDB": _ArangoDBBatchWriter,
     "sqlite": _SQLiteBatchWriter,
     "sqlite3": _SQLiteBatchWriter,
+    "rdf": _RDFWriter,
+    "RDF": _RDFWriter,
+    "csv": _PandasCSVWriter,
+    "CSV": _PandasCSVWriter,
+    "pandas": _PandasCSVWriter,
+    "Pandas": _PandasCSVWriter,
+    "networkx": _NetworkXWriter,
+    "NetworkX": _NetworkXWriter,
 }
 
 
@@ -58,19 +69,14 @@ def get_writer(
     file.
 
     Args:
-
         dbms: the database management system; for options, see DBMS_TO_CLASS.
-
         translator: the Translator object.
-
-        output_directory: the directory to write the output files to.
-
+        deduplicator: the Deduplicator object.
+        output_directory: the directory to output.write the output files to.
         strict_mode: whether to use strict mode.
 
     Returns:
-
         instance: an instance of the selected writer class.
-
     """
 
     dbms_config = _config(dbms)
@@ -102,4 +108,6 @@ def get_writer(
             db_user=dbms_config.get("user"),  # psql
             db_password=dbms_config.get("password"),  # psql
             db_port=dbms_config.get("port"),  # psql
+            rdf_format=dbms_config.get("rdf_format"),  # rdf
+            rdf_namespaces=dbms_config.get("rdf_namespaces"),  # rdf
         )