cognite-neat 0.106.0__py3-none-any.whl → 0.108.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,50 @@ 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_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 +204,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 +213,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 +221,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 +232,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:
-                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
-                )
-            ):
+            if isinstance(object_, URIRef):
                 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 +274,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 +282,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 +315,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 +355,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 +387,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 +409,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 +430,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

@@ -106,7 +106,7 @@ def to_construct_triples(
     non_inherited_starting_rdf_types = []
 
     for transformation in transformations:
-        traversal = cast(RDFPath, transformation.transformation).traversal
+        traversal = cast(RDFPath, transformation.instance_source).traversal
 
         # keeping track of starting rdf types of non-inherited transformations/properties
         if isinstance(traversal, Traversal) and not transformation.inherited:
@@ -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

@@ -1,3 +1,4 @@
+from ._base import BaseTransformerStandardised
 from ._classic_cdf import (
     AddAssetDepth,
     AssetEventConnector,
@@ -5,6 +6,7 @@ from ._classic_cdf import (
     AssetRelationshipConnector,
     AssetSequenceConnector,
     AssetTimeSeriesConnector,
+    LookupRelationshipSourceTarget,
     RelationshipAsEdgeTransformer,
 )
 from ._prune_graph import (
@@ -15,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, SetNeatType, SplitMultiValueProperty
 
 __all__ = [
     "AddAssetDepth",
@@ -29,12 +31,14 @@ __all__ = [
     "ConnectionToLiteral",
     "ConvertLiteral",
     "LiteralToEntity",
+    "LookupRelationshipSourceTarget",
     "MakeConnectionOnExactMatch",
     "PruneDanglingNodes",
     "PruneDeadEndEdges",
     "PruneInstancesOfUnknownType",
     "PruneTypes",
     "RelationshipAsEdgeTransformer",
+    "SetNeatType",
     "SplitMultiValueProperty",
 ]
 
@@ -57,4 +61,7 @@ Transformers = (
     | ConvertLiteral
     | LiteralToEntity
     | ConnectionToLiteral
+    | BaseTransformerStandardised
+    | LookupRelationshipSourceTarget
+    | SetNeatType
 )

cognite/neat/_graph/transformers/_base.py

@@ -1,6 +1,7 @@
 import dataclasses
 import warnings
 from abc import ABC, abstractmethod
+from collections.abc import Iterator
 from typing import ClassVar, TypeAlias, cast
 
 from rdflib import Graph
@@ -65,9 +66,16 @@ class BaseTransformerStandardised(ABC):
         The query to use for extracting target triples from the graph and performing the transformation.
         Returns:
             A query string.
+
+        !!! note "Complex Queries"
+            In majority of cases the query should be a simple SELECT query. However, in case
+            when there is a need to have one or more sub iterators, one can overwrite the ._iterator() method
         """
         raise NotImplementedError()
 
+    def _iterator(self, graph: Graph) -> Iterator:
+        yield from graph.query(self._iterate_query())
+
     def _skip_count_query(self) -> str:
         """
         The query to use for extracting target triples from the graph and performing the transformation.
@@ -97,7 +105,7 @@ class BaseTransformerStandardised(ABC):
         if iteration_count == 0:
             return outcome
 
-        result_iterable = graph.query(self._iterate_query())
+        result_iterable = self._iterator(graph)
         result_iterable = iterate_progress_bar_if_above_config_threshold(
             result_iterable, iteration_count, self.description
         )

cognite/neat/_graph/transformers/_classic_cdf.py

@@ -1,6 +1,7 @@
+import urllib.parse
 import warnings
 from abc import ABC
-from collections.abc import Callable, Iterable
+from collections.abc import Callable, Iterable, Iterator
 from functools import lru_cache
 from typing import cast
 
@@ -9,6 +10,7 @@ from rdflib.query import ResultRow
 
 from cognite.neat._constants import CLASSIC_CDF_NAMESPACE, DEFAULT_NAMESPACE
 from cognite.neat._graph import extractors
+from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._issues.warnings import ResourceNotFoundWarning
 from cognite.neat._utils.collection_ import iterate_progress_bar
 from cognite.neat._utils.rdf_ import (
@@ -229,7 +231,6 @@ class AssetEventConnector(BaseAssetConnector):
         )
 
 
-# TODO: standardise
 class AssetRelationshipConnector(BaseTransformerStandardised):
     description: str = "Connects assets via relationships"
     _use_only_once: bool = True
@@ -465,7 +466,7 @@ WHERE {{
                 ResourceNotFoundWarning(target_source_id, "class", str(relationship_id), "class"), stacklevel=2
             )
             return []
-        edge_id = str(object_by_predicates["externalId"])
+        edge_id = urllib.parse.quote(str(object_by_predicates["externalId"]))
         # If there is properties on the relationship, we create a new intermediate node
         edge_type = self._namespace[f"{source_type}To{target_type}Edge"]
         return self._create_edge(
@@ -516,3 +517,89 @@ WHERE {{
 
     def _predicate(self, target_type: str) -> URIRef:
         return self._namespace[f"relationship{target_type.capitalize()}"]
+
+
+class LookupRelationshipSourceTarget(BaseTransformerStandardised):
+    """When relationships are extracted, the source and target are extracted as literals. This transformers
+    lookup the externalID of the source and target and replaces the literals with the URIRef of the entity.
+    """
+
+    description = "Lookup relationships source and target externalId"
+    _use_only_once: bool = True
+    _need_changes = frozenset({extractors.RelationshipsExtractor.__name__})
+
+    _lookup_entity_query = """SELECT ?entity
+    WHERE {{
+        ?entity a <{entity_type}> .
+        ?entity <{namespace}externalId> "{external_id}" .
+    }}"""
+
+    def __init__(self, namespace: Namespace = CLASSIC_CDF_NAMESPACE, type_prefix: str | None = None) -> None:
+        self._namespace = namespace
+        self._type_prefix = type_prefix
+        self._lookup_entity: Callable[[URIRef, str], URIRef] | None = None
+
+    def _count_query(self) -> str:
+        return f"""SELECT (COUNT(?instance) AS ?instanceCount)
+WHERE {{
+  ?instance a <{self._namespace}ClassicRelationship> .
+}}"""
+
+    def _iterate_query(self) -> str:
+        return f"""SELECT ?instance ?source ?sourceType ?target ?targetType
+        WHERE {{
+          ?instance a <{self._namespace}ClassicRelationship> .
+          ?instance <{self._namespace}sourceExternalId> ?source .
+          ?instance <{self._namespace}targetExternalId> ?target .
+          ?instance <{self._namespace}sourceType> ?sourceType .
+          ?instance <{self._namespace}targetType> ?targetType
+        }}"""
+
+    def _iterator(self, graph: Graph) -> Iterator:
+        self._lookup_entity = self.create_lookup_entity_with_external_id(graph, self._namespace, self._type_prefix)
+        yield from graph.query(self._iterate_query())
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        output = RowTransformationOutput()
+        instance, source, source_type, target, target_type = cast(
+            tuple[URIRef, Literal, URIRef, Literal, URIRef], query_result_row
+        )
+        if self._lookup_entity is None:
+            raise NeatValueError(f"{type(self)}: .operation() called before .transform()")
+        try:
+            source_id = self._lookup_entity(source_type, source.toPython())
+        except ValueError:
+            warnings.warn(ResourceNotFoundWarning(source, "class", str(instance), "class"), stacklevel=2)
+            return output
+
+        try:
+            target_id = self._lookup_entity(target_type, target.toPython())
+        except ValueError:
+            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.instances_modified_count += 1
+        return output
+
+    @staticmethod
+    def create_lookup_entity_with_external_id(
+        graph: Graph, namespace: Namespace, type_prefix: str | None
+    ) -> Callable[[URIRef, str], URIRef]:
+        @lru_cache(maxsize=10_000)
+        def lookup_entity_with_external_id(entity_type: URIRef, external_id: str) -> URIRef:
+            if type_prefix:
+                entity_type = namespace[type_prefix + remove_namespace_from_uri(entity_type)]
+
+            query = LookupRelationshipSourceTarget._lookup_entity_query.format(
+                namespace=namespace, entity_type=entity_type, external_id=external_id
+            )
+            result = list(graph.query(query))
+            if len(result) == 1:
+                return cast(URIRef, result[0][0])  # type: ignore[index]
+            raise ValueError(f"Could not find entity with external_id {external_id} and type {entity_type}")
+
+        return lookup_entity_with_external_id