Keywords with context input

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022-2025 SINTEF
+Copyright (c) 2022-2026 SINTEF
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

pyproject.toml

@@ -144,9 +144,12 @@ addopts = """-rs --cov=tripper --cov-report=term \
     """
 filterwarnings = [
     "ignore:.*imp module.*:DeprecationWarning",
+    "ignore:ConjunctiveGraph.*:DeprecationWarning",  # in pyld
+    "ignore:builtin type SwigPy.*:DeprecationWarning",  # in pyld
     "ignore:::tripper.literal:243",  # Ignore warning in doctest
 ]
 
+
 [tool.setuptools.package-data]
 "tripper.context" = ["*.json", "*.yaml"]
 

tests/datadoc/test_context.py

@@ -94,6 +94,33 @@ def test_get_prefixes():
     assert "mediaType" not in prefixes
 
 
+def test_get_properties():
+    """Test get_properties() method."""
+    properties = ctx.get_properties()
+    assert "adms" not in properties  # prefix is not a property
+    assert "Document" not in properties  # class is not a property
+    assert properties["mediaType"] == "http://www.w3.org/ns/dcat#mediaType"
+
+
+def test_get_object_properties():
+    """Test get_object_properties() method."""
+    from tripper import DCTERMS
+
+    objprop = ctx.get_object_properties()
+    assert "adms" not in objprop  # prefix is not an object property
+    assert "Document" not in objprop  # class is not an object property
+    assert "title" not in objprop  # annotation is not an object property
+    assert objprop["hasPart"] == DCTERMS.hasPart
+
+
+def test_get_classes():
+    """Test get_prefixes() method."""
+    classes = ctx.get_classes()
+    assert "adms" not in classes
+    assert "mediaType" not in classes
+    assert classes["Document"] == "http://xmlns.com/foaf/0.1/Document"
+
+
 def test_sync_prefixes():
     """Test sync_prefixes() method."""
     from tripper import Triplestore

tests/datadoc/test_datadoc_utils.py

@@ -112,3 +112,32 @@ def test_iriname():
     assert iriname("abc") == "abc"
     assert iriname("rdf:JSON") == "JSON"
     assert iriname("https://w3id.org/emmo#Ampere") == "Ampere"
+
+
+def test_getlabel():
+    """Test utility function getlabel()."""
+    from tripper import SKOS
+    from tripper.datadoc.errors import InvalidDatadocError
+    from tripper.datadoc.utils import getlabel
+
+    assert getlabel({"@id": "ex:A", "prefLabel": "a"}) == "a"
+    assert getlabel({"@id": "ex:A", "label": "a"}) == "a"
+    assert getlabel({"@id": "ex:A", "rdfs:label": "a"}) == "a"
+    assert getlabel({"@id": "ex:A"}, default="a") == "a"
+    assert getlabel({"@id": "ex:A"}) == "A"
+
+    # Check for precedence of labels
+    assert (
+        getlabel({"@id": "ex:A", "rdfs:label": "a", "prefLabel": "b"}) == "a"
+    )
+    assert (
+        getlabel({"@id": "ex:A", "rdfs:label": "a", "skos:prefLabel": "b"})
+        == "b"
+    )
+    assert (
+        getlabel({"@id": "ex:A", "rdfs:label": "a", SKOS.prefLabel: "b"})
+        == "b"
+    )
+
+    with pytest.raises(InvalidDatadocError):
+        getlabel({"x": "ex:A"})

tests/datadoc/test_dataset.py

@@ -402,6 +402,48 @@ def test_store():
     }
 
 
+def test_update_context():
+    """Test update_context()."""
+    from tripper import HUME, OWL, Namespace
+    from tripper.datadoc import get_context
+    from tripper.datadoc.dataset import update_context
+
+    EX = Namespace("http://example.com/")
+    sources = {
+        "@context": {
+            "ex": str(EX),
+            "hume": str(HUME),
+        },
+        "@graph": [
+            {
+                # Instances are not added to context
+                "@id": "ex:instr",
+                "@type": "hume:Device",
+            },
+            {
+                # Not added to context, since there is no @type
+                "@id": "ex:instr2",
+            },
+            {
+                "@id": "ex:MyDevice",
+                "skos:prefLabel": "MyDevice",
+                "subClassOf": "hume:Device",
+            },
+        ],
+    }
+    context = get_context(default_theme=None)
+    update_context(sources, context)
+    c = context.get_context_dict()
+    assert "instr" not in c
+    assert "instr2" not in c
+    assert "MyDevice" in c
+    assert c["MyDevice"] == {"@id": EX.MyDevice, "@type": OWL.Class}
+    assert c["Device"] == {"@id": HUME.Device, "@type": OWL.Class}
+
+    # TODO: add tests for what happens if there is mismatch between
+    # previously added context and updated_context...
+
+
 def test_infer_restriction_types():
     """Test infer_restriction_types()."""
     from tripper import DCTERMS, HUME, RDFS, Namespace
@@ -426,7 +468,7 @@ def test_infer_restriction_types():
         "http://example.org#A": {
             DCTERMS.creator: "some",
             DCTERMS.hasPart: "value",
-            DCTERMS.issued: "value",
+            # DCTERMS.issued: "value",
         }
     }
 
@@ -452,7 +494,7 @@ def test_infer_restriction_types():
                 "@id": "ex:MyDevice",
                 # "@type": "owl:Class",
                 "subClassOf": HUME.Device,
-                "hasPart": HUME.MeasuringInstrument,
+                "hasPart": [HUME.MeasuringInstrument, "ex:MyDevice"],
             },
         ],
     }
@@ -577,6 +619,13 @@ def test_update_restrictions():
                 "@type": HUME.Device,
                 "isDefinedBy": HUME.MeasuringInstrument,
             },
+            {
+                # An individial relating to two classes and an individual.
+                # Should be converted to an existential restriction.
+                "@id": "ex:instr3",
+                "@type": HUME.Device,
+                "hasPart": [HUME.MeasuringInstrument, "MyDevice", "ex:instr"],
+            },
             {
                 # A class relating to a class.
                 # Should be converted to an existential restriction.
@@ -586,63 +635,68 @@ def test_update_restrictions():
                 "@id": "ex:MyDevice",
                 # "@type": "owl:Class",
                 "subClassOf": HUME.Device,
+                "label": "MyDevice",
                 "hasPart": HUME.MeasuringInstrument,
             },
+            {
+                # A class relating to two classes
+                "@id": "ex:MyDevice2",
+                "@type": "owl:Class",
+                "subClassOf": HUME.Device,
+                "label": "MyDevice2",
+                "hasPart": [HUME.MeasuringInstrument, "MyDevice"],
+            },
+            # TODO: for completeness, add tests for individual
+            # relating to one individual and individual related to a
+            # list of individuals
         ],
     }
     r6 = deepcopy(d6)
     update_restrictions(r6, ctx)
-    assert r6 == {
-        "@context": {
-            "MeasuringInstrument": {
-                "@id": "https://w3id.org/emmo/hume#MeasuringInstrument",
-                "@type": "owl:Class",
-            }
-        },
-        "@graph": [
-            {
-                "@id": "ex:instr",
-                "@type": "https://w3id.org/emmo/hume#Device",
-                "isDefinedBy": "https://w3id.org/emmo/hume#MeasuringSystem",
-            },
+    res6 = {d["@id"]: d for d in r6["@graph"]}
+    assert res6["ex:instr"] == {
+        "@id": "ex:instr",
+        "@type": "https://w3id.org/emmo/hume#Device",
+        "isDefinedBy": "https://w3id.org/emmo/hume#MeasuringSystem",
+    }
+    assert res6["ex:instr2"] == {
+        "@id": "ex:instr2",
+        "@type": [
+            "https://w3id.org/emmo/hume#Device",
             {
-                "@id": "ex:instr2",
-                "@type": [
-                    "https://w3id.org/emmo/hume#Device",
-                    {
-                        "@type": "owl:Restriction",
-                        "owl:onProperty": {
-                            "@id": (
-                                "http://www.w3.org/2000/01/rdf-schema#"
-                                "isDefinedBy"
-                            )
-                        },
-                        "owl:someValuesFrom": {
-                            "@id": (
-                                "https://w3id.org/emmo/hume#MeasuringInstrument"
-                            )
-                        },
-                    },
-                ],
+                "@type": "owl:Restriction",
+                "owl:onProperty": {
+                    "@id": "http://www.w3.org/2000/01/rdf-schema#isDefinedBy",
+                },
+                "owl:someValuesFrom": {
+                    "@id": "https://w3id.org/emmo/hume#MeasuringInstrument",
+                },
             },
+        ],
+    }
+    assert res6["ex:instr3"] == {
+        # WRONG! Should be converted to restrictions
+        "@id": "ex:instr3",
+        "@type": "https://w3id.org/emmo/hume#Device",
+        "hasPart": [
+            "https://w3id.org/emmo/hume#MeasuringInstrument",
+            "MyDevice",
+            "ex:instr",
+        ],
+    }
+    assert res6["ex:MyDevice"] == {
+        "@id": "ex:MyDevice",
+        "subClassOf": [
+            "https://w3id.org/emmo/hume#Device",
             {
-                "@id": "ex:MyDevice",
-                "subClassOf": [
-                    "https://w3id.org/emmo/hume#Device",
-                    {
-                        "@type": "owl:Restriction",
-                        "owl:onProperty": {
-                            "@id": "http://purl.org/dc/terms/hasPart"
-                        },
-                        "owl:someValuesFrom": {
-                            "@id": (
-                                "https://w3id.org/emmo/hume#MeasuringInstrument"
-                            )
-                        },
-                    },
-                ],
+                "@type": "owl:Restriction",
+                "owl:onProperty": {"@id": "http://purl.org/dc/terms/hasPart"},
+                "owl:someValuesFrom": {
+                    "@id": "https://w3id.org/emmo/hume#MeasuringInstrument"
+                },
             },
         ],
+        "label": "MyDevice",
     }
 
 

tests/datadoc/test_keywords.py

@@ -1,11 +1,12 @@
 """Test the Keywords class."""
 
+# pylint: disable=too-many-statements,wrong-import-position
+
 import pytest
 
 pytest.importorskip("yaml")
 pytest.importorskip("pyld")
 
-# pylint: disable=wrong-import-position
 from tripper.datadoc import Keywords
 
 # A fixture used by all the tests
@@ -14,10 +15,13 @@
 
 def test_get_keywords():
     """Test get_keywords() function."""
+    import warnings
+
     from dataset_paths import testdir  # pylint: disable=import-error
 
-    from tripper import DDOC
-    from tripper.datadoc import get_keywords
+    from tripper import DDOC, OWL, XSD
+    from tripper.datadoc import get_context, get_keywords
+    from tripper.errors import TripperWarning
 
     kw1 = get_keywords()
     assert kw1.data == keywords.data
@@ -65,6 +69,38 @@ def test_get_keywords():
     assert kw6.data.theme == ["ddoc:datadoc", "ddoc:prefixes", "ddoc:process"]
     assert "batchNumber" in kw6
 
+    kw7 = get_keywords(theme=None)
+    assert len(kw7) == 0
+    kw7.add({"resources": {"MyClass": {"iri": "http://example.com/MyClass"}}})
+    assert len(kw7) == 0  # no properties in keywords
+
+    ctx = get_context(default_theme=None)
+    ctx.add_context(
+        {
+            "ex": "http://example.com/",
+            "owl": str(OWL),
+            "xsd": str(XSD),
+            "objprop": {"@id": "ex:objprop", "@type": "@id"},
+            "dataprop": {"@id": "ex:dataprop", "@type": "xsd:string"},
+            "cls": {"@id": "ex:cls", "@type": "owl:Class"},
+        }
+    )
+
+    # Test `context` argument to get_keywords(). Ignore expected
+    # warnings about loss of information
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", category=TripperWarning)
+
+        kw8 = get_keywords(kw7, context=ctx, theme=None)
+        assert len(kw8) == 2  # 2 properties in keywords
+        assert kw8.get_prefixes()["ex"] == "http://example.com/"
+        assert set(kw8.classnames()) == {"Resource", "MyClass", "cls"}
+
+        kw9 = get_keywords(context=ctx, theme=None)
+        assert len(kw9) == 2
+        assert kw9.get_prefixes()["ex"] == "http://example.com/"
+        assert set(kw9.classnames()) == {"Resource", "cls"}
+
 
 def test_iter():
     """Test __iter__() method."""
@@ -155,7 +191,11 @@ def test_load_yaml():
     """
     from dataset_paths import indir  # pylint: disable=import-error
 
-    from tripper.datadoc.errors import ParseError
+    from tripper.datadoc.errors import (
+        ParseError,
+        RedefineKeywordWarning,
+        SkipRedefineKeywordWarning,
+    )
 
     kw = keywords.copy()
 
@@ -195,10 +235,12 @@ def test_load_yaml():
     # keywords are unchanged by failures
     # assert kw == keywords
 
-    kw.load_yaml(indir / "invalid_keywords9.yaml", redefine="skip")
+    with pytest.warns(SkipRedefineKeywordWarning):
+        kw.load_yaml(indir / "invalid_keywords9.yaml", redefine="skip")
     assert kw["title"].iri == "dcterms:title"
 
-    kw.load_yaml(indir / "invalid_keywords9.yaml", redefine="allow")
+    with pytest.warns(RedefineKeywordWarning):
+        kw.load_yaml(indir / "invalid_keywords9.yaml", redefine="allow")
     assert kw["title"].iri == "myonto:a"
 
     kw.load_yaml(indir / "valid_keywords.yaml")
@@ -485,6 +527,7 @@ def test_load2():
 
     from tripper import Triplestore
     from tripper.datadoc import get_keywords
+    from tripper.datadoc.errors import RedefineKeywordWarning
     from tripper.utils import AttrDict
 
     ts = Triplestore("rdflib")
@@ -539,7 +582,8 @@ def test_load2():
     # Create a new Keywords object with
     # default keywords and load from the triplestore
     kw2 = get_keywords()
-    kw2.load_rdf(ts, redefine="allow")
+    with pytest.warns(RedefineKeywordWarning):
+        kw2.load_rdf(ts, redefine="allow")
 
     # Ensure that the specified keywords are in kw2
     assert not {