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

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/function.py

@@ -1,9 +1,9 @@
 import time
 from collections import defaultdict
 from collections.abc import Hashable, Iterable, Sequence
-from functools import lru_cache
+from functools import cached_property
 from pathlib import Path
-from typing import Any, cast, final
+from typing import Any, Literal, cast, final
 
 from cognite.client.data_classes import (
     ClientCredentials,
@@ -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,19 +22,18 @@ from cognite.client.data_classes.capabilities import (
     FunctionsAcl,
     SessionsAcl,
 )
+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
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich import print
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk._parameters import ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.functions import FunctionScheduleID
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
     ResourceCreationError,
-    ResourceRetrievalError,
     ToolkitRequiredValueError,
 )
 from cognite_toolkit._cdf_tk.resource_classes import FunctionScheduleYAML, FunctionsYAML
@@ -48,6 +45,7 @@ from cognite_toolkit._cdf_tk.utils import (
     humanize_collection,
 )
 from cognite_toolkit._cdf_tk.utils.cdf import read_auth, try_find_error
+from cognite_toolkit._cdf_tk.utils.file import create_temporary_zip, sanitize_filename
 from cognite_toolkit._cdf_tk.utils.text import suffix_description
 
 from .auth import GroupAllScopedCRUD
@@ -56,16 +54,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})
@@ -80,8 +73,14 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
     def __init__(self, client: ToolkitClient, build_path: Path | None, console: Console | None):
         super().__init__(client, build_path, console)
         self.data_set_id_by_external_id: dict[str, int] = {}
+        self.space_by_external_id: dict[str, str] = {}
         self.function_dir_by_external_id: dict[str, Path] = {}
 
+    @cached_property
+    def project_data_modeling_status(self) -> Literal["HYBRID", "DATA_MODELING_ONLY"]:
+        status = self.client.project.status()
+        return status.this_project.data_modeling_status
+
     @property
     def display_name(self) -> str:
         return "functions"
@@ -207,6 +206,8 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
         item_id = self.get_id(resource)
         if ds_external_id := resource.pop("dataSetExternalId", None):
             self.data_set_id_by_external_id[item_id] = self.client.lookup.data_sets.id(ds_external_id, is_dry_run)
+        if space := resource.pop("space", None):
+            self.space_by_external_id[item_id] = space
         if "fileId" not in resource:
             # The fileID is required for the function to be created, but in the `.create` method
             # we first create that file and then set the fileID.
@@ -255,6 +256,8 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
             function_zip_file = self.client.files.retrieve(id=file_id)
             if function_zip_file and (data_set_id := function_zip_file.data_set_id):
                 dumped["dataSetExternalId"] = self.client.lookup.data_sets.external_id(data_set_id)
+            if function_zip_file and function_zip_file.instance_id is not None:
+                dumped["space"] = function_zip_file.instance_id.space
 
         if dumped.get("functionPath") == HANDLER_FILE_NAME and "functionPath" not in local:
             # Remove the default value of the functionPath
@@ -291,7 +294,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
@@ -299,18 +302,12 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
             raise ValueError("build_path must be set to compare functions as function code must be compared.")
         for item in items:
             external_id = item.external_id or item.name
-            function_rootdir = self.function_dir_by_external_id[external_id]
-            file_id = self.client.functions._zip_and_upload_folder(
-                name=item.name,
-                folder=str(function_rootdir),
-                external_id=external_id,
-                data_set_id=self.data_set_id_by_external_id.get(external_id),
-            )
+            file_id = self._upload_function_code(external_id, item)
             # Wait until the files is available
             t0 = time.perf_counter()
             sleep_time = 1.0  # seconds
             for i in range(6):
-                file = self.client.files.retrieve(external_id=external_id)
+                file = self.client.files.retrieve(id=file_id)
                 if file and file.uploaded:
                     break
                 time.sleep(sleep_time)
@@ -323,11 +320,55 @@ 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
 
+    def _upload_function_code(self, external_id: str, item: FunctionWrite) -> int:
+        """Uploads the function code to CDF.
+
+        It will either upload the code to a CogniteFile if a space is provided and the feature flag is enabled,
+        or to a classic file if not.
+
+        Args:
+            external_id (str): The external ID of the function.
+            item (FunctionWrite): The function write object.
+
+        Returns:
+            int: The ID of the created file metadata object.
+        """
+        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 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 space:
+                cognite_file = CogniteFileApply(
+                    space=space,
+                    external_id=external_id,
+                    name=f"{sanitize_filename(item.name)}.zip",
+                    mime_type="application/zip",
+                )
+                _ = self.client.data_modeling.instances.apply(cognite_file, replace=True)
+                upload_file = self.client.files.upload_content_bytes(
+                    zip_path.read_bytes(), instance_id=cognite_file.as_id()
+                )
+            else:
+                upload_file = self.client.files.upload_bytes(
+                    zip_path.read_bytes(),
+                    name=f"{sanitize_filename(item.name)}.zip",
+                    external_id=external_id,
+                    overwrite=True,
+                    data_set_id=data_set_id,
+                )
+        return upload_file.id
+
     @staticmethod
     def _warn_if_cpu_or_memory_changed(created_item: Function, item: FunctionWrite) -> None:
         is_cpu_increased = (
@@ -363,7 +404,7 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
     def delete(self, ids: SequenceNotStr[str]) -> int:
         functions = self.retrieve(ids)
 
-        self.client.functions.delete(external_id=ids)
+        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)
         return len(ids)
@@ -376,29 +417,12 @@ class FunctionCRUD(ResourceCRUD[str, FunctionWrite, Function, FunctionWriteList,
     ) -> Iterable[Function]:
         return iter(self.client.functions)
 
-    @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))
-        # Replaced by the toolkit
-        spec.discard(ParameterSpec(("fileId",), frozenset({"int"}), is_required=True, _is_nullable=False))
-        return spec
-
 
 @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})
@@ -427,16 +451,12 @@ class FunctionScheduleCRUD(
         function_actions = (
             [FunctionsAcl.Action.Read] if read_only else [FunctionsAcl.Action.Read, FunctionsAcl.Action.Write]
         )
-        session_actions = (
-            [SessionsAcl.Action.List]
-            if read_only
-            else [SessionsAcl.Action.List, SessionsAcl.Action.Create, SessionsAcl.Action.Delete]
-        )
-
-        return [
+        required_capabilities: list[Capability] = [
             FunctionsAcl(function_actions, FunctionsAcl.Scope.All()),
-            SessionsAcl(session_actions, SessionsAcl.Scope.All()),
         ]
+        if not read_only:
+            required_capabilities.append(SessionsAcl([SessionsAcl.Action.Create], SessionsAcl.Scope.All()))
+        return required_capabilities
 
     @classmethod
     def dump_id(cls, id: FunctionScheduleID) -> dict[str, Any]:
@@ -523,24 +543,9 @@ class FunctionScheduleCRUD(
             )
         return schedules
 
-    def create(self, items: FunctionScheduleWriteList) -> FunctionSchedulesList:
+    def create(self, items: Sequence[FunctionScheduleWrite]) -> FunctionSchedulesList:
         created_list = FunctionSchedulesList([], cognite_client=self.client)
-        functions_to_lookup = list({item.function_external_id for item in items if item.function_external_id})
-        function_id_by_external_id: dict[str, int] = {}
-        if functions_to_lookup:
-            try:
-                function_ids = self.client.lookup.functions.id(functions_to_lookup)
-            except ResourceRetrievalError as e:
-                failed_items = self.get_ids(items)
-                missing_functions = functions_to_lookup
-                if e.resources:
-                    missing_functions = list(e.resources)
-                    failed_items = [id_ for id_ in failed_items if id_.function_external_id in set(missing_functions)]
-                raise ResourceCreationError(
-                    f"Failed to create function schedule(s) {humanize_collection(failed_items)}. "
-                    f"Could not find function(s) {humanize_collection(missing_functions)!r}"
-                ) from e
-            function_id_by_external_id = dict(zip(functions_to_lookup, function_ids))
+        function_id_by_external_id = self._get_function_ids_by_external_id(items)
 
         for item in items:
             id_ = self.get_id(item)
@@ -567,6 +572,28 @@ class FunctionScheduleCRUD(
             created_list.append(created)
         return created_list
 
+    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 {}
+        function_ids = self.client.lookup.functions.id(functions_to_lookup)
+
+        if len(function_ids) == len(functions_to_lookup):
+            return dict(zip(functions_to_lookup, function_ids))
+        # The lookup API is cached, so it is cheap to do individual lookups to find the missing ones.
+        lookup_pair = (
+            (function_external_id, self.client.lookup.functions.id(function_external_id))
+            for function_external_id in functions_to_lookup
+        )
+        missing_functions = {func for func, func_id in lookup_pair if func_id is None}
+        failed_schedules = [self.get_id(item) for item in items if item.function_external_id in missing_functions]
+        plural_schedules = "s" if len(failed_schedules) > 1 else ""
+        plural_fun = "s" if len(missing_functions) > 1 else ""
+        raise ResourceCreationError(
+            f"Failed to create function schedule{plural_schedules} {humanize_collection(failed_schedules)}. "
+            f"Could not find function{plural_fun} {humanize_collection(missing_functions)!r}"
+        )
+
     def delete(self, ids: SequenceNotStr[FunctionScheduleID]) -> int:
         schedules = self.retrieve(ids)
         count = 0
@@ -590,20 +617,6 @@ class FunctionScheduleCRUD(
                     continue
                 yield from self.client.functions.schedules(function_external_id=parent_id)
 
-    @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(("authentication",), frozenset({"dict"}), is_required=False, _is_nullable=False))
-        spec.add(
-            ParameterSpec(("authentication", "clientId"), frozenset({"str"}), is_required=False, _is_nullable=False)
-        )
-        spec.add(
-            ParameterSpec(("authentication", "clientSecret"), frozenset({"str"}), is_required=False, _is_nullable=False)
-        )
-        return spec
-
     def sensitive_strings(self, item: FunctionScheduleWrite) -> Iterable[str]:
         id_ = self.get_id(item)
         if id_ in self.authentication_by_id:

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/hosted_extractors.py

@@ -1,5 +1,4 @@
 from collections.abc import Hashable, Iterable, Sequence
-from functools import lru_cache
 from pathlib import Path
 from typing import Any
 
@@ -9,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,
@@ -35,7 +30,6 @@ from cognite.client.data_classes.hosted_extractors.sources import (
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk._parameters import ANYTHING, ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitNotSupported
@@ -50,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/"
@@ -95,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:
@@ -116,14 +107,6 @@ class HostedExtractorSourceCRUD(ResourceCRUD[str, SourceWrite, Source, SourceWri
     ) -> Iterable[Source]:
         return iter(self.client.hosted_extractors.sources)
 
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        # parameterspec is highly dependent on type of source, so we accept any parameter
-        return ParameterSpecSet(
-            [ParameterSpec((ANYTHING,), frozenset({"dict"}), is_required=False, _is_nullable=False)]
-        )
-
     def dump_resource(self, resource: Source, local: dict[str, Any] | None = None) -> dict[str, Any]:
         HighSeverityWarning(
             "Sources will always be considered different, and thus will always be redeployed."
@@ -161,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/"
@@ -212,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:
@@ -252,21 +230,6 @@ class HostedExtractorDestinationCRUD(
         ).print_warning()
         return self.dump_id(resource.external_id)
 
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Handled by Toolkit
-
-        spec.add(ParameterSpec(("credentials", "clientId"), frozenset({"str"}), is_required=False, _is_nullable=True))
-        spec.add(
-            ParameterSpec(("credentials", "clientSecret"), frozenset({"str"}), is_required=False, _is_nullable=True)
-        )
-
-        spec.discard(ParameterSpec(("targetDataSetId",), frozenset({"int"}), is_required=False, _is_nullable=True))
-        spec.add(ParameterSpec(("targetDataSetExternalId",), frozenset({"str"}), is_required=False, _is_nullable=True))
-        return spec
-
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if "targetDataSetId" in item:
@@ -279,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
@@ -331,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:
@@ -352,33 +312,6 @@ class HostedExtractorJobCRUD(ResourceCRUD[str, JobWrite, Job, JobWriteList, JobL
     ) -> Iterable[Job]:
         return iter(self.client.hosted_extractors.jobs)
 
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Used by the SDK to determine the class to load
-        spec.add(
-            ParameterSpec(
-                (
-                    "format",
-                    "type",
-                ),
-                frozenset({"str"}),
-                is_required=True,
-                _is_nullable=False,
-            )
-        )
-        spec.add(
-            ParameterSpec(
-                ("config", "incrementalLoad", "type"), frozenset({"str"}), is_required=True, _is_nullable=False
-            )
-        )
-        spec.add(
-            ParameterSpec(("config", "pagination", "type"), frozenset({"str"}), is_required=True, _is_nullable=False)
-        )
-
-        return spec
-
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if "sourceId" in item:
@@ -387,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"
@@ -433,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:
@@ -453,11 +383,3 @@ class HostedExtractorMappingCRUD(ResourceCRUD[str, MappingWrite, Mapping, Mappin
         parent_ids: list[Hashable] | None = None,
     ) -> Iterable[Mapping]:
         return iter(self.client.hosted_extractors.mappings)
-
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Used by the SDK to determine the class to load
-        spec.add(ParameterSpec(("input", "type"), frozenset({"str"}), is_required=True, _is_nullable=False))
-        return spec

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/industrial_tool.py

@@ -13,13 +13,11 @@ from cognite.client.utils.useful_types import SequenceNotStr
 from packaging.requirements import Requirement
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk._parameters import ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.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
@@ -35,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"
@@ -158,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)
@@ -173,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)
@@ -197,12 +192,3 @@ class StreamlitCRUD(ResourceCRUD[str, StreamlitWrite, Streamlit, StreamlitWriteL
         for file in self.client.files:
             if file.directory == "/streamlit-apps/":
                 yield Streamlit.from_file(file)
-
-    @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=True))
-        spec.discard(ParameterSpec(("dataSetId",), frozenset({"int"}), is_required=False, _is_nullable=True))
-        return spec