support rdfs class in template loading

Author: gtfierro

buildingmotif/dataclasses/library.py

@@ -209,8 +209,8 @@ def _load_from_ontology(
     ) -> "Library":
         """
         Load a library from an ontology graph. This proceeds as follows.
-        First, get all entities in the graph that are instances of *both* owl:Class
-        and sh:NodeShape. (this is "candidates")
+        First, get all entities in the graph that are instances of *both* sh:NodeShape
+        and either owl:Class or rdfs:Class (these are the "candidates").
 
         For each candidate, use the utility function to parse the NodeShape and turn
         it into a Template.

buildingmotif/dataclasses/shape_collection.py

@@ -207,7 +207,9 @@ def infer_templates(self, library: "Library") -> None:
                 )
                 continue
 
-        class_candidates = set(self.graph.subjects(rdflib.RDF.type, rdflib.OWL.Class))
+        class_candidates = set(
+            self.graph.subjects(rdflib.RDF.type, rdflib.OWL.Class)
+        ).union(self.graph.subjects(rdflib.RDF.type, rdflib.RDFS.Class))
         shape_candidates = set(
             self.graph.subjects(rdflib.RDF.type, rdflib.SH.NodeShape)
         )

buildingmotif/template_matcher.py

@@ -71,7 +71,11 @@ def defined_in(self, node: Node, graph: Graph) -> bool:
         cache = self.in_cache[id(graph)]
         # populate cache if necessary
         if node not in cache:
-            cache[node] = (node, RDF.type, OWL.Class) in graph
+            cache[node] = (node, RDF.type, OWL.Class) in graph or (
+                node,
+                RDF.type,
+                RDFS.Class,
+            ) in graph
         return cache[node]
 
 

buildingmotif/utils.py

@@ -263,6 +263,16 @@ def resolve_library(node_uri: URIRef) -> Optional[str]:
                 break
         return library
 
+    def is_class(node_uri: URIRef) -> bool:
+        for graph in [shape_graph, *depedency_graphs.values()]:
+            if (node_uri, RDF.type, OWL.Class) in graph or (
+                node_uri,
+                RDF.type,
+                RDFS.Class,
+            ) in graph:
+                return True
+        return False
+
     def add_dependency(node_uri: URIRef, param: URIRef):
         if not isinstance(node_uri, URIRef):
             return
@@ -286,9 +296,7 @@ def process_shape(shape_node: Node, focus_param: URIRef):
             return
         visited.add(key)
 
-        if (shape_node, RDF.type, OWL.Class) in shape_graph and isinstance(
-            shape_node, URIRef
-        ):
+        if isinstance(shape_node, URIRef) and is_class(shape_node):
             body.add((focus_param, RDF.type, shape_node))
 
         for cls in shape_graph.objects(shape_node, SH["class"]):

docs/explanations/shapes-and-templates.md

@@ -29,10 +29,10 @@ Evaluating the resulting template will generate a graph that validates against t
 When BuildingMOTIF loads a Library, it makes an attempt to find any shapes defined within it.
 The way this happens depends on how the library is loaded:
 - *Loading library from directory or git repository*: BuildingMOTIF searches for any RDF files in the directory (recursively) and loads them into a Shape Collection; loads any instances of `sh:NodeShape` in the union of these RDF files
-- *Loading library from ontology file*: loads all instances of `sh:NodeShape` in the provided graphc
+- *Loading library from ontology file*: loads all instances of `sh:NodeShape` in the provided graph
 
 ```{important}
-BuildingMOTIF *only* loads shapes which are instances of *both* `sh:NodeShape` **and** `owl:Class`. The assumption is that `owl:Class`-ified shapes could be "instantiated".
+BuildingMOTIF *only* loads shapes which are instances of `sh:NodeShape` **and** either `owl:Class` or `rdfs:Class`. The assumption is that class-ified shapes could be "instantiated".
 ```
 
 Each shape is "decompiled" into components from which a Template can be constructed.

docs/explanations/templates.md

@@ -65,7 +65,7 @@ BuildingMOTIF can also infer a template from certain SHACL shape definitions.
 This happens when a Library is loaded into BuildingMOTIF that contains an RDF graph; this can happen by loading the RDF graph directly (via `Library.load(ontology_graph="path to graph")`)
 or by loading in a directory that contains RDF graphs (via `Library.load(directory="directory with .ttl files")`).
 
-Given an RDF graph, BuildingMOTIF will create a template for each instance of `sh:NodeShape` *provided* that it is also an instance of `owl:Class`.
+Given an RDF graph, BuildingMOTIF will create a template for each instance of `sh:NodeShape` *provided* that it is also an instance of `owl:Class` or `rdfs:Class`.
 In the following RDF graph, BuildingMOTIF would create a tempalte for `vav_shape` but not `sensor_shape`:
 
 ```ttl

tests/unit/dataclasses/test_shape_collection.py

@@ -8,7 +8,7 @@
 
 from buildingmotif.dataclasses.library import Library
 from buildingmotif.dataclasses.shape_collection import ShapeCollection
-from buildingmotif.namespaces import BMOTIF, BRICK
+from buildingmotif.namespaces import BMOTIF, BRICK, PARAM
 
 
 def test_create_shape_collection(clean_building_motif):
@@ -185,3 +185,44 @@ def test_shape_to_query(clean_building_motif, shape_name, query_clauses):
         assert clause in query, query
     # Validate that the query executes correctly
     g.query(query)
+
+
+def test_infer_templates_accepts_rdfs_class(clean_building_motif):
+    graph = Graph()
+    graph.parse(
+        data="""
+        @prefix : <urn:test#> .
+        @prefix owl: <http://www.w3.org/2002/07/owl#> .
+        @prefix sh: <http://www.w3.org/ns/shacl#> .
+        @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+        @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+
+        :ontology a owl:Ontology .
+
+        :MyShape a sh:NodeShape, rdfs:Class ;
+            sh:targetClass :MyShape ;
+            sh:property [
+                sh:path :hasChild ;
+                sh:minCount 1 ;
+                sh:name "child" ;
+                sh:class :ChildClass ;
+            ] .
+
+        :ChildShape a sh:NodeShape, rdfs:Class ;
+            sh:targetClass :ChildClass ;
+            sh:property [
+                sh:path :label ;
+                sh:minCount 1 ;
+                sh:datatype xsd:string ;
+            ] .
+
+        :ChildClass a rdfs:Class .
+        """,
+        format="turtle",
+    )
+
+    lib = Library.load(
+        ontology_graph=graph, infer_templates=True, run_shacl_inference=False
+    )
+    template = lib.get_template_by_name("urn:test#MyShape")
+    assert (PARAM["name"], RDF.type, URIRef("urn:test#MyShape")) in template.body