cognite-neat 0.98.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

cognite/neat/_graph/queries/_base.py

@@ -12,7 +12,7 @@ from cognite.neat._rules._constants import EntityTypes
 from cognite.neat._rules.models.entities import ClassEntity
 from cognite.neat._rules.models.information import InformationRules
 from cognite.neat._shared import InstanceType
-from cognite.neat._utils.rdf_ import remove_namespace_from_uri
+from cognite.neat._utils.rdf_ import remove_instance_ids_in_batch, remove_namespace_from_uri
 
 from ._construct import build_construct_query
 
@@ -342,3 +342,19 @@ class Queries:
             self.graph.query(query.format(unknownType=str(UNKNOWN_TYPE))),
         ):
             yield cast(URIRef, source_type), cast(URIRef, property_), [URIRef(uri) for uri in value_types.split(",")]
+
+    def drop_types(self, type_: list[URIRef]) -> dict[URIRef, int]:
+        """Drop types from the graph store
+
+        Args:
+            type_: List of types to drop
+
+        Returns:
+            Dictionary of dropped types
+        """
+        dropped_types: dict[URIRef, int] = {}
+        for t in type_:
+            instance_ids = self.list_instances_ids_of_class(t)
+            dropped_types[t] = len(instance_ids)
+            remove_instance_ids_in_batch(self.graph, instance_ids)
+        return dropped_types

cognite/neat/_graph/transformers/_classic_cdf.py

@@ -1,4 +1,6 @@
+import textwrap
 import warnings
+from abc import ABC
 from typing import cast
 
 from rdflib import RDF, Graph, Literal, Namespace, URIRef
@@ -7,7 +9,7 @@ from rdflib.query import ResultRow
 from cognite.neat._constants import CLASSIC_CDF_NAMESPACE, DEFAULT_NAMESPACE
 from cognite.neat._graph import extractors
 from cognite.neat._issues.warnings import ResourceNotFoundWarning
-from cognite.neat._utils.rdf_ import remove_namespace_from_uri
+from cognite.neat._utils.rdf_ import Triple, add_triples_in_batch, remove_namespace_from_uri
 
 from ._base import BaseTransformer
 
@@ -32,8 +34,8 @@ class AddAssetDepth(BaseTransformer):
         depth_typing: dict[int, str] | None = None,
     ):
         self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.root_prop = root_prop or DEFAULT_NAMESPACE.root
-        self.parent_prop = parent_prop or DEFAULT_NAMESPACE.parent
+        self.root_prop = root_prop or DEFAULT_NAMESPACE.rootId
+        self.parent_prop = parent_prop or DEFAULT_NAMESPACE.parentId
         self.depth_typing = depth_typing
 
     def transform(self, graph: Graph) -> None:
@@ -75,7 +77,33 @@ class AddAssetDepth(BaseTransformer):
             return None
 
 
-class AssetTimeSeriesConnector(BaseTransformer):
+class BaseAssetConnector(BaseTransformer, ABC):
+    _asset_type: URIRef = DEFAULT_NAMESPACE.Asset
+    _item_type: URIRef
+    _default_attribute: URIRef
+    _connection_type: URIRef
+
+    _select_item_ids = "SELECT DISTINCT ?item_id WHERE {{?item_id a <{item_type}>}}"
+    _select_connected_assets: str = textwrap.dedent("""SELECT ?asset_id WHERE {{
+                              <{item_id}> <{attribute}> ?asset_id .
+                              ?asset_id a <{asset_type}>}}""")
+
+    def __init__(self, attribute: URIRef | None = None) -> None:
+        self._attribute = attribute or self._default_attribute
+
+    def transform(self, graph: Graph) -> None:
+        for item_id, *_ in graph.query(self._select_item_ids.format(item_type=self._item_type)):  # type: ignore[misc]
+            triples: list[Triple] = []
+            for asset_id, *_ in graph.query(  # type: ignore[misc]
+                self._select_connected_assets.format(
+                    item_id=item_id, attribute=self._attribute, asset_type=self._asset_type
+                )
+            ):
+                triples.append((asset_id, self._connection_type, item_id))  # type: ignore[arg-type]
+            add_triples_in_batch(graph, triples)
+
+
+class AssetTimeSeriesConnector(BaseAssetConnector):
     description: str = "Connects assets to timeseries, thus forming bi-directional connection"
     _use_only_once: bool = True
     _need_changes = frozenset(
@@ -84,41 +112,12 @@ class AssetTimeSeriesConnector(BaseTransformer):
             str(extractors.TimeSeriesExtractor.__name__),
         }
     )
-    _asset_template: str = """SELECT ?asset_id WHERE {{
-                              <{timeseries_id}> <{asset_prop}> ?asset_id .
-                              ?asset_id a <{asset_type}>}}"""
+    _item_type = DEFAULT_NAMESPACE.TimeSeries
+    _default_attribute = DEFAULT_NAMESPACE.assetId
+    _connection_type = DEFAULT_NAMESPACE.timeSeries
 
-    def __init__(
-        self,
-        asset_type: URIRef | None = None,
-        timeseries_type: URIRef | None = None,
-        asset_prop: URIRef | None = None,
-    ):
-        self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.timeseries_type = timeseries_type or DEFAULT_NAMESPACE.TimeSeries
-        self.asset_prop = asset_prop or DEFAULT_NAMESPACE.asset
 
-    def transform(self, graph: Graph) -> None:
-        for ts_id_result in graph.query(
-            f"SELECT DISTINCT ?timeseries_id WHERE {{?timeseries_id a <{self.timeseries_type}>}}"
-        ):
-            timeseries_id: URIRef = cast(tuple, ts_id_result)[0]
-
-            if asset_id_res := list(
-                graph.query(
-                    self._asset_template.format(
-                        timeseries_id=timeseries_id,
-                        asset_prop=self.asset_prop,
-                        asset_type=self.asset_type,
-                    )
-                )
-            ):
-                # timeseries can be connected to only one asset in the graph
-                asset_id = cast(list[tuple], asset_id_res)[0][0]
-                graph.add((asset_id, DEFAULT_NAMESPACE.timeSeries, timeseries_id))
-
-
-class AssetSequenceConnector(BaseTransformer):
+class AssetSequenceConnector(BaseAssetConnector):
     description: str = "Connects assets to sequences, thus forming bi-directional connection"
     _use_only_once: bool = True
     _need_changes = frozenset(
@@ -127,41 +126,12 @@ class AssetSequenceConnector(BaseTransformer):
             str(extractors.SequencesExtractor.__name__),
         }
     )
-    _asset_template: str = """SELECT ?asset_id WHERE {{
-                              <{sequence_id}> <{asset_prop}> ?asset_id .
-                              ?asset_id a <{asset_type}>}}"""
-
-    def __init__(
-        self,
-        asset_type: URIRef | None = None,
-        sequence_type: URIRef | None = None,
-        asset_prop: URIRef | None = None,
-    ):
-        self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.sequence_type = sequence_type or DEFAULT_NAMESPACE.Sequence
-        self.asset_prop = asset_prop or DEFAULT_NAMESPACE.asset
-
-    def transform(self, graph: Graph) -> None:
-        for sequency_id_result in graph.query(
-            f"SELECT DISTINCT ?sequence_id WHERE {{?sequence_id a <{self.sequence_type}>}}"
-        ):
-            sequence_id: URIRef = cast(tuple, sequency_id_result)[0]
-
-            if asset_id_res := list(
-                graph.query(
-                    self._asset_template.format(
-                        sequence_id=sequence_id,
-                        asset_prop=self.asset_prop,
-                        asset_type=self.asset_type,
-                    )
-                )
-            ):
-                # sequence can be connected to only one asset in the graph
-                asset_id = cast(list[tuple], asset_id_res)[0][0]
-                graph.add((asset_id, DEFAULT_NAMESPACE.sequence, sequence_id))
+    _item_type = DEFAULT_NAMESPACE.Sequence
+    _default_attribute = DEFAULT_NAMESPACE.assetId
+    _connection_type = DEFAULT_NAMESPACE.sequence
 
 
-class AssetFileConnector(BaseTransformer):
+class AssetFileConnector(BaseAssetConnector):
     description: str = "Connects assets to files, thus forming bi-directional connection"
     _use_only_once: bool = True
     _need_changes = frozenset(
@@ -170,39 +140,12 @@ class AssetFileConnector(BaseTransformer):
             str(extractors.FilesExtractor.__name__),
         }
     )
-    _asset_template: str = """SELECT ?asset_id WHERE {{
-                              <{file_id}> <{asset_prop}> ?asset_id .
-                              ?asset_id a <{asset_type}>}}"""
-
-    def __init__(
-        self,
-        asset_type: URIRef | None = None,
-        file_type: URIRef | None = None,
-        asset_prop: URIRef | None = None,
-    ):
-        self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.file_type = file_type or DEFAULT_NAMESPACE.File
-        self.asset_prop = asset_prop or DEFAULT_NAMESPACE.asset
+    _item_type = DEFAULT_NAMESPACE.File
+    _default_attribute = DEFAULT_NAMESPACE.assetIds
+    _connection_type = DEFAULT_NAMESPACE.file
 
-    def transform(self, graph: Graph) -> None:
-        for sequency_id_result in graph.query(f"SELECT DISTINCT ?file_id WHERE {{?file_id a <{self.file_type}>}}"):
-            file_id: URIRef = cast(tuple, sequency_id_result)[0]
-
-            if assets_id_res := list(
-                graph.query(
-                    self._asset_template.format(
-                        file_id=file_id,
-                        asset_prop=self.asset_prop,
-                        asset_type=self.asset_type,
-                    )
-                )
-            ):
-                # files can be connected to multiple assets in the graph
-                for (asset_id,) in cast(list[tuple], assets_id_res):
-                    graph.add((asset_id, DEFAULT_NAMESPACE.file, file_id))
 
-
-class AssetEventConnector(BaseTransformer):
+class AssetEventConnector(BaseAssetConnector):
     description: str = "Connects assets to events, thus forming bi-directional connection"
     _use_only_once: bool = True
     _need_changes = frozenset(
@@ -211,36 +154,9 @@ class AssetEventConnector(BaseTransformer):
             str(extractors.EventsExtractor.__name__),
         }
     )
-    _asset_template: str = """SELECT ?asset_id WHERE {{
-                              <{event_id}> <{asset_prop}> ?asset_id .
-                              ?asset_id a <{asset_type}>}}"""
-
-    def __init__(
-        self,
-        asset_type: URIRef | None = None,
-        event_type: URIRef | None = None,
-        asset_prop: URIRef | None = None,
-    ):
-        self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
-        self.event_type = event_type or DEFAULT_NAMESPACE.Event
-        self.asset_prop = asset_prop or DEFAULT_NAMESPACE.asset
-
-    def transform(self, graph: Graph) -> None:
-        for event_id_result in graph.query(f"SELECT DISTINCT ?event_id WHERE {{?event_id a <{self.event_type}>}}"):
-            event_id: URIRef = cast(tuple, event_id_result)[0]
-
-            if assets_id_res := list(
-                graph.query(
-                    self._asset_template.format(
-                        event_id=event_id,
-                        asset_prop=self.asset_prop,
-                        asset_type=self.asset_type,
-                    )
-                )
-            ):
-                # files can be connected to multiple assets in the graph
-                for (asset_id,) in cast(list[tuple], assets_id_res):
-                    graph.add((asset_id, DEFAULT_NAMESPACE.event, event_id))
+    _item_type = DEFAULT_NAMESPACE.Event
+    _default_attribute = DEFAULT_NAMESPACE.assetIds
+    _connection_type = DEFAULT_NAMESPACE.event
 
 
 class AssetRelationshipConnector(BaseTransformer):
@@ -271,9 +187,9 @@ class AssetRelationshipConnector(BaseTransformer):
     ):
         self.asset_type = asset_type or DEFAULT_NAMESPACE.Asset
         self.relationship_type = relationship_type or DEFAULT_NAMESPACE.Relationship
-        self.relationship_source_xid_prop = relationship_source_xid_prop or DEFAULT_NAMESPACE.source_external_id
-        self.relationship_target_xid_prop = relationship_target_xid_prop or DEFAULT_NAMESPACE.target_external_id
-        self.asset_xid_property = asset_xid_property or DEFAULT_NAMESPACE.external_id
+        self.relationship_source_xid_prop = relationship_source_xid_prop or DEFAULT_NAMESPACE.sourceExternalId
+        self.relationship_target_xid_prop = relationship_target_xid_prop or DEFAULT_NAMESPACE.targetExternalId
+        self.asset_xid_property = asset_xid_property or DEFAULT_NAMESPACE.externalId
 
     def transform(self, graph: Graph) -> None:
         for relationship_id_result in graph.query(

cognite/neat/_graph/transformers/_prune_graph.py

@@ -123,4 +123,4 @@ class PruneDanglingNodes(BaseTransformer):
             for node in nodes_without_neighbours:
                 # Remove node and its property triples in the graph
                 if isinstance(node, ResultRow):
-                    graph.remove(triple=(node["subject"], None, None))
+                    graph.remove((node["subject"], None, None))

cognite/neat/_graph/transformers/_rdfpath.py

@@ -49,7 +49,7 @@ class AddSelfReferenceProperty(BaseTransformer):
                 )
 
             traversal = SingleProperty.from_string(
-                class_=property_.class_.id,
+                class_=property_.view.id,
                 property_=f"{self.rules.metadata.prefix}:{property_.property_}",
             )
 

cognite/neat/_issues/warnings/__init__.py

@@ -6,6 +6,7 @@ from cognite.neat._issues._base import DefaultWarning, NeatWarning, _get_subclas
 
 from . import user_modeling
 from ._external import (
+    AuthWarning,
     FileItemNotSupportedWarning,
     FileMissingRequiredFieldWarning,
     FileReadWarning,
@@ -26,6 +27,8 @@ from ._models import (
 from ._properties import (
     PropertyDefinitionDuplicatedWarning,
     PropertyNotFoundWarning,
+    PropertyOverwritingWarning,
+    PropertySkippedWarning,
     PropertyTypeNotSupportedWarning,
     PropertyValueTypeUndefinedWarning,
 )
@@ -52,6 +55,8 @@ __all__ = [
     "PropertyTypeNotSupportedWarning",
     "PropertyNotFoundWarning",
     "PropertyValueTypeUndefinedWarning",
+    "PropertyOverwritingWarning",
+    "PropertySkippedWarning",
     "ResourceNeatWarning",
     "ResourcesDuplicatedWarning",
     "RegexViolationWarning",
@@ -64,6 +69,7 @@ __all__ = [
     "NotSupportedViewContainerLimitWarning",
     "NotSupportedHasDataFilterLimitWarning",
     "UndefinedViewWarning",
+    "AuthWarning",
     "user_modeling",
 ]
 

cognite/neat/_issues/warnings/_external.py

@@ -38,3 +38,11 @@ class FileItemNotSupportedWarning(NeatWarning):
 
     item: str
     filepath: Path
+
+
+@dataclass(unsafe_hash=True)
+class AuthWarning(NeatWarning):
+    """Failed to {action} due to {reason}"""
+
+    action: str
+    reason: str

cognite/neat/_issues/warnings/_properties.py

@@ -54,3 +54,19 @@ class PropertyValueTypeUndefinedWarning(PropertyWarning[T_Identifier]):
 
     default_action: str
     recommended_action: str | None = None
+
+
+@dataclass(unsafe_hash=True)
+class PropertyOverwritingWarning(PropertyWarning[T_Identifier]):
+    """Overwriting the {overwriting} for {property_name} in the {resource_type}
+    with identifier {identifier}."""
+
+    overwriting: tuple[str, ...]
+
+
+@dataclass(unsafe_hash=True)
+class PropertySkippedWarning(PropertyWarning[T_Identifier]):
+    """The {resource_type} with identifier {identifier} has a property {property_name}
+    which is skipped. {reason}."""
+
+    reason: str

cognite/neat/_rules/_constants.py

@@ -1,6 +1,7 @@
 import re
 import sys
 from functools import cached_property
+from typing import Literal
 
 if sys.version_info >= (3, 11):
     from enum import StrEnum
@@ -42,7 +43,7 @@ class EntityTypes(StrEnum):
     space = "space"
 
 
-def get_reserved_words() -> dict[str, list[str]]:
+def get_reserved_words(key: Literal["class", "view", "property", "space"]) -> list[str]:
     return {
         "class": ["Class", "class"],
         "view": [
@@ -82,7 +83,7 @@ def get_reserved_words() -> dict[str, list[str]]:
             "extensions",
         ],
         "space": ["space", "cdf", "dms", "pg3", "shared", "system", "node", "edge"],
-    }
+    }[key]
 
 
 ENTITY_PATTERN = re.compile(r"^(?P<prefix>.*?):?(?P<suffix>[^(:]*)(\((?P<content>.+)\))?$")
@@ -93,20 +94,20 @@ MORE_THAN_ONE_NONE_ALPHANUMERIC_REGEX = r"([_-]{2,})"
 PREFIX_COMPLIANCE_REGEX = r"^([a-zA-Z]+)([a-zA-Z0-9]*[_-]{0,1}[a-zA-Z0-9_-]*)([a-zA-Z0-9]*)$"
 
 SPACE_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['space'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('space'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_-]{0,41}[a-zA-Z0-9]?$)"
 )
 
 
 DATA_MODEL_COMPLIANCE_REGEX = r"^[a-zA-Z]([a-zA-Z0-9_]{0,253}[a-zA-Z0-9])?$"
 
 VIEW_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['view'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('view'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
 )
 DMS_PROPERTY_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['property'])})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('property'))})$)" r"(^[a-zA-Z][a-zA-Z0-9_]{0,253}[a-zA-Z0-9]?$)"
 )
 CLASS_ID_COMPLIANCE_REGEX = (
-    rf"(?!^({'|'.join(get_reserved_words()['class'])})$)" r"(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
+    rf"(?!^({'|'.join(get_reserved_words('class'))})$)" r"(^[a-zA-Z][a-zA-Z0-9._-]{0,253}[a-zA-Z0-9]?$)"
 )
 
 INFORMATION_PROPERTY_ID_COMPLIANCE_REGEX = (

cognite/neat/_rules/analysis/_base.py

@@ -109,14 +109,14 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
         raise NotImplementedError
 
     # Todo Lru cache this method.
-    def class_parent_pairs(self) -> dict[T_ClassEntity, list[T_ClassEntity]]:
+    def class_parent_pairs(self, allow_different_space: bool = False) -> dict[T_ClassEntity, list[T_ClassEntity]]:
         """This only returns class - parent pairs only if parent is in the same data model"""
         class_subclass_pairs: dict[T_ClassEntity, list[T_ClassEntity]] = {}
         for cls_ in self._get_classes():
             entity = self._get_cls_entity(cls_)
             class_subclass_pairs[entity] = []
             for parent in self._get_cls_parents(cls_) or []:
-                if parent.prefix == entity.prefix:
+                if parent.prefix == entity.prefix or allow_different_space:
                     class_subclass_pairs[entity].append(parent)
                 else:
                     warnings.warn(
@@ -126,11 +126,15 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
 
         return class_subclass_pairs
 
-    def classes_with_properties(self, consider_inheritance: bool = False) -> dict[T_ClassEntity, list[T_Property]]:
+    def classes_with_properties(
+        self, consider_inheritance: bool = False, allow_different_namespace: bool = False
+    ) -> dict[T_ClassEntity, list[T_Property]]:
         """Returns classes that have been defined in the data model.
 
         Args:
             consider_inheritance: Whether to consider inheritance or not. Defaults False
+            allow_different_namespace: When considering inheritance, whether to allow parents from
+                different namespaces or not. Defaults False
 
         Returns:
             Dictionary of classes with a list of properties defined for them
@@ -150,7 +154,7 @@ class BaseAnalysis(ABC, Generic[T_Rules, T_Class, T_Property, T_ClassEntity, T_P
             class_property_pairs[self._get_cls_entity(property_)].append(property_)  # type: ignore
 
         if consider_inheritance:
-            class_parent_pairs = self.class_parent_pairs()
+            class_parent_pairs = self.class_parent_pairs(allow_different_namespace)
             for class_ in class_parent_pairs:
                 self._add_inherited_properties(class_, class_property_pairs, class_parent_pairs)
 

cognite/neat/_rules/exporters/_base.py

@@ -3,8 +3,7 @@ from collections.abc import Iterable
 from pathlib import Path
 from typing import Generic, TypeVar
 
-from cognite.client import CogniteClient
-
+from cognite.neat._client import NeatClient
 from cognite.neat._rules._shared import T_VerifiedRules
 from cognite.neat._utils.auxiliary import class_html_doc
 from cognite.neat._utils.upload import UploadResult, UploadResultList
@@ -32,11 +31,11 @@ class BaseExporter(ABC, Generic[T_VerifiedRules, T_Export]):
 class CDFExporter(BaseExporter[T_VerifiedRules, T_Export]):
     @abstractmethod
     def export_to_cdf_iterable(
-        self, rules: T_VerifiedRules, client: CogniteClient, dry_run: bool = False, fallback_one_by_one: bool = False
+        self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
     ) -> Iterable[UploadResult]:
         raise NotImplementedError
 
     def export_to_cdf(
-        self, rules: T_VerifiedRules, client: CogniteClient, dry_run: bool = False, fallback_one_by_one: bool = False
+        self, rules: T_VerifiedRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
     ) -> UploadResultList:
         return UploadResultList(self.export_to_cdf_iterable(rules, client, dry_run, fallback_one_by_one))

cognite/neat/_rules/exporters/_rules2dms.py

@@ -3,7 +3,6 @@ from collections.abc import Collection, Hashable, Iterable, Sequence
 from pathlib import Path
 from typing import Literal, TypeAlias, cast
 
-from cognite.client import CogniteClient
 from cognite.client.data_classes._base import CogniteResource, CogniteResourceList
 from cognite.client.data_classes.data_modeling import (
     ContainerApplyList,
@@ -15,23 +14,14 @@ from cognite.client.data_classes.data_modeling import (
 )
 from cognite.client.exceptions import CogniteAPIError
 
+from cognite.neat._client import DataModelingLoader, NeatClient
+from cognite.neat._client.data_classes.schema import DMSSchema
 from cognite.neat._issues import IssueList
 from cognite.neat._issues.warnings import (
     PrincipleOneModelOneSpaceWarning,
     ResourceRetrievalWarning,
 )
-from cognite.neat._rules.models.dms import DMSRules, DMSSchema, PipelineSchema
-from cognite.neat._utils.cdf.loaders import (
-    ContainerLoader,
-    DataModelingLoader,
-    DataModelLoader,
-    RawDatabaseLoader,
-    RawTableLoader,
-    ResourceLoader,
-    SpaceLoader,
-    TransformationLoader,
-    ViewLoader,
-)
+from cognite.neat._rules.models.dms import DMSRules
 from cognite.neat._utils.upload import UploadResult
 
 from ._base import CDFExporter
@@ -119,14 +109,14 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         return rules.as_schema(include_pipeline=self.export_pipeline, instance_space=self.instance_space)
 
     def delete_from_cdf(
-        self, rules: DMSRules, client: CogniteClient, dry_run: bool = False, skip_space: bool = False
+        self, rules: DMSRules, client: NeatClient, dry_run: bool = False, skip_space: bool = False
     ) -> Iterable[UploadResult]:
-        to_export = self._prepare_exporters(rules, client)
+        to_export = self._prepare_exporters(rules)
 
         # 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 items, loader in reversed(to_export):
-            if skip_space and isinstance(loader, SpaceLoader):
+            if skip_space and isinstance(items, SpaceApplyList):
                 continue
             item_ids = loader.get_ids(items)
             existing_items = loader.retrieve(item_ids)
@@ -166,9 +156,9 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
             )
 
     def export_to_cdf_iterable(
-        self, rules: DMSRules, client: CogniteClient, dry_run: bool = False, fallback_one_by_one: bool = False
+        self, rules: DMSRules, client: NeatClient, dry_run: bool = False, fallback_one_by_one: bool = False
     ) -> Iterable[UploadResult]:
-        to_export = self._prepare_exporters(rules, client)
+        to_export = self._prepare_exporters(rules)
 
         result_by_name = {}
         if self.existing_handling == "force":
@@ -176,17 +166,18 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 result_by_name[delete_result.name] = delete_result
 
         redeploy_data_model = False
-        for items, loader in to_export:
+        for items 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
+            is_redeploying = isinstance(items, DataModelApplyList) and redeploy_data_model
+            loader = client.loaders.get_loader(items)
 
             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)
+            warning_list = self._validate(loader, items, client)
             issue_list.extend(warning_list)
 
             created: set[Hashable] = set()
@@ -206,6 +197,8 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                     failed_changed.update(loader.get_id(item) for item in to_update)
                 else:
                     raise ValueError(f"Unsupported existing_handling {self.existing_handling}")
+                created.update(loader.get_id(item) for item in to_create)
+                deleted.update(loader.get_id(item) for item in to_delete)
             else:
                 if to_delete:
                     try:
@@ -226,7 +219,7 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                     else:
                         deleted.update(loader.get_id(item) for item in to_delete)
 
-                if isinstance(loader, DataModelingLoader):
+                if isinstance(items, DataModelApplyList):
                     to_create = loader.sort_by_dependencies(to_create)
 
                 try:
@@ -292,11 +285,11 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 issues=issue_list,
             )
 
-            if loader is ViewLoader and (created or changed):
+            if isinstance(items, ViewApplyList) and (created or changed):
                 redeploy_data_model = True
 
     def _categorize_items_for_upload(
-        self, loader: ResourceLoader, items: Sequence[CogniteResource], is_redeploying
+        self, loader: DataModelingLoader, 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)
@@ -304,7 +297,7 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         to_create, to_update, unchanged, to_delete = [], [], [], []
         for item in items:
             if (
-                isinstance(loader, DataModelingLoader)
+                isinstance(items, DataModelApplyList)
                 and self.include_space is not None
                 and not loader.in_space(item, self.include_space)
             ):
@@ -322,28 +315,24 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
                 to_update.append(item)
         return to_create, to_delete, to_update, unchanged
 
-    def _prepare_exporters(self, rules, client) -> list[tuple[CogniteResourceList, ResourceLoader]]:
+    def _prepare_exporters(self, rules: DMSRules) -> list[CogniteResourceList]:
         schema = self.export(rules)
-        to_export: list[tuple[CogniteResourceList, ResourceLoader]] = []
+        to_export: list[CogniteResourceList] = []
         if self.export_components.intersection({"all", "spaces"}):
-            to_export.append((SpaceApplyList(schema.spaces.values()), SpaceLoader(client)))
+            to_export.append(SpaceApplyList(schema.spaces.values()))
         if self.export_components.intersection({"all", "containers"}):
-            to_export.append((ContainerApplyList(schema.containers.values()), ContainerLoader(client)))
+            to_export.append(ContainerApplyList(schema.containers.values()))
         if self.export_components.intersection({"all", "views"}):
-            to_export.append((ViewApplyList(schema.views.values()), ViewLoader(client, self.existing_handling)))
+            to_export.append(ViewApplyList(schema.views.values()))
         if self.export_components.intersection({"all", "data_models"}):
-            to_export.append((DataModelApplyList([schema.data_model]), DataModelLoader(client)))
-        if isinstance(schema, PipelineSchema):
-            to_export.append((schema.databases, RawDatabaseLoader(client)))
-            to_export.append((schema.raw_tables, RawTableLoader(client)))
-            to_export.append((schema.transformations, TransformationLoader(client)))
+            to_export.append(DataModelApplyList([schema.data_model]))
         return to_export
 
-    def _validate(self, loader: ResourceLoader, items: CogniteResourceList) -> IssueList:
+    def _validate(self, loader: DataModelingLoader, items: CogniteResourceList, client: NeatClient) -> IssueList:
         issue_list = IssueList()
-        if isinstance(loader, DataModelLoader):
+        if isinstance(items, DataModelApplyList):
             models = cast(list[DataModelApply], items)
-            if other_models := self._exist_other_data_models(loader, models):
+            if other_models := self._exist_other_data_models(client, models):
                 warning = PrincipleOneModelOneSpaceWarning(
                     f"There are multiple data models in the same space {models[0].space}. "
                     f"Other data models in the space are {other_models}.",
@@ -355,13 +344,13 @@ class DMSExporter(CDFExporter[DMSRules, DMSSchema]):
         return issue_list
 
     @classmethod
-    def _exist_other_data_models(cls, loader: DataModelLoader, models: list[DataModelApply]) -> list[DataModelId]:
+    def _exist_other_data_models(cls, client: NeatClient, models: list[DataModelApply]) -> list[DataModelId]:
         if not models:
             return []
         space = models[0].space
         external_id = models[0].external_id
         try:
-            data_models = loader.client.data_modeling.data_models.list(space=space, limit=25, all_versions=False)
+            data_models = client.data_modeling.data_models.list(space=space, limit=25, all_versions=False)
         except CogniteAPIError as e:
             warnings.warn(ResourceRetrievalWarning(frozenset({space}), "space", str(e)), stacklevel=2)
             return []