class TestNamespaces(unittest.TestCase):
"""Test namespace registry and namespaces."""
def setUp(self):
"""Set up some temporary directories."""
self.tempdir = tempfile.TemporaryDirectory()
self.namespace_registry = NamespaceRegistry()
self.namespace_registry._load_cuba()
self.installer = OntologyInstallationManager(
namespace_registry=self.namespace_registry, path=self.tempdir.name)
self.graph = self.namespace_registry._graph
def tearDown(self):
"""Clean up all temporary directories."""
self.tempdir.cleanup()
def test_namespace_registry_load_cuba(self):
"""Test loading the CUBA namespace."""
g = rdflib.Graph()
g.parse(CUBA_FILE, format="ttl")
self.assertTrue(isomorphic(g, self.graph))
self.assertIn("cuba", self.namespace_registry._namespaces)
self.assertEqual(
self.namespace_registry._namespaces["cuba"],
rdflib.URIRef("http://www.osp-core.com/cuba#"),
)
def test_namespace_registry_store(self):
"""Test storing loaded namespaces."""
self.graph.parse(RDF_FILE, format="ttl")
self.namespace_registry.bind(
"parser_test",
rdflib.URIRef("http://www.osp-core.com"
"/parser_test#"),
)
self.namespace_registry.update_namespaces()
self.namespace_registry.store(self.tempdir.name)
self.assertItemsEqual(os.listdir(self.tempdir.name),
["graph.xml", "namespaces.txt"])
g = rdflib.Graph()
g.parse(os.path.join(self.tempdir.name, "graph.xml"), format="xml")
g1 = rdflib.Graph()
g1.parse(CUBA_FILE, format="ttl")
g1.parse(RDF_FILE, format="ttl")
self.assertTrue(isomorphic(g, g1))
with open(os.path.join(self.tempdir.name, "namespaces.txt")) as f:
lines = set(map(lambda x: x.strip(), f))
self.assertIn("cuba\thttp://www.osp-core.com/cuba#", lines)
self.assertIn("parser_test\thttp://www.osp-core.com/parser_test#",
lines)
def test_namespace_registry_load(self):
"""Test loading an installed namespaces."""
# no graph.xml found
self.namespace_registry.clear()
self.namespace_registry.load_graph_file(self.tempdir.name)
g = rdflib.Graph()
g.parse(CUBA_FILE, format="ttl")
self.assertTrue(isomorphic(g, self.namespace_registry._graph))
self.namespace_registry.clear()
self.graph = self.namespace_registry._graph
# graph.ttl found
self.graph.parse(RDF_FILE, format="ttl")
self.namespace_registry.bind(
"parser_test",
rdflib.URIRef("http://www.osp-core.com/"
"parser_test#"),
)
self.namespace_registry.update_namespaces()
self.namespace_registry.store(self.tempdir.name)
nr = NamespaceRegistry()
nr.load_graph_file(self.tempdir.name)
self.assertTrue(isomorphic(nr._graph, self.graph))
self.assertIn("parser_test", nr)
def test_namespace_registry_clear(self):
"""Test clearing a namespace registry."""
self.namespace_registry.clear()
self.assertIsNot(self.namespace_registry._graph, self.graph)
self.assertTrue(isomorphic(self.namespace_registry._graph, self.graph))
def test_namespace_registry_from_iri(self):
"""Test getting namespaces from iri."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
city_iri = ns_iri + "City"
hasPart_iri = ns_iri + "hasPart"
self.modify_labels()
c = self.namespace_registry.from_iri(rdflib_cuba.Entity)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "cuba")
self.assertEqual(c.name, "Entity")
r = self.namespace_registry.from_iri(rdflib_cuba.relationship)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "cuba")
self.assertEqual(r.name, "relationship")
a = self.namespace_registry.from_iri(rdflib_cuba.attribute)
self.assertIsInstance(a, OntologyAttribute)
self.assertEqual(a.namespace.get_name(), "cuba")
self.assertEqual(a.name, "attribute")
c = self.namespace_registry.from_iri(city_iri)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "city")
self.assertEqual(c.name, "City")
r = self.namespace_registry.from_iri(hasPart_iri)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "city")
self.assertEqual(r.name, "hasPart")
import osp.core.namespaces
old_ns_reg = osp.core.ontology.namespace_registry.namespace_registry
try:
osp.core.ontology.namespace_registry.namespace_registry = (
self.namespace_registry)
from_iri = self.namespace_registry.from_iri
c = from_iri(rdflib_cuba.Entity)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "cuba")
self.assertEqual(c.name, "Entity")
self.graph.add((ns_iri, rdflib_cuba._reference_by_label,
rdflib.Literal(True)))
self.namespace_registry.from_iri.cache_clear()
self.namespace_registry._get.cache_clear()
c = from_iri(city_iri)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "city")
self.assertEqual(c.name, "City_T")
r = from_iri(hasPart_iri)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "city")
self.assertEqual(r.name, "hasPart_T")
# undefined namespace
self.graph.add(
(rdflib.URIRef("a/b#c"), rdflib.RDF.type, rdflib.OWL.Class))
self.graph.add(
(rdflib.URIRef("d/e/f"), rdflib.RDF.type, rdflib.OWL.Class))
a = from_iri("a/b#c")
b = from_iri("d/e/f")
self.assertIsInstance(a, OntologyClass)
self.assertEqual(a.namespace.get_name(), "a/b#")
self.assertEqual(a.name, "c")
self.assertIsInstance(b, OntologyClass)
self.assertEqual(b.namespace.get_name(), "d/e/")
self.assertEqual(b.name, "f")
finally:
osp.core.ontology.namespace_registry = old_ns_reg
def test_namespace_registry_update_namespaces(self):
"""Test updateing the namespaces."""
self.namespace_registry.bind("a", rdflib.URIRef("aaa"))
self.namespace_registry.bind("b", rdflib.URIRef("bbb"))
self.namespace_registry.bind("c", rdflib.URIRef("ccc"))
self.namespace_registry.update_namespaces()
self.assertEqual(self.namespace_registry.a.get_name(), "a")
self.assertEqual(self.namespace_registry.a.get_iri(),
rdflib.URIRef("aaa"))
self.assertEqual(self.namespace_registry.b.get_name(), "b")
self.assertEqual(self.namespace_registry.b.get_iri(),
rdflib.URIRef("bbb"))
self.assertEqual(self.namespace_registry.c.get_name(), "c")
self.assertEqual(self.namespace_registry.c.get_iri(),
rdflib.URIRef("ccc"))
def test_namespace_registry_get(self):
"""Test getting namsepaces from namespace registry."""
self.installer.install("city")
self.assertIn("city", self.namespace_registry)
self.assertEqual(
self.namespace_registry._get("city").get_name(), "city")
self.assertEqual(
self.namespace_registry.get("city").get_name(), "city")
self.assertEqual(self.namespace_registry["city"].get_name(), "city")
self.assertEqual(self.namespace_registry.city.get_name(), "city")
self.assertRaises(KeyError, self.namespace_registry._get, "invalid")
self.assertEqual(self.namespace_registry.get("invalid"), None)
self.assertRaises(KeyError, self.namespace_registry.__getitem__,
"invalid")
self.assertRaises(AttributeError, getattr, self.namespace_registry,
"invalid")
self.assertEqual({x.get_name()
for x in self.namespace_registry}, {"cuba", "city"})
def modify_labels(self):
"""Modify the labels in the graph. Append a T.
Helper method.
"""
namespace = self.namespace_registry.city
triples = list()
for s, p, o in self.graph:
if s in namespace and p in (
rdflib.SKOS.prefLabel,
rdflib.RDFS.label,
):
# To test querying by label.
label_SKOS = f"{o}_T"
triples.append((
s,
rdflib.SKOS.prefLabel,
rdflib.Literal(label_SKOS, lang="en"),
))
# To test RDFS labels and special characters.
label_RDFS = f"{o}-$"
triples.append((
s,
rdflib.RDFS.label,
rdflib.Literal(label_RDFS, lang="en"),
))
# To test non-english languages.
label_RDFS_jp = f"{o}_T_jp"
triples.append((
s,
rdflib.RDFS.label,
rdflib.Literal(label_RDFS_jp, lang="jp"),
))
label_SKOS_aa = f"{o}_T_aa_SKOS"
triples.append((
s,
rdflib.SKOS.prefLabel,
rdflib.Literal(label_SKOS_aa, lang="aa"),
))
# To test undefined languages.
label_RDFS_unk = f"{o}_T_unknown_lang"
triples.append(
(s, rdflib.RDFS.label, rdflib.Literal(label_RDFS_unk)))
# To test labels that coincide in different languages.
label_RDFS_es = f"{o}_T_cosa"
label_RDFS_it = f"{o}_T_cosa"
for label, lang in (
(label_RDFS_es, "es"),
(label_RDFS_it, "it"),
):
triples.append((
s,
rdflib.RDFS.label,
rdflib.Literal(label, lang=lang),
))
else:
triples.append((s, p, o))
# Test different concepts with same label, and querying by language.
triples.append((
rdflib.URIRef(str(namespace._iri) + "City"),
rdflib.RDFS.label,
rdflib.Literal("Burro", lang="it"),
))
triples.append((
rdflib.URIRef(str(namespace._iri) + "Street"),
rdflib.RDFS.label,
rdflib.Literal("Burro", lang="es"),
))
self.graph.remove((None, None, None))
for t in triples:
self.graph.add(t)
def test_namespace_get(self):
"""Test getting entities from namespace."""
self.installer.install("city")
self.modify_labels()
namespace = self.namespace_registry.city
# dot
self.assertIsInstance(namespace.City, OntologyClass)
self.assertEqual(namespace.City.name, "City")
self.assertEqual(namespace.City._iri_suffix, "City")
self.assertIsInstance(namespace.hasPart, OntologyRelationship)
self.assertEqual(namespace.hasPart.name, "hasPart")
self.assertEqual(namespace.hasPart._iri_suffix, "hasPart")
self.assertIsInstance(namespace.coordinates, OntologyAttribute)
self.assertEqual(namespace.coordinates.name, "coordinates")
self.assertEqual(namespace.coordinates._iri_suffix, "coordinates")
# item
self.assertIsInstance(namespace["City_T"], OntologyClass)
self.assertEqual(namespace["City_T"].name, "City")
self.assertEqual(namespace["City_T"]._iri_suffix, "City")
self.assertIsInstance(namespace["City_T", "en"], OntologyClass)
self.assertEqual(namespace["City_T", "en"].name, "City")
self.assertEqual(namespace["City_T", "en"]._iri_suffix, "City")
self.assertIsInstance(namespace["hasPart_T"], OntologyRelationship)
self.assertEqual(namespace["hasPart_T"].name, "hasPart")
self.assertEqual(namespace["hasPart_T"]._iri_suffix, "hasPart")
self.assertIsInstance(namespace["coordinates_T"], OntologyAttribute)
self.assertEqual(namespace["coordinates_T"].name, "coordinates")
self.assertEqual(namespace["coordinates_T"]._iri_suffix, "coordinates")
# get
self.assertIsInstance(namespace.get("City"), OntologyClass)
self.assertEqual(namespace.get("City").name, "City")
self.assertEqual(namespace.get("City")._iri_suffix, "City")
self.assertIsInstance(namespace.get("hasPart"), OntologyRelationship)
self.assertEqual(namespace.get("hasPart").name, "hasPart")
self.assertEqual(namespace.get("hasPart")._iri_suffix, "hasPart")
self.assertIsInstance(namespace.get("coordinates"), OntologyAttribute)
self.assertEqual(namespace.get("coordinates").name, "coordinates")
self.assertEqual(
namespace.get("coordinates")._iri_suffix, "coordinates")
self.assertRaises(AttributeError, namespace.__getattr__, "CITY")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART_T")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART")
self.assertEqual(namespace.get("COORDINATES"), None)
# reference by label
namespace._reference_by_label = True
# The above line is artificial (the user is not expected to change
# this private variable at runtime). Therefore, the cache for the
# `_get_from_label` method needs to be cleared for the test, as it
# produces different results depending on the value of
# `_reference_by_label`.
namespace._get_from_label.cache_clear()
# dot
self.assertIsInstance(namespace.City_T, OntologyClass)
self.assertEqual(namespace.City_T.name, "City_T")
self.assertEqual(namespace.City_T._iri_suffix, "City")
self.assertIsInstance(namespace.hasPart_T, OntologyRelationship)
self.assertEqual(namespace.hasPart_T.name, "hasPart_T")
self.assertEqual(namespace.hasPart_T._iri_suffix, "hasPart")
self.assertIsInstance(namespace.coordinates_T, OntologyAttribute)
self.assertEqual(namespace.coordinates_T.name, "coordinates_T")
self.assertEqual(namespace.coordinates_T._iri_suffix, "coordinates")
# item
self.assertIsInstance(namespace["City_T"], OntologyClass)
self.assertEqual(namespace["City_T"].name, "City_T")
self.assertEqual(namespace["City_T"]._iri_suffix, "City")
self.assertIsInstance(namespace["City_T", "en"], OntologyClass)
self.assertEqual(namespace["City_T", "en"].name, "City_T")
self.assertEqual(namespace["City_T", "en"]._iri_suffix, "City")
self.assertIsInstance(namespace["hasPart_T"], OntologyRelationship)
self.assertEqual(namespace["hasPart_T"].name, "hasPart_T")
self.assertEqual(namespace["hasPart_T"]._iri_suffix, "hasPart")
self.assertIsInstance(namespace["coordinates_T"], OntologyAttribute)
self.assertEqual(namespace["coordinates_T"].name, "coordinates_T")
self.assertEqual(namespace["coordinates_T"]._iri_suffix, "coordinates")
# get
self.assertIsInstance(namespace.get("City_T"), OntologyClass)
self.assertEqual(namespace.get("City_T").name, "City_T")
self.assertEqual(namespace.get("City_T")._iri_suffix, "City")
self.assertIsInstance(namespace.get("hasPart_T"), OntologyRelationship)
self.assertEqual(namespace.get("hasPart_T").name, "hasPart_T")
self.assertEqual(namespace.get("hasPart_T")._iri_suffix, "hasPart")
self.assertIsInstance(namespace.get("coordinates_T"),
OntologyAttribute)
self.assertEqual(namespace.get("coordinates_T").name, "coordinates_T")
self.assertEqual(
namespace.get("coordinates_T")._iri_suffix, "coordinates")
self.assertRaises(AttributeError, namespace.__getattr__, "CITY")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART_T")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART")
self.assertEqual(namespace.get("COORDINATES"), None)
self.assertRaises(AttributeError, namespace.__getattr__, "City")
self.assertRaises(KeyError, namespace.__getitem__, "City")
self.assertEqual(namespace.get("coordinates"), None)
# Special characters and RDFS labels.
# RDFS label (special characters)
self.assertIsInstance(getattr(namespace, "City-$"), OntologyClass)
self.assertEqual(getattr(namespace, "City-$").name, "City-$")
self.assertEqual(getattr(namespace, "City-$")._iri_suffix, "City")
# Language.
# Refer to the label in non-english language.
self.assertIsInstance(namespace.City_T_jp, OntologyClass)
self.assertEqual(namespace.City_T_jp.name, "City_T_jp")
self.assertEqual(namespace.City_T._iri_suffix, "City")
# Labels with unknown languages.
self.assertEqual(namespace["City_T_unknown_lang"].name,
"City_T_unknown_lang")
# Coincident label in different languages.
self.assertIsInstance(namespace.City_T_cosa, OntologyClass)
self.assertEqual(namespace.City_T_cosa.name, "City_T_cosa")
self.assertEqual(namespace.City_T._iri_suffix, "City")
# Different concepts with the same label.
self.assertRaises(AttributeError, namespace.__getattr__, "Burro")
# Same word with different concept in different languages.
self.assertEqual(namespace["Burro", "it"], namespace.City_T)
self.assertEqual(namespace["Burro", "es"], namespace.Street_T)
def test_namespace_str(self):
"""Test converting namespace object to string."""
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertEqual(str(namespace),
"city (http://www.osp-core.com/city#)")
self.assertEqual(repr(namespace),
"<city: http://www.osp-core.com/city#>")
def test_get_default_rel(self):
"""Test getting the default relationship."""
# default rel defined as flag in entity name
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertEqual(namespace.get_default_rel().name, "hasPart")
onto_def_rel = os.path.join(os.path.dirname(__file__),
"default_rel_across_namespace_valid.yml")
self.installer.install(onto_def_rel)
namespace = self.namespace_registry.default_rel_test_namespace_valid
self.assertEqual(namespace.get_default_rel(), cuba.activeRelationship)
onto_def_rel = os.path.join(
os.path.dirname(__file__),
"default_rel_across_namespace_two_definitions.yml",
)
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
onto_def_rel = os.path.join(
os.path.dirname(__file__),
"default_rel_across_namespace_uninstalled_entity.yml",
)
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
# Now this will be checked at installation time.
onto_def_rel = os.path.join(
os.path.dirname(__file__),
"default_rel_across_namespace_uninstalled_namespace.yml",
)
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
def test_contains(self):
"""Test containment."""
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertIn("City", namespace)
self.assertIn("hasPart", namespace)
def test_iter(self):
"""Test the __iter__() magic method."""
self.installer.install("city")
namespace = self.namespace_registry.city
entities = set(namespace)
self.assertIn(namespace.encloses, entities)
self.assertIn(namespace.City, entities)
self.assertIn(namespace.name, entities)
self.assertEqual(len(entities), 32)
def test_get_namespace_from_iri(self):
"""Test getting namespace object from IRI."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
namespace = self.namespace_registry.namespace_from_iri(ns_iri)
self.assertEqual(namespace.get_name(), "city")
self.assertEqual(namespace.get_iri(), ns_iri)
ns_iri = rdflib.URIRef("http://www.random_namespace.com#")
namespace = self.namespace_registry.namespace_from_iri(ns_iri)
self.assertEqual(namespace.get_name(),
"http://www.random_namespace.com#")
self.assertEqual(namespace.get_iri(), ns_iri)
def test_get_namespace_name_and_iri(self):
"""Test getting namespace name and IRI."""
self.installer.install("city")
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.osp-core.com/city#City")),
("city", rdflib.URIRef("http://www.osp-core.com/city#")),
)
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.random_namespace.com#Bla")),
(
"http://www.random_namespace.com#",
rdflib.URIRef("http://www.random_namespace.com#"),
),
)
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.random_namespace.com/Bla")),
(
"http://www.random_namespace.com/",
rdflib.URIRef("http://www.random_namespace.com/"),
),
)
def test_get_reference_by_label(self):
"""Test getting the reference style."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
self.assertFalse(
self.namespace_registry._get_reference_by_label(ns_iri))
self.graph.add(
(ns_iri, rdflib_cuba._reference_by_label, rdflib.Literal(True)))
self.assertTrue(
self.namespace_registry._get_reference_by_label(ns_iri))
def test_get_entity_name(self):
"""Test getting the name of an entity."""
self.installer.install("city")
self.modify_labels()
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
iri = rdflib.URIRef("http://www.osp-core.com/city#City")
self.assertEqual(self.namespace_registry._get_entity_name(iri, ns_iri),
"City")
self.graph.add(
(ns_iri, rdflib_cuba._reference_by_label, rdflib.Literal(True)))
self.assertEqual(self.namespace_registry._get_entity_name(iri, ns_iri),
"City_T")
def test_autocompletion_ipython(self):
"""Checks that all the expected ontology entities are in __dir__.
The check is done just for the `cuba` namespace.
"""
expected = {
"activeRelationship",
"passiveRelationship",
"relationship",
"attribute",
"path",
"Entity",
"File",
"Nothing",
"Wrapper",
}
self.assertSetEqual(set(dir(cuba)) & expected, expected)
class TestNamespaces(unittest.TestCase):
"""Test namespace registry and namespaces."""
def setUp(self):
"""Set up some temporary directories."""
self.tempdir = tempfile.TemporaryDirectory()
self.namespace_registry = NamespaceRegistry()
self.namespace_registry._load_cuba()
self.installer = OntologyInstallationManager(
namespace_registry=self.namespace_registry, path=self.tempdir.name)
self.graph = self.namespace_registry._graph
def tearDown(self):
"""Clean up all temporary directories."""
self.tempdir.cleanup()
def test_namespace_registry_load_cuba(self):
"""Test loading the CUBA namespace."""
g = rdflib.Graph()
g.parse(CUBA_FILE, format="ttl")
self.assertTrue(isomorphic(g, self.graph))
self.assertIn("cuba", self.namespace_registry._namespaces)
self.assertEqual(self.namespace_registry._namespaces["cuba"],
rdflib.URIRef("http://www.osp-core.com/cuba#"))
def test_namespace_registry_store(self):
"""Test storing loaded namespaces."""
self.graph.parse(RDF_FILE, format="ttl")
self.graph.bind("parser_test",
rdflib.URIRef("http://www.osp-core.com/parser_test#"))
self.namespace_registry.update_namespaces()
self.namespace_registry.store(self.tempdir.name)
self.assertEqual(os.listdir(self.tempdir.name),
["graph.xml", "namespaces.txt"])
g = rdflib.Graph()
g.parse(os.path.join(self.tempdir.name, "graph.xml"), format="xml")
g1 = rdflib.Graph()
g1.parse(CUBA_FILE, format="ttl")
g1.parse(RDF_FILE, format="ttl")
self.assertTrue(isomorphic(g, g1))
with open(os.path.join(self.tempdir.name, "namespaces.txt")) as f:
lines = set(map(lambda x: x.strip(), f))
self.assertIn("cuba\thttp://www.osp-core.com/cuba#", lines)
self.assertIn("parser_test\thttp://www.osp-core.com/parser_test#",
lines)
def test_namespace_registry_load(self):
"""Test loading an installed namespaces."""
# no graph.xml found
self.namespace_registry.clear()
self.namespace_registry.load(self.tempdir.name)
g = rdflib.Graph()
g.parse(CUBA_FILE, format="ttl")
self.assertTrue(isomorphic(g, self.namespace_registry._graph))
self.namespace_registry.clear()
self.graph = self.namespace_registry._graph
# graph.ttl found
self.graph.parse(RDF_FILE, format="ttl")
self.graph.bind("parser_test",
rdflib.URIRef("http://www.osp-core.com/parser_test#"))
self.namespace_registry.update_namespaces()
self.namespace_registry.store(self.tempdir.name)
nr = NamespaceRegistry()
nr.load(self.tempdir.name)
self.assertTrue(isomorphic(nr._graph, self.graph))
self.assertIn("parser_test", nr)
def test_namespace_registry_clear(self):
"""Test clearing a namespace registry."""
self.namespace_registry.clear()
self.assertIsNot(self.namespace_registry._graph, self.graph)
self.assertTrue(isomorphic(self.namespace_registry._graph, self.graph))
def test_namespace_registry_from_iri(self):
"""Test getting namespaces from iri."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
city_iri = ns_iri + "City"
hasPart_iri = ns_iri + "hasPart"
self.modify_labels()
c = self.namespace_registry.from_iri(rdflib_cuba.Entity)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "cuba")
self.assertEqual(c.name, "Entity")
r = self.namespace_registry.from_iri(rdflib_cuba.relationship)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "cuba")
self.assertEqual(r.name, "relationship")
a = self.namespace_registry.from_iri(rdflib_cuba.attribute)
self.assertIsInstance(a, OntologyAttribute)
self.assertEqual(a.namespace.get_name(), "cuba")
self.assertEqual(a.name, "attribute")
c = self.namespace_registry.from_iri(city_iri)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "city")
self.assertEqual(c.name, "City")
r = self.namespace_registry.from_iri(hasPart_iri)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "city")
self.assertEqual(r.name, "hasPart")
from osp.core.namespaces import from_iri
import osp.core.namespaces
old_ns_reg = osp.core.namespaces._namespace_registry
try:
osp.core.namespaces._namespace_registry = self.namespace_registry
c = from_iri(rdflib_cuba.Entity)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "cuba")
self.assertEqual(c.name, "Entity")
self.graph.add((ns_iri, rdflib_cuba._reference_by_label,
rdflib.Literal(True)))
c = self.namespace_registry.from_iri(city_iri)
self.assertIsInstance(c, OntologyClass)
self.assertEqual(c.namespace.get_name(), "city")
self.assertEqual(c.name, "City_T")
r = self.namespace_registry.from_iri(hasPart_iri)
self.assertIsInstance(r, OntologyRelationship)
self.assertEqual(r.namespace.get_name(), "city")
self.assertEqual(r.name, "hasPart_T")
# undefined namespace
self.graph.add(
(rdflib.URIRef("a/b#c"), rdflib.RDF.type, rdflib.OWL.Class))
self.graph.add(
(rdflib.URIRef("d/e/f"), rdflib.RDF.type, rdflib.OWL.Class))
a = from_iri("a/b#c")
b = from_iri("d/e/f")
self.assertIsInstance(a, OntologyClass)
self.assertEqual(a.namespace.get_name(), "a/b#")
self.assertEqual(a.name, "c")
self.assertIsInstance(b, OntologyClass)
self.assertEqual(b.namespace.get_name(), "d/e/")
self.assertEqual(b.name, "f")
finally:
osp.core.namespaces._namespace_registry = old_ns_reg
def test_namespace_registry_update_namespaces(self):
"""Test updateing the namespaces."""
self.graph.bind("a", rdflib.URIRef("aaa"))
self.graph.bind("b", rdflib.URIRef("bbb"))
self.graph.bind("c", rdflib.URIRef("ccc"))
self.namespace_registry.update_namespaces()
self.assertEqual(self.namespace_registry.a.get_name(), "a")
self.assertEqual(self.namespace_registry.a.get_iri(),
rdflib.URIRef("aaa"))
self.assertEqual(self.namespace_registry.b.get_name(), "b")
self.assertEqual(self.namespace_registry.b.get_iri(),
rdflib.URIRef("bbb"))
self.assertEqual(self.namespace_registry.c.get_name(), "c")
self.assertEqual(self.namespace_registry.c.get_iri(),
rdflib.URIRef("ccc"))
def test_namespace_registry_get(self):
"""Test getting namsepaces from namespace registry."""
self.installer.install("city")
self.assertIn("city", self.namespace_registry)
self.assertEqual(
self.namespace_registry._get("city").get_name(), "city")
self.assertEqual(
self.namespace_registry.get("city").get_name(), "city")
self.assertEqual(self.namespace_registry["city"].get_name(), "city")
self.assertEqual(self.namespace_registry.city.get_name(), "city")
self.assertRaises(KeyError, self.namespace_registry._get, "invalid")
self.assertEqual(self.namespace_registry.get("invalid"), None)
self.assertRaises(KeyError, self.namespace_registry.__getitem__,
"invalid")
self.assertRaises(AttributeError, getattr, self.namespace_registry,
"invalid")
self.assertEqual({x.get_name()
for x in self.namespace_registry},
{'xml', 'rdf', 'rdfs', 'xsd', 'cuba', 'owl', 'city'})
def modify_labels(self):
"""Modify the labels in the graph. Append a T.
Helper method.
"""
triples = list()
for s, p, o in self.graph:
if (s.startswith("http://www.osp-core.com/city#")
and p == rdflib.SKOS.prefLabel):
triples.append((s, p, rdflib.Literal(f"{o}_T", lang="en")))
else:
triples.append((s, p, o))
self.graph.remove((None, None, None))
for t in triples:
self.graph.add(t)
def test_namespace_get(self):
"""Test getting entities from namespace."""
self.installer.install("city")
self.modify_labels()
namespace = self.namespace_registry.city
# dot
self.assertIsInstance(namespace.City, OntologyClass)
self.assertEqual(namespace.City.name, "City")
self.assertEqual(namespace.City._iri_suffix, "City")
self.assertIsInstance(namespace.hasPart, OntologyRelationship)
self.assertEqual(namespace.hasPart.name, "hasPart")
self.assertEqual(namespace.hasPart._iri_suffix, "hasPart")
self.assertIsInstance(namespace.coordinates, OntologyAttribute)
self.assertEqual(namespace.coordinates.name, "coordinates")
self.assertEqual(namespace.coordinates._iri_suffix, "coordinates")
# item
self.assertIsInstance(namespace["City_T"][0], OntologyClass)
self.assertEqual(namespace["City_T"][0].name, "City")
self.assertEqual(namespace["City_T"][0]._iri_suffix, "City")
self.assertIsInstance(namespace["City_T", "en"][0], OntologyClass)
self.assertEqual(namespace["City_T", "en"][0].name, "City")
self.assertEqual(namespace["City_T", "en"][0]._iri_suffix, "City")
self.assertIsInstance(namespace["hasPart_T"][0], OntologyRelationship)
self.assertEqual(namespace["hasPart_T"][0].name, "hasPart")
self.assertEqual(namespace["hasPart_T"][0]._iri_suffix, "hasPart")
self.assertIsInstance(namespace["coordinates_T"][0], OntologyAttribute)
self.assertEqual(namespace["coordinates_T"][0].name, "coordinates")
self.assertEqual(namespace["coordinates_T"][0]._iri_suffix,
"coordinates")
# get
self.assertIsInstance(namespace.get("City"), OntologyClass)
self.assertEqual(namespace.get("City").name, "City")
self.assertEqual(namespace.get("City")._iri_suffix, "City")
self.assertIsInstance(namespace.get("hasPart"), OntologyRelationship)
self.assertEqual(namespace.get("hasPart").name, "hasPart")
self.assertEqual(namespace.get("hasPart")._iri_suffix, "hasPart")
self.assertIsInstance(namespace.get("coordinates"), OntologyAttribute)
self.assertEqual(namespace.get("coordinates").name, "coordinates")
self.assertEqual(
namespace.get("coordinates")._iri_suffix, "coordinates")
self.assertRaises(AttributeError, namespace.__getattr__, "CITY")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART_T")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART")
self.assertEqual(namespace.get("COORDINATES"), None)
# reference by label
namespace._reference_by_label = True
# dot
self.assertIsInstance(namespace.City_T, OntologyClass)
self.assertEqual(namespace.City_T.name, "City_T")
self.assertEqual(namespace.City_T._iri_suffix, "City")
self.assertIsInstance(namespace.hasPart_T, OntologyRelationship)
self.assertEqual(namespace.hasPart_T.name, "hasPart_T")
self.assertEqual(namespace.hasPart_T._iri_suffix, "hasPart")
self.assertIsInstance(namespace.coordinates_T, OntologyAttribute)
self.assertEqual(namespace.coordinates_T.name, "coordinates_T")
self.assertEqual(namespace.coordinates_T._iri_suffix, "coordinates")
# item
self.assertIsInstance(namespace["City_T"][0], OntologyClass)
self.assertEqual(namespace["City_T"][0].name, "City_T")
self.assertEqual(namespace["City_T"][0]._iri_suffix, "City")
self.assertIsInstance(namespace["City_T", "en"][0], OntologyClass)
self.assertEqual(namespace["City_T", "en"][0].name, "City_T")
self.assertEqual(namespace["City_T", "en"][0]._iri_suffix, "City")
self.assertIsInstance(namespace["hasPart_T"][0], OntologyRelationship)
self.assertEqual(namespace["hasPart_T"][0].name, "hasPart_T")
self.assertEqual(namespace["hasPart_T"][0]._iri_suffix, "hasPart")
self.assertIsInstance(namespace["coordinates_T"][0], OntologyAttribute)
self.assertEqual(namespace["coordinates_T"][0].name, "coordinates_T")
self.assertEqual(namespace["coordinates_T"][0]._iri_suffix,
"coordinates")
# get
self.assertIsInstance(namespace.get("City_T"), OntologyClass)
self.assertEqual(namespace.get("City_T").name, "City_T")
self.assertEqual(namespace.get("City_T")._iri_suffix, "City")
self.assertIsInstance(namespace.get("hasPart_T"), OntologyRelationship)
self.assertEqual(namespace.get("hasPart_T").name, "hasPart_T")
self.assertEqual(namespace.get("hasPart_T")._iri_suffix, "hasPart")
self.assertIsInstance(namespace.get("coordinates_T"),
OntologyAttribute)
self.assertEqual(namespace.get("coordinates_T").name, "coordinates_T")
self.assertEqual(
namespace.get("coordinates_T")._iri_suffix, "coordinates")
self.assertRaises(AttributeError, namespace.__getattr__, "CITY")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART_T")
self.assertRaises(KeyError, namespace.__getitem__, "HAS_PART")
self.assertEqual(namespace.get("COORDINATES"), None)
self.assertRaises(AttributeError, namespace.__getattr__, "City")
self.assertRaises(KeyError, namespace.__getitem__, "City")
self.assertEqual(namespace.get("coordinates"), None)
def test_namespace_str(self):
"""Test converting namespace object to string."""
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertEqual(str(namespace),
"city (http://www.osp-core.com/city#)")
self.assertEqual(repr(namespace),
"<city: http://www.osp-core.com/city#>")
def test_get_default_rel(self):
"""Test getting the default relationship."""
# default rel defined as flag in entity name
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertEqual(namespace.get_default_rel().name, "hasPart")
onto_def_rel = os.path.join(os.path.dirname(__file__),
'default_rel_across_namespace_valid.yml')
self.installer.install(onto_def_rel)
namespace = self.namespace_registry.default_rel_test_namespace_valid
self.assertEqual(namespace.get_default_rel(), cuba.activeRelationship)
onto_def_rel = os.path.join(
os.path.dirname(__file__),
'default_rel_across_namespace_two_definitions.yml')
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
onto_def_rel = os.path.join(
os.path.dirname(__file__),
'default_rel_across_namespace_uninstalled_entity.yml')
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
onto_def_rel = os.path.join(
os.path.dirname(__file__),
'default_rel_across_namespace_uninstalled_namespace.yml')
self.assertRaises(ValueError, self.installer.install, onto_def_rel)
def test_contains(self):
"""Test containment."""
self.installer.install("city")
namespace = self.namespace_registry.city
self.assertIn("City", namespace)
self.assertIn("hasPart", namespace)
def test_iter(self):
"""Test the __iter__() magic method."""
self.installer.install("city")
namespace = self.namespace_registry.city
entities = set(namespace)
self.assertIn(namespace.encloses, entities)
self.assertIn(namespace.City, entities)
self.assertIn(namespace.name, entities)
self.assertEqual(len(entities), 32)
def test_get_namespace_from_iri(self):
"""Test getting namespace object from IRI."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
namespace = self.namespace_registry.namespace_from_iri(ns_iri)
self.assertEqual(namespace.get_name(), "city")
self.assertEqual(namespace.get_iri(), ns_iri)
ns_iri = rdflib.URIRef("http://www.random_namespace.com#")
namespace = self.namespace_registry.namespace_from_iri(ns_iri)
self.assertEqual(namespace.get_name(),
"http://www.random_namespace.com#")
self.assertEqual(namespace.get_iri(), ns_iri)
def test_get_namespace_name_and_iri(self):
"""Test getting namespace name and IRI."""
self.installer.install("city")
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.osp-core.com/city#City")),
("city", rdflib.URIRef("http://www.osp-core.com/city#")))
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.random_namespace.com#Bla")),
("http://www.random_namespace.com#",
rdflib.URIRef("http://www.random_namespace.com#")))
self.assertEqual(
self.namespace_registry._get_namespace_name_and_iri(
rdflib.URIRef("http://www.random_namespace.com/Bla")),
("http://www.random_namespace.com/",
rdflib.URIRef("http://www.random_namespace.com/")))
def test_get_reference_by_label(self):
"""Test getting the reference style."""
self.installer.install("city")
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
self.assertFalse(
self.namespace_registry._get_reference_by_label(ns_iri))
self.graph.add(
(ns_iri, rdflib_cuba._reference_by_label, rdflib.Literal(True)))
self.assertTrue(
self.namespace_registry._get_reference_by_label(ns_iri))
def test_get_entity_name(self):
"""Test getting the name of an entity."""
self.installer.install("city")
self.modify_labels()
ns_iri = rdflib.URIRef("http://www.osp-core.com/city#")
iri = rdflib.URIRef("http://www.osp-core.com/city#City")
self.assertEqual(self.namespace_registry._get_entity_name(iri, ns_iri),
"City")
self.graph.add(
(ns_iri, rdflib_cuba._reference_by_label, rdflib.Literal(True)))
self.assertEqual(self.namespace_registry._get_entity_name(iri, ns_iri),
"City_T")