cognite-neat 0.99.0__tar.gz → 0.100.0__tar.gz

{cognite_neat-0.99.0 → cognite_neat-0.100.0}/PKG-INFO

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

{cognite_neat-0.99.0 → cognite_neat-0.100.0}/cognite/neat/_client/_api/data_modeling_loaders.py

@@ -1,11 +1,12 @@
+import warnings
 from abc import ABC, abstractmethod
-from collections.abc import Sequence
+from collections.abc import Callable, Collection, Iterable, Sequence
+from dataclasses import dataclass, field
 from graphlib import TopologicalSorter
-from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, TypeVar, cast
 
 from cognite.client.data_classes import filters
 from cognite.client.data_classes._base import (
-    CogniteResourceList,
     T_CogniteResourceList,
     T_WritableCogniteResource,
     T_WriteClass,
@@ -22,6 +23,10 @@ from cognite.client.data_classes.data_modeling import (
     DataModelList,
     EdgeConnection,
     MappedProperty,
+    Node,
+    NodeApply,
+    NodeApplyList,
+    NodeList,
     RequiresConstraint,
     Space,
     SpaceApply,
@@ -47,6 +52,9 @@ from cognite.client.data_classes.data_modeling.views import (
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
+from cognite.neat._client.data_classes.data_modeling import Component
+from cognite.neat._client.data_classes.schema import DMSSchema
+from cognite.neat._issues.warnings import CDFMaxIterationsWarning
 from cognite.neat._shared import T_ID
 
 if TYPE_CHECKING:
@@ -54,6 +62,16 @@ if TYPE_CHECKING:
 
 T_WritableCogniteResourceList = TypeVar("T_WritableCogniteResourceList", bound=WriteableCogniteResourceList)
 
+T_Item = TypeVar("T_Item")
+T_Out = TypeVar("T_Out", bound=Iterable)
+
+
+@dataclass
+class MultiCogniteAPIError(Exception, Generic[T_ID, T_WritableCogniteResourceList]):
+    success: T_WritableCogniteResourceList
+    failed: list[T_ID] = field(default_factory=list)
+    errors: list[CogniteAPIError] = field(default_factory=list)
+
 
 class ResourceLoader(
     ABC,
@@ -66,6 +84,7 @@ class ResourceLoader(
     """
 
     resource_name: str
+    dependencies: "ClassVar[frozenset[type[ResourceLoader]]]" = frozenset()
 
     def __init__(self, client: "NeatClient") -> None:
         # This is exposed to allow for disabling the cache.
@@ -87,35 +106,79 @@ class ResourceLoader(
         return [cls.get_id(item) for item in items]
 
     def create(self, items: Sequence[T_WriteClass]) -> T_WritableCogniteResourceList:
-        created = self._create(items)
+        # Containers can have dependencies on other containers, so we sort them before creating them.
+        items = self.sort_by_dependencies(items)
+
+        exception: MultiCogniteAPIError[T_ID, T_WritableCogniteResourceList] | None = None
+        try:
+            created = self._fallback_one_by_one(self._create, items)
+        except MultiCogniteAPIError as e:
+            created = e.success
+            exception = e
+
         if self.cache:
             self._items_by_id.update({self.get_id(item): item for item in created})
+
+        if exception is not None:
+            raise exception
+
         return created
 
     def retrieve(self, ids: SequenceNotStr[T_ID]) -> T_WritableCogniteResourceList:
         if not self.cache:
-            return self._retrieve(ids)
+            # We now that SequenceNotStr = Sequence
+            return self._fallback_one_by_one(self._retrieve, ids)  # type: ignore[arg-type]
+        exception: MultiCogniteAPIError[T_ID, T_WritableCogniteResourceList] | None = None
         missing_ids = [id for id in ids if id not in self._items_by_id.keys()]
         if missing_ids:
-            retrieved = self._retrieve(missing_ids)
+            try:
+                retrieved = self._retrieve(missing_ids)
+            except MultiCogniteAPIError as e:
+                retrieved = e.success
+                exception = e
             self._items_by_id.update({self.get_id(item): item for item in retrieved})
-        return self._create_list([self._items_by_id[id] for id in ids])
+        if exception is not None:
+            raise exception
+        # We need to check the cache again, in case we didn't retrieve all the items.
+        return self._create_list([self._items_by_id[id] for id in ids if id in self._items_by_id])
+
+    def update(
+        self, items: Sequence[T_WriteClass], force: bool = False, drop_data: bool = False
+    ) -> T_WritableCogniteResourceList:
+        exception: MultiCogniteAPIError[T_ID, T_WritableCogniteResourceList] | None = None
+        if force:
+            updated = self._update_force(items, drop_data=drop_data)
+        else:
+            try:
+                updated = self._fallback_one_by_one(self._update, items)
+            except MultiCogniteAPIError as e:
+                updated = e.success
+                exception = e
+
+        if self.cache:
+            self._items_by_id.update({self.get_id(item): item for item in updated})
+
+        if exception is not None:
+            raise exception
 
-    def update(self, items: Sequence[T_WriteClass]) -> T_WritableCogniteResourceList:
-        if not self.cache:
-            return self._update(items)
-        updated = self._update(items)
-        self._items_by_id.update({self.get_id(item): item for item in updated})
         return updated
 
     def delete(self, ids: SequenceNotStr[T_ID] | Sequence[T_WriteClass]) -> list[T_ID]:
         id_list = [self.get_id(item) for item in ids]
-        if not self.cache:
-            return self._delete(id_list)
-        ids = [self.get_id(item) for item in ids]
-        deleted = self._delete(id_list)
-        for id in deleted:
-            self._items_by_id.pop(id, None)
+        exception: MultiCogniteAPIError[T_ID, T_WritableCogniteResourceList] | None = None
+        try:
+            # We know that SequenceNotStr = Sequence
+            deleted = self._fallback_one_by_one(self._delete, id_list)  # type: ignore[arg-type]
+        except MultiCogniteAPIError as e:
+            deleted = e.success
+            exception = e
+
+        if self.cache:
+            for id in deleted:
+                self._items_by_id.pop(id, None)
+        if exception is not None:
+            raise exception
+
         return deleted
 
     @abstractmethod
@@ -138,9 +201,77 @@ class ResourceLoader(
     def _create_list(self, items: Sequence[T_WritableCogniteResource]) -> T_WritableCogniteResourceList:
         raise NotImplementedError
 
+    def has_data(self, item_id: T_ID) -> bool:
+        return False
+
     def are_equal(self, local: T_WriteClass, remote: T_WritableCogniteResource) -> bool:
         return local == remote.as_write()
 
+    def sort_by_dependencies(self, items: Sequence[T_WriteClass]) -> list[T_WriteClass]:
+        return list(items)
+
+    def _update_force(
+        self,
+        items: Sequence[T_WriteClass],
+        drop_data: bool = False,
+        tried_force_update: set[T_ID] | None = None,
+        success: T_WritableCogniteResourceList | None = None,
+    ) -> T_WritableCogniteResourceList:
+        tried_force_update = tried_force_update or set()
+        try:
+            return self._update(items)
+        except CogniteAPIError as e:
+            failed_ids = {self.get_id(failed) for failed in e.failed + e.unknown}
+            success_ids = [self.get_id(success) for success in e.successful]
+            success_ = self.retrieve(success_ids)
+            if success is None:
+                success = success_
+            else:
+                success.extend(success_)
+            to_redeploy: list[T_WriteClass] = []
+            for item in items:
+                item_id = self.get_id(item)
+                if item_id in failed_ids:
+                    if tried_force_update and item_id in tried_force_update:
+                        # Avoid infinite loop
+                        continue
+                    tried_force_update.add(item_id)
+                    if self.has_data(item_id) and not drop_data:
+                        continue
+                    to_redeploy.append(item)
+            if not to_redeploy:
+                # Avoid infinite loop
+                raise e
+            self.delete(to_redeploy)
+            forced = self._update_force(to_redeploy, drop_data, tried_force_update, success)
+            forced.extend(success)
+            return forced
+
+    def _fallback_one_by_one(self, method: Callable[[Sequence[T_Item]], T_Out], items: Sequence[T_Item]) -> T_Out:
+        try:
+            return method(items)
+        except CogniteAPIError as e:
+            exception = MultiCogniteAPIError[T_ID, T_WritableCogniteResourceList](self._create_list([]))
+            success = {self.get_id(success) for success in e.successful}
+            if success:
+                # Need read version of the items to put into cache.
+                retrieve_items = self.retrieve(list(success))
+                exception.success.extend(retrieve_items)
+            for item in items:
+                # We know that item is either T_ID or T_WriteClass
+                # but the T_Item cannot be bound to both types at the same time.
+                item_id = self.get_id(item)  # type: ignore[arg-type]
+                if item_id in success:
+                    continue
+                try:
+                    item_result = method([item])
+                except CogniteAPIError as item_exception:
+                    exception.errors.append(item_exception)
+                    exception.failed.extend(self.get_ids(item_exception.failed))
+                else:
+                    exception.success.extend(item_result)
+            raise exception from None
+
 
 class DataModelingLoader(
     ResourceLoader[T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList],
@@ -152,40 +283,10 @@ class DataModelingLoader(
             return item.space in space
         raise ValueError(f"Item {item} does not have a space attribute")
 
-    def sort_by_dependencies(self, items: list[T_WriteClass]) -> list[T_WriteClass]:
-        return items
-
-    def create(
-        self, items: Sequence[T_WriteClass], existing_handling: Literal["fail", "skip", "update", "force"] = "fail"
-    ) -> T_WritableCogniteResourceList:
-        if existing_handling != "force":
-            return super().create(items)
-
-        created = self._create_force(items, set())
-        if self.cache:
-            self._items_by_id.update({self.get_id(item): item for item in created})
-        return created
-
-    def _create_force(
-        self,
-        items: Sequence[T_WriteClass],
-        tried_force_deploy: set[T_ID],
-    ) -> T_WritableCogniteResourceList:
-        try:
-            return self._create(items)
-        except CogniteAPIError as e:
-            failed_ids = {self.get_id(failed) for failed in e.failed}
-            to_redeploy = [
-                item
-                for item in items
-                if self.get_id(item) in failed_ids and self.get_id(item) not in tried_force_deploy
-            ]
-            if not to_redeploy:
-                # Avoid infinite loop
-                raise e
-            tried_force_deploy.update([self.get_id(item) for item in to_redeploy])
-            self.delete(to_redeploy)
-            return self._create_force(to_redeploy, tried_force_deploy)
+    @classmethod
+    @abstractmethod
+    def items_from_schema(cls, schema: DMSSchema) -> T_CogniteResourceList:
+        raise NotImplementedError
 
 
 class SpaceLoader(DataModelingLoader[str, SpaceApply, Space, SpaceApplyList, SpaceList]):
@@ -257,9 +358,147 @@ class SpaceLoader(DataModelingLoader[str, SpaceApply, Space, SpaceApplyList, Spa
         deleted_space = self._client.data_modeling.spaces.delete(space)
         print(f"Deleted space {deleted_space}")
 
+    @classmethod
+    def items_from_schema(cls, schema: DMSSchema) -> SpaceApplyList:
+        return SpaceApplyList(schema.spaces.values())
+
+    def has_data(self, item_id: str) -> bool:
+        return bool(self._client.data_modeling.instances.list("node", limit=1, space=item_id)) or bool(
+            self._client.data_modeling.instances.list("edge", limit=1, space=item_id)
+        )
+
+
+class ContainerLoader(DataModelingLoader[ContainerId, ContainerApply, Container, ContainerApplyList, ContainerList]):
+    resource_name = "containers"
+    dependencies = frozenset({SpaceLoader})
+
+    @classmethod
+    def get_id(cls, item: Container | ContainerApply | ContainerId | dict) -> ContainerId:
+        if isinstance(item, Container | ContainerApply):
+            return item.as_id()
+        if isinstance(item, dict):
+            return ContainerId.load(item)
+        return item
+
+    def sort_by_dependencies(self, items: Sequence[ContainerApply]) -> list[ContainerApply]:
+        container_by_id = {container.as_id(): container for container in items}
+        container_dependencies = {
+            container.as_id(): {
+                const.require
+                for const in container.constraints.values()
+                if isinstance(const, RequiresConstraint) and const.require in container_by_id
+            }
+            for container in items
+        }
+        return [
+            container_by_id[container_id] for container_id in TopologicalSorter(container_dependencies).static_order()
+        ]
+
+    def _create(self, items: Sequence[ContainerApply]) -> ContainerList:
+        return self._client.data_modeling.containers.apply(items)
+
+    def retrieve(self, ids: SequenceNotStr[ContainerId], include_connected: bool = False) -> ContainerList:
+        if not include_connected:
+            return super().retrieve(ids)
+        # Retrieve recursively updates the cache.
+        return self._retrieve_recursive(ids)
+
+    def _retrieve(self, ids: SequenceNotStr[ContainerId]) -> ContainerList:
+        return self._client.data_modeling.containers.retrieve(cast(Sequence, ids))
+
+    def _update(self, items: Sequence[ContainerApply]) -> ContainerList:
+        return self._create(items)
+
+    def _delete(self, ids: SequenceNotStr[ContainerId]) -> list[ContainerId]:
+        return self._client.data_modeling.containers.delete(cast(Sequence, ids))
+
+    def _create_list(self, items: Sequence[Container]) -> ContainerList:
+        return ContainerList(items)
+
+    def _retrieve_recursive(self, container_ids: SequenceNotStr[ContainerId]) -> ContainerList:
+        """Containers can reference each other through the 'requires' constraint.
+
+        This method retrieves all containers that are referenced by other containers through the 'requires' constraint,
+        including their parents.
+        """
+        max_iterations = 10  # Limiting the number of iterations to avoid infinite loops
+        found = ContainerList([])
+        found_ids: set[ContainerId] = set()
+        last_batch = list(container_ids)
+        for _ in range(max_iterations):
+            if not last_batch:
+                break
+            to_retrieve_from_cdf: set[ContainerId] = set()
+            batch_ids: list[ContainerId] = []
+            for container_id in last_batch:
+                if container_id in found_ids:
+                    continue
+                elif container_id in self._items_by_id:
+                    container = self._items_by_id[container_id]
+                    found.append(container)
+                    batch_ids.extend(self.get_connected_containers(container, found_ids))
+                else:
+                    to_retrieve_from_cdf.add(container_id)
+
+            if to_retrieve_from_cdf:
+                retrieved_batch = self._client.data_modeling.containers.retrieve(list(to_retrieve_from_cdf))
+                self._items_by_id.update({view.as_id(): view for view in retrieved_batch})
+                found.extend(retrieved_batch)
+                found_ids.update({view.as_id() for view in retrieved_batch})
+                for container in retrieved_batch:
+                    batch_ids.extend(self.get_connected_containers(container, found_ids))
+
+            last_batch = batch_ids
+        else:
+            warnings.warn(
+                CDFMaxIterationsWarning(
+                    "The maximum number of iterations was reached while resolving referenced containers."
+                    "There might be referenced containers that are not included in the list of containers.",
+                    max_iterations=max_iterations,
+                ),
+                stacklevel=2,
+            )
+
+        if self.cache is False:
+            # We must update the cache to retrieve recursively.
+            # If the cache is disabled, bust the cache to avoid storing the retrieved views.
+            self.bust_cache()
+        return found
+
+    @staticmethod
+    def get_connected_containers(
+        container: Container | ContainerApply, skip: set[ContainerId] | None = None
+    ) -> set[ContainerId]:
+        connected_containers = set()
+        for constraint in container.constraints.values():
+            if isinstance(constraint, RequiresConstraint):
+                connected_containers.add(constraint.require)
+        if skip:
+            return {container_id for container_id in connected_containers if container_id not in skip}
+        return connected_containers
+
+    def are_equal(self, local: ContainerApply, remote: Container) -> bool:
+        local_dumped = local.dump(camel_case=True)
+        if "usedFor" not in local_dumped:
+            # Setting used_for to "node" as it is the default value in the CDF.
+            local_dumped["usedFor"] = "node"
+
+        return local_dumped == remote.as_write().dump(camel_case=True)
+
+    @classmethod
+    def items_from_schema(cls, schema: DMSSchema) -> ContainerApplyList:
+        return ContainerApplyList(schema.containers.values())
+
+    def has_data(self, item_id: ContainerId) -> bool:
+        has_data = filters.HasData(containers=[item_id])
+        return bool(self._client.data_modeling.instances.list("node", limit=1, filter=has_data)) or bool(
+            self._client.data_modeling.instances.list("edge", limit=1, filter=has_data)
+        )
+
 
 class ViewLoader(DataModelingLoader[ViewId, ViewApply, View, ViewApplyList, ViewList]):
     resource_name = "views"
+    dependencies = frozenset({SpaceLoader, ContainerLoader})
 
     @classmethod
     def get_id(cls, item: View | ViewApply | ViewId | dict) -> ViewId:
@@ -273,12 +512,12 @@ class ViewLoader(DataModelingLoader[ViewId, ViewApply, View, ViewApplyList, View
         return self._client.data_modeling.views.apply(items)
 
     def retrieve(
-        self, ids: SequenceNotStr[ViewId], include_connections: bool = False, include_ancestor: bool = False
+        self, ids: SequenceNotStr[ViewId], include_connected: bool = False, include_ancestor: bool = False
     ) -> ViewList:
-        if not include_connections and not include_ancestor:
+        if not include_connected and not include_ancestor:
             return super().retrieve(ids)
         # Retrieve recursively updates the cache.
-        return self._retrieve_recursive(ids, include_connections, include_ancestor)
+        return self._retrieve_recursive(ids, include_connected, include_ancestor)
 
     def _retrieve(self, ids: SequenceNotStr[ViewId]) -> ViewList:
         return self._client.data_modeling.views.retrieve(cast(Sequence, ids))
@@ -338,19 +577,19 @@ class ViewLoader(DataModelingLoader[ViewId, ViewApply, View, ViewApplyList, View
             include_connections: Whether to include all connected views.
             include_ancestors: Whether to include all ancestors.
         """
-        last_batch = list(view_ids)
+        last_batch = set(view_ids)
         found = ViewList([])
         found_ids: set[ViewId] = set()
         while last_batch:
             to_retrieve_from_cdf: set[ViewId] = set()
-            batch_ids: list[ViewId] = []
+            batch_ids: set[ViewId] = set()
             for view_id in last_batch:
                 if view_id in found_ids:
                     continue
                 elif view_id in self._items_by_id:
                     view = self._items_by_id[view_id]
                     found.append(view)
-                    batch_ids.extend(self.get_connected_views(view, include_ancestors, include_connections, found_ids))
+                    batch_ids.update(self.get_connected_views(view, include_ancestors, include_connections, found_ids))
                 else:
                     to_retrieve_from_cdf.add(view_id)
 
@@ -360,7 +599,7 @@ class ViewLoader(DataModelingLoader[ViewId, ViewApply, View, ViewApplyList, View
                 found.extend(retrieved_batch)
                 found_ids.update({view.as_id() for view in retrieved_batch})
                 for view in retrieved_batch:
-                    batch_ids.extend(self.get_connected_views(view, include_ancestors, include_connections, found_ids))
+                    batch_ids.update(self.get_connected_views(view, include_ancestors, include_connections, found_ids))
 
             last_batch = batch_ids
 
@@ -400,58 +639,14 @@ class ViewLoader(DataModelingLoader[ViewId, ViewApply, View, ViewApplyList, View
     def _create_list(self, items: Sequence[View]) -> ViewList:
         return ViewList(items)
 
-
-class ContainerLoader(DataModelingLoader[ContainerId, ContainerApply, Container, ContainerApplyList, ContainerList]):
-    resource_name = "containers"
-
     @classmethod
-    def get_id(cls, item: Container | ContainerApply | ContainerId | dict) -> ContainerId:
-        if isinstance(item, Container | ContainerApply):
-            return item.as_id()
-        if isinstance(item, dict):
-            return ContainerId.load(item)
-        return item
-
-    def sort_by_dependencies(self, items: Sequence[ContainerApply]) -> list[ContainerApply]:
-        container_by_id = {container.as_id(): container for container in items}
-        container_dependencies = {
-            container.as_id(): {
-                const.require
-                for const in container.constraints.values()
-                if isinstance(const, RequiresConstraint) and const.require in container_by_id
-            }
-            for container in items
-        }
-        return [
-            container_by_id[container_id] for container_id in TopologicalSorter(container_dependencies).static_order()
-        ]
-
-    def _create(self, items: Sequence[ContainerApply]) -> ContainerList:
-        return self._client.data_modeling.containers.apply(items)
-
-    def _retrieve(self, ids: SequenceNotStr[ContainerId]) -> ContainerList:
-        return self._client.data_modeling.containers.retrieve(cast(Sequence, ids))
-
-    def _update(self, items: Sequence[ContainerApply]) -> ContainerList:
-        return self._create(items)
-
-    def _delete(self, ids: SequenceNotStr[ContainerId]) -> list[ContainerId]:
-        return self._client.data_modeling.containers.delete(cast(Sequence, ids))
-
-    def _create_list(self, items: Sequence[Container]) -> ContainerList:
-        return ContainerList(items)
-
-    def are_equal(self, local: ContainerApply, remote: Container) -> bool:
-        local_dumped = local.dump(camel_case=True)
-        if "usedFor" not in local_dumped:
-            # Setting used_for to "node" as it is the default value in the CDF.
-            local_dumped["usedFor"] = "node"
-
-        return local_dumped == remote.as_write().dump(camel_case=True)
+    def items_from_schema(cls, schema: DMSSchema) -> ViewApplyList:
+        return ViewApplyList(schema.views.values())
 
 
 class DataModelLoader(DataModelingLoader[DataModelId, DataModelApply, DataModel, DataModelApplyList, DataModelList]):
     resource_name = "data_models"
+    dependencies = frozenset({SpaceLoader, ViewLoader})
 
     @classmethod
     def get_id(cls, item: DataModel | DataModelApply | DataModelId | dict) -> DataModelId:
@@ -491,6 +686,72 @@ class DataModelLoader(DataModelingLoader[DataModelId, DataModelApply, DataModel,
 
         return local_dumped == cdf_resource_dumped
 
+    @classmethod
+    def items_from_schema(cls, schema: DMSSchema) -> DataModelApplyList:
+        return DataModelApplyList([schema.data_model])
+
+
+class NodeLoader(DataModelingLoader[NodeId, NodeApply, Node, NodeApplyList, NodeList]):
+    resource_name = "nodes"
+    dependencies = frozenset({SpaceLoader, ContainerLoader, ViewLoader})
+
+    @classmethod
+    def get_id(cls, item: Node | NodeApply | NodeId | dict) -> NodeId:
+        if isinstance(item, Node | NodeApply):
+            return item.as_id()
+        if isinstance(item, dict):
+            return NodeId.load(item)
+        return item
+
+    def _create(self, items: Sequence[NodeApply]) -> NodeList:
+        self._client.data_modeling.instances.apply(items)
+        return self._retrieve([item.as_id() for item in items])
+
+    def _retrieve(self, ids: SequenceNotStr[NodeId]) -> NodeList:
+        return self._client.data_modeling.instances.retrieve(cast(Sequence, ids)).nodes
+
+    def _update(self, items: Sequence[NodeApply]) -> NodeList:
+        self._client.data_modeling.instances.apply(items, replace=True)
+        return self._retrieve([item.as_id() for item in items])
+
+    def _delete(self, ids: SequenceNotStr[NodeId]) -> list[NodeId]:
+        return list(self._client.data_modeling.instances.delete(nodes=cast(Sequence, ids)).nodes)
+
+    def _create_list(self, items: Sequence[Node]) -> NodeList:
+        return NodeList(items)
+
+    def are_equal(self, local: NodeApply, remote: Node) -> bool:
+        local_dumped = local.dump()
+
+        # Note reading from a container is not supported.
+        sources = [
+            source_prop_pair.source
+            for source_prop_pair in local.sources or []
+            if isinstance(source_prop_pair.source, ViewId)
+        ]
+        if sources:
+            try:
+                cdf_resource_with_properties = self._client.data_modeling.instances.retrieve(
+                    nodes=remote.as_id(), sources=sources
+                ).nodes[0]
+            except CogniteAPIError:
+                # View does not exist, so node does not exist.
+                return False
+        else:
+            cdf_resource_with_properties = remote
+        cdf_resource_dumped = cdf_resource_with_properties.as_write().dump()
+
+        if "existingVersion" not in local_dumped:
+            # Existing version is typically not set when creating nodes, but we get it back
+            # when we retrieve the node from the server.
+            local_dumped["existingVersion"] = cdf_resource_dumped.get("existingVersion", None)
+
+        return local_dumped == cdf_resource_dumped
+
+    @classmethod
+    def items_from_schema(cls, schema: DMSSchema) -> NodeApplyList:
+        return NodeApplyList(schema.node_types.values())
+
 
 class DataModelLoaderAPI:
     def __init__(self, client: "NeatClient") -> None:
@@ -499,14 +760,27 @@ class DataModelLoaderAPI:
         self.views = ViewLoader(client)
         self.containers = ContainerLoader(client)
         self.data_models = DataModelLoader(client)
+        self.nodes = NodeLoader(client)
+        self._loaders: list[DataModelingLoader] = [
+            self.spaces,
+            self.views,
+            self.containers,
+            self.data_models,
+            self.nodes,
+        ]
 
-    def get_loader(self, items: Any) -> DataModelingLoader:
-        if isinstance(items, CogniteResourceList):
-            resource_name = type(items).__name__.casefold().removesuffix("list").removesuffix("apply")
-        elif isinstance(items, str):
-            resource_name = items
-        else:
-            raise ValueError(f"Cannot determine resource name from {items}")
-        if resource_name[-1] != "s":
-            resource_name += "s"
-        return getattr(self, resource_name)
+    def by_dependency_order(
+        self, component: Component | Collection[Component] | None = None
+    ) -> list[DataModelingLoader]:
+        loader_by_type = {type(loader): loader for loader in self._loaders}
+        loader_iterable = (
+            loader_by_type[loader_cls]  # type: ignore[index]
+            for loader_cls in TopologicalSorter(
+                {type(loader): loader.dependencies for loader in self._loaders}  # type: ignore[attr-defined]
+            ).static_order()
+        )
+        if component is None:
+            return list(loader_iterable)
+        components = {component} if isinstance(component, str) else set(component)
+        components = {{"node_type": "nodes"}.get(component, component) for component in components}
+        return [loader for loader in loader_iterable if loader.resource_name in components]