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

cognite/neat/_graph/extractors/_rdf_file.py

@@ -1,6 +1,7 @@
+import zipfile
 from collections.abc import Iterable
 from pathlib import Path
-from typing import get_args
+from typing import cast, get_args
 
 from rdflib import URIRef
 from rdflib.util import guess_format
@@ -10,6 +11,7 @@ from cognite.neat._graph._shared import RDFTypes
 from cognite.neat._graph.extractors._base import BaseExtractor
 from cognite.neat._issues._base import IssueList
 from cognite.neat._issues.errors import FileNotFoundNeatError, FileTypeUnexpectedError
+from cognite.neat._issues.errors._general import NeatValueError
 from cognite.neat._shared import Triple
 
 
@@ -24,25 +26,50 @@ class RdfFileExtractor(BaseExtractor):
 
     def __init__(
         self,
-        filepath: Path,
+        filepath: Path | zipfile.ZipExtFile,
         base_uri: URIRef = DEFAULT_BASE_URI,
         issue_list: IssueList | None = None,
     ):
         self.issue_list = issue_list or IssueList(title=f"{filepath.name}")
         self.base_uri = base_uri
         self.filepath = filepath
-        self.format = guess_format(str(self.filepath))
 
-        if not self.filepath.exists():
+        self.format = guess_format(str(self.filepath) if isinstance(self.filepath, Path) else self.filepath.name)
+
+        print(self.format)
+        if isinstance(self.filepath, Path) and not self.filepath.exists():
             self.issue_list.append(FileNotFoundNeatError(self.filepath))
 
         if not self.format:
             self.issue_list.append(
                 FileTypeUnexpectedError(
-                    self.filepath,
+                    (self.filepath if isinstance(self.filepath, Path) else Path(self.filepath.name)),
                     frozenset(get_args(RDFTypes)),
                 )
             )
 
     def extract(self) -> Iterable[Triple]:
         raise NotImplementedError()
+
+    @classmethod
+    def from_zip(
+        cls,
+        filepath: Path,
+        filename: str = "neat-session/instances/instances.ttl",
+        base_uri: URIRef = DEFAULT_BASE_URI,
+        issue_list: IssueList | None = None,
+    ):
+        if not filepath.exists():
+            raise FileNotFoundNeatError(filepath)
+        if filepath.suffix not in {".zip"}:
+            raise NeatValueError("Expected a zip file, got {filepath.suffix}")
+
+        with zipfile.ZipFile(filepath, "r") as zip_ref:
+            for file_info in zip_ref.infolist():
+                if file_info.filename == filename:
+                    # We need to open the file in the zip file, and close it upon
+                    # triple extraction ...
+                    file = zip_ref.open(file_info)
+                    return cls(cast(zipfile.ZipExtFile, file), base_uri, issue_list)
+
+        raise NeatValueError(f"Cannot extract {filename} from zip file {filepath}")

cognite/neat/_graph/loaders/_rdf2dms.py

@@ -32,7 +32,7 @@ from cognite.neat._issues.errors import (
 from cognite.neat._issues.warnings import PropertyDirectRelationLimitWarning, PropertyTypeNotSupportedWarning
 from cognite.neat._rules.analysis._dms import DMSAnalysis
 from cognite.neat._rules.models import DMSRules
-from cognite.neat._rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json
+from cognite.neat._rules.models.data_types import _DATA_TYPE_BY_DMS_TYPE, Json, String
 from cognite.neat._rules.models.entities._single_value import ViewEntity
 from cognite.neat._shared import InstanceType
 from cognite.neat._store import NeatGraphStore
@@ -159,7 +159,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
         tracker = self._tracker(type(self).__name__, view_ids, "views")
         for view_id, (view, instance_count) in view_and_count_by_id.items():
-            pydantic_cls, edge_by_type, issues = self._create_validation_classes(view)  # type: ignore[var-annotated]
+            pydantic_cls, edge_by_type, edge_by_prop_id, issues = self._create_validation_classes(view)  # type: ignore[var-annotated]
             yield from issues
             tracker.issue(issues)
 
@@ -200,20 +200,61 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
                 )
 
                 for identifier, properties in instance_iterable:
+                    start_node, end_node = self._pop_start_end_node(properties)
+                    is_edge = start_node and end_node
+                    if (is_edge and view.used_for == "node") or (not is_edge and view.used_for == "edge"):
+                        instance_type = "edge" if is_edge else "node"
+                        creation_error = ResourceCreationError(
+                            identifier,
+                            instance_type,
+                            error=f"{instance_type.capitalize()} found in {view.used_for} view",
+                        )
+                        tracker.issue(creation_error)
+                        if stop_on_exception:
+                            raise creation_error
+                        yield creation_error
+                        continue
+
                     if skip_properties:
                         properties = {k: v for k, v in properties.items() if k not in skip_properties}
-                    try:
-                        yield self._create_node(identifier, properties, pydantic_cls, view_id)
-                    except ValueError as e:
-                        error_node = ResourceCreationError(identifier, "node", error=str(e))
-                        tracker.issue(error_node)
-                        if stop_on_exception:
-                            raise error_node from e
-                        yield error_node
-                    yield from self._create_edges(identifier, properties, edge_by_type, tracker)
+
+                    if start_node and end_node:
+                        # Is an edge
+                        try:
+                            yield self._create_edge_with_properties(
+                                identifier, properties, start_node, end_node, pydantic_cls, view_id
+                            )
+                        except ValueError as e:
+                            error_edge = ResourceCreationError(identifier, "edge", error=str(e))
+                            tracker.issue(error_edge)
+                            if stop_on_exception:
+                                raise error_edge from e
+                            yield error_edge
+                    else:
+                        try:
+                            yield self._create_node(identifier, properties, pydantic_cls, view_id)
+                        except ValueError as e:
+                            error_node = ResourceCreationError(identifier, "node", error=str(e))
+                            tracker.issue(error_node)
+                            if stop_on_exception:
+                                raise error_node from e
+                            yield error_node
+                        yield from self._create_edges_without_properties(
+                            identifier, properties, edge_by_type, edge_by_prop_id, tracker
+                        )
                 tracker.finish(track_id)
                 yield _END_OF_CLASS
 
+    @staticmethod
+    def _pop_start_end_node(properties: dict[str | InstanceType, list[str]]) -> tuple[str | None, str | None]:
+        start_node = properties.pop("startNode", [None])[0]
+        if not start_node:
+            start_node = properties.pop("start_node", [None])[0]
+        end_node = properties.pop("endNode", [None])[0]
+        if not end_node:
+            end_node = properties.pop("end_node", [None])[0]
+        return start_node, end_node
+
     def write_to_file(self, filepath: Path) -> None:
         if filepath.suffix not in [".json", ".yaml", ".yml"]:
             raise ValueError(f"File format {filepath.suffix} is not supported")
@@ -298,17 +339,30 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
     def _create_validation_classes(
         self, view: dm.View
-    ) -> tuple[type[BaseModel], dict[str, tuple[str, dm.EdgeConnection]], NeatIssueList]:
+    ) -> tuple[
+        type[BaseModel],
+        dict[str, tuple[str, dm.EdgeConnection]],
+        dict[str, tuple[str, dm.EdgeConnection]],
+        NeatIssueList,
+    ]:
         issues = IssueList()
         field_definitions: dict[str, tuple[type, Any]] = {}
-        edge_by_property: dict[str, tuple[str, dm.EdgeConnection]] = {}
+        edge_by_type: dict[str, tuple[str, dm.EdgeConnection]] = {}
+        edge_by_prop_id: dict[str, tuple[str, dm.EdgeConnection]] = {}
         validators: dict[str, classmethod] = {}
         direct_relation_by_property: dict[str, dm.DirectRelation] = {}
         unit_properties: list[str] = []
         json_fields: list[str] = []
+        text_fields: list[str] = []
         for prop_id, prop in view.properties.items():
             if isinstance(prop, dm.EdgeConnection):
-                edge_by_property[prop_id] = prop_id, prop
+                if prop.edge_source:
+                    # Edges with properties are created separately
+                    continue
+
+                edge_by_type[prop.type.external_id] = prop_id, prop
+                edge_by_prop_id[prop_id] = prop_id, prop
+
             if isinstance(prop, dm.MappedProperty):
                 if is_readonly_property(prop.container, prop.container_property_identifier):
                     continue
@@ -334,6 +388,8 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
                     if data_type == Json:
                         json_fields.append(prop_id)
+                    elif data_type == String:
+                        text_fields.append(prop_id)
                     python_type = data_type.python
                 if isinstance(prop.type, ListablePropertyType) and prop.type.is_list:
                     python_type = list[python_type]
@@ -369,11 +425,20 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             else:
                 raise ValueError(f"Expect valid JSON string or dict for {info.field_name}: {value}")
 
+        def parse_text(cls, value: Any, info: ValidationInfo) -> Any:
+            if isinstance(value, list):
+                return [remove_namespace_from_uri(v) for v in value]
+            else:
+                return remove_namespace_from_uri(value)
+
         if json_fields:
             validators["parse_json_string"] = field_validator(*json_fields, mode="before")(parse_json_string)  # type: ignore[assignment, arg-type]
 
         validators["parse_list"] = field_validator("*", mode="before")(parse_list)  # type: ignore[assignment, arg-type]
 
+        if text_fields:
+            validators["parse_text"] = field_validator(*text_fields, mode="before")(parse_text)  # type: ignore[assignment, arg-type]
+
         if direct_relation_by_property:
 
             def parse_direct_relation(cls, value: list, info: ValidationInfo) -> dict | list[dict]:
@@ -414,7 +479,7 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             )
 
         pydantic_cls = create_model(view.external_id, __validators__=validators, **field_definitions)  # type: ignore[arg-type, call-overload]
-        return pydantic_cls, edge_by_property, issues
+        return pydantic_cls, edge_by_type, edge_by_prop_id, issues
 
     def _create_node(
         self,
@@ -435,17 +500,46 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             ],
         )
 
-    def _create_edges(
+    def _create_edge_with_properties(
+        self,
+        identifier: str,
+        properties: dict[str | InstanceType, list[str]],
+        start_node: str,
+        end_node: str,
+        pydantic_cls: type[BaseModel],
+        view_id: dm.ViewId,
+    ) -> dm.EdgeApply:
+        type_ = properties.pop(RDF.type, [None])[0]
+        created = pydantic_cls.model_validate(properties)
+        if type_ is None:
+            raise ValueError(f"Missing type for edge {identifier}")
+
+        return dm.EdgeApply(
+            space=self.instance_space,
+            external_id=identifier,
+            type=dm.DirectRelationReference(view_id.space, view_id.external_id),
+            start_node=dm.DirectRelationReference(self.instance_space, start_node),
+            end_node=dm.DirectRelationReference(self.instance_space, end_node),
+            sources=[
+                dm.NodeOrEdgeData(source=view_id, properties=dict(created.model_dump(exclude_unset=True).items()))
+            ],
+        )
+
+    def _create_edges_without_properties(
         self,
         identifier: str,
         properties: dict[str, list[str]],
         edge_by_type: dict[str, tuple[str, dm.EdgeConnection]],
+        edge_by_prop_id: dict[str, tuple[str, dm.EdgeConnection]],
         tracker: Tracker,
     ) -> Iterable[dm.EdgeApply | NeatIssue]:
         for predicate, values in properties.items():
-            if predicate not in edge_by_type:
+            if predicate in edge_by_type:
+                prop_id, edge = edge_by_type[predicate]
+            elif predicate in edge_by_prop_id:
+                prop_id, edge = edge_by_prop_id[predicate]
+            else:
                 continue
-            prop_id, edge = edge_by_type[predicate]
             if isinstance(edge, SingleEdgeConnection) and len(values) > 1:
                 error = ResourceDuplicatedError(
                     resource_type="edge",

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:

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 (
@@ -29,6 +31,7 @@ __all__ = [
     "ConnectionToLiteral",
     "ConvertLiteral",
     "LiteralToEntity",
+    "LookupRelationshipSourceTarget",
     "MakeConnectionOnExactMatch",
     "PruneDanglingNodes",
     "PruneDeadEndEdges",
@@ -57,4 +60,6 @@ Transformers = (
     | ConvertLiteral
     | LiteralToEntity
     | ConnectionToLiteral
+    | BaseTransformerStandardised
+    | LookupRelationshipSourceTarget
 )

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

cognite/neat/_graph/transformers/_rdfpath.py

@@ -35,8 +35,8 @@ class AddSelfReferenceProperty(BaseTransformer):
 
     def transform(self, graph: Graph) -> None:
         for property_ in self.properties:
-            prefix = property_.transformation.traversal.class_.prefix
-            suffix = property_.transformation.traversal.class_.suffix
+            prefix = property_.instance_source.traversal.class_.prefix
+            suffix = property_.instance_source.traversal.class_.suffix
 
             namespace = self.rules.prefixes[prefix] if prefix in self.rules.prefixes else self.rules.metadata.namespace
 
@@ -54,7 +54,7 @@ class AddSelfReferenceProperty(BaseTransformer):
                 property_=f"{self.rules.metadata.prefix}:{property_.property_}",
             )
 
-            property_.transformation = RDFPath(traversal=traversal)
+            property_.instance_source = RDFPath(traversal=traversal)
 
 
 class MakeConnectionOnExactMatch(BaseTransformerStandardised):

cognite/neat/_graph/transformers/_value_type.py

@@ -1,23 +1,21 @@
 import warnings
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
 from typing import Any, cast
 from urllib.parse import quote
 
 import rdflib
-from rdflib import RDF, XSD, Graph, Namespace, URIRef
+from rdflib import RDF, Namespace, URIRef
 from rdflib.query import ResultRow
 
 from cognite.neat._constants import UNKNOWN_TYPE
-from cognite.neat._graph.queries import Queries
 from cognite.neat._issues.warnings import PropertyDataTypeConversionWarning
 from cognite.neat._utils.auxiliary import string_to_ideal_type
-from cognite.neat._utils.rdf_ import get_namespace, remove_namespace_from_uri
+from cognite.neat._utils.rdf_ import Triple, get_namespace, remove_namespace_from_uri
 
-from ._base import BaseTransformer, BaseTransformerStandardised, RowTransformationOutput
+from ._base import BaseTransformerStandardised, RowTransformationOutput
 
 
-# TODO: Standardise
-class SplitMultiValueProperty(BaseTransformer):
+class SplitMultiValueProperty(BaseTransformerStandardised):
     description: str = (
         "SplitMultiValueProperty is a transformer that splits a "
         "multi-value property into multiple single-value properties."
@@ -25,55 +23,67 @@ class SplitMultiValueProperty(BaseTransformer):
     _use_only_once: bool = True
     _need_changes = frozenset({})
 
-    _object_property_template: str = """SELECT ?s ?o WHERE{{
+    def __init__(self, unknown_type: URIRef | None = None) -> None:
+        self.unknown_type = unknown_type or UNKNOWN_TYPE
 
-                                ?s a <{subject_uri}> .
-                                ?s <{property_uri}> ?o .
-                                ?o a <{object_uri}> .
+    def _iterate_query(self) -> str:
+        query = """SELECT ?subjectType ?property
+                          (GROUP_CONCAT(DISTINCT STR(?valueType); SEPARATOR=",") AS ?valueTypes)
+
+                   WHERE {{
+                       ?s ?property ?o .
+                       ?s a ?subjectType .
+                       OPTIONAL {{ ?o a ?type }}
+
+                       # Key part to determine value type: either object, data or unknown
+                       BIND(   IF(isLiteral(?o),DATATYPE(?o),
+                               IF(BOUND(?type), ?type,
+                                               <{unknownType}>)) AS ?valueType)
+                   }}
+
+                   GROUP BY ?subjectType ?property
+                   HAVING (COUNT(DISTINCT ?valueType) > 1)"""
+
+        return query.format(unknownType=self.unknown_type)
+
+    def _count_query(self) -> str:
+        query = """SELECT (COUNT(*) AS ?tripleCount)
+                   WHERE {?s ?p ?o .}"""
+        return query
+
+    def _sub_iterate_query(self, type_: URIRef, property_: URIRef) -> str:
+        query = """ SELECT ?s ?p ?o ?valueType WHERE {{
+                           ?s a <{subject_uri}> .
+                           ?s <{property_uri}> ?o .
 
-                            }}"""
+                           OPTIONAL {{ ?o a ?type }}
 
-    _datatype_property_template: str = """SELECT ?s ?o WHERE {{
+                           BIND(<{property_uri}> AS ?p)
 
-                                ?s a <{subject_uri}> .
-                                ?s <{property_uri}> ?o .
-                                FILTER (datatype(?o) = <{object_uri}>)
+                           BIND(IF(isLiteral(?o),  DATATYPE(?o),
+                                   IF(BOUND(?type),?type,
+                                                   <{unknownType}>)) AS ?valueType)
 
-                                }}"""
+                                               }} """
 
-    _unknown_property_template: str = """SELECT ?s ?o WHERE {{
+        return query.format(unknownType=self.unknown_type, subject_uri=type_, property_uri=property_)
 
-                                ?s a <{subject_uri}> .
-                                ?s <{property_uri}> ?o .
-                                FILTER NOT EXISTS {{ ?o a ?objectType }}
-                                }}"""
+    def _iterator(self, graph) -> Iterator:
+        for type_, property_, _ in graph.query(self._iterate_query()):
+            yield from graph.query(self._sub_iterate_query(type_, property_))
 
-    def transform(self, graph: Graph) -> None:
-        # handle multi value type object properties
-        for subject_uri, property_uri, value_types in Queries(graph).multi_value_type_property():
-            for value_type_uri in value_types:
-                _args = {
-                    "subject_uri": subject_uri,
-                    "property_uri": property_uri,
-                    "object_uri": value_type_uri,
-                }
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+        subject, old_property, object, value_type = query_result_row
 
-                # Case 1: Unknown value type
-                if value_type_uri == UNKNOWN_TYPE:
-                    iterator = graph.query(self._unknown_property_template.format(**_args))
+        new_property = URIRef(f"{old_property}_{remove_namespace_from_uri(value_type)}")
 
-                # Case 2: Datatype value type
-                elif value_type_uri.startswith(str(XSD)):
-                    iterator = graph.query(self._datatype_property_template.format(**_args))
+        row_output.add_triples.append(cast(Triple, (subject, new_property, object)))
+        row_output.remove_triples.append(cast(Triple, (subject, old_property, object)))
 
-                # Case 3: Object value type
-                else:
-                    iterator = graph.query(self._object_property_template.format(**_args))
+        row_output.instances_modified_count += 1
 
-                for s, o in iterator:  # type: ignore [misc]
-                    graph.remove((s, property_uri, o))
-                    new_property = URIRef(f"{property_uri}_{remove_namespace_from_uri(value_type_uri)}")
-                    graph.add((s, new_property, o))
+        return row_output
 
 
 class ConvertLiteral(BaseTransformerStandardised):

cognite/neat/_rules/analysis/_base.py

@@ -251,7 +251,7 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
                 if (
                     only_rdfpath
                     and isinstance(property_, InformationProperty)
-                    and isinstance(property_.transformation, RDFPath)
+                    and isinstance(property_.instance_source, RDFPath)
                 ) or not only_rdfpath:
                     processed_properties[prop_entity] = property_
             class_property_pairs[class_] = processed_properties