cognite-neat 0.83.0__py3-none-any.whl → 0.84.1__py3-none-any.whl

cognite/neat/_shared.py

@@ -0,0 +1,35 @@
+from abc import abstractmethod
+from collections.abc import Hashable, Sequence
+from dataclasses import dataclass
+from typing import Any, TypeVar
+
+import pandas as pd
+
+T_ID = TypeVar("T_ID", bound=Hashable)
+
+
+@dataclass
+class NeatObject:
+    """A neat object can be dumped to a dictionary."""
+
+    @abstractmethod
+    def dump(self, aggregate: bool = True) -> dict[str, Any]:
+        """Return a dictionary representation of the object."""
+        raise NotImplementedError()
+
+
+T_NeatObject = TypeVar("T_NeatObject", bound=NeatObject)
+
+
+class NeatList(list, Sequence[T_NeatObject]):
+    """A list of neat objects."""
+
+    def dump(self) -> list[dict[str, Any]]:
+        """Return a list of dictionary representations of the objects."""
+        return [obj.dump() for obj in self]
+
+    def to_pandas(self) -> pd.DataFrame:
+        return pd.DataFrame(self.dump())
+
+    def _repr_html_(self) -> str:
+        return self.to_pandas()._repr_html_()  # type: ignore[operator]

cognite/neat/_version.py

@@ -1 +1 @@
-__version__ = "0.83.0"
+__version__ = "0.84.1"

cognite/neat/graph/loaders/_rdf2asset.py

@@ -0,0 +1,123 @@
+from collections.abc import Sequence
+from dataclasses import dataclass, fields
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes import AssetWrite
+
+from cognite.neat.graph._tracking.base import Tracker
+from cognite.neat.graph._tracking.log import LogTracker
+from cognite.neat.graph.stores import NeatGraphStore
+from cognite.neat.issues import NeatIssue, NeatIssueList
+from cognite.neat.rules.models import AssetRules
+
+from ._base import CDFLoader
+
+
+@dataclass(frozen=True)
+class AssetLoaderMetadataKeys:
+    """Class holding mapping between NEAT metadata key names and their desired names
+    in CDF Asset metadata
+
+    Args:
+        start_time: Start time key name
+        end_time: End time key name
+        update_time: Update time key name
+        resurrection_time: Resurrection time key name
+        identifier: Identifier key name
+        active: Active key name
+        type: Type key name
+    """
+
+    start_time: str = "start_time"
+    end_time: str = "end_time"
+    update_time: str = "update_time"
+    resurrection_time: str = "resurrection_time"
+    identifier: str = "identifier"
+    active: str = "active"
+    type: str = "type"
+
+    def as_aliases(self) -> dict[str, str]:
+        return {str(field.default): getattr(self, field.name) for field in fields(self)}
+
+
+class AssetLoader(CDFLoader[AssetWrite]):
+    def __init__(
+        self,
+        rules: AssetRules,
+        graph_store: NeatGraphStore,
+        data_set_id: int,
+        use_orphanage: bool = False,
+        use_labels: bool = False,
+        asset_external_id_prefix: str | None = None,
+        metadata_keys: AssetLoaderMetadataKeys | None = None,
+        create_issues: Sequence[NeatIssue] | None = None,
+        tracker: type[Tracker] | None = None,
+    ):
+        super().__init__(graph_store)
+
+        self.rules = rules
+        self.data_set_id = data_set_id
+        self.use_labels = use_labels
+        self.use_orphanage = use_orphanage
+
+        self.orphanage_external_id = (
+            f"{asset_external_id_prefix or ''}orphanage-{data_set_id}" if use_orphanage else None
+        )
+
+        self.asset_external_id_prefix = asset_external_id_prefix
+        self.metadata_keys = metadata_keys or AssetLoaderMetadataKeys()
+
+        self._issues = NeatIssueList[NeatIssue](create_issues or [])
+        self._tracker: type[Tracker] = tracker or LogTracker
+
+    @classmethod
+    def from_rules(
+        cls,
+        rules: AssetRules,
+        graph_store: NeatGraphStore,
+        data_set_id: int,
+        use_orphanage: bool = False,
+        use_labels: bool = False,
+        asset_external_id_prefix: str | None = None,
+        metadata_keys: AssetLoaderMetadataKeys | None = None,
+    ) -> "AssetLoader":
+        issues: list[NeatIssue] = []
+
+        return cls(
+            rules, graph_store, data_set_id, use_orphanage, use_labels, asset_external_id_prefix, metadata_keys, issues
+        )
+
+    def _create_validation_classes(self) -> None:
+        # need to get back class-property pairs where are definition of
+        # asset implementations, extend InformationRulesAnalysis make it generic
+
+        # by default if there is not explicitly stated external_id
+        # use rdf:type and drop the prefix
+
+        # based on those create pydantic model AssetDefinition
+        # which will have .to_asset_write()
+
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def categorize_assets(self, client: CogniteClient) -> None:
+        """Categorize assets to those to be created, updated, decommissioned, or resurrected"""
+
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    def load_to_cdf(self, client: CogniteClient, dry_run: bool = False) -> Sequence[AssetWrite]:
+        # generate assets
+        # check for circular asset hierarchy
+        # check for orphaned assets
+        # batch upsert of assets to CDF (otherwise we will hit the API rate limit)
+
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    @classmethod
+    def _check_for_circular_asset_hierarchy(cls, assets: list[AssetWrite]) -> None:
+        """Check for circular references in the asset rules"""
+        raise NotImplementedError("Not implemented yet, this is placeholder")
+
+    @classmethod
+    def _check_for_orphaned_assets(cls, assets: list[AssetWrite]) -> None:
+        """Check for circular references in the asset rules"""
+        raise NotImplementedError("Not implemented yet, this is placeholder")

cognite/neat/graph/loaders/_rdf2dms.py

@@ -34,14 +34,14 @@ class DMSLoader(CDFLoader[dm.InstanceApply]):
         data_model: dm.DataModel[dm.View] | None,
         instance_space: str,
         class_by_view_id: dict[ViewId, str] | None = None,
-        creat_issues: Sequence[NeatIssue] | None = None,
+        create_issues: Sequence[NeatIssue] | None = None,
         tracker: type[Tracker] | None = None,
     ):
         super().__init__(graph_store)
         self.data_model = data_model
         self.instance_space = instance_space
         self.class_by_view_id = class_by_view_id or {}
-        self._issues = NeatIssueList[NeatIssue](creat_issues or [])
+        self._issues = NeatIssueList[NeatIssue](create_issues or [])
         self._tracker: type[Tracker] = tracker or LogTracker
 
     @classmethod

cognite/neat/graph/stores/_base.py

@@ -14,8 +14,8 @@ from cognite.neat.graph.extractors import RdfFileExtractor, TripleExtractors
 from cognite.neat.graph.models import Triple
 from cognite.neat.graph.queries import Queries
 from cognite.neat.graph.transformers import Transformers
+from cognite.neat.rules.models import InformationRules
 from cognite.neat.rules.models.entities import ClassEntity
-from cognite.neat.rules.models.information import InformationRules
 from cognite.neat.utils.auxiliary import local_import
 
 from ._provenance import Change, Provenance
@@ -66,7 +66,8 @@ class NeatGraphStore:
 
     def add_rules(self, rules: InformationRules) -> None:
         """This method is used to add rules to the graph store and it is the only correct
-        way to add rules to the graph store, after the graph store has been initialized."""
+        way to add rules to the graph store, after the graph store has been initialized.
+        """
 
         self.rules = rules
         self.base_namespace = self.rules.metadata.namespace
@@ -169,7 +170,10 @@ class NeatGraphStore:
         # not yet developed
 
         if not self.rules:
-            warnings.warn("No rules found for the graph store, returning empty list.", stacklevel=2)
+            warnings.warn(
+                "No rules found for the graph store, returning empty list.",
+                stacklevel=2,
+            )
             return []
 
         class_entity = ClassEntity(prefix=self.rules.metadata.prefix, suffix=class_)

cognite/neat/rules/exporters/_base.py

@@ -7,7 +7,7 @@ from cognite.client import CogniteClient
 
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.models import DMSRules, InformationRules, RoleTypes
-from cognite.neat.utils.upload import UploadDiffsCount
+from cognite.neat.utils.upload import UploadResult, UploadResultList
 
 T_Export = TypeVar("T_Export")
 
@@ -37,5 +37,10 @@ class BaseExporter(ABC, Generic[T_Export]):
 
 class CDFExporter(BaseExporter[T_Export]):
     @abstractmethod
-    def export_to_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadDiffsCount]:
+    def export_to_cdf_iterable(
+        self, rules: Rules, client: CogniteClient, dry_run: bool = False
+    ) -> Iterable[UploadResult]:
         raise NotImplementedError
+
+    def export_to_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> UploadResultList:
+        return UploadResultList(self.export_to_cdf_iterable(rules, client, dry_run))

cognite/neat/rules/exporters/_rules2dms.py

@@ -1,5 +1,5 @@
 import warnings
-from collections.abc import Collection, Iterable
+from collections.abc import Collection, Hashable, Iterable, Sequence
 from pathlib import Path
 from typing import Literal, TypeAlias, cast
 
@@ -31,7 +31,7 @@ from cognite.neat.utils.cdf_loaders import (
     TransformationLoader,
     ViewLoader,
 )
-from cognite.neat.utils.upload import UploadDiffsCount
+from cognite.neat.utils.upload import UploadResult
 
 from ._base import CDFExporter
 
@@ -123,109 +123,84 @@ class DMSExporter(CDFExporter[DMSSchema]):
             raise ValueError(f"{type(rules).__name__} cannot be exported to DMS")
         return dms_rules.as_schema(include_pipeline=self.export_pipeline, instance_space=self.instance_space)
 
-    def delete_from_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadDiffsCount]:
-        schema, to_export = self._prepare_schema_and_exporters(rules, client)
+    def delete_from_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadResult]:
+        to_export = self._prepare_exporters(rules, client)
 
         # we need to reverse order in which we are picking up the items to delete
         # as they are sorted in the order of creation and we need to delete them in reverse order
-        for all_items, loader in reversed(to_export):
-            all_item_ids = loader.get_ids(all_items)
-            item_ids = [item_id for item_id in all_item_ids]
-            cdf_items = loader.retrieve(item_ids)
-            cdf_item_by_id = {loader.get_id(item): item for item in cdf_items}
-            items = [item for item in all_items if loader.get_id(item) in item_ids]
-            to_delete = []
-
-            for item in items:
+        for items, loader in reversed(to_export):
+            item_ids = loader.get_ids(items)
+            existing_items = loader.retrieve(item_ids)
+            existing_ids = loader.get_ids(existing_items)
+            to_delete: list[Hashable] = []
+            for item_id in item_ids:
                 if (
                     isinstance(loader, DataModelingLoader)
                     and self.include_space is not None
-                    and not loader.in_space(item, self.include_space)
+                    and not loader.in_space(item_id, self.include_space)
                 ):
                     continue
 
-                cdf_item = cdf_item_by_id.get(loader.get_id(item))
-                if cdf_item:
-                    to_delete.append(cdf_item)
-
-            deleted = len(to_delete)
-            failed_deleted = 0
+                if item_id in existing_ids:
+                    to_delete.append(item_id)
 
+            deleted: set[Hashable] = set()
+            failed_deleted: set[Hashable] = set()
             error_messages: list[str] = []
-            if not dry_run:
-                if to_delete:
-                    try:
-                        loader.delete(to_delete)
-                    except CogniteAPIError as e:
-                        failed_deleted = len(e.failed) + len(e.unknown)
-                        deleted -= failed_deleted
-                        error_messages.append(f"Failed delete: {e.message}")
+            if dry_run:
+                deleted.update(to_delete)
+            elif to_delete:
+                try:
+                    loader.delete(to_delete)
+                except CogniteAPIError as e:
+                    failed_deleted.update(loader.get_id(item) for item in e.failed + e.unknown)
+                    deleted.update(loader.get_id(item) for item in e.successful)
+                    error_messages.append(f"Failed delete: {e.message}")
+                else:
+                    deleted.update(to_delete)
 
-            yield UploadDiffsCount(
+            yield UploadResult(
                 name=loader.resource_name,
                 deleted=deleted,
-                skipped=0,
                 failed_deleted=failed_deleted,
                 error_messages=error_messages,
             )
 
-    def export_to_cdf(self, rules: Rules, client: CogniteClient, dry_run: bool = False) -> Iterable[UploadDiffsCount]:
-        schema, to_export = self._prepare_schema_and_exporters(rules, client)
+    def export_to_cdf_iterable(
+        self, rules: Rules, client: CogniteClient, dry_run: bool = False
+    ) -> Iterable[UploadResult]:
+        to_export = self._prepare_exporters(rules, client)
 
-        # The conversion from DMS to GraphQL does not seem to be triggered even if the views
-        # are changed. This is a workaround to force the conversion.
         redeploy_data_model = False
+        for items, loader in to_export:
+            # The conversion from DMS to GraphQL does not seem to be triggered even if the views
+            # are changed. This is a workaround to force the conversion.
+            is_redeploying = loader is DataModelingLoader and redeploy_data_model
 
-        for all_items, loader in to_export:
-            issue_list = IssueList()
-            all_item_ids = loader.get_ids(all_items)
-            item_ids = [item_id for item_id in all_item_ids]
-            cdf_items = loader.retrieve(item_ids)
-            cdf_item_by_id = {loader.get_id(item): item for item in cdf_items}
-            items = [item for item in all_items if loader.get_id(item) in item_ids]
-            to_create, to_update, unchanged, to_delete = [], [], [], []
-            is_redeploying = loader.resource_name == "data_models" and redeploy_data_model
-            for item in items:
-                if (
-                    isinstance(loader, DataModelingLoader)
-                    and self.include_space is not None
-                    and not loader.in_space(item, self.include_space)
-                ):
-                    continue
-
-                cdf_item = cdf_item_by_id.get(loader.get_id(item))
-                if cdf_item is None:
-                    to_create.append(item)
-                elif is_redeploying:
-                    to_update.append(item)
-                    to_delete.append(cdf_item)
-                elif loader.are_equal(item, cdf_item):
-                    unchanged.append(item)
-                else:
-                    to_update.append(item)
-
-            created = len(to_create)
-            failed_created = 0
-            skipped = 0
-
-            if self.existing_handling in ["update", "force"]:
-                changed = len(to_update)
-                failed_changed = 0
-            elif self.existing_handling == "skip":
-                changed = 0
-                failed_changed = 0
-                skipped += len(to_update)
-            elif self.existing_handling == "fail":
-                failed_changed = len(to_update)
-                changed = 0
-            else:
-                raise ValueError(f"Unsupported existing_handling {self.existing_handling}")
+            to_create, to_delete, to_update, unchanged = self._categorize_items_for_upload(
+                loader, items, is_redeploying
+            )
 
+            issue_list = IssueList()
             warning_list = self._validate(loader, items)
             issue_list.extend(warning_list)
 
+            created: set[Hashable] = set()
+            skipped: set[Hashable] = set()
+            changed: set[Hashable] = set()
+            failed_created: set[Hashable] = set()
+            failed_changed: set[Hashable] = set()
             error_messages: list[str] = []
-            if not dry_run:
+            if dry_run:
+                if self.existing_handling in ["update", "force"]:
+                    changed.update(loader.get_id(item) for item in to_update)
+                elif self.existing_handling == "skip":
+                    skipped.update(loader.get_id(item) for item in to_update)
+                elif self.existing_handling == "fail":
+                    failed_changed.update(loader.get_id(item) for item in to_update)
+                else:
+                    raise ValueError(f"Unsupported existing_handling {self.existing_handling}")
+            else:
                 if to_delete:
                     try:
                         loader.delete(to_delete)
@@ -238,23 +213,31 @@ class DMSExporter(CDFExporter[DMSSchema]):
                 try:
                     loader.create(to_create)
                 except CogniteAPIError as e:
-                    failed_created = len(e.failed) + len(e.unknown)
-                    created -= failed_created
+                    failed_created.update(loader.get_id(item) for item in e.failed + e.unknown)
+                    created.update(loader.get_id(item) for item in e.successful)
                     error_messages.append(e.message)
+                else:
+                    created.update(loader.get_id(item) for item in to_create)
 
                 if self.existing_handling in ["update", "force"]:
                     try:
                         loader.update(to_update)
                     except CogniteAPIError as e:
-                        failed_changed = len(e.failed) + len(e.unknown)
-                        changed -= failed_changed
+                        failed_changed.update(loader.get_id(item) for item in e.failed + e.unknown)
+                        changed.update(loader.get_id(item) for item in e.successful)
                         error_messages.append(e.message)
-
-            yield UploadDiffsCount(
+                    else:
+                        changed.update(loader.get_id(item) for item in to_update)
+                elif self.existing_handling == "skip":
+                    skipped.update(loader.get_id(item) for item in to_update)
+                elif self.existing_handling == "fail":
+                    failed_changed.update(loader.get_id(item) for item in to_update)
+
+            yield UploadResult(
                 name=loader.resource_name,
                 created=created,
                 changed=changed,
-                unchanged=len(unchanged),
+                unchanged={loader.get_id(item) for item in unchanged},
                 skipped=skipped,
                 failed_created=failed_created,
                 failed_changed=failed_changed,
@@ -262,12 +245,37 @@ class DMSExporter(CDFExporter[DMSSchema]):
                 issues=issue_list,
             )
 
-            if loader.resource_name == "views" and (created or changed) and not redeploy_data_model:
+            if loader is ViewLoader and (created or changed):
                 redeploy_data_model = True
 
-    def _prepare_schema_and_exporters(
-        self, rules, client
-    ) -> tuple[DMSSchema, list[tuple[CogniteResourceList, ResourceLoader]]]:
+    def _categorize_items_for_upload(
+        self, loader: ResourceLoader, items: Sequence[CogniteResource], is_redeploying
+    ) -> tuple[list[CogniteResource], list[CogniteResource], list[CogniteResource], list[CogniteResource]]:
+        item_ids = loader.get_ids(items)
+        cdf_items = loader.retrieve(item_ids)
+        cdf_item_by_id = {loader.get_id(item): item for item in cdf_items}
+        to_create, to_update, unchanged, to_delete = [], [], [], []
+        for item in items:
+            if (
+                isinstance(loader, DataModelingLoader)
+                and self.include_space is not None
+                and not loader.in_space(item, self.include_space)
+            ):
+                continue
+
+            cdf_item = cdf_item_by_id.get(loader.get_id(item))
+            if cdf_item is None:
+                to_create.append(item)
+            elif is_redeploying:
+                to_update.append(item)
+                to_delete.append(cdf_item)
+            elif loader.are_equal(item, cdf_item):
+                unchanged.append(item)
+            else:
+                to_update.append(item)
+        return to_create, to_delete, to_update, unchanged
+
+    def _prepare_exporters(self, rules, client) -> list[tuple[CogniteResourceList, ResourceLoader]]:
         schema = self.export(rules)
         to_export: list[tuple[CogniteResourceList, ResourceLoader]] = []
         if self.export_components.intersection({"all", "spaces"}):
@@ -282,9 +290,9 @@ class DMSExporter(CDFExporter[DMSSchema]):
             to_export.append((schema.databases, RawDatabaseLoader(client)))
             to_export.append((schema.raw_tables, RawTableLoader(client)))
             to_export.append((schema.transformations, TransformationLoader(client)))
-        return schema, to_export
+        return to_export
 
-    def _validate(self, loader: ResourceLoader, items: list[CogniteResource]) -> IssueList:
+    def _validate(self, loader: ResourceLoader, items: CogniteResourceList) -> IssueList:
         issue_list = IssueList()
         if isinstance(loader, DataModelLoader):
             models = cast(list[DataModelApply], items)

cognite/neat/rules/importers/_base.py

@@ -11,7 +11,7 @@ from rdflib import Namespace
 
 from cognite.neat.rules._shared import Rules
 from cognite.neat.rules.issues.base import IssueList, NeatValidationError, ValidationWarning
-from cognite.neat.rules.models import DMSRules, InformationRules, RoleTypes
+from cognite.neat.rules.models import AssetRules, DMSRules, InformationRules, RoleTypes
 
 
 class BaseImporter(ABC):
@@ -48,9 +48,9 @@ class BaseImporter(ABC):
 
         if rules.metadata.role is role or role is None:
             output = rules
-        elif isinstance(rules, DMSRules) and role is RoleTypes.information_architect:
+        elif isinstance(rules, DMSRules) or isinstance(rules, AssetRules) and role is RoleTypes.information_architect:
             output = rules.as_information_architect_rules()
-        elif isinstance(rules, InformationRules) and role is RoleTypes.dms_architect:
+        elif isinstance(rules, InformationRules) or isinstance(rules, AssetRules) and role is RoleTypes.dms_architect:
             output = rules.as_dms_architect_rules()
         else:
             raise NotImplementedError(f"Role {role} is not supported for {type(rules).__name__} rules")

cognite/neat/rules/models/_rdfpath.py

@@ -6,7 +6,7 @@ from collections import Counter
 from functools import total_ordering
 from typing import ClassVar, Literal
 
-from pydantic import BaseModel, field_validator
+from pydantic import BaseModel, field_validator, model_serializer
 
 from cognite.neat.rules import exceptions
 
@@ -82,6 +82,7 @@ TABLE_REGEX_COMPILED = re.compile(
 
 StepDirection = Literal["source", "target", "origin"]
 _direction_by_symbol: dict[str, StepDirection] = {"->": "target", "<-": "source"}
+_symbol_by_direction: dict[StepDirection, str] = {"source": "<-", "target": "->"}
 
 Undefined = type(object())
 Unknown = type(object())
@@ -196,10 +197,29 @@ class Step(BaseModel):
         msg += " ->prefix:suffix, <-prefix:suffix, ->prefix:suffix(prefix:suffix) or <-prefix:suffix(prefix:suffix)"
         raise ValueError(msg)
 
+    def __str__(self) -> str:
+        if self.property:
+            return f"{self.class_}({self.property})"
+        else:
+            return f"{_symbol_by_direction[self.direction]}{self.class_}"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
 
 class Traversal(BaseModel):
     class_: Entity
 
+    def __str__(self) -> str:
+        return f"{self.class_}"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    @model_serializer(when_used="unless-none", return_type=str)
+    def as_str(self) -> str:
+        return str(self)
+
 
 class SingleProperty(Traversal):
     property: Entity
@@ -208,6 +228,9 @@ class SingleProperty(Traversal):
     def from_string(cls, class_: str, property_: str) -> Self:
         return cls(class_=Entity.from_string(class_), property=Entity.from_string(property_))
 
+    def __str__(self) -> str:
+        return f"{self.class_}({self.property})"
+
 
 class AllReferences(Traversal):
     @classmethod
@@ -220,6 +243,9 @@ class AllProperties(Traversal):
     def from_string(cls, class_: str) -> Self:
         return cls(class_=Entity.from_string(class_))
 
+    def __str__(self) -> str:
+        return f"{self.class_}(*)"
+
 
 class Origin(BaseModel):
     class_: Entity
@@ -245,6 +271,9 @@ class Hop(Traversal):
             ),
         )
 
+    def __str__(self) -> str:
+        return f"{self.class_}{''.join([str(step) for step in self.traversal])}"
+
 
 class TableLookup(BaseModel):
     name: str
@@ -261,7 +290,17 @@ class Query(BaseModel):
 
 
 class RDFPath(Rule):
-    traversal: Traversal | Query
+    traversal: SingleProperty | AllProperties | AllReferences | Hop
+
+    def __str__(self) -> str:
+        return f"{self.traversal}"
+
+    def __repr__(self) -> str:
+        return self.__str__()
+
+    @model_serializer(when_used="unless-none", return_type=str)
+    def as_str(self) -> str:
+        return str(self)
 
 
 class RawLookup(RDFPath):

cognite/neat/rules/models/asset/_rules.py

@@ -148,9 +148,12 @@ class AssetRules(BaseRules):
     def as_domain_rules(self) -> DomainRules:
         from ._converter import _AssetRulesConverter
 
-        return _AssetRulesConverter(cast(InformationRules, self)).as_domain_rules()
+        return _AssetRulesConverter(self.as_information_architect_rules()).as_domain_rules()
 
     def as_dms_architect_rules(self) -> "DMSRules":
         from ._converter import _AssetRulesConverter
 
-        return _AssetRulesConverter(cast(InformationRules, self)).as_dms_architect_rules()
+        return _AssetRulesConverter(self.as_information_architect_rules()).as_dms_architect_rules()
+
+    def as_information_architect_rules(self) -> InformationRules:
+        return InformationRules.model_validate(self.model_dump())

cognite/neat/rules/models/information/_converter.py

@@ -16,11 +16,15 @@ from cognite.neat.rules.models._constants import DMS_CONTAINER_SIZE_LIMIT
 from cognite.neat.rules.models.data_types import DataType
 from cognite.neat.rules.models.domain import DomainRules
 from cognite.neat.rules.models.entities import (
+    AssetEntity,
+    AssetFields,
     ClassEntity,
     ContainerEntity,
     DMSUnknownEntity,
+    EntityTypes,
     MultiValueTypeInfo,
     ReferenceEntity,
+    RelationshipEntity,
     UnknownEntity,
     ViewEntity,
     ViewPropertyEntity,
@@ -29,6 +33,7 @@ from cognite.neat.rules.models.entities import (
 from ._rules import InformationClass, InformationMetadata, InformationProperty, InformationRules
 
 if TYPE_CHECKING:
+    from cognite.neat.rules.models.asset._rules import AssetRules
     from cognite.neat.rules.models.dms._rules import DMSMetadata, DMSProperty, DMSRules
 
 
@@ -52,6 +57,28 @@ class _InformationRulesConverter:
     def as_domain_rules(self) -> DomainRules:
         raise NotImplementedError("DomainRules not implemented yet")
 
+    def as_asset_architect_rules(self) -> "AssetRules":
+        from cognite.neat.rules.models.asset._rules import AssetClass, AssetMetadata, AssetProperty, AssetRules
+
+        classes: SheetList[AssetClass] = SheetList[AssetClass](
+            data=[AssetClass(**class_.model_dump()) for class_ in self.rules.classes]
+        )
+        properties: SheetList[AssetProperty] = SheetList[AssetProperty]()
+        for prop_ in self.rules.properties:
+            if prop_.type_ == EntityTypes.data_property:
+                properties.append(
+                    AssetProperty(**prop_.model_dump(), implementation=[AssetEntity(property=AssetFields.metadata)])
+                )
+            elif prop_.type_ == EntityTypes.object_property:
+                properties.append(AssetProperty(**prop_.model_dump(), implementation=[RelationshipEntity()]))
+
+        return AssetRules(
+            metadata=AssetMetadata(**self.rules.metadata.model_dump()),
+            properties=properties,
+            classes=classes,
+            prefixes=self.rules.prefixes,
+        )
+
     def as_dms_architect_rules(self) -> "DMSRules":
         from cognite.neat.rules.models.dms._rules import (
             DMSContainer,

cognite/neat/rules/models/information/_rules.py

@@ -49,7 +49,7 @@ from cognite.neat.rules.models.entities import (
 )
 
 if TYPE_CHECKING:
-    from cognite.neat.rules.models.dms._rules import DMSRules
+    from cognite.neat.rules.models import AssetRules, DMSRules
 
 
 if sys.version_info >= (3, 11):
@@ -341,6 +341,11 @@ class InformationRules(BaseRules):
 
         return _InformationRulesConverter(self).as_domain_rules()
 
+    def as_asset_architect_rules(self) -> "AssetRules":
+        from ._converter import _InformationRulesConverter
+
+        return _InformationRulesConverter(self).as_asset_architect_rules()
+
     def as_dms_architect_rules(self) -> "DMSRules":
         from ._converter import _InformationRulesConverter
 

cognite/neat/utils/cdf_loaders/_base.py

@@ -9,18 +9,10 @@ from cognite.client.data_classes._base import (
     T_WriteClass,
     WriteableCogniteResourceList,
 )
-from cognite.client.data_classes.data_modeling import (
-    DataModelingId,
-)
-from cognite.client.data_classes.data_modeling.ids import (
-    InstanceId,
-    VersionedDataModelingId,
-)
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from .data_classes import RawTableID
+from cognite.neat._shared import T_ID
 
-T_ID = TypeVar("T_ID", bound=str | int | DataModelingId | InstanceId | VersionedDataModelingId | RawTableID)
 T_WritableCogniteResourceList = TypeVar("T_WritableCogniteResourceList", bound=WriteableCogniteResourceList)
 
 

cognite/neat/utils/cdf_loaders/_data_modeling.py

@@ -41,7 +41,8 @@ from ._base import T_ID, ResourceLoader, T_WritableCogniteResourceList
 class DataModelingLoader(
     ResourceLoader[T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList]
 ):
-    def in_space(self, item: T_WriteClass | T_WritableCogniteResource, space: set[str]) -> bool:
+    @classmethod
+    def in_space(cls, item: T_WriteClass | T_WritableCogniteResource | T_ID, space: set[str]) -> bool:
         if hasattr(item, "space"):
             return item.space in space
         raise ValueError(f"Item {item} does not have a space attribute")

cognite/neat/utils/upload.py

@@ -1,69 +1,89 @@
 from abc import ABC
 from dataclasses import dataclass, field
 from functools import total_ordering
+from typing import Any, Generic
 
+from cognite.neat._shared import T_ID, NeatList, NeatObject
 from cognite.neat.issues import NeatIssueList
 
 
 @total_ordering
 @dataclass
-class UploadResultCore(ABC):
+class UploadResultCore(NeatObject, ABC):
     name: str
     error_messages: list[str] = field(default_factory=list)
     issues: NeatIssueList = field(default_factory=NeatIssueList)
 
     def __lt__(self, other: object) -> bool:
-        if isinstance(other, UploadDiffsCount):
+        if isinstance(other, UploadResultCore):
             return self.name < other.name
         else:
             return NotImplemented
 
     def __eq__(self, other: object) -> bool:
-        if isinstance(other, UploadDiffsCount):
+        if isinstance(other, UploadResultCore):
             return self.name == other.name
         else:
             return NotImplemented
 
+    def dump(self, aggregate: bool = True) -> dict[str, Any]:
+        return {"name": self.name}
+
+
+class UploadResultList(NeatList[UploadResultCore]): ...
+
 
 @dataclass
-class UploadDiffsCount(UploadResultCore):
-    created: int = 0
-    deleted: int = 0
-    changed: int = 0
-    unchanged: int = 0
-    skipped: int = 0
-    failed_created: int = 0
-    failed_changed: int = 0
-    failed_deleted: int = 0
+class UploadResult(UploadResultCore, Generic[T_ID]):
+    created: set[T_ID] = field(default_factory=set)
+    deleted: set[T_ID] = field(default_factory=set)
+    changed: set[T_ID] = field(default_factory=set)
+    unchanged: set[T_ID] = field(default_factory=set)
+    skipped: set[T_ID] = field(default_factory=set)
+    failed_created: set[T_ID] = field(default_factory=set)
+    failed_changed: set[T_ID] = field(default_factory=set)
+    failed_deleted: set[T_ID] = field(default_factory=set)
 
     @property
-    def total(self) -> int:
-        return self.created + self.deleted + self.changed + self.unchanged
+    def failed(self) -> int:
+        return len(self.failed_created) + len(self.failed_changed) + len(self.failed_deleted)
 
     @property
-    def failed(self) -> int:
-        return self.failed_created + self.failed_changed + self.failed_deleted
+    def total(self) -> int:
+        return len(self.created) + len(self.deleted) + len(self.changed) + len(self.unchanged) + len(self.skipped)
 
-    def as_report_str(self) -> str:
-        line = []
+    def dump(self, aggregate: bool = True) -> dict[str, Any]:
+        output = super().dump(aggregate)
         if self.created:
-            line.append(f"created {self.created}")
+            output["created"] = len(self.created) if aggregate else list(self.created)
+        if self.deleted:
+            output["deleted"] = len(self.deleted) if aggregate else list(self.deleted)
         if self.changed:
-            line.append(f"updated {self.changed}")
-        if self.skipped:
-            line.append(f"skipped {self.skipped}")
+            output["changed"] = len(self.changed) if aggregate else list(self.changed)
         if self.unchanged:
-            line.append(f"unchanged {self.unchanged}")
-        if self.deleted:
-            line.append(f"deleted {self.deleted}")
+            output["unchanged"] = len(self.unchanged) if aggregate else list(self.unchanged)
+        if self.skipped:
+            output["skipped"] = len(self.skipped) if aggregate else list(self.skipped)
         if self.failed_created:
-            line.append(f"failed to create {self.failed_created}")
+            output["failed_created"] = len(self.failed_created) if aggregate else list(self.failed_created)
         if self.failed_changed:
-            line.append(f"failed to update {self.failed_changed}")
+            output["failed_changed"] = len(self.failed_changed) if aggregate else list(self.failed_changed)
         if self.failed_deleted:
-            line.append(f"failed to delete {self.failed_deleted}")
-
-        return f"{self.name.title()}: {', '.join(line)}"
+            output["failed_deleted"] = len(self.failed_deleted) if aggregate else list(self.failed_deleted)
+        if self.error_messages:
+            output["error_messages"] = len(self.error_messages) if aggregate else self.error_messages
+        if self.issues:
+            output["issues"] = len(self.issues) if aggregate else [issue.dump() for issue in self.issues]
+        return output
+
+    def __str__(self) -> str:
+        dumped = self.dump(aggregate=True)
+        lines: list[str] = []
+        for key, value in dumped.items():
+            if key in ["name", "error_messages", "issues"]:
+                continue
+            lines.append(f"{key}: {value}")
+        return f"{self.name.title()}: {', '.join(lines)}"
 
 
 @dataclass
@@ -71,6 +91,14 @@ class UploadResultIDs(UploadResultCore):
     success: list[str] = field(default_factory=list)
     failed: list[str] = field(default_factory=list)
 
+    def dump(self, aggregate: bool = True) -> dict[str, Any]:
+        output = super().dump(aggregate)
+        if self.success:
+            output["success"] = len(self.success) if aggregate else self.success
+        if self.failed:
+            output["failed"] = len(self.failed) if aggregate else self.failed
+        return output
+
 
 @dataclass
 class UploadDiffsID(UploadResultCore):
@@ -84,3 +112,15 @@ class UploadDiffsID(UploadResultCore):
         result.success = self.created + self.changed + self.unchanged
         result.failed = self.failed
         return result
+
+    def dump(self, aggregate: bool = True) -> dict[str, Any]:
+        output = super().dump(aggregate)
+        if self.created:
+            output["created"] = len(self.created) if aggregate else self.created
+        if self.changed:
+            output["changed"] = len(self.changed) if aggregate else self.changed
+        if self.unchanged:
+            output["unchanged"] = len(self.unchanged) if aggregate else self.unchanged
+        if self.failed:
+            output["failed"] = len(self.failed) if aggregate else self.failed
+        return output

cognite/neat/workflows/steps/lib/current/rules_exporter.py

@@ -95,7 +95,7 @@ class DeleteDataModelFromCDF(Step):
         report_lines = ["# Data Model Deletion from CDF\n\n"]
         errors = []
         for result in dms_exporter.delete_from_cdf(rules=input_rules, client=cdf_client, dry_run=dry_run):
-            report_lines.append(result.as_report_str())
+            report_lines.append(str(result))
             errors.extend(result.error_messages)
 
         report_lines.append("\n\n# ERRORS\n\n")
@@ -216,8 +216,8 @@ class RulesToDMS(Step):
 
         report_lines = ["# DMS Schema Export to CDF\n\n"]
         errors = []
-        for result in dms_exporter.export_to_cdf(rules=input_rules, client=cdf_client, dry_run=dry_run):
-            report_lines.append(result.as_report_str())
+        for result in dms_exporter.export_to_cdf_iterable(rules=input_rules, client=cdf_client, dry_run=dry_run):
+            report_lines.append(str(result))
             errors.extend(result.error_messages)
 
         report_lines.append("\n\n# ERRORS\n\n")
@@ -555,8 +555,8 @@ class RulesToCDFTransformations(Step):
 
         report_lines = ["# DMS Schema Export to CDF\n\n"]
         errors = []
-        for result in dms_exporter.export_to_cdf(rules=input_rules, client=cdf_client, dry_run=dry_run):
-            report_lines.append(result.as_report_str())
+        for result in dms_exporter.export_to_cdf_iterable(rules=input_rules, client=cdf_client, dry_run=dry_run):
+            report_lines.append(str(result))
             errors.extend(result.error_messages)
 
         report_lines.append("\n\n# ERRORS\n\n")

{cognite_neat-0.83.0.dist-info → cognite_neat-0.84.1.dist-info}/METADATA

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

{cognite_neat-0.83.0.dist-info → cognite_neat-0.84.1.dist-info}/RECORD

@@ -1,5 +1,6 @@
 cognite/neat/__init__.py,sha256=v-rRiDOgZ3sQSMQKq0vgUQZvpeOkoHFXissAx6Ktg84,61
-cognite/neat/_version.py,sha256=FwfsRG64Uncan1BBCrMrXMKjMO1MhfWoBbdMOZk1GnU,23
+cognite/neat/_shared.py,sha256=afQiTM0SvIKqeBRTvpfwwIvZL7QMQevt4F7lqRagAFg,968
+cognite/neat/_version.py,sha256=V73U5VqNMlTo-QuWNLjECQI8_59YjD0cHrTa5BEP1lg,23
 cognite/neat/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite/neat/app/api/asgi/metrics.py,sha256=nxFy7L5cChTI0a-zkCiJ59Aq8yLuIJp5c9Dg0wRXtV0,152
 cognite/neat/app/api/configuration.py,sha256=2U5M6M252swvQPQyooA1EBzFUZNtcTmuSaywfJDgckM,4232
@@ -70,14 +71,15 @@ cognite/neat/graph/issues/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 cognite/neat/graph/issues/loader.py,sha256=v8YDsehkUT1QUG61JM9BDV_lqowMUnDmGmbay0aFzN4,3085
 cognite/neat/graph/loaders/__init__.py,sha256=hHC9sfFfbnGSVFTYeuNTIEu4tdLSJ2mWV07fereLelo,125
 cognite/neat/graph/loaders/_base.py,sha256=bdYC6CwsHVqnQa1QzOhL68qQhF1OtrsearqH6D-z3E4,4037
-cognite/neat/graph/loaders/_rdf2dms.py,sha256=6B3fdsaygSOYClq5vgNPMF4HJkO_Xt1OlrrbTsU0Bdc,12989
+cognite/neat/graph/loaders/_rdf2asset.py,sha256=aFby7BwIrW253LEJ4XqGeUuf4jG9VUe8Lg7OlUnXMlM,4493
+cognite/neat/graph/loaders/_rdf2dms.py,sha256=ZijbUsKOT01LBmTxsCgTw6lW65ysyxYe5aGOzD1l_r0,12991
 cognite/neat/graph/models.py,sha256=AtLgZh2qyRP6NRetjQCy9qLMuTQB0CH52Zsev-qa2sk,149
 cognite/neat/graph/queries/__init__.py,sha256=BgDd-037kvtWwAoGAy8eORVNMiZ5-E9sIV0txIpeaN4,50
 cognite/neat/graph/queries/_base.py,sha256=20A7GDBdmc35VmHVz5n0YCGPcnBAmUX-bM2ImHPManc,3844
 cognite/neat/graph/queries/_construct.py,sha256=FxzSQqzCpo7lKVYerlLAY03oqCeFM5L6MozfBUblzr4,7341
 cognite/neat/graph/queries/_shared.py,sha256=EwW2RbPttt7-z7QTgfKWlthA2Nq5d3bYyyewFkCA7R4,5043
 cognite/neat/graph/stores/__init__.py,sha256=G-VG_YwfRt1kuPao07PDJyZ3w_0-eguzLUM13n-Z_RA,64
-cognite/neat/graph/stores/_base.py,sha256=b4qidXCl9190LrvLXTms2lDqv1ErwvvcGzQkY6mU9hI,10096
+cognite/neat/graph/stores/_base.py,sha256=7NnJUh7SQ1lDfJruOgKWc2IesT1DC81Yi6Xqp44RFwM,10140
 cognite/neat/graph/stores/_oxrdflib.py,sha256=A5zeRm5_e8ui_ihGpgstRDg_N7qcLZ3QZBRGrOXSGI0,9569
 cognite/neat/graph/stores/_provenance.py,sha256=Hr9WBhFj-eoet4czL8XSBGYnu9Yn66YsTgH_G0n3QpY,3293
 cognite/neat/graph/transformers/__init__.py,sha256=wXrNSyJNGnis3haaCKVPZ5y5kKSUsOUHnh-860ekatk,555
@@ -187,14 +189,14 @@ cognite/neat/rules/examples/__init__.py,sha256=nxIwueAcHgZhkYriGxnDLQmIyiT8PByPH
 cognite/neat/rules/examples/wind-energy.owl,sha256=NuomCA9FuuLF0JlSuG3OKqD4VBcHgSjDKFLV17G1zV8,65934
 cognite/neat/rules/exceptions.py,sha256=YLnsbXXJdDSr_szQoioEtOdqDV8PR7RdQjpMP2SWeCs,123868
 cognite/neat/rules/exporters/__init__.py,sha256=Gn3CjkVKHJF9Po1ZPH4wAJ-sRW9up7b2CpXm-eReV3Q,413
-cognite/neat/rules/exporters/_base.py,sha256=3eLIzZ3ddVVQGV7qQn-hKV0U_lPMBQzC4AblTKYzaEA,1535
-cognite/neat/rules/exporters/_rules2dms.py,sha256=e9veycUKfZ5NFDC_ar08hNd-LWrZAva_bRFa9VfI8AA,13725
+cognite/neat/rules/exporters/_base.py,sha256=TkdpmliKjKVDITBAE4ySq_Zc8edFDQzHkbvHll4ODkg,1763
+cognite/neat/rules/exporters/_rules2dms.py,sha256=xnmq4FbMAvYVtJzDM-wwTRwVq_t3XWf8ffmhpE27BSk,14547
 cognite/neat/rules/exporters/_rules2excel.py,sha256=HvUdXYHxfLMijYWdTnfqCsw3Izf8S-XDSve-2ZbqF8Y,14248
 cognite/neat/rules/exporters/_rules2ontology.py,sha256=Od53uLdcC2Q7UiF5PA2P0gw3O14eTD3MeJ1-trd64ZM,20388
 cognite/neat/rules/exporters/_rules2yaml.py,sha256=GA8eUYRxUfIU6IMvlyGO5JidkOD5eUKSbH3qAiFiaCg,3026
 cognite/neat/rules/exporters/_validation.py,sha256=OlKIyf4nhSDehJwFHDQ8Zdf6HpNfW7dSe2s67eywHu4,4078
 cognite/neat/rules/importers/__init__.py,sha256=gR6_TAEa3iO5NCLKRztHg-FMiLdBnx47Z3iSzbwLfcE,481
-cognite/neat/rules/importers/_base.py,sha256=RoPovpuIvIr18xFBt-txz8OsIHqyMfMcMHOBivyQqHs,4296
+cognite/neat/rules/importers/_base.py,sha256=_hvxYnLiK8zf0MFes1VJ5TFisdZl-bOB6tFi3DQgYpc,4374
 cognite/neat/rules/importers/_dms2rules.py,sha256=5yJGYkM7lAMu-QfO0_r59WE4RGtMu2smMqLm16ohgLQ,18994
 cognite/neat/rules/importers/_dtdl2rules/__init__.py,sha256=CNR-sUihs2mnR1bPMKs3j3L4ds3vFTsrl6YycExZTfU,68
 cognite/neat/rules/importers/_dtdl2rules/_unit_lookup.py,sha256=wW4saKva61Q_i17guY0dc4OseJDQfqHy_QZBtm0OD6g,12134
@@ -220,13 +222,13 @@ cognite/neat/rules/issues/spreadsheet_file.py,sha256=YCp0Pk_TsiqYuOPdWpjUpre-zvi
 cognite/neat/rules/models/__init__.py,sha256=IqAg-h8PlcXcR_l-MECNMcVxMecF57vdg-Y488mBgWM,917
 cognite/neat/rules/models/_base.py,sha256=uZrP_TRu3aljL3XZGMyNtlQDsMPwUEsfSNjGhRdMg88,11234
 cognite/neat/rules/models/_constants.py,sha256=zPREgHT79_4FMg58QlaXc7A8XKRJrjP5SUgh63jDnTk,31
-cognite/neat/rules/models/_rdfpath.py,sha256=RoHnfWufjnDtwJh7UUzWKoJz8luvX7Gb5SDQORfkQTE,11030
+cognite/neat/rules/models/_rdfpath.py,sha256=t7h_9LMQrcj9JaYV2AXN_sYymbAvy-iyuAOjlhaTmog,12174
 cognite/neat/rules/models/_types/__init__.py,sha256=l1tGxzE7ezNHIL72AoEvNHN2IFuitxOLxiHJG__s6t4,305
 cognite/neat/rules/models/_types/_base.py,sha256=2GhLUE1ukV8X8SGL_JDxpbWGZyAvOnSqAE6JmDh5wbI,929
 cognite/neat/rules/models/_types/_field.py,sha256=h2RrhjxdaRbzHG5EyduyHLkCJJmQoyZb9pYCkgMcnVk,3203
 cognite/neat/rules/models/asset/__init__.py,sha256=qNon0kHleCPo2eT82TmeBAfiDDdwdKNU-Xdewuz8JRA,231
 cognite/neat/rules/models/asset/_converter.py,sha256=PrTh9ZZkqSJBviiJE4xc3pClCsaWu2tTYOdgwg6_VOk,150
-cognite/neat/rules/models/asset/_rules.py,sha256=mUgZEExfdMLDdpldfYLEyeWU4e89SKn_nyGv52v-1aQ,6044
+cognite/neat/rules/models/asset/_rules.py,sha256=fYp1pMJtioUtT747fo5NX69lgvPiPtHwXf_YuX--SEc,6195
 cognite/neat/rules/models/asset/_rules_input.py,sha256=LiT-85CVgDz2ng65CtrRa77r4rnmg3E4Q6DC7-gv0dE,6257
 cognite/neat/rules/models/asset/_serializer.py,sha256=ixqRf9qEzvChgysRaDX4g_vHVDtRBCsPYC9sOn0-ShE,3365
 cognite/neat/rules/models/asset/_validation.py,sha256=86ymEgMZpG1eWu53PviUyUFnQBUJmYDZggUDXufBYLI,148
@@ -242,8 +244,8 @@ cognite/neat/rules/models/dms/_validation.py,sha256=5mk9L99FSwC8Ok7weEjnFJ_OZnmq
 cognite/neat/rules/models/domain.py,sha256=wZ-DeIPFnacbNlxSrRuLzUpnhHdTpzNc22z0sDfisi4,2880
 cognite/neat/rules/models/entities.py,sha256=qZa_PJOjFk3yTu5NyTSbAjsrU0HUxVnme_7YruBJoRQ,20460
 cognite/neat/rules/models/information/__init__.py,sha256=HR6g8xgyU53U7Ck8pPdbT70817Q4NC1r1pCRq5SA8iw,291
-cognite/neat/rules/models/information/_converter.py,sha256=Xxlg_F6wWXNOnnq4ZJDgj1blDL-mZdFVlYutktZ9r68,12757
-cognite/neat/rules/models/information/_rules.py,sha256=G_FsNMRy5h4u9c3WfCAo2isrGlflgjsgRGpVLQSUJ5Q,13210
+cognite/neat/rules/models/information/_converter.py,sha256=nsfOCe13c3gqbbF1mrQHofemzYKpvg_NKjJZDwSXo5E,13960
+cognite/neat/rules/models/information/_rules.py,sha256=TIFZhsPJhYkZjhAIu7iKegcp7Jgbd7iatDKMeC9x4gs,13403
 cognite/neat/rules/models/information/_rules_input.py,sha256=ExCjcD0pvsThXYDf3uWYLzSLqN_2OtXFggbW_RB8hr4,10343
 cognite/neat/rules/models/information/_serializer.py,sha256=yti9I_xJruxrib66YIBInhze___Io-oPTQH6uWDumPE,3503
 cognite/neat/rules/models/information/_validation.py,sha256=Is2GzL2lZU3A5zPu3NjvlXfmIU2_Y10C5Nxi5Denz4g,7528
@@ -253,14 +255,14 @@ cognite/neat/utils/auxiliary.py,sha256=E2-YtddzScvN7l7j0kNYIMlfqIUT9NWMqLpcJYPK4
 cognite/neat/utils/cdf.py,sha256=piRx-6GRz4cCfBZD5rU0OM6ixQ3cj5TMzI0yCYUveR8,2422
 cognite/neat/utils/cdf_classes.py,sha256=NEmz5UprBlqfqZnqJkRk5xjSpzazwHbhcWsMH_GNxP8,5831
 cognite/neat/utils/cdf_loaders/__init__.py,sha256=s2aPR5XLo6WZ0ybstAJlcGFYkA7CyHW1XO-NYpL0V6o,483
-cognite/neat/utils/cdf_loaders/_base.py,sha256=j85HINIx4poGD-0dN3JPHTqjOS1XhCxv7G9s1gC1GBo,2057
-cognite/neat/utils/cdf_loaders/_data_modeling.py,sha256=RoIj2cL_j3vP6e4BlCExZU8d96p3dLitU9nsIIyesLc,11336
+cognite/neat/utils/cdf_loaders/_base.py,sha256=ryNC_AMXIESWXuTVJ-02L-HSVSpD6V49XdLTRYeFg70,1764
+cognite/neat/utils/cdf_loaders/_data_modeling.py,sha256=-owgamlYnB4-hnvsvWiGPFcnvkKs0EzrrWmIKhnvBpI,11359
 cognite/neat/utils/cdf_loaders/_ingestion.py,sha256=_2G8BObvpZ-vTHaCMAW_-ckHBLY96Hbg27uKAvpCaWk,6303
 cognite/neat/utils/cdf_loaders/data_classes.py,sha256=0apspfwVlFltYOZfmk_PNknS3Z3SCxVr3kkvXH0bfPA,3844
 cognite/neat/utils/exceptions.py,sha256=-w4cAcvcoWLf-_ZwAl7QV_NysfqtQzIOd1Ti-mpxJgM,981
 cognite/neat/utils/spreadsheet.py,sha256=LI0c7dlW0zXHkHw0NvB-gg6Df6cDcE3FbiaHBYLXdzQ,2714
 cognite/neat/utils/text.py,sha256=4bg1_Q0lg7KsoxaDOvXrVyeY78BJN8i-27BlyDzUCls,3082
-cognite/neat/utils/upload.py,sha256=XaAKqyMhz6qXbUrttGNIXZxFRPJvrnbMpDRF8GEiK2g,2707
+cognite/neat/utils/upload.py,sha256=opAB8oDtpgcrugcjbUg0tjGqtFUnAS7zixtLiRYZ3TA,5084
 cognite/neat/utils/utils.py,sha256=1LEwR8gpHw_6pvEeLkW_cDU_lUun4qSsw_Rr3JsKwgA,14172
 cognite/neat/utils/xml.py,sha256=ppLT3lQKVp8wOP-m8-tFY8uB2P4R76l7R_-kUtsABng,992
 cognite/neat/workflows/__init__.py,sha256=oiKub_U9f5cA0I1nKl5dFkR4BD8_6Be9eMzQ_50PwP0,396
@@ -289,7 +291,7 @@ cognite/neat/workflows/steps/lib/current/__init__.py,sha256=c22IznGdCSNCpXCi_yon
 cognite/neat/workflows/steps/lib/current/graph_extractor.py,sha256=vW9UpJScx5dFVCSairpOdWRdBdLpkCt2kNh6litbF0o,5161
 cognite/neat/workflows/steps/lib/current/graph_loader.py,sha256=HfGg1HRZhbV58TFu89FTjKeUxGsbCYLeFJIQFDN_pQM,2341
 cognite/neat/workflows/steps/lib/current/graph_store.py,sha256=r7VTxdaz8jJQU7FJbnRDMxvEYbSAZFNMABhPyfNwiFk,6295
-cognite/neat/workflows/steps/lib/current/rules_exporter.py,sha256=iFwzDWgUDBSPajaNAcXvu9pVw-jX66upvwyMXyTq7SE,23822
+cognite/neat/workflows/steps/lib/current/rules_exporter.py,sha256=1SKBYDnyDr975oMr9aOQVHExHjPQ0-whDDBNpTQ4K1A,23807
 cognite/neat/workflows/steps/lib/current/rules_importer.py,sha256=23dxamGHSbJoG7qUqL4KiGznSmDTVHw1EfqhLCeAwDM,14695
 cognite/neat/workflows/steps/lib/current/rules_validator.py,sha256=LwF9lXlnuPOxDSsOMMTHBi2BHc5rk08IF5zahS9yQuw,4844
 cognite/neat/workflows/steps/lib/io/__init__.py,sha256=k7IPbIq3ey19oRc5sA_15F99-O6dxzqbm1LihGRRo5A,32
@@ -307,8 +309,8 @@ cognite/neat/workflows/steps_registry.py,sha256=fkTX14ZA7_gkUYfWIlx7A1XbCidvqR23
 cognite/neat/workflows/tasks.py,sha256=dqlJwKAb0jlkl7abbY8RRz3m7MT4SK8-7cntMWkOYjw,788
 cognite/neat/workflows/triggers.py,sha256=_BLNplzoz0iic367u1mhHMHiUrCwP-SLK6_CZzfODX0,7071
 cognite/neat/workflows/utils.py,sha256=gKdy3RLG7ctRhbCRwaDIWpL9Mi98zm56-d4jfHDqP1E,453
-cognite_neat-0.83.0.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
-cognite_neat-0.83.0.dist-info/METADATA,sha256=ghwKVMP-mGJe6-Akz2QknoGas7foq5rsCPA8qVzg200,9400
-cognite_neat-0.83.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-cognite_neat-0.83.0.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
-cognite_neat-0.83.0.dist-info/RECORD,,
+cognite_neat-0.84.1.dist-info/LICENSE,sha256=W8VmvFia4WHa3Gqxq1Ygrq85McUNqIGDVgtdvzT-XqA,11351
+cognite_neat-0.84.1.dist-info/METADATA,sha256=i54w9dUQS9DCWAsl2IR-P14CUA1uMLpjrdISbJXnL8o,9400
+cognite_neat-0.84.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+cognite_neat-0.84.1.dist-info/entry_points.txt,sha256=61FPqiWb25vbqB0KI7znG8nsg_ibLHBvTjYnkPvNFso,50
+cognite_neat-0.84.1.dist-info/RECORD,,