🐛 fix(SHACL-core): improve SHACL violation parsing with better error handling

Author: kikkomep

rocrate_validator/requirements/shacl/checks.py

@@ -196,12 +196,33 @@ def __do_execute_check__(self, shacl_context: SHACLValidationContext):
         logger.debug("Parsing Validation with result: %s", shacl_result)
         # process the failed checks to extract the requirement checks involved
         for violation in shacl_result.violations:
-            shape = shapes_registry.get_shape(Shape.compute_key(shapes_graph, violation.sourceShape))
-            assert shape is not None, "Unable to map the violation to a shape"
+            shape = None
+            try:
+                shape = shapes_registry.get_shape(Shape.compute_key(shapes_graph, violation.sourceShape))
+            except (ValueError, KeyError):
+                # sourceShape may be a BNode (e.g. an inline sh:sparql constraint).
+                # Attempt to resolve the owning NodeShape/PropertyShape via the graph.
+                shape = resolve_parent_shape(shapes_graph, violation.sourceShape, shapes_registry)
+                if shape is None:
+                    logger.warning(
+                        "Unable to map violation to a shape (sourceShape: %s); skipping",
+                        violation.sourceShape,
+                    )
+                    continue
+            if shape is None:
+                logger.warning(
+                    "Shape not found for violation (sourceShape: %s)",
+                    violation.sourceShape,
+                )
+                continue
             requirementCheck = SHACLCheck.get_instance(shape)
-            assert requirementCheck is not None, "The requirement check cannot be None"
-            if (not shacl_context.settings.skip_checks or
-                    requirementCheck.identifier not in shacl_context.settings.skip_checks):
+            if requirementCheck is None:
+                logger.warning("No check instance found for shape: %s", shape.key)
+                continue
+            if (
+                not shacl_context.settings.skip_checks
+                or requirementCheck.identifier not in shacl_context.settings.skip_checks
+            ):
                 failed_requirements_checks.add(requirementCheck)
                 violations = failed_requirements_checks_violations.get(requirementCheck.identifier, None)
                 if violations is None:

rocrate_validator/requirements/shacl/utils.py

@@ -16,7 +16,7 @@
 
 import hashlib
 from pathlib import Path
-from typing import Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 from rdflib import RDF, BNode, Graph, Namespace
 from rdflib.term import Node
@@ -26,6 +26,9 @@
 from rocrate_validator.errors import BadSyntaxError
 from rocrate_validator.models import Severity
 
+if TYPE_CHECKING:
+    from rocrate_validator.requirements.shacl.models import Shape
+
 # set up logging
 logger = logging.getLogger(__name__)
 
@@ -296,3 +299,39 @@ def load_shapes_from_graph(g: Graph) -> ShapesList:
         subgraphs[shape] = subgraph
 
     return ShapesList(node_shapes, property_shapes, subgraphs, g)
+
+
+def resolve_parent_shape(
+    shapes_graph: Graph, source_shape_node: Node, shapes_registry
+) -> Optional[Shape]:
+    """
+    Try to resolve the parent NodeShape/PropertyShape for a BNode constraint node.
+
+    When a SPARQL constraint (sh:sparql) or inline constraint BNode fires a violation,
+    pyshacl reports the BNode as `sh:sourceShape`. That BNode is not registered
+    in the ShapesRegistry directly; instead the containing NodeShape is.
+    This helper walks up via sh:sparql and sh:property predicates to find it.
+    """
+    from rocrate_validator.requirements.shacl.models import Shape
+
+    if not isinstance(source_shape_node, BNode):
+        return None
+    SHACL = Namespace(SHACL_NS)
+    # Predicates via which a NodeShape/PropertyShape can own a constraint BNode
+    parent_predicates = [SHACL.sparql, SHACL.property]
+    for predicate in parent_predicates:
+        for parent_node in shapes_graph.subjects(predicate, source_shape_node):
+            try:
+                parent_shape = shapes_registry.get_shape(
+                    Shape.compute_key(shapes_graph, parent_node)
+                )
+                if parent_shape is not None:
+                    logger.debug(
+                        "Resolved parent shape %s for SPARQL/inline constraint BNode %s",
+                        parent_shape.key,
+                        source_shape_node,
+                    )
+                    return parent_shape
+            except (ValueError, KeyError):
+                continue
+    return None