Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
28 changes: 20 additions & 8 deletions lode/models/datatypeRestriction.py
Original file line number Diff line number Diff line change
Expand Up @@ -2,27 +2,39 @@
from .restriction import Restriction

class DatatypeRestriction(Restriction):
"""A datatype narrowed by an XSD facet, such as a pattern or a minimum value."""
"""A datatype narrowed by XSD facet/value pairs, such as numeric bounds."""

def __init__(self, **kwargs):
"""Create a datatype restriction with no datatype and no facet value."""
"""Create a datatype restriction with no base datatype or facets."""
super().__init__(**kwargs)
self.applies_on_concept = None # Datatype (from owl:onDatatype) string (xsd:pattern, xsd:minInclusive, ...)
self.has_restriction_value = None # Literal (the corresponding value e.g. 0.0)
self.applies_on_concept = None # Datatype from owl:onDatatype
self.has_facets = [] # Ordered (facet operator, Literal) pairs
self.has_restriction_value = None # Last value, for single-facet callers


def get_applies_on_concept(self):
"""Return applies_on_concept (the datatype, or the facet string)."""
"""Return the base datatype."""
return self.applies_on_concept

def set_applies_on_concept(self, datatype):
"""Set applies_on_concept (the datatype, or the facet string)."""
"""Set the base datatype without changing its facets."""
self.applies_on_concept = datatype

def set_has_facet(self, constraint, value):
"""Add a facet/value pair, preserving its association and list order."""
pair = (constraint, value)
if pair not in self.has_facets:
self.has_facets.append(pair)
self.set_has_restriction_value(value)

def get_has_facets(self):
"""Return a copy of all facet/value pairs."""
return list(self.has_facets)

def set_has_restriction_value(self, string):
"""Set has_restriction_value (the literal value of the facet)."""
self.has_restriction_value = string

def get_has_restriction_value(self):
"""Return has_restriction_value (the literal value of the facet)."""
return self.has_restriction_value
"""Return the last facet value; use get_has_facets() for all constraints."""
return self.has_restriction_value
7 changes: 3 additions & 4 deletions lode/reader/logic/owl_logic.py
Original file line number Diff line number Diff line change
Expand Up @@ -741,7 +741,7 @@ def handle_disjoint_union(self, instance, uri, predicate, obj, setter=None):
logger.warning("disjointUnion failed for %s", uri, exc_info=True)

def handle_datatype_restriction(self, instance, uri, predicate, obj, setter=None):
"""Handle owl:withRestrictions on a datatype: set the datatype and one facet value per facet.
"""Handle owl:withRestrictions: preserve the base datatype and every facet/value pair.

Facet nodes (e.g. xsd:minInclusive) are cached and tracked, so phase 6
does not turn them into Statements.
Expand Down Expand Up @@ -769,9 +769,8 @@ def handle_datatype_restriction(self, instance, uri, predicate, obj, setter=None
str(XSD.maxLength): "maxLength",
}
manchester_facet = FACET_MAP.get(str(facet_pred), str(facet_pred))
instance.set_applies_on_concept(manchester_facet)
literal = self._create_literal(facet_val)
instance.set_has_restriction_value(literal)
instance.set_has_facet(manchester_facet, literal)

# Register facet node in cache keyed to the parent DatatypeRestriction
# and mark all its triples as mapped, so phase6 does not create
Expand Down Expand Up @@ -1101,4 +1100,4 @@ def _uri_in_axiom_members(self, axiom_node, uri_ref):
if first == uri_ref:
return True
node = self.graph.value(node, RDF.rest)
return False
return False
19 changes: 10 additions & 9 deletions lode/viewer/owl_viewer.py
Original file line number Diff line number Diff line change
Expand Up @@ -158,22 +158,23 @@ def _get(instance, prop_name, default=None):
parts.extend(self._parse_restriction(resource, language, _seen))

elif obj_type == "DatatypeRestriction":
concept = _get(obj, 'applies_on_concept') # Datatype(xsd:string)
constraint = _get(obj, 'has_constraint') # "pattern"
value = _get(obj, 'has_restriction_value') # Literal("[0-9]+")
concept = _get(obj, 'applies_on_concept')
facets = _get(obj, 'has_facets', [])

# Safely check if the is_inverse flag is True
is_inv = obj.get_is_inverse() if hasattr(obj, 'get_is_inverse') else getattr(obj, 'is_inverse', False)
if is_inv:
parts.append({'text': 'inverse of ', 'link': None, 'type': 'Text'})

parts.extend(self._parse_restriction(concept, language, _seen))
if constraint:
parts.append({'text': f' with {constraint} ', 'link': None, 'type': 'Text'})
else:
parts.append({'text': ' restricted by ', 'link': None, 'type': 'Text'})

parts.extend(self._parse_restriction(value, language, _seen))
if facets:
parts.append({'text': '[', 'link': None, 'type': 'Text'})
for i, (constraint, value) in enumerate(facets):
if i > 0:
parts.append({'text': ', ', 'link': None, 'type': 'Text'})
parts.append({'text': f'{constraint} ', 'link': None, 'type': 'Text'})
parts.extend(self._parse_restriction(value, language, _seen))
parts.append({'text': ']', 'link': None, 'type': 'Text'})

return parts

Expand Down
113 changes: 113 additions & 0 deletions tests/test_datatype_restrictions.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,113 @@
"""Offline regressions for datatype facets in the reader and generated HTML."""
from html.parser import HTMLParser

import pytest
from rdflib import Graph, Namespace
from rdflib.compare import isomorphic
from rdflib.namespace import XSD

from lode.builder import build_html
from lode.models import Datatype, DatatypeRestriction
from lode.reader import Reader


EX = Namespace("http://example.org/ranges#")
CASES = [
("actOrder", "integer", "[ xsd:minInclusive 1 ] [ xsd:maxInclusive 3 ]",
"integer[>= 1, <= 3]"),
("stageOrder", "integer", "[ xsd:minInclusive 1 ] [ xsd:maxInclusive 17 ]",
"integer[>= 1, <= 17]"),
("fitScore", "integer", "[ xsd:minInclusive -1 ] [ xsd:maxInclusive 4 ]",
"integer[>= -1, <= 4]"),
("reversed", "integer", "[ xsd:maxInclusive 4 ] [ xsd:minInclusive -1 ]",
"integer[<= 4, >= -1]"),
("exclusive", "decimal", "[ xsd:minExclusive 0.5 ] [ xsd:maxExclusive 9.5 ]",
"decimal[> 0.5, < 9.5]"),
("zero", "integer", "[ xsd:minInclusive 0 ]", "integer[>= 0]"),
("pattern", "string", '[ xsd:pattern "[0-9]+" ] [ xsd:minLength 1 ]',
"string[pattern [0-9]+, minLength 1]"),
]


@pytest.fixture
def range_reader(tmp_path):
declarations = "\n".join(
f"ex:{name} a owl:DatatypeProperty ; rdfs:range [ a rdfs:Datatype ; "
f"owl:onDatatype xsd:{datatype} ; owl:withRestrictions ( {facets} ) ] ."
for name, datatype, facets, _ in CASES
)
path = tmp_path / "ranges.ttl"
path.write_text("""
@prefix ex: <http://example.org/ranges#> .
@prefix owl: <http://www.w3.org/2002/07/owl#> .
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
<http://example.org/ranges> a owl:Ontology .
""" + declarations, encoding="utf-8")
reader = Reader()
reader.load_instances(str(path), "owl")
return reader


@pytest.mark.parametrize("name,datatype,expected",
[(name, datatype, expected) for name, datatype, _, expected in CASES],
ids=[case[0] for case in CASES])
def test_range_preserves_datatype_and_every_facet(range_reader, name, datatype,
expected):
viewer = range_reader.get_viewer()
data = viewer.get_view_data(str(EX[name]))
rendered = data["entities"][0]["relations"]["range"][0]

assert rendered["text"] == expected
assert rendered["parts"][0]["link"] == str(XSD[datatype])

restrictions = {
instance for instances in range_reader._instance_cache.values()
for instance in instances if isinstance(instance, DatatypeRestriction)
}
assert len(restrictions) == len(CASES)
for restriction in restrictions:
assert isinstance(restriction.get_applies_on_concept(), Datatype)


class _RestrictionText(HTMLParser):
"""Read visible restriction blocks without matching the hidden RDF snippets."""

def __init__(self, html):
super().__init__()
self.depth = 0
self.blocks = []
self.feed(html)

def handle_starttag(self, tag, attrs):
if tag == "div":
if self.depth:
self.depth += 1
elif "restriction-block" in dict(attrs).get("class", "").split():
self.depth = 1
self.blocks.append("")

def handle_endtag(self, tag):
if tag == "div" and self.depth:
self.depth -= 1

def handle_data(self, text):
if self.depth:
self.blocks[-1] += text


def test_static_index_and_resource_pages_show_complete_ranges(range_reader, tmp_path):
out = tmp_path / "site"
build_html(range_reader.get_viewer(), out, reader=range_reader)

def compact(text):
return "".join(text.split())

index = _RestrictionText((out / "index.html").read_text(encoding="utf-8"))
for name, _, _, expected in CASES:
page = out / "resources" / "ex" / f"{name}.html"
resource = _RestrictionText(page.read_text(encoding="utf-8"))
assert compact(expected) in [compact(block) for block in index.blocks]
assert compact(expected) in [compact(block) for block in resource.blocks]

assert isomorphic(Graph().parse(out / "index.ttl"), range_reader.get_main_graph())
Loading