cognite-toolkit 0.6.89__py3-none-any.whl → 0.6.91__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -3,6 +3,8 @@ from typing import cast
 from cognite.client import CogniteClient
 from rich.console import Console
 
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient
+
 from .api.canvas import CanvasAPI
 from .api.charts import ChartsAPI
 from .api.dml import DMLAPI
@@ -11,6 +13,7 @@ from .api.extended_files import ExtendedFileMetadataAPI
 from .api.extended_functions import ExtendedFunctionsAPI
 from .api.extended_raw import ExtendedRawAPI
 from .api.extended_timeseries import ExtendedTimeSeriesAPI
+from .api.infield import InfieldAPI
 from .api.lookup import LookUpGroup
 from .api.migration import MigrationAPI
 from .api.project import ProjectAPI
@@ -24,6 +27,7 @@ from .config import ToolkitClientConfig
 class ToolkitClient(CogniteClient):
     def __init__(self, config: ToolkitClientConfig | None = None, enable_set_pending_ids: bool = False) -> None:
         super().__init__(config=config)
+        http_client = HTTPClient(self.config)
         toolkit_config = ToolkitClientConfig.from_client_config(self.config)
         self.console = Console()
         self.search = SearchAPI(self._config, self._API_VERSION, self)
@@ -42,6 +46,7 @@ class ToolkitClient(CogniteClient):
         self.token = TokenAPI(self)
         self.charts = ChartsAPI(self._config, self._API_VERSION, self)
         self.project = ProjectAPI(config=toolkit_config, cognite_client=self)
+        self.infield = InfieldAPI(http_client, self.console)
 
     @property
     def config(self) -> ToolkitClientConfig:

cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -0,0 +1,156 @@
+from collections.abc import Sequence
+from typing import Any, cast
+
+from rich.console import Console
+
+from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse, QueryResponse
+from cognite_toolkit._cdf_tk.client.data_classes.infield import DataExplorationConfig, InfieldLocationConfig
+from cognite_toolkit._cdf_tk.client.data_classes.instance_api import (
+    InstanceResponseItem,
+    InstanceResult,
+    NodeIdentifier,
+)
+from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ItemsRequest, SimpleBodyRequest
+
+
+class InfieldConfigAPI:
+    ENDPOINT = "/models/instances"
+    LOCATION_REF = "locationConfig"
+    EXPLORATION_REF = "explorerConfig"
+    # We know that this key exists and it has alias set.
+    DATA_EXPLORATION_PROP_ID = cast(str, InfieldLocationConfig.model_fields["data_exploration_config"].alias)
+
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self._console = console
+        self._config = http_client.config
+
+    def apply(self, items: Sequence[InfieldLocationConfig]) -> list[InstanceResult]:
+        if len(items) > 500:
+            raise ValueError("Cannot apply more than 500 InfieldLocationConfig items at once.")
+
+        request_items = (
+            [item.as_request_item()]
+            if item.data_exploration_config is None
+            else [item.as_request_item(), item.data_exploration_config.as_request_item()]
+            for item in items
+        )
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=[item for sublist in request_items for item in sublist],
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[InstanceResult].model_validate(responses.get_first_body()).items
+
+    def retrieve(self, items: Sequence[NodeIdentifier]) -> list[InfieldLocationConfig]:
+        if len(items) > 100:
+            raise ValueError("Cannot retrieve more than 100 InfieldLocationConfig items at once.")
+        if not items:
+            return []
+        responses = self._http_client.request_with_retries(
+            SimpleBodyRequest(
+                # We use the query endpoint to be able to retrieve linked DataExplorationConfig items
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
+                method="POST",
+                body_content=self._retrieve_query(items),
+            )
+        )
+        responses.raise_for_status()
+        parsed_response = QueryResponse[InstanceResponseItem].model_validate(responses.get_first_body())
+        return self._parse_retrieve_response(parsed_response)
+
+    def delete(self, items: Sequence[InfieldLocationConfig]) -> list[NodeIdentifier]:
+        if len(items) > 500:
+            raise ValueError("Cannot delete more than 500 InfieldLocationConfig items at once.")
+
+        identifiers = (
+            [item.as_id()]
+            if item.data_exploration_config is None
+            else [item.as_id(), item.data_exploration_config.as_id()]
+            for item in items
+        )
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
+                method="POST",
+                items=[identifier for sublist in identifiers for identifier in sublist],
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[NodeIdentifier].model_validate(responses.get_first_body()).items
+
+    @classmethod
+    def _retrieve_query(cls, items: Sequence[NodeIdentifier]) -> dict[str, Any]:
+        return {
+            "with": {
+                cls.LOCATION_REF: {
+                    "limit": len(items),
+                    "nodes": {
+                        "filter": {
+                            "instanceReferences": [
+                                {"space": item.space, "externalId": item.external_id} for item in items
+                            ]
+                        },
+                    },
+                },
+                cls.EXPLORATION_REF: {
+                    "nodes": {
+                        "from": "locationConfig",
+                        "direction": "outwards",
+                        "through": {
+                            "source": InfieldLocationConfig.VIEW_ID.dump(),
+                            "identifier": cls.DATA_EXPLORATION_PROP_ID,
+                        },
+                    }
+                },
+            },
+            "select": {
+                cls.LOCATION_REF: {
+                    "sources": [{"source": InfieldLocationConfig.VIEW_ID.dump(), "properties": ["*"]}],
+                },
+                cls.EXPLORATION_REF: {
+                    "sources": [{"source": DataExplorationConfig.VIEW_ID.dump(), "properties": ["*"]}],
+                },
+            },
+        }
+
+    def _parse_retrieve_response(
+        self, parsed_response: QueryResponse[InstanceResponseItem]
+    ) -> list[InfieldLocationConfig]:
+        data_exploration_results = (
+            DataExplorationConfig.model_validate(
+                item.get_properties_for_source(DataExplorationConfig.VIEW_ID, include_identifier=True)
+            )
+            for item in parsed_response.items[self.EXPLORATION_REF]
+        )
+        data_exploration_config_map = {(dec.space, dec.external_id): dec for dec in data_exploration_results}
+        result: list[InfieldLocationConfig] = []
+        for item in parsed_response.items[self.LOCATION_REF]:
+            properties = item.get_properties_for_source(InfieldLocationConfig.VIEW_ID, include_identifier=True)
+            data_exploration = properties.pop(self.DATA_EXPLORATION_PROP_ID, None)
+            if isinstance(data_exploration, dict):
+                space = data_exploration["space"]
+                external_id = data_exploration["externalId"]
+                if (space, external_id) not in data_exploration_config_map:
+                    HighSeverityWarning(
+                        f"{self.DATA_EXPLORATION_PROP_ID} with space '{space}' and externalId '{external_id}' referenced in InfieldLocationConfig '{properties['externalId']}' was not found in the retrieved results."
+                    ).print_warning(console=self._console)
+                else:
+                    # Pydantic allow already validated models to be assigned to fields
+                    properties[self.DATA_EXPLORATION_PROP_ID] = data_exploration_config_map[(space, external_id)]  # type: ignore[assignment,index]
+            else:
+                HighSeverityWarning(
+                    f"InfieldLocationConfig '{properties['externalId']}' is missing a valid {self.DATA_EXPLORATION_PROP_ID} reference."
+                ).print_warning(console=self._console)
+            result.append(InfieldLocationConfig.model_validate(properties))
+        return result
+
+
+class InfieldAPI:
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self.config = InfieldConfigAPI(http_client, console)

cognite_toolkit/_cdf_tk/client/data_classes/api_classes.py

@@ -0,0 +1,17 @@
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel, Field, JsonValue
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class PagedResponse(BaseModel, Generic[T]):
+    items: list[T]
+    next_cursor: str | None = Field(None, alias="nextCursor")
+
+
+class QueryResponse(BaseModel, Generic[T]):
+    items: dict[str, list[T]]
+    typing: dict[str, JsonValue] | None = None
+    next_cursor: dict[str, str] = Field(alias="nextCursor")
+    debug: dict[str, JsonValue] | None = None

cognite_toolkit/_cdf_tk/client/data_classes/base.py

@@ -0,0 +1,63 @@
+import sys
+from abc import ABC, abstractmethod
+from typing import Any, Generic, TypeVar
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class BaseModelObject(BaseModel):
+    """Base class for all object. This includes resources and nested objects."""
+
+    # We allow extra fields to support forward compatibility.
+    model_config = ConfigDict(alias_generator=to_camel, extra="allow")
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
+
+        This is the default serialization method for request resources.
+        """
+        return self.model_dump(mode="json", by_alias=camel_case)
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any]) -> "Self":
+        """Load method to match CogniteResource signature."""
+        return cls.model_validate(resource)
+
+
+class RequestResource(BaseModelObject): ...
+
+
+T_RequestResource = TypeVar("T_RequestResource", bound=RequestResource)
+
+
+class ResponseResource(BaseModelObject, Generic[T_RequestResource], ABC):
+    @abstractmethod
+    def as_request_resource(self) -> T_RequestResource:
+        """Convert the response resource to a request resource."""
+        ...
+
+
+class Identifier(BaseModel):
+    """Base class for all identifier classes."""
+
+    model_config = ConfigDict(alias_generator=to_camel, extra="ignore", populate_by_name=True, frozen=True)
+
+    def dump(self, include_type: bool = True) -> dict[str, Any]:
+        """Dump the identifier to a dictionary.
+
+        Args:
+            include_type (bool): Whether to include the type of the identifier in the output.
+
+        Returns:
+            dict[str, Any]: The dumped identifier.
+        """
+        return self.model_dump(mode="json", by_alias=True, exclude_defaults=not include_type)
+
+    def as_id(self) -> Self:
+        return self

cognite_toolkit/_cdf_tk/client/data_classes/infield.py

@@ -0,0 +1,102 @@
+import sys
+from collections import UserList
+from typing import Any, ClassVar, Literal
+
+from cognite.client import CogniteClient
+from pydantic import JsonValue, field_validator
+from pydantic_core.core_schema import ValidationInfo
+
+from cognite_toolkit._cdf_tk.protocols import ResourceRequestListProtocol, ResourceResponseListProtocol
+from cognite_toolkit._cdf_tk.utils.text import sanitize_instance_external_id
+
+from .base import ResponseResource
+from .instance_api import InstanceRequestResource, ViewReference
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+INFIELD_LOCATION_CONFIG_VIEW_ID = ViewReference(space="cdf_infield", external_id="InFieldLocationConfig", version="v1")
+DATA_EXPLORATION_CONFIG_VIEW_ID = ViewReference(space="cdf_infield", external_id="DataExplorationConfig", version="v1")
+
+
+class DataExplorationConfig(InstanceRequestResource):
+    """Data Exploration Configuration resource class."""
+
+    VIEW_ID: ClassVar[ViewReference] = DATA_EXPLORATION_CONFIG_VIEW_ID
+    instance_type: Literal["node"] = "node"
+
+    observations: dict[str, JsonValue] | None = None
+    activities: dict[str, JsonValue] | None = None
+    documents: dict[str, JsonValue] | None = None
+    notifications: dict[str, JsonValue] | None = None
+    assets: dict[str, JsonValue] | None = None
+
+
+class InfieldLocationConfig(
+    ResponseResource["InfieldLocationConfig"],
+    InstanceRequestResource,
+):
+    """Infield Location Configuration resource class.
+
+    This class is used for both the response and request resource for Infield Location Configuration nodes.
+    """
+
+    VIEW_ID: ClassVar[ViewReference] = INFIELD_LOCATION_CONFIG_VIEW_ID
+    instance_type: Literal["node"] = "node"
+
+    root_location_external_id: str | None = None
+    feature_toggles: dict[str, JsonValue] | None = None
+    app_instance_space: str | None = None
+    access_management: dict[str, JsonValue] | None = None
+    data_filters: dict[str, JsonValue] | None = None
+    data_exploration_config: DataExplorationConfig | None = None
+
+    def as_request_resource(self) -> "InfieldLocationConfig":
+        return self
+
+    def as_write(self) -> Self:
+        return self
+
+    @field_validator("data_exploration_config", mode="before")
+    @classmethod
+    def generate_identifier_if_missing(cls, value: Any, info: ValidationInfo) -> Any:
+        """We do not require the user to specify the space and externalId for the data exploration config."""
+        if isinstance(value, dict):
+            if value.get("space") is None:
+                value["space"] = info.data["space"]
+            if value.get("externalId") is None:
+                external_id = info.data["external_id"]
+                candidate = f"{external_id}_data_exploration_config"
+                value["externalId"] = sanitize_instance_external_id(candidate)
+        return value
+
+
+class InfieldLocationConfigList(
+    UserList[InfieldLocationConfig],
+    ResourceResponseListProtocol,
+    ResourceRequestListProtocol,
+):
+    """A list of InfieldLocationConfig objects."""
+
+    _RESOURCE = InfieldLocationConfig
+    data: list[InfieldLocationConfig]
+
+    def __init__(self, initlist: list[InfieldLocationConfig] | None = None, **_: Any) -> None:
+        super().__init__(initlist or [])
+
+    def dump(self, camel_case: bool = True) -> list[dict[str, Any]]:
+        """Serialize the list of InfieldLocationConfig objects to a list of dictionaries."""
+        return [item.dump(camel_case) for item in self.data]
+
+    @classmethod
+    def load(
+        cls, data: list[dict[str, Any]], cognite_client: CogniteClient | None = None
+    ) -> "InfieldLocationConfigList":
+        """Deserialize a list of dictionaries to an InfieldLocationConfigList."""
+        items = [InfieldLocationConfig.model_validate(item) for item in data]
+        return cls(items)
+
+    def as_write(self) -> Self:
+        return self

cognite_toolkit/_cdf_tk/client/data_classes/instance_api.py

@@ -0,0 +1,157 @@
+from typing import Any, ClassVar, Literal, TypeAlias
+
+from pydantic import ConfigDict, JsonValue, model_serializer
+
+from .base import BaseModelObject, Identifier, RequestResource
+
+InstanceType: TypeAlias = Literal["node", "edge"]
+
+
+class InstanceIdentifier(Identifier):
+    """Identifier for an Instance instance."""
+
+    instance_type: InstanceType
+    space: str
+    external_id: str
+
+
+class NodeIdentifier(InstanceIdentifier):
+    instance_type: Literal["node"] = "node"
+
+
+class EdgeIdentifier(InstanceIdentifier):
+    instance_type: Literal["edge"] = "edge"
+
+
+class InstanceResult(BaseModelObject):
+    instance_type: InstanceType
+    version: int
+    was_modified: bool
+    space: str
+    external_id: str
+    created_time: int
+    last_updated_time: int
+
+    def as_id(self) -> InstanceIdentifier:
+        return InstanceIdentifier(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+        )
+
+
+class ViewReference(Identifier):
+    type: Literal["view"] = "view"
+    space: str
+    external_id: str
+    version: str
+
+
+######################################################
+# The classes below are helper classes for making instances request/responses.
+# By using these, we can avoid having to include the instances specific classes in the DTO classes
+# that are instance. Instead, these classes can now only have the properties they need to define.
+#######################################################
+
+
+class InstanceRequestResource(RequestResource):
+    """This is a base class for resources that are Instances."""
+
+    VIEW_ID: ClassVar[ViewReference]
+    instance_type: InstanceType
+    space: str
+    external_id: str
+
+    def as_id(self) -> InstanceIdentifier:
+        return InstanceIdentifier(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+        )
+
+    def as_request_item(self) -> "InstanceRequestItem":
+        return InstanceRequestItem(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+            sources=[InstanceSource(source=self.VIEW_ID, resource=self)],
+        )
+
+
+class InstanceSource(BaseModelObject):
+    source: ViewReference
+    resource: InstanceRequestResource
+
+    @model_serializer(mode="plain")
+    def serialize_resource(self) -> dict[str, Any]:
+        properties: dict[str, JsonValue] = {}
+        for field_id, field in type(self.resource).model_fields.items():
+            if field_id in InstanceRequestResource.model_fields:
+                # Skip space, external_id, instance_type
+                continue
+            key = field.alias or field_id
+            properties[key] = self._serialize_property(getattr(self.resource, field_id))
+
+        return {
+            "source": self.source.model_dump(by_alias=True),
+            "properties": properties,
+        }
+
+    @classmethod
+    def _serialize_property(cls, value: Any) -> JsonValue:
+        """Handles serialization of direct relations."""
+        if isinstance(value, InstanceRequestResource):
+            return {"space": value.space, "externalId": value.external_id}
+        elif isinstance(value, list):
+            return [cls._serialize_property(v) for v in value]
+        return value
+
+
+class InstanceRequestItem(BaseModelObject):
+    model_config = ConfigDict(populate_by_name=True)
+    instance_type: InstanceType
+    space: str
+    external_id: str
+    existing_version: int | None = None
+    sources: list[InstanceSource] | None = None
+
+    def as_id(self) -> InstanceIdentifier:
+        return InstanceIdentifier(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+        )
+
+
+class InstanceResponseItem(BaseModelObject):
+    instance_type: InstanceType
+    space: str
+    external_id: str
+    version: int
+    type: InstanceIdentifier | None = None
+    created_time: int
+    last_updated_time: int
+    deleted_time: int | None = None
+    properties: dict[str, dict[str, dict[str, JsonValue]]] | None = None
+
+    def get_properties_for_source(
+        self, source: ViewReference, include_identifier: bool = False
+    ) -> dict[str, JsonValue]:
+        output: dict[str, JsonValue] = (
+            {"space": self.space, "externalId": self.external_id} if include_identifier else {}
+        )
+        if not self.properties:
+            return output
+        if source.space not in self.properties:
+            return output
+        space_properties = self.properties[source.space]
+        view_version = f"{source.external_id}/{source.version}"
+        output.update(space_properties.get(view_version, {}))
+        return output
+
+    def as_id(self) -> InstanceIdentifier:
+        return InstanceIdentifier(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+        )

cognite_toolkit/_cdf_tk/client/testing.py

@@ -21,6 +21,7 @@ from .api.extended_files import ExtendedFileMetadataAPI
 from .api.extended_functions import ExtendedFunctionsAPI
 from .api.extended_raw import ExtendedRawAPI
 from .api.extended_timeseries import ExtendedTimeSeriesAPI
+from .api.infield import InfieldAPI, InfieldConfigAPI
 from .api.location_filters import LocationFiltersAPI
 from .api.lookup import (
     AssetLookUpAPI,
@@ -73,6 +74,8 @@ class ToolkitClientMock(CogniteClientMock):
         self.functions = MagicMock(spec=ExtendedFunctionsAPI)
         self.functions.calls = MagicMock(spec_set=FunctionCallsAPI)
         self.functions.schedules = MagicMock(spec_set=FunctionSchedulesAPI)
+        self.infield = MagicMock(spec=InfieldAPI)
+        self.infield.config = MagicMock(spec_set=InfieldConfigAPI)
 
         self.project = MagicMock(spec_set=ProjectAPI)
 

cognite_toolkit/_cdf_tk/commands/_utils.py

@@ -1,10 +1,6 @@
-from cognite.client.data_classes._base import T_CogniteResourceList, T_WritableCogniteResource, T_WriteClass
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.cruds import (
-    ResourceCRUD,
-)
-from cognite_toolkit._cdf_tk.cruds._base_cruds import T_ID, T_WritableCogniteResourceList
+from cognite_toolkit._cdf_tk.cruds._base_cruds import T_ID
 
 
 def _print_ids_or_length(resource_ids: SequenceNotStr[T_ID], limit: int = 10) -> str:
@@ -14,22 +10,3 @@ def _print_ids_or_length(resource_ids: SequenceNotStr[T_ID], limit: int = 10) ->
         return f"{resource_ids}"
     else:
         return f"{len(resource_ids)} items"
-
-
-def _remove_duplicates(
-    loaded_resources: T_CogniteResourceList,
-    loader: ResourceCRUD[
-        T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
-    ],
-) -> tuple[T_CogniteResourceList, list[T_ID]]:
-    seen: set[T_ID] = set()
-    output = loader.list_write_cls([])
-    duplicates: list[T_ID] = []
-    for item in loaded_resources:
-        identifier = loader.get_id(item)
-        if identifier not in seen:
-            output.append(item)
-            seen.add(identifier)
-        else:
-            duplicates.append(identifier)
-    return output, duplicates

cognite_toolkit/_cdf_tk/commands/build_cmd.py

@@ -492,7 +492,7 @@ class BuildCommand(ToolkitCommand):
             # which is what we do in the deploy step to verify that the source file has not changed.
             source = SourceLocationEager(source_path, calculate_hash(source_path, shorten=True))
 
-            content = variables.replace(content, source_path.suffix)
+            content = variables.replace(content, source_path)
 
             replace_warnings = self._check_variables_replaced(content, module_dir, source_path)
 

cognite_toolkit/_cdf_tk/commands/clean.py

@@ -2,7 +2,6 @@ import traceback
 from graphlib import TopologicalSorter
 from pathlib import Path
 
-from cognite.client.data_classes._base import T_CogniteResourceList, T_WritableCogniteResource, T_WriteClass
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich import print
@@ -24,7 +23,14 @@ from cognite_toolkit._cdf_tk.cruds import (
     ResourceCRUD,
     ResourceWorker,
 )
-from cognite_toolkit._cdf_tk.cruds._base_cruds import T_ID, Loader, T_WritableCogniteResourceList
+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.data_classes import (
     BuildEnvironment,
     DeployResults,
@@ -58,7 +64,7 @@ class CleanCommand(ToolkitCommand):
     def clean_resources(
         self,
         loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
+            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
         ],
         env_vars: EnvironmentVariables,
         read_modules: list[ReadModule],
@@ -130,7 +136,7 @@ class CleanCommand(ToolkitCommand):
             return ResourceDeployResult(name=loader.display_name)
 
     def _delete_resources(
-        self, loaded_resources: T_CogniteResourceList, loader: ResourceCRUD, dry_run: bool, verbose: bool
+        self, loaded_resources: T_ResourceResponseList, loader: ResourceCRUD, dry_run: bool, verbose: bool
     ) -> int:
         nr_of_deleted = 0
         resource_ids = loader.get_ids(loaded_resources)
@@ -155,7 +161,7 @@ class CleanCommand(ToolkitCommand):
         return nr_of_deleted
 
     def _drop_data(
-        self, loaded_resources: T_CogniteResourceList, loader: ResourceContainerCRUD, dry_run: bool, verbose: bool
+        self, loaded_resources: T_ResourceResponseList, loader: ResourceContainerCRUD, dry_run: bool, verbose: bool
     ) -> int:
         nr_of_dropped = 0
         resource_ids = loader.get_ids(loaded_resources)