cognite-toolkit 0.5.64__tar.gz → 0.5.65__tar.gz

{cognite_toolkit-0.5.64 → cognite_toolkit-0.5.65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.5.64
+Version: 0.5.65
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Project-URL: Homepage, https://docs.cognite.com/cdf/deploy/cdf_toolkit/
 Project-URL: Changelog, https://github.com/cognitedata/toolkit/releases

{cognite_toolkit-0.5.64 → cognite_toolkit-0.5.65}/cdf.toml

@@ -25,4 +25,4 @@ dump = true
 [modules]
 # This is the version of the modules. It should not be changed manually.
 # It will be updated by the 'cdf modules upgrade' command.
-version = "0.5.64"
+version = "0.5.65"

{cognite_toolkit-0.5.64 → cognite_toolkit-0.5.65}/cognite_toolkit/_builtin_modules/cdf.toml

@@ -4,7 +4,7 @@ default_env = "<DEFAULT_ENV_PLACEHOLDER>"
 [modules]
 # This is the version of the modules. It should not be changed manually.
 # It will be updated by the 'cdf modules upgrade' command.
-version = "0.5.64"
+version = "0.5.65"
 
 
 [plugins]

{cognite_toolkit-0.5.64 → cognite_toolkit-0.5.65}/cognite_toolkit/_cdf_tk/apps/_migrate_app.py

@@ -3,7 +3,7 @@ from typing import Annotated, Any
 
 import typer
 
-from cognite_toolkit._cdf_tk.commands import MigrateTimeseriesCommand, MigrationPrepareCommand
+from cognite_toolkit._cdf_tk.commands import MigrateAssetsCommand, MigrateTimeseriesCommand, MigrationPrepareCommand
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 
 
@@ -12,6 +12,8 @@ class MigrateApp(typer.Typer):
         super().__init__(*args, **kwargs)
         self.callback(invoke_without_command=True)(self.main)
         self.command("prepare")(self.prepare)
+        # Uncomment when command is ready.
+        # self.command("assets")(self.assets)
         self.command("timeseries")(self.timeseries)
 
     def main(self, ctx: typer.Context) -> None:
@@ -57,6 +59,48 @@ class MigrateApp(typer.Typer):
             )
         )
 
+    @staticmethod
+    def assets(
+        ctx: typer.Context,
+        mapping_file: Annotated[
+            Path,
+            typer.Option(
+                "--mapping-file",
+                "-m",
+                help="Path to the mapping file that contains the mapping from Assets to CogniteAssets. "
+                "This file is expected to have the following columns: [id/externalId, dataSetId, space, externalId]."
+                "The dataSetId is optional, and can be skipped. If it is set, it is used to check the access to the dataset.",
+            ),
+        ],
+        dry_run: Annotated[
+            bool,
+            typer.Option(
+                "--dry-run",
+                "-d",
+                help="If set, the migration will not be executed, but only a report of what would be done is printed.",
+            ),
+        ] = False,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """Migrate Assets to CogniteAssets."""
+        client = EnvironmentVariables.create_from_environment().get_client()
+        cmd = MigrateAssetsCommand()
+        cmd.run(
+            lambda: cmd.migrate_assets(
+                client,
+                mapping_file=mapping_file,
+                dry_run=dry_run,
+                verbose=verbose,
+            )
+        )
+
     @staticmethod
     def timeseries(
         ctx: typer.Context,

{cognite_toolkit-0.5.64 → cognite_toolkit-0.5.65}/cognite_toolkit/_cdf_tk/client/api/extended_timeseries.py

@@ -1,6 +1,7 @@
 from collections.abc import Sequence
-from typing import Any, overload
+from typing import Any, cast, overload
 
+from cognite.client import ClientConfig, CogniteClient
 from cognite.client._api.time_series import SortSpec, TimeSeriesAPI
 from cognite.client._constants import DEFAULT_LIMIT_READ
 from cognite.client.data_classes.data_modeling import NodeId
@@ -19,6 +20,11 @@ from cognite_toolkit._cdf_tk.client.data_classes.pending_instances_ids import Pe
 class ExtendedTimeSeriesAPI(TimeSeriesAPI):
     """Extended TimeSeriesAPI to include pending ID methods."""
 
+    def __init__(self, config: ClientConfig, api_version: str | None, cognite_client: CogniteClient) -> None:
+        super().__init__(config, api_version, cognite_client)
+        self._PENDING_IDS_LIMIT = 1000
+        self._UNLINK_LIMIT = 1000
+
     @overload
     def set_pending_ids(
         self, instance_id: NodeId | tuple[str, str], id: int | None = None, external_id: str | None = None
@@ -74,7 +80,7 @@ class ExtendedTimeSeriesAPI(TimeSeriesAPI):
                 },
                 "api_subversion": "alpha",
             }
-            for id_chunk in split_into_chunks(list(identifiers), 1000)
+            for id_chunk in split_into_chunks(list(identifiers), self._PENDING_IDS_LIMIT)
         ]
         tasks_summary = execute_tasks(
             self._post,
@@ -90,6 +96,68 @@ class ExtendedTimeSeriesAPI(TimeSeriesAPI):
 
         return ExtendedTimeSeriesList._load(retrieved_items, cognite_client=self._cognite_client)
 
+    @overload
+    def unlink_instance_ids(
+        self,
+        id: int | None = None,
+        external_id: str | None = None,
+    ) -> ExtendedTimeSeries | None: ...
+
+    @overload
+    def unlink_instance_ids(
+        self,
+        id: Sequence[int] | None = None,
+        external_id: SequenceNotStr[str] | None = None,
+    ) -> ExtendedTimeSeriesList: ...
+
+    def unlink_instance_ids(
+        self,
+        id: int | Sequence[int] | None = None,
+        external_id: str | SequenceNotStr[str] | None = None,
+    ) -> ExtendedTimeSeries | ExtendedTimeSeriesList | None:
+        """Unlink pending instance IDs from time series.
+
+        Args:
+            id (int | Sequence[int] | None): The ID(s) of the time series.
+            external_id (str | SequenceNotStr[str] | None): The external ID(s) of the time series.
+
+        """
+        if id is None and external_id is None:
+            return None
+        if isinstance(id, int) and isinstance(external_id, str):
+            raise ValueError("Cannot specify both id and external_id as single values. Use one or the other.")
+        is_single = isinstance(id, int) or isinstance(external_id, str)
+        identifiers = IdentifierSequence.load(id, external_id)
+
+        tasks = [
+            {
+                "url_path": f"{self._RESOURCE_PATH}/unlink-instance-ids",
+                "json": {"items": id_chunk},
+                "api_subversion": "alpha",
+            }
+            for id_chunk in split_into_chunks(identifiers.as_dicts(), self._UNLINK_LIMIT)
+        ]
+        tasks_summary = execute_tasks(
+            self._post,
+            tasks,
+            max_workers=self._config.max_workers,
+            fail_fast=True,
+        )
+        tasks_summary.raise_compound_exception_if_failed_tasks(
+            task_unwrap_fn=unpack_items_in_payload,
+        )
+
+        retrieved_items = tasks_summary.joined_results(lambda res: res.json()["items"])
+
+        result = ExtendedTimeSeriesList._load(retrieved_items, cognite_client=self._cognite_client)
+        if is_single:
+            if len(result) == 0:
+                return None
+            if len(result) > 1:
+                raise ValueError("Expected a single time series, but multiple were returned.")
+            return cast(ExtendedTimeSeries, result[0])
+        return cast(ExtendedTimeSeriesList, result)
+
     def retrieve(
         self, id: int | None = None, external_id: str | None = None, instance_id: NodeId | None = None
     ) -> ExtendedTimeSeries | None:

{cognite_toolkit-0.5.64 → cognite_toolkit-0.5.65}/cognite_toolkit/_cdf_tk/commands/__init__.py

@@ -1,4 +1,4 @@
-from ._migrate import MigrateTimeseriesCommand, MigrationPrepareCommand
+from ._migrate import MigrateAssetsCommand, MigrateTimeseriesCommand, MigrationPrepareCommand
 from ._populate import PopulateCommand
 from ._profile import ProfileAssetCentricCommand, ProfileTransformationCommand
 from ._purge import PurgeCommand
@@ -26,6 +26,7 @@ __all__ = [
     "DumpResourceCommand",
     "FeatureFlagCommand",
     "InitCommand",
+    "MigrateAssetsCommand",
     "MigrateTimeseriesCommand",
     "MigrationPrepareCommand",
     "ModulesCommand",

cognite_toolkit-0.5.65/cognite_toolkit/_cdf_tk/commands/_migrate/__init__.py

@@ -0,0 +1,5 @@
+from .assets import MigrateAssetsCommand
+from .prepare import MigrationPrepareCommand
+from .timeseries import MigrateTimeseriesCommand
+
+__all__ = ["MigrateAssetsCommand", "MigrateTimeseriesCommand", "MigrationPrepareCommand"]

cognite_toolkit-0.5.65/cognite_toolkit/_cdf_tk/commands/_migrate/assets.py

@@ -0,0 +1,201 @@
+from collections.abc import Callable, Iterable
+from pathlib import Path
+
+from cognite.client.data_classes import Asset, Label, LabelDefinition
+from cognite.client.data_classes.capabilities import (
+    Capability,
+    DataModelInstancesAcl,
+    DataModelsAcl,
+    DataSetScope,
+    SpaceIDScope,
+    TimeSeriesAcl,
+)
+from cognite.client.data_classes.data_modeling import NodeApply, NodeOrEdgeData, ViewId
+from cognite.client.exceptions import CogniteAPIError, CogniteException
+from rich import print
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client._constants import DATA_MODELING_MAX_WRITE_WORKERS
+from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
+from cognite_toolkit._cdf_tk.constants import DMS_INSTANCE_LIMIT_MARGIN
+from cognite_toolkit._cdf_tk.exceptions import (
+    AuthenticationError,
+    ResourceCreationError,
+    ResourceRetrievalError,
+    ToolkitMigrationError,
+    ToolkitValueError,
+)
+from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
+from cognite_toolkit._cdf_tk.utils import humanize_collection
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
+from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
+
+from .data_classes import MigrationMapping, MigrationMappingList
+from .data_model import MAPPING_VIEW_ID
+
+
+class MigrateAssetsCommand(ToolkitCommand):
+    cdf_cdm = "cdf_cdm"
+    asset_id = ViewId(cdf_cdm, "CogniteAsset", "v1")
+
+    # This is the number of timeseries that can be written in parallel.
+    chunk_size = 1000 * DATA_MODELING_MAX_WRITE_WORKERS
+
+    def migrate_assets(
+        self,
+        client: ToolkitClient,
+        mapping_file: Path,
+        dry_run: bool = False,
+        verbose: bool = False,
+    ) -> None:
+        """Migrate resources from Asset-Centric to data modeling in CDF."""
+        mappings = MigrationMappingList.read_mapping_file(mapping_file)
+        self._validate_access(client, mappings)
+        self._validate_migration_mappings_exists(client)
+        self._validate_available_capacity(client, mappings)
+        iteration_count = len(mappings) // self.chunk_size + 1
+        executor = ProducerWorkerExecutor[list[tuple[Asset, MigrationMapping]], list[NodeApply]](
+            download_iterable=self._download_assets(client, mappings),
+            process=self._as_cognite_assets,
+            write=self._upload_assets(client, dry_run=dry_run, verbose=verbose),
+            iteration_count=iteration_count,
+            max_queue_size=10,
+            download_description="Downloading assets",
+            process_description="Converting assets to CogniteAssets",
+            write_description="Uploading CogniteAssets",
+        )
+        executor.run()
+        if executor.error_occurred:
+            raise ResourceCreationError(executor.error_message)
+
+        prefix = "Would have" if dry_run else "Successfully"
+        self.console(f"{prefix} migrated {executor.total_items:,} assets to CogniteAssets.")
+
+    def _validate_access(self, client: ToolkitClient, mappings: MigrationMappingList) -> None:
+        required_capabilities: list[Capability] = [
+            DataModelsAcl(
+                actions=[DataModelsAcl.Action.Read], scope=SpaceIDScope([self.cdf_cdm, MAPPING_VIEW_ID.space])
+            ),
+            DataModelInstancesAcl(
+                actions=[
+                    DataModelInstancesAcl.Action.Read,
+                    DataModelInstancesAcl.Action.Write,
+                    DataModelInstancesAcl.Action.Write_Properties,
+                ],
+                scope=SpaceIDScope(list(mappings.spaces())),
+            ),
+        ]
+        if data_set_ids := mappings.get_data_set_ids():
+            required_capabilities.append(
+                TimeSeriesAcl(
+                    actions=[TimeSeriesAcl.Action.Read, TimeSeriesAcl.Action.Write],
+                    scope=DataSetScope(list(data_set_ids)),
+                )
+            )
+        if missing := client.iam.verify_capabilities(required_capabilities):
+            raise AuthenticationError(f"Missing required capabilities: {humanize_collection(missing)}.")
+
+    def _validate_migration_mappings_exists(self, client: ToolkitClient) -> None:
+        view = client.data_modeling.views.retrieve(MAPPING_VIEW_ID)
+        if not view:
+            raise ToolkitMigrationError(
+                f"The migration mapping view {MAPPING_VIEW_ID} does not exist. "
+                f"Please run the `cdf migrate prepare` command to deploy the migration data model."
+            )
+
+    def _validate_available_capacity(self, client: ToolkitClient, mappings: MigrationMappingList) -> None:
+        """Validate that the project has enough capacity to accommodate the migration."""
+        try:
+            stats = client.data_modeling.statistics.project()
+        except CogniteAPIError:
+            # This endpoint is not yet in alpha, it may change or not be available.
+            self.warn(HighSeverityWarning("Cannot check the instances capacity proceeding with migration anyway."))
+            return
+        available_capacity = stats.instances.instances_limit - stats.instances.instances
+        available_capacity_after = available_capacity - len(mappings)
+
+        if available_capacity_after < DMS_INSTANCE_LIMIT_MARGIN:
+            raise ToolkitValueError(
+                "Cannot proceed with migration, not enough instance capacity available. Total capacity after migration"
+                f"would be {available_capacity_after:,} instances, which is less than the required margin of"
+                f"{DMS_INSTANCE_LIMIT_MARGIN:,} instances. Please increase the instance capacity in your CDF project"
+                f" or delete some existing instances before proceeding with the migration of {len(mappings):,} assets."
+            )
+        total_instances = stats.instances.instances + len(mappings)
+        self.console(
+            f"Project has enough capacity for migration. Total instances after migration: {total_instances:,}."
+        )
+
+    def _download_assets(
+        self, client: ToolkitClient, mappings: MigrationMappingList
+    ) -> Iterable[list[tuple[Asset, MigrationMapping]]]:
+        for chunk in chunker_sequence(mappings, self.chunk_size):
+            try:
+                asset_list = client.assets.retrieve_multiple(
+                    chunk.get_ids(), chunk.get_external_ids(), ignore_unknown_ids=True
+                )
+            except CogniteException as e:
+                raise ResourceRetrievalError(f"Failed to retrieve {len(chunk):,} assets: {e!s}") from e
+            mapping_by_id = chunk.as_mapping_by_id()
+            chunk_list: list[tuple[Asset, MigrationMapping]] = []
+            for asset in asset_list:
+                if asset.id in mapping_by_id:
+                    chunk_list.append((asset, mapping_by_id[asset.id]))
+                elif asset.external_id in mapping_by_id:
+                    chunk_list.append((asset, mapping_by_id[asset.external_id]))
+            yield chunk_list
+
+    def _as_cognite_assets(self, assets: list[tuple[Asset, MigrationMapping]]) -> list[NodeApply]:
+        """Convert Asset objects to CogniteAssetApply objects."""
+        return [self.as_cognite_asset(asset, mapping) for asset, mapping in assets]
+
+    @classmethod
+    def _upload_assets(cls, client: ToolkitClient, dry_run: bool, verbose: bool) -> Callable[[list[NodeApply]], None]:
+        def upload_assets(assets: list[NodeApply]) -> None:
+            if dry_run:
+                if verbose:
+                    print(f"Would have created {len(assets):,} CogniteAssets.")
+                return
+            try:
+                created = client.data_modeling.instances.apply_fast(assets)
+            except CogniteException as e:
+                raise ResourceCreationError(f"Failed to upsert CogniteAssets {len(assets):,}: {e!s}") from e
+            if verbose:
+                print(f"Created {len(created):,} CogniteAssets.")
+
+        return upload_assets
+
+    @classmethod
+    def as_cognite_asset(cls, asset: Asset, mapping: MigrationMapping) -> NodeApply:
+        tags: list[str] = []
+        for label in asset.labels or []:
+            if isinstance(label, str):
+                tags.append(label)
+            elif isinstance(label, dict) and "externalId" in label:
+                tags.append(label["externalId"])
+            elif isinstance(label, Label | LabelDefinition) and label.external_id:
+                tags.append(label.external_id)
+
+        return NodeApply(
+            space=mapping.instance_id.space,
+            external_id=mapping.instance_id.external_id,
+            sources=[
+                NodeOrEdgeData(
+                    source=cls.asset_id,
+                    properties={
+                        "name": asset.name,
+                        "description": asset.description,
+                        "tags": tags or None,
+                    },
+                ),
+                NodeOrEdgeData(
+                    source=MAPPING_VIEW_ID,
+                    properties={
+                        "resourceType": "asset",
+                        "id": asset.id,
+                        "dataSetId": asset.data_set_id,
+                        "classicExternalId": asset.external_id,
+                    },
+                ),
+            ],
+        )

{cognite_toolkit-0.5.64 → cognite_toolkit-0.5.65}/cognite_toolkit/_cdf_tk/commands/_migrate/data_classes.py

@@ -1,5 +1,6 @@
 import csv
 import sys
+from abc import abstractmethod
 from collections.abc import Collection, Iterator, Sequence
 from dataclasses import dataclass
 from pathlib import Path
@@ -24,18 +25,28 @@ class MigrationMapping:
     resource_type: str
     instance_id: NodeId
 
+    @abstractmethod
+    def get_id(self) -> int | str:
+        raise NotImplementedError()
+
 
 @dataclass
 class IdMigrationMapping(MigrationMapping):
     id: int
     data_set_id: int | None = None
 
+    def get_id(self) -> int:
+        return self.id
+
 
 @dataclass
 class ExternalIdMigrationMapping(MigrationMapping):
     external_id: str
     data_set_id: int | None = None
 
+    def get_id(self) -> str:
+        return self.external_id
+
 
 class MigrationMappingList(list, Sequence[MigrationMapping]):
     # Implemented to get correct type hints
@@ -90,6 +101,10 @@ class MigrationMappingList(list, Sequence[MigrationMapping]):
             if isinstance(mapping, IdMigrationMapping | ExternalIdMigrationMapping) and mapping.data_set_id is not None
         }
 
+    def as_mapping_by_id(self) -> dict[int | str, MigrationMapping]:
+        """Return a mapping of IDs to MigrationMapping objects."""
+        return {mapping.get_id(): mapping for mapping in self}
+
     @classmethod
     def read_mapping_file(cls, mapping_file: Path) -> Self:
         if not mapping_file.exists():

{cognite_toolkit-0.5.64 → cognite_toolkit-0.5.65}/cognite_toolkit/_cdf_tk/commands/_migrate/data_model.py

@@ -66,6 +66,8 @@ MAPPING_VIEW = dm.ViewApply(
     },
 )
 
+MAPPING_VIEW_ID = MAPPING_VIEW.as_id()
+
 COGNITE_MIGRATION_MODEL = dm.DataModelApply(
     space=SPACE.space,
     external_id="CogniteMigration",

{cognite_toolkit-0.5.64 → cognite_toolkit-0.5.65}/cognite_toolkit/_cdf_tk/commands/_migrate/prepare.py

@@ -25,7 +25,7 @@ class MigrationPrepareCommand(ToolkitCommand):
         verb = "Would deploy" if dry_run else "Deploying"
         print(f"{verb} {MODEL_ID!r}")
         results = DeployResults([], "deploy", dry_run=dry_run)
-        for loader_cls, resources in [
+        for loader_cls, resource_list in [
             (SpaceLoader, [SPACE]),
             (ContainerLoader, [MAPPING_CONTAINER]),
             (ViewLoader, [MAPPING_VIEW]),
@@ -35,23 +35,15 @@ class MigrationPrepareCommand(ToolkitCommand):
             loader = loader_cls.create_loader(client)  # type: ignore[attr-defined]
             worker = ResourceWorker(loader)
             # MyPy does not understand that `loader` has a `get_id` method.
-            local_by_id = {loader.get_id(item): (item.dump(), item) for item in resources}  # type: ignore[attr-defined]
+            local_by_id = {loader.get_id(item): (item.dump(), item) for item in resource_list}  # type: ignore[attr-defined]
             worker.validate_access(local_by_id, is_dry_run=dry_run)
             cdf_resources = loader.retrieve(list(local_by_id.keys()))
-            to_create, to_update, to_delete, unchanged = worker.categorize_resources(
-                local_by_id, cdf_resources, False, verbose
-            )
+            resources = worker.categorize_resources(local_by_id, cdf_resources, False, verbose)
 
             if dry_run:
-                result = deploy_cmd.dry_run_deploy(to_create, to_update, to_delete, unchanged, loader, False, False)
+                result = deploy_cmd.dry_run_deploy(resources, loader, False, False)
             else:
-                result = deploy_cmd.actual_deploy(
-                    to_create,
-                    to_update,
-                    to_delete,
-                    unchanged,
-                    loader,
-                )
+                result = deploy_cmd.actual_deploy(resources, loader)
             if result:
                 results[result.name] = result
         if results.has_counts:

{cognite_toolkit-0.5.64 → cognite_toolkit-0.5.65}/cognite_toolkit/_cdf_tk/commands/deploy.py

@@ -45,6 +45,7 @@ from cognite_toolkit._cdf_tk.loaders import (
     ResourceWorker,
 )
 from cognite_toolkit._cdf_tk.loaders._base_loaders import T_WritableCogniteResourceList
+from cognite_toolkit._cdf_tk.loaders._worker import CategorizedResources
 from cognite_toolkit._cdf_tk.tk_warnings import EnvironmentVariableMissingWarning
 from cognite_toolkit._cdf_tk.tk_warnings.base import WarningList, catch_warnings
 from cognite_toolkit._cdf_tk.tk_warnings.other import (
@@ -261,7 +262,7 @@ class DeployCommand(ToolkitCommand):
             return None
 
         with catch_warnings(EnvironmentVariableMissingWarning) as env_var_warnings:
-            to_create, to_update, to_delete, unchanged = worker.prepare_resources(
+            resources = worker.prepare_resources(
                 files,
                 environment_variables=env_vars.dump(include_os=True),
                 is_dry_run=dry_run,
@@ -274,7 +275,7 @@ class DeployCommand(ToolkitCommand):
 
         # We are not counting to_delete as these are captured by to_create.
         # (to_delete is used for resources that does not support update and instead needs to be deleted and recreated)
-        nr_of_items = len(to_create) + len(to_update) + len(unchanged)
+        nr_of_items = len(resources.to_create) + len(resources.to_update) + len(resources.unchanged)
         if nr_of_items == 0:
             return ResourceDeployResult(name=loader.display_name)
 
@@ -288,19 +289,16 @@ class DeployCommand(ToolkitCommand):
 
         if dry_run:
             result = self.dry_run_deploy(
-                to_create,
-                to_update,
-                to_delete,
-                unchanged,
+                resources,
                 loader,
                 has_done_drop,
                 has_dropped_data,
             )
         else:
-            result = self.actual_deploy(to_create, to_update, to_delete, unchanged, loader, env_var_warnings)
+            result = self.actual_deploy(resources, loader, env_var_warnings)
 
         if verbose:
-            self._verbose_print(to_create, to_update, unchanged, loader, dry_run)
+            self._verbose_print(resources, loader, dry_run)
 
         if isinstance(loader, ResourceContainerLoader):
             return ResourceContainerDeployResult.from_resource_deploy_result(
@@ -311,10 +309,7 @@ class DeployCommand(ToolkitCommand):
 
     def actual_deploy(
         self,
-        to_create: T_CogniteResourceList,
-        to_update: T_CogniteResourceList,
-        to_delete: list[T_ID],
-        unchanged: T_CogniteResourceList,
+        resources: CategorizedResources[T_ID, T_CogniteResourceList],
         loader: ResourceLoader[
             T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
         ],
@@ -326,16 +321,16 @@ class DeployCommand(ToolkitCommand):
             if isinstance(warning, EnvironmentVariableMissingWarning)
             for identifier in warning.identifiers or []
         }
-        nr_of_unchanged = len(unchanged)
+        nr_of_unchanged = len(resources.unchanged)
         nr_of_deleted, nr_of_created, nr_of_changed = 0, 0, 0
-        if to_delete:
-            deleted = loader.delete(to_delete)
+        if resources.to_delete:
+            deleted = loader.delete(resources.to_delete)
             nr_of_deleted += deleted
-        if to_create:
-            created = self._create_resources(to_create, loader, environment_variable_warning_by_id)
+        if resources.to_create:
+            created = self._create_resources(resources.to_create, loader, environment_variable_warning_by_id)
             nr_of_created += created
-        if to_update:
-            updated = self._update_resources(to_update, loader, environment_variable_warning_by_id)
+        if resources.to_update:
+            updated = self._update_resources(resources.to_update, loader, environment_variable_warning_by_id)
             nr_of_changed += updated
         return ResourceDeployResult(
             name=loader.display_name,
@@ -348,10 +343,7 @@ class DeployCommand(ToolkitCommand):
 
     @staticmethod
     def dry_run_deploy(
-        to_create: T_CogniteResourceList,
-        to_update: T_CogniteResourceList,
-        to_delete: list[T_ID],
-        unchanged: T_CogniteResourceList,
+        resources: CategorizedResources[T_ID, T_CogniteResourceList],
         loader: ResourceLoader[
             T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
         ],
@@ -364,39 +356,40 @@ class DeployCommand(ToolkitCommand):
             and (not isinstance(loader, ResourceContainerLoader) or has_dropped_data)
         ):
             # Means the resources will be deleted and not left unchanged or changed
-            for item in unchanged:
+            for item in resources.unchanged:
                 # We cannot use extents as LoadableNodes cannot be extended.
-                to_create.append(item)
-            for item in to_update:
-                to_create.append(item)
-            unchanged.clear()
-            to_update.clear()
+                resources.to_create.append(item)
+            for item in resources.to_update:
+                resources.to_create.append(item)
+            resources.unchanged.clear()
+            resources.to_update.clear()
         return ResourceDeployResult(
             name=loader.display_name,
-            created=len(to_create),
-            deleted=len(to_delete),
-            changed=len(to_update),
-            unchanged=len(unchanged),
-            total=len(to_create) + len(to_delete) + len(to_update) + len(unchanged),
+            created=len(resources.to_create),
+            deleted=len(resources.to_delete),
+            changed=len(resources.to_update),
+            unchanged=len(resources.unchanged),
+            total=len(resources.to_create)
+            + len(resources.to_delete)
+            + len(resources.to_update)
+            + len(resources.unchanged),
         )
 
     @staticmethod
     def _verbose_print(
-        to_create: T_CogniteResourceList,
-        to_update: T_CogniteResourceList,
-        unchanged: T_CogniteResourceList,
+        resources: CategorizedResources[T_ID, T_CogniteResourceList],
         loader: ResourceLoader,
         dry_run: bool,
     ) -> None:
         print_outs = []
         prefix = "Would have " if dry_run else ""
-        if to_create:
-            print_outs.append(f"{prefix}Created {_print_ids_or_length(loader.get_ids(to_create), limit=20)}")
-        if to_update:
-            print_outs.append(f"{prefix}Updated {_print_ids_or_length(loader.get_ids(to_update), limit=20)}")
-        if unchanged:
+        if resources.to_create:
+            print_outs.append(f"{prefix}Created {_print_ids_or_length(loader.get_ids(resources.to_create), limit=20)}")
+        if resources.to_update:
+            print_outs.append(f"{prefix}Updated {_print_ids_or_length(loader.get_ids(resources.to_update), limit=20)}")
+        if resources.unchanged:
             print_outs.append(
-                f"{'Untouched' if dry_run else 'Unchanged'} {_print_ids_or_length(loader.get_ids(unchanged), limit=5)}"
+                f"{'Untouched' if dry_run else 'Unchanged'} {_print_ids_or_length(loader.get_ids(resources.unchanged), limit=5)}"
             )
         prefix_message = f" {loader.display_name}: "
         if len(print_outs) == 1: