feat: add pyshifty shacl engine support

Author: gtfierro

buildingmotif/api/app.py

@@ -49,8 +49,9 @@ def create_app(DB_URI, shacl_engine: Optional[str] = "pyshacl"):
 
     :param db_uri: database URI
     :type db_uri: str
-    :param shacl_engine: the name of the engine to use for validation: "pyshacl" or "topquadrant". Using topquadrant
-        requires Java to be installed on this machine, and the "topquadrant" feature on BuildingMOTIF,
+    :param shacl_engine: the name of the engine to use for validation: "pyshacl",
+        "topquadrant", or "pyshifty". Using topquadrant requires Java to be
+        installed on this machine, and the "topquadrant" feature on BuildingMOTIF,
         defaults to "pyshacl"
     :type shacl_engine: str, optional
     :return: flask app

buildingmotif/building_motif/building_motif.py

@@ -35,9 +35,10 @@ def __init__(
 
         :param db_uri: database URI
         :type db_uri: str
-        :param shacl_engine: the name of the engine to use for validation: "pyshacl" or "topquadrant". Using topquadrant
-            requires Java to be installed on this machine, and the "topquadrant" feature on BuildingMOTIF,
-            defaults to "pyshacl"
+        :param shacl_engine: the name of the engine to use for validation: "pyshacl",
+            "topquadrant", or "pyshifty". Using topquadrant requires Java to be
+            installed on this machine, and the "topquadrant" feature on
+            BuildingMOTIF, defaults to "pyshacl"
         :type shacl_engine: str, optional
         :param log_level: logging level of detail
         :type log_level: int

buildingmotif/dataclasses/compiled_model.py

@@ -222,3 +222,139 @@ def shape_to_df(self, shape: rdflib.URIRef) -> pd.DataFrame:
         metadata.columns = [str(col) for col in metadata.columns]
         # convert the rdflib terms to Python types
         return metadata.map(lambda x: x.toPython())
+
+
+class PyshiftyCompiledModel(CompiledModel):
+    """
+    Specialized CompiledModel for the pyshifty SHACL engine.
+    Keeps data and shape graphs separate and avoids shape skolemization.
+    """
+
+    def __init__(
+        self,
+        model: Model,
+        shape_collections: List[ShapeCollection],
+        compiled_graph: rdflib.Graph,
+        shacl_engine: str = "default",
+    ):
+        self.model = model
+        self.shape_collections = shape_collections
+        ontology_graph = rdflib.Graph()
+        for shape_collection in shape_collections:
+            ontology_graph += shape_collection.graph
+
+        ontology_graph = skolemize_shapes(ontology_graph)
+
+        shacl_engine = (
+            self.model._bm.shacl_engine
+            if (shacl_engine == "default" or not shacl_engine)
+            else shacl_engine
+        )
+
+        self._compiled_graph = shacl_inference(
+            compiled_graph, ontology_graph, shacl_engine
+        )
+
+    def _build_shape_graph(self, error_on_missing_imports: bool = True) -> rdflib.Graph:
+        shape_graph = rdflib.Graph()
+        for sc in self.shape_collections:
+            shape_graph += sc.resolve_imports(
+                error_on_missing_imports=error_on_missing_imports
+            ).graph
+        shape_graph = rewrite_shape_graph(shape_graph)
+        shape_graph.remove((None, OWL.imports, None))
+        return skolemize_shapes(shape_graph)
+
+    def validate_model_against_shapes(
+        self,
+        shapes_to_test: List[rdflib.URIRef],
+        target_class: rdflib.URIRef,
+    ) -> Dict[rdflib.URIRef, "ValidationContext"]:
+        """Validates the model against a list of shapes and generates a
+        validation report for each.
+
+        :param shapes_to_test: list of shape URIs to validate the model against
+        :type shapes_to_test: List[URIRef]
+        :param target_class: the class upon which to run the selected shapes
+        :type target_class: URIRef
+        :return: a dictionary that relates each shape to test URIRef to a
+                 ValidationContext
+        :rtype: Dict[URIRef, ValidationContext]
+        """
+        model_graph = copy_graph(self._compiled_graph)
+
+        results = {}
+
+        targets = model_graph.query(
+            f"""
+            PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
+            PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
+            SELECT ?target
+            WHERE {{
+                ?target rdf:type/rdfs:subClassOf* <{target_class}>
+
+            }}
+        """
+        )
+
+        shape_graph = rdflib.Graph()
+        for shape_collection in self.shape_collections:
+            shape_graph += shape_collection.graph
+        shape_graph = skolemize_shapes(shape_graph)
+
+        for shape_uri in shapes_to_test:
+            temp_model_graph = copy_graph(model_graph)
+            for (s,) in targets:
+                temp_model_graph.add((URIRef(s), A, shape_uri))
+
+            valid, report_g, report_str = shacl_validate(
+                temp_model_graph, shape_graph, engine=self.model._bm.shacl_engine
+            )
+            results[shape_uri] = ValidationContext(
+                self.shape_collections,
+                shape_graph,
+                valid,
+                report_g,
+                report_str,
+                self.model,
+            )
+
+        return results
+
+    def validate(
+        self,
+        error_on_missing_imports: bool = True,
+    ) -> "ValidationContext":
+        """Validates this model against the given list of ShapeCollections.
+        If no list is provided, the model will be validated against the model's "manifest".
+        If a list of shape collections is provided, the manifest will *not* be automatically
+        included in the set of shape collections.
+
+        Loads all of the ShapeCollections into a single graph.
+
+        :param error_on_missing_imports: if True, raises an error if any of the dependency
+            ontologies are missing (i.e. they need to be loaded into BuildingMOTIF), defaults
+            to True
+        :type error_on_missing_imports: bool, optional
+        :return: An object containing useful properties/methods to deal with
+            the validation results
+        :rtype: ValidationContext
+        """
+        data_graph = copy_graph(self._compiled_graph)
+        data_graph.remove((None, OWL.imports, None))
+
+        shape_graph = self._build_shape_graph(
+            error_on_missing_imports=error_on_missing_imports
+        )
+
+        valid, report_g, report_str = shacl_validate(
+            data_graph, shape_graph, engine=self.model._bm.shacl_engine
+        )
+        return ValidationContext(
+            self.shape_collections,
+            shape_graph,
+            valid,
+            report_g,
+            report_str,
+            self.model,
+        )

buildingmotif/dataclasses/model.py

@@ -232,20 +232,30 @@ def compile(
             ShapeCollections
         :rtype: Graph
         """
-        from buildingmotif.dataclasses.compiled_model import CompiledModel
+        from buildingmotif.dataclasses.compiled_model import (
+            CompiledModel,
+            PyshiftyCompiledModel,
+        )
 
-        ontology_graph = rdflib.Graph()
         if shape_collections is None:
             shape_collections = [self.get_manifest()]
+
+        model_graph = copy_graph(self.graph).skolemize()
+        shacl_engine = self._bm.shacl_engine
+
+        if shacl_engine == "pyshifty":
+            return PyshiftyCompiledModel(
+                self, shape_collections, model_graph, shacl_engine=shacl_engine
+            )
+
+        ontology_graph = rdflib.Graph()
         for shape_collection in shape_collections:
             ontology_graph += shape_collection.graph
 
         ontology_graph = skolemize_shapes(ontology_graph)
 
-        model_graph = copy_graph(self.graph).skolemize()
-
         compiled_graph = shacl_inference(
-            model_graph, ontology_graph, engine=self._bm.shacl_engine
+            model_graph, ontology_graph, engine=shacl_engine
         )
         return CompiledModel(self, shape_collections, compiled_graph)
 

buildingmotif/utils.py

@@ -635,7 +635,8 @@ def shacl_validate(
     """
     Validate the data graph against the shape graph.
     Uses the fastest validation method available. Use the 'topquadrant' feature
-    to use TopQuadrant's SHACL engine. Defaults to using PySHACL.
+    to use TopQuadrant's SHACL engine. Use 'pyshifty' to use the pyshifty engine.
+    Defaults to using PySHACL.
 
     :param data_graph: the graph to validate
     :type data_graph: Graph
@@ -659,6 +660,18 @@ def shacl_validate(
                 "TopQuadrant SHACL engine not available. Using PySHACL instead."
             )
             pass
+    elif engine == "pyshifty":
+        try:
+            import shifty  # type: ignore
+
+            return shifty.validate(
+                data_graph,
+                shape_graph or Graph(),
+                run_inference=True,
+            )
+        except ImportError:
+            logging.info("PyShifty SHACL engine not available. Using PySHACL instead.")
+            pass
 
     data_graph = data_graph + (shape_graph or Graph())
     return pyshacl.validate(
@@ -679,8 +692,8 @@ def shacl_inference(
     """
     Infer new triples in the data graph using the shape graph.
     Edits the data graph in place. Uses the fastest inference method available.
-    Use the 'topquadrant' feature to use TopQuadrant's SHACL engine. Defaults to
-    using PySHACL.
+    Use the 'topquadrant' feature to use TopQuadrant's SHACL engine. Use
+    'pyshifty' to use the pyshifty engine. Defaults to using PySHACL.
 
     :param data_graph: the graph to infer new triples in
     :type data_graph: Graph
@@ -701,6 +714,19 @@ def shacl_inference(
                 "TopQuadrant SHACL engine not available. Using PySHACL instead."
             )
             pass
+    elif engine == "pyshifty":
+        try:
+            import shifty  # type: ignore
+
+            o = shifty.infer(
+                data_graph,
+                shape_graph or Graph(),
+                union=True,
+            )
+            return o
+        except ImportError:
+            logging.info("PyShifty SHACL engine not available. Using PySHACL instead.")
+            pass
 
     # We use a fixed-point computation approach to 'compiling' RDF models.
     # We accomlish this by keeping track of the size of the graph before and after