cognite-neat 0.97.1__py3-none-any.whl → 0.97.3__py3-none-any.whl

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/_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/_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/_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/_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/_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/_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/_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/_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/_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/_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/_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:

cognite/neat/_session/_set.py

@@ -2,11 +2,12 @@ from datetime import datetime, timezone
 
 from cognite.client import data_modeling as dm
 
+from cognite.neat._constants import COGNITE_MODELS
 from cognite.neat._rules.transformers import SetIDDMSModel
 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
@@ -20,6 +21,12 @@ class SetAPI:
         if res := self._state.data_model.last_verified_dms_rules:
             source_id, rules = res
 
+            if rules.metadata.as_data_model_id() in COGNITE_MODELS:
+                raise NeatSessionError(
+                    "Cannot change the data model ID of a Cognite Data Model in NeatSession"
+                    " due to temporarily issue with the reverse direct relation interpretation"
+                )
+
             start = datetime.now(timezone.utc)
             transformer = SetIDDMSModel(new_model_id)
             output = transformer.transform(rules)
@@ -27,15 +34,16 @@ class SetAPI:
 
             # Provenance
             change = Change.from_rules_activity(
-                output,
+                output.rules,
                 transformer.agent,
                 start,
                 end,
                 "Changed data model id",
-                self._state.data_model.provenance.source_entity(source_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(output, change)
+            self._state.data_model.write(output.rules, change)
             if self._verbose:
                 print(f"Data model ID set to {new_model_id}")
         else:

cognite/neat/_session/_to.py

@@ -2,12 +2,14 @@ from pathlib import Path
 from typing import Any, Literal, overload
 
 from cognite.client import CogniteClient
+from cognite.client.data_classes.data_modeling import SpaceApply
 
 from cognite.neat._graph import loaders
 from cognite.neat._issues import IssueList, catch_warnings
 from cognite.neat._rules import exporters
-from cognite.neat._session._wizard import space_wizard
-from cognite.neat._utils.upload import UploadResultCore
+from cognite.neat._rules._constants import PATTERNS
+from cognite.neat._rules._shared import VerifiedRules
+from cognite.neat._utils.upload import UploadResultCore, UploadResultList
 
 from ._state import SessionState
 from .exceptions import NeatSessionError, intercept_session_exceptions
@@ -23,9 +25,24 @@ class ToAPI:
     def excel(
         self,
         io: Any,
+        model: Literal["dms", "information", "logical", "physical"] | None,
     ) -> None:
+        """Export the verified data model to Excel.
+
+        Args:
+            io: The file path or file-like object to write the Excel file to.
+            model: The format of the data model to export. Defaults to None.
+        """
         exporter = exporters.ExcelExporter()
-        exporter.export_to_file(self._state.data_model.last_verified_rule[1], Path(io))
+        rules: VerifiedRules
+        if model == "information" or model == "logical":
+            rules = self._state.data_model.last_verified_information_rules[1]
+        elif model == "dms" or model == "physical":
+            rules = self._state.data_model.last_verified_dms_rules[1]
+        else:
+            rules = self._state.data_model.last_verified_rule[1]
+
+        exporter.export_to_file(rules, Path(io))
         return None
 
     @overload
@@ -50,19 +67,29 @@ class CDFToAPI:
         self._state = state
         self._verbose = verbose
 
-    def instances(self, space: str | None = None):
+    def instances(self, space: str | None = None) -> UploadResultList:
         if not self._client:
             raise NeatSessionError("No CDF client provided!")
 
+        space = space or f"{self._state.data_model.last_verified_dms_rules[1].metadata.space}_instances"
+
+        if space and space == self._state.data_model.last_verified_dms_rules[1].metadata.space:
+            raise NeatSessionError("Space for instances must be different from the data model space.")
+        elif not PATTERNS.space_compliance.match(str(space)):
+            raise NeatSessionError("Please provide a valid space name. {PATTERNS.space_compliance.pattern}")
+
+        if not self._client.data_modeling.spaces.retrieve(space):
+            self._client.data_modeling.spaces.apply(SpaceApply(space=space))
+
         loader = loaders.DMSLoader.from_rules(
             self._state.data_model.last_verified_dms_rules[1],
             self._state.instances.store,
-            space_wizard(space=space),
+            instance_space=space,
         )
         result = loader.load_into_cdf(self._client)
         self._state.instances.outcome.append(result)
-        print("You can inspect the details with the .inspect.instances.outcome(...) method.")
-        return loader.load_into_cdf(self._client)
+        print("You can inspect the details with the .inspect.outcome.instances(...) method.")
+        return result
 
     def data_model(
         self,

cognite/neat/_utils/auth.py

@@ -41,7 +41,7 @@ def get_cognite_client(env_file_name: str) -> CogniteClient:
         with suppress(KeyError, FileNotFoundError, TypeError):
             variables = _from_dotenv(repo_root / env_file_name)
             client = variables.get_client()
-            print("Found .env file in repository root. Loaded variables from .env file.")
+            print(f"Found {env_file_name} file in repository root. Loaded variables from {env_file_name} file.")
             return client
     variables = _prompt_user()
     if repo_root and _env_in_gitignore(repo_root, env_file_name):
@@ -50,13 +50,14 @@ def get_cognite_client(env_file_name: str) -> CogniteClient:
 
         env_file = repo_root / env_file_name
         answer = Prompt.ask(
-            "Do you store the variables in an .env file in the repository root for easy reuse?", choices=["y", "n"]
+            f"Do you store the variables in an {env_file_name} file in the repository root for easy reuse?",
+            choices=["y", "n"],
         )
         if env_file.exists():
             answer = Prompt.ask(f"{env_file} already exists. Overwrite?", choices=["y", "n"])
         if answer == "y":
             env_file.write_text(variables.create_env_file())
-            print("Created .env file in repository root.")
+            print(f"Created {env_file_name} file in repository root.")
 
     return variables.get_client()
 

cognite/neat/_utils/upload.py

@@ -4,6 +4,7 @@ from functools import total_ordering
 from typing import Any, Generic
 
 from cognite.neat._issues import IssueList
+from cognite.neat._issues.errors import NeatValueError
 from cognite.neat._shared import T_ID, NeatList, NeatObject
 
 
@@ -110,3 +111,22 @@ class UploadResult(UploadResultCore, Generic[T_ID]):
                 continue
             lines.append(f"{key}: {value}")
         return f"{self.name.title()}: {', '.join(lines)}"
+
+    def merge(self, other: "UploadResult[T_ID]") -> "UploadResult[T_ID]":
+        if self.name != other.name:
+            raise NeatValueError(f"Cannot merge UploadResults with different names: {self.name} and {other.name}")
+        return UploadResult(
+            name=self.name,
+            error_messages=self.error_messages + other.error_messages,
+            issues=IssueList(self.issues + other.issues),
+            created=self.created.union(other.created),
+            upserted=self.upserted.union(other.upserted),
+            deleted=self.deleted.union(other.deleted),
+            changed=self.changed.union(other.changed),
+            unchanged=self.unchanged.union(other.unchanged),
+            skipped=self.skipped.union(other.skipped),
+            failed_created=self.failed_created.union(other.failed_created),
+            failed_upserted=self.failed_upserted.union(other.failed_upserted),
+            failed_changed=self.failed_changed.union(other.failed_changed),
+            failed_deleted=self.failed_deleted.union(other.failed_deleted),
+        )

cognite/neat/_version.py

@@ -1,2 +1,2 @@
-__version__ = "0.97.1"
+__version__ = "0.97.3"
 __engine__ = "^1.0.3"

{cognite_neat-0.97.1.dist-info → cognite_neat-0.97.3.dist-info}/METADATA

@@ -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.dist-info → cognite_neat-0.97.3.dist-info}/RECORD

@@ -101,11 +101,11 @@ cognite/neat/_graph/extractors/_iodd.py,sha256=nMSLmtgvxLrQJMA5NECF1OCp4Bcv0Vq0W
 cognite/neat/_graph/extractors/_mock_graph_generator.py,sha256=yEqQdbnRQjBXVQIEVGP_B_Gqu4qi_1koqpMjw8XRTA0,15409
 cognite/neat/_graph/extractors/_rdf_file.py,sha256=WHsVAtfRhMdtjTTN0et3pAFMm2PTCTyHOJgPSVqsqi4,1688
 cognite/neat/_graph/loaders/__init__.py,sha256=TbeJqifd16JLOglPVNOeb6pN_w060UYag50KquBM_r0,769
-cognite/neat/_graph/loaders/_base.py,sha256=ms_nntW7RKhO751yS2w9-zGIoAYDRecY9-RaE6Krrcw,3600
+cognite/neat/_graph/loaders/_base.py,sha256=tjplRd-vbWhWyys0Ll3KgHR3F3ETlP_dXJ3e8F8w15M,3984
 cognite/neat/_graph/loaders/_rdf2asset.py,sha256=OMfTVbVEx6yAUlds7c2mVcgnBV0Cq5DiQ7joW3-yy0Y,17525
-cognite/neat/_graph/loaders/_rdf2dms.py,sha256=oIpm35JMlb_VR38QZqpQo3TULU_c0aGqD1CrYEaEHyY,14977
+cognite/neat/_graph/loaders/_rdf2dms.py,sha256=kR5yjXS5VDHMUFff5WSTrZRqKSzX53SlEbcwHMVh8J8,15951
 cognite/neat/_graph/queries/__init__.py,sha256=BgDd-037kvtWwAoGAy8eORVNMiZ5-E9sIV0txIpeaN4,50
-cognite/neat/_graph/queries/_base.py,sha256=NuDG8H4wC7R4Py8kpgiWEbfAVZajV3L2ivaHDyYa8Iw,12714
+cognite/neat/_graph/queries/_base.py,sha256=FhRCUQ-jpVdtC6qdBWqTlh6JP29BigQJoyACkrr5bBM,13700
 cognite/neat/_graph/queries/_construct.py,sha256=CW8uHtXXACUXDj1AcEjROXtvoiuyx0CTgZ0bURY5Neo,7213
 cognite/neat/_graph/queries/_shared.py,sha256=K3svLkvw-DWPZUwIwpJRjPKg5UIRKFCn5jBLpuJjiHc,5330
 cognite/neat/_graph/transformers/__init__.py,sha256=CdlG9Bk--bLyO5S8jJOkOriZQwJtukXj7oRPXfKKJSY,984
@@ -115,11 +115,11 @@ cognite/neat/_graph/transformers/_iodd.py,sha256=yH-BvVQUswM8RmV2VvOPQAgwudhBJdx
 cognite/neat/_graph/transformers/_prune_graph.py,sha256=fWZ4sMBf3XqoYC5nOU75Gl6XwscRe-wGYT-GiBFmcK8,5277
 cognite/neat/_graph/transformers/_rdfpath.py,sha256=jTqrfoEn8cnQjM4u-d2rDo-VRvT9FJUzbWhMwXbk-WI,4157
 cognite/neat/_graph/transformers/_value_type.py,sha256=JorH-AgDXVZUkG_GCcwn51Mw0M2WIOV834t0kF_Nwvo,2614
-cognite/neat/_issues/__init__.py,sha256=BZu2sZ6SiAbvyzH4yGz87pAiVFpextgQCTPUx_Zti9E,480
-cognite/neat/_issues/_base.py,sha256=YH9wDnqzZjjzhduihFTPh4GxG-DB-eOvOlG4uzZ5DOA,17485
+cognite/neat/_issues/__init__.py,sha256=IEZBpvL88hdghX7JgndhxcZcxreZowuoQFIXuSeIKDs,556
+cognite/neat/_issues/_base.py,sha256=ks4-3bbholOw0VaacazbaX4ViMh0EcS6KPND_srLCbE,19180
 cognite/neat/_issues/errors/__init__.py,sha256=sOfHXOh9BfBEKoHFsneB5pCq5s7wJNhzwIEUKUr7HI4,2160
 cognite/neat/_issues/errors/_external.py,sha256=AuV2PyJcGjYxEnuwmi3zfYWPCF-yr4w39Uy0lQpeoqo,1619
-cognite/neat/_issues/errors/_general.py,sha256=Afsp2OpP8lb5J9JrEDLlBWtU36Mx9AxtKaDxTFqRVKs,808
+cognite/neat/_issues/errors/_general.py,sha256=zwEoaygHA2Nt9vCwiveDuzJsqZYIaX0BoUYkwJkQ4jU,844
 cognite/neat/_issues/errors/_properties.py,sha256=cr29pDs-Cc_kyRJjCk-9bS-HXV6naF27AOv3TSNbQdQ,2787
 cognite/neat/_issues/errors/_resources.py,sha256=SbiojpJ2J9Dk3NKRN0FoiN-vy14LXmEJCJM8xu_gTzQ,3964
 cognite/neat/_issues/errors/_workflow.py,sha256=m_Hlsvl5A1Oy7P3IROnz-4_do8_orZ1Pr1IHqsMyEys,971
@@ -177,7 +177,7 @@ cognite/neat/_rules/models/__init__.py,sha256=wB6Vo3hs9WRtQjHuXR_2HN4jot8ZJE0OiE
 cognite/neat/_rules/models/_base_input.py,sha256=qJrxobZLqpc28adEUJTKdJ8hDUZ67SVDFkUJnGjcPOc,6647
 cognite/neat/_rules/models/_base_rules.py,sha256=Yf4BE5XRSxFRbElrJcKzFwrGT_pOkT_mc_EKpr2-F1Q,13489
 cognite/neat/_rules/models/_rdfpath.py,sha256=hqUMZCMeI8ESdJltu7FifuUhna5JNN_Heup2aYkV56Y,11882
-cognite/neat/_rules/models/_types.py,sha256=jNzz7oO9uKIMqkjJ6kLEvRb83NERW0ZXURLvbPjgViA,4719
+cognite/neat/_rules/models/_types.py,sha256=6kljU9hREz1jllrBlIh7_jr-BLk6aUsINc-iDqPLKWI,5158
 cognite/neat/_rules/models/asset/__init__.py,sha256=Z2tQEABW-q66bmHNcxMuIxPmYQBcGdiSZt7fHGe01dQ,363
 cognite/neat/_rules/models/asset/_rules.py,sha256=KAGwnqvNcGGde6xaUElfkc3BxZZ6obzaqwXhZQ_CQ5o,4188
 cognite/neat/_rules/models/asset/_rules_input.py,sha256=rEiW460fwF-yXZLKF5HR-M0qOLLPmpaac0bJUm2t5TE,3597
@@ -188,7 +188,7 @@ cognite/neat/_rules/models/dms/_exporter.py,sha256=gCATniEtjhCOpofnY4jjTRnkm1s84
 cognite/neat/_rules/models/dms/_rules.py,sha256=3_cn4wIzQDwfSmIwCFRKDJLhvuXxUrz4ompDLtT3Fx0,21445
 cognite/neat/_rules/models/dms/_rules_input.py,sha256=8tOJ9XNX9qBW-PEKAyCJ1mvG1BgrEbJBk7VYTTKG_D0,11813
 cognite/neat/_rules/models/dms/_schema.py,sha256=HSmSDvOm5S0x4Vb9tH9Jvd5i9tXiiM08E_Sdu6q_iA8,50783
-cognite/neat/_rules/models/dms/_validation.py,sha256=LxufRBRUCqvO1yztbk01O5dcX4N4Elf75JHqxt6p8WM,18398
+cognite/neat/_rules/models/dms/_validation.py,sha256=63cS1troy3CBpfeIst0AtpKGYS1-IiZEbh_6Y8Pv3bQ,17256
 cognite/neat/_rules/models/domain.py,sha256=zzmurr1caPZaz6hoUwveCHlSM-bDf9Rt-S1m5HWOfRk,4295
 cognite/neat/_rules/models/entities/__init__.py,sha256=QD-h79HhjqCsgscNU5kuf1ieRCE94dOfpujLuzYbtHk,1469
 cognite/neat/_rules/models/entities/_constants.py,sha256=ToiLaaF-hGLPfn3AsKIIrfB4ZdTk4cY1RjM9gA1Qjkg,288
@@ -209,16 +209,16 @@ cognite/neat/_rules/transformers/_base.py,sha256=jmgcSFWOPvrbfme0kUwXi1_3Bvxwif1
 cognite/neat/_rules/transformers/_converters.py,sha256=DmUP7HKdjNRJ98Bis0s-leYK92a5eSbJMZdLH4HMZww,44141
 cognite/neat/_rules/transformers/_mapping.py,sha256=RWHKPMaP3JdeCNvoDGu9ZGHxfyeIgapYEBRoargnd2Q,6797
 cognite/neat/_rules/transformers/_pipelines.py,sha256=-E5Hgitnr6ee8R9_3sqtjmWIPJ0w1xaLErG6Fo6ExVU,2603
-cognite/neat/_rules/transformers/_verification.py,sha256=Jdy9dpjVxu5Hz__4phXU-44fWbKvL0vLWaq4gm5dVI8,4466
+cognite/neat/_rules/transformers/_verification.py,sha256=8p3cpVTfBkEeRLZSFJh_tby8ScRJodjSvrt2-_JBwQ4,2885
 cognite/neat/_session/__init__.py,sha256=fxQ5URVlUnmEGYyB8Baw7IDq-uYacqkigbc4b-Pr9Fw,58
-cognite/neat/_session/_base.py,sha256=LLCEHWrU9l8vUX2HptQtBPiFnDlZNWzMhrOJKshQCUc,7348
-cognite/neat/_session/_inspect.py,sha256=GoYrsyLkd7JSCZ21VAl5zIehhQ3-bXiV7zzyWSl3xaw,6488
-cognite/neat/_session/_prepare.py,sha256=AIJj28wCbZizbiCeE5wfB4RYZbyoc3bu6ESYgfb9AaY,9673
+cognite/neat/_session/_base.py,sha256=NHyESFlD3N1aUW6oJ3emuUSklopQUXeXblUk9-eje8U,8540
+cognite/neat/_session/_inspect.py,sha256=42mWP2GbQPxsM8-Xt-jY3_LHH0VNikkX8I2t1D_tj5I,7058
+cognite/neat/_session/_prepare.py,sha256=RnKetAX305PwdHQwOag1NHxmU1UTyAQMTAzQAw7MxLw,11219
 cognite/neat/_session/_read.py,sha256=d6O-ymlVx4o0mjKDIlrHOXiTOZxrdxhEX6mieLLETEI,9461
-cognite/neat/_session/_set.py,sha256=iSr086hrAOA8ctj2PlselDcHmkHsCDvcnr_OETjQN-A,1452
+cognite/neat/_session/_set.py,sha256=zNhHI-7WON3NUXCc1Ajo2ti8l5kPYmHeJ8MxJ_QLIJk,1927
 cognite/neat/_session/_show.py,sha256=-f1-f6vJKdpZODYuFv6TFmO1BuELUldfCqZqeLvr0NE,14161
 cognite/neat/_session/_state.py,sha256=rqKHkikagO1pf_fKpY-LZI1X5R_v6AyYpV72_3eSduM,5783
-cognite/neat/_session/_to.py,sha256=xq4cCyMWsbd7Oc55BxffGgUobMDT63jsToK2VTjNiDQ,3802
+cognite/neat/_session/_to.py,sha256=eMEw-25oGRJ-UFv57pCDUGtL_oNi4QharwhDl9DFu80,5181
 cognite/neat/_session/_wizard.py,sha256=Rdld2eZ-Q5BYbmAwW8FlfAYebdlw_P6L6V2WSDk-dHI,1306
 cognite/neat/_session/engine/__init__.py,sha256=aeI5pzljU5n1B-SVu3LwjYVsN1tSVhnJj-4ddflEo4U,120
 cognite/neat/_session/engine/_import.py,sha256=1QxA2_EK613lXYAHKQbZyw2yjo5P9XuiX4Z6_6-WMNQ,169
@@ -230,7 +230,7 @@ cognite/neat/_store/__init__.py,sha256=G-VG_YwfRt1kuPao07PDJyZ3w_0-eguzLUM13n-Z_
 cognite/neat/_store/_base.py,sha256=nKfXaQmtW535aDQZs_EIhFiBnghazZkeuyMen2THxm0,13611
 cognite/neat/_store/_provenance.py,sha256=cLOuZrIgb5mZwL1KvMeL0ODew92QyEvpri62CXhXz_w,8690
 cognite/neat/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite/neat/_utils/auth.py,sha256=hyDnVBUbbgVANzayxbh9uTWlYb924hmzPYkVwwLfDIg,13241
+cognite/neat/_utils/auth.py,sha256=UbFNq4BIqxc1459xJtI1FZz91K5XEMkfY5cfpBHyUHU,13301
 cognite/neat/_utils/auxiliary.py,sha256=kKPOPtwHj-RYerVCTQ_Rukn0Zkc6FNBhgQ1zOTAeRs8,5717
 cognite/neat/_utils/cdf/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/_utils/cdf/data_classes.py,sha256=XdPsHfmE3G-4o1AT_rNRiT916kWRoUpOMfgCyYjI0xU,10461
@@ -245,9 +245,9 @@ cognite/neat/_utils/reader/_base.py,sha256=PECrAlJqKDlyFzAlBBLfKjyOEyJSgN0sUfjbK
 cognite/neat/_utils/spreadsheet.py,sha256=LI0c7dlW0zXHkHw0NvB-gg6Df6cDcE3FbiaHBYLXdzQ,2714
 cognite/neat/_utils/text.py,sha256=PvTEsEjaTu8SE8yYaKUrce4msboMj933dK7-0Eey_rE,3652
 cognite/neat/_utils/time_.py,sha256=O30LUiDH9TdOYz8_a9pFqTtJdg8vEjC3qHCk8xZblG8,345
-cognite/neat/_utils/upload.py,sha256=qd8NA46fMvhCIDh66WNj8MiXv1ewDiFjvy59pSFkmG0,4604
+cognite/neat/_utils/upload.py,sha256=iWKmsQgw4EHLv-11NjYu7zAj5LtqTAfNa87a1kWeuaU,5727
 cognite/neat/_utils/xml_.py,sha256=FQkq84u35MUsnKcL6nTMJ9ajtG9D5i1u4VBnhGqP2DQ,1710
-cognite/neat/_version.py,sha256=obJ4L48mncYyAOX7r86bANjiuo8sNuMcnRMnXjUcUq8,45
+cognite/neat/_version.py,sha256=x_rAP_QXrbMfEieOF7mnEF3qFbN1SzK4mMGniMYJCAo,45
 cognite/neat/_workflows/__init__.py,sha256=S0fZq7kvoqDKodHu1UIPsqcpdvXoefUWRPt1lqeQkQs,420
 cognite/neat/_workflows/base.py,sha256=O1pcmfbme2gIVF2eOGrKZSUDmhZc8L9rI8UfvLN2YAM,26839
 cognite/neat/_workflows/cdf_store.py,sha256=3pebnATPo6In4-1srpa3wzstynTOi3T6hwFX5uaie4c,18050
@@ -276,8 +276,8 @@ cognite/neat/_workflows/tasks.py,sha256=dr2xuIb8P5e5e9p_fjzRlvDbKsre2xGYrkc3wnRx
 cognite/neat/_workflows/triggers.py,sha256=u69xOsaTtM8_WD6ZeIIBB-XKwvlZmPHAsZQh_TnyHcM,7073
 cognite/neat/_workflows/utils.py,sha256=gKdy3RLG7ctRhbCRwaDIWpL9Mi98zm56-d4jfHDqP1E,453
 cognite/neat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_neat-0.97.1.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.97.1.dist-info/METADATA,sha256=CUzzYAntpELjv-uak04D5lH33bYK_0wLI_uPoKjixOI,9657
-cognite_neat-0.97.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-cognite_neat-0.97.1.dist-info/entry_points.txt,sha256=SsQlnl8SNMSSjE3acBI835JYFtsIinLSbVmHmMEXv6E,51
-cognite_neat-0.97.1.dist-info/RECORD,,
+cognite_neat-0.97.3.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.97.3.dist-info/METADATA,sha256=ohCmVgNuYqPUXNKeJk9sFrE9yRuxwjbroUmNoUhLj-k,9657
+cognite_neat-0.97.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+cognite_neat-0.97.3.dist-info/entry_points.txt,sha256=SsQlnl8SNMSSjE3acBI835JYFtsIinLSbVmHmMEXv6E,51
+cognite_neat-0.97.3.dist-info/RECORD,,