cognite-toolkit 0.7.10__py3-none-any.whl → 0.7.12__py3-none-any.whl

cognite_toolkit/_cdf.py

@@ -36,6 +36,7 @@ from cognite_toolkit._cdf_tk.apps import (
 )
 from cognite_toolkit._cdf_tk.cdf_toml import CDFToml
 from cognite_toolkit._cdf_tk.commands import (
+    AboutCommand,
     CollectCommand,
 )
 from cognite_toolkit._cdf_tk.constants import HINT_LEAD_TEXT, URL, USE_SENTRY
@@ -115,6 +116,13 @@ _app.add_typer(ModulesApp(**default_typer_kws), name="modules")
 _app.command("init")(landing_app.main_init)
 
 
+@_app.command("about")
+def about() -> None:
+    """Display information about the Toolkit installation and configuration."""
+    cmd = AboutCommand()
+    cmd.run(lambda: cmd.execute(Path.cwd()))
+
+
 def app() -> NoReturn:
     # --- Main entry point ---
     # Users run 'app()' directly, but that doesn't allow us to control excepton handling:

cognite_toolkit/_cdf_tk/commands/__init__.py

@@ -6,13 +6,13 @@ from ._migrate import (
 from ._profile import ProfileAssetCentricCommand, ProfileAssetCommand, ProfileRawCommand, ProfileTransformationCommand
 from ._purge import PurgeCommand
 from ._upload import UploadCommand
+from .about import AboutCommand
 from .auth import AuthCommand
 from .build_cmd import BuildCommand
 from .clean import CleanCommand
 from .collect import CollectCommand
 from .deploy import DeployCommand
 from .dump_resource import DumpResourceCommand
-from .featureflag import FeatureFlagCommand
 from .init import InitCommand
 from .modules import ModulesCommand
 from .pull import PullCommand
@@ -21,6 +21,7 @@ from .resources import ResourcesCommand
 from .run import RunFunctionCommand, RunTransformationCommand, RunWorkflowCommand
 
 __all__ = [
+    "AboutCommand",
     "AuthCommand",
     "BuildCommand",
     "CleanCommand",
@@ -28,7 +29,6 @@ __all__ = [
     "DeployCommand",
     "DownloadCommand",
     "DumpResourceCommand",
-    "FeatureFlagCommand",
     "InitCommand",
     "MigrationCanvasCommand",
     "MigrationPrepareCommand",

cognite_toolkit/_cdf_tk/commands/_purge.py

@@ -7,12 +7,7 @@ from typing import Literal, cast
 
 import questionary
 from cognite.client.data_classes import DataSetUpdate
-from cognite.client.data_classes._base import CogniteResourceList
-from cognite.client.data_classes.data_modeling import (
-    EdgeList,
-    NodeId,
-    NodeList,
-)
+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
@@ -46,6 +41,7 @@ from cognite_toolkit._cdf_tk.exceptions import (
     AuthorizationError,
     ToolkitMissingResourceError,
 )
+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 (
@@ -107,7 +103,7 @@ class ToDelete(ABC):
     @abstractmethod
     def get_process_function(
         self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
-    ) -> Callable[[CogniteResourceList], list[JsonVal]]:
+    ) -> Callable[[list[ResourceResponseProtocol]], list[JsonVal]]:
         raise NotImplementedError()
 
     def get_extra_fields(self) -> dict[str, JsonVal]:
@@ -118,9 +114,10 @@ class ToDelete(ABC):
 class DataModelingToDelete(ToDelete):
     def get_process_function(
         self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
-    ) -> Callable[[CogniteResourceList], list[JsonVal]]:
-        def as_id(chunk: CogniteResourceList) -> list[JsonVal]:
-            return [item.as_id().dump(include_type=False) for item in chunk]
+    ) -> 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
 
@@ -129,11 +126,11 @@ class DataModelingToDelete(ToDelete):
 class EdgeToDelete(ToDelete):
     def get_process_function(
         self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
-    ) -> Callable[[CogniteResourceList], list[JsonVal]]:
-        def as_id(chunk: CogniteResourceList) -> list[JsonVal]:
+    ) -> 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(EdgeList, chunk)
+                for item in cast(list[Edge], chunk)
             ]
 
         return as_id
@@ -146,9 +143,10 @@ class NodesToDelete(ToDelete):
 
     def get_process_function(
         self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
-    ) -> Callable[[CogniteResourceList], list[JsonVal]]:
-        def check_for_data(chunk: CogniteResourceList) -> list[JsonVal]:
-            node_ids = cast(NodeList, chunk).as_ids()
+    ) -> 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)
@@ -164,8 +162,7 @@ class NodesToDelete(ToDelete):
                 dumped = node_id.dump(include_instance_type=True)
                 # The delete endpoint expects "instanceType" instead of "type"
                 dumped["instanceType"] = dumped.pop("type")
-                # MyPy think complains about invariant here, even though dict[str, str] is a type of JsonVal
-                result.append(dumped)  # type: ignore[arg-type]
+                result.append(dumped)
             return result
 
         return check_for_data
@@ -175,9 +172,10 @@ class NodesToDelete(ToDelete):
 class IdResourceToDelete(ToDelete):
     def get_process_function(
         self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
-    ) -> Callable[[CogniteResourceList], list[JsonVal]]:
-        def as_id(chunk: CogniteResourceList) -> list[JsonVal]:
-            return [{"id": item.id} for item in chunk]
+    ) -> 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
 
@@ -186,9 +184,10 @@ class IdResourceToDelete(ToDelete):
 class ExternalIdToDelete(ToDelete):
     def get_process_function(
         self, client: ToolkitClient, console: Console, verbose: bool, process_results: ResourceDeployResult
-    ) -> Callable[[CogniteResourceList], list[JsonVal]]:
-        def as_external_id(chunk: CogniteResourceList) -> list[JsonVal]:
-            return [{"externalId": item.external_id} for item in chunk]
+    ) -> 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
 
@@ -321,7 +320,7 @@ class PurgeCommand(ToolkitCommand):
                     iteration_count = item.total // self.BATCH_SIZE_DM + (
                         1 if item.total % self.BATCH_SIZE_DM > 0 else 0
                     )
-                executor = ProducerWorkerExecutor[CogniteResourceList, list[JsonVal]](
+                executor = ProducerWorkerExecutor[list[ResourceResponseProtocol], list[JsonVal]](
                     download_iterable=self._iterate_batch(
                         item.crud, space, data_set_external_id, batch_size=self.BATCH_SIZE_DM
                     ),
@@ -348,13 +347,13 @@ class PurgeCommand(ToolkitCommand):
     @staticmethod
     def _iterate_batch(
         crud: ResourceCRUD, selected_space: str | None, data_set_external_id: str | None, batch_size: int
-    ) -> Iterable[CogniteResourceList]:
-        batch = crud.list_cls([])
+    ) -> 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
 

cognite_toolkit/_cdf_tk/commands/_upload.py

@@ -215,6 +215,10 @@ class UploadCommand(ToolkitCommand):
                 reader = MultiFileReader(datafiles)
                 if reader.is_table and not isinstance(io, TableUploadableStorageIO):
                     raise ToolkitValueError(f"{selector.display_name} does not support {reader.format!r} files.")
+
+                chunk_count = io.count_chunks(reader)
+                iteration_count = chunk_count // io.CHUNK_SIZE + (1 if chunk_count % io.CHUNK_SIZE > 0 else 0)
+
                 tracker = ProgressTracker[str]([self._UPLOAD])
                 executor = ProducerWorkerExecutor[list[tuple[str, dict[str, JsonVal]]], Sequence[UploadItem]](
                     download_iterable=io.read_chunks(reader, selector),
@@ -230,7 +234,7 @@ class UploadCommand(ToolkitCommand):
                         tracker=tracker,
                         console=console,
                     ),
-                    iteration_count=None,
+                    iteration_count=iteration_count,
                     max_queue_size=self._MAX_QUEUE_SIZE,
                     download_description=f"Reading {selector.display_name!r} files",
                     process_description="Processing",

cognite_toolkit/_cdf_tk/commands/about.py

@@ -0,0 +1,221 @@
+import platform
+import sys
+from pathlib import Path
+
+from rich import print
+from rich.table import Table
+
+from cognite_toolkit._cdf_tk.cdf_toml import CDFToml, _read_toml
+from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
+from cognite_toolkit._cdf_tk.constants import clean_name
+from cognite_toolkit._cdf_tk.feature_flags import Flags
+from cognite_toolkit._cdf_tk.plugins import Plugins
+from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning, MediumSeverityWarning
+from cognite_toolkit._version import __version__
+
+
+class AboutCommand(ToolkitCommand):
+    def execute(self, cwd: Path) -> None:
+        # Version information
+        print(f"\n[bold cyan]Cognite Toolkit[/bold cyan] version: [yellow]{__version__}[/yellow]")
+        print(f"Python version: {sys.version.split()[0]}")
+        print(f"Platform: {platform.system()} {platform.release()}")
+
+        # Check for cdf.toml in the current directory
+        cdf_toml_path = cwd / CDFToml.file_name
+
+        if cdf_toml_path.exists():
+            print(f"\n[bold green]Configuration file found:[/bold green] {cdf_toml_path}")
+
+            cdf_toml = CDFToml.load(cwd)
+
+            # We need to read the raw TOML to get original key names for plugins and alpha flags
+            raw_toml = _read_toml(cdf_toml_path)
+
+            self._check_unrecognized_sections(raw_toml)
+            self._display_plugins(cdf_toml, raw_toml)
+            self._display_alpha_flags(cdf_toml, raw_toml)
+            self._display_additional_config(cdf_toml)
+
+        else:
+            # Search for cdf.toml in subdirectories
+            found_files = self._search_cdf_toml(cwd)
+
+            if found_files:
+                print(f"\n[bold yellow]No cdf.toml found in current directory:[/bold yellow] {cwd}")
+                print("\n[bold]Found cdf.toml files in subdirectories:[/bold]")
+                for file in found_files:
+                    rel_path = file.relative_to(cwd)
+                    print(f"  • {rel_path}")
+                print(f"\n[bold cyan]Hint:[/bold cyan] Move one of these files to {cwd} or navigate to its directory.")
+            else:
+                print("\n[bold yellow]No cdf.toml found[/bold yellow] in current directory or subdirectories.")
+                print(f"Current directory: {cwd}")
+                print("\n[bold cyan]Hint:[/bold cyan] Run [yellow]cdf init[/yellow] to create a new project.")
+
+    def _check_unrecognized_sections(self, raw_toml: dict) -> None:
+        """Check for unrecognized tables in cdf.toml and warn about them."""
+        # Valid top-level tables in cdf.toml
+        valid_tables = {"cdf", "modules", "alpha_flags", "feature_flags", "plugins", "library"}
+
+        # Filter out empty keys, whitespace-only keys, and check for unrecognized tables
+        unrecognized_tables = [key for key in raw_toml.keys() if key and key.strip() and key not in valid_tables]
+
+        if unrecognized_tables:
+            print()
+
+        for table in unrecognized_tables:
+            # Try to find a matching valid table by stripping non-alphabetical characters
+            suggestion = self._find_similar_table(table, valid_tables)
+
+            message = f"Table '{table}' in cdf.toml is not recognized and will have no effect."
+            if suggestion:
+                message += f" Did you mean '{suggestion}'?"
+
+            self.warn(MediumSeverityWarning(message))
+
+    @staticmethod
+    def _find_similar_table(unrecognized: str, valid_tables: set[str]) -> str | None:
+        """Find a similar valid table by comparing alphabetical characters only.
+
+        Returns None if the unrecognized table is already valid or if no similar match is found.
+        """
+        # If it's already a valid table, return None (no suggestion needed)
+        if unrecognized in valid_tables:
+            return None
+
+        # Keep only alphabetical characters and lowercase
+        normalized_unrecognized = "".join(c for c in unrecognized if c.isalpha()).lower()
+
+        # First, try exact match (after normalization)
+        for valid in valid_tables:
+            normalized_valid = "".join(c for c in valid if c.isalpha()).lower()
+            if normalized_unrecognized == normalized_valid:
+                return valid
+
+        # If no match, check for singular/plural variations (missing 's')
+        for valid in valid_tables:
+            normalized_valid = "".join(c for c in valid if c.isalpha()).lower()
+
+            # Check if adding 's' to unrecognized matches valid (e.g., "plugin" -> "plugins")
+            if normalized_unrecognized + "s" == normalized_valid:
+                return valid
+
+        return None
+
+    def _display_plugins(self, cdf_toml: CDFToml, raw_toml: dict) -> None:
+        """Display all available plugins and their status."""
+        table = Table(title="Plugins", show_header=True)
+        table.add_column("Plugin", justify="left", style="cyan")
+        table.add_column("Status", justify="center")
+        table.add_column("Description", justify="left")
+
+        # Track which plugins we've seen
+        seen_plugins = set()
+
+        # Show all plugins from the enum
+        for plugin in Plugins:
+            plugin_name = plugin.value.name
+            cleaned_key = clean_name(plugin_name)
+            seen_plugins.add(cleaned_key)
+
+            is_enabled = cdf_toml.plugins.get(cleaned_key, False)
+            if is_enabled:
+                status = "[green]✓ enabled[/green]"
+            else:
+                status = "[dim]○ disabled[/dim]"
+
+            table.add_row(plugin_name, status, plugin.value.description)
+
+        print()
+        print(table)
+
+        # Show any unrecognized plugins from cdf.toml using original key names
+        raw_plugins = raw_toml.get("plugins", {})
+        unrecognized = []
+        for original_key, value in raw_plugins.items():
+            cleaned_key = clean_name(original_key)
+            if cleaned_key not in seen_plugins:
+                unrecognized.append((original_key, value))
+
+        for original_key, is_enabled in unrecognized:
+            status = "enabled" if is_enabled else "disabled"
+            self.warn(
+                LowSeverityWarning(f"Plugin '{original_key}' in cdf.toml is not recognized and will have no effect.")
+            )
+
+    def _display_alpha_flags(self, cdf_toml: CDFToml, raw_toml: dict) -> None:
+        """Display available alpha flags and their status."""
+        table = Table(title="Alpha Flags", show_header=True)
+        table.add_column("Flag", justify="left", style="yellow")
+        table.add_column("Status", justify="center")
+        table.add_column("Description", justify="left")
+
+        # Track which flags we've seen
+        seen_flags = set()
+
+        # Show flags from the enum that are either enabled or visible
+        for flag in Flags:
+            cleaned_key = clean_name(flag.name)
+            seen_flags.add(cleaned_key)
+
+            is_enabled = cdf_toml.alpha_flags.get(cleaned_key, False)
+
+            # Only show if enabled or visible
+            if is_enabled or flag.value.visible:
+                # Convert enum name to kebab-case for display
+                display_name = flag.name.lower().replace("_", "-")
+
+                if is_enabled:
+                    status = "[green]✓ enabled[/green]"
+                else:
+                    status = "[dim]○ disabled[/dim]"
+
+                table.add_row(display_name, status, flag.value.description)
+
+        print()
+        print(table)
+
+        # Show any unrecognized flags from cdf.toml using original key names
+        raw_flags = raw_toml.get("alpha_flags", {})
+        unrecognized = []
+        for original_key, value in raw_flags.items():
+            cleaned_key = clean_name(original_key)
+            if cleaned_key not in seen_flags:
+                unrecognized.append((original_key, value))
+
+        for original_key, is_enabled in unrecognized:
+            status = "enabled" if is_enabled else "disabled"
+            self.warn(
+                LowSeverityWarning(
+                    f"Alpha flag '{original_key}' in cdf.toml is not recognized and will have no effect."
+                )
+            )
+
+    def _display_additional_config(self, cdf_toml: CDFToml) -> None:
+        """Display additional configuration information."""
+        print("\n[bold]Additional Configuration:[/bold]")
+
+        print(f"  Default environment: [cyan]{cdf_toml.cdf.default_env}[/cyan]")
+
+        if cdf_toml.cdf.has_user_set_default_org:
+            print(f"  Default organization dir: [cyan]{cdf_toml.cdf.default_organization_dir}[/cyan]")
+
+        if cdf_toml.cdf.file_encoding:
+            print(f"  File encoding: [cyan]{cdf_toml.cdf.file_encoding}[/cyan]")
+
+        print(f"  Modules version: [cyan]{cdf_toml.modules.version}[/cyan]")
+
+        if cdf_toml.libraries:
+            print(f"  Configured libraries: [cyan]{len(cdf_toml.libraries)}[/cyan]")
+            for lib_name, lib_config in cdf_toml.libraries.items():
+                print(f"    • {lib_name}: [dim]{lib_config.url}[/dim]")
+
+    def _search_cdf_toml(self, cwd: Path) -> list[Path]:
+        """Search for cdf.toml files in immediate subdirectories (one level down)."""
+        try:
+            return sorted(
+                [potential_file for potential_file in cwd.glob(f"*/{CDFToml.file_name}") if potential_file.is_file()]
+            )
+        except PermissionError:
+            return []

cognite_toolkit/_cdf_tk/commands/clean.py

@@ -1,4 +1,5 @@
 import traceback
+from collections.abc import Sequence
 from graphlib import TopologicalSorter
 from pathlib import Path
 
@@ -24,14 +25,7 @@ from cognite_toolkit._cdf_tk.cruds import (
     ResourceCRUD,
     ResourceWorker,
 )
-from cognite_toolkit._cdf_tk.cruds._base_cruds import (
-    T_ID,
-    Loader,
-    T_ResourceRequest,
-    T_ResourceRequestList,
-    T_ResourceResponse,
-    T_ResourceResponseList,
-)
+from cognite_toolkit._cdf_tk.cruds._base_cruds import Loader
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildEnvironment,
     DeployResults,
@@ -46,6 +40,7 @@ from cognite_toolkit._cdf_tk.exceptions import (
     ToolkitValidationError,
     ToolkitValueError,
 )
+from cognite_toolkit._cdf_tk.protocols import T_ResourceRequest, T_ResourceResponse
 from cognite_toolkit._cdf_tk.tk_warnings import (
     LowSeverityWarning,
     MediumSeverityWarning,
@@ -57,6 +52,7 @@ from cognite_toolkit._cdf_tk.utils import (
     read_yaml_file,
 )
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
+from cognite_toolkit._cdf_tk.utils.useful_types import T_ID
 
 from ._utils import _print_ids_or_length
 
@@ -66,9 +62,7 @@ AVAILABLE_DATA_TYPES: tuple[str, ...] = tuple(CRUDS_BY_FOLDER_NAME)
 class CleanCommand(ToolkitCommand):
     def clean_resources(
         self,
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         env_vars: EnvironmentVariables,
         read_modules: list[ReadModule],
         dry_run: bool = False,
@@ -139,7 +133,7 @@ class CleanCommand(ToolkitCommand):
             return ResourceDeployResult(name=loader.display_name)
 
     def _delete_resources(
-        self, loaded_resources: T_ResourceResponseList, loader: ResourceCRUD, dry_run: bool, verbose: bool
+        self, loaded_resources: Sequence[T_ResourceResponse], loader: ResourceCRUD, dry_run: bool, verbose: bool
     ) -> int:
         nr_of_deleted = 0
         resource_ids = loader.get_ids(loaded_resources)
@@ -164,7 +158,11 @@ class CleanCommand(ToolkitCommand):
         return nr_of_deleted
 
     def _drop_data(
-        self, loaded_resources: T_ResourceResponseList, loader: ResourceContainerCRUD, dry_run: bool, verbose: bool
+        self,
+        loaded_resources: Sequence[T_ResourceResponse],
+        loader: ResourceContainerCRUD,
+        dry_run: bool,
+        verbose: bool,
     ) -> int:
         nr_of_dropped = 0
         resource_ids = loader.get_ids(loaded_resources)

cognite_toolkit/_cdf_tk/commands/deploy.py

@@ -1,4 +1,4 @@
-from collections.abc import Hashable
+from collections.abc import Hashable, Sequence
 from graphlib import TopologicalSorter
 from pathlib import Path
 from typing import overload
@@ -46,9 +46,7 @@ from cognite_toolkit._cdf_tk.exceptions import (
 )
 from cognite_toolkit._cdf_tk.protocols import (
     T_ResourceRequest,
-    T_ResourceRequestList,
     T_ResourceResponse,
-    T_ResourceResponseList,
 )
 from cognite_toolkit._cdf_tk.tk_warnings import EnvironmentVariableMissingWarning
 from cognite_toolkit._cdf_tk.tk_warnings.base import WarningList, catch_warnings
@@ -338,9 +336,7 @@ class DeployCommand(ToolkitCommand):
 
     def deploy_resource_type(
         self,
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         env_vars: EnvironmentVariables,
         read_modules: list[ReadModule] | None = None,
         dry_run: bool = False,
@@ -402,10 +398,8 @@ class DeployCommand(ToolkitCommand):
 
     def actual_deploy(
         self,
-        resources: CategorizedResources[T_ID, T_ResourceResponseList],
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        resources: CategorizedResources[T_ID, T_ResourceRequest],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         env_var_warnings: WarningList | None = None,
     ) -> ResourceDeployResult:
         environment_variable_warning_by_id = {
@@ -436,10 +430,8 @@ class DeployCommand(ToolkitCommand):
 
     @staticmethod
     def dry_run_deploy(
-        resources: CategorizedResources[T_ID, T_ResourceResponseList],
-        loader: ResourceCRUD[
-            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
-        ],
+        resources: CategorizedResources[T_ID, T_ResourceRequest],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         has_done_drop: bool,
         has_dropped_data: bool,
     ) -> ResourceDeployResult:
@@ -470,7 +462,7 @@ class DeployCommand(ToolkitCommand):
 
     @staticmethod
     def _verbose_print(
-        resources: CategorizedResources[T_ID, T_ResourceResponseList],
+        resources: CategorizedResources[T_ID, T_ResourceRequest],
         loader: ResourceCRUD,
         dry_run: bool,
     ) -> None:
@@ -494,7 +486,7 @@ class DeployCommand(ToolkitCommand):
 
     def _create_resources(
         self,
-        resources: T_ResourceResponseList,
+        resources: Sequence[T_ResourceRequest],
         loader: ResourceCRUD,
         environment_variable_warning_by_id: dict[Hashable, EnvironmentVariableMissingWarning],
     ) -> int:
@@ -517,7 +509,7 @@ class DeployCommand(ToolkitCommand):
 
     def _update_resources(
         self,
-        resources: T_ResourceResponseList,
+        resources: Sequence[T_ResourceRequest],
         loader: ResourceCRUD,
         environment_variable_warning_by_id: dict[Hashable, EnvironmentVariableMissingWarning],
     ) -> int:

cognite_toolkit/_cdf_tk/commands/dump_resource.py

@@ -3,7 +3,7 @@ import json
 import zipfile
 from abc import ABC, abstractmethod
 from collections import defaultdict
-from collections.abc import Hashable, Iterable, Iterator
+from collections.abc import Hashable, Iterable, Iterator, Sequence
 from functools import cached_property
 from pathlib import Path
 from typing import Generic, cast
@@ -22,6 +22,7 @@ from cognite.client.data_classes import (
     filters,
 )
 from cognite.client.data_classes._base import (
+    CogniteResource,
     CogniteResourceList,
 )
 from cognite.client.data_classes.agents import (
@@ -113,7 +114,7 @@ class ResourceFinder(Iterable, ABC, Generic[T_ID]):
         raise NotImplementedError
 
     # Can be implemented in subclasses
-    def update(self, resources: CogniteResourceList) -> None: ...
+    def update(self, resources: Sequence[CogniteResource]) -> None: ...
 
 
 class DataModelFinder(ResourceFinder[DataModelId]):
@@ -178,7 +179,7 @@ class DataModelFinder(ResourceFinder[DataModelId]):
         self.data_model = models_by_version[selected_model]
         return self.data_model.as_id()
 
-    def update(self, resources: CogniteResourceList) -> None:
+    def update(self, resources: Sequence[CogniteResource]) -> None:
         if isinstance(resources, dm.DataModelList):
             self.view_ids |= {
                 view.as_id() if isinstance(view, dm.View) else view for item in resources for view in item.views
@@ -187,7 +188,7 @@ class DataModelFinder(ResourceFinder[DataModelId]):
             self.container_ids |= resources.referenced_containers()
         elif isinstance(resources, dm.SpaceList):
             return
-        self.space_ids |= {item.space for item in resources}
+        self.space_ids |= {item.space for item in resources if hasattr(item, "space")}
 
     def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
         self.identifier = self._selected()
@@ -804,6 +805,7 @@ class DumpResourceCommand(ToolkitCommand):
             output_dir.mkdir(exist_ok=True)
 
         dumped_ids: list[Hashable] = []
+        resources: Sequence[CogniteResource] | None = None
         for identifiers, resources, loader, subfolder in finder:
             if not identifiers and not resources:
                 # No resources to dump