cognite-neat 0.107.0__py3-none-any.whl → 0.109.0__py3-none-any.whl

cognite/neat/_graph/queries/_base.py

@@ -3,11 +3,12 @@ from collections import defaultdict
 from collections.abc import Iterable
 from typing import Literal, cast, overload
 
-from rdflib import RDF, Graph, Namespace, URIRef
+from rdflib import RDF, Dataset, Graph, Namespace, URIRef
 from rdflib import Literal as RdfLiteral
+from rdflib.graph import DATASET_DEFAULT_GRAPH_ID
 from rdflib.query import ResultRow
 
-from cognite.neat._constants import UNKNOWN_TYPE
+from cognite.neat._constants import NEAT
 from cognite.neat._rules._constants import EntityTypes
 from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._rules.models.information import InformationRules
@@ -20,11 +21,21 @@ from ._construct import build_construct_query
 class Queries:
     """Helper class for storing standard queries for the graph store."""
 
-    def __init__(self, graph: Graph, rules: InformationRules | None = None):
-        self.graph = graph
-        self.rules = rules
-
-    def summarize_instances(self) -> list[tuple]:
+    def __init__(
+        self,
+        dataset: Dataset,
+        rules: dict[URIRef, InformationRules] | None = None,
+        default_named_graph: URIRef | None = None,
+    ):
+        self.dataset = dataset
+        self.rules = rules or {}
+        self.default_named_graph = default_named_graph or DATASET_DEFAULT_GRAPH_ID
+
+    def graph(self, named_graph: URIRef | None = None) -> Graph:
+        """Get named graph from the dataset to query over"""
+        return self.dataset.graph(named_graph or self.default_named_graph)
+
+    def summarize_instances(self, named_graph: URIRef | None = None) -> list[tuple]:
         """Summarize instances in the graph store by class and count"""
 
         query_statement = """ SELECT ?class (COUNT(?instance) AS ?instanceCount)
@@ -39,36 +50,55 @@ class Queries:
                 remove_namespace_from_uri(cast(URIRef, cast(tuple, res)[0])),
                 cast(RdfLiteral, cast(tuple, res)[1]).value,
             )
-            for res in list(self.graph.query(query_statement))
+            for res in list(self.graph(named_graph=named_graph).query(query_statement))
         ]
 
-    @property
-    def types(self) -> dict[URIRef, str]:
+    def types(self, named_graph: URIRef | None = None) -> dict[URIRef, str]:
         """Types and their short form in the graph"""
         query = """SELECT DISTINCT ?type
                    WHERE {?s a ?type .}"""
-        return {type_: remove_namespace_from_uri(cast(URIRef, type_)) for (type_,) in list(self.graph.query(query))}  # type: ignore[misc, index, arg-type]
 
-    def type_uri(self, type_: str) -> list[URIRef]:
+        return {  # type: ignore[misc, index, arg-type]
+            cast(URIRef, type_): remove_namespace_from_uri(cast(URIRef, type_))
+            for (type_,) in list(self.graph(named_graph).query(query))
+        }
+
+    def type_uri(self, type_: str, named_graph: URIRef | None = None) -> list[URIRef]:
         """Get the URIRef of a type"""
-        return [k for k, v in self.types.items() if v == type_]
+        return [k for k, v in self.types(named_graph).items() if v == type_]
+
+    def properties(self, named_graph: URIRef | None = None) -> dict[URIRef, str]:
+        """Properties and their short form in the graph
 
-    @property
-    def properties(self) -> dict[URIRef, str]:
+        Args:
+            named_graph: Named graph to query over, default None (default graph)
+
+        """
         query = """SELECT DISTINCT ?property
                WHERE {?s ?property ?o . FILTER(?property != rdf:type)}"""
-        return {type_: remove_namespace_from_uri(cast(URIRef, type_)) for (type_,) in list(self.graph.query(query))}  # type: ignore[misc, index, arg-type]
+        return {  # type: ignore[misc, index, arg-type]
+            cast(URIRef, type_): remove_namespace_from_uri(cast(URIRef, type_))
+            for (type_,) in list(self.graph(named_graph).query(query))
+        }
 
-    def property_uri(self, property_: str) -> list[URIRef]:
-        """Get the URIRef of a type"""
-        return [k for k, v in self.properties.items() if v == property_]
+    def property_uri(self, property_: str, named_graph: URIRef | None = None) -> list[URIRef]:
+        """Get the URIRef of a property
 
-    def list_instances_ids_of_class(self, class_uri: URIRef, limit: int = -1) -> list[URIRef]:
+        Args:
+            property_: Property to find URIRef for
+            named_graph: Named graph to query over, default None (default graph)
+        """
+        return [k for k, v in self.properties(named_graph).items() if v == property_]
+
+    def list_instances_ids_of_class(
+        self, class_uri: URIRef, limit: int = -1, named_graph: URIRef | None = None
+    ) -> list[URIRef]:
         """Get instances ids for a given class
 
         Args:
             class_uri: Class for which instances are to be found
             limit: Max number of instances to return, by default -1 meaning all instances
+            named_graph: Named graph to query over, default None (default graph)
 
         Returns:
             List of class instance URIs
@@ -76,16 +106,17 @@ class Queries:
         query_statement = "SELECT DISTINCT ?subject WHERE { ?subject a <class> .} LIMIT X".replace(
             "class", class_uri
         ).replace("LIMIT X", "" if limit == -1 else f"LIMIT {limit}")
-        return [cast(tuple, res)[0] for res in list(self.graph.query(query_statement))]
+        return [cast(tuple, res)[0] for res in list(self.graph(named_graph).query(query_statement))]
 
-    def list_instances_of_type(self, class_uri: URIRef) -> list[ResultRow]:
+    def list_instances_of_type(self, class_uri: URIRef, named_graph: URIRef | None = None) -> list[ResultRow]:
         """Get all triples for instances of a given class
 
         Args:
             class_uri: Class for which instances are to be found
+            named_graph: Named graph to query over, default None (default graph)
 
         Returns:
-            List of triples for instances of the given class
+            List of triples for instances of the given class in the named graph
         """
         query = (
             f"SELECT ?instance ?prop ?value "
@@ -93,17 +124,22 @@ class Queries:
         )
 
         # Select queries gives an iterable of result rows
-        return cast(list[ResultRow], list(self.graph.query(query)))
+        return cast(list[ResultRow], list(self.graph(named_graph).query(query)))
 
-    def triples_of_type_instances(self, rdf_type: str | URIRef) -> list[tuple[str, str, str]]:
+    def triples_of_type_instances(
+        self, rdf_type: str | URIRef, named_graph: URIRef | None = None
+    ) -> list[tuple[str, str, str]]:
         """Get all triples of a given type.
 
-        This method assumes the graph has been transformed into the default namespace.
+        Args:
+            rdf_type: Type URI to query
+            named_graph: Named graph to query over, default None (default graph)
         """
+        named_graph = named_graph or self.default_named_graph
         if isinstance(rdf_type, URIRef):
             rdf_uri = rdf_type
-        elif isinstance(rdf_type, str) and self.rules:
-            rdf_uri = self.rules.metadata.namespace[rdf_type]
+        elif isinstance(rdf_type, str) and self.rules and self.rules.get(named_graph):
+            rdf_uri = self.rules[named_graph].metadata.namespace[rdf_type]
         else:
             warnings.warn(
                 "Unknown namespace. Please either provide a URIRef or set the rules of the store.",
@@ -117,46 +153,54 @@ class Queries:
             "order by ?instance"
         )
 
-        result = self.graph.query(query)
+        result = self.graph(named_graph).query(query)
 
         # We cannot include the RDF.type in case there is a neat:type property
         return [remove_namespace_from_uri(list(triple)) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index, arg-type]
 
-    def type_with_property(self, type_: URIRef, property_uri: URIRef) -> bool:
+    def type_with_property(self, type_: URIRef, property_uri: URIRef, named_graph: URIRef | None = None) -> bool:
         """Check if a property exists in the graph store
 
         Args:
+            type_: Type URI to check
             property_uri: Property URI to check
+            named_graph: Named graph to query over, default None (default graph)
 
         Returns:
             True if property exists, False otherwise
         """
         query = f"SELECT ?o WHERE {{ ?s a <{type_}> ; <{property_uri}> ?o .}} Limit 1"
-        return bool(list(self.graph.query(query)))
+        return bool(list(self.graph(named_graph).query(query)))
 
-    def has_namespace(self, namespace: Namespace) -> bool:
+    def has_namespace(self, namespace: Namespace, named_graph: URIRef | None = None) -> bool:
         """Check if a namespace exists in the graph store
 
         Args:
             namespace: Namespace to check
+            named_graph: Named graph to query over, default None (default graph)
 
         Returns:
             True if namespace exists, False otherwise
         """
         query = f"ASK WHERE {{ ?s ?p ?o . FILTER(STRSTARTS(STR(?p), STR(<{namespace}>))) }}"
-        return bool(self.graph.query(query))
+        return bool(self.graph(named_graph).query(query))
 
-    def has_type(self, type_: URIRef) -> bool:
+    def has_data(self) -> bool:
+        """Check if the graph store has data"""
+        return cast(bool, next(iter(self.dataset.query("ASK WHERE { ?s ?p ?o }"))))
+
+    def has_type(self, type_: URIRef, named_graph: URIRef | None = None) -> bool:
         """Check if a type exists in the graph store
 
         Args:
             type_: Type to check
+            named_graph: Named graph to query over, default None (default graph)
 
         Returns:
             True if type exists, False otherwise
         """
         query = f"ASK WHERE {{ ?s a <{type_}> }}"
-        return bool(self.graph.query(query))
+        return bool(self.graph(named_graph).query(query))
 
     def describe(
         self,
@@ -164,6 +208,7 @@ class Queries:
         instance_type: str | None = None,
         property_renaming_config: dict | None = None,
         property_types: dict[str, EntityTypes] | None = None,
+        named_graph: URIRef | None = None,
     ) -> tuple[str, dict[str | InstanceType, list[str]]] | None:
         """DESCRIBE instance for a given class from the graph store
 
@@ -172,6 +217,7 @@ class Queries:
             instance_type: Type of the instance, default None (will be inferred from triples)
             property_renaming_config: Dictionary to rename properties, default None (no renaming)
             property_types: Dictionary of property types, default None (helper for removal of namespace)
+            named_graph: Named graph to query over, default None (default graph)
 
 
         Returns:
@@ -179,7 +225,7 @@ class Queries:
         """
         property_values: dict[str, list[str]] = defaultdict(list)
         identifier = remove_namespace_from_uri(instance_id, validation="prefix")
-        for _, predicate, object_ in cast(list[ResultRow], self.graph.query(f"DESCRIBE <{instance_id}>")):
+        for _, predicate, object_ in cast(list[ResultRow], self.graph(named_graph).query(f"DESCRIBE <{instance_id}>")):
             if object_.lower() in [
                 "",
                 "none",
@@ -190,45 +236,28 @@ class Queries:
 
             # set property
             if property_renaming_config and predicate != RDF.type:
-                property_ = property_renaming_config.get(
-                    predicate, remove_namespace_from_uri(predicate, validation="prefix")
-                )
+                property_ = remove_namespace_from_uri(predicate, validation="prefix")
+                renamed_property_ = property_renaming_config.get(predicate, property_)
+
             elif not property_renaming_config and predicate != RDF.type:
                 property_ = remove_namespace_from_uri(predicate, validation="prefix")
+                renamed_property_ = property_
+
             else:
                 property_ = RDF.type
+                renamed_property_ = property_
 
-            # set value
-            # if it is URIRef and property type is object property, we need to remove namespace
-            # if it URIref but we are doing this into data type property, we do not remove namespace
-            # case 1 for RDF type we remove namespace
-            if property_ == RDF.type:
+            if isinstance(object_, URIRef):
                 value = remove_namespace_from_uri(object_, validation="prefix")
-
-            # case 2 for define object properties we remove namespace
-            elif (
-                isinstance(object_, URIRef)
-                and property_types
-                and (
-                    property_types.get(property_, None) == EntityTypes.object_property
-                    or property_types.get(property_, None) == EntityTypes.undefined
-                )
-            ):
-                value = remove_namespace_from_uri(object_, validation="prefix")
-
-            # case 3 when property type is not defined and returned value is URIRef we remove namespace
-            elif isinstance(object_, URIRef) and not property_types:
-                value = remove_namespace_from_uri(object_, validation="prefix")
-
-            # case 4 for data type properties we do not remove namespace but keep the entire value
-            # but we drop the datatype part, and keep everything to be string (data loader will do the conversion)
-            # for value type it expects (if possible)
+            elif isinstance(object_, RdfLiteral):
+                value = object_.toPython()
             else:
+                # It is a blank node
                 value = str(object_)
 
             # add type to the dictionary
             if predicate != RDF.type:
-                property_values[property_].append(value)
+                property_values[renamed_property_].append(value)
             else:
                 # guarding against multiple rdf:type values as this is not allowed in CDF
                 if RDF.type not in property_values:
@@ -249,6 +278,7 @@ class Queries:
         class_: str,
         properties_optional: bool = True,
         instance_id: URIRef | None = None,
+        named_graph: URIRef | None = None,
     ) -> list[tuple[str, str, str]]:
         """CONSTRUCT instances for a given class from the graph store
 
@@ -256,21 +286,29 @@ class Queries:
             class_: Class entity for which we want to generate query
             properties_optional: Whether to make all properties optional, default True
             instance_ids: List of instance ids to filter on, default None (all)
+            named_graph: Named graph to query over, default None (default graph
 
         Returns:
             List of triples for instances of the given class
         """
-
-        if self.rules and (
-            query := build_construct_query(
-                class_=ClassEntity(prefix=self.rules.metadata.prefix, suffix=class_),
-                graph=self.graph,
-                rules=self.rules,
-                properties_optional=properties_optional,
-                instance_id=instance_id,
+        named_graph = named_graph or self.default_named_graph
+        if (
+            self.rules
+            and self.rules.get(named_graph)
+            and (
+                query := build_construct_query(
+                    class_=ClassEntity(
+                        prefix=self.rules[named_graph].metadata.prefix,
+                        suffix=class_,
+                    ),
+                    graph=self.graph(named_graph),
+                    rules=self.rules[named_graph],
+                    properties_optional=properties_optional,
+                    instance_id=instance_id,
+                )
             )
         ):
-            result = self.graph.query(query)
+            result = self.graph(named_graph).query(query)
 
             # We cannot include the RDF.type in case there is a neat:type property
             return [remove_namespace_from_uri(cast(ResultRow, triple)) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index, arg-type]
@@ -281,25 +319,36 @@ class Queries:
             )
             return []
 
-    def list_triples(self, limit: int = 25) -> list[ResultRow]:
+    def list_triples(self, limit: int = 25, named_graph: URIRef | None = None) -> list[ResultRow]:
         """List triples in the graph store
 
         Args:
             limit: Max number of triples to return, by default 25
+            named_graph: Named graph to query over, default None (default graph)
 
         Returns:
             List of triples
         """
         query = f"SELECT ?subject ?predicate ?object WHERE {{ ?subject ?predicate ?object }} LIMIT {limit}"
-        return cast(list[ResultRow], list(self.graph.query(query)))
+        return cast(list[ResultRow], list(self.graph(named_graph).query(query)))
 
     @overload
     def list_types(self, remove_namespace: Literal[False] = False, limit: int = 25) -> list[ResultRow]: ...
 
     @overload
-    def list_types(self, remove_namespace: Literal[True], limit: int = 25) -> list[str]: ...
+    def list_types(
+        self,
+        remove_namespace: Literal[True],
+        limit: int = 25,
+        named_graph: URIRef | None = None,
+    ) -> list[str]: ...
 
-    def list_types(self, remove_namespace: bool = False, limit: int = 25) -> list[ResultRow] | list[str]:
+    def list_types(
+        self,
+        remove_namespace: bool = False,
+        limit: int = 25,
+        named_graph: URIRef | None = None,
+    ) -> list[ResultRow] | list[str]:
         """List types in the graph store
 
         Args:
@@ -310,13 +359,14 @@ class Queries:
             List of types
         """
         query = f"SELECT DISTINCT ?type WHERE {{ ?subject a ?type }} LIMIT {limit}"
-        result = cast(list[ResultRow], list(self.graph.query(query)))
+        result = cast(list[ResultRow], list(self.graph(named_graph).query(query)))
         if remove_namespace:
             return [remove_namespace_from_uri(res[0]) for res in result]
         return result
 
     def multi_value_type_property(
         self,
+        named_graph: URIRef | None = None,
     ) -> Iterable[tuple[URIRef, URIRef, list[URIRef]]]:
         query = """SELECT ?sourceType ?property
                           (GROUP_CONCAT(DISTINCT STR(?valueType); SEPARATOR=",") AS ?valueTypes)
@@ -341,15 +391,20 @@ class Queries:
             value_types,
         ) in cast(
             ResultRow,
-            self.graph.query(query.format(unknownType=str(UNKNOWN_TYPE))),
+            self.graph(named_graph).query(query.format(unknownType=str(NEAT.UnknownType))),
         ):
             yield cast(URIRef, source_type), cast(URIRef, property_), [URIRef(uri) for uri in value_types.split(",")]
 
-    def drop_types(self, type_: list[URIRef]) -> dict[URIRef, int]:
+    def drop_types(
+        self,
+        type_: list[URIRef],
+        named_graph: URIRef | None = None,
+    ) -> dict[URIRef, int]:
         """Drop types from the graph store
 
         Args:
             type_: List of types to drop
+            named_graph: Named graph to query over, default None (default graph
 
         Returns:
             Dictionary of dropped types
@@ -358,11 +413,16 @@ class Queries:
         for t in type_:
             instance_ids = self.list_instances_ids_of_class(t)
             dropped_types[t] = len(instance_ids)
-            remove_instance_ids_in_batch(self.graph, instance_ids)
+            remove_instance_ids_in_batch(self.graph(named_graph), instance_ids)
         return dropped_types
 
-    def multi_type_instances(self) -> dict[str, list[str]]:
-        """Find instances with multiple types"""
+    def multi_type_instances(self, named_graph: URIRef | None = None) -> dict[str, list[str]]:
+        """Find instances with multiple types
+
+        Args:
+            named_graph: Named graph to query over, default None (default graph)
+
+        """
 
         query = """
         SELECT ?instance (GROUP_CONCAT(str(?type); SEPARATOR=",") AS ?types)
@@ -374,7 +434,7 @@ class Queries:
         """
 
         result = {}
-        for instance, types in self.graph.query(query):  # type: ignore
+        for instance, types in self.graph(named_graph).query(query):  # type: ignore
             result[remove_namespace_from_uri(instance)] = remove_namespace_from_uri(types.split(","))
 
         return result

cognite/neat/_graph/queries/_construct.py

@@ -115,7 +115,7 @@ def to_construct_triples(
         graph_template_triple = Triple(
             subject="?instance",
             predicate=f"{transformation.class_.prefix}:{transformation.property_}",
-            object=f'?{re.sub(r"[^_a-zA-Z0-9/_]", "_", str(transformation.property_).lower())}',
+            object=f"?{re.sub(r'[^_a-zA-Z0-9/_]', '_', str(transformation.property_).lower())}",
             optional=False,
         )
         templates.append(graph_template_triple)

cognite/neat/_graph/transformers/__init__.py

@@ -17,7 +17,7 @@ from ._prune_graph import (
     PruneTypes,
 )
 from ._rdfpath import AddSelfReferenceProperty, MakeConnectionOnExactMatch
-from ._value_type import ConnectionToLiteral, ConvertLiteral, LiteralToEntity, SplitMultiValueProperty
+from ._value_type import ConnectionToLiteral, ConvertLiteral, LiteralToEntity, SetType, SplitMultiValueProperty
 
 __all__ = [
     "AddAssetDepth",
@@ -38,6 +38,7 @@ __all__ = [
     "PruneInstancesOfUnknownType",
     "PruneTypes",
     "RelationshipAsEdgeTransformer",
+    "SetType",
     "SplitMultiValueProperty",
 ]
 
@@ -62,4 +63,5 @@ Transformers = (
     | ConnectionToLiteral
     | BaseTransformerStandardised
     | LookupRelationshipSourceTarget
+    | SetType
 )

cognite/neat/_graph/transformers/_base.py

@@ -12,14 +12,14 @@ from cognite.neat._shared import Triple
 from cognite.neat._utils.collection_ import iterate_progress_bar_if_above_config_threshold
 from cognite.neat._utils.graph_transformations_report import GraphTransformationResult
 
-To_Add_Triples: TypeAlias = list[Triple]
-To_Remove_Triples: TypeAlias = list[Triple]
+To_Add_Triples: TypeAlias = set[Triple]
+To_Remove_Triples: TypeAlias = set[Triple]
 
 
 @dataclasses.dataclass
 class RowTransformationOutput:
-    remove_triples: To_Remove_Triples = dataclasses.field(default_factory=list)
-    add_triples: To_Add_Triples = dataclasses.field(default_factory=list)
+    remove_triples: To_Remove_Triples = dataclasses.field(default_factory=set)
+    add_triples: To_Add_Triples = dataclasses.field(default_factory=set)
     instances_removed_count: int = 0
     instances_added_count: int = 0
     instances_modified_count: int = 0

cognite/neat/_graph/transformers/_classic_cdf.py

@@ -63,11 +63,11 @@ class AddAssetDepth(BaseTransformerStandardised):
         row_output = RowTransformationOutput()
         subject, object = query_result_row
 
-        row_output.add_triples.append(cast(Triple, (subject, DEFAULT_NAMESPACE.depth, object)))
+        row_output.add_triples.add(cast(Triple, (subject, DEFAULT_NAMESPACE.depth, object)))
 
         if self.depth_typing and (type_ := self.depth_typing.get(int(object), None)):
-            row_output.remove_triples.append(cast(Triple, (subject, RDF.type, self.asset_type)))
-            row_output.add_triples.append(cast(Triple, (subject, RDF.type, DEFAULT_NAMESPACE[type_])))
+            row_output.remove_triples.add(cast(Triple, (subject, RDF.type, self.asset_type)))
+            row_output.add_triples.add(cast(Triple, (subject, RDF.type, DEFAULT_NAMESPACE[type_])))
 
         row_output.instances_modified_count += 1
 
@@ -128,7 +128,7 @@ class BaseAssetConnector(BaseTransformerStandardised, ABC):
         row_output = RowTransformationOutput()
         subject, object = query_result_row
 
-        row_output.add_triples.append(cast(Triple, (subject, self.asset_to_resource_connection, object)))
+        row_output.add_triples.add(cast(Triple, (subject, self.asset_to_resource_connection, object)))
 
         row_output.instances_modified_count += 1
 
@@ -305,12 +305,12 @@ class AssetRelationshipConnector(BaseTransformerStandardised):
         row_output = RowTransformationOutput()
         source, relationship, target = query_result_row
 
-        row_output.add_triples.append(cast(Triple, (source, DEFAULT_NAMESPACE.relationship, target)))
-        row_output.add_triples.append(cast(Triple, (relationship, DEFAULT_NAMESPACE.source, source)))
-        row_output.add_triples.append(cast(Triple, (relationship, DEFAULT_NAMESPACE.target, target)))
+        row_output.add_triples.add(cast(Triple, (source, DEFAULT_NAMESPACE.relationship, target)))
+        row_output.add_triples.add(cast(Triple, (relationship, DEFAULT_NAMESPACE.source, source)))
+        row_output.add_triples.add(cast(Triple, (relationship, DEFAULT_NAMESPACE.target, target)))
 
-        row_output.remove_triples.append(cast(Triple, (relationship, self.relationship_source_xid_prop, None)))
-        row_output.remove_triples.append(cast(Triple, (relationship, self.relationship_target_xid_prop, None)))
+        row_output.remove_triples.add(cast(Triple, (relationship, self.relationship_source_xid_prop, None)))
+        row_output.remove_triples.add(cast(Triple, (relationship, self.relationship_target_xid_prop, None)))
 
         row_output.instances_modified_count += 2
 
@@ -578,10 +578,10 @@ WHERE {{
             warnings.warn(ResourceNotFoundWarning(target, "class", str(instance), "class"), stacklevel=2)
             return output
 
-        output.remove_triples.append((instance, self._namespace.sourceExternalId, source))
-        output.remove_triples.append((instance, self._namespace.targetExternalId, target))
-        output.add_triples.append((instance, self._namespace.sourceExternalId, source_id))
-        output.add_triples.append((instance, self._namespace.targetExternalId, target_id))
+        output.remove_triples.add((instance, self._namespace.sourceExternalId, source))
+        output.remove_triples.add((instance, self._namespace.targetExternalId, target))
+        output.add_triples.add((instance, self._namespace.sourceExternalId, source_id))
+        output.add_triples.add((instance, self._namespace.targetExternalId, target_id))
         output.instances_modified_count += 1
         return output
 

cognite/neat/_graph/transformers/_prune_graph.py

@@ -237,7 +237,7 @@ class PruneTypes(BaseTransformerStandardised):
         row_output = RowTransformationOutput()
 
         (subject,) = query_result_row
-        row_output.remove_triples.append((subject, None, None))  # type: ignore
+        row_output.remove_triples.add((subject, None, None))  # type: ignore
         row_output.instances_removed_count = 1
 
         return row_output
@@ -272,7 +272,7 @@ class PruneDeadEndEdges(BaseTransformerStandardised):
 
     def operation(self, row: ResultRow) -> RowTransformationOutput:
         row_output = RowTransformationOutput()
-        row_output.remove_triples.append(cast(Triple, row))
+        row_output.remove_triples.add(cast(Triple, row))
         row_output.instances_modified_count = 1
 
         return row_output
@@ -307,7 +307,7 @@ class PruneInstancesOfUnknownType(BaseTransformerStandardised):
     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.remove_triples.add(cast(Triple, (subject, None, None)))
         row_output.instances_removed_count = 1
 
         return row_output

cognite/neat/_graph/transformers/_rdfpath.py

@@ -7,7 +7,6 @@ from rdflib.query import ResultRow
 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 get_namespace, remove_namespace_from_uri
 
 from ._base import BaseTransformer, BaseTransformerStandardised, RowTransformationOutput
@@ -76,7 +75,7 @@ class MakeConnectionOnExactMatch(BaseTransformerStandardised):
         self.object_type = object_type
         self.object_predicate = object_predicate
         subject_namespace = Namespace(get_namespace(subject_type))
-        self.connection = (
+        self.connection: URIRef = (
             subject_namespace[quote(connection.strip())]
             if isinstance(connection, str)
             else connection or subject_namespace[remove_namespace_from_uri(self.object_type).lower()]
@@ -125,8 +124,8 @@ class MakeConnectionOnExactMatch(BaseTransformerStandardised):
     def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
         row_output = RowTransformationOutput()
 
-        subject, object = query_result_row
+        subject, object = cast(tuple[URIRef, URIRef], query_result_row)
 
-        row_output.add_triples.append(cast(Triple, (subject, self.connection, object)))
+        row_output.add_triples.add((subject, self.connection, object))
         row_output.instances_modified_count += 1
         return row_output