cognite-toolkit 0.6.97__py3-none-any.whl → 0.7.39__py3-none-any.whl

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py

@@ -8,17 +8,24 @@ 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 (
+from cognite_toolkit._cdf_tk.client.data_classes.infield import (
+    InFieldCDMLocationConfig,
+    InfieldLocationConfig,
+    InfieldLocationConfigList,
+)
+from cognite_toolkit._cdf_tk.client.data_classes.instance_api import InstanceResult, TypedNodeIdentifier
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.apm_config_v1 import (
     APMConfig,
     APMConfigList,
     APMConfigWrite,
-    APMConfigWriteList,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.infield import InfieldLocationConfig, InfieldLocationConfigList
-from cognite_toolkit._cdf_tk.client.data_classes.instance_api import InstanceResult, NodeIdentifier
 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 InfieldLocationConfigYAML, InfieldV1YAML
+from cognite_toolkit._cdf_tk.resource_classes import (
+    InFieldCDMLocationConfigYAML,
+    InfieldLocationConfigYAML,
+    InfieldV1YAML,
+)
 from cognite_toolkit._cdf_tk.utils import quote_int_value_by_key_in_yaml, safe_read
 from cognite_toolkit._cdf_tk.utils.cdf import iterate_instances
 from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_hashable, diff_list_identifiable, hash_dict
@@ -31,14 +38,10 @@ from .group_scoped import GroupResourceScopedCRUD
 
 
 @final
-class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig, APMConfigWriteList, APMConfigList]):
+class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig]):
     folder_name = "cdf_applications"
-    filename_pattern = r"^.*\.InfieldV1$"  # Matches all yaml files whose stem ends with '.InfieldV1'.
-    filetypes = frozenset({"yaml", "yml"})
     resource_cls = APMConfig
     resource_write_cls = APMConfigWrite
-    list_cls = APMConfigList
-    list_write_cls = APMConfigWriteList
     kind = "InfieldV1"
     yaml_cls = InfieldV1YAML
     dependencies = frozenset({DataSetsCRUD, AssetCRUD, SpaceCRUD, GroupAllScopedCRUD, GroupResourceScopedCRUD})
@@ -86,9 +89,9 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig, APMConfigWriteL
             f"Install the infield options with cdf modules init/add to deploy it."
         )
 
-    def create(self, items: APMConfigWriteList) -> NodeApplyResultList:
+    def create(self, items: Sequence[APMConfigWrite]) -> NodeApplyResultList:
         result = self.client.data_modeling.instances.apply(
-            nodes=items.as_nodes(), auto_create_direct_relations=True, replace=False
+            nodes=[item.as_node() for item in items], auto_create_direct_relations=True, replace=False
         )
         return result.nodes
 
@@ -98,9 +101,9 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig, APMConfigWriteL
         ).nodes
         return APMConfigList.from_nodes(result)
 
-    def update(self, items: APMConfigWriteList) -> NodeApplyResultList:
+    def update(self, items: Sequence[APMConfigWrite]) -> NodeApplyResultList:
         result = self.client.data_modeling.instances.apply(
-            nodes=items.as_nodes(), auto_create_direct_relations=True, replace=True
+            nodes=[item.as_node() for item in items], auto_create_direct_relations=True, replace=True
         )
         return result.nodes
 
@@ -243,35 +246,27 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig, APMConfigWriteL
 
 
 @final
-class InFieldLocationConfigCRUD(
-    ResourceCRUD[
-        NodeIdentifier,
-        InfieldLocationConfig,
-        InfieldLocationConfig,
-        InfieldLocationConfigList,
-        InfieldLocationConfigList,
-    ]
-):
+class InFieldLocationConfigCRUD(ResourceCRUD[TypedNodeIdentifier, InfieldLocationConfig, InfieldLocationConfig]):
     folder_name = "cdf_applications"
-    filename_pattern = r"^.*\.InFieldLocationConfig$"
-    filetypes = frozenset({"yaml", "yml"})
     resource_cls = InfieldLocationConfig
     resource_write_cls = InfieldLocationConfig
-    list_cls = InfieldLocationConfigList
-    list_write_cls = InfieldLocationConfigList
     kind = "InFieldLocationConfig"
     yaml_cls = InfieldLocationConfigYAML
     dependencies = frozenset({SpaceCRUD, GroupAllScopedCRUD, GroupResourceScopedCRUD})
     _doc_url = "Instances/operation/applyNodeAndEdges"
 
+    @property
+    def display_name(self) -> str:
+        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]:
+    def dump_id(cls, id: TypedNodeIdentifier) -> dict[str, Any]:
         return id.dump(include_type=False)
 
     @classmethod
@@ -306,20 +301,20 @@ class InFieldLocationConfigCRUD(
 
         return dumped
 
-    def create(self, items: InfieldLocationConfigList) -> list[InstanceResult]:
+    def create(self, items: Sequence[InfieldLocationConfig]) -> list[InstanceResult]:
         created = self.client.infield.config.apply(items)
         config_ids = {config.as_id() for config in items}
         # We filter out all the data exploration configs that were created along with the infield location configs
         # 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: InfieldLocationConfigList) -> Sized:
+    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
@@ -347,3 +342,99 @@ class InFieldLocationConfigCRUD(
         elif json_path == ("dataExplorationConfig", "documents", "supportedFormats"):
             return diff_list_hashable(local, cdf)
         return super().diff_list(local, cdf, json_path)
+
+
+@final
+class InFieldCDMLocationConfigCRUD(
+    ResourceCRUD[TypedNodeIdentifier, InFieldCDMLocationConfig, InFieldCDMLocationConfig]
+):
+    folder_name = "cdf_applications"
+    resource_cls = InFieldCDMLocationConfig
+    resource_write_cls = InFieldCDMLocationConfig
+    kind = "InFieldCDMLocationConfig"
+    yaml_cls = InFieldCDMLocationConfigYAML
+    dependencies = frozenset({SpaceCRUD, GroupAllScopedCRUD, GroupResourceScopedCRUD})
+    _doc_url = "Instances/operation/applyNodeAndEdges"
+
+    @property
+    def display_name(self) -> str:
+        return "infield CDM location configs"
+
+    @classmethod
+    def get_id(cls, item: InFieldCDMLocationConfig | dict) -> TypedNodeIdentifier:
+        if isinstance(item, dict):
+            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: TypedNodeIdentifier) -> dict[str, Any]:
+        return id.dump(include_type=False)
+
+    @classmethod
+    def get_required_capability(
+        cls, items: Sequence[InFieldCDMLocationConfig] | None, read_only: bool
+    ) -> Capability | list[Capability]:
+        if not items or items is None:
+            return []
+
+        actions = (
+            [DataModelInstancesAcl.Action.Read]
+            if read_only
+            else [DataModelInstancesAcl.Action.Read, DataModelInstancesAcl.Action.Write]
+        )
+        instance_spaces = sorted({item.space for item in items})
+
+        return DataModelInstancesAcl(actions, DataModelInstancesAcl.Scope.SpaceID(instance_spaces))
+
+    def dump_resource(self, resource: InFieldCDMLocationConfig, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.as_write().dump()
+        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)
+        dumped.pop("instanceType", None)
+        return dumped
+
+    def create(self, items: Sequence[InFieldCDMLocationConfig]) -> list[InstanceResult]:
+        return self.client.infield.cdm_config.apply(items)
+
+    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[TypedNodeIdentifier]) -> int:
+        # We must retrieve the full resource to delete it.
+        retrieved = self.retrieve(list(ids))
+        _ = self.client.infield.cdm_config.delete(retrieved)
+        return len(retrieved)
+
+    def _iterate(
+        self,
+        data_set_external_id: str | None = None,
+        space: str | None = None,
+        parent_ids: list[Hashable] | None = None,
+    ) -> Iterable[InFieldCDMLocationConfig]:
+        raise NotImplementedError(f"Iteration over {self.display_name} is not supported.")
+
+    def diff_list(
+        self, local: list[Any], cdf: list[Any], json_path: tuple[str | int, ...]
+    ) -> tuple[dict[int, int], list[int]]:
+        if json_path == ("accessManagement", "templateAdmins"):
+            return diff_list_hashable(local, cdf)
+        elif json_path == ("accessManagement", "checklistAdmins"):
+            return diff_list_hashable(local, cdf)
+        elif json_path == ("disciplines",):
+            return diff_list_identifiable(local, cdf, get_identifier=hash_dict)
+        elif len(json_path) == 3 and json_path[0] == "dataFilters" and json_path[2] == "instanceSpaces":
+            # Handles dataFilters.<entity>.instanceSpaces (e.g., files, assets, operations, timeSeries, etc.)
+            return diff_list_hashable(local, cdf)
+        elif json_path == ("dataExplorationConfig", "filters"):
+            return diff_list_identifiable(local, cdf, get_identifier=hash_dict)
+        elif len(json_path) == 4 and json_path[:2] == ("dataExplorationConfig", "filters") and json_path[3] == "values":
+            # Handles dataExplorationConfig.filters[i].values
+            return diff_list_hashable(local, cdf)
+
+        return super().diff_list(local, cdf, json_path)

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/file.py

@@ -21,7 +21,6 @@ from cognite.client.data_classes import (
     FileMetadata,
     FileMetadataList,
     FileMetadataWrite,
-    FileMetadataWriteList,
 )
 from cognite.client.data_classes.capabilities import (
     Capability,
@@ -34,10 +33,9 @@ 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.data_classes.legacy.extendable_cognite_file import (
     ExtendableCogniteFile,
     ExtendableCogniteFileApply,
-    ExtendableCogniteFileApplyList,
     ExtendableCogniteFileList,
 )
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceContainerCRUD, ResourceCRUD
@@ -57,19 +55,11 @@ from .datamodel import SpaceCRUD, ViewCRUD
 
 
 @final
-class FileMetadataCRUD(
-    ResourceContainerCRUD[str, FileMetadataWrite, FileMetadata, FileMetadataWriteList, FileMetadataList]
-):
+class FileMetadataCRUD(ResourceContainerCRUD[str, FileMetadataWrite, FileMetadata]):
     item_name = "file contents"
     folder_name = "files"
-    filename_pattern = (
-        # Matches all yaml files except file names whose stem ends with `.CogniteFile` or `File`.
-        r"(?i)^(?!.*(?:File|CogniteFile)$).*$"
-    )
     resource_cls = FileMetadata
     resource_write_cls = FileMetadataWrite
-    list_cls = FileMetadataList
-    list_write_cls = FileMetadataWriteList
     yaml_cls = FileMetadataYAML
     kind = "FileMetadata"
     dependencies = frozenset({DataSetsCRUD, GroupAllScopedCRUD, LabelCRUD, AssetCRUD})
@@ -151,7 +141,7 @@ class FileMetadataCRUD(
             dumped["assetExternalIds"] = self.client.lookup.assets.external_id(asset_ids)
         return dumped
 
-    def create(self, items: FileMetadataWriteList) -> FileMetadataList:
+    def create(self, items: Sequence[FileMetadataWrite]) -> FileMetadataList:
         created = FileMetadataList([])
         for meta in items:
             try:
@@ -164,7 +154,7 @@ class FileMetadataCRUD(
     def retrieve(self, ids: SequenceNotStr[str]) -> FileMetadataList:
         return self.client.files.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: FileMetadataWriteList) -> FileMetadataList:
+    def update(self, items: Sequence[FileMetadataWrite]) -> FileMetadataList:
         return self.client.files.update(items, mode="replace")
 
     def delete(self, ids: str | int | SequenceNotStr[str | int] | None) -> int:
@@ -197,24 +187,13 @@ class FileMetadataCRUD(
 
 
 @final
-class CogniteFileCRUD(
-    ResourceContainerCRUD[
-        NodeId,
-        ExtendableCogniteFileApply,
-        ExtendableCogniteFile,
-        ExtendableCogniteFileApplyList,
-        ExtendableCogniteFileList,
-    ]
-):
+class CogniteFileCRUD(ResourceContainerCRUD[NodeId, ExtendableCogniteFileApply, ExtendableCogniteFile]):
     template_pattern = "$FILENAME"
     item_name = "file contents"
     folder_name = "files"
-    filename_pattern = r"^.*CogniteFile"  # Matches all yaml files whose stem ends with 'CogniteFile'.
     kind = "CogniteFile"
     resource_cls = ExtendableCogniteFile
     resource_write_cls = ExtendableCogniteFileApply
-    list_cls = ExtendableCogniteFileList
-    list_write_cls = ExtendableCogniteFileApplyList
     yaml_cls = CogniteFileYAML
     dependencies = frozenset({GroupAllScopedCRUD, SpaceCRUD, ViewCRUD})
 
@@ -294,7 +273,7 @@ class CogniteFileCRUD(
             return diff_list_identifiable(local, cdf, get_identifier=dm_identifier)
         return super().diff_list(local, cdf, json_path)
 
-    def create(self, items: ExtendableCogniteFileApplyList) -> NodeApplyResultList:
+    def create(self, items: Sequence[ExtendableCogniteFileApply]) -> NodeApplyResultList:
         created = self.client.data_modeling.instances.apply(
             nodes=items, replace=False, skip_on_version_conflict=True, auto_create_direct_relations=True
         )
@@ -310,7 +289,7 @@ class CogniteFileCRUD(
         )
         return ExtendableCogniteFileList(items)
 
-    def update(self, items: ExtendableCogniteFileApplyList) -> NodeApplyResultList:
+    def update(self, items: Sequence[ExtendableCogniteFileApply]) -> NodeApplyResultList:
         updated = self.client.data_modeling.instances.apply(nodes=items, replace=True)
         return updated.nodes
 

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/function.py

@@ -12,9 +12,7 @@ from cognite.client.data_classes import (
     FunctionSchedule,
     FunctionSchedulesList,
     FunctionScheduleWrite,
-    FunctionScheduleWriteList,
     FunctionWrite,
-    FunctionWriteList,
 )
 from cognite.client.data_classes.capabilities import (
     AllScope,
@@ -24,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
@@ -32,13 +31,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.functions import FunctionScheduleID
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.functions import FunctionScheduleID
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
     ResourceCreationError,
     ToolkitRequiredValueError,
 )
-from cognite_toolkit._cdf_tk.feature_flags import Flags
 from cognite_toolkit._cdf_tk.resource_classes import FunctionScheduleYAML, FunctionsYAML
 from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning, LowSeverityWarning
 from cognite_toolkit._cdf_tk.utils import (
@@ -57,16 +55,11 @@ from .group_scoped import GroupResourceScopedCRUD
 
 
 @final
-class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList, FunctionList]):
+class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function]):
     support_drop = True
     folder_name = "functions"
-    filename_pattern = (
-        r"^(?:(?!schedule).)*$"  # Matches all yaml files except file names who's stem contain *.schedule.
-    )
     resource_cls = Function
     resource_write_cls = FunctionWrite
-    list_cls = FunctionList
-    list_write_cls = FunctionWriteList
     kind = "Function"
     yaml_cls = FunctionsYAML
     dependencies = frozenset({DataSetsCRUD, GroupAllScopedCRUD})
@@ -302,7 +295,7 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
             self.client.functions.activate()
         return False
 
-    def create(self, items: FunctionWriteList) -> FunctionList:
+    def create(self, items: Sequence[FunctionWrite]) -> FunctionList:
         created = FunctionList([], cognite_client=self.client)
         if not self._is_activated("create"):
             return created
@@ -328,7 +321,7 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
                     " problem persists, please contact Cognite support."
                 )
             item.file_id = file_id
-            created_item = self.client.functions.create_with_429_retry(item, console=self.console)
+            created_item = self.client.functions.create_with_429_retry(item)
             self._warn_if_cpu_or_memory_changed(created_item, item)
             created.append(created_item)
         return created
@@ -349,18 +342,14 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
         function_rootdir = self.function_dir_by_external_id[external_id]
         data_set_id = self.data_set_id_by_external_id.get(external_id)
         space = self.space_by_external_id.get(external_id)
-        if (
-            Flags.FUNCTION_COGNITE_FILE.is_enabled()
-            and space is None
-            and self.project_data_modeling_status.casefold() == "data_modeling_only"
-        ):
+        if space is None and self.project_data_modeling_status.casefold() == "data_modeling_only":
             raise ResourceCreationError(
                 f"Function {external_id!r} must have a space set when the project is in DATA_MODELING_ONLY mode. "
                 "This is used to set the NodeId of the CogniteFile created for the function code."
             )
 
         with create_temporary_zip(function_rootdir, "function.zip") as zip_path:
-            if Flags.FUNCTION_COGNITE_FILE.is_enabled() and space:
+            if space:
                 cognite_file = CogniteFileApply(
                     space=space,
                     external_id=external_id,
@@ -416,9 +405,20 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
     def delete(self, ids: SequenceNotStr[str]) -> int:
         functions = self.retrieve(ids)
 
-        self.client.functions.delete_with_429_retry(external_id=ids, ignore_unknown_ids=True, console=self.console)
+        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(
@@ -431,17 +431,10 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
 
 
 @final
-class FunctionScheduleCRUD(
-    ResourceCRUD[
-        FunctionScheduleID, FunctionScheduleWrite, FunctionSchedule, FunctionScheduleWriteList, FunctionSchedulesList
-    ]
-):
+class FunctionScheduleCRUD(ResourceCRUD[FunctionScheduleID, FunctionScheduleWrite, FunctionSchedule]):
     folder_name = "functions"
-    filename_pattern = r"^.*schedule.*$"  # Matches all yaml files who's stem contain *.schedule
     resource_cls = FunctionSchedule
     resource_write_cls = FunctionScheduleWrite
-    list_cls = FunctionSchedulesList
-    list_write_cls = FunctionScheduleWriteList
     kind = "Schedule"
     yaml_cls = FunctionScheduleYAML
     dependencies = frozenset({FunctionCRUD, GroupResourceScopedCRUD, GroupAllScopedCRUD})
@@ -562,7 +555,7 @@ class FunctionScheduleCRUD(
             )
         return schedules
 
-    def create(self, items: FunctionScheduleWriteList) -> FunctionSchedulesList:
+    def create(self, items: Sequence[FunctionScheduleWrite]) -> FunctionSchedulesList:
         created_list = FunctionSchedulesList([], cognite_client=self.client)
         function_id_by_external_id = self._get_function_ids_by_external_id(items)
 
@@ -591,7 +584,7 @@ class FunctionScheduleCRUD(
             created_list.append(created)
         return created_list
 
-    def _get_function_ids_by_external_id(self, items: FunctionScheduleWriteList) -> dict[str, int]:
+    def _get_function_ids_by_external_id(self, items: Sequence[FunctionScheduleWrite]) -> dict[str, int]:
         functions_to_lookup = list({item.function_external_id for item in items if item.function_external_id})
         if not functions_to_lookup:
             return {}

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/hosted_extractors.py

@@ -8,21 +8,17 @@ from cognite.client.data_classes.hosted_extractors import (
     Destination,
     DestinationList,
     DestinationWrite,
-    DestinationWriteList,
     EventHubSourceWrite,
     Job,
     JobList,
     JobWrite,
-    JobWriteList,
     KafkaSourceWrite,
     Mapping,
     MappingList,
     MappingWrite,
-    MappingWriteList,
     Source,
     SourceList,
     SourceWrite,
-    SourceWriteList,
 )
 from cognite.client.data_classes.hosted_extractors.sources import (
     AuthenticationWrite,
@@ -48,13 +44,10 @@ from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
 from .data_organization import DataSetsCRUD
 
 
-class HostedExtractorSourceCRUD(ResourceCRUD[str, SourceWrite, Source, SourceWriteList, SourceList]):
+class HostedExtractorSourceCRUD(ResourceCRUD[str, SourceWrite, Source]):
     folder_name = "hosted_extractors"
-    filename_pattern = r".*\.Source$"  # Matches all yaml files whose stem ends with '.Source'.
     resource_cls = Source
     resource_write_cls = SourceWrite
-    list_cls = SourceList
-    list_write_cls = SourceWriteList
     kind = "Source"
     yaml_cls = HostedExtractorSourceYAML
     _doc_base_url = "https://api-docs.cognite.com/20230101-alpha/tag/"
@@ -93,13 +86,13 @@ class HostedExtractorSourceCRUD(ResourceCRUD[str, SourceWrite, Source, SourceWri
             HostedExtractorsAcl.Scope.All(),
         )
 
-    def create(self, items: SourceWriteList) -> SourceList:
+    def create(self, items: Sequence[SourceWrite]) -> SourceList:
         return self.client.hosted_extractors.sources.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> SourceList:
         return self.client.hosted_extractors.sources.retrieve(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: SourceWriteList) -> SourceList:
+    def update(self, items: Sequence[SourceWrite]) -> SourceList:
         return self.client.hosted_extractors.sources.update(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
@@ -151,15 +144,10 @@ class HostedExtractorSourceCRUD(ResourceCRUD[str, SourceWrite, Source, SourceWri
             yield auth.client_secret
 
 
-class HostedExtractorDestinationCRUD(
-    ResourceCRUD[str, DestinationWrite, Destination, DestinationWriteList, DestinationList]
-):
+class HostedExtractorDestinationCRUD(ResourceCRUD[str, DestinationWrite, Destination]):
     folder_name = "hosted_extractors"
-    filename_pattern = r".*\.Destination$"  # Matches all yaml files whose stem ends with '.Destination'.
     resource_cls = Destination
     resource_write_cls = DestinationWrite
-    list_cls = DestinationList
-    list_write_cls = DestinationWriteList
     dependencies = frozenset({DataSetsCRUD})
     kind = "Destination"
     _doc_base_url = "https://api-docs.cognite.com/20230101-alpha/tag/"
@@ -202,13 +190,13 @@ class HostedExtractorDestinationCRUD(
             HostedExtractorsAcl.Scope.All(),
         )
 
-    def create(self, items: DestinationWriteList) -> DestinationList:
+    def create(self, items: Sequence[DestinationWrite]) -> DestinationList:
         return self.client.hosted_extractors.destinations.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> DestinationList:
         return self.client.hosted_extractors.destinations.retrieve(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: DestinationWriteList) -> DestinationList:
+    def update(self, items: Sequence[DestinationWrite]) -> DestinationList:
         return self.client.hosted_extractors.destinations.update(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
@@ -254,13 +242,10 @@ class HostedExtractorDestinationCRUD(
             yield self._authentication_by_id[id_].client_secret
 
 
-class HostedExtractorJobCRUD(ResourceCRUD[str, JobWrite, Job, JobWriteList, JobList]):
+class HostedExtractorJobCRUD(ResourceCRUD[str, JobWrite, Job]):
     folder_name = "hosted_extractors"
-    filename_pattern = r".*\.Job$"  # Matches all yaml files whose stem ends with '.Job'.
     resource_cls = Job
     resource_write_cls = JobWrite
-    list_cls = JobList
-    list_write_cls = JobWriteList
     dependencies = frozenset({HostedExtractorSourceCRUD, HostedExtractorDestinationCRUD})
     kind = "Job"
     yaml_cls = HostedExtractorJobYAML
@@ -306,13 +291,13 @@ class HostedExtractorJobCRUD(ResourceCRUD[str, JobWrite, Job, JobWriteList, JobL
             dumped.pop("config", None)
         return dumped
 
-    def create(self, items: JobWriteList) -> JobList:
+    def create(self, items: Sequence[JobWrite]) -> JobList:
         return self.client.hosted_extractors.jobs.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> JobList:
         return self.client.hosted_extractors.jobs.retrieve(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: JobWriteList) -> JobList:
+    def update(self, items: Sequence[JobWrite]) -> JobList:
         return self.client.hosted_extractors.jobs.update(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
@@ -335,13 +320,10 @@ class HostedExtractorJobCRUD(ResourceCRUD[str, JobWrite, Job, JobWriteList, JobL
             yield HostedExtractorDestinationCRUD, item["destinationId"]
 
 
-class HostedExtractorMappingCRUD(ResourceCRUD[str, MappingWrite, Mapping, MappingWriteList, MappingList]):
+class HostedExtractorMappingCRUD(ResourceCRUD[str, MappingWrite, Mapping]):
     folder_name = "hosted_extractors"
-    filename_pattern = r".*\.Mapping$"  # Matches all yaml files whose stem ends with '.Mapping'.
     resource_cls = Mapping
     resource_write_cls = MappingWrite
-    list_cls = MappingList
-    list_write_cls = MappingWriteList
     # This is not an explicit dependency, however, adding it here as mapping will should be deployed after source.
     dependencies = frozenset({HostedExtractorSourceCRUD})
     kind = "Mapping"
@@ -381,13 +363,13 @@ class HostedExtractorMappingCRUD(ResourceCRUD[str, MappingWrite, Mapping, Mappin
             HostedExtractorsAcl.Scope.All(),
         )
 
-    def create(self, items: MappingWriteList) -> MappingList:
+    def create(self, items: Sequence[MappingWrite]) -> MappingList:
         return self.client.hosted_extractors.mappings.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> MappingList:
         return self.client.hosted_extractors.mappings.retrieve(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: MappingWriteList) -> MappingList:
+    def update(self, items: Sequence[MappingWrite]) -> MappingList:
         return self.client.hosted_extractors.mappings.update(items)
 
     def delete(self, ids: SequenceNotStr[str]) -> int:

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/industrial_tool.py

@@ -14,11 +14,10 @@ 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.data_classes.legacy.streamlit_ import (
     Streamlit,
     StreamlitList,
     StreamlitWrite,
-    StreamlitWriteList,
 )
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitNotADirectoryError, ToolkitRequiredValueError
@@ -34,13 +33,10 @@ from .data_organization import DataSetsCRUD
 
 
 @final
-class StreamlitCRUD(ResourceCRUD[str, StreamlitWrite, Streamlit, StreamlitWriteList, StreamlitList]):
+class StreamlitCRUD(ResourceCRUD[str, StreamlitWrite, Streamlit]):
     folder_name = "streamlit"
-    filename_pattern = r".*streamlit$"
     resource_cls = Streamlit
     resource_write_cls = StreamlitWrite
-    list_cls = StreamlitList
-    list_write_cls = StreamlitWriteList
     kind = "Streamlit"
     dependencies = frozenset({DataSetsCRUD, GroupAllScopedCRUD})
     _doc_url = "Files/operation/initFileUpload"
@@ -157,7 +153,7 @@ class StreamlitCRUD(ResourceCRUD[str, StreamlitWrite, Streamlit, StreamlitWriteL
                 missing.append(recommended.name)
         return missing
 
-    def create(self, items: StreamlitWriteList) -> StreamlitList:
+    def create(self, items: Sequence[StreamlitWrite]) -> StreamlitList:
         created = StreamlitList([])
         for item in items:
             content = self._as_json_string(item.external_id, item.entrypoint)
@@ -172,7 +168,7 @@ class StreamlitCRUD(ResourceCRUD[str, StreamlitWrite, Streamlit, StreamlitWriteL
         files = self.client.files.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
         return StreamlitList([Streamlit.from_file(file) for file in files])
 
-    def update(self, items: StreamlitWriteList) -> StreamlitList:
+    def update(self, items: Sequence[StreamlitWrite]) -> StreamlitList:
         files = []
         for item in items:
             content = self._as_json_string(item.external_id, item.entrypoint)