cognite-toolkit 0.5.97__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/migration.py

@@ -0,0 +1,111 @@
+from collections.abc import Hashable, Iterable, Sequence, Sized
+from typing import Any, final
+
+from cognite.client.data_classes import capabilities
+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 (
+    ResourceViewMapping,
+    ResourceViewMappingApply,
+)
+from cognite_toolkit._cdf_tk.constants import COGNITE_MIGRATION_SPACE
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
+from cognite_toolkit._cdf_tk.resource_classes import ResourceViewMappingYAML
+from cognite_toolkit._cdf_tk.utils import in_dict
+
+from .datamodel import SpaceCRUD, ViewCRUD
+
+
+@final
+class ResourceViewMappingCRUD(ResourceCRUD[str, ResourceViewMappingApply, ResourceViewMapping]):
+    folder_name = "migration"
+    resource_cls = ResourceViewMapping
+    resource_write_cls = ResourceViewMappingApply
+    kind = "ResourceViewMapping"
+    dependencies = frozenset({SpaceCRUD, ViewCRUD})
+    _doc_url = "Instances/operation/applyNodeAndEdges"
+    yaml_cls = ResourceViewMappingYAML
+
+    @property
+    def display_name(self) -> str:
+        return "resource view mapping"
+
+    @classmethod
+    def get_id(cls, item: ResourceViewMapping | ResourceViewMappingApply | dict) -> str:
+        if isinstance(item, dict):
+            return item["externalId"]
+        return item.external_id
+
+    @classmethod
+    def dump_id(cls, id: str) -> dict[str, Any]:
+        return {"externalId": id}
+
+    @classmethod
+    def get_required_capability(
+        cls, items: Sequence[ResourceViewMappingApply] | None, read_only: bool
+    ) -> Capability | list[Capability]:
+        if not items and items is not None:
+            return []
+
+        actions = (
+            [capabilities.DataModelInstancesAcl.Action.Read]
+            if read_only
+            else [capabilities.DataModelInstancesAcl.Action.Read, capabilities.DataModelInstancesAcl.Action.Write]
+        )
+
+        return capabilities.DataModelInstancesAcl(
+            actions=actions, scope=capabilities.DataModelInstancesAcl.Scope.SpaceID([COGNITE_MIGRATION_SPACE])
+        )
+
+    def prerequisite_warning(self) -> str | None:
+        view_id = ResourceViewMapping.get_source()
+        views = self.client.data_modeling.views.retrieve(view_id)
+        if len(views) > 0:
+            return None
+        return f"{self.display_name} requires the {view_id!r} to be deployed. run `cdf migrate prepare` to deploy it."
+
+    def create(self, items: Sequence[ResourceViewMappingApply]) -> Sized:
+        return self.client.migration.resource_view_mapping.upsert(items)
+
+    def update(self, items: Sequence[ResourceViewMappingApply]) -> Sized:
+        return self.client.migration.resource_view_mapping.upsert(items)
+
+    def retrieve(self, ids: SequenceNotStr[str]) -> NodeList[ResourceViewMapping]:
+        return self.client.migration.resource_view_mapping.retrieve(external_id=ids)
+
+    def delete(self, ids: SequenceNotStr[str]) -> int:
+        result = self.client.migration.resource_view_mapping.delete(external_id=ids)
+        return len(result)
+
+    def _iterate(
+        self,
+        data_set_external_id: str | None = None,
+        space: str | None = None,
+        parent_ids: list[Hashable] | None = None,
+    ) -> Iterable[ResourceViewMapping]:
+        if space == COGNITE_MIGRATION_SPACE:
+            return self.client.migration.resource_view_mapping.list(limit=-1)
+        else:
+            return []
+
+    @classmethod
+    def get_dependent_items(cls, item: dict) -> "Iterable[tuple[type[ResourceCRUD], Hashable]]":
+        yield SpaceCRUD, COGNITE_MIGRATION_SPACE
+
+        yield ViewCRUD, ResourceViewMapping.get_source()
+
+        if "viewId" in item:
+            view_id = item["viewId"]
+            if isinstance(view_id, dict) and in_dict(("space", "externalId"), view_id):
+                yield ViewCRUD, ViewId.load(view_id)
+
+    def dump_resource(self, resource: ResourceViewMapping, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.as_write().dump(context="local")
+        local = local or {}
+        if "existingVersion" not in local:
+            # Existing version is typically not set when creating nodes, but we get it back
+            # when we retrieve the node from the server.
+            dumped.pop("existingVersion", None)
+        return dumped

cognite_toolkit/_cdf_tk/{loaders/_resource_loaders/raw_loaders.py → cruds/_resource_cruds/raw.py}

@@ -30,26 +30,21 @@ 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.loaders._base_loaders import ResourceContainerLoader, ResourceLoader
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceContainerCRUD, ResourceCRUD
 from cognite_toolkit._cdf_tk.resource_classes import DatabaseYAML, TableYAML
 
-from .auth_loaders import GroupAllScopedLoader
+from .auth import GroupAllScopedCRUD
 
 
 @final
-class RawDatabaseLoader(
-    ResourceContainerLoader[RawDatabase, RawDatabase, RawDatabase, RawDatabaseList, RawDatabaseList]
-):
+class RawDatabaseCRUD(ResourceContainerCRUD[RawDatabase, RawDatabase, RawDatabase]):
     item_name = "raw tables"
     folder_name = "raw"
-    filename_pattern = r"^(?!.*Table$).*$"
     resource_cls = RawDatabase
     resource_write_cls = RawDatabase
-    list_cls = RawDatabaseList
-    list_write_cls = RawDatabaseList
     kind = "Database"
     yaml_cls = DatabaseYAML
-    dependencies = frozenset({GroupAllScopedLoader})
+    dependencies = frozenset({GroupAllScopedCRUD})
     support_update = False
     _doc_url = "Raw/operation/createDBs"
 
@@ -80,9 +75,9 @@ class RawDatabaseLoader(
             for item in items:
                 tables_by_database[item.db_name] = []
 
-            scope = RawAcl.Scope.Table(dict(tables_by_database)) if tables_by_database else RawAcl.Scope.All()  # type: ignore[arg-type]
+            scope = RawAcl.Scope.Table(dict(tables_by_database)) if tables_by_database else RawAcl.Scope.All()
 
-        return RawAcl(actions, scope)  # type: ignore[arg-type]
+        return RawAcl(actions, scope)
 
     @classmethod
     def get_id(cls, item: RawDatabase | dict) -> RawDatabase:
@@ -94,7 +89,7 @@ class RawDatabaseLoader(
     def dump_id(cls, id: RawDatabase) -> dict[str, Any]:
         return {"dbName": id.db_name}
 
-    def create(self, items: RawDatabaseList) -> RawDatabaseList:
+    def create(self, items: Sequence[RawDatabase]) -> RawDatabaseList:
         database_list = self.client.raw.databases.create([db.db_name for db in items])
         return RawDatabaseList([RawDatabase(db_name=db.name) for db in database_list if db.name])
 
@@ -153,20 +148,17 @@ class RawDatabaseLoader(
 
 
 @final
-class RawTableLoader(ResourceContainerLoader[RawTable, RawTable, RawTable, RawTableList, RawTableList]):
+class RawTableCRUD(ResourceContainerCRUD[RawTable, RawTable, RawTable]):
     item_name = "raw rows"
     folder_name = "raw"
-    filename_pattern = r"^(?!.*Database$).*$"
     resource_cls = RawTable
     resource_write_cls = RawTable
-    list_cls = RawTableList
-    list_write_cls = RawTableList
     kind = "Table"
     yaml_cls = TableYAML
     support_update = False
-    dependencies = frozenset({RawDatabaseLoader, GroupAllScopedLoader})
+    dependencies = frozenset({RawDatabaseCRUD, GroupAllScopedCRUD})
     _doc_url = "Raw/operation/createTables"
-    parent_resource = frozenset({RawDatabaseLoader})
+    parent_resource = frozenset({RawDatabaseCRUD})
 
     def __init__(self, client: ToolkitClient, build_dir: Path, console: Console | None):
         super().__init__(client, build_dir, console)
@@ -195,9 +187,9 @@ class RawTableLoader(ResourceContainerLoader[RawTable, RawTable, RawTable, RawTa
             for item in items:
                 tables_by_database[item.db_name].append(item.table_name)
 
-            scope = RawAcl.Scope.Table(dict(tables_by_database)) if tables_by_database else RawAcl.Scope.All()  # type: ignore[arg-type]
+            scope = RawAcl.Scope.Table(dict(tables_by_database)) if tables_by_database else RawAcl.Scope.All()
 
-        return RawAcl(actions, scope)  # type: ignore[arg-type]
+        return RawAcl(actions, scope)
 
     @classmethod
     def get_id(cls, item: RawTable | dict) -> RawTable:
@@ -213,11 +205,11 @@ class RawTableLoader(ResourceContainerLoader[RawTable, RawTable, RawTable, RawTa
         return {"dbName": id.db_name, "tableName": id.table_name}
 
     @classmethod
-    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceLoader], Hashable]]:
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if "dbName" in item:
-            yield RawDatabaseLoader, RawDatabase(item["dbName"])
+            yield RawDatabaseCRUD, RawDatabase(item["dbName"])
 
-    def create(self, items: RawTableList) -> RawTableList:
+    def create(self, items: Sequence[RawTable]) -> RawTableList:
         created = RawTableList([])
         for db_name, raw_tables in itertools.groupby(sorted(items, key=lambda x: x.db_name), key=lambda x: x.db_name):
             tables = [table.table_name for table in raw_tables]
@@ -273,8 +265,8 @@ class RawTableLoader(ResourceContainerLoader[RawTable, RawTable, RawTable, RawTa
         for parent_id in parent_ids or (RawDatabase(cast(str, db.name)) for db in self.client.raw.databases):
             if not isinstance(parent_id, RawDatabase):
                 continue
-            for table in self.client.raw.tables(cast(str, parent_id.db_name)):
-                yield RawTable(db_name=cast(str, parent_id.db_name), table_name=cast(str, table.name))
+            for table in self.client.raw.tables(parent_id.db_name):
+                yield RawTable(db_name=parent_id.db_name, table_name=cast(str, table.name))
 
     def count(self, ids: SequenceNotStr[RawTable]) -> int:
         if not self._printed_warning:

cognite_toolkit/_cdf_tk/{loaders/_resource_loaders/relationship_loader.py → cruds/_resource_cruds/relationship.py}

@@ -1,39 +1,34 @@
 from collections.abc import Hashable, Iterable, Sequence
-from functools import lru_cache
 from typing import Any, final
 
 from cognite.client.data_classes import (
     Relationship,
     RelationshipList,
     RelationshipWrite,
-    RelationshipWriteList,
     capabilities,
 )
 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._parameters import ANY_INT, ParameterSpec, ParameterSpecSet
-from cognite_toolkit._cdf_tk.loaders._base_loaders import ResourceLoader
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
+from cognite_toolkit._cdf_tk.resource_classes import RelationshipYAML
 
-from .classic_loaders import AssetLoader, EventLoader, SequenceLoader
-from .data_organization_loaders import DataSetsLoader, LabelLoader
-from .file_loader import FileMetadataLoader
-from .timeseries_loaders import TimeSeriesLoader
+from .classic import AssetCRUD, EventCRUD, SequenceCRUD
+from .data_organization import DataSetsCRUD, LabelCRUD
+from .file import FileMetadataCRUD
+from .timeseries import TimeSeriesCRUD
 
 
 @final
-class RelationshipLoader(ResourceLoader[str, RelationshipWrite, Relationship, RelationshipWriteList, RelationshipList]):
+class RelationshipCRUD(ResourceCRUD[str, RelationshipWrite, Relationship]):
     folder_name = "classic"
-    filename_pattern = r"^.*\.Relationship$"  # Matches all yaml files whose stem ends with '.Asset'.
-    filetypes = frozenset({"yaml", "yml"})
     resource_cls = Relationship
     resource_write_cls = RelationshipWrite
-    list_cls = RelationshipList
-    list_write_cls = RelationshipWriteList
     kind = "Relationship"
+    yaml_cls = RelationshipYAML
     dependencies = frozenset(
-        {DataSetsLoader, AssetLoader, EventLoader, SequenceLoader, FileMetadataLoader, TimeSeriesLoader, LabelLoader}
+        {DataSetsCRUD, AssetCRUD, EventCRUD, SequenceCRUD, FileMetadataCRUD, TimeSeriesCRUD, LabelCRUD}
     )
     _doc_url = "Relationships/operation/createRelationships"
 
@@ -73,18 +68,15 @@ class RelationshipLoader(ResourceLoader[str, RelationshipWrite, Relationship, Re
             if data_set_ids := {item.data_set_id for item in items if item.data_set_id}:
                 scope = capabilities.RelationshipsAcl.Scope.DataSet(list(data_set_ids))
 
-        return capabilities.RelationshipsAcl(
-            actions,
-            scope,  # type: ignore[arg-type]
-        )
+        return capabilities.RelationshipsAcl(actions, scope)
 
-    def create(self, items: RelationshipWriteList) -> RelationshipList:
+    def create(self, items: Sequence[RelationshipWrite]) -> RelationshipList:
         return self.client.relationships.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> RelationshipList:
         return self.client.relationships.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: RelationshipWriteList) -> RelationshipList:
+    def update(self, items: Sequence[RelationshipWrite]) -> RelationshipList:
         return self.client.relationships.update(items)
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
@@ -109,33 +101,19 @@ class RelationshipLoader(ResourceLoader[str, RelationshipWrite, Relationship, Re
         )
 
     @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Added by toolkit
-        spec.add(ParameterSpec(("dataSetExternalId",), frozenset({"str"}), is_required=False, _is_nullable=False))
-        spec.discard(ParameterSpec(("dataSetId",), frozenset({"int"}), is_required=False, _is_nullable=False))
-
-        # Failure from generation of spec
-        spec.add(
-            ParameterSpec(("labels", ANY_INT, "externalId"), frozenset({"str"}), is_required=False, _is_nullable=False)
-        )
-        return spec
-
-    @classmethod
-    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceLoader], Hashable]]:
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         """Returns all items that this item requires.
 
         For example, a TimeSeries requires a DataSet, so this method would return the
         DatasetLoader and identifier of that dataset.
         """
         if "dataSetExternalId" in item:
-            yield DataSetsLoader, item["dataSetExternalId"]
+            yield DataSetsCRUD, item["dataSetExternalId"]
         for label in item.get("labels", []):
             if isinstance(label, dict):
-                yield LabelLoader, label["externalId"]
+                yield LabelCRUD, label["externalId"]
             elif isinstance(label, str):
-                yield LabelLoader, label
+                yield LabelCRUD, label
         for connection in ["source", "target"]:
             type_key = f"{connection}Type"
             id_key = f"{connection}ExternalId"
@@ -145,15 +123,15 @@ class RelationshipLoader(ResourceLoader[str, RelationshipWrite, Relationship, Re
                 if isinstance(id_value, str) and isinstance(type_value, str):
                     type_value = type_value.strip().casefold()
                     if type_value == "asset":
-                        yield AssetLoader, id_value
+                        yield AssetCRUD, id_value
                     elif type_value == "sequence":
-                        yield SequenceLoader, id_value
+                        yield SequenceCRUD, id_value
                     elif type_value == "timeseries":
-                        yield TimeSeriesLoader, id_value
+                        yield TimeSeriesCRUD, id_value
                     elif type_value == "file":
-                        yield FileMetadataLoader, id_value
+                        yield FileMetadataCRUD, id_value
                     elif type_value == "event":
-                        yield EventLoader, id_value
+                        yield EventCRUD, 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/{loaders/_resource_loaders/robotics_loaders.py → cruds/_resource_cruds/robotics.py}

@@ -13,36 +13,36 @@ from cognite_toolkit._cdf_tk.client.data_classes.robotics import (
     DataPostProcessing,
     DataPostProcessingList,
     DataPostProcessingWrite,
-    DataPostProcessingWriteList,
     Frame,
     FrameList,
     FrameWrite,
-    FrameWriteList,
     Location,
     LocationList,
     LocationWrite,
-    LocationWriteList,
     Map,
     MapList,
     MapWrite,
-    MapWriteList,
     RobotCapability,
     RobotCapabilityList,
     RobotCapabilityWrite,
-    RobotCapabilityWriteList,
 )
-from cognite_toolkit._cdf_tk.loaders._base_loaders import ResourceLoader
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
+from cognite_toolkit._cdf_tk.resource_classes import (
+    RobotCapabilityYAML,
+    RobotDataPostProcessingYAML,
+    RobotFrameYAML,
+    RobotLocationYAML,
+    RobotMapYAML,
+)
 from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_hashable
 
 
-class RoboticFrameLoader(ResourceLoader[str, FrameWrite, Frame, FrameWriteList, FrameList]):
+class RoboticFrameCRUD(ResourceCRUD[str, FrameWrite, Frame]):
     folder_name = "robotics"
-    filename_pattern = r"^.*\.Frame$"  # Matches all yaml files whose stem ends with '.Frame'.
     resource_cls = Frame
     resource_write_cls = FrameWrite
-    list_cls = FrameList
-    list_write_cls = FrameWriteList
     kind = "Frame"
+    yaml_cls = RobotFrameYAML
     _doc_url = "Frames/operation/createFrames"
 
     @property
@@ -73,18 +73,17 @@ class RoboticFrameLoader(ResourceLoader[str, FrameWrite, Frame, FrameWriteList,
                 capabilities.RoboticsAcl.Action.Create,
                 capabilities.RoboticsAcl.Action.Delete,
                 capabilities.RoboticsAcl.Action.Update,
-                capabilities.RoboticsAcl.Action.Delete,
             ],
             capabilities.RoboticsAcl.Scope.All(),
         )
 
-    def create(self, items: FrameWriteList) -> FrameList:
+    def create(self, items: Sequence[FrameWrite]) -> FrameList:
         return self.client.robotics.frames.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> FrameList:
         return _fallback_to_one_by_one(self.client.robotics.frames.retrieve, ids, FrameList)
 
-    def update(self, items: FrameWriteList) -> FrameList:
+    def update(self, items: Sequence[FrameWrite]) -> FrameList:
         return self.client.robotics.frames.update(items)
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
@@ -103,14 +102,12 @@ class RoboticFrameLoader(ResourceLoader[str, FrameWrite, Frame, FrameWriteList,
         return iter(self.client.robotics.frames)
 
 
-class RoboticLocationLoader(ResourceLoader[str, LocationWrite, Location, LocationWriteList, LocationList]):
+class RoboticLocationCRUD(ResourceCRUD[str, LocationWrite, Location]):
     folder_name = "robotics"
-    filename_pattern = r"^.*\.Location$"  # Matches all yaml files whose stem ends with '.Location'.
     resource_cls = Location
     resource_write_cls = LocationWrite
-    list_cls = LocationList
-    list_write_cls = LocationWriteList
     kind = "Location"
+    yaml_cls = RobotLocationYAML
     _doc_url = "Locations/operation/createLocations"
 
     @property
@@ -145,19 +142,18 @@ class RoboticLocationLoader(ResourceLoader[str, LocationWrite, Location, Locatio
                 capabilities.RoboticsAcl.Action.Create,
                 capabilities.RoboticsAcl.Action.Delete,
                 capabilities.RoboticsAcl.Action.Update,
-                capabilities.RoboticsAcl.Action.Delete,
             ]
         )
 
         return capabilities.RoboticsAcl(actions, capabilities.RoboticsAcl.Scope.All())
 
-    def create(self, items: LocationWriteList) -> LocationList:
+    def create(self, items: Sequence[LocationWrite]) -> LocationList:
         return self.client.robotics.locations.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> LocationList:
         return _fallback_to_one_by_one(self.client.robotics.locations.retrieve, ids, LocationList)
 
-    def update(self, items: LocationWriteList) -> LocationList:
+    def update(self, items: Sequence[LocationWrite]) -> LocationList:
         return self.client.robotics.locations.update(items)
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
@@ -176,18 +172,12 @@ class RoboticLocationLoader(ResourceLoader[str, LocationWrite, Location, Locatio
         return iter(self.client.robotics.locations)
 
 
-class RoboticsDataPostProcessingLoader(
-    ResourceLoader[
-        str, DataPostProcessingWrite, DataPostProcessing, DataPostProcessingWriteList, DataPostProcessingList
-    ]
-):
+class RoboticsDataPostProcessingCRUD(ResourceCRUD[str, DataPostProcessingWrite, DataPostProcessing]):
     folder_name = "robotics"
-    filename_pattern = r"^.*\.DataPostProcessing$"  # Matches all yaml files whose stem ends with '.DataPostProcessing'.
     resource_cls = DataPostProcessing
     resource_write_cls = DataPostProcessingWrite
-    list_cls = DataPostProcessingList
-    list_write_cls = DataPostProcessingWriteList
     kind = "DataPostProcessing"
+    yaml_cls = RobotDataPostProcessingYAML
     _doc_url = "DataPostProcessing/operation/createDataPostProcessing"
 
     @property
@@ -222,19 +212,18 @@ class RoboticsDataPostProcessingLoader(
                 capabilities.RoboticsAcl.Action.Create,
                 capabilities.RoboticsAcl.Action.Delete,
                 capabilities.RoboticsAcl.Action.Update,
-                capabilities.RoboticsAcl.Action.Delete,
             ]
         )
 
         return capabilities.RoboticsAcl(actions, capabilities.RoboticsAcl.Scope.All())
 
-    def create(self, items: DataPostProcessingWriteList) -> DataPostProcessingList:
+    def create(self, items: Sequence[DataPostProcessingWrite]) -> DataPostProcessingList:
         return self.client.robotics.data_postprocessing.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> DataPostProcessingList:
         return _fallback_to_one_by_one(self.client.robotics.data_postprocessing.retrieve, ids, DataPostProcessingList)
 
-    def update(self, items: DataPostProcessingWriteList) -> DataPostProcessingList:
+    def update(self, items: Sequence[DataPostProcessingWrite]) -> DataPostProcessingList:
         # There is a bug in the /update endpoint that requires the input_schema to be a string
         # and not an object. This is a workaround until the bug is fixed.
         # We do the serialization to avoid modifying the original object.
@@ -272,16 +261,12 @@ class RoboticsDataPostProcessingLoader(
         return super().diff_list(local, cdf, json_path)
 
 
-class RobotCapabilityLoader(
-    ResourceLoader[str, RobotCapabilityWrite, RobotCapability, RobotCapabilityWriteList, RobotCapabilityList]
-):
+class RobotCapabilityCRUD(ResourceCRUD[str, RobotCapabilityWrite, RobotCapability]):
     folder_name = "robotics"
-    filename_pattern = r"^.*\.RobotCapability$"  # Matches all yaml files whose stem ends with '.RobotCapability'.
     resource_cls = RobotCapability
     resource_write_cls = RobotCapabilityWrite
-    list_cls = RobotCapabilityList
-    list_write_cls = RobotCapabilityWriteList
     kind = "RobotCapability"
+    yaml_cls = RobotCapabilityYAML
     _doc_url = "RobotCapabilities/operation/createRobotCapabilities"
 
     @property
@@ -316,19 +301,18 @@ class RobotCapabilityLoader(
                 capabilities.RoboticsAcl.Action.Create,
                 capabilities.RoboticsAcl.Action.Delete,
                 capabilities.RoboticsAcl.Action.Update,
-                capabilities.RoboticsAcl.Action.Delete,
             ]
         )
 
         return capabilities.RoboticsAcl(actions, capabilities.RoboticsAcl.Scope.All())
 
-    def create(self, items: RobotCapabilityWriteList) -> RobotCapabilityList:
+    def create(self, items: Sequence[RobotCapabilityWrite]) -> RobotCapabilityList:
         return self.client.robotics.capabilities.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> RobotCapabilityList:
         return _fallback_to_one_by_one(self.client.robotics.capabilities.retrieve, ids, RobotCapabilityList)
 
-    def update(self, items: RobotCapabilityWriteList) -> RobotCapabilityList:
+    def update(self, items: Sequence[RobotCapabilityWrite]) -> RobotCapabilityList:
         # There is a bug in the /update endpoint that requires the input_schema to be a string
         # and not an object. This is a workaround until the bug is fixed.
         # We do the serialization to avoid modifying the original object.
@@ -369,15 +353,13 @@ class RobotCapabilityLoader(
         return super().diff_list(local, cdf, json_path)
 
 
-class RoboticMapLoader(ResourceLoader[str, MapWrite, Map, MapWriteList, MapList]):
+class RoboticMapCRUD(ResourceCRUD[str, MapWrite, Map]):
     folder_name = "robotics"
-    filename_pattern = r"^.*\.Map$"  # Matches all yaml files whose stem ends with '.Map'.
     resource_cls = Map
     resource_write_cls = MapWrite
-    list_cls = MapList
-    list_write_cls = MapWriteList
     kind = "Map"
-    dependencies = frozenset({RoboticFrameLoader, RoboticLocationLoader})
+    dependencies = frozenset({RoboticFrameCRUD, RoboticLocationCRUD})
+    yaml_cls = RobotMapYAML
     _doc_url = "Maps/operation/createMaps"
 
     @property
@@ -413,7 +395,6 @@ class RoboticMapLoader(ResourceLoader[str, MapWrite, Map, MapWriteList, MapList]
                 capabilities.RoboticsAcl.Action.Create,
                 capabilities.RoboticsAcl.Action.Delete,
                 capabilities.RoboticsAcl.Action.Update,
-                capabilities.RoboticsAcl.Action.Delete,
             ]
         )
 
@@ -427,13 +408,13 @@ class RoboticMapLoader(ResourceLoader[str, MapWrite, Map, MapWriteList, MapList]
             del dump["scale"]
         return dump
 
-    def create(self, items: MapWriteList) -> MapList:
+    def create(self, items: Sequence[MapWrite]) -> MapList:
         return self.client.robotics.maps.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> MapList:
         return _fallback_to_one_by_one(self.client.robotics.maps.retrieve, ids, MapList)
 
-    def update(self, items: MapWriteList) -> MapList:
+    def update(self, items: Sequence[MapWrite]) -> MapList:
         return self.client.robotics.maps.update(items)
 
     def delete(self, ids: SequenceNotStr[str]) -> int: