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

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
@@ -8,7 +9,7 @@ from rdflib.query import ResultRow
 
 from cognite.neat._issues.warnings import NeatValueWarning
 from cognite.neat._shared import Triple
-from cognite.neat._utils.collection_ import iterate_progress_bar
+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]
@@ -42,7 +43,6 @@ class BaseTransformerStandardised(ABC):
     description: str
     _use_only_once: bool = False
     _need_changes: ClassVar[frozenset[str]] = frozenset()
-    _use_iterate_bar_threshold: int = 500
 
     @abstractmethod
     def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
@@ -66,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.
@@ -98,13 +105,10 @@ class BaseTransformerStandardised(ABC):
         if iteration_count == 0:
             return outcome
 
-        result_iterable = graph.query(self._iterate_query())
-        if iteration_count > self._use_iterate_bar_threshold:
-            result_iterable = iterate_progress_bar(  # type: ignore[misc, assignment]
-                result_iterable,
-                total=iteration_count,
-                description=self.description,
-            )
+        result_iterable = self._iterator(graph)
+        result_iterable = iterate_progress_bar_if_above_config_threshold(
+            result_iterable, iteration_count, self.description
+        )
 
         for row in result_iterable:
             row = cast(ResultRow, row)

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,8 +231,7 @@ class AssetEventConnector(BaseAssetConnector):
         )
 
 
-# TODO: standardise
-class AssetRelationshipConnector(BaseTransformer):
+class AssetRelationshipConnector(BaseTransformerStandardised):
     description: str = "Connects assets via relationships"
     _use_only_once: bool = True
     _need_changes = frozenset(
@@ -248,6 +249,44 @@ class AssetRelationshipConnector(BaseTransformer):
                               ?target <{asset_xid_property}> ?target_xid .
                               ?target a <{asset_type}> .}}"""
 
+    def _count_query(self) -> str:
+        query = """SELECT (COUNT(?target) as ?count) WHERE {{
+                   ?relationship a <{relationship_type}> .
+                   ?relationship <{relationship_source_xid_prop}> ?source_xid .
+                   ?source <{asset_xid_property}> ?source_xid .
+                   ?source a <{asset_type}> .
+
+                   ?relationship <{relationship_target_xid_prop}> ?target_xid .
+                   ?target <{asset_xid_property}> ?target_xid .
+                   ?target a <{asset_type}> .}}"""
+
+        return query.format(
+            relationship_type=self.relationship_type,
+            relationship_source_xid_prop=self.relationship_source_xid_prop,
+            relationship_target_xid_prop=self.relationship_target_xid_prop,
+            asset_xid_property=self.asset_xid_property,
+            asset_type=self.asset_type,
+        )
+
+    def _iterate_query(self) -> str:
+        query = """SELECT ?source ?relationship ?target WHERE {{
+                   ?relationship a <{relationship_type}> .
+                   ?relationship <{relationship_source_xid_prop}> ?source_xid .
+                   ?source <{asset_xid_property}> ?source_xid .
+                   ?source a <{asset_type}> .
+
+                   ?relationship <{relationship_target_xid_prop}> ?target_xid .
+                   ?target <{asset_xid_property}> ?target_xid .
+                   ?target a <{asset_type}> .}}"""
+
+        return query.format(
+            relationship_type=self.relationship_type,
+            relationship_source_xid_prop=self.relationship_source_xid_prop,
+            relationship_target_xid_prop=self.relationship_target_xid_prop,
+            asset_xid_property=self.asset_xid_property,
+            asset_type=self.asset_type,
+        )
+
     def __init__(
         self,
         asset_type: URIRef | None = None,
@@ -262,48 +301,20 @@ class AssetRelationshipConnector(BaseTransformer):
         self.relationship_target_xid_prop = relationship_target_xid_prop or DEFAULT_NAMESPACE.targetExternalId
         self.asset_xid_property = asset_xid_property or DEFAULT_NAMESPACE.externalId
 
-    def transform(self, graph: Graph) -> None:
-        for relationship_id_result in graph.query(
-            f"SELECT DISTINCT ?relationship_id WHERE {{?relationship_id a <{self.relationship_type}>}}"
-        ):
-            relationship_id: URIRef = cast(tuple, relationship_id_result)[0]
-
-            if assets_id_res := list(
-                graph.query(
-                    self._asset_template.format(
-                        relationship_id=relationship_id,
-                        asset_xid_property=self.asset_xid_property,
-                        relationship_source_xid_prop=self.relationship_source_xid_prop,
-                        relationship_target_xid_prop=self.relationship_target_xid_prop,
-                        asset_type=self.asset_type,
-                    )
-                )
-            ):
-                # files can be connected to multiple assets in the graph
-                for source_asset_id, target_asset_id in cast(list[tuple], assets_id_res):
-                    # create a relationship between the two assets
-                    graph.add(
-                        (
-                            source_asset_id,
-                            DEFAULT_NAMESPACE.relationship,
-                            relationship_id,
-                        )
-                    )
-                    graph.add(
-                        (
-                            target_asset_id,
-                            DEFAULT_NAMESPACE.relationship,
-                            relationship_id,
-                        )
-                    )
+    def operation(self, query_result_row: ResultRow) -> RowTransformationOutput:
+        row_output = RowTransformationOutput()
+        source, relationship, target = query_result_row
 
-                    # add source and target to the relationship
-                    graph.add((relationship_id, DEFAULT_NAMESPACE.source, source_asset_id))
-                    graph.add((relationship_id, DEFAULT_NAMESPACE.target, target_asset_id))
+        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)))
 
-                    # remove properties that are not needed, specifically the external ids
-                    graph.remove((relationship_id, self.relationship_source_xid_prop, None))
-                    graph.remove((relationship_id, self.relationship_target_xid_prop, None))
+        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.instances_modified_count += 2
+
+        return row_output
 
 
 # TODO: standardise
@@ -455,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(
@@ -506,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,12 +54,12 @@ 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):
     description: str = "Adds property that contains id of reference to all references of given class in Rules"
-    _use_only_once: bool = True
+    _use_only_once: bool = False
     _need_changes = frozenset({})
 
     def __init__(

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/_issues/warnings/_external.py

@@ -42,7 +42,7 @@ class FileItemNotSupportedWarning(NeatWarning):
 
 @dataclass(unsafe_hash=True)
 class CDFAuthWarning(NeatWarning):
-    """Failed to {action} due to {reason}"""
+    """Failed to {action}: {reason}"""
 
     action: str
     reason: str

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

cognite/neat/_rules/analysis/_information.py

@@ -55,12 +55,13 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
 
     def has_hop_transformations(self):
         return any(
-            prop_.transformation and isinstance(prop_.transformation.traversal, Hop) for prop_ in self.rules.properties
+            prop_.instance_source and isinstance(prop_.instance_source.traversal, Hop)
+            for prop_ in self.rules.properties
         )
 
     def has_self_reference_property_transformations(self):
         return any(
-            prop_.transformation and isinstance(prop_.transformation.traversal, SelfReferenceProperty)
+            prop_.instance_source and isinstance(prop_.instance_source.traversal, SelfReferenceProperty)
             for prop_ in self.rules.properties
         )
 
@@ -68,7 +69,7 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
         return [
             prop_
             for prop_ in self.rules.properties
-            if prop_.transformation and isinstance(prop_.transformation.traversal, SelfReferenceProperty)
+            if prop_.instance_source and isinstance(prop_.instance_source.traversal, SelfReferenceProperty)
         ]
 
     def define_property_renaming_config(self, class_: ClassEntity) -> dict[str | URIRef, str]:
@@ -76,7 +77,7 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
 
         if definitions := self.class_property_pairs(only_rdfpath=True, consider_inheritance=True).get(class_, None):
             for property_id, definition in definitions.items():
-                transformation = cast(RDFPath, definition.transformation)
+                transformation = cast(RDFPath, definition.instance_source)
 
                 # use case we have a single property rdf path, and defined prefix
                 # in either metadata or prefixes of rules
@@ -101,26 +102,26 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
 
         return property_renaming_configuration
 
-    def neat_id_to_transformation_property_uri(self, property_neat_id: URIRef) -> URIRef | None:
+    def neat_id_to_instance_source_property_uri(self, property_neat_id: URIRef) -> URIRef | None:
         if (
             (property_ := self.properties_by_neat_id.get(property_neat_id))
-            and property_.transformation
+            and property_.instance_source
             and isinstance(
-                property_.transformation.traversal,
+                property_.instance_source.traversal,
                 SingleProperty,
             )
             and (
-                property_.transformation.traversal.property.prefix in self.rules.prefixes
-                or property_.transformation.traversal.property.prefix == self.rules.metadata.prefix
+                property_.instance_source.traversal.property.prefix in self.rules.prefixes
+                or property_.instance_source.traversal.property.prefix == self.rules.metadata.prefix
             )
         ):
             namespace = (
                 self.rules.metadata.namespace
-                if property_.transformation.traversal.property.prefix == self.rules.metadata.prefix
-                else self.rules.prefixes[property_.transformation.traversal.property.prefix]
+                if property_.instance_source.traversal.property.prefix == self.rules.metadata.prefix
+                else self.rules.prefixes[property_.instance_source.traversal.property.prefix]
             )
 
-            return namespace[property_.transformation.traversal.property.suffix]
+            return namespace[property_.instance_source.traversal.property.suffix]
         return None
 
     def property_types(self, class_: ClassEntity) -> dict[str, EntityTypes]:
@@ -137,7 +138,7 @@ class InformationAnalysis(BaseAnalysis[InformationRules, InformationClass, Infor
             class_, None
         ):
             for property_ in class_property_pairs.values():
-                classes.append(cast(RDFPath, property_.transformation).traversal.class_)
+                classes.append(cast(RDFPath, property_.instance_source).traversal.class_)
 
             return cast(ClassEntity, most_occurring_element(classes))
         else:

cognite/neat/_rules/catalog/__init__.py

@@ -5,3 +5,4 @@ from pathlib import Path
 _CATALOG = Path(__file__).parent
 imf_attributes = _CATALOG / "info-rules-imf.xlsx"
 hello_world_pump = _CATALOG / "hello_world_pump.xlsx"
+classic_model = _CATALOG / "classic_model.xlsx"

cognite/neat/_rules/importers/_dms2rules.py

@@ -115,8 +115,8 @@ class DMSImporter(BaseImporter[DMSInputRules]):
         data_model_ids = [data_model_id]
         data_models = client.data_modeling.data_models.retrieve(data_model_ids, inline_views=True)
 
-        user_models = cls._find_model_in_list(data_models, data_model_id)
-        if len(user_models) == 0:
+        retrieved_models = cls._find_model_in_list(data_models, data_model_id)
+        if len(retrieved_models) == 0:
             return cls(
                 DMSSchema(),
                 [
@@ -127,16 +127,18 @@ class DMSImporter(BaseImporter[DMSInputRules]):
                     )
                 ],
             )
-        user_model = user_models.latest_version()
+        return cls.from_data_model(client, retrieved_models.latest_version())
 
+    @classmethod
+    def from_data_model(cls, client: NeatClient, model: dm.DataModel[dm.View]) -> "DMSImporter":
         issue_list = IssueList()
         with _handle_issues(issue_list) as result:
-            schema = NeatClient(client).schema.retrieve_data_model(user_model)
+            schema = client.schema.retrieve_data_model(model)
 
         if result.result == "failure" or issue_list.has_errors:
             return cls(DMSSchema(), issue_list)
 
-        metadata = cls._create_metadata_from_model(user_model)
+        metadata = cls._create_metadata_from_model(model)
 
         return cls(
             schema,

cognite/neat/_rules/importers/_rdf/_inference2rules.py

@@ -17,6 +17,7 @@ from cognite.neat._rules.models.information import (
 )
 from cognite.neat._store import NeatGraphStore
 from cognite.neat._store._provenance import INSTANCES_ENTITY
+from cognite.neat._utils.collection_ import iterate_progress_bar
 from cognite.neat._utils.rdf_ import remove_namespace_from_uri, uri_to_short_form
 
 from ._base import DEFAULT_NON_EXISTING_NODE_TYPE, BaseRDFImporter
@@ -27,7 +28,6 @@ ORDERED_CLASSES_QUERY = """SELECT ?class (count(?s) as ?instances )
                            WHERE { ?s a ?class . }
                            group by ?class order by DESC(?instances)"""
 
-
 INSTANCES_OF_CLASS_QUERY = """SELECT ?s ?propertyCount WHERE { ?s a <class> . BIND ('Unknown' as ?propertyCount) }"""
 
 
@@ -171,8 +171,10 @@ class InferenceImporter(BaseRDFImporter):
             INSTANCES_OF_CLASS_QUERY if self.max_number_of_instance == -1 else INSTANCES_OF_CLASS_RICHNESS_ORDERED_QUERY
         )
 
+        classes_iterable = iterate_progress_bar(classes.items(), len(classes), "Inferring classes")
+
         # Infers all the properties of the class
-        for class_id, class_definition in classes.items():
+        for class_id, class_definition in classes_iterable:
             for (  # type: ignore[misc]
                 instance,
                 _,
@@ -231,7 +233,7 @@ class InferenceImporter(BaseRDFImporter):
                         "property_": property_id,
                         "max_count": cast(RdfLiteral, occurrence).value,
                         "value_type": value_type_id,
-                        "transformation": (
+                        "instance_source": (
                             f"{uri_to_short_form(class_definition['uri'], prefixes)}"
                             f"({uri_to_short_form(cast(URIRef, property_uri), prefixes)})"
                         ),