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

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/extraction_pipeline.py

@@ -13,9 +13,7 @@
 # limitations under the License.
 
 
-import re
 from collections.abc import Hashable, Iterable, Sequence
-from functools import lru_cache
 from pathlib import Path
 from typing import Any, final
 
@@ -32,14 +30,11 @@ from cognite.client.data_classes.capabilities import (
 from cognite.client.data_classes.extractionpipelines import (
     ExtractionPipelineConfigList,
     ExtractionPipelineConfigWrite,
-    ExtractionPipelineConfigWriteList,
     ExtractionPipelineWrite,
-    ExtractionPipelineWriteList,
 )
 from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk._parameters import ANYTHING, ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.client.data_classes.raw import RawDatabase, RawTable
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
@@ -64,15 +59,10 @@ from .raw import RawDatabaseCRUD, RawTableCRUD
 
 
 @final
-class ExtractionPipelineCRUD(
-    ResourceCRUD[str, ExtractionPipelineWrite, ExtractionPipeline, ExtractionPipelineWriteList, ExtractionPipelineList]
-):
+class ExtractionPipelineCRUD(ResourceCRUD[str, ExtractionPipelineWrite, ExtractionPipeline]):
     folder_name = "extraction_pipelines"
-    filename_pattern = r"^(?:(?!\.config).)*$"  # Matches all yaml files except file names who's stem contain *.config.
     resource_cls = ExtractionPipeline
     resource_write_cls = ExtractionPipelineWrite
-    list_cls = ExtractionPipelineList
-    list_write_cls = ExtractionPipelineWriteList
     kind = "ExtractionPipeline"
     dependencies = frozenset({DataSetsCRUD, RawDatabaseCRUD, RawTableCRUD, GroupAllScopedCRUD})
     yaml_cls = ExtractionPipelineYAML
@@ -180,7 +170,7 @@ class ExtractionPipelineCRUD(
     def retrieve(self, ids: SequenceNotStr[str]) -> ExtractionPipelineList:
         return self.client.extraction_pipelines.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: ExtractionPipelineWriteList) -> ExtractionPipelineList:
+    def update(self, items: Sequence[ExtractionPipelineWrite]) -> ExtractionPipelineList:
         # Bug in SDK overload so need the ignore.
         return self.client.extraction_pipelines.update(items, mode="replace")  # type: ignore[call-overload]
 
@@ -214,16 +204,6 @@ class ExtractionPipelineCRUD(
             if pipeline.data_set_id == data_set.id:
                 yield pipeline
 
-    @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))
-        # Set on deploy time by toolkit
-        spec.discard(ParameterSpec(("dataSetId",), frozenset({"int"}), is_required=True, _is_nullable=False))
-        return spec
-
 
 @final
 class ExtractionPipelineConfigCRUD(
@@ -231,16 +211,11 @@ class ExtractionPipelineConfigCRUD(
         str,
         ExtractionPipelineConfigWrite,
         ExtractionPipelineConfig,
-        ExtractionPipelineConfigWriteList,
-        ExtractionPipelineConfigList,
     ]
 ):
     folder_name = "extraction_pipelines"
-    filename_pattern = r"^.*config$"
     resource_cls = ExtractionPipelineConfig
     resource_write_cls = ExtractionPipelineConfigWrite
-    list_cls = ExtractionPipelineConfigList
-    list_write_cls = ExtractionPipelineConfigWriteList
     kind = "Config"
     dependencies = frozenset({ExtractionPipelineCRUD})
     _doc_url = "Extraction-Pipelines-Config/operation/createExtPipeConfig"
@@ -307,10 +282,6 @@ class ExtractionPipelineConfigCRUD(
     def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> ExtractionPipelineConfigWrite:
         config_raw = resource.get("config")
         if isinstance(config_raw, str):
-            # There might be keyvaults secrets in the config that would lead to parsing errors. The syntax
-            # for this is `connection-string: !keyvault secret`. This is not valid YAML, so we need to
-            # replace it with `connection-string: keyvault secret` to make it valid.
-            config_raw = re.sub(r":\s+!(\w+)", r": \1", config_raw)
             self._validate_config(config_raw, resource)
         return ExtractionPipelineConfigWrite._load(resource)
 
@@ -364,18 +335,18 @@ class ExtractionPipelineConfigCRUD(
             return diff_list_force_hashable(local, cdf)
         return super().diff_list(local, cdf, json_path)
 
-    def _upsert(self, items: ExtractionPipelineConfigWriteList) -> ExtractionPipelineConfigList:
+    def _upsert(self, items: Sequence[ExtractionPipelineConfigWrite]) -> ExtractionPipelineConfigList:
         upserted = ExtractionPipelineConfigList([])
         for item in items:
             created = self.client.extraction_pipelines.config.create(item)
             upserted.append(created)
         return upserted
 
-    def create(self, items: ExtractionPipelineConfigWriteList) -> ExtractionPipelineConfigList:
+    def create(self, items: Sequence[ExtractionPipelineConfigWrite]) -> ExtractionPipelineConfigList:
         return self._upsert(items)
 
     # configs cannot be updated, instead new revision is created
-    def update(self, items: ExtractionPipelineConfigWriteList) -> ExtractionPipelineConfigList:
+    def update(self, items: Sequence[ExtractionPipelineConfigWrite]) -> ExtractionPipelineConfigList:
         return self._upsert(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> ExtractionPipelineConfigList:
@@ -436,11 +407,3 @@ class ExtractionPipelineConfigCRUD(
             except CogniteAPIError as e:
                 if e.code == 404 and "There is no config stored" in e.message:
                     continue
-
-    @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(("config", ANYTHING), frozenset({"dict"}), is_required=True, _is_nullable=False))
-        return spec

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py

@@ -1,6 +1,5 @@
 import collections.abc
-from collections.abc import Hashable, Iterable
-from functools import lru_cache
+from collections.abc import Hashable, Iterable, Sequence, Sized
 from pathlib import Path
 from typing import Any, final
 
@@ -9,15 +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._parameters import ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.client.data_classes.apm_config_v1 import (
     APMConfig,
     APMConfigList,
     APMConfigWrite,
-    APMConfigWriteList,
 )
+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, 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 (
+    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
@@ -30,15 +38,12 @@ 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})
     _doc_url = "Instances/operation/applyNodeAndEdges"
     _root_location_filters: tuple[str, ...] = ("general", "assets", "files", "timeseries")
@@ -75,9 +80,18 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig, APMConfigWriteL
 
         return DataModelInstancesAcl(actions, DataModelInstancesAcl.Scope.SpaceID([APMConfig.space]))
 
-    def create(self, items: APMConfigWriteList) -> NodeApplyResultList:
+    def prerequisite_warning(self) -> str | None:
+        views = self.client.data_modeling.views.retrieve(APMConfig.view_id)
+        if len(views) > 0:
+            return None
+        return (
+            f"{self.display_name} requires the {APMConfig.view_id!r} to be deployed. "
+            f"Install the infield options with cdf modules init/add to deploy it."
+        )
+
+    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
 
@@ -87,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
 
@@ -117,33 +131,6 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig, APMConfigWriteL
         ):
             yield APMConfig.from_node(node)
 
-    @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(
-                ("featureConfiguration", "rootLocationConfiguration", "dataSetExternalId"),
-                frozenset({"str"}),
-                is_required=False,
-                _is_nullable=False,
-            )
-        )
-        spec.discard(
-            ParameterSpec(
-                (
-                    "featureConfiguration",
-                    "rootLocationConfiguration",
-                    "dataSetId",
-                ),
-                frozenset({"int"}),
-                is_required=False,
-                _is_nullable=False,
-            )
-        )
-        return spec
-
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if isinstance(app_data_space_id := item.get("appDataSpaceId"), str):
@@ -256,3 +243,196 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig, APMConfigWriteL
         if not isinstance(feature_configuration, dict):
             return None
         return feature_configuration.get("rootLocationConfigurations")
+
+
+@final
+class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConfig, InfieldLocationConfig]):
+    folder_name = "cdf_applications"
+    resource_cls = InfieldLocationConfig
+    resource_write_cls = InfieldLocationConfig
+    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:
+        if isinstance(item, dict):
+            return NodeIdentifier(space=item["space"], external_id=item["externalId"])
+        return NodeIdentifier(space=item.space, external_id=item.external_id)
+
+    @classmethod
+    def dump_id(cls, id: NodeIdentifier) -> dict[str, Any]:
+        return id.dump(include_type=False)
+
+    @classmethod
+    def get_required_capability(
+        cls, items: Sequence[InfieldLocationConfig] | 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: InfieldLocationConfig, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.dump()
+        local = local or {}
+        dumped.pop("instanceType", None)
+        if isinstance(cdf_dec := dumped.get("dataExplorationConfig"), dict):
+            cdf_dec.pop("instanceType", None)
+            if isinstance(local_dec := local.get("dataExplorationConfig"), dict):
+                if "space" in cdf_dec and "space" not in local_dec:
+                    # Default space is used for the data exploration config if not specified locally.
+                    cdf_dec.pop("space")
+                if "externalId" in cdf_dec and "externalId" not in local_dec:
+                    # Default externalId is used for the data exploration config if not specified locally.
+                    cdf_dec.pop("externalId")
+
+        return dumped
+
+    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:
+        return InfieldLocationConfigList(self.client.infield.config.retrieve(list(ids)))
+
+    def update(self, items: Sequence[InfieldLocationConfig]) -> Sized:
+        return self.create(items)
+
+    def delete(self, ids: SequenceNotStr[NodeIdentifier]) -> 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
+        # and the linked DataExplorationConfig.
+        _ = self.client.infield.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[InfieldLocationConfig]:
+        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 == ("dataFilters", "general", "spaces"):
+            return diff_list_hashable(local, cdf)
+        elif json_path == ("dataExplorationConfig", "documents", "supportedFormats"):
+            return diff_list_hashable(local, cdf)
+        return super().diff_list(local, cdf, json_path)
+
+
+@final
+class InFieldCDMLocationConfigCRUD(ResourceCRUD[NodeIdentifier, 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) -> NodeIdentifier:
+        if isinstance(item, dict):
+            return NodeIdentifier(space=item["space"], external_id=item["externalId"])
+        return NodeIdentifier(space=item.space, external_id=item.external_id)
+
+    @classmethod
+    def dump_id(cls, id: NodeIdentifier) -> 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[NodeIdentifier]) -> 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[NodeIdentifier]) -> 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

@@ -15,14 +15,12 @@
 
 from collections.abc import Hashable, Iterable, Sequence
 from datetime import date, datetime
-from functools import lru_cache
 from typing import Any, cast, final
 
 from cognite.client.data_classes import (
     FileMetadata,
     FileMetadataList,
     FileMetadataWrite,
-    FileMetadataWriteList,
 )
 from cognite.client.data_classes.capabilities import (
     Capability,
@@ -35,18 +33,16 @@ 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._parameters import ANY_INT, ANY_STR, ANYTHING, ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.client.data_classes.extendable_cognite_file import (
     ExtendableCogniteFile,
     ExtendableCogniteFileApply,
-    ExtendableCogniteFileApplyList,
     ExtendableCogniteFileList,
 )
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceContainerCRUD, ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
     ToolkitRequiredValueError,
 )
-from cognite_toolkit._cdf_tk.resource_classes import FileMetadataYAML
+from cognite_toolkit._cdf_tk.resource_classes import CogniteFileYAML, FileMetadataYAML
 from cognite_toolkit._cdf_tk.utils import (
     in_dict,
 )
@@ -59,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})
@@ -153,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:
@@ -166,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,47 +185,16 @@ class FileMetadataCRUD(
         self.create(existing.as_write())
         return deleted_files
 
-    @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(("securityCategoryNames",), frozenset({"list"}), is_required=False, _is_nullable=False))
-
-        spec.add(
-            ParameterSpec(("securityCategoryNames", ANY_STR), frozenset({"str"}), 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({"int"}), is_required=False, _is_nullable=False)
-        )
-        spec.discard(ParameterSpec(("assetIds",), frozenset({"list"}), is_required=False, _is_nullable=False))
-        spec.discard(ParameterSpec(("assetIds", ANY_INT), frozenset({"str"}), is_required=False, _is_nullable=False))
-
-        return spec
-
 
 @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})
 
     _doc_url = "Files/operation/initFileUpload"
@@ -316,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
         )
@@ -332,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
 
@@ -372,17 +329,6 @@ class CogniteFileCRUD(
         self.create(existing_node.as_write())
         return len(existing_meta)
 
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Removed by the SDK
-        spec.add(ParameterSpec(("instanceType",), frozenset({"str"}), is_required=False, _is_nullable=False))
-        # Sources are used when writing to the API.
-        spec.add(ParameterSpec(("sources",), frozenset({"list"}), is_required=False, _is_nullable=False))
-        spec.add(ParameterSpec(("sources", ANYTHING), frozenset({"list"}), 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.