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

cognite_toolkit/_cdf_tk/{loaders/_data_loaders.py → cruds/_data_cruds.py}

@@ -5,28 +5,30 @@ from typing import TYPE_CHECKING, cast, final
 
 import pandas as pd
 from cognite.client.data_classes import FileMetadataWrite
-from cognite.client.data_classes._base import T_CogniteResourceList, T_WritableCogniteResource, T_WriteClass
 
 from cognite_toolkit._cdf_tk.client.data_classes.extendable_cognite_file import ExtendableCogniteFileApply
 from cognite_toolkit._cdf_tk.client.data_classes.raw import RawTable
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
+from cognite_toolkit._cdf_tk.protocols import (
+    T_ResourceRequest,
+    T_ResourceResponse,
+)
 from cognite_toolkit._cdf_tk.utils import read_yaml_content, safe_read
 from cognite_toolkit._cdf_tk.utils.file import read_csv
 
-from ._base_loaders import T_ID, DataLoader, ResourceLoader, T_WritableCogniteResourceList
-from ._resource_loaders import CogniteFileLoader, FileMetadataLoader, RawTableLoader, TimeSeriesLoader
+from ._base_cruds import T_ID, DataCRUD, ResourceCRUD
+from ._resource_cruds import CogniteFileCRUD, FileMetadataCRUD, RawTableCRUD, TimeSeriesCRUD
 
 if TYPE_CHECKING:
     from cognite_toolkit._cdf_tk.data_classes import BuildEnvironment
 
 
 @final
-class DatapointsLoader(DataLoader):
+class DatapointsCRUD(DataCRUD):
     item_name = "datapoints"
     folder_name = "timeseries"
     kind = "Datapoints"
-    filetypes = frozenset({"csv", "parquet"})
-    dependencies = frozenset({TimeSeriesLoader})
+    dependencies = frozenset({TimeSeriesCRUD})
     _doc_url = "Time-series/operation/postMultiTimeSeriesDatapoints"
 
     @property
@@ -40,7 +42,9 @@ class DatapointsLoader(DataLoader):
         resource_directories = state.built_resources[self.folder_name].get_resource_directories(self.folder_name)
 
         for resource_dir in resource_directories:
-            for datafile in self._find_data_files(resource_dir):
+            for datafile in resource_dir.rglob("*"):
+                if not datafile.stem.casefold().endswith(self.kind.casefold()):
+                    continue
                 if datafile.suffix == ".csv":
                     # The replacement is used to ensure that we read exactly the same file on Windows and Linux
                     file_content = datafile.read_bytes().replace(b"\r\n", b"\n").decode("utf-8")
@@ -49,7 +53,7 @@ class DatapointsLoader(DataLoader):
                 elif datafile.suffix == ".parquet":
                     data = pd.read_parquet(datafile, engine="pyarrow")
                 else:
-                    raise ValueError(f"Unsupported file type {datafile.suffix} for {datafile.name}")
+                    continue
                 timeseries_ids = list(data.columns)
                 if len(timeseries_ids) == 1:
                     ts_str = timeseries_ids[0]
@@ -80,17 +84,11 @@ class DatapointsLoader(DataLoader):
 
 
 @final
-class FileLoader(DataLoader):
+class FileCRUD(DataCRUD):
     item_name = "file contents"
     folder_name = "files"
     kind = "File"
-    filetypes = frozenset()
-    exclude_filetype: frozenset[str] = frozenset({})
-    filename_pattern = (
-        # Exclude FileMetadata and CogniteFile
-        r"(?i)^(?!.*(?:FileMetadata|CogniteFile)$).*$"
-    )
-    dependencies = frozenset({FileMetadataLoader, CogniteFileLoader})
+    dependencies = frozenset({FileMetadataCRUD, CogniteFileCRUD})
     _doc_url = "Files/operation/initFileUpload"
 
     @property
@@ -106,8 +104,8 @@ class FileLoader(DataLoader):
                 continue
 
             if result := {
-                FileMetadataLoader.kind: (FileMetadataLoader, "external_id"),
-                CogniteFileLoader.kind: (CogniteFileLoader, "instance_id"),
+                FileMetadataCRUD.kind: (FileMetadataCRUD, "external_id"),
+                CogniteFileCRUD.kind: (CogniteFileCRUD, "instance_id"),
             }.get(resource.kind):
                 loader_cls, id_name = result
                 meta: FileMetadataWrite | ExtendableCogniteFileApply = self._read_metadata(
@@ -130,19 +128,16 @@ class FileLoader(DataLoader):
     @staticmethod
     def _read_metadata(
         destination: Path,
-        loader: type[
-            ResourceLoader[
-                T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
-            ]
-        ],
+        loader: type[ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse]],
         identifier: T_ID,
-    ) -> T_WriteClass:
+    ) -> T_ResourceRequest:
         built_content = read_yaml_content(safe_read(destination, encoding=BUILD_FOLDER_ENCODING))
         if isinstance(built_content, dict):
-            return loader.resource_write_cls.load(built_content)
+            return loader.resource_write_cls._load(built_content)
         elif isinstance(built_content, list):
+            write_resources = (loader.resource_write_cls._load(content) for content in built_content)
             try:
-                return next(m for m in loader.list_write_cls.load(built_content) if loader.get_id(m) == identifier)
+                return next(m for m in write_resources if loader.get_id(m) == identifier)
             except StopIteration:
                 raise RuntimeError(f"Missing metadata for {destination.as_posix()}")
 
@@ -150,12 +145,11 @@ class FileLoader(DataLoader):
 
 
 @final
-class RawFileLoader(DataLoader):
+class RawFileCRUD(DataCRUD):
     item_name = "rows"
     folder_name = "raw"
-    filetypes = frozenset({"csv", "parquet"})
     kind = "Raw"
-    dependencies = frozenset({RawTableLoader})
+    dependencies = frozenset({RawTableCRUD})
     _doc_url = "Raw/operation/postRows"
 
     @property
@@ -167,13 +161,13 @@ class RawFileLoader(DataLoader):
             return
 
         for resource in state.built_resources[self.folder_name]:
-            if resource.kind != RawTableLoader.kind:
+            if resource.kind != RawTableCRUD.kind:
                 continue
             table = cast(RawTable, resource.identifier)
             datafile = next(
                 (
                     resource.source.path.with_suffix(f".{file_type}")
-                    for file_type in self.filetypes
+                    for file_type in ["csv", "parquet"]
                     if (resource.source.path.with_suffix(f".{file_type}").exists())
                 ),
                 None,
@@ -185,8 +179,7 @@ class RawFileLoader(DataLoader):
             if datafile.suffix == ".csv":
                 # The replacement is used to ensure that we read exactly the same file on Windows and Linux
                 file_content = datafile.read_bytes().replace(b"\r\n", b"\n").decode("utf-8")
-                data = read_csv(io.StringIO(file_content))
-                data.fillna("", inplace=True)
+                data = read_csv(io.StringIO(file_content)).astype(object).fillna("")
                 if not data.columns.empty and data.columns[0] == "key":
                     print(f"Setting index to 'key' for {datafile.name}")
                     data.set_index("key", inplace=True)

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/__init__.py

@@ -0,0 +1,98 @@
+from .agent import AgentCRUD
+from .auth import GroupAllScopedCRUD, GroupCRUD, SecurityCategoryCRUD
+from .classic import AssetCRUD, EventCRUD, SequenceCRUD, SequenceRowCRUD
+from .configuration import SearchConfigCRUD
+from .data_organization import DataSetsCRUD, LabelCRUD
+from .datamodel import (
+    ContainerCRUD,
+    DataModelCRUD,
+    EdgeCRUD,
+    GraphQLCRUD,
+    NodeCRUD,
+    SpaceCRUD,
+    ViewCRUD,
+)
+from .extraction_pipeline import ExtractionPipelineConfigCRUD, ExtractionPipelineCRUD
+from .fieldops import InFieldCDMLocationConfigCRUD, InFieldLocationConfigCRUD, InfieldV1CRUD
+from .file import CogniteFileCRUD, FileMetadataCRUD
+from .function import FunctionCRUD, FunctionScheduleCRUD
+from .group_scoped import GroupResourceScopedCRUD
+from .hosted_extractors import (
+    HostedExtractorDestinationCRUD,
+    HostedExtractorJobCRUD,
+    HostedExtractorMappingCRUD,
+    HostedExtractorSourceCRUD,
+)
+from .industrial_tool import StreamlitCRUD
+from .location import LocationFilterCRUD
+from .migration import ResourceViewMappingCRUD
+from .raw import RawDatabaseCRUD, RawTableCRUD
+from .relationship import RelationshipCRUD
+from .robotics import (
+    RobotCapabilityCRUD,
+    RoboticFrameCRUD,
+    RoboticLocationCRUD,
+    RoboticMapCRUD,
+    RoboticsDataPostProcessingCRUD,
+)
+from .streams import StreamCRUD
+from .three_d_model import ThreeDModelCRUD
+from .timeseries import DatapointSubscriptionCRUD, TimeSeriesCRUD
+from .transformation import TransformationCRUD, TransformationNotificationCRUD, TransformationScheduleCRUD
+from .workflow import WorkflowCRUD, WorkflowTriggerCRUD, WorkflowVersionCRUD
+
+__all__ = [
+    "AgentCRUD",
+    "AssetCRUD",
+    "CogniteFileCRUD",
+    "ContainerCRUD",
+    "DataModelCRUD",
+    "DataSetsCRUD",
+    "DatapointSubscriptionCRUD",
+    "EdgeCRUD",
+    "EventCRUD",
+    "ExtractionPipelineCRUD",
+    "ExtractionPipelineConfigCRUD",
+    "FileMetadataCRUD",
+    "FunctionCRUD",
+    "FunctionScheduleCRUD",
+    "GraphQLCRUD",
+    "GroupAllScopedCRUD",
+    "GroupCRUD",
+    "GroupResourceScopedCRUD",
+    "HostedExtractorDestinationCRUD",
+    "HostedExtractorJobCRUD",
+    "HostedExtractorMappingCRUD",
+    "HostedExtractorSourceCRUD",
+    "InFieldCDMLocationConfigCRUD",
+    "InFieldLocationConfigCRUD",
+    "InfieldV1CRUD",
+    "LabelCRUD",
+    "LocationFilterCRUD",
+    "NodeCRUD",
+    "RawDatabaseCRUD",
+    "RawTableCRUD",
+    "RelationshipCRUD",
+    "ResourceViewMappingCRUD",
+    "RobotCapabilityCRUD",
+    "RoboticFrameCRUD",
+    "RoboticLocationCRUD",
+    "RoboticMapCRUD",
+    "RoboticsDataPostProcessingCRUD",
+    "SearchConfigCRUD",
+    "SecurityCategoryCRUD",
+    "SequenceCRUD",
+    "SequenceRowCRUD",
+    "SpaceCRUD",
+    "StreamCRUD",
+    "StreamlitCRUD",
+    "ThreeDModelCRUD",
+    "TimeSeriesCRUD",
+    "TransformationCRUD",
+    "TransformationNotificationCRUD",
+    "TransformationScheduleCRUD",
+    "ViewCRUD",
+    "WorkflowCRUD",
+    "WorkflowTriggerCRUD",
+    "WorkflowVersionCRUD",
+]

cognite_toolkit/_cdf_tk/{loaders/_resource_loaders/agent_loaders.py → cruds/_resource_cruds/agent.py}

@@ -1,28 +1,24 @@
 from collections.abc import Hashable, Iterable, Sequence
-from functools import lru_cache
 from typing import Any
 
-from cognite.client.data_classes.agents import Agent, AgentList, AgentUpsert, AgentUpsertList
-from cognite.client.data_classes.capabilities import Capability
+from cognite.client.data_classes.agents import Agent, AgentList, AgentUpsert
+from cognite.client.data_classes.capabilities import AgentsAcl, Capability
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk._parameters.constants import ANY_INT, ANYTHING
-from cognite_toolkit._cdf_tk._parameters.data_classes import ParameterSpec, ParameterSpecSet
-from cognite_toolkit._cdf_tk.loaders._base_loaders import ResourceLoader
-from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_identifiable
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
+from cognite_toolkit._cdf_tk.resource_classes import AgentYAML
+from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_hashable, diff_list_identifiable
 
 
-class AgentLoader(ResourceLoader[str, AgentUpsert, Agent, AgentUpsertList, AgentList]):
+class AgentCRUD(ResourceCRUD[str, AgentUpsert, Agent]):
     folder_name = "agents"
-    filename_pattern = r".*\.Agent$"  # Matches all yaml files whose stem ends with '.Agent'.
     resource_cls = Agent
     resource_write_cls = AgentUpsert
-    list_cls = AgentList
-    list_write_cls = AgentUpsertList
     kind = "Agent"
+    yaml_cls = AgentYAML
     _doc_base_url = ""
-    _doc_url = "https://api-docs.cognite.com/20230101-alpha/tag/Agents/operation/main_api_v1_projects__projectName__ai_agents_post"
+    _doc_url = "https://api-docs.cognite.com/20230101-beta/tag/Agents/operation/main_ai_agents_post/"
 
     @classmethod
     def get_id(cls, item: AgentUpsert | Agent | dict) -> str:
@@ -38,30 +34,20 @@ class AgentLoader(ResourceLoader[str, AgentUpsert, Agent, AgentUpsertList, Agent
     def get_required_capability(
         cls, items: Sequence[AgentUpsert] | None, read_only: bool
     ) -> Capability | list[Capability]:
-        return []
+        if not items and items is not None:
+            return []
 
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Tool configuration is a dict where the accepted keys depend on the tool type.
-        spec.add(
-            ParameterSpec(
-                ("tools", ANY_INT, "configuration", ANYTHING),
-                frozenset({"dict"}),
-                is_required=False,
-                _is_nullable=False,
-            )
-        )
-        return spec
+        actions = [AgentsAcl.Action.READ] if read_only else [AgentsAcl.Action.READ, AgentsAcl.Action.WRITE]
+
+        return AgentsAcl(actions, AgentsAcl.Scope.All())
 
-    def create(self, items: AgentUpsertList) -> AgentList:
+    def create(self, items: Sequence[AgentUpsert]) -> AgentList:
         return self.client.agents.upsert(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> AgentList:
         return self.client.agents.retrieve(ids, ignore_unknown_ids=True)
 
-    def update(self, items: AgentUpsertList) -> AgentList:
+    def update(self, items: Sequence[AgentUpsert]) -> AgentList:
         return self.client.agents.upsert(items)
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
@@ -89,12 +75,24 @@ class AgentLoader(ResourceLoader[str, AgentUpsert, Agent, AgentUpsertList, Agent
 
     def dump_resource(self, resource: Agent, local: dict[str, Any] | None = None) -> dict[str, Any]:
         dumped = resource.as_write().dump()
+        # The atlas endpoints are not yet full implemented. There are properties being added and removed that are
+        # not part of the official API. For example, as of 31.July 2025, `labels` is not part of the API, however,
+        # this is necessary to ensure that the agents are shown as published in the UI, so we cannot ignore it.
+        # The below logic ensures that we keep the unknown properties returned by the API, such that when we run
+        # `cdf dump agents` we will not lose any properties that are not part of the official API.
+        if (unknown_props := getattr(resource, "_unknown_properties", None)) and isinstance(unknown_props, dict):
+            dumped.update(unknown_props)
         if local is None:
             return dumped
         if resource.instructions == "" and "instructions" not in local:
             # Instructions are optional, if not set the server set them to an empty string.
             # We remove them from the dumped resource to ensure it will be equal to the local resource.
             dumped.pop("instructions", None)
+        for key in ["labels", "exampleQuestions"]:
+            if key not in local and not dumped.get(key):
+                # If the local resource does not have the key and the server set Agent has it set to an empty list,
+                # we remove it from the dumped resource to ensure it will be equal to the local resource.
+                dumped.pop(key, None)
         return dumped
 
     def diff_list(
@@ -108,4 +106,10 @@ class AgentLoader(ResourceLoader[str, AgentUpsert, Agent, AgentUpsertList, Agent
             return diff_list_identifiable(
                 local, cdf, get_identifier=lambda t: (t.get("name", ""), t.get("description", ""))
             )
+        elif json_path == ("labels",):
+            return diff_list_hashable(local, cdf)
+        elif json_path == ("exampleQuestions",):
+            return diff_list_identifiable(
+                local, cdf, get_identifier=lambda q: q.get("question", "") if isinstance(q, dict) else str(q)
+            )
         return super().diff_list(local, cdf, json_path)

cognite_toolkit/_cdf_tk/{loaders/_resource_loaders/auth_loaders.py → cruds/_resource_cruds/auth.py}

@@ -17,7 +17,6 @@ import difflib
 from collections import defaultdict
 from collections.abc import Callable, Hashable, Iterable, Sequence
 from dataclasses import dataclass
-from functools import lru_cache
 from pathlib import Path
 from typing import Any, Literal, cast, final
 
@@ -31,11 +30,9 @@ from cognite.client.data_classes.iam import (
     Group,
     GroupList,
     GroupWrite,
-    GroupWriteList,
     SecurityCategory,
     SecurityCategoryList,
     SecurityCategoryWrite,
-    SecurityCategoryWriteList,
 )
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
@@ -43,11 +40,10 @@ from rich import print
 from rich.console import Console
 from rich.markup import escape
 
-from cognite_toolkit._cdf_tk._parameters import ANY_INT, ANY_STR, ANYTHING, ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.raw import RawDatabase, RawTable
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitWrongResourceError
-from cognite_toolkit._cdf_tk.loaders._base_loaders import ResourceLoader
 from cognite_toolkit._cdf_tk.resource_classes import GroupYAML, SecurityCategoriesYAML
 from cognite_toolkit._cdf_tk.tk_warnings import (
     HighSeverityWarning,
@@ -62,19 +58,16 @@ class _ReplaceMethod:
     """This is a small helper class used in the
     lookup and replace in the ACL scoped ids"""
 
-    lookup_method: Callable[[str, bool], int]
+    lookup_method: Callable[[str, bool], int | None]
     reverse_lookup_method: Callable[[int], str | None]
     id_name: str
 
 
-class GroupLoader(ResourceLoader[str, GroupWrite, Group, GroupWriteList, GroupList]):
+class GroupCRUD(ResourceCRUD[str, GroupWrite, Group]):
     folder_name = "auth"
-    filename_pattern = r"^(?!.*SecurityCategory$).*"
     kind = "Group"
     resource_cls = Group
     resource_write_cls = GroupWrite
-    list_cls = GroupList
-    list_write_cls = GroupWriteList
     yaml_cls = GroupYAML
     resource_scopes = frozenset(
         {
@@ -145,14 +138,14 @@ class GroupLoader(ResourceLoader[str, GroupWrite, Group, GroupWriteList, GroupLi
         return {"name": id}
 
     @classmethod
-    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceLoader], Hashable]]:
-        from .classic_loaders import AssetLoader
-        from .data_organization_loaders import DataSetsLoader
-        from .datamodel_loaders import SpaceLoader
-        from .extraction_pipeline_loaders import ExtractionPipelineLoader
-        from .location_loaders import LocationFilterLoader
-        from .raw_loaders import RawDatabaseLoader, RawTableLoader
-        from .timeseries_loaders import TimeSeriesLoader
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
+        from .classic import AssetCRUD
+        from .data_organization import DataSetsCRUD
+        from .datamodel import SpaceCRUD
+        from .extraction_pipeline import ExtractionPipelineCRUD
+        from .location import LocationFilterCRUD
+        from .raw import RawDatabaseCRUD, RawTableCRUD
+        from .timeseries import TimeSeriesCRUD
 
         for capability in item.get("capabilities", []):
             for acl, content in capability.items():
@@ -160,41 +153,41 @@ class GroupLoader(ResourceLoader[str, GroupWrite, Group, GroupWriteList, GroupLi
                     if space_ids := scope.get(cap.SpaceIDScope._scope_name, []):
                         if isinstance(space_ids, dict) and "spaceIds" in space_ids:
                             for space_id in space_ids["spaceIds"]:
-                                yield SpaceLoader, space_id
+                                yield SpaceCRUD, space_id
                     if data_set_ids := scope.get(cap.DataSetScope._scope_name, []):
                         if isinstance(data_set_ids, dict) and "ids" in data_set_ids:
                             for data_set_id in data_set_ids["ids"]:
-                                yield DataSetsLoader, data_set_id
+                                yield DataSetsCRUD, data_set_id
                     if table_ids := scope.get(cap.TableScope._scope_name, []):
                         for db_name, tables in table_ids.get("dbsToTables", {}).items():
-                            yield RawDatabaseLoader, RawDatabase(db_name)
+                            yield RawDatabaseCRUD, RawDatabase(db_name)
                             if isinstance(tables, list):
-                                yield from ((RawTableLoader, RawTable(db_name, table)) for table in tables)
+                                yield from ((RawTableCRUD, RawTable(db_name, table)) for table in tables)
                             elif isinstance(tables, dict) and "tables" in tables:
                                 for table in tables["tables"]:
-                                    yield RawTableLoader, RawTable(db_name, table)
+                                    yield RawTableCRUD, RawTable(db_name, table)
                     if extraction_pipeline_ids := scope.get(cap.ExtractionPipelineScope._scope_name, []):
                         if isinstance(extraction_pipeline_ids, dict) and "ids" in extraction_pipeline_ids:
                             for extraction_pipeline_id in extraction_pipeline_ids["ids"]:
-                                yield ExtractionPipelineLoader, extraction_pipeline_id
+                                yield ExtractionPipelineCRUD, extraction_pipeline_id
                     if asset_root_ids := scope.get(cap.AssetRootIDScope._scope_name, []):
                         if isinstance(asset_root_ids, dict) and "rootIds" in asset_root_ids:
                             for asset_root_id in asset_root_ids["rootIds"]:
-                                yield AssetLoader, asset_root_id
+                                yield AssetCRUD, asset_root_id
                     if (ids := scope.get(cap.IDScope._scope_name, [])) or (
                         ids := scope.get(cap.IDScopeLowerCase._scope_name, [])
                     ):
-                        loader: type[ResourceLoader] | None = None
+                        loader: type[ResourceCRUD] | None = None
                         if acl == cap.DataSetsAcl._capability_name:
-                            loader = DataSetsLoader
+                            loader = DataSetsCRUD
                         elif acl == cap.ExtractionPipelinesAcl._capability_name:
-                            loader = ExtractionPipelineLoader
+                            loader = ExtractionPipelineCRUD
                         elif acl == cap.TimeSeriesAcl._capability_name:
-                            loader = TimeSeriesLoader
+                            loader = TimeSeriesCRUD
                         elif acl == cap.SecurityCategoriesAcl._capability_name:
-                            loader = SecurityCategoryLoader
+                            loader = SecurityCategoryCRUD
                         elif acl == cap.LocationFiltersAcl._capability_name:
-                            loader = LocationFilterLoader
+                            loader = LocationFilterCRUD
                         if loader is not None and isinstance(ids, dict) and "ids" in ids:
                             for id_ in ids["ids"]:
                                 yield loader, id_
@@ -208,7 +201,7 @@ class GroupLoader(ResourceLoader[str, GroupWrite, Group, GroupWriteList, GroupLi
                 if len(scope) != 1:
                     # This will raise an error when the group is loaded.
                     continue
-                scope_name, scope_content = next(iter(scope.items()))
+                scope_name, _scope_content = next(iter(scope.items()))
 
                 if (acl, scope_name) in replace_method_by_acl:
                     replace_method = replace_method_by_acl[(acl, scope_name)]
@@ -457,32 +450,6 @@ class GroupLoader(ResourceLoader[str, GroupWrite, Group, GroupWriteList, GroupLi
     ) -> Iterable[Group]:
         return self.client.iam.groups.list(all=True)
 
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # The Capability class in the SDK class Group implementation is deviating from the API.
-        # So we need to modify the spec to match the API.
-        for item in spec:
-            if item.path[0] == "capabilities" and len(item.path) > 2:
-                # Add extra ANY_STR layer
-                # The spec class is immutable, so we use this trick to modify it.
-                object.__setattr__(item, "path", (*item.path[:2], ANY_STR, *item.path[2:]))
-        spec.add(
-            ParameterSpec(
-                ("capabilities", ANY_INT, ANY_STR), frozenset({"dict"}), is_required=False, _is_nullable=False
-            )
-        )
-        spec.add(
-            ParameterSpec(
-                ("capabilities", ANY_INT, ANY_STR, "scope", ANYTHING),
-                frozenset({"dict"}),
-                is_required=True,
-                _is_nullable=False,
-            )
-        )
-        return spec
-
     def diff_list(
         self, local: list[Any], cdf: list[Any], json_path: tuple[str | int, ...]
     ) -> tuple[dict[int, int], list[int]]:
@@ -497,7 +464,7 @@ class GroupLoader(ResourceLoader[str, GroupWrite, Group, GroupWriteList, GroupLi
 
 
 @final
-class GroupAllScopedLoader(GroupLoader):
+class GroupAllScopedCRUD(GroupCRUD):
     def __init__(self, client: ToolkitClient, build_dir: Path | None, console: Console | None):
         super().__init__(client, build_dir, console, "all_scoped_only")
 
@@ -507,18 +474,13 @@ class GroupAllScopedLoader(GroupLoader):
 
 
 @final
-class SecurityCategoryLoader(
-    ResourceLoader[str, SecurityCategoryWrite, SecurityCategory, SecurityCategoryWriteList, SecurityCategoryList]
-):
-    filename_pattern = r"^.*SecurityCategory$"  # Matches all yaml files who's stem ends with *SecurityCategory.
+class SecurityCategoryCRUD(ResourceCRUD[str, SecurityCategoryWrite, SecurityCategory]):
     resource_cls = SecurityCategory
     resource_write_cls = SecurityCategoryWrite
-    list_cls = SecurityCategoryList
-    list_write_cls = SecurityCategoryWriteList
     kind = "SecurityCategory"
     yaml_cls = SecurityCategoriesYAML
     folder_name = "auth"
-    dependencies = frozenset({GroupAllScopedLoader})
+    dependencies = frozenset({GroupAllScopedCRUD})
     _doc_url = "Security-categories/operation/createSecurityCategories"
 
     @property
@@ -562,7 +524,7 @@ class SecurityCategoryLoader(
             SecurityCategoriesAcl.Scope.All(),
         )
 
-    def create(self, items: SecurityCategoryWriteList) -> SecurityCategoryList:
+    def create(self, items: Sequence[SecurityCategoryWrite]) -> SecurityCategoryList:
         return self.client.iam.security_categories.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> SecurityCategoryList:
@@ -570,7 +532,7 @@ class SecurityCategoryLoader(
         categories = self.client.iam.security_categories.list(limit=-1)
         return SecurityCategoryList([c for c in categories if c.name in names])
 
-    def update(self, items: SecurityCategoryWriteList) -> SecurityCategoryList:
+    def update(self, items: Sequence[SecurityCategoryWrite]) -> SecurityCategoryList:
         items_by_name = {item.name: item for item in items}
         retrieved = self.retrieve(list(items_by_name.keys()))
         retrieved_by_name = {item.name: item for item in retrieved}