biocypher 0.5.41__tar.gz → 0.5.42__tar.gz

{biocypher-0.5.41 → biocypher-0.5.42}/PKG-INFO

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

{biocypher-0.5.41 → biocypher-0.5.42}/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 ###
 

{biocypher-0.5.41 → biocypher-0.5.42}/biocypher/_metadata.py

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

{biocypher-0.5.41 → biocypher-0.5.42}/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-0.5.41 → biocypher-0.5.42}/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-0.5.41 → biocypher-0.5.42}/biocypher/write/_batch_writer.py

@@ -6,6 +6,7 @@ import os
 import re
 import glob
 
+from rdflib import Graph
 from more_itertools import peekable
 
 from biocypher._create import BioCypherEdge, BioCypherNode, BioCypherRelAsNode
@@ -117,6 +118,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 +199,20 @@ class _BatchWriter(ABC):
 
             db_port:
                 The database port.
+
+            rdf_format:
+                The format of RDF.
+
+            rdf_namespaces:
+                The namespaces for RDF.
         """
         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(

{biocypher-0.5.41 → biocypher-0.5.42}/biocypher/write/_write.py

@@ -14,6 +14,7 @@ suitable for import into a DBMS.
 """
 
 from biocypher._logger import logger
+from biocypher.write.graph._rdf import _RDFWriter
 from biocypher.write.graph._neo4j import _Neo4jBatchWriter
 from biocypher.write.graph._arangodb import _ArangoDBBatchWriter
 from biocypher.write.relational._sqlite import _SQLiteBatchWriter
@@ -43,6 +44,8 @@ DBMS_TO_CLASS = {
     "ArangoDB": _ArangoDBBatchWriter,
     "sqlite": _SQLiteBatchWriter,
     "sqlite3": _SQLiteBatchWriter,
+    "rdf": _RDFWriter,
+    "RDF": _RDFWriter,
 }
 
 
@@ -102,4 +105,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
         )

biocypher-0.5.42/biocypher/write/graph/_rdf.py

@@ -0,0 +1,516 @@
+#!/usr/bin/env python
+
+#
+# Copyright 2021, Heidelberg University Clinic
+#
+# File author(s):  Loes van den Biggelaar
+#                  Sebastian Lobentanzer
+#
+# Distributed under MIT licence, see the file `LICENSE`.
+#
+"""
+BioCypher 'offline' module. Handles the writing of node and edge representations
+suitable for import into a DBMS.
+"""
+from types import GeneratorType
+from typing import Union
+import os
+
+from rdflib import DC, RDF, RDFS, SKOS, DCTERMS, Graph, Literal, Namespace
+from rdflib.namespace import (
+    _NAMESPACE_PREFIXES_CORE,
+    _NAMESPACE_PREFIXES_RDFLIB,
+)
+
+from biocypher._create import BioCypherEdge, BioCypherNode
+from biocypher._logger import logger
+from biocypher.write._batch_writer import _BatchWriter
+
+
+class _RDFWriter(_BatchWriter):
+
+    """
+    Class to write BioCypher's property graph into an RDF format using
+    rdflib and all the extensions it supports (RDF/XML, N3, NTriples,
+    N-Quads, Turtle, TriX, Trig and JSON-LD). By default the conversion
+    is done keeping only the minimum information about node and edges,
+    skipping all properties.
+    """
+
+    def _get_import_script_name(self) -> str:
+        """
+        Returns the name of the RDF admin import script.
+        This function applicable for RDF export.
+
+        Returns:
+            str: The name of the import script (ending in .sh)
+        """
+        return "rdf-import-call.sh"
+
+    def _get_default_import_call_bin_prefix(self):
+        """
+        Method to provide the default string for the import call bin prefix.
+
+        Returns:
+            str: The default location for the RDF admin import location
+        """
+        return "bin/"
+
+    def _is_rdf_format_supported(self, rdf_format: str) -> bool:
+        """
+        Function to check if the specified RDF format is supported.
+
+        Args:
+            rdf_format (str): The RDF format to check.
+
+        Returns:
+            bool: Returns True if rdf format supported, False otherwise.
+        """
+        supported_formats = [
+            "xml",
+            "n3",
+            "turtle",
+            "nt",
+            "pretty-xml",
+            "trix",
+            "trig",
+            "nquads",
+            "json-ld",
+        ]
+        if rdf_format not in supported_formats:
+            logger.error(
+                f"{rdf_format}; Incorrect or unsupported RDF format, use one of the following: "
+                f'"xml", "n3", "turtle", "nt", "pretty-xml", "trix", "trig", "nquads", "json-ld" ',
+            )
+            return False
+        else:
+            # RDF graph does not support 'ttl' format, only 'turtle' format. however, the preferred file extension is always '.ttl'
+            if self.rdf_format == "turtle":
+                self.extension = "ttl"
+            elif self.rdf_format == "ttl":
+                self.rdf_format = "turtle"
+                self.extension = "ttl"
+            else:
+                self.extension = self.rdf_format
+            return True
+
+    def _write_single_edge_list_to_file(
+        self,
+        edge_list: list,
+        label: str,
+        prop_dict: dict,
+    ):
+        """
+        This function takes one list of biocypher edges and writes them
+        to an RDF file with the given format.
+
+        Args:
+            edge_list (list): list of BioCypherEdges to be written
+
+            label (str): the label (type) of the edge
+
+            prop_dict (dict): properties of node class passed from parsing
+                function and their types
+
+        Returns:
+            bool: The return value. True for success, False otherwise.
+        """
+
+        if not all(isinstance(n, BioCypherEdge) for n in edge_list):
+            logger.error("Edges must be passed as type BioCypherEdge.")
+            return False
+
+        # translate label to PascalCase
+        label_pascal = self.translator.name_sentence_to_pascal(label)
+
+        # create file name
+        file_name = os.path.join(
+            self._outdir, f"{label_pascal}.{self.extension}"
+        )
+
+        # write data in graph
+        graph = Graph()
+        self._init_namespaces(graph)
+
+        for edge in edge_list:
+            rdf_subject = edge.get_source_id()
+            rdf_object = edge.get_target_id()
+            rdf_predicate = edge.get_id()
+            rdf_properties = edge.get_properties()
+            if rdf_predicate == None:
+                rdf_predicate = rdf_subject + rdf_object
+
+            edge_label = self.translator.name_sentence_to_pascal(
+                edge.get_label()
+            )
+            edge_uri = self.rdf_namespaces["biocypher"][edge_label]
+            graph.add((edge_uri, RDF.type, RDFS.Class))
+            graph.add(
+                (
+                    self.rdf_namespaces["biocypher"][rdf_predicate],
+                    RDF.type,
+                    edge_uri,
+                )
+            )
+            graph.add(
+                (
+                    self.rdf_namespaces["biocypher"][rdf_predicate],
+                    self.rdf_namespaces["biocypher"]["subject"],
+                    self.subject_to_uri(rdf_subject),
+                )
+            )
+            graph.add(
+                (
+                    self.rdf_namespaces["biocypher"][rdf_predicate],
+                    self.rdf_namespaces["biocypher"]["object"],
+                    self.subject_to_uri(rdf_object),
+                )
+            )
+
+            # add properties to the transformed edge --> node
+            for key, value in rdf_properties.items():
+                # only write value if it exists.
+                if value:
+                    self.add_property_to_graph(graph, rdf_predicate, value, key)
+
+        graph.serialize(destination=file_name, format=self.rdf_format)
+
+        logger.info(
+            f"Writing {len(edge_list)} entries to {label_pascal}.{self.rdf_format}",
+        )
+
+        return True
+
+    def add_property_to_graph(
+        self,
+        graph: Graph,
+        rdf_subject: str,
+        rdf_object: str,
+        rdf_predicate: str,
+    ):
+        """
+        Function to add the properties to an RDF node. It takes the graph, the subject, object, and predicate of the RDF triple.
+        It checks if the property is a list and adds it to the graph accordingly. otherwise it checks if the string represents a list.
+        If it does, it transforms it to a list and adds it to the graph. if not, it adds the property to the graph as a literal.
+        If the property is neither a list or string, it will also be added as a literal.
+
+        Args:
+            graph (RDFLib.Graph): The RDF graph to add the nodes to.
+
+            rdf_subject (str): The subject of the RDF triple.
+
+            rdf_object (str): The object of the RDF triple.
+
+            rdf_predicate (str): The predicate of the RDF triple.
+
+        Returns:
+            None
+        """
+        if isinstance(rdf_object, list):
+            for obj in rdf_object:
+                graph.add(
+                    (
+                        self.subject_to_uri(rdf_subject),
+                        self.property_to_uri(rdf_predicate),
+                        Literal(obj),
+                    )
+                )
+        elif isinstance(rdf_object, str):
+            if rdf_object.startswith("[") and rdf_object.endswith("]"):
+                self.add_property_to_graph(
+                    graph,
+                    rdf_subject,
+                    self.transform_string_to_list(rdf_object),
+                    rdf_predicate,
+                )
+            else:
+                graph.add(
+                    (
+                        self.subject_to_uri(rdf_subject),
+                        self.property_to_uri(rdf_predicate),
+                        Literal(rdf_object),
+                    )
+                )
+        else:
+            graph.add(
+                (
+                    self.subject_to_uri(rdf_subject),
+                    self.property_to_uri(rdf_predicate),
+                    Literal(rdf_object),
+                )
+            )
+
+    def transform_string_to_list(self, string_list: str) -> list:
+        """
+        Function to transform a string representation of a list into a list.
+
+        Args:
+            string_list (str): The string representation of the list.
+
+        Returns:
+            list: The list representation of the input string.
+        """
+        return (
+            string_list.replace("[", "")
+            .replace("]", "")
+            .replace("'", "")
+            .split(", ")
+        )
+
+    def _write_single_node_list_to_file(
+        self,
+        node_list: list,
+        label: str,
+        prop_dict: dict,
+        labels: str,
+    ):
+        """
+        This function takes a list of BioCypherNodes and writes them
+        to an RDF file in the specified format.
+
+        Args:
+            node_list (list): A list of BioCypherNodes to be written.
+
+            label (str): The label (type) of the nodes.
+
+            prop_dict (dict): A dictionary of properties and their types for the node class.
+
+        Returns:
+            bool: True if the writing is successful, False otherwise.
+        """
+        if not all(isinstance(n, BioCypherNode) for n in node_list):
+            logger.error("Nodes must be passed as type BioCypherNode.")
+            return False
+
+        # translate label to PascalCase
+        label_pascal = self.translator.name_sentence_to_pascal(label)
+
+        # create file name
+        file_name = os.path.join(
+            self._outdir, f"{label_pascal}.{self.extension}"
+        )
+
+        # write data in graph
+        graph = Graph()
+        self._init_namespaces(graph)
+
+        for n in node_list:
+            rdf_subject = n.get_id()
+            rdf_object = n.get_label()
+            properties = n.get_properties()
+            class_name = self.translator.name_sentence_to_pascal(rdf_object)
+            graph.add(
+                (
+                    self.rdf_namespaces["biocypher"][class_name],
+                    RDF.type,
+                    RDFS.Class,
+                )
+            )
+            graph.add(
+                (
+                    self.subject_to_uri(rdf_subject),
+                    RDF.type,
+                    self.rdf_namespaces["biocypher"][class_name],
+                )
+            )
+            for key, value in properties.items():
+                # only write value if it exists.
+                if value:
+                    self.add_property_to_graph(graph, rdf_subject, value, key)
+
+        graph.serialize(destination=file_name, format=self.rdf_format)
+
+        logger.info(
+            f"Writing {len(node_list)} entries to {label_pascal}.{self.rdf_format}",
+        )
+
+        return True
+
+    def write_nodes(
+        self, nodes, batch_size: int = int(1e6), force: bool = False
+    ) -> bool:
+        """
+        Wrapper for writing nodes in RDF format. It calls the _write_node_data() function, specifying the node data.
+
+        Args:
+            nodes (list or generator): A list or generator of nodes in BioCypherNode format.
+            batch_size (int): The number of nodes to write in each batch.
+            force (bool): Flag to force the writing even if the output file already exists.
+
+        Returns:
+            bool: True if the writing is successful, False otherwise.
+        """
+        # check if specified output format is correct
+        passed = self._is_rdf_format_supported(self.rdf_format)
+        if not passed:
+            logger.error("Error while writing node data, wrong RDF format")
+            return False
+        # write node data using _write_node_data method
+        passed = self._write_node_data(nodes, batch_size, force)
+        if not passed:
+            logger.error("Error while writing node data.")
+            return False
+        return True
+
+    def write_edges(
+        self,
+        edges: Union[list, GeneratorType],
+        batch_size: int = int(1e6),
+    ) -> bool:
+        """
+        Wrapper for writing edges in RDF format. It calls _write_edge_data()
+        functions specifying it's edge data.
+
+        Args:
+            edges (BioCypherEdge): a list or generator of edges in
+                :py:class:`BioCypherEdge` format
+            batch_size (int): The number of edges to write in each batch.
+
+        Returns:
+            bool: The return value. True for success, False otherwise.
+        """
+        # check if specified output format is correct
+        passed = self._is_rdf_format_supported(self.rdf_format)
+        if not passed:
+            logger.error("Error while writing edge data, wrong RDF format")
+            return False
+        # write edge data using _write_edge_data method
+        passed = self._write_edge_data(edges, batch_size=batch_size)
+        if not passed:
+            logger.error("Error while writing edge data.")
+            return False
+
+        return True
+
+    def _construct_import_call(self) -> bool:
+        """
+        Function to write the import call.
+        This function is not applicable for RDF.
+
+        Returns:
+            bool: The return value. True for success, False otherwise.
+        """
+        return ""
+
+    def _write_array_string(self, string_list):
+        """
+        Abstract method to write the string representation of an array into a .csv file
+        as required by the RDF admin-import.
+        This function is not applicable for RDF.
+
+        Args:
+            string_list (list): list of ontology strings
+
+        Returns:
+            str: The string representation of an array for the neo4j admin import
+        """
+
+        return True
+
+    def _write_node_headers(self):
+        """
+        Abstract method that takes care of importing properties of a graph entity that is represented
+        as a node as per the definition in the `schema_config.yaml`
+        This function is not applicable for RDF.
+
+        Returns:
+            bool: The return value. True for success, False otherwise.
+        """
+        return True
+
+    def _write_edge_headers(self):
+        """
+        Abstract method to write a database import-file for a graph entity that is represented
+        as an edge as per the definition in the `schema_config.yaml`,
+        containing only the header for this type of edge.
+        This function is not applicable for RDF.
+
+        Returns:
+            bool: The return value. True for success, False otherwise.
+        """
+        return True
+
+    def subject_to_uri(self, subject: str) -> str:
+        """
+        Converts the subject to a proper URI using the available namespaces.
+        If the conversion fails, it defaults to the biocypher prefix.
+
+        Args:
+            subject (str): The subject to be converted to a URI.
+
+        Returns:
+            str: The corresponding URI for the subject.
+        """
+        try:
+            _pref, _id = subject.split(":")
+
+            if _pref in self.rdf_namespaces.keys():
+                return self.rdf_namespaces[_pref][_id]
+            else:
+                return self.rdf_namespaces["biocypher"][subject]
+        except ValueError:
+            return self.rdf_namespaces["biocypher"][subject]
+
+    def property_to_uri(self, property_name: str) -> dict[str, str]:
+        """
+        Converts a property name to its corresponding URI.
+
+        This function takes a property name and searches for its corresponding URI in various namespaces.
+        It first checks the core namespaces for rdflib, including owl, rdf, rdfs, xsd, and xml.
+
+        Args:
+            property_name (str): The property name to be converted to a URI.
+
+        Returns:
+            str: The corresponding URI for the input property name.
+        """
+        # These namespaces are core for rdflib; owl, rdf, rdfs, xsd and xml
+        for namespace in _NAMESPACE_PREFIXES_CORE.values():
+            if property_name in namespace:
+                return namespace[property_name]
+
+        # If the property name is not found in the core namespaces, search in the SKOS, DC, and DCTERMS namespaces
+        for namespace in [SKOS, DC, DCTERMS]:
+            if property_name in namespace:
+                return namespace[property_name]
+
+        # If the property name is still not found, try other namespaces from rdflib.
+        for namespace in _NAMESPACE_PREFIXES_RDFLIB.values():
+            if property_name in namespace:
+                return namespace[property_name]
+
+        # If the property name is "licence", it recursively calls the function with "license" as the input.
+        if property_name == "licence":
+            return self.property_to_uri("license")
+
+        # TODO: add an option to search trough manually implemented namespaces
+
+        # If the input is not found in any of the namespaces, it returns the corresponding URI from the biocypher namespace.
+        # TODO: give a warning and try to prevent this option altogether
+        return self.rdf_namespaces["biocypher"][property_name]
+
+    def _init_namespaces(self, graph: Graph):
+        """
+        Initializes the namespaces for the RDF graph. These namespaces are used to convert nodes to URIs.
+
+        This function adds the biocypher standard namespace to the `rdf_namespaces` attribute of the class.
+        If `rdf_namespaces` is empty, it sets it to the biocypher standard namespace. Otherwise, it merges
+        the biocypher standard namespace with the namespaces defined in the biocypher_config.yaml.
+
+        Args:
+            graph (RDFLib.Graph): The RDF graph to bind the namespaces to.
+
+        Returns:
+            None
+        """
+        # add biocypher standard to self.rdf_namespaces
+        biocypher_standard = {"biocypher": "https://biocypher.org/biocypher#"}
+        if not self.rdf_namespaces:
+            self.rdf_namespaces = biocypher_standard
+        else:
+            self.rdf_namespaces = self.rdf_namespaces | biocypher_standard
+
+        for key, value in self.rdf_namespaces.items():
+            namespace = Namespace(value)
+            self.rdf_namespaces[key] = namespace
+            graph.bind(key, namespace)

{biocypher-0.5.41 → biocypher-0.5.42}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "biocypher"
-version = "0.5.41"
+version = "0.5.42"
 description = "A unifying framework for biomedical research knowledge graphs"
 authors = [
     "Sebastian Lobentanzer <sebastian.lobentanzer@gmail.com>",