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

cognite_toolkit/_cdf_tk/commands/_purge.py

@@ -1,65 +1,69 @@
-import dataclasses
 import uuid
+from abc import ABC, abstractmethod
 from collections.abc import Callable, Hashable, Iterable, Sequence
+from dataclasses import dataclass
 from functools import partial
-from graphlib import CycleError, TopologicalSorter
-from typing import cast
+from typing import Literal, cast
 
 import questionary
-from cognite.client.data_classes import AggregateResultItem, DataSetUpdate, filters
-from cognite.client.data_classes._base import CogniteResourceList
-from cognite.client.data_classes.data_modeling import NodeId, ViewId
+from cognite.client.data_classes import DataSetUpdate
+from cognite.client.data_classes.data_modeling import Edge, NodeId
+from cognite.client.data_classes.data_modeling.statistics import SpaceStatistics
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils._identifier import InstanceId
 from rich import print
 from rich.console import Console
 from rich.panel import Panel
-from rich.status import Status
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.cruds import (
-    RESOURCE_CRUD_LIST,
     AssetCRUD,
-    CogniteFileCRUD,
     ContainerCRUD,
     DataModelCRUD,
-    DataSetsCRUD,
     EdgeCRUD,
-    FunctionCRUD,
-    GraphQLCRUD,
-    GroupAllScopedCRUD,
-    GroupCRUD,
-    GroupResourceScopedCRUD,
-    HostedExtractorDestinationCRUD,
-    LocationFilterCRUD,
+    EventCRUD,
+    ExtractionPipelineCRUD,
+    FileMetadataCRUD,
+    LabelCRUD,
     NodeCRUD,
+    RelationshipCRUD,
     ResourceCRUD,
+    SequenceCRUD,
     SpaceCRUD,
-    StreamlitCRUD,
+    ThreeDModelCRUD,
+    TimeSeriesCRUD,
     TransformationCRUD,
     ViewCRUD,
+    WorkflowCRUD,
 )
 from cognite_toolkit._cdf_tk.data_classes import DeployResults, ResourceDeployResult
 from cognite_toolkit._cdf_tk.exceptions import (
     AuthorizationError,
-    CDFAPIError,
     ToolkitMissingResourceError,
-    ToolkitRequiredValueError,
-    ToolkitValueError,
 )
-from cognite_toolkit._cdf_tk.storageio import InstanceIO, InstanceSelector
+from cognite_toolkit._cdf_tk.protocols import ResourceResponseProtocol
+from cognite_toolkit._cdf_tk.storageio import InstanceIO
+from cognite_toolkit._cdf_tk.storageio.selectors import InstanceSelector
 from cognite_toolkit._cdf_tk.tk_warnings import (
     HighSeverityWarning,
     LimitedAccessWarning,
-    MediumSeverityWarning,
 )
 from cognite_toolkit._cdf_tk.utils import humanize_collection
+from cognite_toolkit._cdf_tk.utils.aggregators import (
+    AssetAggregator,
+    EventAggregator,
+    FileAggregator,
+    LabelCountAggregator,
+    RelationshipAggregator,
+    SequenceAggregator,
+    TimeSeriesAggregator,
+)
 from cognite_toolkit._cdf_tk.utils.http_client import (
-    FailedRequestMessage,
+    FailedRequestItems,
+    FailedResponseItems,
     HTTPClient,
     ItemsRequest,
-    ResponseMessage,
-    SuccessItem,
+    SuccessResponseItems,
 )
 from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
@@ -68,95 +72,158 @@ from cognite_toolkit._cdf_tk.utils.validate_access import ValidateAccess
 from ._base import ToolkitCommand
 
 
-@dataclasses.dataclass
+@dataclass
 class DeleteResults:
     deleted: int = 0
     failed: int = 0
 
 
+@dataclass
+class DeleteItem:
+    item: JsonVal
+    as_id_fun: Callable[[JsonVal], Hashable]
+
+    def dump(self) -> JsonVal:
+        return self.item
+
+    def as_id(self) -> Hashable:
+        return self.as_id_fun(self.item)
+
+
+@dataclass
+class ToDelete(ABC):
+    crud: ResourceCRUD
+    total: int
+    delete_url: str
+
+    @property
+    def display_name(self) -> str:
+        return self.crud.display_name
+
+    @abstractmethod
+    def get_process_function(
+        self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
+    ) -> Callable[[list[ResourceResponseProtocol]], list[JsonVal]]:
+        raise NotImplementedError()
+
+    def get_extra_fields(self) -> dict[str, JsonVal]:
+        return {}
+
+
+@dataclass
+class DataModelingToDelete(ToDelete):
+    def get_process_function(
+        self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
+    ) -> Callable[[list[ResourceResponseProtocol]], list[JsonVal]]:
+        def as_id(chunk: list[ResourceResponseProtocol]) -> list[JsonVal]:
+            # We know that all data modeling resources implement as_id
+            return [item.as_id().dump(include_type=False) for item in chunk]  # type: ignore[attr-defined]
+
+        return as_id
+
+
+@dataclass
+class EdgeToDelete(ToDelete):
+    def get_process_function(
+        self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
+    ) -> Callable[[list[ResourceResponseProtocol]], list[JsonVal]]:
+        def as_id(chunk: list[ResourceResponseProtocol]) -> list[JsonVal]:
+            return [
+                {"space": item.space, "externalId": item.external_id, "instanceType": "edge"}
+                for item in cast(list[Edge], chunk)
+            ]
+
+        return as_id
+
+
+@dataclass
+class NodesToDelete(ToDelete):
+    delete_datapoints: bool
+    delete_file_content: bool
+
+    def get_process_function(
+        self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
+    ) -> Callable[[list[ResourceResponseProtocol]], list[JsonVal]]:
+        def check_for_data(chunk: list[ResourceResponseProtocol]) -> list[JsonVal]:
+            # We know that all node resources implement as_id
+            node_ids = [item.as_id() for item in chunk]  # type: ignore[attr-defined]
+            found_ids: set[InstanceId] = set()
+            if not self.delete_datapoints:
+                timeseries = client.time_series.retrieve_multiple(instance_ids=node_ids, ignore_unknown_ids=True)
+                found_ids |= {ts.instance_id for ts in timeseries if ts.instance_id is not None}
+            if not self.delete_file_content:
+                files = client.files.retrieve_multiple(instance_ids=node_ids, ignore_unknown_ids=True)
+                found_ids |= {f.instance_id for f in files if f.instance_id is not None}
+            if found_ids and verbose:
+                console.print(f"Skipping {found_ids} nodes as they have datapoints or file content")
+            process_results.unchanged += len(found_ids)
+            result: list[JsonVal] = []
+            for node_id in (n for n in node_ids if n not in found_ids):
+                dumped = node_id.dump(include_instance_type=True)
+                # The delete endpoint expects "instanceType" instead of "type"
+                dumped["instanceType"] = dumped.pop("type")
+                result.append(dumped)
+            return result
+
+        return check_for_data
+
+
+@dataclass
+class IdResourceToDelete(ToDelete):
+    def get_process_function(
+        self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
+    ) -> Callable[[list[ResourceResponseProtocol]], list[JsonVal]]:
+        def as_id(chunk: list[ResourceResponseProtocol]) -> list[JsonVal]:
+            # We know that all id resources have an id attribute
+            return [{"id": item.id} for item in chunk]  # type: ignore[attr-defined]
+
+        return as_id
+
+
+@dataclass
+class ExternalIdToDelete(ToDelete):
+    def get_process_function(
+        self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
+    ) -> Callable[[list[ResourceResponseProtocol]], list[JsonVal]]:
+        def as_external_id(chunk: list[ResourceResponseProtocol]) -> list[JsonVal]:
+            # We know that all external id resources have an external_id attribute
+            return [{"externalId": item.external_id} for item in chunk]  # type: ignore[attr-defined]
+
+        return as_external_id
+
+
+@dataclass
+class AssetToDelete(IdResourceToDelete):
+    recursive: bool
+
+    def get_extra_fields(self) -> dict[str, JsonVal]:
+        return {"recursive": self.recursive}
+
+
 class PurgeCommand(ToolkitCommand):
     BATCH_SIZE_DM = 1000
 
     def space(
-        self,
-        client: ToolkitClient,
-        space: str | None = None,
-        include_space: bool = False,
-        dry_run: bool = False,
-        auto_yes: bool = False,
-        verbose: bool = False,
-    ) -> None:
-        """Purge a space and all its content"""
-        selected_space = self._get_selected_space(space, client)
-        if space is None:
-            # Interactive mode
-            include_space = questionary.confirm("Do you also want to delete the space itself?", default=False).ask()
-            dry_run = questionary.confirm("Dry run?", default=True).ask()
-        if not dry_run:
-            self._print_panel("space", selected_space)
-            if not auto_yes:
-                confirm = questionary.confirm(
-                    f"Are you really sure you want to purge the {selected_space!r} space?", default=False
-                ).ask()
-                if not confirm:
-                    return
-                confirm = questionary.confirm(
-                    f"If any of the nodes in {selected_space!r} are TimeSeries or Files, this will delete the "
-                    "datapoints and file contents. If you want to unlink the nodes before deleting, please use the "
-                    "cdf purge instances command. Are you sure you want to continue?",
-                    default=False,
-                ).ask()
-                if not confirm:
-                    return
-        loaders = self._get_dependencies(
-            SpaceCRUD,
-            exclude={
-                GraphQLCRUD,
-                GroupResourceScopedCRUD,
-                LocationFilterCRUD,
-                TransformationCRUD,
-                CogniteFileCRUD,
-            },
-        )
-        is_purged = self._purge(client, loaders, selected_space, dry_run=dry_run, verbose=verbose)
-        if include_space and is_purged:
-            space_loader = SpaceCRUD.create_loader(client)
-            if dry_run:
-                print(f"Would delete space {selected_space}")
-            else:
-                try:
-                    space_loader.delete([selected_space])
-                    print(f"Space {selected_space} deleted")
-                except CogniteAPIError as e:
-                    self.warn(HighSeverityWarning(f"Failed to delete space {selected_space!r}: {e}"))
-        elif include_space:
-            self.warn(HighSeverityWarning(f"Space {selected_space!r} was not deleted due to errors during the purge"))
-
-        if not dry_run and is_purged:
-            print(f"Purge space {selected_space!r} completed.")
-        elif not dry_run:
-            print(f"Purge space {selected_space!r} partly completed. See warnings for details.")
-
-    def space_v2(
         self,
         client: ToolkitClient,
         selected_space: str,
         include_space: bool = False,
+        delete_datapoints: bool = False,
+        delete_file_content: bool = False,
         dry_run: bool = False,
         auto_yes: bool = False,
         verbose: bool = False,
     ) -> DeployResults:
-        results = DeployResults([], "purge", dry_run=dry_run)
-
         # Warning Messages
         if not dry_run:
             self._print_panel("space", selected_space)
+
         if not dry_run and not auto_yes:
             confirm = questionary.confirm(
                 f"Are you really sure you want to purge the {selected_space!r} space?", default=False
             ).ask()
             if not confirm:
-                return results
+                return DeployResults([], "purge", dry_run=dry_run)
 
         stats = client.data_modeling.statistics.spaces.retrieve(selected_space)
         if stats is None:
@@ -165,189 +232,328 @@ class PurgeCommand(ToolkitCommand):
         # ValidateAuth
         validator = ValidateAccess(client, "purge")
         if include_space or (stats.containers + stats.views + stats.data_models) > 0:
+            # We check for write even in dry-run mode. This is because dry-run is expected to fail
+            # if the user cannot perform the purge.
             validator.data_model(["read", "write"], spaces={selected_space})
         if (stats.nodes + stats.edges) > 0:
             validator.instances(["read", "write"], spaces={selected_space})
 
-        config = client.config
-        total_by_crud_cls = {
-            EdgeCRUD: (stats.edges, config.create_api_url("/models/instances/delete")),
-            NodeCRUD: (stats.nodes, config.create_api_url("/models/instances/delete")),
-            DataModelCRUD: (stats.data_models, config.create_api_url("/models/datamodels/delete")),
-            ViewCRUD: (stats.views, config.create_api_url("/models/views/delete")),
-            ContainerCRUD: (stats.containers, config.create_api_url("/models/containers/delete")),
-        }
+        to_delete = self._create_to_delete_list_purge_space(client, delete_datapoints, delete_file_content, stats)
         if dry_run:
-            for crud_cls, (total, _) in total_by_crud_cls.items():
-                crud = crud_cls.create_loader(client)  # type: ignore[attr-defined]
-                results[crud.display_name] = ResourceDeployResult(crud.display_name, deleted=total)
+            results = DeployResults([], "purge", dry_run=True)
+            for item in to_delete:
+                results[item.display_name] = ResourceDeployResult(item.display_name, deleted=item.total)
             if include_space:
                 space_loader = SpaceCRUD.create_loader(client)
                 results[space_loader.display_name] = ResourceDeployResult(space_loader.display_name, deleted=1)
         else:
-            with HTTPClient(client.config, max_retries=10) as delete_client:
-                for crud_cls, (total, URL) in total_by_crud_cls.items():
-                    crud = crud_cls.create_loader(client)  # type: ignore[attr-defined]
-                    if total == 0:
-                        results[crud.display_name] = ResourceDeployResult(crud.display_name, deleted=0)
-                        continue
-                    result = ResourceDeployResult(crud.display_name)
-                    # Containers, DataModels and Views need special handling to avoid type info in the delete call
-                    # While for instance we need the type info in delete.
-                    dump_args = (
-                        {"include_type": False} if isinstance(crud, ContainerCRUD | DataModelCRUD | ViewCRUD) else {}
-                    )
-                    executor = ProducerWorkerExecutor[CogniteResourceList, list[JsonVal]](
-                        download_iterable=self._iterate_batch(crud, selected_space, batch_size=self.BATCH_SIZE_DM),
-                        process=lambda list_: [item.as_id().dump(**dump_args) for item in list_],
-                        write=self._purge_batch(crud, URL, delete_client, result),
-                        max_queue_size=10,
-                        iteration_count=total // self.BATCH_SIZE_DM + (1 if total % self.BATCH_SIZE_DM > 0 else 0),
-                        download_description=f"Downloading {crud.display_name}",
-                        process_description=f"Preparing {crud.display_name} for deletion",
-                        write_description=f"Deleting {crud.display_name}",
-                    )
-                    executor.run()
-                    results[crud.display_name] = result
-                    if executor.error_occurred:
-                        self.warn(
-                            HighSeverityWarning(f"Failed to delete all {crud.display_name}. {executor.error_message}")
-                        )
+            results = self._delete_resources(to_delete, client, verbose, selected_space, None)
             if include_space:
-                space_loader = SpaceCRUD.create_loader(client)
-                try:
-                    space_loader.delete([selected_space])
-                    print(f"Space {selected_space} deleted")
-                except CogniteAPIError as e:
-                    self.warn(HighSeverityWarning(f"Failed to delete space {selected_space!r}: {e}"))
-                else:
-                    results[space_loader.display_name] = ResourceDeployResult(space_loader.display_name, deleted=1)
+                self._delete_space(client, selected_space, results)
         print(results.counts_table(exclude_columns={"Created", "Changed", "Total"}))
         return results
 
     @staticmethod
-    def _iterate_batch(crud: ResourceCRUD, selected_space: str, batch_size: int) -> Iterable[CogniteResourceList]:
-        batch = crud.list_cls([])
-        for resource in crud.iterate(space=selected_space):
+    def _create_to_delete_list_purge_space(
+        client: ToolkitClient, delete_datapoints: bool, delete_file_content: bool, stats: SpaceStatistics
+    ) -> list[ToDelete]:
+        config = client.config
+        to_delete = [
+            EdgeToDelete(
+                EdgeCRUD.create_loader(client), stats.edges, config.create_api_url("/models/instances/delete")
+            ),
+            NodesToDelete(
+                NodeCRUD.create_loader(client),
+                stats.nodes,
+                config.create_api_url(
+                    "/models/instances/delete",
+                ),
+                delete_datapoints=delete_datapoints,
+                delete_file_content=delete_file_content,
+            ),
+            DataModelingToDelete(
+                DataModelCRUD.create_loader(client),
+                stats.data_models,
+                config.create_api_url("/models/datamodels/delete"),
+            ),
+            DataModelingToDelete(
+                ViewCRUD.create_loader(client), stats.views, config.create_api_url("/models/views/delete")
+            ),
+            DataModelingToDelete(
+                ContainerCRUD.create_loader(client),
+                stats.containers,
+                config.create_api_url("/models/containers/delete"),
+            ),
+        ]
+        return to_delete
+
+    def _delete_space(self, client: ToolkitClient, selected_space: str, results: DeployResults) -> None:
+        space_loader = SpaceCRUD.create_loader(client)
+        try:
+            space_loader.delete([selected_space])
+            print(f"Space {selected_space} deleted")
+        except CogniteAPIError as e:
+            self.warn(HighSeverityWarning(f"Failed to delete space {selected_space!r}: {e}"))
+        else:
+            results[space_loader.display_name] = ResourceDeployResult(space_loader.display_name, deleted=1)
+
+    def _delete_resources(
+        self,
+        to_delete: list[ToDelete],
+        client: ToolkitClient,
+        verbose: bool,
+        space: str | None,
+        data_set_external_id: str | None,
+    ) -> DeployResults:
+        results = DeployResults([], "purge", dry_run=False)
+        console = Console()
+        with HTTPClient(client.config, max_retries=10) as delete_client:
+            for item in to_delete:
+                if item.total == 0:
+                    results[item.display_name] = ResourceDeployResult(item.display_name, deleted=0)
+                    continue
+                # Two results objects since they are updated concurrently
+                process_results = ResourceDeployResult(item.display_name)
+                write_results = ResourceDeployResult(item.display_name)
+                iteration_count: int | None = None
+                if item.total > 0:
+                    iteration_count = item.total // self.BATCH_SIZE_DM + (
+                        1 if item.total % self.BATCH_SIZE_DM > 0 else 0
+                    )
+                executor = ProducerWorkerExecutor[list[ResourceResponseProtocol], list[JsonVal]](
+                    download_iterable=self._iterate_batch(
+                        item.crud, space, data_set_external_id, batch_size=self.BATCH_SIZE_DM
+                    ),
+                    process=item.get_process_function(client, console, verbose, process_results),
+                    write=self._purge_batch(item, item.delete_url, delete_client, write_results),
+                    max_queue_size=10,
+                    iteration_count=iteration_count,
+                    download_description=f"Downloading {item.display_name}",
+                    process_description=f"Preparing {item.display_name} for deletion",
+                    write_description=f"Deleting {item.display_name}",
+                    console=console,
+                )
+                executor.run()
+                write_results += process_results
+                results[item.display_name] = write_results
+                if executor.error_occurred:
+                    if verbose and executor.error_traceback:
+                        executor.print_traceback()
+                    self.warn(
+                        HighSeverityWarning(f"Failed to delete all {item.display_name}. {executor.error_message}")
+                    )
+        return results
+
+    @staticmethod
+    def _iterate_batch(
+        crud: ResourceCRUD, selected_space: str | None, data_set_external_id: str | None, batch_size: int
+    ) -> Iterable[list[ResourceResponseProtocol]]:
+        batch: list[ResourceResponseProtocol] = []
+        for resource in crud.iterate(space=selected_space, data_set_external_id=data_set_external_id):
             batch.append(resource)
             if len(batch) >= batch_size:
                 yield batch
-                batch = crud.list_cls([])
+                batch = []
         if batch:
             yield batch
 
     @staticmethod
     def _purge_batch(
-        crud: ResourceCRUD, delete_url: str, delete_client: HTTPClient, result: ResourceDeployResult
+        delete_item: ToDelete, delete_url: str, delete_client: HTTPClient, result: ResourceDeployResult
     ) -> Callable[[list[JsonVal]], None]:
+        crud = delete_item.crud
+
+        def as_id(item: JsonVal) -> Hashable:
+            try:
+                return crud.get_id(item)
+            except KeyError:
+                # Fallback to internal ID
+                return crud.get_internal_id(item)
+
         def process(items: list[JsonVal]) -> None:
             responses = delete_client.request_with_retries(
                 ItemsRequest(
                     endpoint_url=delete_url,
                     method="POST",
-                    items=items,
-                    as_id=crud.get_id,
+                    items=[DeleteItem(item=item, as_id_fun=as_id) for item in items],
+                    extra_body_fields=delete_item.get_extra_fields(),
                 )
             )
             for response in responses:
-                if isinstance(response, SuccessItem):
-                    result.deleted += 1
+                if isinstance(response, SuccessResponseItems):
+                    result.deleted += len(response.ids)
                 else:
-                    result.unchanged += 1
+                    result.unchanged += len(items)
 
         return process
 
-    @staticmethod
-    def _get_dependencies(
-        loader_cls: type[ResourceCRUD], exclude: set[type[ResourceCRUD]] | None = None
-    ) -> dict[type[ResourceCRUD], frozenset[type[ResourceCRUD]]]:
-        return {
-            dep_cls: dep_cls.dependencies
-            for dep_cls in RESOURCE_CRUD_LIST
-            if loader_cls in dep_cls.dependencies and (exclude is None or dep_cls not in exclude)
-        }
-
-    @staticmethod
-    def _get_selected_space(space: str | None, client: ToolkitClient) -> str:
-        if space is None:
-            spaces = client.data_modeling.spaces.list(limit=-1, include_global=False)
-            selected_space = questionary.select(
-                "Which space do you want to purge"
-                " (including all data models, views, containers, nodes and edges within that space)?",
-                sorted([space.space for space in spaces]),
-            ).ask()
-        else:
-            retrieved = client.data_modeling.spaces.retrieve(space)
-            if retrieved is None:
-                raise ToolkitMissingResourceError(f"Space {space} does not exist")
-            selected_space = space
-
-        if selected_space is None:
-            raise ToolkitValueError("No space selected")
-        return selected_space
-
     def dataset(
         self,
         client: ToolkitClient,
-        external_id: str | None = None,
-        include_dataset: bool = False,
+        selected_data_set_external_id: str,
+        archive_dataset: bool = False,
+        include_data: bool = True,
+        include_configurations: bool = False,
+        asset_recursive: bool = False,
         dry_run: bool = False,
         auto_yes: bool = False,
         verbose: bool = False,
-    ) -> None:
-        """Purge a dataset and all its content"""
-        selected_dataset = self._get_selected_dataset(external_id, client)
-        if external_id is None:
-            # Interactive mode
-            include_dataset = questionary.confirm(
-                "Do you want to archive the dataset itself after the purge?", default=False
-            ).ask()
-            dry_run = questionary.confirm("Dry run?", default=True).ask()
+    ) -> DeployResults:
+        """Purge a dataset and all its content
+
+        Args:
+            client: The ToolkitClient to use
+            selected_data_set_external_id:  The external ID of the dataset to purge
+            archive_dataset:  Whether to archive the dataset itself after the purge
+            include_data: Whether to include data (assets, events, time series, files, sequences, 3D models, relationships, labels) in the purge
+            include_configurations: Whether to include configurations (workflows, transformations, extraction pipelines) in the purge
+            asset_recursive: Whether to recursively delete assets.
+            dry_run: Whether to perform a dry run
+            auto_yes:  Whether to automatically confirm the purge
+            verbose:  Whether to print verbose output
+
+        Returns:
+            DeployResults: The results of the purge operation
+
+        """
+        # Warning Messages
         if not dry_run:
-            self._print_panel("dataset", selected_dataset)
-            if not auto_yes:
-                confirm = questionary.confirm(
-                    f"Are you really sure you want to purge the {selected_dataset!r} dataset?", default=False
-                ).ask()
-                if not confirm:
-                    return
-
-        loaders = self._get_dependencies(
-            DataSetsCRUD,
-            exclude={
-                GroupCRUD,
-                GroupResourceScopedCRUD,
-                GroupAllScopedCRUD,
-                StreamlitCRUD,
-                HostedExtractorDestinationCRUD,
-                FunctionCRUD,
-                LocationFilterCRUD,
-            },
+            self._print_panel("dataSet", selected_data_set_external_id)
+        if not dry_run and not auto_yes:
+            confirm = questionary.confirm(
+                f"Are you really sure you want to purge the {selected_data_set_external_id!r} dataSet?", default=False
+            ).ask()
+            if not confirm:
+                return DeployResults([], "purge", dry_run=dry_run)
+
+        # Validate Auth
+        validator = ValidateAccess(client, "purge")
+        data_set_id = client.lookup.data_sets.id(selected_data_set_external_id)
+        if data_set_id is None:
+            raise ToolkitMissingResourceError(f"DataSet {selected_data_set_external_id!r} does not exist")
+        action = cast(Sequence[Literal["read", "write"]], ["read"] if dry_run else ["read", "write"])
+        if include_data:
+            # Check asset, events, time series, files, and sequences access, relationships, labels, 3D access.
+            validator.dataset_data(action, dataset_ids={data_set_id})
+        if include_configurations:
+            # Check workflow, transformations, extraction pipeline access
+            validator.dataset_configurations(action, dataset_ids={data_set_id})
+
+        to_delete: list[ToDelete] = self._create_to_delete_list_purge_dataset(
+            client,
+            include_data,
+            include_configurations,
+            selected_data_set_external_id,
+            asset_recursive,
         )
-        is_purged = self._purge(client, loaders, selected_data_set=selected_dataset, dry_run=dry_run, verbose=verbose)
-        if include_dataset and is_purged:
-            if dry_run:
-                print(f"Would have archived {selected_dataset}")
-            else:
-                archived = (
-                    DataSetUpdate(external_id=selected_dataset)
-                    .external_id.set(str(uuid.uuid4()))
-                    .metadata.add({"archived": "true"})
-                    .write_protected.set(True)
-                )
-                client.data_sets.update(archived)
-                print(f"DataSet {selected_dataset} archived")
-        elif include_dataset:
-            self.warn(
-                HighSeverityWarning(f"DataSet {selected_dataset} was not archived due to errors during the purge")
-            )
+        if dry_run:
+            results = DeployResults([], "purge", dry_run=True)
+            for item in to_delete:
+                results[item.display_name] = ResourceDeployResult(item.display_name, deleted=item.total)
+        else:
+            results = self._delete_resources(to_delete, client, verbose, None, selected_data_set_external_id)
+        print(results.counts_table(exclude_columns={"Created", "Changed", "Total"}))
+        if archive_dataset and not dry_run:
+            self._archive_dataset(client, selected_data_set_external_id)
+        return results
 
-        if not dry_run and is_purged:
-            print(f"Purged dataset {selected_dataset!r} completed")
-        elif not dry_run:
-            print(f"Purged dataset {selected_dataset!r} partly completed. See warnings for details.")
+    @staticmethod
+    def _archive_dataset(client: ToolkitClient, data_set: str) -> None:
+        archived = (
+            DataSetUpdate(external_id=data_set)
+            .external_id.set(str(uuid.uuid4()))
+            .metadata.add({"archived": "true"})
+            .write_protected.set(True)
+        )
+        client.data_sets.update(archived)
+        print(f"DataSet {data_set} archived")
 
-    def _print_panel(self, resource_type: str, resource: str) -> None:
+    @staticmethod
+    def _create_to_delete_list_purge_dataset(
+        client: ToolkitClient,
+        include_data: bool,
+        include_configurations: bool,
+        data_set_external_id: str,
+        asset_recursive: bool,
+    ) -> list[ToDelete]:
+        config = client.config
+        to_delete: list[ToDelete] = []
+
+        if include_data:
+            three_d_crud = ThreeDModelCRUD.create_loader(client)
+            to_delete.extend(
+                [
+                    ExternalIdToDelete(
+                        RelationshipCRUD.create_loader(client),
+                        RelationshipAggregator(client).count(data_set_external_id=data_set_external_id),
+                        config.create_api_url("/relationships/delete"),
+                    ),
+                    IdResourceToDelete(
+                        EventCRUD.create_loader(client),
+                        EventAggregator(client).count(data_set_external_id=data_set_external_id),
+                        config.create_api_url("/events/delete"),
+                    ),
+                    IdResourceToDelete(
+                        FileMetadataCRUD.create_loader(client),
+                        FileAggregator(client).count(data_set_external_id=data_set_external_id),
+                        config.create_api_url("/files/delete"),
+                    ),
+                    IdResourceToDelete(
+                        TimeSeriesCRUD.create_loader(client),
+                        TimeSeriesAggregator(client).count(data_set_external_id=data_set_external_id),
+                        config.create_api_url("/timeseries/delete"),
+                    ),
+                    IdResourceToDelete(
+                        SequenceCRUD.create_loader(client),
+                        SequenceAggregator(client).count(data_set_external_id=data_set_external_id),
+                        config.create_api_url("/sequences/delete"),
+                    ),
+                    IdResourceToDelete(
+                        three_d_crud,
+                        sum(1 for _ in three_d_crud.iterate(data_set_external_id=data_set_external_id)),
+                        config.create_api_url("/3d/models/delete"),
+                    ),
+                    AssetToDelete(
+                        AssetCRUD.create_loader(client),
+                        AssetAggregator(client).count(data_set_external_id=data_set_external_id),
+                        config.create_api_url("/assets/delete"),
+                        recursive=asset_recursive,
+                    ),
+                    ExternalIdToDelete(
+                        LabelCRUD.create_loader(client),
+                        LabelCountAggregator(client).count(data_set_external_id=data_set_external_id),
+                        config.create_api_url("/labels/delete"),
+                    ),
+                ]
+            )
+        if include_configurations:
+            transformation_crud = TransformationCRUD.create_loader(client)
+            workflow_crud = WorkflowCRUD.create_loader(client)
+            extraction_pipeline_crud = ExtractionPipelineCRUD.create_loader(client)
+
+            to_delete.extend(
+                [
+                    IdResourceToDelete(
+                        transformation_crud,
+                        sum(1 for _ in transformation_crud.iterate(data_set_external_id=data_set_external_id)),
+                        config.create_api_url("/transformations/delete"),
+                    ),
+                    ExternalIdToDelete(
+                        workflow_crud,
+                        sum(1 for _ in workflow_crud.iterate(data_set_external_id=data_set_external_id)),
+                        config.create_api_url("/workflows/delete"),
+                    ),
+                    IdResourceToDelete(
+                        extraction_pipeline_crud,
+                        sum(1 for _ in extraction_pipeline_crud.iterate(data_set_external_id=data_set_external_id)),
+                        config.create_api_url("/extpipes/delete"),
+                    ),
+                ]
+            )
+        return to_delete
+
+    @staticmethod
+    def _print_panel(resource_type: str, resource: str) -> None:
         print(
             Panel(
                 f"[red]WARNING:[/red] This operation [bold]cannot be undone[/bold]! "
@@ -360,387 +566,6 @@ class PurgeCommand(ToolkitCommand):
             )
         )
 
-    @staticmethod
-    def _get_selected_dataset(external_id: str | None, client: ToolkitClient) -> str:
-        if external_id is None:
-            datasets = client.data_sets.list(limit=-1)
-            selected_dataset: str = questionary.select(
-                "Which space are you going to purge (delete all resources in dataset)?",
-                sorted([dataset.external_id for dataset in datasets if dataset.external_id]),
-            ).ask()
-        else:
-            retrieved = client.data_sets.retrieve(external_id=external_id)
-            if retrieved is None:
-                raise ToolkitMissingResourceError(f"DataSet {external_id!r} does not exist")
-            selected_dataset = external_id
-
-        if selected_dataset is None:
-            raise ToolkitValueError("No space selected")
-        return selected_dataset
-
-    def _purge(
-        self,
-        client: ToolkitClient,
-        loaders: dict[type[ResourceCRUD], frozenset[type[ResourceCRUD]]],
-        selected_space: str | None = None,
-        selected_data_set: str | None = None,
-        dry_run: bool = False,
-        verbose: bool = False,
-        batch_size: int = 1000,
-    ) -> bool:
-        is_purged = True
-        results = DeployResults([], "purge", dry_run=dry_run)
-        loader_cls: type[ResourceCRUD]
-        has_purged_views = False
-        with Console().status("...", spinner="aesthetic", speed=0.4) as status:
-            for loader_cls in reversed(list(TopologicalSorter(loaders).static_order())):
-                if loader_cls not in loaders:
-                    # Dependency that is included
-                    continue
-                loader = loader_cls.create_loader(client, console=status.console)
-                status_prefix = "Would have deleted" if dry_run else "Deleted"
-                if isinstance(loader, ViewCRUD) and not dry_run:
-                    status_prefix = "Expected deleted"  # Views are not always deleted immediately
-                    has_purged_views = True
-
-                if not dry_run and isinstance(loader, NodeCRUD):
-                    # Special handling of nodes as node type must be deleted after regular nodes
-                    # In dry-run mode, we are not deleting the nodes, so we can skip this.
-                    warnings_before = len(self.warning_list)
-                    deleted_nodes = self._purge_nodes(loader, status, selected_space, verbose)
-                    results[loader.display_name] = ResourceDeployResult(
-                        name=loader.display_name,
-                        deleted=deleted_nodes,
-                        total=deleted_nodes,
-                    )
-                    if len(self.warning_list) > warnings_before and any(
-                        isinstance(warn, HighSeverityWarning) for warn in self.warning_list[warnings_before:]
-                    ):
-                        is_purged = False
-                    continue
-                elif not dry_run and isinstance(loader, AssetCRUD):
-                    # Special handling of assets as we must ensure all children are deleted before the parent.
-                    # In dry-run mode, we are not deleting the assets, so we can skip this.
-                    deleted_assets = self._purge_assets(loader, status, selected_data_set)
-                    results[loader.display_name] = ResourceDeployResult(
-                        loader.display_name, deleted=deleted_assets, total=deleted_assets
-                    )
-                    continue
-
-                # Child loaders are, for example, WorkflowTriggerLoader, WorkflowVersionLoader for WorkflowLoader
-                # These must delete all resources that are connected to the resource that the loader is deleting
-                # Exclude loaders that we are already iterating over
-                child_loader_classes = self._get_dependencies(loader_cls, exclude=set(loaders))
-                child_loaders = [
-                    child_loader.create_loader(client)
-                    for child_loader in reversed(list(TopologicalSorter(child_loader_classes).static_order()))
-                    # Necessary as the topological sort includes dependencies that are not in the loaders
-                    if child_loader in child_loader_classes
-                ]
-                count = 0
-                status.update(f"{status_prefix} {count:,} {loader.display_name}...")
-                batch_ids: list[Hashable] = []
-                for resource in loader.iterate(data_set_external_id=selected_data_set, space=selected_space):
-                    try:
-                        batch_ids.append(loader.get_id(resource))
-                    except (ToolkitRequiredValueError, KeyError) as e:
-                        try:
-                            batch_ids.append(loader.get_internal_id(resource))
-                        except (AttributeError, NotImplementedError):
-                            self.warn(
-                                HighSeverityWarning(
-                                    f"Cannot delete {type(resource).__name__}. Failed to obtain ID: {e}"
-                                ),
-                                console=status.console,
-                            )
-                            is_purged = False
-                            continue
-
-                    if len(batch_ids) >= batch_size:
-                        child_deletion = self._delete_children(
-                            batch_ids, child_loaders, dry_run, status.console, verbose
-                        )
-                        batch_delete, batch_size = self._delete_batch(
-                            batch_ids, dry_run, loader, batch_size, status.console, verbose
-                        )
-                        count += batch_delete
-                        status.update(f"{status_prefix} {count:,} {loader.display_name}...")
-                        batch_ids = []
-                        # The DeployResults is overloaded such that the below accumulates the counts
-                        for name, child_count in child_deletion.items():
-                            results[name] = ResourceDeployResult(name, deleted=child_count, total=child_count)
-
-                if batch_ids:
-                    child_deletion = self._delete_children(batch_ids, child_loaders, dry_run, status.console, verbose)
-                    batch_delete, batch_size = self._delete_batch(
-                        batch_ids, dry_run, loader, batch_size, status.console, verbose
-                    )
-                    count += batch_delete
-                    status.update(f"{status_prefix} {count:,} {loader.display_name}...")
-                    for name, child_count in child_deletion.items():
-                        results[name] = ResourceDeployResult(name, deleted=child_count, total=child_count)
-                if count > 0:
-                    status.console.print(f"{status_prefix} {count:,} {loader.display_name}.")
-                results[loader.display_name] = ResourceDeployResult(
-                    name=loader.display_name,
-                    deleted=count,
-                    total=count,
-                )
-        print(results.counts_table(exclude_columns={"Created", "Changed", "Untouched", "Total"}))
-        if has_purged_views:
-            print("You might need to run the purge command multiple times to delete all views.")
-        return is_purged
-
-    def _delete_batch(
-        self,
-        batch_ids: list[Hashable],
-        dry_run: bool,
-        loader: ResourceCRUD,
-        batch_size: int,
-        console: Console,
-        verbose: bool,
-    ) -> tuple[int, int]:
-        if dry_run:
-            deleted = len(batch_ids)
-        else:
-            try:
-                deleted = loader.delete(batch_ids)
-            except CogniteAPIError as delete_error:
-                if (
-                    delete_error.code == 408
-                    and "timed out" in delete_error.message.casefold()
-                    and batch_size > 1
-                    and (len(batch_ids) > 1)
-                ):
-                    self.warn(
-                        MediumSeverityWarning(
-                            f"Timed out deleting {loader.display_name}. Trying again with a smaller batch size."
-                        ),
-                        include_timestamp=True,
-                        console=console,
-                    )
-                    new_batch_size = len(batch_ids) // 2
-                    first = batch_ids[:new_batch_size]
-                    second = batch_ids[new_batch_size:]
-                    first_deleted, first_batch_size = self._delete_batch(
-                        first, dry_run, loader, new_batch_size, console, verbose
-                    )
-                    second_deleted, second_batch_size = self._delete_batch(
-                        second, dry_run, loader, new_batch_size, console, verbose
-                    )
-                    return first_deleted + second_deleted, min(first_batch_size, second_batch_size)
-                else:
-                    raise delete_error
-
-        if verbose:
-            prefix = "Would delete" if dry_run else "Finished purging"
-            console.print(f"{prefix} {deleted:,} {loader.display_name}")
-        return deleted, batch_size
-
-    @staticmethod
-    def _delete_children(
-        parent_ids: list[Hashable], child_loaders: list[ResourceCRUD], dry_run: bool, console: Console, verbose: bool
-    ) -> dict[str, int]:
-        child_deletion: dict[str, int] = {}
-        for child_loader in child_loaders:
-            child_ids = set()
-            for child in child_loader.iterate(parent_ids=parent_ids):
-                child_ids.add(child_loader.get_id(child))
-            count = 0
-            if child_ids:
-                if dry_run:
-                    count = len(child_ids)
-                else:
-                    count = child_loader.delete(list(child_ids))
-
-                if verbose:
-                    prefix = "Would delete" if dry_run else "Deleted"
-                    console.print(f"{prefix} {count:,} {child_loader.display_name}")
-            child_deletion[child_loader.display_name] = count
-        return child_deletion
-
-    def _purge_nodes(
-        self,
-        loader: NodeCRUD,
-        status: Status,
-        selected_space: str | None = None,
-        verbose: bool = False,
-        batch_size: int = 1000,
-    ) -> int:
-        """Special handling of nodes as we must ensure all node types are deleted last."""
-        # First find all Node Types
-        node_types: dict[NodeId, set[NodeId]] = {}
-        total_count = 0
-        for node in loader.iterate(space=selected_space):
-            if node.type and (selected_space is None or node.space == selected_space):
-                node_id = NodeId(node.type.space, node.type.external_id)
-                node_types[node_id] = set()
-            total_count += 1
-            status.update(f"Looking up node.type {total_count:,}...")
-
-        count = 0
-        batch_ids: list[NodeId] = []
-        for node in loader.iterate(space=selected_space):
-            node_id = node.as_id()
-            if node_id in node_types:
-                # Skip if it is a node type
-                continue
-            batch_ids.append(node_id)
-            if len(batch_ids) >= batch_size:
-                deleted, batch_size = self._delete_node_batch(batch_ids, loader, batch_size, status.console, verbose)
-                count += deleted
-                status.update(f"Deleted {count:,}/{total_count} {loader.display_name}...")
-                batch_ids = []
-
-        if batch_ids:
-            deleted, batch_size = self._delete_node_batch(batch_ids, loader, batch_size, status.console, verbose)
-            count += deleted
-
-        # Finally delete all node types, first do a lookup and topological sort to ensure deleting in the right order.
-        # Note this is an edge case, and is a result of some strange usage. But we need to handle it.
-        for node_type in loader.retrieve(list(node_types.keys())):
-            if node_type.type:
-                required = NodeId(node_type.type.space, node_type.type.external_id)
-                if required in node_types:
-                    node_types[required].add(node_type.as_id())
-
-        try:
-            node_type_ids = list(TopologicalSorter(node_types).static_order())
-        except CycleError as e:
-            self.warn(
-                HighSeverityWarning(f"Failed to delete node-types: Cycle detected. {e.args}"), console=status.console
-            )
-            return count
-
-        deleted, batch_size = self._delete_node_batch(node_type_ids, loader, batch_size, status.console, verbose)
-        count += deleted
-        if count > 0:
-            status.console.print(f"Finished purging {loader.display_name}.")
-        return count
-
-    def _delete_node_batch(
-        self, batch_ids: list[NodeId], loader: NodeCRUD, batch_size: int, console: Console, verbose: bool
-    ) -> tuple[int, int]:
-        try:
-            deleted = loader.delete(batch_ids)
-        except CogniteAPIError as delete_error:
-            if (
-                delete_error.code == 400
-                and "Attempted to delete a node which is used as a type" in delete_error.message
-            ):
-                # Fallback to delete one by one
-                deleted = 0
-                for node_id in batch_ids:
-                    try:
-                        loader.delete([node_id])
-                        deleted += 1
-                    except CogniteAPIError:
-                        is_type = filters.Equals(["node", "type"], node_id.dump(include_instance_type=False))
-                        instance_spaces = {node.space for node in loader.client.data_modeling.instances(filter=is_type)}
-                        if instance_spaces:
-                            suffix = (
-                                "It is used as a node type in the following spaces, "
-                                f"which must be purged first: {humanize_collection(instance_spaces)}"
-                            )
-                        else:
-                            suffix = "It is used as a node type, but failed to find the spaces where it is used."
-                        self.warn(HighSeverityWarning(f"Failed to delete {node_id!r}. {suffix}"), console=console)
-            elif (
-                delete_error.code == 408
-                and "timed out" in delete_error.message.casefold()
-                and batch_size > 1
-                and (len(batch_ids) > 1)
-            ):
-                self.warn(
-                    MediumSeverityWarning(
-                        f"Timed out deleting {loader.display_name}. Trying again with a smaller batch size."
-                    ),
-                    include_timestamp=True,
-                    console=console,
-                )
-                new_batch_size = len(batch_ids) // 2
-                first = batch_ids[:new_batch_size]
-                second = batch_ids[new_batch_size:]
-                first_deleted, first_batch_size = self._delete_node_batch(
-                    first, loader, new_batch_size, console, verbose
-                )
-                second_deleted, second_batch_size = self._delete_node_batch(
-                    second, loader, new_batch_size, console, verbose
-                )
-                return first_deleted + second_deleted, min(first_batch_size, second_batch_size)
-            else:
-                raise delete_error
-
-        if verbose:
-            console.print(f"Deleted {deleted:,} {loader.display_name}")
-        return deleted, batch_size
-
-    def _purge_assets(
-        self,
-        loader: AssetCRUD,
-        status: Status,
-        selected_data_set: str | None = None,
-        batch_size: int = 1000,
-    ) -> int:
-        # Using sets to avoid duplicates
-        children_ids: set[int] = set()
-        parent_ids: set[int] = set()
-        is_first = True
-        last_failed = False
-        count = level = depth = last_parent_count = 0
-        total_asset_count: int | None = None
-        # Iterate through the asset hierarchy once per depth level. This is to delete all children before the parent.
-        while is_first or level < depth:
-            for asset in loader.iterate(data_set_external_id=selected_data_set):
-                aggregates = cast(AggregateResultItem, asset.aggregates)
-                if is_first and aggregates.depth is not None:
-                    depth = max(depth, aggregates.depth)
-
-                if aggregates.child_count == 0:
-                    children_ids.add(asset.id)
-                else:
-                    parent_ids.add(asset.id)
-
-                if len(children_ids) >= batch_size:
-                    count += loader.delete(list(children_ids))
-                    if total_asset_count:
-                        status.update(f"Deleted {count:,}/{total_asset_count:,} {loader.display_name}...")
-                    else:
-                        status.update(f"Deleted {count:,} {loader.display_name}...")
-                    children_ids = set()
-
-            if is_first:
-                total_asset_count = count + len(parent_ids) + len(children_ids)
-            if children_ids:
-                count += loader.delete(list(children_ids))
-                status.update(f"Deleted {count:,}/{total_asset_count:,} {loader.display_name}...")
-                children_ids = set()
-
-            if len(parent_ids) == last_parent_count and last_failed:
-                try:
-                    # Just try to delete them all at once
-                    count += loader.delete(list(parent_ids))
-                except CogniteAPIError as e:
-                    raise CDFAPIError(
-                        f"Failed to delete {len(parent_ids)} assets. This could be due to a parent-child cycle or an "
-                        "eventual consistency issue. Wait a few seconds and try again. An alternative is to use the "
-                        "Python-SDK to delete the asset hierarchy "
-                        "`client.assets.delete(external_id='my_root_asset', recursive=True)`"
-                    ) from e
-                else:
-                    status.update(f"Deleted {count:,}/{total_asset_count:,} {loader.display_name}...")
-                    break
-            elif len(parent_ids) == last_parent_count:
-                last_failed = True
-            else:
-                last_failed = False
-            level += 1
-            last_parent_count = len(parent_ids)
-            parent_ids.clear()
-            is_first = False
-        status.console.print(f"Finished purging {loader.display_name}.")
-        return count
-
     def instances(
         self,
         client: ToolkitClient,
@@ -889,21 +714,21 @@ class PurgeCommand(ToolkitCommand):
             results.deleted += len(items)
             return
 
-        responses: Sequence[ResponseMessage | FailedRequestMessage] = delete_client.request_with_retries(
+        responses = delete_client.request_with_retries(
             ItemsRequest(
                 delete_client.config.create_api_url("/models/instances/delete"),
                 method="POST",
-                # MyPy fails to understand that dict[str, JsonVal] is compatible with JsonVal
-                items=items,  # type: ignore[arg-type]
-                # The PySDK does not use the JsonVal type hint, but we know these are correct
-                as_id=InstanceId.load,  # type: ignore[arg-type]
+                # MyPy does not understand that InstanceId.load handles dict[str, JsonVal]
+                items=[DeleteItem(item=item, as_id_fun=InstanceId.load) for item in items],  # type: ignore[arg-type]
             )
         )
         for response in responses:
-            if isinstance(response, SuccessItem):
-                results.deleted += 1
+            if isinstance(response, SuccessResponseItems):
+                results.deleted += len(response.ids)
+            elif isinstance(response, FailedResponseItems | FailedRequestItems):
+                results.failed += len(response.ids)
             else:
-                results.failed += 1
+                results.failed += len(items)
 
     @staticmethod
     def _unlink_timeseries(
@@ -940,10 +765,3 @@ class PurgeCommand(ToolkitCommand):
             elif verbose and files:
                 console.print(f"Would have unlinked {len(files)} files from their blob content.")
         return instances
-
-    @staticmethod
-    def get_selected_view_id(view: list[str]) -> ViewId:
-        if not (isinstance(view, list) and len(view) == 3):
-            raise ToolkitValueError(f"Invalid view format: {view}. Expected format is 'space externalId version'.")
-
-        return ViewId.load(tuple(view))  # type: ignore[arg-type]