Skip to content

Graph-Native Infrastructure for Context and Accountable AI Systems

fix(export): read the ontology shape the generator actually emits (#1103)

FABIOTESSc30ec14858f2
diff --git a/semantica/export/owl_exporter.py b/semantica/export/owl_exporter.py
index 3c604d59..6770ddeb 100644
--- a/semantica/export/owl_exporter.py
+++ b/semantica/export/owl_exporter.py
@@ -22,6 +22,7 @@ Author: Semantica Contributors
License: MIT
"""
+import re
from datetime import datetime
from pathlib import Path
from typing import Any, Dict, List, Optional, Union
@@ -225,6 +226,7 @@ class OWLExporter:
Returns:
String containing OWL-XML serialization
"""
+ esc_xml = self._escape_xml
ontology_uri = ontology.get("uri") or self.ontology_uri
ontology_name = ontology.get("name", "SemanticaOntology")
version = ontology.get("version") or self.version
@@ -237,97 +239,125 @@ class OWLExporter:
lines.append("")
# Ontology declaration
- lines.append(f' <owl:Ontology rdf:about="{ontology_uri}">')
- lines.append(f" <rdfs:label>{ontology_name}</rdfs:label>")
- lines.append(f" <owl:versionInfo>{version}</owl:versionInfo>")
+ lines.append(f' <owl:Ontology rdf:about="{esc_xml(ontology_uri)}">')
+ lines.append(f" <rdfs:label>{esc_xml(ontology_name)}</rdfs:label>")
+ lines.append(f" <owl:versionInfo>{esc_xml(version)}</owl:versionInfo>")
if ontology.get("description"):
lines.append(
- f' <rdfs:comment>{ontology.get("description")}</rdfs:comment>'
+ f' <rdfs:comment>{esc_xml(ontology.get("description"))}</rdfs:comment>'
)
lines.append(" </owl:Ontology>")
lines.append("")
+ class_index = self._class_iri_index(ontology, ontology_uri)
+ object_properties, data_properties = self._split_properties(ontology)
+
+ def _as_list(value):
+ if value is None:
+ return []
+ return value if isinstance(value, list) else [value]
+
# Classes
- classes = ontology.get("classes", [])
- for cls in classes:
- class_uri = cls.get("uri") or cls.get("id", "")
+ for cls in ontology.get("classes", []) or []:
+ if not isinstance(cls, dict):
+ continue
+ class_uri = self._term_iri(cls, ontology_uri)
+ if not class_uri:
+ self.logger.warning(
+ "Skipping a class with no name, uri or id: it would serialise "
+ "as an empty rdf:about"
+ )
+ continue
class_name = cls.get("name") or cls.get("label", "")
- lines.append(f' <owl:Class rdf:about="{class_uri}">')
- lines.append(f" <rdfs:label>{class_name}</rdfs:label>")
+ lines.append(f' <owl:Class rdf:about="{esc_xml(class_uri)}">')
+ lines.append(f" <rdfs:label>{esc_xml(class_name)}</rdfs:label>")
- if cls.get("comment"):
- lines.append(f' <rdfs:comment>{cls.get("comment")}</rdfs:comment>')
+ comment = cls.get("comment") or cls.get("description")
+ if comment:
+ lines.append(f" <rdfs:comment>{esc_xml(comment)}</rdfs:comment>")
# Subclass relationships
- if cls.get("subClassOf"):
- parent = cls.get("subClassOf")
- lines.append(f' <rdfs:subClassOf rdf:resource="{parent}"/>')
+ for parent in _as_list(cls.get("subClassOf") or cls.get("parent")):
+ parent_iri = self._resolve_class_ref(parent, ontology_uri, class_index)
+ if parent_iri:
+ lines.append(
+ f' <rdfs:subClassOf rdf:resource="{esc_xml(parent_iri)}"/>'
+ )
# Equivalent classes
- if cls.get("equivalentClass"):
- equiv = cls.get("equivalentClass")
- lines.append(f' <owl:equivalentClass rdf:resource="{equiv}"/>')
+ for equiv in _as_list(cls.get("equivalentClass")):
+ equiv_iri = self._resolve_class_ref(equiv, ontology_uri, class_index)
+ if equiv_iri:
+ lines.append(
+ f' <owl:equivalentClass rdf:resource="{esc_xml(equiv_iri)}"/>'
+ )
lines.append(" </owl:Class>")
lines.append("")
# Object properties
- object_properties = ontology.get("object_properties", [])
for prop in object_properties:
- prop_uri = prop.get("uri") or prop.get("id", "")
+ prop_uri = self._term_iri(prop, ontology_uri)
+ if not prop_uri:
+ self.logger.warning(
+ "Skipping an object property with no name, uri or id"
+ )
+ continue
prop_name = prop.get("name") or prop.get("label", "")
- lines.append(f' <owl:ObjectProperty rdf:about="{prop_uri}">')
- lines.append(f" <rdfs:label>{prop_name}</rdfs:label>")
-
- if prop.get("comment"):
- lines.append(f' <rdfs:comment>{prop.get("comment")}</rdfs:comment>')
-
- # Domain
- if prop.get("domain"):
- domain = prop.get("domain")
- if isinstance(domain, list):
- for d in domain:
- lines.append(f' <rdfs:domain rdf:resource="{d}"/>')
- else:
- lines.append(f' <rdfs:domain rdf:resource="{domain}"/>')
-
- # Range
- if prop.get("range"):
- range_val = prop.get("range")
- if isinstance(range_val, list):
- for r in range_val:
- lines.append(f' <rdfs:range rdf:resource="{r}"/>')
- else:
- lines.append(f' <rdfs:range rdf:resource="{range_val}"/>')
+ lines.append(f' <owl:ObjectProperty rdf:about="{esc_xml(prop_uri)}">')
+ lines.append(f" <rdfs:label>{esc_xml(prop_name)}</rdfs:label>")
+
+ comment = prop.get("comment") or prop.get("description")
+ if comment:
+ lines.append(f" <rdfs:comment>{esc_xml(comment)}</rdfs:comment>")
+
+ for domain in _as_list(prop.get("domain")):
+ domain_iri = self._resolve_class_ref(domain, ontology_uri, class_index)
+ if domain_iri:
+ lines.append(
+ f' <rdfs:domain rdf:resource="{esc_xml(domain_iri)}"/>'
+ )
+
+ for range_val in _as_list(prop.get("range")):
+ range_iri = self._resolve_class_ref(range_val, ontology_uri, class_index)
+ if range_iri:
+ lines.append(
+ f' <rdfs:range rdf:resource="{esc_xml(range_iri)}"/>'
+ )
lines.append(" </owl:ObjectProperty>")
lines.append("")
# Data properties
- data_properties = ontology.get("data_properties", [])
for prop in data_properties:
- prop_uri = prop.get("uri") or prop.get("id", "")
+ prop_uri = self._term_iri(prop, ontology_uri)
+ if not prop_uri:
+ self.logger.warning("Skipping a data property with no name, uri or id")
+ continue
prop_name = prop.get("name") or prop.get("label", "")
- lines.append(f' <owl:DatatypeProperty rdf:about="{prop_uri}">')
- lines.append(f" <rdfs:label>{prop_name}</rdfs:label>")
-
- if prop.get("comment"):
- lines.append(f' <rdfs:comment>{prop.get("comment")}</rdfs:comment>')
-
- # Domain
- if prop.get("domain"):
- domain = prop.get("domain")
- lines.append(f' <rdfs:domain rdf:resource="{domain}"/>')
+ lines.append(f' <owl:DatatypeProperty rdf:about="{esc_xml(prop_uri)}">')
+ lines.append(f" <rdfs:label>{esc_xml(prop_name)}</rdfs:label>")
- # Range
- if prop.get("range"):
- range_type = prop.get("range", "xsd:string")
- lines.append(
- f' <rdfs:range rdf:resource="http://www.w3.org/2001/XMLSchema#{range_type}"/>'
- )
+ comment = prop.get("comment") or prop.get("description")
+ if comment:
+ lines.append(f" <rdfs:comment>{esc_xml(comment)}</rdfs:comment>")
+
+ for domain in _as_list(prop.get("domain")):
+ domain_iri = self._resolve_class_ref(domain, ontology_uri, class_index)
+ if domain_iri:
+ lines.append(
+ f' <rdfs:domain rdf:resource="{esc_xml(domain_iri)}"/>'
+ )
+
+ for range_val in _as_list(prop.get("range")):
+ range_iri = self._resolve_datatype_iri(range_val)
+ if range_iri:
+ lines.append(
+ f' <rdfs:range rdf:resource="{esc_xml(range_iri)}"/>'
+ )
lines.append(" </owl:DatatypeProperty>")
lines.append("")
@@ -335,6 +365,161 @@ class OWLExporter:
lines.append("</rdf:RDF>")
return "\n".join(lines)
+ # ── Ontology-dict normalisation ───────────────────────────────────────────
+ #
+ # OntologyGenerator emits a single `properties` list tagged with
+ # type/@type, while hand-authored ontologies use `object_properties` and
+ # `data_properties`. Both shapes are accepted; everything below works from
+ # the normalised view so the two cannot drift apart again (#1103).
+
+ _XSD_NS = "http://www.w3.org/2001/XMLSchema#"
+
+ @staticmethod
+ def _is_absolute_iri(value: str) -> bool:
+ return bool(re.match(r"^[A-Za-z][A-Za-z0-9+.\-]*:", value))
+
+ @classmethod
+ def _join_iri(cls, base: str, local: str) -> str:
+ """Append a local name to a base IRI, respecting hash and slash bases."""
+ if not base:
+ return ""
+ separator = "" if base.endswith(("#", "/", ":")) else "#"
+ return f"{base}{separator}{local}"
+
+ @classmethod
+ def _term_iri(cls, term: Dict[str, Any], base: str) -> str:
+ """
+ Resolve the IRI of a class or property.
+
+ Returns "" when the term carries nothing usable, so the caller can skip
+ it. Interpolating an empty string into <> silently resolves against the
+ parser's base — under rdflib that is the current working directory — and
+ collapses every such term onto one subject.
+ """
+ for key in ("uri", "iri", "id"):
+ value = term.get(key)
+ if isinstance(value, str) and value.strip():
+ value = value.strip()
+ return value if cls._is_absolute_iri(value) else cls._join_iri(base, value)
+
+ name = term.get("name") or term.get("label")
+ if isinstance(name, str) and name.strip():
+ return cls._join_iri(base, name.strip())
+ return ""
+
+ @classmethod
+ def _class_iri_index(cls, ontology: Dict[str, Any], base: str) -> Dict[str, str]:
+ """Map class name and label to the IRI that class is actually exported under."""
+ index: Dict[str, str] = {}
+ for class_def in ontology.get("classes", []) or []:
+ if not isinstance(class_def, dict):
+ continue
+ iri = cls._term_iri(class_def, base)
+ if not iri:
+ continue
+ for key in (class_def.get("name"), class_def.get("label")):
+ if isinstance(key, str) and key.strip():
+ index.setdefault(key.strip(), iri)
+ return index
+
+ @classmethod
+ def _resolve_class_ref(cls, value: Any, base: str, index: Dict[str, str]) -> str:
+ """
+ Resolve a domain/range reference to an absolute IRI.
+
+ The generator writes bare class names here. Looking the name up in the
+ class index first means a reference always lands on the IRI that class
+ was exported under, rather than on a re-derived guess.
+ """
+ if not isinstance(value, str) or not value.strip():
+ return ""
+ value = value.strip()
+ if cls._is_absolute_iri(value):
+ return value
+ if value in index:
+ return index[value]
+ if ":" in value: # a prefixed name we cannot expand
+ return ""
+ return cls._join_iri(base, value)
+
+ @classmethod
+ def _resolve_datatype_iri(cls, value: Any) -> str:
+ """
+ Resolve a data property range to an absolute datatype IRI.
+
+ Accepts "string", "xsd:string" and a full IRI alike. The previous
+ `xsd:{range}` interpolation doubled the prefix whenever the generator
+ had already written "xsd:string".
+ """
+ if not isinstance(value, str) or not value.strip():
+ return ""
+ value = value.strip()
+ if value.startswith(("xsd:", "XSD:")):
+ return cls._XSD_NS + value.split(":", 1)[1]
+ if cls._is_absolute_iri(value):
+ return value
+ return cls._XSD_NS + value
+
+ @classmethod
+ def _ttl_datatype_ref(cls, value: Any) -> str:
+ """
+ Render a data property range for Turtle.
+
+ XSD datatypes are written with the xsd: prefix the header already
+ declares; anything else is written as a full IRI. Both are the same
+ term, this only keeps the compact style the module was written in.
+ """
+ iri = cls._resolve_datatype_iri(value)
+ if not iri:
+ return ""
+ if iri.startswith(cls._XSD_NS):
+ return f"xsd:{iri[len(cls._XSD_NS):]}"
+ return f"<{iri}>"
+
+ @classmethod
+ def _split_properties(
+ cls, ontology: Dict[str, Any]
+ ) -> "tuple[List[Dict[str, Any]], List[Dict[str, Any]]]":
+ """
+ Return (object_properties, data_properties) across both dict shapes.
+
+ A property listed under an explicit key keeps that key's kind. A
+ property from the generator's combined `properties` list is classified
+ by its own type/@type, defaulting to a data property.
+ """
+ object_props: List[Dict[str, Any]] = []
+ data_props: List[Dict[str, Any]] = []
+
+ for prop in ontology.get("object_properties", []) or []:
+ if isinstance(prop, dict):
+ object_props.append(prop)
+ for prop in ontology.get("data_properties", []) or []:
+ if isinstance(prop, dict):
+ data_props.append(prop)
+
+ for prop in ontology.get("properties", []) or []:
+ if not isinstance(prop, dict):
+ continue
+ kind = str(prop.get("type") or "").strip().lower()
+ owl_type = str(prop.get("@type") or "").strip().lower()
+ if kind in ("object", "objectproperty") or owl_type.endswith("objectproperty"):
+ object_props.append(prop)
+ else:
+ data_props.append(prop)
+
+ return object_props, data_props
+
+ @staticmethod
+ def _escape_xml(value: Any) -> str:
+ """Escape a value for safe embedding in XML text or an attribute value."""
+ return (
+ str(value)
+ .replace("&", "&amp;")
+ .replace("<", "&lt;")
+ .replace(">", "&gt;")
+ .replace('"', "&quot;")
+ )
+
@staticmethod
def _escape_ttl_str(value: str) -> str:
"""Escape a string value for safe embedding in a Turtle string literal."""
@@ -387,62 +572,83 @@ class OWLExporter:
lines.append(self._ttl_block(ontology_uri, "owl:Ontology", onto_predicates))
lines.append("")
+ class_index = self._class_iri_index(ontology, ontology_uri)
+ object_properties, data_properties = self._split_properties(ontology)
+
+ def _as_list(value):
+ if value is None:
+ return []
+ return value if isinstance(value, list) else [value]
+
# Classes
- for cls in ontology.get("classes", []):
- class_uri = cls.get("uri") or cls.get("id", "")
+ for cls in ontology.get("classes", []) or []:
+ if not isinstance(cls, dict):
+ continue
+ class_uri = self._term_iri(cls, ontology_uri)
+ if not class_uri:
+ self.logger.warning(
+ "Skipping a class with no name, uri or id: it would serialise as <>"
+ )
+ continue
class_name = cls.get("name") or cls.get("label", "")
predicates = [f'rdfs:label "{esc(class_name)}"']
- comment = cls.get("comment")
+ comment = cls.get("comment") or cls.get("description")
if comment:
predicates.append(f'rdfs:comment "{esc(comment)}"')
- sub_class = cls.get("subClassOf")
- if sub_class:
- predicates.append(f"rdfs:subClassOf <{sub_class}>")
- equiv = cls.get("equivalentClass")
- if equiv:
- predicates.append(f"owl:equivalentClass <{equiv}>")
+ for parent in _as_list(cls.get("subClassOf") or cls.get("parent")):
+ parent_iri = self._resolve_class_ref(parent, ontology_uri, class_index)
+ if parent_iri:
+ predicates.append(f"rdfs:subClassOf <{parent_iri}>")
+ for equiv in _as_list(cls.get("equivalentClass")):
+ equiv_iri = self._resolve_class_ref(equiv, ontology_uri, class_index)
+ if equiv_iri:
+ predicates.append(f"owl:equivalentClass <{equiv_iri}>")
lines.append(self._ttl_block(class_uri, "owl:Class", predicates))
lines.append("")
# Object properties
- for prop in ontology.get("object_properties", []):
- prop_uri = prop.get("uri") or prop.get("id", "")
+ for prop in object_properties:
+ prop_uri = self._term_iri(prop, ontology_uri)
+ if not prop_uri:
+ self.logger.warning(
+ "Skipping an object property with no name, uri or id"
+ )
+ continue
prop_name = prop.get("name") or prop.get("label", "")
predicates = [f'rdfs:label "{esc(prop_name)}"']
- comment = prop.get("comment")
+ comment = prop.get("comment") or prop.get("description")
if comment:
predicates.append(f'rdfs:comment "{esc(comment)}"')
- domain = prop.get("domain")
- if domain:
- if isinstance(domain, list):
- for d in domain:
- predicates.append(f"rdfs:domain <{d}>")
- else:
- predicates.append(f"rdfs:domain <{domain}>")
- range_val = prop.get("range")
- if range_val:
- if isinstance(range_val, list):
- for r in range_val:
- predicates.append(f"rdfs:range <{r}>")
- else:
- predicates.append(f"rdfs:range <{range_val}>")
+ for domain in _as_list(prop.get("domain")):
+ domain_iri = self._resolve_class_ref(domain, ontology_uri, class_index)
+ if domain_iri:
+ predicates.append(f"rdfs:domain <{domain_iri}>")
+ for range_val in _as_list(prop.get("range")):
+ range_iri = self._resolve_class_ref(range_val, ontology_uri, class_index)
+ if range_iri:
+ predicates.append(f"rdfs:range <{range_iri}>")
lines.append(self._ttl_block(prop_uri, "owl:ObjectProperty", predicates))
lines.append("")
# Data properties
- for prop in ontology.get("data_properties", []):
- prop_uri = prop.get("uri") or prop.get("id", "")
+ for prop in data_properties:
+ prop_uri = self._term_iri(prop, ontology_uri)
+ if not prop_uri:
+ self.logger.warning("Skipping a data property with no name, uri or id")
+ continue
prop_name = prop.get("name") or prop.get("label", "")
predicates = [f'rdfs:label "{esc(prop_name)}"']
- comment = prop.get("comment")
+ comment = prop.get("comment") or prop.get("description")
if comment:
predicates.append(f'rdfs:comment "{esc(comment)}"')
- domain = prop.get("domain")
- if domain:
- predicates.append(f"rdfs:domain <{domain}>")
- range_type = prop.get("range")
- if range_type:
- predicates.append(f"rdfs:range xsd:{range_type}")
+ for domain in _as_list(prop.get("domain")):
+ domain_iri = self._resolve_class_ref(domain, ontology_uri, class_index)
+ if domain_iri:
+ predicates.append(f"rdfs:domain <{domain_iri}>")
+ for range_val in _as_list(prop.get("range")):
+ range_ref = self._ttl_datatype_ref(range_val)
+ if range_ref:
+ predicates.append(f"rdfs:range {range_ref}")
lines.append(self._ttl_block(prop_uri, "owl:DatatypeProperty", predicates))
lines.append("")
diff --git a/semantica/ontology/ontology_generator.py b/semantica/ontology/ontology_generator.py
index 80851f63..db5ae460 100644
--- a/semantica/ontology/ontology_generator.py
+++ b/semantica/ontology/ontology_generator.py
@@ -438,10 +438,13 @@ class OntologyGenerator:
entities=entities, relationships=relationships, classes=classes, **prop_options
)
- # Add types to classes
+ # Add types to classes.
+ # ClassInferrer sets "uri": None when it was given no namespace manager,
+ # so the key is present and a `not in` guard never fires: every class
+ # then reached the exporters with no IRI at all (#1103).
for cls in classes:
cls["@type"] = "owl:Class"
- if "uri" not in cls:
+ if not cls.get("uri"):
cls["uri"] = self.namespace_manager.generate_class_iri(cls["name"])
# Add types to properties
@@ -451,7 +454,7 @@ class OntologyGenerator:
else:
prop["@type"] = "owl:DatatypeProperty"
- if "uri" not in prop:
+ if not prop.get("uri"):
prop["uri"] = self.namespace_manager.generate_property_iri(prop["name"])
return {
@@ -692,12 +695,16 @@ class OntologyOptimizer:
Returns:
Improved ontology
"""
- # Ensure all classes have required fields
+ # Ensure all classes have required fields. Both guards used `not in`,
+ # which misses a key that is present and None, and the URI fallback
+ # assigned a bare class name where an absolute IRI is required (#1103).
classes = ontology.get("classes", [])
for cls in classes:
- if "uri" not in cls:
- cls["uri"] = cls.get("name", "Entity")
- if "label" not in cls:
+ if not cls.get("uri"):
+ cls["uri"] = self.namespace_manager.generate_class_iri(
+ cls.get("name", "Entity")
+ )
+ if not cls.get("label"):
cls["label"] = cls.get("name", "Entity")
# Ensure all properties have domains and ranges
diff --git a/tests/export/test_owl_exporter_generator_schema.py b/tests/export/test_owl_exporter_generator_schema.py
new file mode 100644
index 00000000..db65ca70
--- /dev/null
+++ b/tests/export/test_owl_exporter_generator_schema.py
@@ -0,0 +1,181 @@
+"""
+Regression tests for #1103.
+
+OWLExporter read `object_properties` / `data_properties` while OntologyGenerator
+emits a single `properties` list, so every generated property was dropped. Class
+IRIs arrived as None and were interpolated into `<>`, collapsing every class onto
+the empty relative IRI, so an ontology of N classes serialised as one node
+carrying N labels.
+
+These tests drive the exporter with what the generator actually produces, and
+assert on the parsed graph rather than on the serialised text.
+"""
+
+import pytest
+
+rdflib = pytest.importorskip("rdflib")
+from rdflib import Graph, RDF, RDFS, OWL, URIRef, Literal # noqa: E402
+
+from semantica.export.owl_exporter import OWLExporter # noqa: E402
+from semantica.ontology.ontology_generator import OntologyGenerator # noqa: E402
+
+XSD = "http://www.w3.org/2001/XMLSchema#"
+
+
[email protected](scope="module")
+def generated_ontology():
+ """A real OntologyGenerator run, not a hand-written stand-in."""
+ data = {
+ "entities": [
+ {"type": "Person", "name": "John", "age": 30},
+ {"type": "Person", "name": "Jane", "age": 25},
+ {"type": "Organization", "name": "Acme"},
+ {"type": "Organization", "name": "Globex"},
+ ],
+ "relationships": [
+ {"source": "John", "target": "Acme", "type": "works_at"},
+ {"source": "Jane", "target": "Globex", "type": "works_at"},
+ ],
+ }
+ return OntologyGenerator().generate_ontology(data)
+
+
[email protected](scope="module")
+def turtle_graph(generated_ontology):
+ ttl = OWLExporter()._export_owl_turtle(generated_ontology)
+ graph = Graph()
+ graph.parse(data=ttl, format="turtle")
+ return graph
+
+
[email protected](scope="module")
+def xml_graph(generated_ontology):
+ xml = OWLExporter()._export_owl_xml(generated_ontology)
+ graph = Graph()
+ graph.parse(data=xml, format="xml")
+ return graph
+
+
+def test_generator_mints_class_iris(generated_ontology):
+ """The `uri` key is present with a None value, so a `not in` guard misses it."""
+ classes = generated_ontology["classes"]
+ assert classes, "fixture produced no classes"
+ for cls in classes:
+ assert cls.get("uri"), f"class {cls.get('name')!r} has no URI: {cls.get('uri')!r}"
+ assert str(cls["uri"]).startswith("http"), cls["uri"]
+
+
+def test_every_class_is_a_distinct_absolute_iri(turtle_graph, generated_ontology):
+ subjects = set(turtle_graph.subjects(RDF.type, OWL.Class))
+ assert len(subjects) == len(generated_ontology["classes"])
+ for subject in subjects:
+ assert isinstance(subject, URIRef)
+ assert str(subject) != "", "class collapsed onto the empty relative IRI"
+ assert str(subject).startswith("http"), subject
+
+
+def test_class_labels_are_not_stacked_on_one_node(turtle_graph):
+ """Two classes must not share a subject and pile up two rdfs:label values."""
+ for subject in set(turtle_graph.subjects(RDF.type, OWL.Class)):
+ labels = list(turtle_graph.objects(subject, RDFS.label))
+ assert len(labels) == 1, f"{subject} carries {len(labels)} labels: {labels}"
+
+
+def test_no_generated_property_is_dropped(turtle_graph, generated_ontology):
+ declared = set(turtle_graph.subjects(RDF.type, OWL.ObjectProperty)) | set(
+ turtle_graph.subjects(RDF.type, OWL.DatatypeProperty)
+ )
+ expected = {URIRef(p["uri"]) for p in generated_ontology["properties"]}
+ assert expected, "fixture produced no properties"
+ assert expected <= declared, f"dropped: {expected - declared}"
+
+
+def test_properties_keep_their_owl_type(turtle_graph, generated_ontology):
+ by_uri = {p["uri"]: p for p in generated_ontology["properties"]}
+ for uri, prop in by_uri.items():
+ expected = OWL.ObjectProperty if prop["type"] == "object" else OWL.DatatypeProperty
+ assert (URIRef(uri), RDF.type, expected) in turtle_graph, (
+ f"{prop['name']} ({prop['type']}) is not typed {expected}"
+ )
+
+
+def test_object_property_domain_and_range_are_class_iris(turtle_graph, generated_ontology):
+ """The generator emits bare class names; they must resolve, not stay relative."""
+ class_iris = {URIRef(c["uri"]) for c in generated_ontology["classes"]}
+ obj_props = [p for p in generated_ontology["properties"] if p["type"] == "object"]
+ assert obj_props, "fixture produced no object properties"
+ for prop in obj_props:
+ subject = URIRef(prop["uri"])
+ for predicate in (RDFS.domain, RDFS.range):
+ values = list(turtle_graph.objects(subject, predicate))
+ assert values, f"{prop['name']} has no {predicate}"
+ for value in values:
+ assert value in class_iris, f"{prop['name']} {predicate} = {value!r}"
+
+
+def test_data_property_range_is_a_single_well_formed_xsd_iri(turtle_graph, generated_ontology):
+ """`rdfs:range xsd:{range}` doubled the prefix when range was already 'xsd:string'."""
+ data_props = [p for p in generated_ontology["properties"] if p["type"] != "object"]
+ assert data_props, "fixture produced no data properties"
+ for prop in data_props:
+ ranges = list(turtle_graph.objects(URIRef(prop["uri"]), RDFS.range))
+ assert ranges, f"{prop['name']} has no range"
+ for value in ranges:
+ assert str(value).startswith(XSD), f"{prop['name']} range = {value!r}"
+ assert "xsd:" not in str(value), f"doubled prefix: {value!r}"
+
+
+def test_xml_and_turtle_describe_the_same_ontology(turtle_graph, xml_graph):
+ """The two serialisations of one ontology must not be different graphs."""
+ def summary(graph):
+ return {
+ "classes": set(graph.subjects(RDF.type, OWL.Class)),
+ "object_properties": set(graph.subjects(RDF.type, OWL.ObjectProperty)),
+ "data_properties": set(graph.subjects(RDF.type, OWL.DatatypeProperty)),
+ }
+
+ assert summary(turtle_graph) == summary(xml_graph)
+
+
+def test_explicit_object_and_data_property_keys_still_work():
+ """The pre-existing hand-authored shape must keep working."""
+ ontology = {
+ "uri": "https://example.org/onto/",
+ "name": "Hand",
+ "classes": [{"uri": "https://example.org/onto/Person", "name": "Person"}],
+ "object_properties": [
+ {
+ "uri": "https://example.org/onto/knows",
+ "name": "knows",
+ "domain": "https://example.org/onto/Person",
+ "range": "https://example.org/onto/Person",
+ }
+ ],
+ "data_properties": [
+ {"uri": "https://example.org/onto/age", "name": "age", "range": "integer"}
+ ],
+ }
+ graph = Graph()
+ graph.parse(data=OWLExporter()._export_owl_turtle(ontology), format="turtle")
+
+ assert (URIRef("https://example.org/onto/knows"), RDF.type, OWL.ObjectProperty) in graph
+ assert (URIRef("https://example.org/onto/age"), RDF.type, OWL.DatatypeProperty) in graph
+ assert (
+ URIRef("https://example.org/onto/age"),
+ RDFS.range,
+ URIRef(XSD + "integer"),
+ ) in graph
+
+
+def test_a_class_without_any_identifier_is_skipped_not_emitted_as_empty():
+ """An unusable class must not become `<>` and swallow the document IRI."""
+ ontology = {
+ "uri": "https://example.org/onto/",
+ "name": "Partial",
+ "classes": [{"comment": "no name, no uri, no id"}],
+ }
+ graph = Graph()
+ graph.parse(data=OWLExporter()._export_owl_turtle(ontology), format="turtle")
+
+ assert set(graph.subjects(RDF.type, OWL.Class)) == set()
+ assert (URIRef("https://example.org/onto/"), RDF.type, OWL.Ontology) in graph