cognite-neat 0.103.1__py3-none-any.whl → 0.105.0__py3-none-any.whl

cognite/neat/_graph/transformers/_prune_graph.py

@@ -1,15 +1,17 @@
 from typing import cast
 
 from rdflib import Graph, Namespace, URIRef
+from rdflib.query import ResultRow
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._shared import Triple
 from cognite.neat._utils.rdf_ import as_neat_compliant_uri
 from cognite.neat._utils.text import sentence_or_string_to_camel
 
-from ._base import BaseTransformer
+from ._base import BaseTransformer, BaseTransformerStandardised, RowTransformationOutput
 
 
+# TODO: Standardise after figuring out the bug which appears when running test_iodd_transformers.py
 class AttachPropertyFromTargetToSource(BaseTransformer):
     """
     Transformer that considers a TargetNode and SourceNode relationship, to extract a property that is attached to
@@ -148,6 +150,7 @@ class AttachPropertyFromTargetToSource(BaseTransformer):
                 graph.remove((target_node, None, None))
 
 
+# TODO: Remove or adapt IODD
 class PruneDanglingNodes(BaseTransformer):
     """
     Knowledge graph pruner and resolver. Will remove rdf triples from graph that does not have connections
@@ -189,18 +192,12 @@ class PruneDanglingNodes(BaseTransformer):
                 graph.remove((subject, None, None))
 
 
-class PruneTypes(BaseTransformer):
+class PruneTypes(BaseTransformerStandardised):
     """
     Removes all the instances of specific type
     """
 
     description: str = "Prunes nodes of specific rdf types"
-    _query_template = """
-                        SELECT ?subject
-                        WHERE {{
-                            ?subject a <{rdf_type}> .
-                            }}
-                      """
 
     def __init__(
         self,
@@ -208,50 +205,109 @@ class PruneTypes(BaseTransformer):
     ):
         self.node_prune_types = node_prune_types
 
-    def transform(self, graph: Graph) -> None:
-        for type_ in self.node_prune_types:
-            for (subject,) in list(graph.query(self._query_template.format(rdf_type=type_))):  # type: ignore
-                graph.remove((subject, None, None))
-
-
-class PruneDeadEndEdges(BaseTransformer):
+    def _iterate_query(self) -> str:
+        filter_string = ""
+        for node in self.node_prune_types:
+            filter_string += f" <{node}> "
+
+        query = """
+                SELECT ?subject
+                WHERE {{
+                  ?subject a ?type .
+                  VALUES ?type {{ {rdf_types_string} }}
+                }}
+                """
+        return query.format(rdf_types_string=filter_string)
+
+    def _count_query(self) -> str:
+        filter_string = ""
+        for node in self.node_prune_types:
+            filter_string += f" <{node}> "
+
+        query = """
+                SELECT ( COUNT( ?subject ) as ?count )
+                WHERE {{
+                  ?subject a ?type .
+                  VALUES ?type {{ {rdf_types_string} }}
+                }}
+                """
+        return query.format(rdf_types_string=filter_string)
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+
+        (subject,) = query_result_row
+        row_output.remove_triples.append((subject, None, None))  # type: ignore
+        row_output.instances_removed_count = 1
+
+        return row_output
+
+
+class PruneDeadEndEdges(BaseTransformerStandardised):
     """
     Removes all the triples where object is a node that is not found in graph
     """
 
-    description: str = "Prunes the graph of specified rdf types that do not have connections to other nodes."
-    _query_template = """
-                        SELECT ?subject ?predicate ?object
-                        WHERE {
-                            ?subject ?predicate ?object .
-                            FILTER (isIRI(?object) && ?predicate != rdf:type)
-                            FILTER NOT EXISTS {?object ?p ?o .}
-
-                            }
-
-                      """
-
-    def transform(self, graph: Graph) -> None:
-        for triple in graph.query(self._query_template):
-            graph.remove(cast(Triple, triple))
-
-
-class PruneInstancesOfUnknownType(BaseTransformer):
+    description: str = "Pruning the graph of triples where object is a node that is not found in graph."
+
+    def _iterate_query(self) -> str:
+        return """
+                 SELECT ?subject ?predicate ?object
+                 WHERE {
+                     ?subject ?predicate ?object .
+                     FILTER (isIRI(?object) && ?predicate != rdf:type)
+                     FILTER NOT EXISTS {?object ?p ?o .}
+                     }
+                 """
+
+    def _count_query(self) -> str:
+        return """
+                SELECT (COUNT(?object) AS ?count)
+                WHERE {
+                    ?subject ?predicate ?object .
+                    FILTER (isIRI(?object) && ?predicate != rdf:type)
+                    FILTER NOT EXISTS {?object ?p ?o .}
+                    }
+                """
+
+    def operation(self, row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+        row_output.remove_triples.append(cast(Triple, row))
+        row_output.instances_modified_count = 1
+
+        return row_output
+
+
+class PruneInstancesOfUnknownType(BaseTransformerStandardised):
     """
     Removes all the triples where object is a node that is not found in graph
     """
 
-    description: str = "Prunes the graph of specified rdf types that do not have connections to other nodes."
-    _query_template = """
-                    SELECT DISTINCT ?subject
-                    WHERE {
-                        ?subject ?p ?o .
-                        FILTER NOT EXISTS {?subject a ?object .}
-
-                        }
-
-                    """
-
-    def transform(self, graph: Graph) -> None:
-        for (subject,) in graph.query(self._query_template):  # type: ignore
-            graph.remove((subject, None, None))
+    description: str = "Prunes the graph of triples where the object is a node that is not found in the graph."
+
+    def _iterate_query(self) -> str:
+        return """
+                SELECT DISTINCT ?subject
+                WHERE {
+                    ?subject ?p ?o .
+                    FILTER NOT EXISTS {?subject a ?object .}
+
+                    }
+                """
+
+    def _count_query(self) -> str:
+        return """
+                SELECT (COUNT(DISTINCT ?subject) as ?count)
+                WHERE {
+                    ?subject ?p ?o .
+                    FILTER NOT EXISTS {?subject a ?object .}
+                    }
+                """
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+        (subject,) = query_result_row
+        row_output.remove_triples.append(cast(Triple, (subject, None, None)))
+        row_output.instances_removed_count = 1
+
+        return row_output

cognite/neat/_graph/transformers/_rdfpath.py

@@ -2,15 +2,16 @@ from typing import cast
 from urllib.parse import quote
 
 from rdflib import Graph, URIRef
+from rdflib.query import ResultRow
 
 from cognite.neat._constants import DEFAULT_NAMESPACE
 from cognite.neat._rules.analysis import InformationAnalysis
 from cognite.neat._rules.models._rdfpath import RDFPath, SingleProperty
 from cognite.neat._rules.models.information import InformationRules
 from cognite.neat._shared import Triple
-from cognite.neat._utils.rdf_ import add_triples_in_batch, remove_namespace_from_uri
+from cognite.neat._utils.rdf_ import remove_namespace_from_uri
 
-from ._base import BaseTransformer
+from ._base import BaseTransformer, BaseTransformerStandardised, RowTransformationOutput
 
 
 class ReduceHopTraversal(BaseTransformer):
@@ -19,6 +20,7 @@ class ReduceHopTraversal(BaseTransformer):
     ...
 
 
+# TODO: Standardise
 class AddSelfReferenceProperty(BaseTransformer):
     description: str = "Adds property that contains id of reference to all references of given class in Rules"
     _use_only_once: bool = True
@@ -56,17 +58,10 @@ class AddSelfReferenceProperty(BaseTransformer):
             property_.transformation = RDFPath(traversal=traversal)
 
 
-class MakeConnectionOnExactMatch(BaseTransformer):
+class MakeConnectionOnExactMatch(BaseTransformerStandardised):
     description: str = "Adds property that contains id of reference to all references of given class in Rules"
     _use_only_once: bool = True
     _need_changes = frozenset({})
-    _ref_template: str = """SELECT DISTINCT ?subject ?object
-                            WHERE {{
-                                ?subject a <{subject_type}> .
-                                ?subject <{subject_predicate}> ?value .
-                                ?object <{object_predicate}> ?value .
-                                ?object a <{object_type}> .
-                            }}"""
 
     def __init__(
         self,
@@ -90,20 +85,49 @@ class MakeConnectionOnExactMatch(BaseTransformer):
 
         self.limit = limit
 
-    def transform(self, graph: Graph) -> None:
-        query = self._ref_template.format(
+    def _iterate_query(self) -> str:
+        query = """SELECT DISTINCT ?subject ?object
+                            WHERE {{
+                                ?subject a <{subject_type}> .
+                                ?subject <{subject_predicate}> ?value .
+                                ?object <{object_predicate}> ?value .
+                                ?object a <{object_type}> .
+                            }}"""
+
+        if self.limit and isinstance(self.limit, int) and self.limit > 0:
+            query += f" LIMIT {self.limit}"
+
+        return query.format(
             subject_type=self.subject_type,
             subject_predicate=self.subject_predicate,
             object_type=self.object_type,
             object_predicate=self.object_predicate,
         )
 
+    def _count_query(self) -> str:
+        query = """SELECT (COUNT(DISTINCT (?subject ?object)) as ?count)
+                    WHERE {{
+                        ?subject a <{subject_type}> .
+                        ?subject <{subject_predicate}> ?value .
+                        ?object <{object_predicate}> ?value .
+                        ?object a <{object_type}> .
+                    }}"""
+
         if self.limit and isinstance(self.limit, int) and self.limit > 0:
             query += f" LIMIT {self.limit}"
 
-        triples: list[Triple] = []
-        for subject, object in graph.query(query):  # type: ignore [misc]
-            triples.append(cast(Triple, (subject, self.connection, object)))
+        return query.format(
+            subject_type=self.subject_type,
+            subject_predicate=self.subject_predicate,
+            object_type=self.object_type,
+            object_predicate=self.object_predicate,
+        )
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+
+        subject, object = query_result_row
 
-        print(f"Found {len(triples)} connections. Adding them to the graph...")
-        add_triples_in_batch(graph, triples)
+        row_output.add_triples.append(cast(Triple, (subject, self.connection, object)))
+        row_output.instances_modified_count += 1
+        return row_output