cognite-neat 0.123.26__py3-none-any.whl → 1.0.22__py3-none-any.whl

cognite/neat/_data_model/deployer/deployer.py

@@ -0,0 +1,431 @@
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from functools import partial
+from typing import cast
+
+from cognite.neat._client import NeatClient
+from cognite.neat._data_model._constants import COGNITE_SPACES
+from cognite.neat._data_model._shared import OnSuccessResultProducer
+from cognite.neat._data_model._snapshot import SchemaSnapshot
+from cognite.neat._data_model.models.dms import (
+    ContainerRequest,
+    DataModelBody,
+    RequestSchema,
+    T_DataModelResource,
+    T_ResourceId,
+)
+from cognite.neat._utils.collection import chunker_sequence
+from cognite.neat._utils.http_client import (
+    FailedRequestItems,
+    FailedResponseItems,
+    ItemIDBody,
+    ItemsRequest,
+    SuccessResponseItems,
+)
+from cognite.neat._utils.http_client._data_classes import APIResponse
+from cognite.neat._utils.useful_types import ModusOperandi, T_Reference
+
+from ._differ import ItemDiffer
+from ._differ_container import ContainerDiffer
+from ._differ_data_model import DataModelDiffer
+from ._differ_space import SpaceDiffer
+from ._differ_view import ViewDiffer
+from .data_classes import (
+    AddedField,
+    AppliedChanges,
+    ChangedFieldResult,
+    ContainerDeploymentPlan,
+    DataModelEndpoint,
+    DeploymentResult,
+    FieldChange,
+    FieldChanges,
+    HTTPChangeResult,
+    NoOpChangeResult,
+    RemovedField,
+    ResourceChange,
+    ResourceDeploymentPlan,
+    ResourceDeploymentPlanList,
+    SeverityType,
+)
+
+
+@dataclass
+class DeploymentOptions:
+    """Configuration options for deployment.
+
+    Attributes:
+        dry_run (bool): If True, the deployment will be simulated without applying changes. Defaults to True.
+        auto_rollback (bool): If True, automatically roll back changes if deployment fails. Defaults to True.
+        max_severity (SeverityType): Maximum allowed severity of changes to proceed with deployment.
+            Defaults to SeverityType.SAFE.
+        modus_operandi (ModusOperandi): Deployment mode. If "additive", only add/modify resources
+            specified in the data model. If "rebuild", remove resources not present in the data model.
+            Defaults to "additive".
+    """
+
+    dry_run: bool = True
+    auto_rollback: bool = True
+    drop_data: bool = False
+    max_severity: SeverityType = SeverityType.WARNING
+    modus_operandi: ModusOperandi = "additive"
+
+
+class SchemaDeployer(OnSuccessResultProducer):
+    INDEX_DELETE_BATCH_SIZE = 10
+    CONSTRAINT_DELETE_BATCH_SIZE = 10
+
+    def __init__(self, client: NeatClient, options: DeploymentOptions | None = None) -> None:
+        super().__init__()
+        self.client: NeatClient = client
+        self.options: DeploymentOptions = options or DeploymentOptions()
+
+    def run(self, data_model: RequestSchema) -> None:
+        if self._results is not None:
+            raise RuntimeError("SchemaDeployer has already been run.")
+        self._results = self.deploy(data_model)
+
+    def deploy(self, data_model: RequestSchema) -> DeploymentResult:
+        # Step 1: Fetch current CDF state
+        snapshot = SchemaSnapshot.fetch_cdf_data_model(self.client, data_model)
+
+        # Step 2: Create deployment plan by comparing local vs cdf
+        plan = self.create_deployment_plan(snapshot, data_model)
+
+        # Step 3: Adjust plan based on modus operandi
+        if self.options.modus_operandi == "additive":
+            # Filter out deletions and removals in additive mode
+            plan = plan.consolidate_changes()
+        elif self.options.modus_operandi == "rebuild":
+            # Breaking changes are forced by deleting and recreating resources
+            # Containers are treated as additive unless drop_data is specified
+            plan = plan.force_changes(self.options.drop_data)
+        else:
+            raise NotImplementedError(f"Unsupported modus operandi: {self.options.modus_operandi!r}")
+
+        if not self.should_proceed_to_deploy(plan):
+            # Step 4: Check if deployment should proceed
+            return DeploymentResult(status="failure", plan=list(plan), snapshot=snapshot)
+        elif self.options.dry_run:
+            # Step 5: If dry-run, return plan without applying
+            return DeploymentResult(status="pending", plan=list(plan), snapshot=snapshot)
+
+        # Step 6: Apply changes
+        changes = self.apply_changes(plan)
+
+        # Step 7: Rollback if failed and auto_rollback is enabled
+        if not changes.is_success and self.options.auto_rollback:
+            recovery = self.apply_changes(changes.as_recovery_plan())
+            return DeploymentResult(
+                status="recovered" if recovery.is_success else "recovery_failed",
+                plan=list(plan),
+                snapshot=snapshot,
+                responses=changes,
+                recovery=recovery,
+            )
+        return DeploymentResult(
+            status="success" if changes.is_success else "partial", plan=list(plan), snapshot=snapshot, responses=changes
+        )
+
+    def create_deployment_plan(self, snapshot: SchemaSnapshot, data_model: RequestSchema) -> ResourceDeploymentPlanList:
+        return ResourceDeploymentPlanList(
+            [
+                self._create_resource_plan(
+                    snapshot.spaces,
+                    data_model.spaces,
+                    "spaces",
+                    SpaceDiffer(),
+                    skip_criteria=partial(self._skip_resource, model_space=data_model.data_model.space),
+                ),
+                self._create_resource_plan(
+                    snapshot.containers,
+                    data_model.containers,
+                    "containers",
+                    ContainerDiffer(),
+                    ContainerDeploymentPlan,
+                    skip_criteria=partial(self._skip_resource, model_space=data_model.data_model.space),
+                ),
+                self._create_resource_plan(
+                    snapshot.views,
+                    data_model.views,
+                    "views",
+                    ViewDiffer(
+                        current_container_map=snapshot.containers,
+                        new_container_map={container.as_reference(): container for container in data_model.containers},
+                    ),
+                    skip_criteria=partial(self._skip_resource, model_space=data_model.data_model.space),
+                ),
+                self._create_resource_plan(
+                    snapshot.data_model,
+                    [data_model.data_model],
+                    "datamodels",
+                    DataModelDiffer(),
+                    skip_criteria=partial(self._skip_resource, model_space=data_model.data_model.space),
+                ),
+            ]
+        )
+
+    def _create_resource_plan(
+        self,
+        current_resources: dict[T_ResourceId, T_DataModelResource],
+        new_resources: list[T_DataModelResource],
+        endpoint: DataModelEndpoint,
+        differ: ItemDiffer[T_DataModelResource],
+        plan_type: type[ResourceDeploymentPlan[T_ResourceId, T_DataModelResource]] = ResourceDeploymentPlan,
+        skip_criteria: Callable[[T_ResourceId], str | None] | None = None,
+    ) -> ResourceDeploymentPlan[T_ResourceId, T_DataModelResource]:
+        resources: list[ResourceChange[T_ResourceId, T_DataModelResource]] = []
+        for new_resource in new_resources:
+            # We know that .as_reference() will return T_ResourceId
+            ref = cast(T_ResourceId, new_resource.as_reference())
+            if skip_criteria is not None and (reason := skip_criteria(ref)):
+                resources.append(ResourceChange(resource_id=ref, new_value=None, current_value=None, message=reason))
+                continue
+            if ref not in current_resources:
+                resources.append(ResourceChange(resource_id=ref, new_value=new_resource))
+                continue
+            current_resource = current_resources[ref]
+            diffs = differ.diff(current_resource, new_resource)
+            if (
+                isinstance(current_resource, ContainerRequest)
+                and isinstance(new_resource, ContainerRequest)
+                and self.options.modus_operandi == "additive"
+            ):
+                # In additive mode, changes to constraints and indexes require removal and re-adding
+                # In rebuild mode, all changes are forced via deletion and re-adding
+                diffs = self.remove_readd_modified_indexes_and_constraints(diffs, current_resource, new_resource)
+            resources.append(
+                ResourceChange(resource_id=ref, new_value=new_resource, current_value=current_resource, changes=diffs)
+            )
+
+        return plan_type(endpoint=endpoint, resources=resources)
+
+    @classmethod
+    def remove_readd_modified_indexes_and_constraints(
+        cls, diffs: list[FieldChange], current_resource: ContainerRequest, new_resource: ContainerRequest
+    ) -> list[FieldChange]:
+        """Constraints and indexes cannot be modified directly; they must be removed and re-added.
+
+        Args:
+            diffs: The list of field changes detected by the differ.
+            current_resource: The current state of the container.
+            new_resource: The desired state of the container.
+        Returns:
+            A modified list of field changes with constraints and indexes handled appropriately.
+        """
+        modified_diffs: list[FieldChange] = []
+        for diff in diffs:
+            if (diff.field_path.startswith("constraints") or diff.field_path.startswith("indexes")) and isinstance(
+                diff, FieldChanges
+            ):
+                if "." not in diff.field_path:
+                    # Should not happen, but just in case
+                    raise RuntimeError("Bug in Neat. Malformed field path for constraint/index change.")
+                # Field type is either "constraints" or "indexes"
+                field_type, identifier, *_ = diff.field_path.split(".", maxsplit=2)
+                # Mark for removal
+                modified_diffs.append(
+                    RemovedField(
+                        field_path=f"{field_type}.{identifier}",
+                        item_severity=SeverityType.WARNING,
+                        current_value=getattr(current_resource, field_type)[identifier],
+                    )
+                )
+                # Mark for addition
+                modified_diffs.append(
+                    AddedField(
+                        field_path=f"{field_type}.{identifier}",
+                        item_severity=SeverityType.SAFE,
+                        new_value=getattr(new_resource, field_type)[identifier],
+                    )
+                )
+            else:
+                modified_diffs.append(diff)
+        return modified_diffs
+
+    @classmethod
+    def _skip_resource(cls, resource_id: T_ResourceId, model_space: str) -> str | None:
+        """Checks if a resource should be skipped based on its space.
+
+        Args:
+            resource_id: The ID of the resource to check.
+            model_space: The space of the data model.
+
+        Returns:
+            A reason for skipping if the resource space does not match the model space, otherwise None.
+        """
+        if resource_id.space in COGNITE_SPACES:
+            return f"Skipping resource as it is in the reserved Cognite space '{resource_id.space}'."
+        elif resource_id.space != model_space:
+            return (
+                f"Skipping resource as it is in the space '{resource_id.space}'"
+                f" not matching data model space '{model_space}'."
+            )
+        return None
+
+    def should_proceed_to_deploy(self, plan: Sequence[ResourceDeploymentPlan]) -> bool:
+        max_severity_in_plan = SeverityType.max_severity(
+            [change.severity for resource_plan in plan for change in resource_plan.resources],
+            default=SeverityType.SAFE,
+        )
+        return max_severity_in_plan.value <= self.options.max_severity.value
+
+    def apply_changes(self, plan: Sequence[ResourceDeploymentPlan]) -> AppliedChanges:
+        """Applies the given deployment plan to CDF by making the necessary API calls.
+
+        Args:
+            plan (list[ResourceDeploymentPlan]): The deployment plan to apply.
+
+        Returns:
+            AppliedChanges: The result of applying the changes.
+        """
+        applied_changes = AppliedChanges()
+        # If any HTTP request fails, the skip_message will be set and subsequent operations will be skipped
+        failure_message: str | None = None
+        for resource in reversed(plan):
+            if failure_message is None:
+                deletions = self._delete_items(resource)
+                applied_changes.deletions.extend(deletions)
+                if any(not deletion.is_success for deletion in deletions):
+                    failure_message = f"Skipping due to {resource.endpoint} deletions failing."
+            else:
+                applied_changes.skipped.extend(
+                    [
+                        NoOpChangeResult(endpoint=resource.endpoint, change=change, reason=failure_message)
+                        for change in resource.to_delete
+                    ]
+                )
+
+        for resource in plan:
+            if failure_message is None:
+                if isinstance(resource, ContainerDeploymentPlan):
+                    # Note that we continue to deploy even if removing constraints/indexes fail,
+                    # as the creation/update of views and data models will still succeed.
+                    applied_changes.changed_fields.extend(self._remove_container_constraints(resource))
+                    applied_changes.changed_fields.extend(self._remove_container_indexes(resource))
+
+                creations, updated = self._upsert_items(resource)
+                applied_changes.created.extend(creations)
+                applied_changes.updated.extend(updated)
+                if any(not change.is_success for change in creations + updated):
+                    failure_message = f"Skipping due to {resource.endpoint} upsert failing."
+            else:
+                applied_changes.skipped.extend(
+                    [
+                        NoOpChangeResult(endpoint=resource.endpoint, change=change, reason=failure_message)
+                        for change in resource.to_upsert
+                    ]
+                )
+
+            applied_changes.unchanged.extend(
+                [
+                    NoOpChangeResult(endpoint=resource.endpoint, change=change, reason="No changes detected.")
+                    for change in resource.unchanged
+                ]
+            )
+            applied_changes.skipped.extend(
+                [
+                    NoOpChangeResult(endpoint=resource.endpoint, change=change, reason=change.message or "Unknown")
+                    for change in resource.skip
+                ]
+            )
+        return applied_changes
+
+    def _delete_items(self, resource: ResourceDeploymentPlan) -> list[HTTPChangeResult]:
+        to_delete_by_id = {change.resource_id: change for change in resource.to_delete}
+        if not to_delete_by_id:
+            return []
+        responses = self.client.http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self.client.config.create_api_url(f"/models/{resource.endpoint}/delete"),
+                method="POST",
+                body=ItemIDBody(items=list(to_delete_by_id.keys())),
+            )
+        )
+        return self._process_resource_responses(responses, to_delete_by_id, resource.endpoint)
+
+    def _upsert_items(self, resource: ResourceDeploymentPlan) -> tuple[list[HTTPChangeResult], list[HTTPChangeResult]]:
+        to_upsert = [
+            resource_change.new_value for resource_change in resource.to_upsert if resource_change.new_value is not None
+        ]
+        if not to_upsert:
+            return [], []
+        responses = self.client.http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self.client.config.create_api_url(f"/models/{resource.endpoint}"),
+                method="POST",
+                body=DataModelBody(items=to_upsert),
+            )
+        )
+        to_create_by_id = {rc.resource_id: rc for rc in resource.to_create}
+        create_result = self._process_resource_responses(responses, to_create_by_id, resource.endpoint)
+        to_update_by_id = {rc.resource_id: rc for rc in resource.to_update}
+        update_result = self._process_resource_responses(responses, to_update_by_id, resource.endpoint)
+        return create_result, update_result
+
+    def _remove_container_indexes(self, resource: ContainerDeploymentPlan) -> list[ChangedFieldResult]:
+        return self._remove_container_fields(
+            resource.indexes_to_remove,
+            "/models/containers/indexes/delete",
+            self.INDEX_DELETE_BATCH_SIZE,
+        )
+
+    def _remove_container_constraints(self, resource: ContainerDeploymentPlan) -> list[ChangedFieldResult]:
+        return self._remove_container_fields(
+            resource.constraints_to_remove,
+            "/models/containers/constraints/delete",
+            self.CONSTRAINT_DELETE_BATCH_SIZE,
+        )
+
+    def _remove_container_fields(
+        self,
+        fields_to_remove: Mapping[T_Reference, FieldChange],
+        endpoint: str,
+        batch_size: int,
+    ) -> list[ChangedFieldResult]:
+        if not fields_to_remove:
+            return []
+        results: list[ChangedFieldResult] = []
+        for batch in chunker_sequence(list(fields_to_remove.keys()), batch_size):
+            responses = self.client.http_client.request_with_retries(
+                ItemsRequest(
+                    endpoint_url=self.client.config.create_api_url(endpoint),
+                    method="POST",
+                    body=ItemIDBody(items=batch),
+                )
+            )
+            results.extend(self._process_field_responses(responses, fields_to_remove))
+        return results
+
+    @classmethod
+    def _process_resource_responses(
+        cls, responses: APIResponse, change_by_id: dict[T_ResourceId, ResourceChange], endpoint: DataModelEndpoint
+    ) -> list[HTTPChangeResult]:
+        results: list[HTTPChangeResult] = []
+        for response in responses:
+            if isinstance(response, SuccessResponseItems | FailedResponseItems | FailedRequestItems):
+                for id in response.ids:
+                    if id not in change_by_id:
+                        continue
+                    results.append(HTTPChangeResult(change=change_by_id[id], http_message=response, endpoint=endpoint))
+            else:
+                # This should never happen as we do a ItemsRequest should always return ItemMessage responses
+                raise ValueError("Bug in Neat. Got an unexpected response type.")
+        return results
+
+    @classmethod
+    def _process_field_responses(
+        cls, responses: APIResponse, change_by_id: Mapping[T_Reference, FieldChange]
+    ) -> list[ChangedFieldResult]:
+        results: list[ChangedFieldResult] = []
+        for response in responses:
+            if isinstance(response, SuccessResponseItems | FailedResponseItems | FailedRequestItems):
+                for id in response.ids:
+                    if id not in change_by_id:
+                        continue
+                    results.append(
+                        ChangedFieldResult(resource_id=id, field_change=change_by_id[id], http_message=response)
+                    )
+            else:
+                # This should never happen as we do a ItemsRequest should always return ItemMessage responses
+                raise RuntimeError("Bug in Neat. Got an unexpected response type.")
+        return results

cognite/neat/_data_model/exporters/__init__.py

@@ -0,0 +1,15 @@
+from ._api_exporter import DMSAPIExporter, DMSAPIJSONExporter, DMSAPIYAMLExporter
+from ._base import DMSExporter, DMSFileExporter
+from ._table_exporter.exporter import DMSExcelExporter, DMSTableExporter, DMSTableJSONExporter, DMSTableYamlExporter
+
+__all__ = [
+    "DMSAPIExporter",
+    "DMSAPIJSONExporter",
+    "DMSAPIYAMLExporter",
+    "DMSExcelExporter",
+    "DMSExporter",
+    "DMSFileExporter",
+    "DMSTableExporter",
+    "DMSTableJSONExporter",
+    "DMSTableYamlExporter",
+]

cognite/neat/_data_model/exporters/_api_exporter.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+
+import yaml
+
+from cognite.neat._data_model.exporters._base import DMSExporter, DMSFileExporter
+from cognite.neat._data_model.models.dms import RequestSchema
+
+
+class DMSAPIExporter(DMSExporter[RequestSchema]):
+    def export(self, data_model: RequestSchema) -> RequestSchema:
+        return data_model
+
+    def export_to_file(self, data_model: RequestSchema, file_path: Path) -> None:
+        raise RuntimeError(f"{type(self).__name__} does not support export_to_file method.")
+
+
+class DMSAPIYAMLExporter(DMSAPIExporter, DMSFileExporter[RequestSchema]):
+    def export_to_file(self, data_model: RequestSchema, file_path: Path) -> None:
+        """Export the data model to a YAML file in API format."""
+        if file_path.suffix.lower() not in {".yaml", ".yml"}:
+            raise ValueError("The file path must have a .yaml or .yml extension.")
+
+        api_format = data_model.model_dump(mode="json", by_alias=True)
+        file_path.write_text(yaml.safe_dump(api_format, sort_keys=False), encoding=self.ENCODING, newline=self.NEW_LINE)
+
+
+class DMSAPIJSONExporter(DMSAPIExporter, DMSFileExporter[RequestSchema]):
+    def export_to_file(self, data_model: RequestSchema, file_path: Path) -> None:
+        """Export the data model to a JSON file in API format."""
+        if file_path.suffix.lower() != ".json":
+            raise ValueError("The file path must have a .json extension.")
+
+        file_path.write_text(
+            data_model.model_dump_json(by_alias=True),
+            encoding=self.ENCODING,
+            newline=self.NEW_LINE,
+        )

cognite/neat/_data_model/exporters/_base.py

@@ -0,0 +1,24 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Generic, TypeVar
+
+from cognite.neat._data_model.models.dms import RequestSchema
+
+T_Export = TypeVar("T_Export")
+
+
+class DMSExporter(ABC, Generic[T_Export]):
+    """This is the base class for all DMS exporters."""
+
+    NEW_LINE = "\n"
+    ENCODING = "utf-8"
+
+    @abstractmethod
+    def export(self, data_model: RequestSchema) -> T_Export:
+        raise NotImplementedError()
+
+
+class DMSFileExporter(DMSExporter[T_Export], ABC):
+    @abstractmethod
+    def export_to_file(self, data_model: RequestSchema, file_path: Path) -> None:
+        raise NotImplementedError()

cognite/neat/_data_model/exporters/_table_exporter/exporter.py

@@ -0,0 +1,128 @@
+import json
+from pathlib import Path
+from typing import cast
+
+import yaml
+
+from cognite.neat._data_model.exporters._base import DMSExporter, DMSFileExporter
+from cognite.neat._data_model.importers._table_importer.data_classes import DMSProperty, TableDMS
+from cognite.neat._data_model.models.dms import RequestSchema
+from cognite.neat._utils.useful_types import DataModelTableType
+
+from .workbook import WorkbookCreator, WorkbookOptions
+from .writer import DMSTableWriter
+
+
+class DMSTableExporter(DMSExporter[DataModelTableType]):
+    """Exports DMS to a table structure.
+
+    The tables can are expected to be a dictionary where the keys are the table names and the values
+    are lists of dictionaries representing the rows in the table.
+    """
+
+    class Sheets:
+        properties = cast(str, TableDMS.model_fields["properties"].validation_alias)
+
+    def __init__(self, exclude_none: bool = False, skip_properties_in_other_spaces: bool = True) -> None:
+        self._exclude_none = exclude_none
+        self._skip_properties_in_other_spaces = skip_properties_in_other_spaces
+
+    def export(self, data_model: RequestSchema) -> DataModelTableType:
+        model = data_model.data_model
+        tables = DMSTableWriter(model.space, model.version, self._skip_properties_in_other_spaces).write_tables(
+            data_model
+        )
+        exclude: set[str] = set()
+        if self._exclude_none:
+            if not tables.enum:
+                exclude.add("enum")
+            if not tables.nodes:
+                exclude.add("nodes")
+            if not tables.containers:
+                exclude.add("containers")
+
+        output = tables.model_dump(mode="json", by_alias=True, exclude_none=self._exclude_none, exclude=exclude)
+        # When we have exclude_none we only want to exclude none of optional properties, not required.
+        # Thus, we do the implementation below
+        required_properties = [
+            field_.serialization_alias for field_ in DMSProperty.model_fields.values() if field_.is_required()
+        ]
+        for row in output[self.Sheets.properties]:
+            for prop in required_properties:
+                if prop not in row:
+                    row[prop] = None
+        return output
+
+
+class DMSTableYamlExporter(DMSTableExporter, DMSFileExporter[DataModelTableType]):
+    """Exports DMS to YAML."""
+
+    def __init__(self) -> None:
+        super().__init__(exclude_none=True)
+
+    def export_to_file(self, data_model: RequestSchema, file_path: Path) -> None:
+        """Exports the data model as a flat YAML file, which is identical to the spreadsheet representation
+
+        Args:
+            data_model (RequestSchema): The data model to export.
+            file_path (Path): The path to the YAML file to create.
+        """
+        table_format = self.export(data_model)
+        file_path.write_text(
+            yaml.safe_dump(table_format, sort_keys=False), encoding=self.ENCODING, newline=self.NEW_LINE
+        )
+
+
+class DMSTableJSONExporter(DMSTableExporter, DMSFileExporter[DataModelTableType]):
+    """Exports DMS to JSON."""
+
+    def __init__(self) -> None:
+        super().__init__(exclude_none=True)
+
+    def export_to_file(self, data_model: RequestSchema, file_path: Path) -> None:
+        """Exports the data model as a flat JSON file, which is identical to the spreadsheet representation
+
+        Args:
+            data_model (RequestSchema): The data model to export.
+            file_path (Path): The path to the JSON file to create.
+        """
+        table_format = self.export(data_model)
+        file_path.write_text(json.dumps(table_format), encoding=self.ENCODING, newline=self.NEW_LINE)
+
+
+class DMSExcelExporter(DMSTableExporter, DMSFileExporter[DataModelTableType]):
+    """Exports DMS to Excel file."""
+
+    def __init__(self, options: WorkbookOptions | None = None) -> None:
+        self._options = options or WorkbookOptions()
+        super().__init__(
+            exclude_none=False, skip_properties_in_other_spaces=self._options.skip_properties_in_other_spaces
+        )
+
+    def export_to_file(self, data_model: RequestSchema, file_path: Path) -> None:
+        """Exports the data model as a Excel file.
+
+        Args:
+            data_model (RequestSchema): The data model to export.
+            file_path (Path): The path to the Excel file to create.
+            options (WorkbookOptions | None): Options for creating the workbook.
+        """
+        table_format = self.export(data_model)
+        workbook = WorkbookCreator(self._options).create_workbook(table_format)
+        try:
+            workbook.save(file_path)
+        finally:
+            workbook.close()
+
+
+class DMSCsvExporter(DMSTableExporter, DMSFileExporter[DataModelTableType]):
+    """Exports DMS to CSV files in a directory."""
+
+    def export_to_file(self, data_model: RequestSchema, directory_path: Path) -> None:
+        """Exports the data model as a set of CSV files, one for each table.
+
+        Args:
+            data_model (RequestSchema): The data model to export.
+            directory_path (Path): The path to the directory to create the CSV files in.
+        """
+        raise NotImplementedError()