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

cognite_toolkit/_cdf_tk/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,7 +40,6 @@ 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
@@ -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 GroupCRUD(ResourceCRUD[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(
         {
@@ -457,32 +450,6 @@ class GroupCRUD(ResourceCRUD[str, GroupWrite, Group, GroupWriteList, GroupList])
     ) -> 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]]:
@@ -507,14 +474,9 @@ class GroupAllScopedCRUD(GroupCRUD):
 
 
 @final
-class SecurityCategoryCRUD(
-    ResourceCRUD[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"
@@ -562,7 +524,7 @@ class SecurityCategoryCRUD(
             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 SecurityCategoryCRUD(
         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}

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/classic.py

@@ -1,63 +1,78 @@
 import collections.abc
 import io
-from collections.abc import Hashable, Iterable
-from functools import lru_cache
+from collections.abc import Hashable, Iterable, Sequence
 from pathlib import Path
 from typing import Any, final
 
 import pandas as pd
 from cognite.client.data_classes import (
+    AggregateResultItem,
     Asset,
     AssetList,
     AssetWrite,
-    AssetWriteList,
     Event,
     EventList,
     EventWrite,
-    EventWriteList,
-    Sequence,
     SequenceList,
     SequenceWrite,
-    SequenceWriteList,
     capabilities,
 )
+from cognite.client.data_classes import Sequence as CDFSequence
 from cognite.client.data_classes.capabilities import Capability
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk._parameters import ANY_INT, ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.sequences import (
     ToolkitSequenceRows,
     ToolkitSequenceRowsList,
     ToolkitSequenceRowsWrite,
-    ToolkitSequenceRowsWriteList,
 )
+from cognite_toolkit._cdf_tk.constants import TABLE_FORMATS, YAML_SUFFIX
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
-from cognite_toolkit._cdf_tk.resource_classes import AssetYAML, EventYAML, SequenceYAML
-from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning
+from cognite_toolkit._cdf_tk.feature_flags import Flags
+from cognite_toolkit._cdf_tk.resource_classes import AssetYAML, EventYAML, SequenceRowYAML, SequenceYAML
+from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning, ToolkitDeprecationWarning
 from cognite_toolkit._cdf_tk.utils import load_yaml_inject_variables
 from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_hashable, diff_list_identifiable
 from cognite_toolkit._cdf_tk.utils.file import read_csv
 
 from .data_organization import DataSetsCRUD, LabelCRUD
 
+_DEPRECATION_WARNING_ISSUED = False
+
 
 @final
-class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset, AssetWriteList, AssetList]):
+class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset]):
     folder_name = "classic"
-    filename_pattern = r"^.*\.Asset$"  # Matches all yaml files whose stem ends with '.Asset'.
-    filetypes = frozenset({"yaml", "yml", "csv", "parquet"})
     resource_cls = Asset
     resource_write_cls = AssetWrite
-    list_cls = AssetList
-    list_write_cls = AssetWriteList
     yaml_cls = AssetYAML
     kind = "Asset"
     dependencies = frozenset({DataSetsCRUD, LabelCRUD})
     _doc_url = "Assets/operation/createAssets"
 
+    @classmethod
+    def is_supported_file(cls, file: Path) -> bool:
+        if Flags.v08.is_enabled():
+            return super().is_supported_file(file)
+        global _DEPRECATION_WARNING_ISSUED
+        if not file.stem.casefold().endswith(cls.kind.casefold()):
+            return False
+        if file.suffix in YAML_SUFFIX:
+            return True
+        if file.suffix in TABLE_FORMATS:
+            if not _DEPRECATION_WARNING_ISSUED:
+                ToolkitDeprecationWarning(
+                    feature="deployment of asset from CSV or Parquet files",
+                    alternative="data plugin and cdf data upload commands",
+                    removal_version="0.8",
+                ).print_warning()
+                _DEPRECATION_WARNING_ISSUED = True
+            return True
+        return False
+
     @property
     def display_name(self) -> str:
         return "assets"
@@ -104,13 +119,13 @@ class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset, AssetWriteList, AssetList])
 
         return capabilities.AssetsAcl(actions, scope)
 
-    def create(self, items: AssetWriteList) -> AssetList:
+    def create(self, items: Sequence[AssetWrite]) -> AssetList:
         return self.client.assets.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> AssetList:
         return self.client.assets.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: AssetWriteList) -> AssetList:
+    def update(self, items: Sequence[AssetWrite]) -> AssetList:
         return self.client.assets.update(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str | int]) -> int:
@@ -144,23 +159,6 @@ class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset, AssetWriteList, AssetList])
             )
         )
 
-    @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))
-
-        # Failed to be inferred from the AssetWrite.__init__ method.
-        spec.add(
-            ParameterSpec(("labels", ANY_INT, "externalId"), frozenset({"str"}), is_required=True, _is_nullable=True)
-        )
-
-        # Should not be used, used for parentExternalId instead
-        spec.discard(ParameterSpec(("parentId",), frozenset({"int"}), is_required=False, _is_nullable=False))
-        return spec
-
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         """Returns all items that this item requires.
@@ -232,17 +230,28 @@ class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset, AssetWriteList, AssetList])
             dumped.pop("metadata", None)
         if "parentId" in dumped and "parentId" not in local:
             dumped.pop("parentId")
+        if resource.aggregates:
+            # This is only included when the asset is downloaded/migrated with aggregated properties
+            aggregates = (
+                resource.aggregates.dump()
+                if isinstance(resource.aggregates, AggregateResultItem)
+                else resource.aggregates
+            )
+            if "path" in aggregates:
+                path = aggregates.pop("path", [])
+                if path:
+                    aggregates["path"] = self.client.lookup.assets.external_id(
+                        [segment["id"] for segment in path if "id" in segment]
+                    )
+            dumped.update(aggregates)
         return dumped
 
 
 @final
-class SequenceCRUD(ResourceCRUD[str, SequenceWrite, Sequence, SequenceWriteList, SequenceList]):
+class SequenceCRUD(ResourceCRUD[str, SequenceWrite, CDFSequence]):
     folder_name = "classic"
-    filename_pattern = r"^.*\.Sequence$"
-    resource_cls = Sequence
+    resource_cls = CDFSequence
     resource_write_cls = SequenceWrite
-    list_cls = SequenceList
-    list_write_cls = SequenceWriteList
     kind = "Sequence"
     dependencies = frozenset({DataSetsCRUD, AssetCRUD})
     yaml_cls = SequenceYAML
@@ -253,7 +262,7 @@ class SequenceCRUD(ResourceCRUD[str, SequenceWrite, Sequence, SequenceWriteList,
         return "sequences"
 
     @classmethod
-    def get_id(cls, item: Sequence | SequenceWrite | dict) -> str:
+    def get_id(cls, item: CDFSequence | SequenceWrite | dict) -> str:
         if isinstance(item, dict):
             return item["externalId"]
         if not item.external_id:
@@ -261,7 +270,7 @@ class SequenceCRUD(ResourceCRUD[str, SequenceWrite, Sequence, SequenceWriteList,
         return item.external_id
 
     @classmethod
-    def get_internal_id(cls, item: Sequence | dict) -> int:
+    def get_internal_id(cls, item: CDFSequence | dict) -> int:
         if isinstance(item, dict):
             return item["id"]
         if not item.id:
@@ -274,7 +283,7 @@ class SequenceCRUD(ResourceCRUD[str, SequenceWrite, Sequence, SequenceWriteList,
 
     @classmethod
     def get_required_capability(
-        cls, items: collections.abc.Sequence[SequenceWrite] | None, read_only: bool
+        cls, items: Sequence[SequenceWrite] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -298,7 +307,7 @@ class SequenceCRUD(ResourceCRUD[str, SequenceWrite, Sequence, SequenceWriteList,
             resource["assetId"] = self.client.lookup.assets.id(asset_external_id, is_dry_run)
         return SequenceWrite._load(resource)
 
-    def dump_resource(self, resource: Sequence, local: dict[str, Any] | None = None) -> dict[str, Any]:
+    def dump_resource(self, resource: CDFSequence, local: dict[str, Any] | None = None) -> dict[str, Any]:
         dumped = resource.as_write().dump()
         local = local or {}
         if data_set_id := dumped.pop("dataSetId", None):
@@ -326,13 +335,13 @@ class SequenceCRUD(ResourceCRUD[str, SequenceWrite, Sequence, SequenceWriteList,
             return super().diff_list(local, cdf, json_path)
         return diff_list_identifiable(local, cdf, get_identifier=lambda col: col["externalId"])
 
-    def create(self, items: SequenceWriteList) -> SequenceList:
+    def create(self, items: Sequence[SequenceWrite]) -> SequenceList:
         return self.client.sequences.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> SequenceList:
         return self.client.sequences.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: SequenceWriteList) -> SequenceList:
+    def update(self, items: Sequence[SequenceWrite]) -> SequenceList:
         return self.client.sequences.upsert(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str | int]) -> int:
@@ -353,22 +362,11 @@ class SequenceCRUD(ResourceCRUD[str, SequenceWrite, Sequence, SequenceWriteList,
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[Sequence]:
+    ) -> Iterable[CDFSequence]:
         return iter(
             self.client.sequences(data_set_external_ids=[data_set_external_id] if data_set_external_id else None)
         )
 
-    @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))
-        spec.add(ParameterSpec(("assetExternalId",), frozenset({"int"}), is_required=False, _is_nullable=False))
-        spec.discard(ParameterSpec(("assetId",), frozenset({"int"}), is_required=False, _is_nullable=False))
-        return spec
-
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if "dataSetExternalId" in item:
@@ -378,21 +376,15 @@ class SequenceCRUD(ResourceCRUD[str, SequenceWrite, Sequence, SequenceWriteList,
 
 
 @final
-class SequenceRowCRUD(
-    ResourceCRUD[
-        str, ToolkitSequenceRowsWrite, ToolkitSequenceRows, ToolkitSequenceRowsWriteList, ToolkitSequenceRowsList
-    ]
-):
+class SequenceRowCRUD(ResourceCRUD[str, ToolkitSequenceRowsWrite, ToolkitSequenceRows]):
     folder_name = "classic"
-    filename_pattern = r"^.*\.SequenceRow$"
     resource_cls = ToolkitSequenceRows
     resource_write_cls = ToolkitSequenceRowsWrite
-    list_cls = ToolkitSequenceRowsList
-    list_write_cls = ToolkitSequenceRowsWriteList
     kind = "SequenceRow"
     dependencies = frozenset({SequenceCRUD})
     parent_resource = frozenset({SequenceCRUD})
     _doc_url = "Sequences/operation/postSequenceData"
+    yaml_cls = SequenceRowYAML
     support_update = False
 
     def __init__(self, client: ToolkitClient, build_dir: Path | None, console: Console | None):
@@ -432,8 +424,7 @@ class SequenceRowCRUD(
         # We don't have any capabilities for SequenceRows, that is already handled by the Sequence
         return []
 
-    def create(self, items: ToolkitSequenceRowsWriteList) -> ToolkitSequenceRowsWriteList:
-        item: ToolkitSequenceRowsWrite
+    def create(self, items: Sequence[ToolkitSequenceRowsWrite]) -> Sequence[ToolkitSequenceRowsWrite]:
         for item in items:
             self.client.sequences.rows.insert(item.as_sequence_rows(), external_id=item.external_id)
         return items
@@ -509,14 +500,10 @@ class SequenceRowCRUD(
 
 
 @final
-class EventCRUD(ResourceCRUD[str, EventWrite, Event, EventWriteList, EventList]):
+class EventCRUD(ResourceCRUD[str, EventWrite, Event]):
     folder_name = "classic"
-    filename_pattern = r"^.*\.Event$"  # Matches all yaml files whose stem ends with '.Event'.
-    filetypes = frozenset({"yaml", "yml"})
     resource_cls = Event
     resource_write_cls = EventWrite
-    list_cls = EventList
-    list_write_cls = EventWriteList
     yaml_cls = EventYAML
     kind = "Event"
     dependencies = frozenset({DataSetsCRUD, AssetCRUD})
@@ -568,13 +555,13 @@ class EventCRUD(ResourceCRUD[str, EventWrite, Event, EventWriteList, EventList])
 
         return capabilities.EventsAcl(actions, scope)
 
-    def create(self, items: EventWriteList) -> EventList:
+    def create(self, items: Sequence[EventWrite]) -> EventList:
         return self.client.events.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> EventList:
         return self.client.events.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: EventWriteList) -> EventList:
+    def update(self, items: Sequence[EventWrite]) -> EventList:
         return self.client.events.update(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str | int]) -> int:
@@ -598,22 +585,6 @@ class EventCRUD(ResourceCRUD[str, EventWrite, Event, EventWriteList, EventList])
     ) -> Iterable[Event]:
         return iter(self.client.events(data_set_external_ids=[data_set_external_id] if data_set_external_id else None))
 
-    @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))
-
-        spec.add(ParameterSpec(("assetExternalIds",), frozenset({"list"}), is_required=False, _is_nullable=False))
-        spec.add(
-            ParameterSpec(("assetExternalIds", ANY_INT), frozenset({"str"}), is_required=False, _is_nullable=False)
-        )
-        spec.discard(ParameterSpec(("assetIds",), frozenset({"int"}), is_required=False, _is_nullable=False))
-        spec.discard(ParameterSpec(("assetIds", ANY_INT), frozenset({"int"}), is_required=False, _is_nullable=False))
-        return spec
-
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         """Returns all items that this item requires.

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/configuration.py

@@ -11,25 +11,22 @@ from cognite_toolkit._cdf_tk.client.data_classes.search_config import (
     SearchConfig,
     SearchConfigList,
     SearchConfigWrite,
-    SearchConfigWriteList,
     ViewId,
 )
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.resource_classes import SearchConfigYAML
+from cognite_toolkit._cdf_tk.utils import sanitize_filename
 from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_identifiable, dm_identifier
 
 from .datamodel import ViewCRUD
 
 
 @final
-class SearchConfigCRUD(ResourceCRUD[ViewId, SearchConfigWrite, SearchConfig, SearchConfigWriteList, SearchConfigList]):
+class SearchConfigCRUD(ResourceCRUD[ViewId, SearchConfigWrite, SearchConfig]):
     support_drop = False
     folder_name = "cdf_applications"
-    filename_pattern = r"^.*SearchConfig$"
     resource_cls = SearchConfig
     resource_write_cls = SearchConfigWrite
-    list_cls = SearchConfigList
-    list_write_cls = SearchConfigWriteList
     yaml_cls = SearchConfigYAML
     dependencies = frozenset({ViewCRUD})
     kind = "SearchConfig"
@@ -69,11 +66,14 @@ class SearchConfigCRUD(ResourceCRUD[ViewId, SearchConfigWrite, SearchConfig, Sea
     def dump_id(cls, id: ViewId) -> dict[str, Any]:
         return {"view": id.dump()}
 
+    @classmethod
+    def as_str(cls, id: ViewId) -> str:
+        return sanitize_filename(f"{id.external_id}_{id.space}")
+
     def dump_resource(self, resource: SearchConfig, local: dict[str, Any] | None = None) -> dict[str, Any]:
         dumped = resource.as_write().dump()
         local = local or {}
-        if "id" in dumped and "id" not in local:
-            dumped.pop("id", None)
+        dumped.pop("id", None)
         for key in ["columnsLayout", "filterLayout", "propertiesLayout"]:
             if not dumped.get(key) and key not in local:
                 dumped.pop(key, None)
@@ -100,20 +100,17 @@ class SearchConfigCRUD(ResourceCRUD[ViewId, SearchConfigWrite, SearchConfig, Sea
             return diff_list_identifiable(local, cdf, get_identifier=dm_identifier)
         return super().diff_list(local, cdf, json_path)
 
-    def _upsert(self, items: SearchConfigWrite | SearchConfigWriteList) -> SearchConfigList:
+    def _upsert(self, items: Sequence[SearchConfigWrite]) -> SearchConfigList:
         """
         Upsert search configurations using the upsert method
         """
-        if isinstance(items, SearchConfigWrite):
-            items = SearchConfigWriteList([items])
-
         result = SearchConfigList([])
         for item in items:
             created = self.client.search.configurations.upsert(item)
             result.append(created)
         return result
 
-    def create(self, items: SearchConfigWriteList) -> SearchConfigList:
+    def create(self, items: Sequence[SearchConfigWrite]) -> SearchConfigList:
         """
         Create new search configurations using the upsert method
         """
@@ -125,7 +122,7 @@ class SearchConfigCRUD(ResourceCRUD[ViewId, SearchConfigWrite, SearchConfig, Sea
         # The API does not support server-side filtering, so we filter in memory.
         return SearchConfigList([config for config in all_configs if config.view in ids])
 
-    def update(self, items: SearchConfigWriteList) -> SearchConfigList:
+    def update(self, items: Sequence[SearchConfigWrite]) -> SearchConfigList:
         """
         Update search configurations using the upsert method
         """

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/data_organization.py

@@ -15,14 +15,12 @@
 
 import json
 from collections.abc import Hashable, Iterable, Sequence
-from functools import lru_cache
 from typing import Any, final
 
 from cognite.client.data_classes import (
     DataSet,
     DataSetList,
     DataSetWrite,
-    DataSetWriteList,
     LabelDefinition,
     LabelDefinitionList,
     LabelDefinitionWrite,
@@ -32,11 +30,9 @@ from cognite.client.data_classes.capabilities import (
     Capability,
     DataSetsAcl,
 )
-from cognite.client.data_classes.labels import LabelDefinitionWriteList
 from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk._parameters import ANY_STR, ANYTHING, ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
     ToolkitRequiredValueError,
@@ -47,13 +43,11 @@ from .auth import GroupAllScopedCRUD
 
 
 @final
-class DataSetsCRUD(ResourceCRUD[str, DataSetWrite, DataSet, DataSetWriteList, DataSetList]):
+class DataSetsCRUD(ResourceCRUD[str, DataSetWrite, DataSet]):
     support_drop = False
     folder_name = "data_sets"
     resource_cls = DataSet
     resource_write_cls = DataSetWrite
-    list_cls = DataSetList
-    list_write_cls = DataSetWriteList
     yaml_cls = DataSetYAML
     kind = "DataSet"
     dependencies = frozenset({GroupAllScopedCRUD})
@@ -144,7 +138,7 @@ class DataSetsCRUD(ResourceCRUD[str, DataSetWrite, DataSet, DataSetWriteList, Da
     def retrieve(self, ids: SequenceNotStr[str]) -> DataSetList:
         return self.client.data_sets.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: DataSetWriteList) -> DataSetList:
+    def update(self, items: Sequence[DataSetWrite]) -> DataSetList:
         return self.client.data_sets.update(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
@@ -158,29 +152,12 @@ class DataSetsCRUD(ResourceCRUD[str, DataSetWrite, DataSet, DataSetWriteList, Da
     ) -> Iterable[DataSet]:
         return iter(self.client.data_sets)
 
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Added by toolkit, toolkit will automatically convert metadata to json
-        spec.add(
-            ParameterSpec(
-                ("metadata", ANY_STR, ANYTHING), frozenset({"unknown"}), is_required=False, _is_nullable=False
-            )
-        )
-        return spec
-
 
 @final
-class LabelCRUD(
-    ResourceCRUD[str, LabelDefinitionWrite, LabelDefinition, LabelDefinitionWriteList, LabelDefinitionList]
-):
+class LabelCRUD(ResourceCRUD[str, LabelDefinitionWrite, LabelDefinition]):
     folder_name = "classic"
-    filename_pattern = r"^.*Label$"  # Matches all yaml files whose stem ends with *Label.
     resource_cls = LabelDefinition
     resource_write_cls = LabelDefinitionWrite
-    list_cls = LabelDefinitionList
-    list_write_cls = LabelDefinitionWriteList
     yaml_cls = LabelsYAML
     kind = "Label"
     dependencies = frozenset({DataSetsCRUD, GroupAllScopedCRUD})
@@ -224,7 +201,7 @@ class LabelCRUD(
 
         return capabilities.LabelsAcl(actions, scope)
 
-    def create(self, items: LabelDefinitionWriteList) -> LabelDefinitionList:
+    def create(self, items: Sequence[LabelDefinitionWrite]) -> LabelDefinitionList:
         return self.client.labels.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> LabelDefinitionList:
@@ -250,14 +227,6 @@ class LabelCRUD(
     ) -> Iterable[LabelDefinition]:
         return iter(self.client.labels(data_set_external_ids=[data_set_external_id] if data_set_external_id else None))
 
-    @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))
-        return spec
-
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         """Returns all items that this item requires.