cognite-neat 0.97.1__tar.gz → 0.97.3__tar.gz

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cognite-neat
-Version: 0.97.1
+Version: 0.97.3
 Summary: Knowledge graph transformation
 Home-page: https://cognite-neat.readthedocs-hosted.com/
 License: Apache-2.0

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_graph/loaders/_base.py

@@ -51,7 +51,14 @@ class CDFLoader(BaseLoader[T_Output]):
     def load_into_cdf(
         self, client: CogniteClient, dry_run: bool = False, check_client: bool = True
     ) -> UploadResultList:
-        return UploadResultList(self.load_into_cdf_iterable(client, dry_run, check_client))
+        upload_result_by_name: dict[str, UploadResult] = {}
+        for upload_result in self.load_into_cdf_iterable(client, dry_run, check_client):
+            if last_result := upload_result_by_name.get(upload_result.name):
+                upload_result_by_name[upload_result.name] = last_result.merge(upload_result)
+            else:
+                upload_result_by_name[upload_result.name] = upload_result
+
+        return UploadResultList(upload_result_by_name.values())
 
     def load_into_cdf_iterable(
         self, client: CogniteClient, dry_run: bool = False, check_client: bool = True

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_graph/loaders/_rdf2dms.py

@@ -1,3 +1,4 @@
+import itertools
 import json
 from collections.abc import Iterable, Sequence
 from pathlib import Path
@@ -295,9 +296,24 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         dry_run: bool,
         read_issues: IssueList,
     ) -> Iterable[UploadResult]:
+        nodes: list[dm.NodeApply] = []
+        edges: list[dm.EdgeApply] = []
+        source_by_node_id: dict[dm.NodeId, str] = {}
+        source_by_edge_id: dict[dm.EdgeId, str] = {}
+        for item in items:
+            if isinstance(item, dm.NodeApply):
+                nodes.append(item)
+                if item.sources:
+                    source_by_node_id[item.as_id()] = item.sources[0].source.external_id
+                else:
+                    source_by_node_id[item.as_id()] = "node"
+            elif isinstance(item, dm.EdgeApply):
+                edges.append(item)
+                if item.sources:
+                    source_by_edge_id[item.as_id()] = item.sources[0].source.external_id
+                else:
+                    source_by_edge_id[item.as_id()] = "edge"
         try:
-            nodes = [item for item in items if isinstance(item, dm.NodeApply)]
-            edges = [item for item in items if isinstance(item, dm.EdgeApply)]
             upserted = client.data_modeling.instances.apply(
                 nodes,
                 edges,
@@ -312,19 +328,23 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
             result.created.update(item.as_id() for item in e.successful)
             yield result
         else:
-            for instance_type, instances in {
-                "Nodes": upserted.nodes,
-                "Edges": upserted.edges,
-            }.items():
-                result = UploadResult[InstanceId](name=instance_type, issues=read_issues)
-                for instance in instances:  # type: ignore[attr-defined]
-                    if instance.was_modified and instance.created_time == instance.last_updated_time:
-                        result.created.add(instance.as_id())
-                    elif instance.was_modified:
-                        result.changed.add(instance.as_id())
-                    else:
-                        result.unchanged.add(instance.as_id())
-                yield result
+            for instances, ids_by_source in [
+                (upserted.nodes, source_by_node_id),
+                (upserted.edges, source_by_edge_id),
+            ]:
+                for name, subinstances in itertools.groupby(
+                    sorted(instances, key=lambda i: ids_by_source[i.as_id()]),  # type: ignore[call-overload, index, attr-defined]
+                    key=lambda i: ids_by_source[i.as_id()],  # type: ignore[index]
+                ):
+                    result = UploadResult(name=name, issues=read_issues)
+                    for instance in subinstances:  # type: ignore[attr-defined]
+                        if instance.was_modified and instance.created_time == instance.last_updated_time:
+                            result.created.add(instance.as_id())
+                        elif instance.was_modified:
+                            result.changed.add(instance.as_id())
+                        else:
+                            result.unchanged.add(instance.as_id())
+                    yield result
 
 
 def _get_field_value_types(cls, info):

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_graph/queries/_base.py

@@ -42,6 +42,27 @@ class Queries:
             for res in list(self.graph.query(query_statement))
         ]
 
+    @property
+    def types(self) -> 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]:
+        """Get the URIRef of a type"""
+        return [k for k, v in self.types.items() if v == type_]
+
+    @property
+    def properties(self) -> dict[URIRef, str]:
+        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]
+
+    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 list_instances_ids_of_class(self, class_uri: URIRef, limit: int = -1) -> list[URIRef]:
         """Get instances ids for a given class
 
@@ -101,7 +122,7 @@ class Queries:
         # 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 types_with_property(self, property_uri: URIRef) -> list[URIRef]:
+    def type_with_property(self, type_: URIRef, property_uri: URIRef) -> bool:
         """Check if a property exists in the graph store
 
         Args:
@@ -110,8 +131,8 @@ class Queries:
         Returns:
             True if property exists, False otherwise
         """
-        query = f"SELECT DISTINCT ?t WHERE {{ ?s <{property_uri}> ?o ; a ?t}} Limit 1"
-        return cast(list[URIRef], [t[0] for t in self.graph.query(query)])  # type: ignore[index]
+        query = f"SELECT ?o WHERE {{ ?s a <{type_}> ; <{property_uri}> ?o .}} Limit 1"
+        return bool(list(self.graph.query(query)))
 
     def has_namespace(self, namespace: Namespace) -> bool:
         """Check if a namespace exists in the graph store
@@ -250,7 +271,7 @@ class Queries:
             result = self.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]
+            return [remove_namespace_from_uri(cast(ResultRow, triple)) for triple in result if triple[1] != RDF.type]  # type: ignore[misc, index, arg-type]
         else:
             warnings.warn(
                 "No rules found for the graph store, returning empty list.",

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_issues/__init__.py

@@ -3,12 +3,14 @@ as some helper classes to handle them like NeatIssueList"""
 
 from ._base import (
     DefaultWarning,
+    FutureResult,
     IssueList,
     MultiValueError,
     NeatError,
     NeatIssue,
     NeatIssueList,
     NeatWarning,
+    catch_issues,
     catch_warnings,
 )
 
@@ -21,4 +23,6 @@ __all__ = [
     "IssueList",
     "MultiValueError",
     "catch_warnings",
+    "catch_issues",
+    "FutureResult",
 ]

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_issues/_base.py

@@ -18,6 +18,7 @@ from cognite.client.data_classes.data_modeling import (
     PropertyId,
     ViewId,
 )
+from pydantic import ValidationError
 from pydantic_core import ErrorDetails
 
 from cognite.neat._utils.spreadsheet import SpreadsheetRead
@@ -398,6 +399,10 @@ class NeatIssueList(list, Sequence[T_NeatIssue], ABC):
         """Return all the warnings in this list."""
         return type(self)([issue for issue in self if isinstance(issue, NeatWarning)])  # type: ignore[misc]
 
+    def has_error_type(self, error_type: type[NeatError]) -> bool:
+        """Return True if this list contains any errors of the given type."""
+        return any(isinstance(issue, error_type) for issue in self)
+
     def as_errors(self, operation: str = "Operation failed") -> ExceptionGroup:
         """Return an ExceptionGroup with all the errors in this list."""
         return ExceptionGroup(
@@ -473,3 +478,46 @@ def catch_warnings(
         finally:
             if warning_logger and issues is not None:
                 issues.extend([warning_cls.from_warning(warning) for warning in warning_logger])  # type: ignore[misc]
+
+
+class FutureResult:
+    def __init__(self) -> None:
+        self._result: Literal["success", "failure", "pending"] = "pending"
+
+    @property
+    def result(self) -> Literal["success", "failure", "pending"]:
+        return self._result
+
+
+@contextmanager
+def catch_issues(
+    issues: IssueList,
+    error_cls: type[NeatError] = NeatError,
+    warning_cls: type[NeatWarning] = NeatWarning,
+    error_args: dict[str, Any] | None = None,
+) -> Iterator[FutureResult]:
+    """This is an internal help function to handle issues and warnings.
+
+    Args:
+        issues: The issues list to append to.
+        error_cls: The class used to convert errors to issues.
+        warning_cls:  The class used to convert warnings to issues.
+
+    Returns:
+        FutureResult: A future result object that can be used to check the result of the context manager.
+    """
+    with catch_warnings(issues, warning_cls):
+        future_result = FutureResult()
+        try:
+            yield future_result
+        except ValidationError as e:
+            issues.extend(error_cls.from_pydantic_errors(e.errors(), **(error_args or {})))
+            future_result._result = "failure"
+        except MultiValueError as e:
+            issues.extend(e.errors)
+            future_result._result = "failure"
+        except NeatError as e:
+            issues.append(e)
+            future_result._result = "failure"
+        else:
+            future_result._result = "success"

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_issues/errors/_general.py

@@ -19,10 +19,12 @@ class NeatTypeError(NeatError, TypeError):
 
 @dataclass(unsafe_hash=True)
 class RegexViolationError(NeatError, ValueError):
-    """Value, {value} failed regex, {regex}, validation. Make sure that the name follows the regex pattern."""
+    """Value, {value} in {location} failed regex, {regex}, validation.
+    Make sure that the name follows the regex pattern."""
 
     value: str
     regex: str
+    location: str
 
 
 @dataclass(unsafe_hash=True)

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_rules/models/_types.py

@@ -76,13 +76,17 @@ NamespaceType = Annotated[
 PrefixType = Annotated[
     str,
     StringConstraints(pattern=PREFIX_COMPLIANCE_REGEX),
-    _custom_error(lambda _, value: RegexViolationError(value, PREFIX_COMPLIANCE_REGEX)),
+    _custom_error(
+        lambda _, value: RegexViolationError(value, PREFIX_COMPLIANCE_REGEX, "prefix entry in metadata"),
+    ),
 ]
 
 DataModelExternalIdType = Annotated[
     str,
     StringConstraints(pattern=DATA_MODEL_COMPLIANCE_REGEX),
-    _custom_error(lambda _, value: RegexViolationError(value, DATA_MODEL_COMPLIANCE_REGEX)),
+    _custom_error(
+        lambda _, value: RegexViolationError(value, DATA_MODEL_COMPLIANCE_REGEX, "external ID entry in metadata")
+    ),
 ]
 
 
@@ -90,15 +94,15 @@ VersionType = Annotated[
     str,
     BeforeValidator(str),
     StringConstraints(pattern=VERSION_COMPLIANCE_REGEX),
-    _custom_error(lambda _, value: RegexViolationError(value, VERSION_COMPLIANCE_REGEX)),
+    _custom_error(lambda _, value: RegexViolationError(value, VERSION_COMPLIANCE_REGEX, "version entry in metadata")),
 ]
 
 
-def _external_id_validation_factory(entity_type: EntityTypes):
+def _external_id_validation_factory(entity_type: EntityTypes, location: str):
     def _external_id_validation(value: str) -> str:
         compiled_regex = PATTERNS.entity_pattern(entity_type)
         if not compiled_regex.match(value):
-            raise RegexViolationError(value, compiled_regex.pattern)
+            raise RegexViolationError(value, compiled_regex.pattern, location)
         if PATTERNS.more_than_one_alphanumeric.search(value):
             warnings.warn(
                 RegexViolationWarning(
@@ -116,36 +120,40 @@ def _external_id_validation_factory(entity_type: EntityTypes):
 
 SpaceType = Annotated[
     str,
-    AfterValidator(_external_id_validation_factory(EntityTypes.space)),
+    AfterValidator(_external_id_validation_factory(EntityTypes.space, "space entry in metadata")),
 ]
 
 InformationPropertyType = Annotated[
     str,
-    AfterValidator(_external_id_validation_factory(EntityTypes.information_property)),
+    AfterValidator(_external_id_validation_factory(EntityTypes.information_property, "Property column in properties")),
 ]
 DmsPropertyType = Annotated[
     str,
-    AfterValidator(_external_id_validation_factory(EntityTypes.dms_property)),
+    AfterValidator(_external_id_validation_factory(EntityTypes.dms_property, "Property column in properties")),
 ]
 
 
-def _entity_validation(value: Entities) -> Entities:
+def _entity_validation(value: Entities, location: str) -> Entities:
     suffix_regex = PATTERNS.entity_pattern(value.type_)
     if not suffix_regex.match(value.suffix):
-        raise RegexViolationError(str(value), suffix_regex.pattern)
+        raise RegexViolationError(str(value), suffix_regex.pattern, location)
     return value
 
 
-ClassEntityType = Annotated[ClassEntity, AfterValidator(_entity_validation)]
-ViewEntityType = Annotated[ViewEntity, AfterValidator(_entity_validation)]
-ContainerEntityType = Annotated[ContainerEntity, AfterValidator(_entity_validation)]
+ClassEntityType = Annotated[ClassEntity, AfterValidator(lambda v: _entity_validation(v, "the Class column"))]
+ViewEntityType = Annotated[ViewEntity, AfterValidator(lambda v: _entity_validation(v, "the View column"))]
+ContainerEntityType = Annotated[
+    ContainerEntity, AfterValidator(lambda v: _entity_validation(v, "the Container column"))
+]
 
 
-def _multi_value_type_validation(value: MultiValueTypeInfo) -> MultiValueTypeInfo:
+def _multi_value_type_validation(value: MultiValueTypeInfo, location: str) -> MultiValueTypeInfo:
     for type_ in value.types:
         if isinstance(type_, ClassEntity):
-            _entity_validation(type_)
+            _entity_validation(type_, location)
     return value
 
 
-MultiValueTypeType = Annotated[MultiValueTypeInfo, AfterValidator(_multi_value_type_validation)]
+MultiValueTypeType = Annotated[
+    MultiValueTypeInfo, AfterValidator(lambda v: _multi_value_type_validation(v, "the Value Type column"))
+]

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_rules/models/dms/_validation.py

@@ -157,21 +157,6 @@ class DMSPostValidation:
                     )
                 )
 
-            # This sets the container definition for all the properties where it is not defined.
-            # This allows the user to define the container only once.
-            value_type = next(iter(value_types))
-            list_definition = next(iter(list_definitions)) if list_definitions else None
-            nullable_definition = next(iter(nullable_definitions)) if nullable_definitions else None
-            default_definition = next(iter(default_definitions)) if default_definitions else None
-            index_definition = next(iter(index_definitions)).split(",") if index_definitions else None
-            constraint_definition = next(iter(constraint_definitions)).split(",") if constraint_definitions else None
-            for _, prop in properties:
-                prop.value_type = value_type
-                prop.is_list = prop.is_list or list_definition
-                prop.nullable = prop.nullable or nullable_definition
-                prop.default = prop.default or default_definition
-                prop.index = prop.index or index_definition
-                prop.constraint = prop.constraint or constraint_definition
         self.issue_list.extend(errors)
 
     def _referenced_views_and_containers_are_existing_and_proper_size(self) -> None:

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_rules/transformers/_verification.py

@@ -1,11 +1,7 @@
 from abc import ABC
-from collections.abc import Iterator
-from contextlib import contextmanager
 from typing import Any, Literal
 
-from pydantic import ValidationError
-
-from cognite.neat._issues import IssueList, MultiValueError, NeatError, NeatWarning, catch_warnings
+from cognite.neat._issues import IssueList, NeatError, NeatWarning, catch_issues
 from cognite.neat._issues.errors import NeatTypeError
 from cognite.neat._rules._shared import (
     InputRules,
@@ -45,7 +41,7 @@ class VerificationTransformer(RulesTransformer[T_InputRules, T_VerifiedRules], A
         if isinstance(rules, ReadRules):
             error_args = rules.read_context
         verified_rules: T_VerifiedRules | None = None
-        with _catch_issues(issues, NeatError, NeatWarning, error_args) as future:
+        with catch_issues(issues, NeatError, NeatWarning, error_args) as future:
             rules_cls = self._get_rules_cls(in_)
             verified_rules = rules_cls.model_validate(in_.dump())  # type: ignore[assignment]
 
@@ -92,46 +88,3 @@ class VerifyAnyRules(VerificationTransformer[InputRules, VerifiedRules]):
             return DomainRules
         else:
             raise NeatTypeError(f"Unsupported rules type: {type(in_)}")
-
-
-class _FutureResult:
-    def __init__(self) -> None:
-        self._result: Literal["success", "failure", "pending"] = "pending"
-
-    @property
-    def result(self) -> Literal["success", "failure", "pending"]:
-        return self._result
-
-
-@contextmanager
-def _catch_issues(
-    issues: IssueList,
-    error_cls: type[NeatError] = NeatError,
-    warning_cls: type[NeatWarning] = NeatWarning,
-    error_args: dict[str, Any] | None = None,
-) -> Iterator[_FutureResult]:
-    """This is an internal help function to handle issues and warnings.
-
-    Args:
-        issues: The issues list to append to.
-        error_cls: The class used to convert errors to issues.
-        warning_cls:  The class used to convert warnings to issues.
-
-    Returns:
-        FutureResult: A future result object that can be used to check the result of the context manager.
-    """
-    with catch_warnings(issues, warning_cls):
-        future_result = _FutureResult()
-        try:
-            yield future_result
-        except ValidationError as e:
-            issues.extend(error_cls.from_pydantic_errors(e.errors(), **(error_args or {})))
-            future_result._result = "failure"
-        except MultiValueError as e:
-            issues.extend(e.errors)
-            future_result._result = "failure"
-        except NeatError as e:
-            issues.append(e)
-            future_result._result = "failure"
-        else:
-            future_result._result = "success"

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_session/_base.py

@@ -5,9 +5,10 @@ from cognite.client import CogniteClient
 from cognite.client import data_modeling as dm
 
 from cognite.neat import _version
-from cognite.neat._issues import IssueList
+from cognite.neat._issues import IssueList, catch_issues
+from cognite.neat._issues.errors import RegexViolationError
 from cognite.neat._rules import importers
-from cognite.neat._rules._shared import ReadRules
+from cognite.neat._rules._shared import ReadRules, VerifiedRules
 from cognite.neat._rules.importers._rdf._base import DEFAULT_NON_EXISTING_NODE_TYPE
 from cognite.neat._rules.models import DMSRules
 from cognite.neat._rules.models.data_types import AnyURI
@@ -15,10 +16,12 @@ from cognite.neat._rules.models.entities._single_value import UnknownEntity
 from cognite.neat._rules.models.information._rules import InformationRules
 from cognite.neat._rules.models.information._rules_input import InformationInputRules
 from cognite.neat._rules.transformers import ConvertToRules, VerifyAnyRules
+from cognite.neat._rules.transformers._converters import ConversionTransformer
 from cognite.neat._store._provenance import (
     INSTANCES_ENTITY,
     Change,
 )
+from cognite.neat._utils.auth import _CLIENT_NAME
 
 from ._inspect import InspectAPI
 from ._prepare import PrepareAPI
@@ -49,6 +52,8 @@ class NeatSession:
         self.show = ShowAPI(self._state)
         self.set = SetAPI(self._state, verbose)
         self.inspect = InspectAPI(self._state)
+        if self._client is not None and self._client._config is not None:
+            self._client._config.client_name = _CLIENT_NAME
         if load_engine != "skip" and (engine_version := load_neat_engine(client, load_engine)):
             print(f"Neat Engine {engine_version} loaded.")
 
@@ -85,35 +90,52 @@ class NeatSession:
             print("You can inspect the issues with the .inspect.issues(...) method.")
         return output.issues
 
-    def convert(self, target: Literal["dms", "information"]) -> None:
+    def convert(self, target: Literal["dms", "information"]) -> IssueList:
         start = datetime.now(timezone.utc)
-        if target == "dms":
-            source_id, info_rules = self._state.data_model.last_verified_information_rules
-            converter = ConvertToRules(DMSRules)
-            converted_rules = converter.transform(info_rules).rules
-        elif target == "information":
-            source_id, dms_rules = self._state.data_model.last_verified_dms_rules
-            converter = ConvertToRules(InformationRules)
-            converted_rules = converter.transform(dms_rules).rules
-        else:
-            raise NeatSessionError(f"Target {target} not supported.")
+        issues = IssueList()
+        converter: ConversionTransformer | None = None
+        converted_rules: VerifiedRules | None = None
+        with catch_issues(issues):
+            if target == "dms":
+                source_id, info_rules = self._state.data_model.last_verified_information_rules
+                converter = ConvertToRules(DMSRules)
+                converted_rules = converter.transform(info_rules).rules
+            elif target == "information":
+                source_id, dms_rules = self._state.data_model.last_verified_dms_rules
+                converter = ConvertToRules(InformationRules)
+                converted_rules = converter.transform(dms_rules).rules
+            else:
+                # Session errors are not caught by the catch_issues context manager
+                raise NeatSessionError(f"Target {target} not supported.")
+
         end = datetime.now(timezone.utc)
+        if issues:
+            self._state.data_model.issue_lists.append(issues)
 
-        # Provenance
-        change = Change.from_rules_activity(
-            converted_rules,
-            converter.agent,
-            start,
-            end,
-            f"Converted data model {source_id} to {converted_rules.id_}",
-            self._state.data_model.provenance.source_entity(source_id)
-            or self._state.data_model.provenance.target_entity(source_id),
-        )
+        if converted_rules is not None and converter is not None:
+            # Provenance
+            change = Change.from_rules_activity(
+                converted_rules,
+                converter.agent,
+                start,
+                end,
+                f"Converted data model {source_id} to {converted_rules.id_}",
+                self._state.data_model.provenance.source_entity(source_id)
+                or self._state.data_model.provenance.target_entity(source_id),
+            )
+
+            self._state.data_model.write(converted_rules, change)
 
-        self._state.data_model.write(converted_rules, change)
+            if self._verbose and not issues.has_errors:
+                print(f"Rules converted to {target}")
+        else:
+            print("Conversion failed.")
+        if issues:
+            print("You can inspect the issues with the .inspect.issues(...) method.")
+            if issues.has_error_type(RegexViolationError):
+                print("You can use .prepare. to try to fix the issues")
 
-        if self._verbose:
-            print(f"Rules converted to {target}")
+        return issues
 
     def infer(
         self,

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_session/_inspect.py

@@ -173,8 +173,18 @@ class InspectUploadOutcome:
                             continue
                         lines.append(f"#### {key}")
                         if isinstance(value, list):
-                            for v in value:
-                                lines.append(f"  * {v}")
+                            total = len(value)
+                            for i, v in enumerate(value):
+                                if key in ["created", "updated", "changed"]:
+                                    if i < 50:
+                                        lines.append(f"  * {v}")
+                                    elif i == 50 and total > 50:
+                                        lines.append(f"  * ... {total-50} more")
+                                    elif i == 50 and total == 50:
+                                        lines.append(f"  * {v}")
+                                else:
+                                    lines.append(f"  * {v}")
+
                         else:
                             lines.append(f"  * {value}")
 

{cognite_neat-0.97.1 → cognite_neat-0.97.3}/cognite/neat/_session/_prepare.py

@@ -12,7 +12,7 @@ from cognite.neat._rules.transformers import ReduceCogniteModel, ToCompliantEnti
 from cognite.neat._store._provenance import Change
 
 from ._state import SessionState
-from .exceptions import intercept_session_exceptions
+from .exceptions import NeatSessionError, intercept_session_exceptions
 
 
 @intercept_session_exceptions
@@ -32,18 +32,18 @@ class InstancePrepareAPI:
 
     def make_connection_on_exact_match(
         self,
-        source: tuple[URIRef, URIRef],
-        target: tuple[URIRef, URIRef],
-        connection: URIRef | None = None,
+        source: tuple[str, str],
+        target: tuple[str, str],
+        connection: str | None = None,
         limit: int | None = 100,
     ) -> None:
         """Make connection on exact match.
 
         Args:
-            source: The source of the connection. A tuple of (rdf type, property) where
+            source: The source of the connection. A tuple of (type, property) where
                     where property is the property that should be matched on the source
                     to make the connection with the target.
-            target: The target of the connection. A tuple of (rdf type, property) where
+            target: The target of the connection. A tuple of (type, property) where
                     where property is the property that should be matched on the target
                     to make the connection with the source.
 
@@ -51,11 +51,19 @@ class InstancePrepareAPI:
                     will be made by lowercasing the target type.
             limit: The maximum number of connections to make. If None, all connections
 
+        !!! note "Make Connection on Exact Match"
+            This method will make a connection between the source and target based on the exact match:
+            (SourceType)-[sourceProperty]->(sourceValue) == (TargetType)-[targetProperty]->(targetValue)
+
+            The connection will be made by creating a new property on the source type that will contain the
+            target value, as follows:
+            (SourceType)-[connection]->(TargetType)
+
 
         """
 
-        subject_type, subject_predicate = source
-        object_type, object_predicate = target
+        subject_type, subject_predicate = self._get_type_and_property_uris(*source)
+        object_type, object_predicate = self._get_type_and_property_uris(*target)
 
         transformer = MakeConnectionOnExactMatch(
             subject_type,
@@ -68,6 +76,24 @@ class InstancePrepareAPI:
 
         self._state.instances.store.transform(transformer)
 
+    def _get_type_and_property_uris(self, type_: str, property_: str) -> tuple[URIRef, URIRef]:
+        type_uri = self._state.instances.store.queries.type_uri(type_)
+        property_uri = self._state.instances.store.queries.property_uri(property_)
+
+        if not type_uri:
+            raise NeatSessionError(f"Type {type_} does not exist in the graph.")
+        elif len(type_uri) > 1:
+            raise NeatSessionError(f"{type_} has multiple ids found in the graph: {','.join(type_uri)}.")
+
+        if not property_uri:
+            raise NeatSessionError(f"Property {property_} does not exist in the graph.")
+        elif len(type_uri) > 1:
+            raise NeatSessionError(f"{property_} has multiple ids found in the graph: {','.join(property_uri)}.")
+
+        if not self._state.instances.store.queries.type_with_property(type_uri[0], property_uri[0]):
+            raise NeatSessionError(f"Property {property_} is not defined for type {type_}. Cannot make connection")
+        return type_uri[0], property_uri[0]
+
 
 @intercept_session_exceptions
 class DataModelPrepareAPI: