biocypher 0.8.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

biocypher/output/write/graph/_rdf.py

@@ -1,33 +1,113 @@
-"""BioCypher 'offline' module. Handles the writing of node and edge representations
-suitable for import into a DBMS.
-"""
+"""Module to provide the RDF writer class."""
 
 import os
 
 from types import GeneratorType
 
-from rdflib import DC, DCTERMS, RDF, RDFS, SKOS, Graph, Literal, Namespace
+from rdflib import (
+    DC,
+    DCTERMS,
+    RDF,
+    RDFS,
+    SKOS,
+    Graph,
+    Literal,
+    Namespace,
+    URIRef,
+)
 from rdflib.namespace import (
     _NAMESPACE_PREFIXES_CORE,
     _NAMESPACE_PREFIXES_RDFLIB,
 )
 
 from biocypher._create import BioCypherEdge, BioCypherNode
+from biocypher._deduplicate import Deduplicator
 from biocypher._logger import logger
+from biocypher._translate import Translator
 from biocypher.output.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
+    """Write BioCypher's property graph into an RDF format.
+
+    Uses `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 __init__(
+        self,
+        translator: Translator,
+        deduplicator: Deduplicator,
+        delimiter: str,
+        array_delimiter: str = ",",
+        quote: str = '"',
+        output_directory: str | None = None,
+        db_name: str = "neo4j",
+        import_call_bin_prefix: str | None = None,
+        import_call_file_prefix: str | None = None,
+        wipe: bool = True,
+        strict_mode: bool = False,
+        skip_bad_relationships: bool = False,
+        skip_duplicate_nodes: bool = False,
+        db_user: str = None,
+        db_password: str = None,
+        db_host: str = None,
+        db_port: str = None,
+        file_format: str = None,
+        rdf_namespaces: dict = {},
+        labels_order: str = "Ascending",
+        **kwargs,
+    ):
+        super().__init__(
+            translator=translator,
+            deduplicator=deduplicator,
+            delimiter=delimiter,
+            array_delimiter=array_delimiter,
+            quote=quote,
+            output_directory=output_directory,
+            db_name=db_name,
+            import_call_bin_prefix=import_call_bin_prefix,
+            import_call_file_prefix=import_call_file_prefix,
+            wipe=wipe,
+            strict_mode=strict_mode,
+            skip_bad_relationships=skip_bad_relationships,
+            skip_duplicate_nodes=skip_duplicate_nodes,
+            db_user=db_user,
+            db_password=db_password,
+            db_host=db_host,
+            db_port=db_port,
+            file_format=file_format,
+            rdf_namespaces=rdf_namespaces,
+            labels_order=labels_order,
+            **kwargs,
+        )
+        if not self.rdf_namespaces:
+            # For some reason, the config can pass
+            # the None object.
+            self.rdf_namespaces = {}
+
+        if "rdf_format" in kwargs:
+            logger.warning("The 'rdf_format' config option is deprecated, use 'file_format' instead.")
+            if not file_format:
+                format = kwargs["rdf_format"]
+                logger.warning(f"I will set 'file_format: {format}' for you.")
+                self.file_format = format
+                kwargs.pop("rdf_format")
+            logger.warning("NOTE: this warning will become an error in next versions.")
+
+        if not file_format:
+            msg = "You need to indicate a 'file_format'."
+            logger.error(msg)
+            raise RuntimeError(msg)
+
+        self.namespaces = {}
+
     def _get_import_script_name(self) -> str:
-        """Returns the name of the RDF admin import script.
-        This function applicable for RDF export.
+        """Return the name of the RDF admin import script.
+
+        This function is used for RDF export.
 
         Returns
         -------
@@ -37,7 +117,7 @@ class _RDFWriter(_BatchWriter):
         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.
+        """Provide the default string for the import call bin prefix.
 
         Returns
         -------
@@ -46,12 +126,12 @@ class _RDFWriter(_BatchWriter):
         """
         return "bin/"
 
-    def _is_rdf_format_supported(self, rdf_format: str) -> bool:
-        """Function to check if the specified RDF format is supported.
+    def _is_rdf_format_supported(self, file_format: str) -> bool:
+        """Check if the specified RDF format is supported.
 
         Args:
         ----
-            rdf_format (str): The RDF format to check.
+            file_format (str): The RDF format to check.
 
         Returns:
         -------
@@ -62,6 +142,7 @@ class _RDFWriter(_BatchWriter):
             "xml",
             "n3",
             "turtle",
+            "ttl",
             "nt",
             "pretty-xml",
             "trix",
@@ -69,22 +150,18 @@ class _RDFWriter(_BatchWriter):
             "nquads",
             "json-ld",
         ]
-        if rdf_format not in supported_formats:
+        if file_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" ',
+                f"Incorrect or unsupported RDF format: '{file_format}',"
+                f"use one of the following: {', '.join(supported_formats)}.",
             )
             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"
+            # Set the file extension to match the format
+            if self.file_format == "turtle":
                 self.extension = "ttl"
             else:
-                self.extension = self.rdf_format
+                self.extension = self.file_format
             return True
 
     def _write_single_edge_list_to_file(
@@ -93,8 +170,7 @@ class _RDFWriter(_BatchWriter):
         label: str,
         prop_dict: dict,
     ):
-        """This function takes one list of biocypher edges and writes them
-        to an RDF file with the given format.
+        """Write a list of BioCypherEdges to an RDF file.
 
         Args:
         ----
@@ -110,6 +186,8 @@ class _RDFWriter(_BatchWriter):
             bool: The return value. True for success, False otherwise.
 
         """
+        # NOTE: prop_dict is not used. Remove in next refactor.
+
         if not all(isinstance(n, BioCypherEdge) for n in edge_list):
             logger.error("Edges must be passed as type BioCypherEdge.")
             return False
@@ -133,27 +211,27 @@ class _RDFWriter(_BatchWriter):
                 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]
+            edge_uri = self.as_uri(edge_label, "biocypher")
             graph.add((edge_uri, RDF.type, RDFS.Class))
             graph.add(
                 (
-                    self.rdf_namespaces["biocypher"][rdf_predicate],
+                    self.as_uri(rdf_predicate, "biocypher"),
                     RDF.type,
                     edge_uri,
                 ),
             )
             graph.add(
                 (
-                    self.rdf_namespaces["biocypher"][rdf_predicate],
-                    self.rdf_namespaces["biocypher"]["subject"],
-                    self.subject_to_uri(rdf_subject),
+                    self.as_uri(rdf_predicate, "biocypher"),
+                    self.as_uri("subject", "biocypher"),
+                    self.to_uri(rdf_subject),
                 ),
             )
             graph.add(
                 (
-                    self.rdf_namespaces["biocypher"][rdf_predicate],
-                    self.rdf_namespaces["biocypher"]["object"],
-                    self.subject_to_uri(rdf_object),
+                    self.as_uri(rdf_predicate, "biocypher"),
+                    self.as_uri("object", "biocypher"),
+                    self.to_uri(rdf_object),
                 ),
             )
 
@@ -163,10 +241,10 @@ class _RDFWriter(_BatchWriter):
                 if value:
                     self.add_property_to_graph(graph, rdf_predicate, value, key)
 
-        graph.serialize(destination=file_name, format=self.rdf_format)
+        graph.serialize(destination=file_name, format=self.file_format)
 
         logger.info(
-            f"Writing {len(edge_list)} entries to {label_pascal}.{self.rdf_format}",
+            f"Writing {len(edge_list)} entries to {label_pascal}.{self.file_format}",
         )
 
         return True
@@ -206,7 +284,7 @@ class _RDFWriter(_BatchWriter):
             for obj in rdf_object:
                 graph.add(
                     (
-                        self.subject_to_uri(rdf_subject),
+                        self.to_uri(rdf_subject),
                         self.property_to_uri(rdf_predicate),
                         Literal(obj),
                     ),
@@ -222,7 +300,7 @@ class _RDFWriter(_BatchWriter):
             else:
                 graph.add(
                     (
-                        self.subject_to_uri(rdf_subject),
+                        self.to_uri(rdf_subject),
                         self.property_to_uri(rdf_predicate),
                         Literal(rdf_object),
                     ),
@@ -230,14 +308,14 @@ class _RDFWriter(_BatchWriter):
         else:
             graph.add(
                 (
-                    self.subject_to_uri(rdf_subject),
+                    self.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.
+        """Transform a string representation of a list into a list.
 
         Args:
         ----
@@ -257,8 +335,7 @@ class _RDFWriter(_BatchWriter):
         prop_dict: dict,
         labels: str,
     ):
-        """This function takes a list of BioCypherNodes and writes them
-        to an RDF file in the specified format.
+        """Write a list of BioCypherNodes to an RDF file.
 
         Args:
         ----
@@ -268,11 +345,15 @@ class _RDFWriter(_BatchWriter):
 
             prop_dict (dict): A dictionary of properties and their types for the node class.
 
+            labels (str): string of one or several concatenated labels
+
         Returns:
         -------
             bool: True if the writing is successful, False otherwise.
 
         """
+        # NOTE: labels and prop_dict are not used.
+
         if not all(isinstance(n, BioCypherNode) for n in node_list):
             logger.error("Nodes must be passed as type BioCypherNode.")
             return False
@@ -294,16 +375,16 @@ class _RDFWriter(_BatchWriter):
             class_name = self.translator.name_sentence_to_pascal(rdf_object)
             graph.add(
                 (
-                    self.rdf_namespaces["biocypher"][class_name],
+                    self.as_uri(class_name, "biocypher"),
                     RDF.type,
                     RDFS.Class,
                 ),
             )
             graph.add(
                 (
-                    self.subject_to_uri(rdf_subject),
+                    self.to_uri(rdf_subject),
                     RDF.type,
-                    self.rdf_namespaces["biocypher"][class_name],
+                    self.as_uri(class_name, "biocypher"),
                 ),
             )
             for key, value in properties.items():
@@ -311,22 +392,24 @@ class _RDFWriter(_BatchWriter):
                 if value:
                     self.add_property_to_graph(graph, rdf_subject, value, key)
 
-        graph.serialize(destination=file_name, format=self.rdf_format)
+        graph.serialize(destination=file_name, format=self.file_format)
 
         logger.info(
-            f"Writing {len(node_list)} entries to {label_pascal}.{self.rdf_format}",
+            f"Writing {len(node_list)} entries to {label_pascal}.{self.file_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.
+        """Write nodes in RDF format.
 
         Args:
         ----
-            nodes (list or generator): A list or generator of nodes in BioCypherNode format.
+            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.
+            force (bool): Flag to force the writing even if the output file
+                already exists.
 
         Returns:
         -------
@@ -334,7 +417,7 @@ class _RDFWriter(_BatchWriter):
 
         """
         # check if specified output format is correct
-        passed = self._is_rdf_format_supported(self.rdf_format)
+        passed = self._is_rdf_format_supported(self.file_format)
         if not passed:
             logger.error("Error while writing node data, wrong RDF format")
             return False
@@ -350,8 +433,7 @@ class _RDFWriter(_BatchWriter):
         edges: 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.
+        """Write edges in RDF format.
 
         Args:
         ----
@@ -365,7 +447,7 @@ class _RDFWriter(_BatchWriter):
 
         """
         # check if specified output format is correct
-        passed = self._is_rdf_format_supported(self.rdf_format)
+        passed = self._is_rdf_format_supported(self.file_format)
         if not passed:
             logger.error("Error while writing edge data, wrong RDF format")
             return False
@@ -378,7 +460,8 @@ class _RDFWriter(_BatchWriter):
         return True
 
     def _construct_import_call(self) -> bool:
-        """Function to write the import call.
+        """Write the import call.
+
         This function is not applicable for RDF.
 
         Returns
@@ -389,15 +472,12 @@ class _RDFWriter(_BatchWriter):
         return ""
 
     def _quote_string(self, value: str) -> str:
-        """
-        Quote a string.
-        """
-
+        """Quote a string."""
         return f"{self.quote}{value}{self.quote}"
 
     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.
+        """Write the string representation of an array into a .csv file.
+
         This function is not applicable for RDF.
 
         Args:
@@ -412,8 +492,8 @@ class _RDFWriter(_BatchWriter):
         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`
+        """Import properties of a graph entity.
+
         This function is not applicable for RDF.
 
         Returns
@@ -424,9 +504,8 @@ class _RDFWriter(_BatchWriter):
         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.
+        """Write a database import-file for a graph entity.
+
         This function is not applicable for RDF.
 
         Returns
@@ -436,9 +515,38 @@ class _RDFWriter(_BatchWriter):
         """
         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.
+    def as_uri(self, name: str, namespace: str = "") -> str:
+        """Return an RDFlib object with the given namespace as a URI.
+
+        There is often a default for empty namespaces, which would have been
+        loaded with the ontology, and put in `self.namespace` by
+        `self._init_namespaces`.
+
+        Args:
+        ----
+            name (str): The name to be transformed.
+            namespace (str): The namespace to be used.
+
+        Returns:
+        -------
+            str: The URI for the given name and namespace.
+
+        """
+        if namespace in self.namespaces:
+            return URIRef(self.namespaces[namespace][name])
+        else:
+            assert "biocypher" in self.namespaces
+            # If no default empty NS, use the biocypher one,
+            # which is always there.
+            logger.debug(f"I'll consider '{name}' as part of 'biocypher' namespace.")
+            return URIRef(self.namespaces["biocypher"][name])
+
+    def to_uri(self, subject: str) -> str:
+        """Extract the namespace from the given subject.
+
+        Split the subject's string on ":". Then convert the subject to a
+        proper URI, if the namespace is known. If namespace is unknown,
+        defaults to the default prefix of the ontology.
 
         Args:
         ----
@@ -449,21 +557,37 @@ class _RDFWriter(_BatchWriter):
             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]
+        pref_id = subject.split(":")
+        if len(pref_id) == 2:
+            pref, id = pref_id
+            return self.as_uri(id, pref)
+        else:
+            return self.as_uri(subject)
+
+    def find_uri(self, regexp: str) -> str:
+        query = f'SELECT DISTINCT ?s WHERE {{ ?s ?p ?o . FILTER regex(str(?s), "{regexp}")}}'
+        gen = self.graph.query(query)
+        uris = list(gen)
+        if len(uris) > 1:
+            logger.warning(
+                f"Found several terms matching `{regexp}`, I will consider only the first one: `{uris[0][0]}`",
+            )
+            logger.debug("\tothers:")
+            for u in uris[1:]:
+                logger.debug(f"\t{u[0]}")
+        if uris:
+            logger.debug(f"Found {len(uris)} terms, returning: `{uris[0][0]}`")
+            return uris[0][0]
+        else:
+            logger.debug(f"Found no term matching: `{query}`")
+            return None
 
     def property_to_uri(self, property_name: str) -> dict[str, str]:
-        """Converts a property name to its corresponding URI.
+        """Convert 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.
+        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:
         ----
@@ -501,16 +625,16 @@ class _RDFWriter(_BatchWriter):
         # 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]
+        return self.as_uri(property_name, "biocypher")
 
     def _init_namespaces(self, graph: Graph):
         """Initialise 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.
+        This function adds the biocypher standard namespace to the `namespaces`
+        attribute of the class. If `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:
         ----
@@ -521,14 +645,27 @@ class _RDFWriter(_BatchWriter):
             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)
+        # Bind and keep the biocypher namespace.
+        bcns = Namespace("https://biocypher.org/biocypher#")
+        bck = "biocypher"
+        self.namespaces = {bck: bcns}
+        graph.bind(bck, bcns)
+
+        # Keep track of namespaces loaded with the ontologies in the given graph.
+        logger.debug("Bind namespaces:")
+        for prefix, ns in graph.namespaces():
+            if prefix in self.namespaces and str(ns) != str(self.namespaces[prefix]):
+                logger.warning(
+                    f"Namespace '{prefix}' was already loaded"
+                    f"as '{self.namespaces[prefix]}',"
+                    f"I will overwrite it with '{ns}'.",
+                )
+            logger.debug(f"\t'{prefix}'\t=>\t'{ns}'")
+            self.namespaces[prefix] = Namespace(ns)
+
+        # Bind and keep the namespaces given in the config.
+        for prefix, ns in self.rdf_namespaces.items():
+            assert prefix not in self.namespaces
+            self.namespaces[prefix] = Namespace(ns)
+            logger.debug(f"\t'{prefix}'\t->\t{ns}")
+            graph.bind(prefix, self.namespaces[prefix])

{biocypher-0.8.0.dist-info → biocypher-0.9.1.dist-info}/METADATA

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

{biocypher-0.8.0.dist-info → biocypher-0.9.1.dist-info}/RECORD

@@ -1,20 +1,20 @@
 biocypher/__init__.py,sha256=-iq15Q3LhB8WBQjnD15ghszEdaqJ1XvQIF5IaF88KNQ,783
 biocypher/_config/__init__.py,sha256=ku86JZaRrzW5NEz5EXsCRktFwxS0Yo2dwX4UuazdfA4,3416
-biocypher/_config/biocypher_config.yaml,sha256=KdeqgY27YIyvZICNVBCI3h9y7duqF-buynXF_1G5dRY,3368
+biocypher/_config/biocypher_config.yaml,sha256=nrlwSW7YP8qTZYm-HvWdTCZy81jnd2FkIGWH8Se2MzI,3651
 biocypher/_config/test_config.yaml,sha256=Np8jeS5_EP6HHOvMKb7B_Tkyqd5YaYlYz_DVsXypt-A,119
 biocypher/_config/test_schema_config.yaml,sha256=D1600WgEj3iTXrumVU9LIivJHJO36iaxfkOgyam9zVU,3129
 biocypher/_config/test_schema_config_disconnected.yaml,sha256=Qm8FLxEn2spHcyj_5F859KjcDvKSxNhxDvi4b4LLkvQ,68
 biocypher/_config/test_schema_config_extended.yaml,sha256=wn3A76142hhjnImhMF6RODbCFESTJ2TtPvcFdIFsAT0,3309
-biocypher/_core.py,sha256=CGbGHX3-JuJsQJsmLFsFNylPiPiJx83aXq05ocPSeUA,26354
+biocypher/_core.py,sha256=S8frW62bc0V9M6gwU5l_D2ESa-7xwbOTffRuPqbIbT0,27382
 biocypher/_create.py,sha256=QsvXrwEQ8k0uNXvCG06UKejvw-QsJwzSaumrBjx9n1k,9884
 biocypher/_deduplicate.py,sha256=rtglcaLRaVzNjLtaPwTGP8VvCM4PHYQ5CZ-cm32CrKQ,4840
 biocypher/_get.py,sha256=2kjiBFu_onGUhgOpV7IMfGX67jyY1rpHg_GWncEUdrc,13278
 biocypher/_logger.py,sha256=y9dh3SPJOCWXnkFSYSK7aj_-pB7zlAkNCf43Dp1lt74,2941
 biocypher/_mapping.py,sha256=ntspG2C_NaQODhWTBFk0CDvolkOCjtqlQ9E-NkJAuTg,9030
-biocypher/_metadata.py,sha256=xVVYPjLr00BmeV7okCdmxRgsd1clEQkQz4R93HOA8uk,1415
+biocypher/_metadata.py,sha256=Eop3cijNQBsHWeOO8zbBmN_2ICJutZziDPvWppV474M,1415
 biocypher/_misc.py,sha256=N8aDg8j3EEcKf9ZRqzSNruUEUK4RixCy1vQ1V4maGxk,6079
-biocypher/_ontology.py,sha256=McN50IAjmlVUUOc-7kpIdskCeatsmVpJ1a90ca6FQ7Y,30638
-biocypher/_translate.py,sha256=sXyXIg6hpR6Y-dp8NtoAN-H4mzrGI4t1ivlBGxaeqWM,16379
+biocypher/_ontology.py,sha256=lipZxU3aj6zrTbBrJZmCW6IRCuz-KQG3AfbYCVq6aFE,33133
+biocypher/_translate.py,sha256=9E19eLRL0VnxxDuiNhZ5vu54XyKXnfLuBhCgNcL9yAE,17000
 biocypher/output/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biocypher/output/connect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biocypher/output/connect/_get_connector.py,sha256=r-DeDnvGyFEWOd9bXaXQOgVws9rgWz5kwwdzbmt5eKk,1038
@@ -25,19 +25,20 @@ biocypher/output/in_memory/_in_memory_kg.py,sha256=g1TPN8PkeAyXbrRuTAjshqC8voI6E
 biocypher/output/in_memory/_networkx.py,sha256=cSOSAreP7S3oeGT6noZ1kAIvSnkVnU3NUp1OY4yqzn0,1515
 biocypher/output/in_memory/_pandas.py,sha256=Ot2jbK5t_YLHqw0BUv9Z_qWNy9r6IX1LYEyejOSJzos,3288
 biocypher/output/write/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-biocypher/output/write/_batch_writer.py,sha256=4w1YTXF1iAvzZyqcJLhirmKkU12J8NJqb4SiNjM91cY,38044
-biocypher/output/write/_get_writer.py,sha256=PCF-JMCGwlh5hLl1SFLseNsBH1Nt49XTKcqximKwfDY,3532
+biocypher/output/write/_batch_writer.py,sha256=_Dao7z4KN0Uhr86oOOWYEDrIUikR7T0v1SJC2Btd8Y4,38745
+biocypher/output/write/_get_writer.py,sha256=JozRWCMhvh65aQAlcGiiD5x3Nl1HSW8mK1Zf2nTSOzI,4385
 biocypher/output/write/_writer.py,sha256=y0dWI-RyQdrBLr9Fs91Y9KcCMjnlCaKJT0eWsIS2hG4,7158
 biocypher/output/write/graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-biocypher/output/write/graph/_arangodb.py,sha256=NBnVJa4WuK7WNTIAXOg62YjAMAQfEZtcJX97erNLgSw,7794
-biocypher/output/write/graph/_neo4j.py,sha256=aMq8XKZ_UMbDI1gZmZx0D4T3pY2E4l1jMqX78M3TJK0,12051
+biocypher/output/write/graph/_arangodb.py,sha256=xue3hm_DVB5pMR5qqfGXlXll3RpILA0tXos2J-as1-E,7906
+biocypher/output/write/graph/_neo4j.py,sha256=EK5gqQNyVMYfpH1DaDTtGfRKiiq4jx5DLtYCCjY-jbY,12081
 biocypher/output/write/graph/_networkx.py,sha256=2WYkw5ZM3Bp236iwAxEAp3A1DxHKT4_hEPNMUKvPHp4,2320
-biocypher/output/write/graph/_rdf.py,sha256=Vt_mb3HsRrDdrWmwwPsGXshbjjiUd9ZAoLJxoKoglCE,18075
+biocypher/output/write/graph/_owl.py,sha256=2DlxQuAXGnCW068N8bPgADjk_LFhU9D_LJV5lWQeu4A,21333
+biocypher/output/write/graph/_rdf.py,sha256=1TgECkoTHFX0eXtWc_-pr9G55AesReGlh7rg5zvUj5w,21925
 biocypher/output/write/relational/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biocypher/output/write/relational/_csv.py,sha256=m0BSQXts88Qu5AEvoIgnwRz54ia38g4VN3PaA3LCYM8,2807
 biocypher/output/write/relational/_postgresql.py,sha256=RckQJBiuwvDmHAyXxS8zCavYqDecHHWW_piofurokfQ,11965
 biocypher/output/write/relational/_sqlite.py,sha256=BuGWOeeNA83lbUvjpkzqcR9_baWLsbfmLXBKe4O1EPE,2105
-biocypher-0.8.0.dist-info/LICENSE,sha256=oejgxuxyjSnyPw3YPloz6-dCBB_nYizJ4jDQnr-xZUU,1082
-biocypher-0.8.0.dist-info/METADATA,sha256=VByGBm1JcK0yiXCq2aNWSAbguf5_5Lv8rCDTyG1uOLs,10643
-biocypher-0.8.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-biocypher-0.8.0.dist-info/RECORD,,
+biocypher-0.9.1.dist-info/LICENSE,sha256=oejgxuxyjSnyPw3YPloz6-dCBB_nYizJ4jDQnr-xZUU,1082
+biocypher-0.9.1.dist-info/METADATA,sha256=Qjy-T-iNXAn0wye7-NbLivn7ZPz80ZrOu8utum7_4vk,10643
+biocypher-0.9.1.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+biocypher-0.9.1.dist-info/RECORD,,