pyobo 0.11.2__py3-none-any.whl → 0.12.1__py3-none-any.whl

pyobo/struct/functional/obo_to_functional.py

@@ -0,0 +1,385 @@
+"""Converters from OBO to functional OWL."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, cast
+
+import rdflib
+from curies import vocabulary as v
+from rdflib import XSD
+
+from pyobo.struct import Stanza
+from pyobo.struct import vocabulary as pv
+from pyobo.struct.functional import dsl as f
+from pyobo.struct.functional import macros as m
+from pyobo.struct.functional.ontology import Document, Ontology
+from pyobo.struct.reference import OBOLiteral, Reference, _parse_datetime
+
+if TYPE_CHECKING:
+    from pyobo.struct.struct import Obo, Referenced, Term
+    from pyobo.struct.struct_utils import Annotation as OBOAnnotation
+    from pyobo.struct.typedef import TypeDef
+
+__all__ = [
+    "get_ofn_from_obo",
+    "get_ontology_annotations",
+    "get_ontology_axioms",
+    "get_term_axioms",
+    "get_typedef_axioms",
+]
+
+_BASE = "https://w3id.org/biopragmatics/resources"
+
+
+def get_ofn_from_obo(
+    obo_ontology: Obo, *, iri: str | None = None, version_iri: str | None = None
+) -> Document:
+    """Convert an ontology."""
+    prefix = obo_ontology.ontology
+    base = f"{_BASE}/{prefix}"
+    if iri is None:
+        iri = f"{base}/{prefix}.ofn"
+    if version_iri is None and obo_ontology.data_version:
+        version_iri = f"{base}/{obo_ontology.data_version}/{prefix}.ofn"
+    ofn_ontology = Ontology(
+        iri=iri,
+        version_iri=version_iri,
+        annotations=list(get_ontology_annotations(obo_ontology)),
+        axioms=list(get_ontology_axioms(obo_ontology)),
+    )
+    document = Document(
+        ofn_ontology,
+        obo_ontology._get_clean_idspaces(),
+    )
+    return document
+
+
+def get_ontology_axioms(obo_ontology: Obo) -> Iterable[f.Box]:
+    """Get axioms from the ontology."""
+    if obo_ontology.root_terms:
+        yield f.Declaration(pv.has_ontology_root_term, type="AnnotationProperty")
+        yield m.LabelMacro(pv.has_ontology_root_term, cast(str, pv.has_ontology_root_term.name))
+
+    if obo_ontology.subsetdefs:
+        yield f.Declaration("oboInOwl:SubsetProperty", type="AnnotationProperty")
+        for subset_typedef, subset_label in obo_ontology.subsetdefs:
+            yield f.Declaration(subset_typedef, type="AnnotationProperty")
+            yield m.LabelMacro(subset_typedef, subset_label)
+            yield f.SubAnnotationPropertyOf(subset_typedef, "oboInOwl:SubsetProperty")
+
+    if obo_ontology.synonym_typedefs:
+        used_has_scope = False
+        for synonym_typedef in obo_ontology.synonym_typedefs:
+            yield f.Declaration(synonym_typedef, type="AnnotationProperty")
+            yield m.LabelMacro(synonym_typedef, synonym_typedef.name)
+            yield f.SubAnnotationPropertyOf(synonym_typedef, "oboInOwl:SynonymTypeProperty")
+            if synonym_typedef.specificity:
+                used_has_scope = True
+                yield f.AnnotationAssertion(
+                    "oboInOwl:hasScope",
+                    synonym_typedef,
+                    v.synonym_scopes[synonym_typedef.specificity],
+                )
+        if used_has_scope:
+            yield f.Declaration("oboInOwl:hasScope", type="AnnotationProperty")
+
+    for typedef in obo_ontology.typedefs or []:
+        yield from get_typedef_axioms(typedef)
+
+    for term in obo_ontology:
+        yield from get_term_axioms(term)
+
+
+def get_ontology_annotations(obo_ontology: Obo) -> Iterable[f.Annotation]:
+    """Get annotations from the ontology."""
+    for predicate, value in obo_ontology._iterate_property_pairs():
+        yield f.Annotation(predicate, value)
+    if obo_ontology.data_version:
+        yield f.Annotation(pv.version_info, OBOLiteral.string(obo_ontology.data_version))
+    if obo_ontology.auto_generated_by is not None:
+        yield f.Annotation(
+            pv.obo_autogenerated_by, OBOLiteral.string(obo_ontology.auto_generated_by)
+        )
+
+
+def _oboliteral_to_literal(obo_literal: OBOLiteral) -> rdflib.Literal:
+    if obo_literal.datatype.pair == ("xsd", "string") and obo_literal.language:
+        return rdflib.Literal(obo_literal.value, lang=obo_literal.language)
+    if obo_literal.datatype.prefix != "xsd":
+        raise NotImplementedError(
+            f"Automatic literal conversion is not implemented for prefix: {obo_literal.datatype.prefix}"
+        )
+    if obo_literal.datatype.identifier == "dateTime":
+        return rdflib.Literal(_parse_datetime(obo_literal.value), datatype=XSD.dateTime)
+    return rdflib.Literal(obo_literal.value, datatype=XSD._NS.term(obo_literal.datatype.identifier))
+
+
+def get_term_axioms(term: Term) -> Iterable[f.Box]:
+    """Iterate over functional OWL axioms for a term."""
+    s = f.IdentifierBox(term)
+    # 1 and 13
+    if term.type == "Term":
+        yield f.Declaration(s, type="Class")
+        for parent in term.parents:
+            yield f.SubClassOf(s, parent)
+    else:
+        yield f.Declaration(s, type="NamedIndividual")
+        for parent in term.parents:
+            yield f.ClassAssertion(parent, s)
+    # 2
+    if term.is_anonymous is not None:
+        yield m.IsAnonymousMacro(s, term.is_anonymous)
+    # 3
+    if term.name:
+        yield m.LabelMacro(s, term.name)
+    # 4
+    if term.namespace:
+        yield m.OBONamespaceMacro(s, term.namespace)
+    # 5
+    for alt in term.alt_ids:
+        yield m.ReplacedByMacro(alt, s)
+    # 6
+    yield from _yield_definition(term, s)
+    # 7 comment is covered by properties
+    # 8
+    for subset in term.subsets:
+        yield m.OBOIsSubsetMacro(s, subset)
+    # 9
+    yield from _yield_synonyms(term, s)
+    # 10
+    yield from _yield_xrefs(term, s)
+    # 11
+    if term.builtin is not None:
+        yield m.IsOBOBuiltinMacro(s, term.builtin)
+    # 12
+    yield from _yield_properties(term, s)
+    # 13 parents - see top
+    # 14
+    if term.intersection_of:
+        yield m.ClassIntersectionMacro(s, term.intersection_of)
+    # 15
+    if term.union_of:
+        yield m.ClassUnionMacro(s, term.union_of)
+    # 16
+    if term.equivalent_to:
+        yield f.EquivalentClasses([s, *term.equivalent_to])
+    # 17
+    if term.disjoint_from:
+        yield f.DisjointClasses([s, *term.disjoint_from])
+    # 18
+    for typedef, value in term.iterate_relations():
+        rel_annotations = _get_annotations(term, typedef, value)
+        if term.type == "Term":
+            yield m.RelationshipMacro(s=s, p=typedef, o=value, annotations=rel_annotations)
+        else:
+            yield f.ObjectPropertyAssertion(typedef, s, value, annotations=rel_annotations)
+
+    # 19 TODO created_by
+    # 20 TODO creation_date
+    # 21
+    if term.is_obsolete is not None:
+        yield m.IsObsoleteMacro(s, term.is_obsolete)
+    # 22 replaced_by is covered by properties
+    # 23 consider is covered by properties
+
+
+def _get_annotations(
+    term: Stanza, p: Reference | Referenced, o: Reference | Referenced | OBOLiteral | str
+) -> list[f.Annotation]:
+    return _process_anns(term._get_annotations(p, o))
+
+
+def _process_anns(annotations: list[OBOAnnotation]) -> list[f.Annotation]:
+    """Convert OBO anotations to OFN annotations."""
+    return [_convert_annotation(a) for a in annotations]
+
+
+def _convert_annotation(annotation: OBOAnnotation) -> f.Annotation:
+    """Convert OBO anotations to OFN annotations."""
+    match annotation.value:
+        case OBOLiteral():
+            return f.Annotation(
+                annotation.predicate,
+                _oboliteral_to_literal(annotation.value),
+            )
+        case Reference():
+            return f.Annotation(
+                annotation.predicate,
+                annotation.value,
+            )
+    raise TypeError
+
+
+def get_typedef_axioms(typedef: TypeDef) -> Iterable[f.Box]:
+    """Iterate over functional OWL axioms for a typedef."""
+    r = f.IdentifierBox(typedef)
+    # 40
+    if typedef.is_metadata_tag:
+        yield f.Declaration(r, type="AnnotationProperty")
+    else:
+        yield f.Declaration(r, type="ObjectProperty")
+    # 2
+    if typedef.is_anonymous is not None:
+        yield m.IsAnonymousMacro(r, typedef.is_anonymous)
+    # 3
+    if typedef.name:
+        yield m.LabelMacro(r, typedef.name)
+    # 4
+    if typedef.namespace:
+        yield m.OBONamespaceMacro(r, typedef.namespace)
+    # 5 the way this one works is that all of the alts get a term-replaced-by,
+    #   as well as getting their own deprecation axioms
+    for alt_id in typedef.alt_ids:
+        yield m.ReplacedByMacro(alt_id, r)
+    # 6
+    yield from _yield_definition(typedef, r)
+    # 7
+    if typedef.comment:
+        yield m.CommentMacro(r, typedef.comment)
+    # 8
+    for subset in typedef.subsets:
+        yield m.OBOIsSubsetMacro(r, subset)
+    # 9
+    yield from _yield_synonyms(typedef, r)
+    # 10
+    yield from _yield_xrefs(typedef, r)
+    # 11
+    yield from _yield_properties(typedef, r)
+    # 12
+    if typedef.domain:
+        if typedef.is_metadata_tag:
+            yield f.AnnotationPropertyDomain(r, typedef.domain)
+        else:
+            yield f.ObjectPropertyDomain(r, typedef.domain)
+    # 13
+    if typedef.range:
+        if typedef.is_metadata_tag:
+            yield f.AnnotationPropertyRange(r, typedef.range)
+        else:
+            yield f.ObjectPropertyRange(r, typedef.range)
+    # 14
+    if typedef.builtin is not None:
+        yield m.IsOBOBuiltinMacro(r, typedef.builtin)
+    # 15
+    for chain in typedef.holds_over_chain:
+        yield m.HoldsOverChain(r, chain)
+    # 16
+    if typedef.is_anti_symmetric:
+        yield f.AsymmetricObjectProperty(r)
+    # 17
+    if typedef.is_cyclic is not None:
+        yield m.IsCyclic(r, typedef.is_cyclic)
+    # 18
+    if typedef.is_reflexive:
+        yield f.ReflexiveObjectProperty(r)
+    # 19
+    if typedef.is_symmetric:
+        yield f.SymmetricObjectProperty(r)
+    # 20
+    if typedef.is_transitive:
+        yield f.TransitiveObjectProperty(r)
+    # 21
+    if typedef.is_functional:
+        yield f.FunctionalObjectProperty(r)
+    # 22
+    if typedef.is_inverse_functional:
+        yield f.InverseFunctionalObjectProperty(r)
+    # 23
+    for parent in typedef.parents:
+        if typedef.is_metadata_tag:
+            yield f.SubAnnotationPropertyOf(r, parent)
+        else:
+            yield f.SubObjectPropertyOf(r, parent)
+    # 24 TODO intersection_of, ROBOT does not create any output
+    # 25 TODO union_of, ROBOT does not create any output
+    # 26
+    if typedef.equivalent_to:
+        yield f.EquivalentObjectProperties([r, *typedef.equivalent_to])
+    # 27
+    for x in typedef.disjoint_from:
+        yield f.DisjointObjectProperties([x, r])
+    # 28
+    if typedef.inverse:
+        yield f.InverseObjectProperties(r, typedef.inverse)
+    # 29
+    for to in typedef.transitive_over:
+        yield m.TransitiveOver(r, to)
+    # 30
+    for chain in typedef.equivalent_to_chain:
+        yield f.SubObjectPropertyOf(f.ObjectPropertyChain(chain), r)
+    # 31 TODO disjoint_over, ROBOT does not create any output
+    # 32 TODO relationship, ROBOT does not create any output
+    # 33
+    if typedef.is_obsolete is not None:
+        yield m.IsObsoleteMacro(r, typedef.is_obsolete)
+    # 34 TODO created_by
+    # 35 TODO creation_date
+    # 36
+    for rep in typedef.get_replaced_by():
+        yield m.ReplacedByMacro(rep, r)
+    # 37
+    for ref in typedef.get_see_also():
+        yield m.OBOConsiderMacro(r, ref)
+    # 38 TODO expand_assertion_to
+    # 39 TODO expand_expression_to
+    # 41
+    if typedef.is_class_level is not None:
+        yield m.OBOIsClassLevelMacro(r, typedef.is_class_level)
+
+
+def _yield_definition(term: Stanza, s) -> Iterable[m.DescriptionMacro]:
+    if term.definition:
+        yield m.DescriptionMacro(
+            s,
+            term.definition,
+            annotations=_get_annotations(term, pv.has_description, term.definition),
+        )
+
+
+def _yield_synonyms(stanza: Stanza, r) -> Iterable[m.SynonymMacro]:
+    for synonym in stanza.synonyms:
+        yield m.SynonymMacro(
+            r,
+            synonym.name,
+            scope=synonym.specificity,
+            synonym_type=synonym.type,
+            provenance=synonym.provenance,
+            annotations=_process_anns(synonym.annotations),
+            language=synonym.language,
+        )
+
+
+def _yield_xrefs(term: Stanza, s) -> Iterable[m.XrefMacro]:
+    for xref in term.xrefs:
+        yield m.XrefMacro(s, xref, annotations=_get_annotations(term, pv.has_dbxref, xref))
+
+
+_SKIP = {
+    # we skip alt terms since OFN
+    # prefers to flip the triple and use term-replaced-by instead
+    pv.alternative_term,
+}
+
+
+def _yield_properties(term: Stanza, s) -> Iterable[f.AnnotationAssertion]:
+    for typedef, values in term.properties.items():
+        for value in values:
+            annotations = _get_annotations(term, typedef, value)
+            match value:
+                case OBOLiteral():
+                    yield f.AnnotationAssertion(
+                        typedef,
+                        s,
+                        _oboliteral_to_literal(value),
+                        annotations=annotations,
+                    )
+                case Reference():
+                    if typedef in _SKIP:
+                        continue
+                    yield f.AnnotationAssertion(
+                        typedef,
+                        s,
+                        value,
+                        annotations=annotations,
+                    )

pyobo/struct/functional/ontology.py

@@ -0,0 +1,272 @@
+"""High-level ontology object model."""
+
+from __future__ import annotations
+
+import subprocess
+import tempfile
+from collections.abc import Sequence
+from pathlib import Path
+
+from curies import Converter
+from rdflib import OWL, RDF, Graph, term
+
+from pyobo.struct.functional.dsl import Annotation, Annotations, Axiom, Box
+from pyobo.struct.functional.utils import (
+    EXAMPLE_ONTOLOGY_IRI,
+    FunctionalOWLSerializable,
+    list_to_funowl,
+)
+from pyobo.utils.io import safe_open
+
+__all__ = [
+    "Document",
+    "Import",
+    "Ontology",
+    "Prefix",
+    "write_ontology",
+]
+
+
+def write_ontology(
+    *,
+    prefixes: dict[str, str] | list[Prefix],
+    iri: str | None = None,
+    version_iri: str | None = None,
+    directly_imports_documents: list[Import | str] | None = None,
+    annotations: Annotations | None = None,
+    axioms: list[Axiom] | None = None,
+    file=None,
+) -> None:
+    """Print an ontology serialized as functional OWL."""
+    ontology = Ontology(
+        iri=iri,
+        version_iri=version_iri,
+        directly_imports_documents=directly_imports_documents,
+        annotations=annotations,
+        axioms=axioms,
+    )
+    document = Document(ontology, prefixes)
+    print(document.to_funowl(), file=file)
+
+
+class Document:
+    """Represents a functional OWL document."""
+
+    prefixes: list[Prefix]
+    ontologies: list[Ontology]
+
+    def __init__(
+        self,
+        ontologies: Ontology | list[Ontology],
+        prefixes: dict[str, str] | list[Prefix],
+    ) -> None:
+        """Initialize a functional OWL document.
+
+        :param ontologies: An ontology or list of ontologies.
+
+            .. warning::
+
+                RDF export can only be used for a single ontology.
+
+        :param prefixes: A list of prefixes to define in the document
+
+            .. seealso::
+
+                `3.7 "Functional-Style Syntax"
+                <https://www.w3.org/TR/owl2-syntax/#Functional-Style_Syntax>`_
+        """
+        self.ontologies = ontologies if isinstance(ontologies, list) else [ontologies]
+        if isinstance(prefixes, dict):
+            self.prefixes = [
+                Prefix(prefix, uri_prefix)
+                for prefix, uri_prefix in sorted(prefixes.items(), key=lambda kv: kv[0].casefold())
+            ]
+        else:
+            self.prefixes = prefixes
+
+    @property
+    def prefix_map(self) -> dict[str, str]:
+        """Get a simple dictionary representation of prefixes."""
+        return {prefix.prefix: prefix.uri_prefix for prefix in self.prefixes}
+
+    def write_rdf(self, path: str | Path) -> None:
+        """Write RDF to a file."""
+        path = Path(path).expanduser().resolve()
+        graph = self.to_rdf()
+        graph.serialize(path, format="ttl")
+
+    def to_rdf(self) -> Graph:
+        """Get an RDFlib graph representing the ontology."""
+        if len(self.ontologies) != 1:
+            raise ValueError("Can only export one ontology to RDF")
+        graph = Graph()
+        for prefix_box in self.prefixes:
+            graph.namespace_manager.bind(prefix_box.prefix, prefix_box.uri_prefix)
+        converter = Converter.from_rdflib(graph)
+        for ontology in self.ontologies:
+            ontology.to_rdflib_node(graph, converter)
+        return graph
+
+    def write_funowl(self, path: str | Path) -> None:
+        """Write functional OWL to a file.."""
+        path = Path(path).expanduser().resolve()
+        with safe_open(path, read=False) as file:
+            file.write(self.to_funowl())
+
+    def to_funowl(self) -> str:
+        """Get the document as a functional OWL string."""
+        prefixes = list_to_funowl(self.prefixes, sep="\n")
+        ontologies = list_to_funowl(self.ontologies, sep="\n\n")
+        return prefixes + "\n\n" + ontologies
+
+
+class Ontology(Box):
+    """Represents an OWL 2 ontology defined in `3 "Ontologies" <https://www.w3.org/TR/owl2-syntax/#Ontologies>`_."""
+
+    directly_imports_documents: Sequence[Import]
+    annotations: Sequence[Annotation]
+    axioms: Sequence[Box]
+
+    def __init__(
+        self,
+        iri: str | None = None,
+        version_iri: str | None = None,
+        directly_imports_documents: list[Import | str] | None = None,
+        annotations: Annotations | None = None,
+        axioms: Sequence[Box] | None = None,
+    ) -> None:
+        """Instantiate an ontology.
+
+        :param iri: The ontology IRI.
+
+            .. seealso::
+
+                `3.1 "Ontology IRI and Version IRI"
+                <https://www.w3.org/TR/owl2-syntax/#Ontology_IRI_and_Version_IRI>`_
+
+        :param version_iri: An optional version IRI
+        :param directly_imports_documents: Optional ontology imports
+
+            .. seealso::
+
+                `3.4 "Imports" <https://www.w3.org/TR/owl2-syntax/#Imports>`_
+
+        :param annotations: .. seealso::
+
+            `3.5 "Ontology Annotations"
+            <https://www.w3.org/TR/owl2-syntax/#Ontology_Annotations>`_
+        :param axioms: statements about what is true in the domain
+
+            .. seealso::
+
+                `9 "Axioms" <https://www.w3.org/TR/owl2-syntax/#Axioms>`_
+        """
+        self.iri = iri
+        self.version_iri = version_iri
+        self.directly_imports_documents = [
+            Import(i) if isinstance(i, str) else i for i in directly_imports_documents or []
+        ]
+        self.annotations = annotations or []
+        self.axioms = axioms or []
+        # this is the amount of leading whitespace on each
+        # when outputting to functional OWL
+        self._leading = ""
+
+    def to_rdflib_node(self, graph: Graph, converter: Converter) -> term.URIRef | term.BNode:
+        """Add the ontology to the triple store."""
+        ontology_node = term.URIRef(self.iri) if self.iri is not None else term.BNode()
+        graph.add((ontology_node, RDF.type, OWL.Ontology))
+        if self.version_iri:
+            graph.add((ontology_node, OWL.versionIRI, term.URIRef(self.version_iri)))
+        for imp in self.directly_imports_documents:
+            graph.add((ontology_node, OWL.imports, term.URIRef(imp.iri)))
+        for annotation in self.annotations:
+            annotation._add_to_triple(graph, ontology_node, converter=converter)
+        for axiom in self.axioms:
+            axiom.to_rdflib_node(graph, converter)
+        return ontology_node
+
+    def to_funowl(self) -> str:
+        """Make functional OWL."""
+        tag = self.__class__.__name__
+        return f"{tag}({self.to_funowl_args()}\n)"
+
+    def to_funowl_args(self) -> str:
+        """Get the inside of the functional OWL tag representing the ontology."""
+        rv = ""
+        if self.iri:
+            rv += f"<{self.iri}>"
+            if self.version_iri:
+                rv += f" <{self.version_iri}>"
+        rv += f"\n{self._leading}"
+
+        parts: list[Sequence[FunctionalOWLSerializable]] = []
+        if self.directly_imports_documents:
+            parts.append(self.directly_imports_documents)
+        if self.annotations:
+            parts.append(self.annotations)
+        if self.axioms:
+            parts.append(self.axioms)
+
+        rv += f"\n\n{self._leading}".join(
+            list_to_funowl(part, sep=f"\n{self._leading}") for part in parts
+        )
+        return rv
+
+
+class Prefix(Box):
+    """A model for imports, as defined by `3.7 "Functional-Style Syntax" <https://www.w3.org/TR/owl2-syntax/#Functional-Style_Syntax>`_."""
+
+    def __init__(self, prefix: str, uri_prefix: str) -> None:
+        """Initialize the definition with a CURIE prefix and URI prefix."""
+        self.prefix = prefix
+        self.uri_prefix = uri_prefix
+
+    def to_rdflib_node(self, graph: Graph, converter: Converter) -> term.BNode:
+        """Add the prefix to an RDF graph."""
+        graph.namespace_manager.bind(self.prefix, self.uri_prefix)
+        return term.BNode()  # dummy
+
+    def to_funowl_args(self) -> str:
+        """Get the inside of the functional OWL tag representing the prefix."""
+        return f"{self.prefix}:=<{self.uri_prefix}>"
+
+
+class Import(Box):
+    """A model for imports, as defined by `3.4 "Imports" <https://www.w3.org/TR/owl2-syntax/#Imports>`_."""
+
+    def __init__(self, iri: str) -> None:
+        """Initialize the import."""
+        self.iri = iri
+
+    def to_rdflib_node(self, graph: Graph, converter: Converter) -> term.BNode:
+        """Add the import to an RDF graph."""
+        raise NotImplementedError
+
+    def to_funowl_args(self) -> str:
+        """Get the inside of the functional OWL tag representing the import."""
+        return f"<{self.iri}>"
+
+
+def get_rdf_graph_oracle(boxes: list[Box], *, prefix_map: dict[str, str]) -> Graph:
+    """Serialize to turtle via OFN and conversion with ROBOT."""
+    from bioontologies.robot import convert
+
+    ontology = Ontology(
+        iri=EXAMPLE_ONTOLOGY_IRI,
+        axioms=boxes,
+    )
+    document = Document(ontology, prefix_map)
+    graph = Graph()
+    with tempfile.TemporaryDirectory() as directory:
+        stub = Path(directory).joinpath("test")
+        ofn_path = stub.with_suffix(".ofn")
+        text = document.to_funowl()
+        ofn_path.write_text(text)
+        ttl_path = stub.with_suffix(".ttl")
+        try:
+            convert(ofn_path, ttl_path)
+        except subprocess.CalledProcessError:
+            raise RuntimeError(f"failed to convert axioms from:\n\n{text}") from None
+        graph.parse(ttl_path)
+    return graph