cognite-neat 0.104.0__py3-none-any.whl → 0.105.1__py3-none-any.whl

cognite/neat/_graph/extractors/_classic_cdf/_sequences.py

@@ -1,37 +1,251 @@
-from collections.abc import Iterable
+import itertools
+import json
+from collections.abc import Callable, Iterable, Set
 from pathlib import Path
+from typing import Any
 
 from cognite.client import CogniteClient
-from cognite.client.data_classes import Sequence, SequenceFilter, SequenceList
+from cognite.client.data_classes import Sequence, SequenceFilter
+from rdflib import RDF, XSD, Literal, Namespace, URIRef
 
-from ._base import ClassicCDFBaseExtractor, InstanceIdPrefix
+from cognite.neat._client.data_classes.neat_sequence import NeatSequence, NeatSequenceList
+from cognite.neat._shared import Triple
 
+from ._base import DEFAULT_SKIP_METADATA_VALUES, ClassicCDFBaseExtractor, InstanceIdPrefix
 
-class SequencesExtractor(ClassicCDFBaseExtractor[Sequence]):
-    """Extract data from Cognite Data Fusions Sequences into Neat."""
+
+class SequencesExtractor(ClassicCDFBaseExtractor[NeatSequence]):
+    """Extract data from Cognite Data Fusions Sequences into Neat.
+
+    Args:
+        items (Iterable[T_CogniteResource]): An iterable of classic resource.
+        namespace (Namespace, optional): The namespace to use. Defaults to DEFAULT_NAMESPACE.
+        to_type (Callable[[T_CogniteResource], str | None], optional): A function to convert an item to a type.
+            Defaults to None. If None or if the function returns None, the asset will be set to the default type.
+        total (int, optional): The total number of items to load. If passed, you will get a progress bar if rich
+            is installed. Defaults to None.
+        limit (int, optional): The maximal number of items to load. Defaults to None. This is typically used for
+            testing setup of the extractor. For example, if you are extracting 100 000 assets, you might want to
+            limit the extraction to 1000 assets to test the setup.
+        unpack_metadata (bool, optional): Whether to unpack metadata. Defaults to False, which yields the metadata as
+            a JSON string.
+        skip_metadata_values (set[str] | frozenset[str] | None, optional): If you are unpacking metadata, then
+           values in this set will be skipped.
+        camel_case (bool, optional): Whether to use camelCase instead of snake_case for property names.
+            Defaults to True.
+        as_write (bool, optional): Whether to use the write/request format of the items. Defaults to False.
+        unpack_columns (bool, optional): Whether to unpack columns. Defaults to False.
+    """
 
     _default_rdf_type = "Sequence"
+    _column_rdf_type = "ColumnClass"
     _instance_id_prefix = InstanceIdPrefix.sequence
 
+    def __init__(
+        self,
+        items: Iterable[NeatSequence],
+        namespace: Namespace | None = None,
+        to_type: Callable[[NeatSequence], str | None] | None = None,
+        total: int | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+        unpack_columns: bool = False,
+    ):
+        super().__init__(
+            items, namespace, to_type, total, limit, unpack_metadata, skip_metadata_values, camel_case, as_write
+        )
+        self.unpack_columns = unpack_columns
+
     @classmethod
-    def _from_dataset(cls, client: CogniteClient, data_set_external_id: str) -> tuple[int | None, Iterable[Sequence]]:
+    def from_dataset(
+        cls,
+        client: CogniteClient,
+        data_set_external_id: str,
+        namespace: Namespace | None = None,
+        to_type: Callable[[NeatSequence], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+        unpack_columns: bool = False,
+    ):
+        total, items = cls._from_dataset(client, data_set_external_id)
+        return cls(
+            items,
+            namespace,
+            to_type,
+            total,
+            limit,
+            unpack_metadata,
+            skip_metadata_values,
+            camel_case,
+            as_write,
+            unpack_columns,
+        )
+
+    @classmethod
+    def from_hierarchy(
+        cls,
+        client: CogniteClient,
+        root_asset_external_id: str,
+        namespace: Namespace | None = None,
+        to_type: Callable[[NeatSequence], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+        unpack_columns: bool = False,
+    ):
+        total, items = cls._from_hierarchy(client, root_asset_external_id)
+        return cls(
+            items,
+            namespace,
+            to_type,
+            total,
+            limit,
+            unpack_metadata,
+            skip_metadata_values,
+            camel_case,
+            as_write,
+            unpack_columns,
+        )
+
+    @classmethod
+    def from_file(
+        cls,
+        file_path: str | Path,
+        namespace: Namespace | None = None,
+        to_type: Callable[[NeatSequence], str | None] | None = None,
+        limit: int | None = None,
+        unpack_metadata: bool = True,
+        skip_metadata_values: Set[str] | None = DEFAULT_SKIP_METADATA_VALUES,
+        camel_case: bool = True,
+        as_write: bool = False,
+        unpack_columns: bool = False,
+    ):
+        total, items = cls._from_file(file_path)
+        return cls(
+            items,
+            namespace,
+            to_type,
+            total,
+            limit,
+            unpack_metadata,
+            skip_metadata_values,
+            camel_case,
+            as_write,
+            unpack_columns,
+        )
+
+    @classmethod
+    def _from_dataset(
+        cls, client: CogniteClient, data_set_external_id: str
+    ) -> tuple[int | None, Iterable[NeatSequence]]:
         total = client.sequences.aggregate_count(
             filter=SequenceFilter(data_set_ids=[{"externalId": data_set_external_id}])
         )
         items = client.sequences(data_set_external_ids=data_set_external_id)
-        return total, items
+        return total, cls._lookup_rows(items, client)
 
     @classmethod
     def _from_hierarchy(
         cls, client: CogniteClient, root_asset_external_id: str
-    ) -> tuple[int | None, Iterable[Sequence]]:
+    ) -> tuple[int | None, Iterable[NeatSequence]]:
         total = client.sequences.aggregate_count(
             filter=SequenceFilter(asset_subtree_ids=[{"externalId": root_asset_external_id}])
         )
         items = client.sequences(asset_subtree_external_ids=[root_asset_external_id])
-        return total, items
+        return total, cls._lookup_rows(items, client)
 
     @classmethod
-    def _from_file(cls, file_path: str | Path) -> tuple[int | None, Iterable[Sequence]]:
-        sequences = SequenceList.load(Path(file_path).read_text())
+    def _from_file(cls, file_path: str | Path) -> tuple[int | None, Iterable[NeatSequence]]:
+        sequences = NeatSequenceList.load(Path(file_path).read_text())
         return len(sequences), sequences
+
+    @classmethod
+    def _lookup_rows(cls, sequence_iterable: Iterable[Sequence], client: CogniteClient) -> Iterable[NeatSequence]:
+        iterator = iter(sequence_iterable)
+        for sequences in iter(lambda: list(itertools.islice(iterator, client.config.max_workers)), []):
+            # The PySDK uses max_workers to limit the number of requests made in parallel.
+            # We can only get one set of sequence rows per request, so we chunk the sequences up into groups of
+            # max_workers and then make a request to get all the rows for those sequences in one go.
+            sequence_list = list(sequences)
+            row_list = client.sequences.rows.retrieve(id=[seq.id for seq in sequence_list])
+            rows_by_sequence_id = {row.id: row.rows for row in row_list}
+            for seq in sequence_list:
+                yield NeatSequence.from_cognite_sequence(seq, rows_by_sequence_id.get(seq.id))
+
+    def _item2triples_special_cases(self, id_: URIRef, dumped: dict[str, Any]) -> list[Triple]:
+        """For sequences, columns and rows are special cases.'"""
+        if self.unpack_columns:
+            return self._unpack_columns(id_, dumped)
+        else:
+            return self._default_columns_and_rows(id_, dumped)
+
+    def _default_columns_and_rows(self, id_: URIRef, dumped: dict[str, Any]) -> list[Triple]:
+        triples: list[Triple] = []
+        if "columns" in dumped:
+            columns = dumped.pop("columns")
+            triples.extend(
+                [
+                    (
+                        id_,
+                        self.namespace.columns,
+                        # Rows have a rowNumber, so we introduce colNumber here to be consistent.
+                        Literal(json.dumps({"colNumber": no, **col}), datatype=XSD._NS["json"]),
+                    )
+                    for no, col in enumerate(columns, 1)
+                ]
+            )
+        if "rows" in dumped:
+            rows = dumped.pop("rows")
+            triples.extend(
+                [(id_, self.namespace.rows, Literal(json.dumps(row), datatype=XSD._NS["json"])) for row in rows]
+            )
+        return triples
+
+    def _unpack_columns(self, id_: URIRef, dumped: dict[str, Any]) -> list[Triple]:
+        triples: list[Triple] = []
+        columnValueTypes: list[str] = []
+        column_order: list[str] = []
+        if columns := dumped.pop("columns", None):
+            for col in columns:
+                external_id = col.pop("externalId")
+                column_order.append(external_id)
+                value_type = col.pop("valueType")
+                columnValueTypes.append(value_type)
+
+                col_id = self.namespace[f"Column_{external_id}"]
+                triples.append((id_, self.namespace[external_id], col_id))
+                type_ = self.namespace[self._column_rdf_type]
+                triples.append((col_id, RDF.type, type_))
+                if metadata := col.pop("metadata", None):
+                    triples.extend(self._metadata_to_triples(col_id, metadata))
+                # Should only be name and description left in col
+                for key, value in col.items():
+                    if value is None:
+                        continue
+                    triples.append((col_id, self.namespace[key], Literal(value, datatype=XSD.string)))
+
+            triples.append(
+                (id_, self.namespace.columnOrder, Literal(json.dumps(column_order), datatype=XSD._NS["json"]))
+            )
+            triples.append(
+                (id_, self.namespace.columnValueTypes, Literal(json.dumps(columnValueTypes), datatype=XSD._NS["json"]))
+            )
+        if rows := dumped.pop("rows", None):
+            values_by_column: list[list[Any]] = [[] for _ in column_order]
+            for row in rows:
+                for i, value in enumerate(row["values"]):
+                    values_by_column[i].append(value)
+            for col_name, values in zip(column_order, values_by_column, strict=False):
+                triples.append(
+                    (id_, self.namespace[f"{col_name}Values"], Literal(json.dumps(values), datatype=XSD._NS["json"]))
+                )
+
+        return triples

cognite/neat/_graph/extractors/_mock_graph_generator.py

@@ -183,7 +183,7 @@ def _get_generation_order(
     parent_col: str = "source_class",
     child_col: str = "target_class",
 ) -> dict:
-    parent_child_list: list[list[str]] = class_linkage[[parent_col, child_col]].values.tolist()
+    parent_child_list: list[list[str]] = class_linkage[[parent_col, child_col]].values.tolist()  # type: ignore[assignment]
     # Build a directed graph and a list of all names that have no parent
     graph: dict[str, set] = {name: set() for tup in parent_child_list for name in tup}
     has_parent: dict[str, bool] = {name: False for tup in parent_child_list for name in tup}

cognite/neat/_graph/loaders/_rdf2dms.py

@@ -1,10 +1,11 @@
 import itertools
 import json
+import warnings
 from collections import defaultdict
 from collections.abc import Iterable, Sequence
 from graphlib import TopologicalSorter
 from pathlib import Path
-from typing import Any, get_args
+from typing import Any, cast, get_args
 
 import yaml
 from cognite.client import CogniteClient
@@ -19,6 +20,7 @@ from pydantic import BaseModel, ValidationInfo, create_model, field_validator
 from rdflib import RDF, URIRef
 
 from cognite.neat._client import NeatClient
+from cognite.neat._constants import DMS_DIRECT_RELATION_LIST_LIMIT, is_readonly_property
 from cognite.neat._graph._tracking import LogTracker, Tracker
 from cognite.neat._issues import IssueList, NeatIssue, NeatIssueList
 from cognite.neat._issues.errors import (
@@ -27,7 +29,7 @@ from cognite.neat._issues.errors import (
     ResourceDuplicatedError,
     ResourceRetrievalError,
 )
-from cognite.neat._issues.warnings import PropertyTypeNotSupportedWarning
+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
@@ -303,6 +305,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             if isinstance(prop, dm.EdgeConnection):
                 edge_by_property[prop_id] = prop_id, prop
             if isinstance(prop, dm.MappedProperty):
+                if is_readonly_property(prop.container, prop.container_property_identifier):
+                    continue
+
                 if isinstance(prop.type, dm.DirectRelation):
                     if prop.container == dm.ContainerId("cdf_cdm", "CogniteTimeSeries") and prop_id == "unit":
                         unit_properties.append(prop_id)
@@ -343,9 +348,14 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
 
             return value
 
-        def parse_json_string(cls, value: Any, info: ValidationInfo) -> dict:
+        def parse_json_string(cls, value: Any, info: ValidationInfo) -> dict | list:
             if isinstance(value, dict):
                 return value
+            elif isinstance(value, list):
+                try:
+                    return [json.loads(v) if isinstance(v, str) else v for v in value]
+                except json.JSONDecodeError as error:
+                    raise ValueError(f"Not valid JSON string for {info.field_name}: {value}, error {error}") from error
             elif isinstance(value, str):
                 try:
                     return json.loads(value)
@@ -364,7 +374,21 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             def parse_direct_relation(cls, value: list, info: ValidationInfo) -> dict | list[dict]:
                 # We validate above that we only get one value for single direct relations.
                 if list.__name__ in _get_field_value_types(cls, info):
-                    return [{"space": self.instance_space, "externalId": remove_namespace_from_uri(v)} for v in value]
+                    result = [{"space": self.instance_space, "externalId": remove_namespace_from_uri(v)} for v in value]
+                    if len(result) <= DMS_DIRECT_RELATION_LIST_LIMIT:
+                        return result
+                    warnings.warn(
+                        PropertyDirectRelationLimitWarning(
+                            identifier="unknown",
+                            resource_type="view property",
+                            property_name=cast(str, cls.model_fields[info.field_name].alias or info.field_name),
+                            limit=DMS_DIRECT_RELATION_LIST_LIMIT,
+                        ),
+                        stacklevel=2,
+                    )
+                    # To get deterministic results, we sort by space and externalId
+                    result.sort(key=lambda x: (x["space"], x["externalId"]))
+                    return result[:DMS_DIRECT_RELATION_LIST_LIMIT]
                 elif value:
                     return {"space": self.instance_space, "externalId": remove_namespace_from_uri(value[0])}
                 return {}
@@ -401,7 +425,9 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             space=self.instance_space,
             external_id=identifier,
             type=(dm.DirectRelationReference(view_id.space, view_id.external_id) if type_ is not None else None),
-            sources=[dm.NodeOrEdgeData(source=view_id, properties=dict(created.model_dump().items()))],
+            sources=[
+                dm.NodeOrEdgeData(source=view_id, properties=dict(created.model_dump(exclude_unset=True).items()))
+            ],
         )
 
     def _create_edges(

cognite/neat/_graph/transformers/__init__.py

@@ -15,7 +15,7 @@ from ._prune_graph import (
     PruneTypes,
 )
 from ._rdfpath import AddSelfReferenceProperty, MakeConnectionOnExactMatch
-from ._value_type import ConvertLiteral, LiteralToEntity, SplitMultiValueProperty
+from ._value_type import ConnectionToLiteral, ConvertLiteral, LiteralToEntity, SplitMultiValueProperty
 
 __all__ = [
     "AddAssetDepth",
@@ -26,6 +26,7 @@ __all__ = [
     "AssetSequenceConnector",
     "AssetTimeSeriesConnector",
     "AttachPropertyFromTargetToSource",
+    "ConnectionToLiteral",
     "ConvertLiteral",
     "LiteralToEntity",
     "MakeConnectionOnExactMatch",
@@ -55,4 +56,5 @@ Transformers = (
     | PruneInstancesOfUnknownType
     | ConvertLiteral
     | LiteralToEntity
+    | ConnectionToLiteral
 )

cognite/neat/_graph/transformers/_classic_cdf.py

@@ -6,6 +6,7 @@ from functools import lru_cache
 from typing import cast
 
 from rdflib import RDF, Graph, Literal, Namespace, URIRef
+from rdflib.query import ResultRow
 
 from cognite.neat._constants import CLASSIC_CDF_NAMESPACE, DEFAULT_NAMESPACE
 from cognite.neat._graph import extractors
@@ -18,71 +19,57 @@ from cognite.neat._utils.rdf_ import (
     remove_namespace_from_uri,
 )
 
-from ._base import BaseTransformer
+from ._base import BaseTransformer, BaseTransformerStandardised, RowTransformationOutput
 
 
-# TODO: standardise
-class AddAssetDepth(BaseTransformer):
-    description: str = "Adds depth of asset in the asset hierarchy to the graph"
+class AddAssetDepth(BaseTransformerStandardised):
+    description: str = "Adds depth of asset in the asset hierarchy and optionally types asset based on depth"
     _use_only_once: bool = True
     _need_changes = frozenset({str(extractors.AssetsExtractor.__name__)})
 
-    _parent_template: str = """SELECT ?child ?parent WHERE {{
-                              <{asset_id}> <{parent_prop}> ?child .
-                              OPTIONAL{{?child <{parent_prop}>+ ?parent .}}}}"""
-
-    _root_template: str = """SELECT ?root WHERE {{
-                             <{asset_id}> <{root_prop}> ?root .}}"""
-
     def __init__(
         self,
         asset_type: URIRef | None = None,
-        root_prop: URIRef | None = None,
         parent_prop: URIRef | None = None,
         depth_typing: dict[int, str] | None = None,
     ):
         self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.root_prop = root_prop or DEFAULT_NAMESPACE.rootId
         self.parent_prop = parent_prop or DEFAULT_NAMESPACE.parentId
         self.depth_typing = depth_typing
 
-    def transform(self, graph: Graph) -> None:
-        """Adds depth of asset in the asset hierarchy to the graph."""
-        for result in graph.query(f"SELECT DISTINCT ?asset_id WHERE {{?asset_id a <{self.asset_type}>}}"):
-            asset_id = cast(tuple, result)[0]
-            if depth := self.get_depth(graph, asset_id, self.root_prop, self.parent_prop):
-                graph.add((asset_id, DEFAULT_NAMESPACE.depth, Literal(depth)))
-
-                if self.depth_typing and (type_ := self.depth_typing.get(depth, None)):
-                    # remove existing type
-                    graph.remove((asset_id, RDF.type, None))
-
-                    # add new type
-                    graph.add((asset_id, RDF.type, DEFAULT_NAMESPACE[type_]))
-
-    @classmethod
-    def get_depth(
-        cls,
-        graph: Graph,
-        asset_id: URIRef,
-        root_prop: URIRef,
-        parent_prop: URIRef,
-    ) -> int | None:
-        """Get asset depth in the asset hierarchy."""
-
-        # Handles non-root assets
-        if result := list(graph.query(cls._parent_template.format(asset_id=asset_id, parent_prop=parent_prop))):
-            return len(cast(list[tuple], result)) + 2 if cast(list[tuple], result)[0][1] else 2
-
-        # Handles root assets
-        elif (
-            (result := list(graph.query(cls._root_template.format(asset_id=asset_id, root_prop=root_prop))))
-            and len(cast(list[tuple], result)) == 1
-            and cast(list[tuple], result)[0][0] == asset_id
-        ):
-            return 1
-        else:
-            return None
+    def _iterate_query(self) -> str:
+        query = """SELECT ?asset (IF(?isRoot, 0, COUNT(?parent)) AS ?parentCount)
+                   WHERE {{
+                        ?asset a <{asset_type}> .
+                        OPTIONAL {{ ?asset <{parent_prop}>+ ?parent . }}
+                        BIND(IF(BOUND(?parent), false, true) AS ?isRoot)}}
+                   GROUP BY ?asset ?isRoot
+                   ORDER BY DESC(?parentCount)"""
+
+        return query.format(
+            asset_type=self.asset_type,
+            parent_prop=self.parent_prop,
+        )
+
+    def _count_query(self) -> str:
+        query = """SELECT (COUNT(?asset) as ?count)
+                   WHERE {{ ?asset a <{asset_type}> . }}"""
+
+        return query.format(asset_type=self.asset_type)
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+        subject, object = query_result_row
+
+        row_output.add_triples.append(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.instances_modified_count += 1
+
+        return row_output
 
 
 # TODO: standardise
@@ -375,7 +362,8 @@ WHERE {{
     ) -> list[Triple]:
         relationship_triples = cast(list[Triple], list(graph.query(f"DESCRIBE <{relationship_id}>")))
         object_by_predicates = cast(
-            dict[str, URIRef | Literal], {remove_namespace_from_uri(row[1]): row[2] for row in relationship_triples}
+            dict[str, URIRef | Literal],
+            {remove_namespace_from_uri(row[1]): row[2] for row in relationship_triples if row[1] != RDF.type},
         )
         source_external_id = cast(URIRef, object_by_predicates["sourceExternalId"])
         target_source_id = cast(URIRef, object_by_predicates["targetExternalId"])

cognite/neat/_graph/transformers/_rdfpath.py

@@ -1,15 +1,14 @@
 from typing import cast
 from urllib.parse import quote
 
-from rdflib import Graph, URIRef
+from rdflib import Graph, Namespace, 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 remove_namespace_from_uri
+from cognite.neat._utils.rdf_ import get_namespace, remove_namespace_from_uri
 
 from ._base import BaseTransformer, BaseTransformerStandardised, RowTransformationOutput
 
@@ -76,11 +75,11 @@ class MakeConnectionOnExactMatch(BaseTransformerStandardised):
         self.subject_predicate = subject_predicate
         self.object_type = object_type
         self.object_predicate = object_predicate
-
+        subject_namespace = Namespace(get_namespace(subject_type))
         self.connection = (
-            DEFAULT_NAMESPACE[quote(connection.strip())]
+            subject_namespace[quote(connection.strip())]
             if isinstance(connection, str)
-            else connection or DEFAULT_NAMESPACE[remove_namespace_from_uri(self.object_type).lower()]
+            else connection or subject_namespace[remove_namespace_from_uri(self.object_type).lower()]
         )
 
         self.limit = limit
@@ -88,10 +87,10 @@ class MakeConnectionOnExactMatch(BaseTransformerStandardised):
     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}> .
+                                ?subject a <{subject_type}> ;
+                                        <{subject_predicate}> ?value .
+                                ?object a <{object_type}> ;
+                                        <{object_predicate}> ?value .
                             }}"""
 
         if self.limit and isinstance(self.limit, int) and self.limit > 0:
@@ -105,12 +104,12 @@ class MakeConnectionOnExactMatch(BaseTransformerStandardised):
         )
 
     def _count_query(self) -> str:
-        query = """SELECT (COUNT(DISTINCT (?subject ?object)) as ?count)
+        query = """SELECT (COUNT(DISTINCT ?subject) as ?count)
                     WHERE {{
-                        ?subject a <{subject_type}> .
-                        ?subject <{subject_predicate}> ?value .
-                        ?object <{object_predicate}> ?value .
-                        ?object a <{object_type}> .
+                        ?subject a <{subject_type}> ;
+                                <{subject_predicate}> ?value .
+                        ?object a <{object_type}> ;
+                                <{object_predicate}> ?value .
                     }}"""
 
         if self.limit and isinstance(self.limit, int) and self.limit > 0:

cognite/neat/_graph/transformers/_value_type.py

@@ -223,3 +223,75 @@ class LiteralToEntity(BaseTransformerStandardised):
         row_output.instances_modified_count += 1  # we modify the old entity
 
         return row_output
+
+
+class ConnectionToLiteral(BaseTransformerStandardised):
+    description = "Converts an entity connection to a literal value"
+
+    def __init__(self, subject_type: URIRef | None, subject_predicate: URIRef) -> None:
+        self.subject_type = subject_type
+        self.subject_predicate = subject_predicate
+
+    def _iterate_query(self) -> str:
+        if self.subject_type is None:
+            query = """SELECT ?instance ?object
+            WHERE {{
+              ?instance <{subject_predicate}> ?object
+              FILTER(isIRI(?object))
+            }}"""
+            return query.format(subject_predicate=self.subject_predicate)
+        else:
+            query = """SELECT ?instance ?object
+                WHERE {{
+                  ?instance a <{subject_type}> .
+                  ?instance <{subject_predicate}> ?object
+                  FILTER(isIRI(?object))
+                }}"""
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _skip_count_query(self) -> str:
+        if self.subject_type is None:
+            query = """SELECT (COUNT(?object) AS ?objectCount)
+                        WHERE {{
+                          ?instance <{subject_predicate}> ?object
+                          FILTER(isLiteral(?object))
+                        }}"""
+            return query.format(subject_predicate=self.subject_predicate)
+        else:
+            query = """SELECT (COUNT(?object) AS ?objectCount)
+                        WHERE {{
+                          ?instance a <{subject_type}> .
+                          ?instance <{subject_predicate}> ?object
+                          FILTER(isLiteral(?object))
+                        }}"""
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def _count_query(self) -> str:
+        if self.subject_type is None:
+            query = """SELECT (COUNT(?object) AS ?objectCount)
+                WHERE {{
+                  ?instance <{subject_predicate}> ?object
+                  FILTER(isIRI(?object))
+                }}"""
+            return query.format(subject_predicate=self.subject_predicate)
+        else:
+            query = """SELECT (COUNT(?object) AS ?objectCount)
+                        WHERE {{
+                          ?instance a <{subject_type}> .
+                          ?instance <{subject_predicate}> ?object
+                          FILTER(isIRI(?object))
+                        }}"""
+
+            return query.format(subject_type=self.subject_type, subject_predicate=self.subject_predicate)
+
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+
+        instance, object_entity = cast(tuple[URIRef, URIRef], query_result_row)
+        value = remove_namespace_from_uri(object_entity)
+
+        row_output.add_triples.append((instance, self.subject_predicate, rdflib.Literal(value)))
+        row_output.remove_triples.append((instance, self.subject_predicate, object_entity))
+        row_output.instances_modified_count += 1
+
+        return row_output

cognite/neat/_issues/__init__.py

@@ -3,7 +3,6 @@ as some helper classes to handle them like NeatIssueList"""
 
 from ._base import (
     DefaultWarning,
-    FutureResult,
     IssueList,
     MultiValueError,
     NeatError,
@@ -16,7 +15,6 @@ from ._base import (
 
 __all__ = [
     "DefaultWarning",
-    "FutureResult",
     "IssueList",
     "MultiValueError",
     "NeatError",