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

cognite_toolkit/_cdf_tk/cruds/__init__.py

@@ -0,0 +1,224 @@
+# Copyright 2023 Cognite AS
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import itertools
+from typing import Literal, TypeAlias
+
+from cognite_toolkit._cdf_tk.feature_flags import FeatureFlag, Flags
+
+from ._base_cruds import DataCRUD, Loader, ResourceContainerCRUD, ResourceCRUD
+from ._data_cruds import DatapointsCRUD, FileCRUD, RawFileCRUD
+from ._resource_cruds import (
+    AgentCRUD,
+    AssetCRUD,
+    CogniteFileCRUD,
+    ContainerCRUD,
+    DataModelCRUD,
+    DatapointSubscriptionCRUD,
+    DataSetsCRUD,
+    EdgeCRUD,
+    EventCRUD,
+    ExtractionPipelineConfigCRUD,
+    ExtractionPipelineCRUD,
+    FileMetadataCRUD,
+    FunctionCRUD,
+    FunctionScheduleCRUD,
+    GraphQLCRUD,
+    GroupAllScopedCRUD,
+    GroupCRUD,
+    GroupResourceScopedCRUD,
+    HostedExtractorDestinationCRUD,
+    HostedExtractorJobCRUD,
+    HostedExtractorMappingCRUD,
+    HostedExtractorSourceCRUD,
+    InFieldCDMLocationConfigCRUD,
+    InFieldLocationConfigCRUD,
+    InfieldV1CRUD,
+    LabelCRUD,
+    LocationFilterCRUD,
+    NodeCRUD,
+    RawDatabaseCRUD,
+    RawTableCRUD,
+    RelationshipCRUD,
+    ResourceViewMappingCRUD,
+    RobotCapabilityCRUD,
+    RoboticFrameCRUD,
+    RoboticLocationCRUD,
+    RoboticMapCRUD,
+    RoboticsDataPostProcessingCRUD,
+    SearchConfigCRUD,
+    SecurityCategoryCRUD,
+    SequenceCRUD,
+    SequenceRowCRUD,
+    SpaceCRUD,
+    StreamCRUD,
+    StreamlitCRUD,
+    ThreeDModelCRUD,
+    TimeSeriesCRUD,
+    TransformationCRUD,
+    TransformationNotificationCRUD,
+    TransformationScheduleCRUD,
+    ViewCRUD,
+    WorkflowCRUD,
+    WorkflowTriggerCRUD,
+    WorkflowVersionCRUD,
+)
+from ._worker import ResourceWorker
+
+_EXCLUDED_CRUDS: set[type[ResourceCRUD]] = set()
+if not FeatureFlag.is_enabled(Flags.GRAPHQL):
+    _EXCLUDED_CRUDS.add(GraphQLCRUD)
+if not FeatureFlag.is_enabled(Flags.INFIELD):
+    _EXCLUDED_CRUDS.add(InfieldV1CRUD)
+    _EXCLUDED_CRUDS.add(InFieldLocationConfigCRUD)
+    _EXCLUDED_CRUDS.add(InFieldCDMLocationConfigCRUD)
+if not FeatureFlag.is_enabled(Flags.MIGRATE):
+    _EXCLUDED_CRUDS.add(ResourceViewMappingCRUD)
+if not FeatureFlag.is_enabled(Flags.STREAMS):
+    _EXCLUDED_CRUDS.add(StreamCRUD)
+
+
+CRUDS_BY_FOLDER_NAME: dict[str, list[type[Loader]]] = {}
+for _loader in itertools.chain(
+    ResourceCRUD.__subclasses__(),
+    ResourceContainerCRUD.__subclasses__(),
+    DataCRUD.__subclasses__(),
+    GroupCRUD.__subclasses__(),
+):
+    if _loader in [ResourceCRUD, ResourceContainerCRUD, DataCRUD, GroupCRUD] or _loader in _EXCLUDED_CRUDS:
+        # Skipping base classes
+        continue
+    if _loader.folder_name not in CRUDS_BY_FOLDER_NAME:  # type: ignore[attr-defined]
+        CRUDS_BY_FOLDER_NAME[_loader.folder_name] = []  # type: ignore[attr-defined]
+    # MyPy bug: https://github.com/python/mypy/issues/4717
+    CRUDS_BY_FOLDER_NAME[_loader.folder_name].append(_loader)  # type: ignore[arg-type, attr-defined]
+del _loader  # cleanup module namespace
+
+# For backwards compatibility
+CRUDS_BY_FOLDER_NAME["data_models"] = CRUDS_BY_FOLDER_NAME["data_modeling"]  # Todo: Remove in v1.0
+RESOURCE_CRUD_BY_FOLDER_NAME = {
+    folder_name: cruds
+    for folder_name, loaders in CRUDS_BY_FOLDER_NAME.items()
+    if (cruds := [crud for crud in loaders if issubclass(crud, ResourceCRUD)])
+}
+
+CRUD_LIST = list(itertools.chain.from_iterable(CRUDS_BY_FOLDER_NAME.values()))
+RESOURCE_CRUD_LIST = [loader for loader in CRUD_LIST if issubclass(loader, ResourceCRUD)]
+RESOURCE_CRUD_CONTAINER_LIST = [loader for loader in CRUD_LIST if issubclass(loader, ResourceContainerCRUD)]
+RESOURCE_DATA_CRUD_LIST = [loader for loader in CRUD_LIST if issubclass(loader, DataCRUD)]
+KINDS_BY_FOLDER_NAME: dict[str, set[str]] = {}
+for crud in CRUD_LIST:
+    if crud.folder_name not in KINDS_BY_FOLDER_NAME:
+        KINDS_BY_FOLDER_NAME[crud.folder_name] = set()
+    KINDS_BY_FOLDER_NAME[crud.folder_name].add(crud.kind)
+del crud  # cleanup module namespace
+
+ResourceTypes: TypeAlias = Literal[
+    "3dmodels",
+    "agents",
+    "auth",
+    "cdf_applications",
+    "classic",
+    "data_modeling",
+    "data_models",  # Todo: Remove in v1.0
+    "data_sets",
+    "hosted_extractors",
+    "locations",
+    "migration",
+    "transformations",
+    "files",
+    "timeseries",
+    "extraction_pipelines",
+    "functions",
+    "raw",
+    "robotics",
+    "streams",
+    "streamlit",
+    "workflows",
+]
+
+
+def get_crud(resource_dir: str, kind: str) -> type[Loader]:
+    for loader in CRUDS_BY_FOLDER_NAME[resource_dir]:
+        if loader.kind == kind:
+            return loader
+    raise ValueError(f"Loader not found for {resource_dir} and {kind}")
+
+
+__all__ = [
+    "CRUDS_BY_FOLDER_NAME",
+    "CRUD_LIST",
+    "KINDS_BY_FOLDER_NAME",
+    "RESOURCE_CRUD_BY_FOLDER_NAME",
+    "RESOURCE_CRUD_CONTAINER_LIST",
+    "RESOURCE_CRUD_LIST",
+    "RESOURCE_DATA_CRUD_LIST",
+    "AgentCRUD",
+    "AssetCRUD",
+    "CogniteFileCRUD",
+    "ContainerCRUD",
+    "DataCRUD",
+    "DataModelCRUD",
+    "DataSetsCRUD",
+    "DatapointSubscriptionCRUD",
+    "DatapointsCRUD",
+    "EdgeCRUD",
+    "EventCRUD",
+    "ExtractionPipelineCRUD",
+    "ExtractionPipelineConfigCRUD",
+    "FileCRUD",
+    "FileMetadataCRUD",
+    "FunctionCRUD",
+    "FunctionScheduleCRUD",
+    "GroupAllScopedCRUD",
+    "GroupCRUD",
+    "GroupResourceScopedCRUD",
+    "HostedExtractorDestinationCRUD",
+    "HostedExtractorJobCRUD",
+    "HostedExtractorMappingCRUD",
+    "HostedExtractorSourceCRUD",
+    "InFieldCDMLocationConfigCRUD",
+    "InFieldLocationConfigCRUD",
+    "LabelCRUD",
+    "LocationFilterCRUD",
+    "NodeCRUD",
+    "RawDatabaseCRUD",
+    "RawFileCRUD",
+    "RawTableCRUD",
+    "RelationshipCRUD",
+    "ResourceCRUD",
+    "ResourceContainerCRUD",
+    "ResourceTypes",
+    "ResourceWorker",
+    "RobotCapabilityCRUD",
+    "RoboticFrameCRUD",
+    "RoboticLocationCRUD",
+    "RoboticMapCRUD",
+    "RoboticsDataPostProcessingCRUD",
+    "SearchConfigCRUD",
+    "SecurityCategoryCRUD",
+    "SequenceCRUD",
+    "SequenceRowCRUD",
+    "SpaceCRUD",
+    "StreamlitCRUD",
+    "ThreeDModelCRUD",
+    "TimeSeriesCRUD",
+    "TransformationCRUD",
+    "TransformationNotificationCRUD",
+    "TransformationScheduleCRUD",
+    "ViewCRUD",
+    "WorkflowCRUD",
+    "WorkflowTriggerCRUD",
+    "WorkflowVersionCRUD",
+    "get_crud",
+]

cognite_toolkit/_cdf_tk/{loaders/_base_loaders.py → cruds/_base_cruds.py}

@@ -1,27 +1,20 @@
-import re
 import sys
 from abc import ABC, abstractmethod
-from collections.abc import Hashable, Iterable, Sequence, Set, Sized
-from functools import lru_cache
+from collections.abc import Hashable, Iterable, Sequence, Sized
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
-from cognite.client.data_classes._base import (
-    T_CogniteResourceList,
-    T_WritableCogniteResource,
-    T_WriteClass,
-    WriteableCogniteResourceList,
-)
 from cognite.client.data_classes.capabilities import Capability
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk._parameters import ParameterSpecSet, read_parameter_from_init_type_hints
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING, EXCL_FILES, USE_SENTRY
+from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING, YAML_SUFFIX
+from cognite_toolkit._cdf_tk.protocols import T_ResourceRequest, T_ResourceResponse
 from cognite_toolkit._cdf_tk.resource_classes import ToolkitResource
 from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning
-from cognite_toolkit._cdf_tk.utils import load_yaml_inject_variables, safe_read, to_directory_compatible
+from cognite_toolkit._cdf_tk.utils import load_yaml_inject_variables, safe_read, sanitize_filename
+from cognite_toolkit._cdf_tk.utils.useful_types import T_ID
 
 if TYPE_CHECKING:
     from cognite_toolkit._cdf_tk.data_classes import BuildEnvironment
@@ -31,10 +24,6 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
-T_ID = TypeVar("T_ID", bound=Hashable)
-T_WritableCogniteResourceList = TypeVar("T_WritableCogniteResourceList", bound=WriteableCogniteResourceList)
-_COMPILED_PATTERN: dict[str, re.Pattern] = {}
-
 
 class Loader(ABC):
     """This is the base class for all loaders
@@ -46,20 +35,16 @@ class Loader(ABC):
     Class attributes:
         filetypes: The filetypes that are supported by this loader. This should be set in all subclasses.
         folder_name: The name of the folder in the build directory where the files are located. This should be set in all subclasses.
-        filename_pattern: A regex pattern that is used to filter the files that are supported by this loader. This is used
-            when two loaders have the same folder name to differentiate between them. If not set, all files are supported.
         dependencies: A set of loaders that must be loaded before this loader.
         exclude_filetypes: A set of filetypes that should be excluded from the supported filetypes.
     """
 
-    filetypes: frozenset[str]
     folder_name: str
     kind: str
-    filename_pattern: str = ""
-    dependencies: "frozenset[type[ResourceLoader]]" = frozenset()
-    exclude_filetypes: frozenset[str] = frozenset()
+    dependencies: "frozenset[type[ResourceCRUD]]" = frozenset()
     _doc_base_url: str = "https://api-docs.cognite.com/20230101/tag/"
     _doc_url: str = ""
+    sub_folder_name: str | None = None
 
     def __init__(self, client: ToolkitClient, build_dir: Path | None, console: Console | None = None) -> None:
         self.client = client
@@ -87,13 +72,12 @@ class Loader(ABC):
     def doc_url(cls) -> str:
         return cls._doc_base_url + cls._doc_url
 
-    def find_files(self, dir_or_file: Path | None = None, include_formats: Set[str] | None = None) -> list[Path]:
+    def find_files(self, dir_or_file: Path | None = None) -> list[Path]:
         """Find all files that are supported by this loader in the given directory or file.
 
         Args:
             dir_or_file (Path): The directory or file to search in. If no path is given,
                 the build directory is used.
-            include_formats (set[str]): A set of file formats to include. If not set, all formats are included.
 
         Returns:
             list[Path]: A sorted list of all files that are supported by this loader.
@@ -107,12 +91,7 @@ class Loader(ABC):
                 raise ValueError("Invalid file type")
             return [dir_or_file]
         elif dir_or_file.is_dir():
-            file_paths = [
-                file
-                for file in dir_or_file.glob("**/*")
-                if self.is_supported_file(file) and (include_formats is None or file.suffix in include_formats)
-            ]
-            return sorted(file_paths)
+            return sorted([file for file in dir_or_file.rglob("*") if self.is_supported_file(file)])
         else:
             return []
 
@@ -121,81 +100,60 @@ class Loader(ABC):
         return any(cls.is_supported_file(file) for file in directory.glob("**/*"))
 
     @classmethod
-    def is_supported_file(cls, file: Path, force_pattern: bool = False) -> bool:
+    def is_supported_file(cls, file: Path) -> bool:
         """Check if hte file is supported by this loader.
 
         Args:
             file: The filepath to check.
-            force_pattern: If True, the filename pattern is used to determine if the file is supported. If False, the
-                file extension is used to determine if the file is supported (given that the
-                RequireKind flag is enabled).
 
         Returns:
             bool: True if the file is supported, False otherwise.
 
         """
-        if cls.filetypes and file.suffix[1:] not in cls.filetypes:
-            return False
-        if cls.exclude_filetypes and file.suffix[1:] in cls.exclude_filetypes:
-            return False
-        if force_pattern is False and not issubclass(cls, DataLoader):
-            return file.stem.casefold().endswith(cls.kind.casefold())
-        else:
-            if cls.filename_pattern:
-                if cls.filename_pattern not in _COMPILED_PATTERN:
-                    _COMPILED_PATTERN[cls.filename_pattern] = re.compile(cls.filename_pattern, re.IGNORECASE)
-                return _COMPILED_PATTERN[cls.filename_pattern].match(file.stem) is not None
-        return True
+        return file.suffix in YAML_SUFFIX and file.stem.casefold().endswith(cls.kind.casefold())
 
 
 T_Loader = TypeVar("T_Loader", bound=Loader)
 
 
-class ResourceLoader(
-    Loader,
-    ABC,
-    Generic[T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList],
-):
-    """This is the base class for all resource loaders.
+class ResourceCRUD(Loader, ABC, Generic[T_ID, T_ResourceRequest, T_ResourceResponse]):
+    """This is the base class for all resource CRUD.
 
     A resource loader consists of the following
         - A CRUD (Create, Retrieve, Update, Delete) interface for interacting with the CDF API.
-        - A read and write data class with list for the resource.
-        - Must use the file-format YAML to store the local version of the resource.
+        - Serialization/Deserialization of the resources between YAML and the cognite-sdk data classes used in the
+          CRUD interface.
 
-    All resources supported by the cognite_toolkit should implement a loader.
+    All resources supported by the cognite_toolkit should implement a CRUD.
 
     Class attributes:
-        resource_write_cls: The write data class for the resource.
-        resource_cls: The read data class for the resource.
-        list_cls: The read list format for this resource.
-        list_write_cls: The write list format for this resource.
+        resource_write_cls: The API write data class for the resource.
+        resource_cls: The API read data class for the resource.
+        yaml_cls: The File format for this resource. This is used to validate the user input.
         support_drop: Whether the resource supports the drop flag.
-        filetypes: The filetypes that are supported by this loader. This should not be set in the subclass, it
-            should always be yaml and yml.
-        dependencies: A set of loaders that must be loaded before this loader.
+        support_update: Whether the resource supports the update operation.
+        dependencies: A set of other resource cruds that must be loaded before this crud.
+        parent_resource: A set of other resource cruds that are parent resources to this resource. This is used
+            to determine if the iterate method should return any resources when filtering by parent ids.
     """
 
     # Must be set in the subclass
-    resource_write_cls: type[T_WriteClass]
-    resource_cls: type[T_WritableCogniteResource]
-    list_cls: type[T_WritableCogniteResourceList]
-    list_write_cls: type[T_CogniteResourceList]
-    yaml_cls: type[ToolkitResource] | None = None
+    resource_write_cls: type[T_ResourceRequest]
+    resource_cls: type[T_ResourceResponse]
+    yaml_cls: type[ToolkitResource]
     # Optional to set in the subclass
     support_drop = True
     support_update = True
-    filetypes = frozenset({"yaml", "yml"})
-    dependencies: "frozenset[type[ResourceLoader]]" = frozenset()
+    dependencies: "frozenset[type[ResourceCRUD]]" = frozenset()
     # For example, TransformationNotification and Schedule has Transformation as the parent resource
     # This is used in the iterate method to ensure that nothing is returned if
     # the resource type does not have a parent resource.
-    parent_resource: "frozenset[type[ResourceLoader]]" = frozenset()
+    parent_resource: "frozenset[type[ResourceCRUD]]" = frozenset()
 
     # The methods that must be implemented in the subclass
     @classmethod
     @abstractmethod
-    def get_id(cls, item: T_WriteClass | T_WritableCogniteResource | dict) -> T_ID:
+    def get_id(cls, item: T_ResourceRequest | T_ResourceResponse | dict) -> T_ID:
         raise NotImplementedError
 
     @classmethod
@@ -206,19 +164,19 @@ class ResourceLoader(
     @classmethod
     @abstractmethod
     def get_required_capability(
-        cls, items: Sequence[T_WriteClass] | None, read_only: bool
+        cls, items: Sequence[T_ResourceRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         raise NotImplementedError(f"get_required_capability must be implemented for {cls.__name__}.")
 
     @abstractmethod
-    def create(self, items: T_CogniteResourceList) -> Sized:
+    def create(self, items: Sequence[T_ResourceRequest]) -> Sized:
         raise NotImplementedError
 
     @abstractmethod
-    def retrieve(self, ids: SequenceNotStr[T_ID]) -> T_WritableCogniteResourceList:
+    def retrieve(self, ids: SequenceNotStr[T_ID]) -> Sequence[T_ResourceResponse]:
         raise NotImplementedError
 
-    def update(self, items: T_CogniteResourceList) -> Sized:
+    def update(self, items: Sequence[T_ResourceRequest]) -> Sized:
         raise NotImplementedError(f"Update is not supported for {type(self).__name__}.")
 
     @abstractmethod
@@ -230,20 +188,20 @@ class ResourceLoader(
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[T_WritableCogniteResource]:
+    ) -> Iterable[T_ResourceResponse]:
         if sum([1 for x in [data_set_external_id, space, parent_ids] if x is not None]) > 1:
             raise ValueError("At most one of data_set_external_id, space, or parent_ids must be set.")
         if parent_ids is not None and not self.parent_resource:
             return []
         if space is not None:
-            from ._resource_loaders.datamodel_loaders import SpaceLoader
+            from ._resource_cruds.datamodel import SpaceCRUD
 
-            if SpaceLoader not in self.dependencies:
+            if SpaceCRUD not in self.dependencies:
                 return []
         if data_set_external_id is not None:
-            from ._resource_loaders.data_organization_loaders import DataSetsLoader
+            from ._resource_cruds.data_organization import DataSetsCRUD
 
-            if DataSetsLoader not in self.dependencies:
+            if DataSetsCRUD not in self.dependencies:
                 return []
         return self._iterate(data_set_external_id, space, parent_ids)
 
@@ -253,17 +211,20 @@ class ResourceLoader(
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[T_WritableCogniteResource]:
+    ) -> Iterable[T_ResourceResponse]:
         raise NotImplementedError
 
-    # The methods below have default implementations that can be overwritten in subclasses
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        return read_parameter_from_init_type_hints(cls.resource_write_cls).as_camel_case()
+    ### These methods can be optionally overwritten in the subclass ###
+    def prerequisite_warning(self) -> str | None:
+        """ "Returns a warning message if there are any prerequisites that must be met before using this CRUD.
+
+        This is used for special resource CRUDs that for example require data models/views to be deployed in CDF
+        to work. For example, the InfieldV1CRUD and the ResourceViewMappingCRUD.
+        """
+        return None
 
     @classmethod
-    def get_dependent_items(cls, item: dict) -> "Iterable[tuple[type[ResourceLoader], Hashable]]":
+    def get_dependent_items(cls, item: dict) -> "Iterable[tuple[type[ResourceCRUD], Hashable]]":
         """Returns all items that this item requires.
 
         For example, a TimeSeries requires a DataSet, so this method would return the
@@ -293,7 +254,7 @@ class ResourceLoader(
         return []
 
     @classmethod
-    def get_internal_id(cls, item: T_WritableCogniteResource | dict) -> int:
+    def get_internal_id(cls, item: T_ResourceResponse | dict) -> int:
         raise NotImplementedError(f"{cls.__name__} does not have an internal id.")
 
     @classmethod
@@ -330,18 +291,18 @@ class ResourceLoader(
         )
         return raw_yaml if isinstance(raw_yaml, list) else [raw_yaml]
 
-    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> T_WriteClass:
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> T_ResourceRequest:
         """Loads the resource from a dictionary. Can be overwritten in subclasses."""
         return self.resource_write_cls._load(resource)
 
-    def dump_resource(self, resource: T_WritableCogniteResource, local: dict[str, Any] | None = None) -> dict[str, Any]:
+    def dump_resource(self, resource: T_ResourceResponse, local: dict[str, Any] | None = None) -> dict[str, Any]:
         """Dumps the resource to a dictionary that matches the write format.
 
         This is intended to be overwritten in subclasses that require special dumping logic, for example,
         replacing dataSetId with dataSetExternalId.
 
         Args:
-            resource (T_WritableCogniteResource): The resource to dump (typically comes from CDF).
+            resource (T_ResourceResponse): The resource to dump (typically comes from CDF).
             local (dict[str, Any] | None): The local resource. When used in a dump/import command, there is no local
                 resource.
         """
@@ -390,7 +351,7 @@ class ResourceLoader(
             f"Missing implementation for {type(self).__name__} for {'.'.join(map(str, json_path))}."
         )
 
-    def sensitive_strings(self, item: T_WriteClass) -> Iterable[str]:
+    def sensitive_strings(self, item: T_ResourceRequest) -> Iterable[str]:
         """Returns a list of strings that should be masked when printing.
 
         This is used by the loaders with credentials to mask the credentials secrets. For example, the
@@ -401,45 +362,25 @@ class ResourceLoader(
 
     # Helper methods
     @classmethod
-    def get_ids(cls, items: Sequence[T_WriteClass | T_WritableCogniteResource | dict]) -> list[T_ID]:
+    def get_ids(cls, items: Sequence[T_ResourceRequest | T_ResourceResponse | dict]) -> list[T_ID]:
         return [cls.get_id(item) for item in items]
 
-    @classmethod
-    def safe_get_write_cls_parameter_spec(cls) -> ParameterSpecSet | None:
-        from sentry_sdk import capture_exception
-
-        api_spec: ParameterSpecSet | None = None
-        try:
-            api_spec = cls.get_write_cls_parameter_spec()
-        except Exception as e:
-            # We don't want to crash the program if we can't get the parameter spec
-            # as we can continue without doing this check. Note that getting the parameter spec
-            # is also fragile as it relies on the type hints in the cognite-sdk which is out of our control.
-            if USE_SENTRY:
-                capture_exception(e)
-            else:
-                raise
-        return api_spec
-
     @classmethod
     def as_str(cls, id: T_ID) -> str:
         if isinstance(id, str):
-            return to_directory_compatible(id)
+            return sanitize_filename(id)
         raise NotImplementedError(
             f"Bug in CogniteToolkit 'as_str' is not implemented for {cls.__name__.removesuffix('Loader')}."
         )
 
 
-class ResourceContainerLoader(
-    ResourceLoader[T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList],
-    ABC,
-):
-    """This is the base class for all loaders' resource containers.
+class ResourceContainerCRUD(ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse], ABC):
+    """This is the base class for all resource CRUD' containers.
 
-    A resource container is a resource that contains data. For example, Timeseries contains datapoints, and another
+    A resource container CRUD is a resource that contains data. For example, Timeseries contains datapoints, and another
     example is spaces and containers in data modeling that contains instances.
 
-    In addition to the methods that are required for a resource loader, a resource container loader must implement
+    In addition to the methods that are required for a resource CRUD, a resource container CRUD must implement
     the following methods:
         - count: Counts the number of items in the resource container.
         - drop_data: Deletes the data in the resource container.
@@ -460,12 +401,12 @@ class ResourceContainerLoader(
         raise NotImplementedError
 
 
-class DataLoader(Loader, ABC):
-    """This is the base class for all data loaders.
+class DataCRUD(Loader, ABC):
+    """This is the base class for all data CRUD..
 
-    A data loader is a loader that uploads data to CDF. It will typically depend on a
-    resource container that stores the data. For example, the datapoints loader depends
-    on the timeseries loader.
+    A data CRUD is a CRUD that uploads data to CDF. It will typically depend on a
+    resource container that stores the data. For example, the datapoints crud depends
+    on the timeseries CRUD.
 
     It has only one required method:
         - upload: Uploads the data to CDF.
@@ -481,10 +422,3 @@ class DataLoader(Loader, ABC):
     @abstractmethod
     def upload(self, state: "BuildEnvironment", dry_run: bool) -> Iterable[tuple[str, int]]:
         raise NotImplementedError
-
-    def _find_data_files(self, directory: Path) -> list[Path]:
-        return [
-            path
-            for path in directory.rglob("*")
-            if path.is_file() and path.name not in EXCL_FILES and self.is_supported_file(path)
-        ]