cognite-toolkit 0.7.30__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py

@@ -8,17 +8,18 @@ from cognite.client.data_classes.data_modeling import NodeApplyResultList, NodeI
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.apm_config_v1 import (
-    APMConfig,
-    APMConfigList,
-    APMConfigWrite,
-)
-from cognite_toolkit._cdf_tk.client.data_classes.infield import (
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.infield import (
     InFieldCDMLocationConfig,
     InfieldLocationConfig,
     InfieldLocationConfigList,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.instance_api import InstanceResult, NodeIdentifier
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import InstanceResult, TypedNodeIdentifier
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.apm_config_v1 import (
+    APMConfig,
+    APMConfigList,
+    APMConfigWrite,
+)
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.resource_classes import (
@@ -139,7 +140,7 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig]):
             yield SpaceCRUD, customer_data_space_id
         for config in cls._get_root_location_configurations(item) or []:
             if isinstance(asset_external_id := config.get("assetExternalId"), str):
-                yield AssetCRUD, asset_external_id
+                yield AssetCRUD, ExternalId(external_id=asset_external_id)
             if isinstance(data_set_external_id := config.get("dataSetExternalId"), str):
                 yield DataSetsCRUD, data_set_external_id
             if isinstance(app_data_instance_space := config.get("appDataInstanceSpace"), str):
@@ -162,7 +163,7 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig]):
                         yield DataSetsCRUD, data_set_external_id
                 for asset_external_id in filter_.get("assetSubtreeExternalIds", []):
                     if isinstance(asset_external_id, str):
-                        yield AssetCRUD, asset_external_id
+                        yield AssetCRUD, ExternalId(external_id=asset_external_id)
                 if app_data_instance_space := filter_.get("appDataInstanceSpace"):
                     if isinstance(app_data_instance_space, str):
                         yield SpaceCRUD, app_data_instance_space
@@ -246,7 +247,7 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig]):
 
 
 @final
-class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConfig, InfieldLocationConfig]):
+class InFieldLocationConfigCRUD(ResourceCRUD[TypedNodeIdentifier, InfieldLocationConfig, InfieldLocationConfig]):
     folder_name = "cdf_applications"
     resource_cls = InfieldLocationConfig
     resource_write_cls = InfieldLocationConfig
@@ -260,14 +261,17 @@ class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConf
         return "infield location configs"
 
     @classmethod
-    def get_id(cls, item: InfieldLocationConfig | dict) -> NodeIdentifier:
+    def get_id(cls, item: InfieldLocationConfig | dict) -> TypedNodeIdentifier:
         if isinstance(item, dict):
-            return NodeIdentifier(space=item["space"], external_id=item["externalId"])
-        return NodeIdentifier(space=item.space, external_id=item.external_id)
+            return TypedNodeIdentifier(space=item["space"], external_id=item["externalId"])
+        return TypedNodeIdentifier(space=item.space, external_id=item.external_id)
 
     @classmethod
-    def dump_id(cls, id: NodeIdentifier) -> dict[str, Any]:
-        return id.dump(include_type=False)
+    def dump_id(cls, id: TypedNodeIdentifier) -> dict[str, Any]:
+        return {
+            "space": id.space,
+            "externalId": id.external_id,
+        }
 
     @classmethod
     def get_required_capability(
@@ -308,13 +312,13 @@ class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConf
         # as we only want to count the infield location configs here.
         return [res for res in created if res.as_id() in config_ids]
 
-    def retrieve(self, ids: SequenceNotStr[NodeIdentifier]) -> InfieldLocationConfigList:
+    def retrieve(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> InfieldLocationConfigList:
         return InfieldLocationConfigList(self.client.infield.config.retrieve(list(ids)))
 
     def update(self, items: Sequence[InfieldLocationConfig]) -> Sized:
         return self.create(items)
 
-    def delete(self, ids: SequenceNotStr[NodeIdentifier]) -> int:
+    def delete(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> int:
         # We must retrieve the full resource to get hte DataExplorationConfig linked resource deleted as well.
         retrieved = self.retrieve(list(ids))
         # Then, we pass the entire resource to the delete method, which will delete both the InfieldLocationConfig
@@ -345,7 +349,9 @@ class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConf
 
 
 @final
-class InFieldCDMLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InFieldCDMLocationConfig, InFieldCDMLocationConfig]):
+class InFieldCDMLocationConfigCRUD(
+    ResourceCRUD[TypedNodeIdentifier, InFieldCDMLocationConfig, InFieldCDMLocationConfig]
+):
     folder_name = "cdf_applications"
     resource_cls = InFieldCDMLocationConfig
     resource_write_cls = InFieldCDMLocationConfig
@@ -359,14 +365,17 @@ class InFieldCDMLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InFieldCDMLocati
         return "infield CDM location configs"
 
     @classmethod
-    def get_id(cls, item: InFieldCDMLocationConfig | dict) -> NodeIdentifier:
+    def get_id(cls, item: InFieldCDMLocationConfig | dict) -> TypedNodeIdentifier:
         if isinstance(item, dict):
-            return NodeIdentifier(space=item["space"], external_id=item["externalId"])
-        return NodeIdentifier(space=item.space, external_id=item.external_id)
+            return TypedNodeIdentifier(space=item["space"], external_id=item["externalId"])
+        return TypedNodeIdentifier(space=item.space, external_id=item.external_id)
 
     @classmethod
-    def dump_id(cls, id: NodeIdentifier) -> dict[str, Any]:
-        return id.dump(include_type=False)
+    def dump_id(cls, id: TypedNodeIdentifier) -> dict[str, Any]:
+        return {
+            "space": id.space,
+            "externalId": id.external_id,
+        }
 
     @classmethod
     def get_required_capability(
@@ -397,13 +406,13 @@ class InFieldCDMLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InFieldCDMLocati
     def create(self, items: Sequence[InFieldCDMLocationConfig]) -> list[InstanceResult]:
         return self.client.infield.cdm_config.apply(items)
 
-    def retrieve(self, ids: SequenceNotStr[NodeIdentifier]) -> list[InFieldCDMLocationConfig]:
+    def retrieve(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> list[InFieldCDMLocationConfig]:
         return self.client.infield.cdm_config.retrieve(list(ids))
 
     def update(self, items: Sequence[InFieldCDMLocationConfig]) -> Sized:
         return self.create(items)
 
-    def delete(self, ids: SequenceNotStr[NodeIdentifier]) -> int:
+    def delete(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> int:
         # We must retrieve the full resource to delete it.
         retrieved = self.retrieve(list(ids))
         _ = self.client.infield.cdm_config.delete(retrieved)

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/file.py

@@ -15,13 +15,8 @@
 
 from collections.abc import Hashable, Iterable, Sequence
 from datetime import date, datetime
-from typing import Any, cast, final
+from typing import Any, final
 
-from cognite.client.data_classes import (
-    FileMetadata,
-    FileMetadataList,
-    FileMetadataWrite,
-)
 from cognite.client.data_classes.capabilities import (
     Capability,
     DataModelInstancesAcl,
@@ -31,9 +26,11 @@ from cognite.client.data_classes.data_modeling import NodeApplyResultList, NodeI
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils._time import convert_data_modelling_timestamp
 from cognite.client.utils.useful_types import SequenceNotStr
-from rich import print
 
-from cognite_toolkit._cdf_tk.client.data_classes.extendable_cognite_file import (
+from cognite_toolkit._cdf_tk.client.request_classes.filters import ClassicFilter
+from cognite_toolkit._cdf_tk.client.resource_classes.filemetadata import FileMetadataRequest, FileMetadataResponse
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId, InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.extendable_cognite_file import (
     ExtendableCogniteFile,
     ExtendableCogniteFileApply,
     ExtendableCogniteFileList,
@@ -55,11 +52,11 @@ from .datamodel import SpaceCRUD, ViewCRUD
 
 
 @final
-class FileMetadataCRUD(ResourceContainerCRUD[str, FileMetadataWrite, FileMetadata]):
+class FileMetadataCRUD(ResourceContainerCRUD[ExternalId, FileMetadataRequest, FileMetadataResponse]):
     item_name = "file contents"
     folder_name = "files"
-    resource_cls = FileMetadata
-    resource_write_cls = FileMetadataWrite
+    resource_cls = FileMetadataResponse
+    resource_write_cls = FileMetadataRequest
     yaml_cls = FileMetadataYAML
     kind = "FileMetadata"
     dependencies = frozenset({DataSetsCRUD, GroupAllScopedCRUD, LabelCRUD, AssetCRUD})
@@ -72,7 +69,7 @@ class FileMetadataCRUD(ResourceContainerCRUD[str, FileMetadataWrite, FileMetadat
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[FileMetadataWrite] | None, read_only: bool
+        cls, items: Sequence[FileMetadataRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -87,22 +84,22 @@ class FileMetadataCRUD(ResourceContainerCRUD[str, FileMetadataWrite, FileMetadat
         return FilesAcl(actions, scope)
 
     @classmethod
-    def get_id(cls, item: FileMetadata | FileMetadataWrite | dict) -> str:
+    def get_id(cls, item: FileMetadataRequest | FileMetadataResponse | dict) -> ExternalId:
         if isinstance(item, dict):
-            return item["externalId"]
+            return ExternalId(external_id=item["externalId"])
         if item.external_id is None:
             raise ToolkitRequiredValueError("FileMetadata must have external_id set.")
-        return item.external_id
+        return ExternalId(external_id=item.external_id)
 
     @classmethod
-    def get_internal_id(cls, item: FileMetadata | dict) -> int:
+    def get_internal_id(cls, item: FileMetadataResponse | dict) -> int:
         if isinstance(item, dict):
             return item["id"]
         return item.id
 
     @classmethod
-    def dump_id(cls, id: str) -> dict[str, Any]:
-        return {"externalId": id}
+    def dump_id(cls, id: ExternalId) -> dict[str, Any]:
+        return id.dump()
 
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
@@ -118,71 +115,65 @@ class FileMetadataCRUD(ResourceContainerCRUD[str, FileMetadataWrite, FileMetadat
                 elif isinstance(label, str):
                     yield LabelCRUD, label
         for asset_external_id in item.get("assetExternalIds", []):
-            yield AssetCRUD, asset_external_id
+            yield AssetCRUD, ExternalId(external_id=asset_external_id)
 
-    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> FileMetadataWrite:
-        if resource.get("dataSetExternalId") is not None:
-            ds_external_id = resource.pop("dataSetExternalId")
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> FileMetadataRequest:
+        if ds_external_id := resource.pop("dataSetExternalId", None):
             resource["dataSetId"] = self.client.lookup.data_sets.id(ds_external_id, is_dry_run)
         if security_categories_names := resource.pop("securityCategoryNames", []):
-            security_categories = self.client.lookup.security_categories.id(security_categories_names, is_dry_run)
-            resource["securityCategories"] = security_categories
-        if "assetExternalIds" in resource:
-            resource["assetIds"] = self.client.lookup.assets.id(resource["assetExternalIds"], is_dry_run)
-        return FileMetadataWrite._load(resource)
-
-    def dump_resource(self, resource: FileMetadata, local: dict[str, Any] | None = None) -> dict[str, Any]:
-        dumped = resource.as_write().dump()
-        if ds_id := dumped.pop("dataSetId", None):
-            dumped["dataSetExternalId"] = self.client.lookup.data_sets.external_id(ds_id)
+            resource["securityCategories"] = self.client.lookup.security_categories.id(
+                security_categories_names, is_dry_run
+            )
+        if asset_external_ids := resource.pop("assetExternalIds", None):
+            resource["assetIds"] = self.client.lookup.assets.id(asset_external_ids, is_dry_run)
+        return FileMetadataRequest.model_validate(resource)
+
+    def dump_resource(self, resource: FileMetadataResponse, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.as_request_resource().dump()
+        if data_set_id := dumped.pop("dataSetId", None):
+            dumped["dataSetExternalId"] = self.client.lookup.data_sets.external_id(data_set_id)
         if security_categories := dumped.pop("securityCategories", []):
             dumped["securityCategoryNames"] = self.client.lookup.security_categories.external_id(security_categories)
         if asset_ids := dumped.pop("assetIds", []):
             dumped["assetExternalIds"] = self.client.lookup.assets.external_id(asset_ids)
         return dumped
 
-    def create(self, items: Sequence[FileMetadataWrite]) -> FileMetadataList:
-        created = FileMetadataList([])
-        for meta in items:
-            try:
-                created.append(self.client.files.create(meta))
-            except CogniteAPIError as e:
-                if e.code == 409:
-                    print(f"  [bold yellow]WARNING:[/] File {meta.external_id} already exists, skipping upload.")
-        return created
+    def create(self, items: Sequence[FileMetadataRequest]) -> list[FileMetadataResponse]:
+        return self.client.tool.filemetadata.create(items, overwrite=True)
 
-    def retrieve(self, ids: SequenceNotStr[str]) -> FileMetadataList:
-        return self.client.files.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[FileMetadataResponse]:
+        return self.client.tool.filemetadata.retrieve(list(ids), ignore_unknown_ids=True)
 
-    def update(self, items: Sequence[FileMetadataWrite]) -> FileMetadataList:
-        return self.client.files.update(items, mode="replace")
+    def update(self, items: Sequence[FileMetadataRequest]) -> list[FileMetadataResponse]:
+        return self.client.tool.filemetadata.update(items, mode="replace")
 
-    def delete(self, ids: str | int | SequenceNotStr[str | int] | None) -> int:
-        internal_ids, external_ids = self._split_ids(ids)
-        self.client.files.delete(id=internal_ids, external_id=external_ids)
-        return len(cast(SequenceNotStr[str], ids))
+    def delete(self, ids: SequenceNotStr[InternalOrExternalId]) -> int:
+        if not ids:
+            return 0
+        self.client.tool.filemetadata.delete(list(ids), ignore_unknown_ids=True)
+        return len(ids)
 
     def _iterate(
         self,
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[FileMetadata]:
-        return iter(self.client.files(data_set_external_ids=[data_set_external_id] if data_set_external_id else None))
+    ) -> Iterable[FileMetadataResponse]:
+        filter_ = ClassicFilter.from_asset_subtree_and_data_sets(data_set_id=data_set_external_id)
+        for files in self.client.tool.filemetadata.iterate(filter=filter_, limit=None):
+            yield from files
 
-    def count(self, ids: SequenceNotStr[str]) -> int:
+    def count(self, ids: SequenceNotStr[ExternalId]) -> int:
         return sum(
-            1
-            for meta in self.client.files.retrieve_multiple(external_ids=list(ids), ignore_unknown_ids=True)
-            if meta.uploaded
+            1 for meta in self.client.tool.filemetadata.retrieve(list(ids), ignore_unknown_ids=True) if meta.uploaded
         )
 
-    def drop_data(self, ids: SequenceNotStr[str]) -> int:
-        existing = self.client.files.retrieve_multiple(external_ids=list(ids), ignore_unknown_ids=True)
+    def drop_data(self, ids: SequenceNotStr[ExternalId]) -> int:
+        existing = self.client.tool.filemetadata.retrieve(list(ids), ignore_unknown_ids=True)
         # File and FileMetadata is tightly coupled, so we need to delete the metadata and recreate it
         # without the source set to delete the file.
-        deleted_files = self.delete(existing.as_external_ids())
-        self.create(existing.as_write())
+        deleted_files = self.delete([meta.as_id() for meta in existing])
+        self.create([meta.as_request_resource() for meta in existing])
         return deleted_files
 
 

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/function.py

@@ -22,6 +22,7 @@ from cognite.client.data_classes.capabilities import (
     FunctionsAcl,
     SessionsAcl,
 )
+from cognite.client.data_classes.data_modeling import NodeId
 from cognite.client.data_classes.data_modeling.cdm.v1 import CogniteFileApply
 from cognite.client.data_classes.functions import HANDLER_FILE_NAME
 from cognite.client.exceptions import CogniteAPIError
@@ -30,7 +31,7 @@ from rich import print
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.functions import FunctionScheduleID
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.functions import FunctionScheduleID
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
     ResourceCreationError,
@@ -406,7 +407,18 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function]):
 
         self.client.functions.delete_with_429_retry(external_id=ids, ignore_unknown_ids=True)
         file_ids = {func.file_id for func in functions if func.file_id}
-        self.client.files.delete(id=list(file_ids), ignore_unknown_ids=True)
+        files = self.client.files.retrieve_multiple(list(file_ids), ignore_unknown_ids=True)
+        dm_file_nodes: set[NodeId] = set()
+        classic_file_ids: set[int] = set()
+        for file in files:
+            if file.instance_id is not None:
+                dm_file_nodes.add(file.instance_id)
+            else:
+                classic_file_ids.add(file.id)
+        if classic_file_ids:
+            self.client.files.delete(id=list(classic_file_ids), ignore_unknown_ids=True)
+        if dm_file_nodes:
+            self.client.data_modeling.instances.delete(list(dm_file_nodes))
         return len(ids)
 
     def _iterate(

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/industrial_tool.py

@@ -14,7 +14,7 @@ from packaging.requirements import Requirement
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.streamlit_ import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.streamlit_ import (
     Streamlit,
     StreamlitList,
     StreamlitWrite,

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/location.py

@@ -7,7 +7,8 @@ from cognite.client.data_classes.capabilities import Capability, LocationFilters
 from cognite.client.data_classes.data_modeling import DataModelId, ViewId
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.location_filters import (
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.location_filters import (
     LocationFilter,
     LocationFilterList,
     LocationFilterWrite,
@@ -239,14 +240,14 @@ class LocationFilterCRUD(ResourceCRUD[str, LocationFilterWrite, LocationFilter])
                 yield DataSetsCRUD, data_set_external_id
             for asset in asset_centric.get("assetSubtreeIds", []):
                 if "externalId" in asset:
-                    yield AssetCRUD, asset["externalId"]
+                    yield AssetCRUD, ExternalId(external_id=asset["externalId"])
             for subfilter_name in cls.subfilter_names:
                 subfilter = asset_centric.get(subfilter_name, {})
                 for data_set_external_id in subfilter.get("dataSetExternalIds", []):
                     yield DataSetsCRUD, data_set_external_id
                 for asset in subfilter.get("assetSubtreeIds", []):
                     if "externalId" in asset:
-                        yield AssetCRUD, asset["externalId"]
+                        yield AssetCRUD, ExternalId(external_id=asset["externalId"])
         for view in item.get("views", []):
             if in_dict(["space", "externalId", "version"], view):
                 yield ViewCRUD, ViewId(view["space"], view["externalId"], view["version"])

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/migration.py

@@ -6,7 +6,7 @@ from cognite.client.data_classes.capabilities import Capability
 from cognite.client.data_classes.data_modeling import NodeList, ViewId
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.migration import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import (
     ResourceViewMapping,
     ResourceViewMappingApply,
 )

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/raw.py

@@ -29,7 +29,12 @@ from rich import print
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawDatabase, RawDatabaseList, RawTable, RawTableList
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import (
+    RawDatabase,
+    RawDatabaseList,
+    RawTable,
+    RawTableList,
+)
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceContainerCRUD, ResourceCRUD
 from cognite_toolkit._cdf_tk.resource_classes import DatabaseYAML, TableYAML
 

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/relationship.py

@@ -11,6 +11,7 @@ from cognite.client.data_classes.capabilities import Capability
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.resource_classes import RelationshipYAML
 
@@ -123,15 +124,15 @@ class RelationshipCRUD(ResourceCRUD[str, RelationshipWrite, Relationship]):
                 if isinstance(id_value, str) and isinstance(type_value, str):
                     type_value = type_value.strip().casefold()
                     if type_value == "asset":
-                        yield AssetCRUD, id_value
+                        yield AssetCRUD, ExternalId(external_id=id_value)
                     elif type_value == "sequence":
                         yield SequenceCRUD, id_value
                     elif type_value == "timeseries":
-                        yield TimeSeriesCRUD, id_value
+                        yield TimeSeriesCRUD, ExternalId(external_id=id_value)
                     elif type_value == "file":
-                        yield FileMetadataCRUD, id_value
+                        yield FileMetadataCRUD, ExternalId(external_id=id_value)
                     elif type_value == "event":
-                        yield EventCRUD, id_value
+                        yield EventCRUD, ExternalId(external_id=id_value)
 
     def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> RelationshipWrite:
         if ds_external_id := resource.pop("dataSetExternalId", None):

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/robotics.py

@@ -9,7 +9,7 @@ from cognite.client.data_classes.capabilities import Capability
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.robotics import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.robotics import (
     DataPostProcessing,
     DataPostProcessingList,
     DataPostProcessingWrite,

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/simulators.py

@@ -0,0 +1,122 @@
+from collections.abc import Hashable, Iterable, Sequence
+from typing import Any, final
+
+from cognite.client.data_classes.capabilities import Capability
+from cognite.client.utils.useful_types import SequenceNotStr
+
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId, InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.simulator_model import (
+    SimulatorModelRequest,
+    SimulatorModelResponse,
+)
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
+from cognite_toolkit._cdf_tk.resource_classes import SimulatorModelYAML
+
+from .data_organization import DataSetsCRUD
+
+
+@final
+class SimulatorModelCRUD(ResourceCRUD[ExternalId, SimulatorModelRequest, SimulatorModelResponse]):
+    folder_name = "simulators"
+    resource_cls = SimulatorModelResponse
+    resource_write_cls = SimulatorModelRequest
+    yaml_cls = SimulatorModelYAML
+    kind = "SimulatorModel"
+    dependencies = frozenset({DataSetsCRUD})
+    _doc_url = "Simulator-Models/operation/create_simulator_model_simulators_models_post"
+
+    @property
+    def display_name(self) -> str:
+        return "simulator models"
+
+    @classmethod
+    def get_id(cls, item: SimulatorModelRequest | SimulatorModelResponse | dict) -> ExternalId:
+        if isinstance(item, dict):
+            return ExternalId(external_id=item["externalId"])
+        if not item.external_id:
+            raise KeyError("SimulatorModel must have external_id")
+        return ExternalId(external_id=item.external_id)
+
+    @classmethod
+    def get_internal_id(cls, item: SimulatorModelResponse | dict) -> int:
+        if isinstance(item, dict):
+            return item["id"]
+        if not item.id:
+            raise KeyError("SimulatorModel must have id")
+        return item.id
+
+    @classmethod
+    def dump_id(cls, id: ExternalId) -> dict[str, Any]:
+        return id.dump()
+
+    @classmethod
+    def get_required_capability(
+        cls, items: Sequence[SimulatorModelRequest] | None, read_only: bool
+    ) -> Capability | list[Capability]:
+        # Simulator ACLs is not yet implemented in the PySDK, which means
+        # that we cannot check for specific capabilities.
+        return []
+
+    def create(self, items: Sequence[SimulatorModelRequest]) -> list[SimulatorModelResponse]:
+        return self.client.tool.simulators.models.create(items)
+
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[SimulatorModelResponse]:
+        return self.client.tool.simulators.models.retrieve(list(ids), ignore_unknown_ids=True)
+
+    def update(self, items: Sequence[SimulatorModelRequest]) -> list[SimulatorModelResponse]:
+        return self.client.tool.simulators.models.update(items, mode="replace")
+
+    def delete(self, ids: SequenceNotStr[ExternalId | InternalOrExternalId]) -> int:
+        if not ids:
+            return 0
+        self.client.tool.simulators.models.delete(list(ids))
+        return len(ids)
+
+    def _iterate(
+        self,
+        data_set_external_id: str | None = None,
+        space: str | None = None,
+        parent_ids: list[Hashable] | None = None,
+    ) -> Iterable[SimulatorModelResponse]:
+        # Note: The SimulatorModelsAPI doesn't support data_set_external_id filtering directly,
+        # so we iterate and filter in memory if needed.
+        cursor: str | None = None
+        data_set_id: int | None = None
+        if data_set_external_id:
+            data_set_id = self.client.lookup.data_sets.id(data_set_external_id, is_dry_run=False)
+        while True:
+            page = self.client.tool.simulators.models.paginate(
+                limit=1000,
+                cursor=cursor,
+            )
+            if data_set_id:
+                # Filter by data_set_external_id in memory
+                for item in page.items:
+                    if item.data_set_id == data_set_id:
+                        yield item
+            else:
+                yield from page.items
+            if not page.next_cursor or not page.items:
+                break
+            cursor = page.next_cursor
+
+    @classmethod
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
+        """Returns all items that this item requires.
+
+        For example, a SimulatorModel requires a DataSet, so this method would return the
+        DataSetsCRUD and identifier of that dataset.
+        """
+        if "dataSetExternalId" in item:
+            yield DataSetsCRUD, item["dataSetExternalId"]
+
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> SimulatorModelRequest:
+        if ds_external_id := resource.pop("dataSetExternalId", None):
+            resource["dataSetId"] = self.client.lookup.data_sets.id(ds_external_id, is_dry_run)
+        return SimulatorModelRequest.model_validate(resource)
+
+    def dump_resource(self, resource: SimulatorModelResponse, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.as_request_resource().dump()
+        if data_set_id := dumped.pop("dataSetId", None):
+            dumped["dataSetExternalId"] = self.client.lookup.data_sets.external_id(data_set_id)
+        return dumped