cognite-toolkit 0.7.70__py3-none-any.whl → 0.7.71__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/_resource_base.py

@@ -3,10 +3,8 @@
 import sys
 import types
 from abc import ABC, abstractmethod
-from collections import UserList
 from typing import Any, ClassVar, Generic, Literal, TypeVar, Union, get_args, get_origin
 
-from cognite.client import CogniteClient
 from pydantic import BaseModel, ConfigDict
 from pydantic.alias_generators import to_camel
 
@@ -165,23 +163,3 @@ class ResponseResource(BaseModelObject, Generic[T_RequestResource], ABC):
 
 
 T_ResponseResource = TypeVar("T_ResponseResource", bound=ResponseResource)
-
-# Todo: Delete this class and use list[T_Resource] directly
-T_Resource = TypeVar("T_Resource", bound=RequestResource | ResponseResource)
-
-
-class BaseResourceList(UserList[T_Resource]):
-    """Base class for resource lists."""
-
-    _RESOURCE: type[T_Resource]
-
-    def __init__(self, initlist: list[T_Resource] | None = None, **_: Any) -> None:
-        super().__init__(initlist or [])
-
-    def dump(self, camel_case: bool = True) -> list[dict[str, Any]]:
-        return [item.dump(camel_case) for item in self.data]
-
-    @classmethod
-    def load(cls, data: list[dict[str, Any]], cognite_client: "CogniteClient | None" = None) -> Self:
-        items = [cls._RESOURCE.model_validate(item) for item in data]
-        return cls(items)  # type: ignore[arg-type]

cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -1,102 +1,41 @@
 from collections.abc import Sequence
-from typing import Any, cast
+from typing import Any
 
-from pydantic import TypeAdapter
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk.client.cdf_client.responses import QueryResponse
+from cognite_toolkit._cdf_tk.client.api.instances import MultiWrappedInstancesAPI, WrappedInstancesAPI
+from cognite_toolkit._cdf_tk.client.cdf_client import PagedResponse, QueryResponse, ResponseItems
 from cognite_toolkit._cdf_tk.client.http_client import (
     HTTPClient,
-    ItemsRequest,
-    RequestMessage,
+    ItemsSuccessResponse,
+    SuccessResponse,
 )
 from cognite_toolkit._cdf_tk.client.resource_classes.infield import (
     DataExplorationConfig,
-    InFieldCDMLocationConfig,
-    InfieldLocationConfig,
+    InFieldCDMLocationConfigRequest,
+    InFieldCDMLocationConfigResponse,
+    InFieldLocationConfig,
+    InFieldLocationConfigRequest,
+    InFieldLocationConfigResponse,
 )
 from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import (
-    InstanceResponseItem,
-    InstanceResult,
+    TypedInstanceIdentifier,
     TypedNodeIdentifier,
 )
-from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
 
 
-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)
+class InfieldConfigAPI(MultiWrappedInstancesAPI[InFieldLocationConfigRequest, InFieldLocationConfigResponse]):
+    _LOCATION_REF = "locationConfig"
+    _EXPLORATION_REF = "dataExplorationConfig"
 
-    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_items_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 TypeAdapter(list[InstanceResult]).validate_python(responses.get_items())
-
-    def retrieve(self, items: Sequence[TypedNodeIdentifier]) -> list[InfieldLocationConfig]:
-        if len(items) > 100:
-            raise ValueError("Cannot retrieve more than 100 InfieldLocationConfig items at once.")
-        if not items:
-            return []
-        response = self._http_client.request_single_retries(
-            RequestMessage(
-                # 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),
-            )
-        )
-        success = response.get_success_or_raise()
-        parsed_response = QueryResponse[InstanceResponseItem].model_validate(success.body_json)
-        return self._parse_retrieve_response(parsed_response)
-
-    def delete(self, items: Sequence[InfieldLocationConfig]) -> list[TypedNodeIdentifier]:
-        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_items_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 TypeAdapter(list[TypedNodeIdentifier]).validate_python(responses.get_items())
+    def __init__(self, http_client: HTTPClient) -> None:
+        # 500 is chosen as 1000 is the maximum for nodes, and each location config consists of 1 or 2 nodes
+        super().__init__(http_client, query_chunk=500)
 
-    @classmethod
-    def _retrieve_query(cls, items: Sequence[TypedNodeIdentifier]) -> dict[str, Any]:
+    def _retrieve_query(self, items: Sequence[TypedInstanceIdentifier]) -> dict[str, Any]:
         return {
             "with": {
-                cls.LOCATION_REF: {
+                self._LOCATION_REF: {
                     "limit": len(items),
                     "nodes": {
                         "filter": {
@@ -106,148 +45,61 @@ class InfieldConfigAPI:
                         },
                     },
                 },
-                cls.EXPLORATION_REF: {
+                self._EXPLORATION_REF: {
                     "nodes": {
                         "from": "locationConfig",
                         "direction": "outwards",
                         "through": {
-                            "source": InfieldLocationConfig.VIEW_ID.dump(),
-                            "identifier": cls.DATA_EXPLORATION_PROP_ID,
+                            "source": InFieldLocationConfig.VIEW_ID.dump(),
+                            "identifier": "dataExplorationConfig",
                         },
                     }
                 },
             },
             "select": {
-                cls.LOCATION_REF: {
-                    "sources": [{"source": InfieldLocationConfig.VIEW_ID.dump(), "properties": ["*"]}],
+                self._LOCATION_REF: {
+                    "sources": [{"source": InFieldLocationConfig.VIEW_ID.dump(), "properties": ["*"]}],
                 },
-                cls.EXPLORATION_REF: {
+                self._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 InFieldCDMConfigAPI:
-    ENDPOINT = "/models/instances"
-    LOCATION_REF = "cdmLocationConfig"
-
-    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[InFieldCDMLocationConfig]) -> list[InstanceResult]:
-        if len(items) > 500:
-            raise ValueError("Cannot apply more than 500 InFieldCDMLocationConfig items at once.")
-
-        request_items = [item.as_request_item() for item in items]
-        results = self._http_client.request_items_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="POST",
-                items=request_items,
-            )
-        )
-        results.raise_for_status()
-        return TypeAdapter(list[InstanceResult]).validate_python(results.get_items())
-
-    def retrieve(self, items: Sequence[TypedNodeIdentifier]) -> list[InFieldCDMLocationConfig]:
-        if len(items) > 100:
-            raise ValueError("Cannot retrieve more than 100 InFieldCDMLocationConfig items at once.")
-        if not items:
-            return []
-        result = self._http_client.request_single_retries(
-            RequestMessage(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
-                method="POST",
-                body_content=self._retrieve_query(items),
-            )
+    def _validate_query_response(self, query_response: QueryResponse) -> list[InFieldLocationConfigResponse]:
+        exploration_config_results = (
+            DataExplorationConfig.model_validate(item) for item in query_response.items.get(self._EXPLORATION_REF, [])
         )
-        success = result.get_success_or_raise()
-        parsed_response = QueryResponse[InstanceResponseItem].model_validate(success.body_json)
-        return self._parse_retrieve_response(parsed_response)
-
-    def delete(self, items: Sequence[InFieldCDMLocationConfig]) -> list[TypedNodeIdentifier]:
-        if len(items) > 500:
-            raise ValueError("Cannot delete more than 500 InFieldCDMLocationConfig items at once.")
-
-        identifiers = [item.as_id() for item in items]
-        responses = self._http_client.request_items_retries(
-            ItemsRequest(
-                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
-                method="POST",
-                items=identifiers,
-            )
-        )
-        responses.raise_for_status()
-        return TypeAdapter(list[TypedNodeIdentifier]).validate_python(responses.get_items())
-
-    @classmethod
-    def _retrieve_query(cls, items: Sequence[TypedNodeIdentifier]) -> 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
-                            ]
-                        },
-                    },
-                },
-            },
-            "select": {
-                cls.LOCATION_REF: {
-                    "sources": [{"source": InFieldCDMLocationConfig.VIEW_ID.dump(), "properties": ["*"]}],
-                },
-            },
-        }
-
-    def _parse_retrieve_response(
-        self, parsed_response: QueryResponse[InstanceResponseItem]
-    ) -> list[InFieldCDMLocationConfig]:
-        result: list[InFieldCDMLocationConfig] = []
-        for item in parsed_response.items[self.LOCATION_REF]:
-            properties = item.get_properties_for_source(InFieldCDMLocationConfig.VIEW_ID, include_identifier=True)
-            result.append(InFieldCDMLocationConfig.model_validate(properties))
-        return result
+        exploration_config_map = {(item.space, item.external_id): item for item in exploration_config_results}
+        results: list[InFieldLocationConfigResponse] = []
+        for item in query_response.items.get(self._LOCATION_REF, []):
+            location_config = InFieldLocationConfigResponse.model_validate(item)
+            exploration_config = location_config.data_exploration_config
+            if exploration_config is not None:
+                location_config.data_exploration_config = exploration_config_map.get(
+                    (exploration_config.space, exploration_config.external_id), exploration_config
+                )
+            results.append(location_config)
+        return results
+
+
+class InFieldCDMConfigAPI(
+    WrappedInstancesAPI[TypedNodeIdentifier, InFieldCDMLocationConfigRequest, InFieldCDMLocationConfigResponse]
+):
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(http_client, InFieldCDMLocationConfigRequest.VIEW_ID)
+
+    def _validate_response(self, response: SuccessResponse) -> ResponseItems[TypedNodeIdentifier]:
+        return ResponseItems[TypedNodeIdentifier].model_validate_json(response.body)
+
+    def _validate_page_response(
+        self, response: SuccessResponse | ItemsSuccessResponse
+    ) -> PagedResponse[InFieldCDMLocationConfigResponse]:
+        return PagedResponse[InFieldCDMLocationConfigResponse].model_validate_json(response.body)
 
 
 class InfieldAPI:
     def __init__(self, http_client: HTTPClient, console: Console) -> None:
         self._http_client = http_client
-        self.config = InfieldConfigAPI(http_client, console)
-        self.cdm_config = InFieldCDMConfigAPI(http_client, console)
+        self.config = InfieldConfigAPI(http_client)
+        self.cdm_config = InFieldCDMConfigAPI(http_client)

cognite_toolkit/_cdf_tk/client/api/instances.py

@@ -1,30 +1,43 @@
+from abc import ABC, abstractmethod
 from collections.abc import Iterable, Sequence
-from typing import Any, Literal
+from itertools import zip_longest
+from typing import Any, Generic, Literal
 
-from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, PagedResponse, ResponseItems
-from cognite_toolkit._cdf_tk.client.cdf_client.api import Endpoint
-from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsSuccessResponse, SuccessResponse
+from pydantic import JsonValue
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, PagedResponse, QueryResponse, ResponseItems
+from cognite_toolkit._cdf_tk.client.cdf_client.api import APIMethod, Endpoint
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsSuccessResponse, RequestMessage, SuccessResponse
 from cognite_toolkit._cdf_tk.client.request_classes.filters import InstanceFilter
 from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling import (
     InstanceRequest,
     InstanceResponse,
-    ViewReference,
 )
 from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling._instance import InstanceSlimDefinition
-from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import TypedInstanceIdentifier
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import (
+    T_InstancesListRequest,
+    T_InstancesListResponse,
+    T_TypedInstanceIdentifier,
+    T_WrappedInstanceRequest,
+    T_WrappedInstanceResponse,
+    TypedInstanceIdentifier,
+    TypedNodeIdentifier,
+    TypedViewReference,
+)
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
+
+METHOD_MAP: dict[APIMethod, Endpoint] = {
+    "upsert": Endpoint(method="POST", path="/models/instances", item_limit=1000),
+    "retrieve": Endpoint(method="POST", path="/models/instances/byids", item_limit=1000),
+    "delete": Endpoint(method="POST", path="/models/instances/delete", item_limit=1000),
+    "list": Endpoint(method="POST", path="/models/instances/list", item_limit=1000),
+}
+QUERY_ENDPOINT = Endpoint(method="POST", path="/models/instances/query", item_limit=1000)
 
 
 class InstancesAPI(CDFResourceAPI[TypedInstanceIdentifier, InstanceRequest, InstanceResponse]):
     def __init__(self, http_client: HTTPClient) -> None:
-        super().__init__(
-            http_client=http_client,
-            method_endpoint_map={
-                "upsert": Endpoint(method="POST", path="/models/instances", item_limit=1000),
-                "retrieve": Endpoint(method="POST", path="/models/instances/byids", item_limit=1000),
-                "delete": Endpoint(method="POST", path="/models/instances/delete", item_limit=1000),
-                "list": Endpoint(method="POST", path="/models/instances/list", item_limit=1000),
-            },
-        )
+        super().__init__(http_client=http_client, method_endpoint_map=METHOD_MAP)
 
     def _validate_page_response(
         self, response: SuccessResponse | ItemsSuccessResponse
@@ -48,7 +61,7 @@ class InstancesAPI(CDFResourceAPI[TypedInstanceIdentifier, InstanceRequest, Inst
         return response_items
 
     def retrieve(
-        self, items: Sequence[TypedInstanceIdentifier], source: ViewReference | None = None
+        self, items: Sequence[TypedInstanceIdentifier], source: TypedViewReference | None = None
     ) -> list[InstanceResponse]:
         """Retrieve instances from CDF.
 
@@ -141,3 +154,213 @@ class InstancesAPI(CDFResourceAPI[TypedInstanceIdentifier, InstanceRequest, Inst
             List of InstanceResponse objects.
         """
         return self._list(limit=limit, body=self._create_body(filter))
+
+
+class WrappedInstancesAPI(
+    CDFResourceAPI[T_TypedInstanceIdentifier, T_WrappedInstanceRequest, T_WrappedInstanceResponse], ABC
+):
+    """API for wrapped instances in CDF. It is intended to be subclassed for specific wrapped instance types."""
+
+    def __init__(self, http_client: HTTPClient, view_id: TypedViewReference) -> None:
+        super().__init__(http_client=http_client, method_endpoint_map=METHOD_MAP)
+        self._view_id = view_id
+
+    @abstractmethod
+    def _validate_response(self, response: SuccessResponse) -> ResponseItems[T_TypedInstanceIdentifier]:
+        raise NotImplementedError()
+
+    def create(self, items: Sequence[T_WrappedInstanceRequest]) -> list[InstanceSlimDefinition]:
+        """Create instances in CDF.
+
+        Args:
+            items: List of InstanceRequest objects to create.
+        Returns:
+            List of created InstanceSlimDefinition objects.
+        """
+        response_items: list[InstanceSlimDefinition] = []
+        for response in self._chunk_requests(items, "upsert", self._serialize_items):
+            response_items.extend(PagedResponse[InstanceSlimDefinition].model_validate_json(response.body).items)
+        return response_items
+
+    def retrieve(self, items: Sequence[T_TypedInstanceIdentifier]) -> list[T_WrappedInstanceResponse]:
+        """Retrieve instances from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+            source: Optional ViewReference to specify the source view for the instances.
+        Returns:
+            List of retrieved InstanceResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"sources": [{"source": self._view_id.dump()}]}
+        )
+
+    def delete(self, items: Sequence[T_TypedInstanceIdentifier]) -> list[T_TypedInstanceIdentifier]:
+        """Delete instances from CDF.
+
+        Args:
+            items: List of TypedInstanceIdentifier objects to delete.
+        """
+        response_items: list[T_TypedInstanceIdentifier] = []
+        for response in self._chunk_requests(items, "delete", self._serialize_items):
+            response_items.extend(self._validate_response(response).items)
+        return response_items
+
+
+class MultiWrappedInstancesAPI(Generic[T_InstancesListRequest, T_InstancesListResponse], ABC):
+    """API for objects that wraps multiple instances in CDF.
+
+    For example, a Canvas is a node with edges to elements in the Canvas represented as nodes. This wrapper class
+    allows creating, retrieving, updating, and deleting such objects in CDF.
+
+    """
+
+    def __init__(self, http_client: HTTPClient, query_chunk: int) -> None:
+        self._http_client = http_client
+        self._method_endpoint_map = METHOD_MAP
+        self._query_chunk = query_chunk
+
+    @abstractmethod
+    def _retrieve_query(self, item: Sequence[TypedInstanceIdentifier]) -> dict[str, Any]:
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _validate_query_response(self, query_response: QueryResponse) -> list[T_InstancesListResponse]:
+        raise NotImplementedError()
+
+    def create(self, items: Sequence[T_InstancesListRequest]) -> list[InstanceSlimDefinition]:
+        """Create instances in CDF.
+
+        Args:
+            items: List of InstanceRequest objects to create.
+        Returns:
+            List of created InstanceSlimDefinition objects.
+        """
+        endpoint = self._method_endpoint_map["upsert"]
+        response_items: list[InstanceSlimDefinition] = []
+        for item in items:
+            instance_dicts = item.dump_instances()
+            item_response: list[InstanceSlimDefinition] = []
+            for chunk in chunker_sequence(instance_dicts, endpoint.item_limit):
+                request = RequestMessage(
+                    endpoint_url=self._http_client.config.create_api_url(endpoint.path),
+                    method=endpoint.method,
+                    body_content={"items": chunk},  # type: ignore[dict-item]
+                )
+                response = self._http_client.request_single_retries(request)
+                success = response.get_success_or_raise()
+                paged_response = PagedResponse[InstanceSlimDefinition].model_validate_json(success.body)
+                item_response.extend(paged_response.items)
+            response_items.append(self._merge_instance_slim_definitions(item_response))
+        return response_items
+
+    def _merge_instance_slim_definitions(self, items: list[InstanceSlimDefinition]) -> InstanceSlimDefinition:
+        """Merge multiple InstanceSlimDefinition objects into one.
+
+        Args:
+            items: List of InstanceSlimDefinition objects to merge.
+        Returns:
+            Merged InstanceSlimDefinition object.
+        """
+        if not items:
+            raise ValueError("No items to merge.")
+        # Assuming all items have the same space and external_id
+        base_item = items[0]
+        merged_item = InstanceSlimDefinition(
+            instance_type=base_item.instance_type,
+            version=base_item.version,
+            was_modified=any(item.was_modified for item in items),
+            space=base_item.space,
+            external_id=base_item.external_id,
+            created_time=min(item.created_time for item in items),
+            last_updated_time=max(item.last_updated_time for item in items),
+        )
+        return merged_item
+
+    def update(self, items: Sequence[T_InstancesListRequest]) -> list[InstanceSlimDefinition]:
+        """Update multi-wrapped instances in CDF.
+
+        This method automatically removes underlying instances that are part of the old object but not the new one.
+
+        Args:
+            items: A sequence of multi-wrapped instance requests to update.
+
+        Returns:
+            List of updated InstanceSlimDefinition objects, one for each item in the input sequence.
+        """
+        endpoint = self._method_endpoint_map["upsert"]
+        updated: list[InstanceSlimDefinition] = []
+        for item in items:
+            identifier = item.as_id()
+            retrieved = self.retrieve([identifier])
+            if not retrieved:
+                raise ValueError(f"Item with identifier {identifier} not found for update.")
+            to_delete = [id.dump() for id in (set(retrieved[0].as_ids()) - set(item.as_ids()))]
+            to_update = item.dump_instances()
+            item_response: list[InstanceSlimDefinition] = []
+            for upsert_chunk, delete_chunk in zip_longest(
+                chunker_sequence(to_update, endpoint.item_limit),
+                chunker_sequence(to_delete, endpoint.item_limit),
+                fillvalue=None,
+            ):
+                body_content: dict[str, JsonValue] = {}
+                if upsert_chunk:
+                    # MyPy fails do understand that list[dict[str, JsonValue]] is a subtype of JsonValue
+                    body_content["items"] = upsert_chunk  # type: ignore[assignment]
+                if delete_chunk:
+                    body_content["delete"] = delete_chunk  # type: ignore[assignment]
+
+                response = self._http_client.request_single_retries(
+                    message=RequestMessage(
+                        endpoint_url=self._http_client.config.create_api_url(endpoint.path),
+                        method=endpoint.method,
+                        body_content=body_content,
+                    )
+                )
+                success = response.get_success_or_raise()
+                paged_response = PagedResponse[InstanceSlimDefinition].model_validate_json(success.body)
+                item_response.extend(paged_response.items)
+            updated.append(self._merge_instance_slim_definitions(item_response))
+        return updated
+
+    def retrieve(self, items: Sequence[TypedNodeIdentifier]) -> list[T_InstancesListResponse]:
+        """Retrieve instances from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+        Returns:
+            List of retrieved InstanceResponse objects.
+        """
+        retrieved: list[T_InstancesListResponse] = []
+        for chunk in chunker_sequence(items, self._query_chunk):
+            query_body = self._retrieve_query(chunk)
+            request = RequestMessage(
+                endpoint_url=self._http_client.config.create_api_url(QUERY_ENDPOINT.path),
+                method=QUERY_ENDPOINT.method,
+                body_content=query_body,
+            )
+            response = self._http_client.request_single_retries(request)
+            success = response.get_success_or_raise()
+            paged_response = QueryResponse.model_validate_json(success.body)
+            retrieved.extend(self._validate_query_response(paged_response))
+        return retrieved
+
+    def delete(self, items: Sequence[TypedNodeIdentifier]) -> list[TypedNodeIdentifier]:
+        """Delete instances from CDF.
+
+        Args:
+            items: List of TypedInstanceIdentifier objects to delete.
+        """
+        endpoint = self._method_endpoint_map["delete"]
+        response_items: list[TypedNodeIdentifier] = []
+        for chunk in chunker_sequence(items, endpoint.item_limit):
+            request = RequestMessage(
+                endpoint_url=self._http_client.config.create_api_url(endpoint.path),
+                method=endpoint.method,
+                body_content={"items": [item.dump() for item in chunk]},
+            )
+            response = self._http_client.request_single_retries(request)
+            success = response.get_success_or_raise()
+            validated_response = ResponseItems[TypedNodeIdentifier].model_validate_json(success.body)
+            response_items.extend(validated_response.items)
+        return response_items

cognite_toolkit/_cdf_tk/client/cdf_client/responses.py

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