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

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

@@ -1,35 +1,28 @@
-from __future__ import annotations
-
-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
 
-T_ID = TypeVar("T_ID", bound=Hashable)
-T_WritableCogniteResourceList = TypeVar("T_WritableCogniteResourceList", bound=WriteableCogniteResourceList)
-_COMPILED_PATTERN: dict[str, re.Pattern] = {}
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
 
 
 class Loader(ABC):
@@ -42,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
@@ -68,11 +57,11 @@ class Loader(ABC):
 
     @classmethod
     def create_loader(
-        cls: type[T_Loader],
+        cls,
         client: ToolkitClient,
         build_dir: Path | None = None,
         console: Console | None = None,
-    ) -> T_Loader:
+    ) -> Self:
         return cls(client, build_dir, console)
 
     @property
@@ -83,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.
@@ -103,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 []
 
@@ -117,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
@@ -202,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
@@ -226,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)
 
@@ -249,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
@@ -289,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
@@ -326,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.
         """
@@ -386,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
@@ -397,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.
@@ -456,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.
@@ -475,12 +420,5 @@ class DataLoader(Loader, ABC):
     item_name: str
 
     @abstractmethod
-    def upload(self, state: BuildEnvironment, dry_run: bool) -> Iterable[tuple[str, int]]:
+    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)
-        ]

cognite_toolkit/_cdf_tk/{loaders/_data_loaders.py → cruds/_data_cruds.py}

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 import io
 from collections.abc import Iterable
 from pathlib import Path
@@ -7,42 +5,46 @@ from typing import TYPE_CHECKING, cast, final
 
 import pandas as pd
 from cognite.client.data_classes import FileMetadataWrite
-from cognite.client.data_classes._base import T_CogniteResourceList, T_WritableCogniteResource, T_WriteClass
 
 from cognite_toolkit._cdf_tk.client.data_classes.extendable_cognite_file import ExtendableCogniteFileApply
 from cognite_toolkit._cdf_tk.client.data_classes.raw import RawTable
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
+from cognite_toolkit._cdf_tk.protocols import (
+    T_ResourceRequest,
+    T_ResourceResponse,
+)
 from cognite_toolkit._cdf_tk.utils import read_yaml_content, safe_read
 from cognite_toolkit._cdf_tk.utils.file import read_csv
 
-from ._base_loaders import T_ID, DataLoader, ResourceLoader, T_WritableCogniteResourceList
-from ._resource_loaders import CogniteFileLoader, FileMetadataLoader, RawTableLoader, TimeSeriesLoader
+from ._base_cruds import T_ID, DataCRUD, ResourceCRUD
+from ._resource_cruds import CogniteFileCRUD, FileMetadataCRUD, RawTableCRUD, TimeSeriesCRUD
 
 if TYPE_CHECKING:
     from cognite_toolkit._cdf_tk.data_classes import BuildEnvironment
 
 
 @final
-class DatapointsLoader(DataLoader):
+class DatapointsCRUD(DataCRUD):
     item_name = "datapoints"
     folder_name = "timeseries"
     kind = "Datapoints"
-    filetypes = frozenset({"csv", "parquet"})
-    dependencies = frozenset({TimeSeriesLoader})
+    dependencies = frozenset({TimeSeriesCRUD})
     _doc_url = "Time-series/operation/postMultiTimeSeriesDatapoints"
 
     @property
     def display_name(self) -> str:
         return "timeseries datapoints"
 
-    def upload(self, state: BuildEnvironment, dry_run: bool) -> Iterable[tuple[str, int]]:
+    def upload(self, state: "BuildEnvironment", dry_run: bool) -> Iterable[tuple[str, int]]:
         if self.folder_name not in state.built_resources:
             return
 
         resource_directories = state.built_resources[self.folder_name].get_resource_directories(self.folder_name)
 
         for resource_dir in resource_directories:
-            for datafile in self._find_data_files(resource_dir):
+            for datafile in resource_dir.rglob("*"):
+                if not datafile.stem.casefold().endswith(self.kind.casefold()):
+                    continue
                 if datafile.suffix == ".csv":
                     # The replacement is used to ensure that we read exactly the same file on Windows and Linux
                     file_content = datafile.read_bytes().replace(b"\r\n", b"\n").decode("utf-8")
@@ -51,7 +53,7 @@ class DatapointsLoader(DataLoader):
                 elif datafile.suffix == ".parquet":
                     data = pd.read_parquet(datafile, engine="pyarrow")
                 else:
-                    raise ValueError(f"Unsupported file type {datafile.suffix} for {datafile.name}")
+                    continue
                 timeseries_ids = list(data.columns)
                 if len(timeseries_ids) == 1:
                     ts_str = timeseries_ids[0]
@@ -82,24 +84,18 @@ class DatapointsLoader(DataLoader):
 
 
 @final
-class FileLoader(DataLoader):
+class FileCRUD(DataCRUD):
     item_name = "file contents"
     folder_name = "files"
     kind = "File"
-    filetypes = frozenset()
-    exclude_filetype: frozenset[str] = frozenset({})
-    filename_pattern = (
-        # Exclude FileMetadata and CogniteFile
-        r"(?i)^(?!.*(?:FileMetadata|CogniteFile)$).*$"
-    )
-    dependencies = frozenset({FileMetadataLoader, CogniteFileLoader})
+    dependencies = frozenset({FileMetadataCRUD, CogniteFileCRUD})
     _doc_url = "Files/operation/initFileUpload"
 
     @property
     def display_name(self) -> str:
         return "file content"
 
-    def upload(self, state: BuildEnvironment, dry_run: bool) -> Iterable[tuple[str, int]]:
+    def upload(self, state: "BuildEnvironment", dry_run: bool) -> Iterable[tuple[str, int]]:
         if self.folder_name not in state.built_resources:
             return
 
@@ -108,8 +104,8 @@ class FileLoader(DataLoader):
                 continue
 
             if result := {
-                FileMetadataLoader.kind: (FileMetadataLoader, "external_id"),
-                CogniteFileLoader.kind: (CogniteFileLoader, "instance_id"),
+                FileMetadataCRUD.kind: (FileMetadataCRUD, "external_id"),
+                CogniteFileCRUD.kind: (CogniteFileCRUD, "instance_id"),
             }.get(resource.kind):
                 loader_cls, id_name = result
                 meta: FileMetadataWrite | ExtendableCogniteFileApply = self._read_metadata(
@@ -132,19 +128,16 @@ class FileLoader(DataLoader):
     @staticmethod
     def _read_metadata(
         destination: Path,
-        loader: type[
-            ResourceLoader[
-                T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
-            ]
-        ],
+        loader: type[ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse]],
         identifier: T_ID,
-    ) -> T_WriteClass:
+    ) -> T_ResourceRequest:
         built_content = read_yaml_content(safe_read(destination, encoding=BUILD_FOLDER_ENCODING))
         if isinstance(built_content, dict):
-            return loader.resource_write_cls.load(built_content)
+            return loader.resource_write_cls._load(built_content)
         elif isinstance(built_content, list):
+            write_resources = (loader.resource_write_cls._load(content) for content in built_content)
             try:
-                return next(m for m in loader.list_write_cls.load(built_content) if loader.get_id(m) == identifier)
+                return next(m for m in write_resources if loader.get_id(m) == identifier)
             except StopIteration:
                 raise RuntimeError(f"Missing metadata for {destination.as_posix()}")
 
@@ -152,30 +145,29 @@ class FileLoader(DataLoader):
 
 
 @final
-class RawFileLoader(DataLoader):
+class RawFileCRUD(DataCRUD):
     item_name = "rows"
     folder_name = "raw"
-    filetypes = frozenset({"csv", "parquet"})
     kind = "Raw"
-    dependencies = frozenset({RawTableLoader})
+    dependencies = frozenset({RawTableCRUD})
     _doc_url = "Raw/operation/postRows"
 
     @property
     def display_name(self) -> str:
         return "raw rows"
 
-    def upload(self, state: BuildEnvironment, dry_run: bool) -> Iterable[tuple[str, int]]:
+    def upload(self, state: "BuildEnvironment", dry_run: bool) -> Iterable[tuple[str, int]]:
         if self.folder_name not in state.built_resources:
             return
 
         for resource in state.built_resources[self.folder_name]:
-            if resource.kind != RawTableLoader.kind:
+            if resource.kind != RawTableCRUD.kind:
                 continue
             table = cast(RawTable, resource.identifier)
             datafile = next(
                 (
                     resource.source.path.with_suffix(f".{file_type}")
-                    for file_type in self.filetypes
+                    for file_type in ["csv", "parquet"]
                     if (resource.source.path.with_suffix(f".{file_type}").exists())
                 ),
                 None,
@@ -187,8 +179,7 @@ class RawFileLoader(DataLoader):
             if datafile.suffix == ".csv":
                 # The replacement is used to ensure that we read exactly the same file on Windows and Linux
                 file_content = datafile.read_bytes().replace(b"\r\n", b"\n").decode("utf-8")
-                data = read_csv(io.StringIO(file_content))
-                data.fillna("", inplace=True)
+                data = read_csv(io.StringIO(file_content)).astype(object).fillna("")
                 if not data.columns.empty and data.columns[0] == "key":
                     print(f"Setting index to 'key' for {datafile.name}")
                     data.set_index("key", inplace=True)