cognite-toolkit 0.7.55__tar.gz → 0.7.56__tar.gz

{cognite_toolkit-0.7.55 → cognite_toolkit-0.7.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.55
+Version: 0.7.56
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Author: Cognite AS
 Author-email: Cognite AS <support@cognite.com>

cognite_toolkit-0.7.56/cognite_toolkit/_cdf_tk/client/http_client/__init__.py

@@ -0,0 +1,33 @@
+from ._client import HTTPClient
+from ._data_classes2 import (
+    ErrorDetails2,
+    FailedRequest2,
+    FailedResponse2,
+    HTTPResult2,
+    RequestMessage2,
+    SuccessResponse2,
+)
+from ._exception import ToolkitAPIError
+from ._item_classes import (
+    ItemsFailedRequest2,
+    ItemsFailedResponse2,
+    ItemsRequest2,
+    ItemsResultMessage2,
+    ItemsSuccessResponse2,
+)
+
+__all__ = [
+    "ErrorDetails2",
+    "FailedRequest2",
+    "FailedResponse2",
+    "HTTPClient",
+    "HTTPResult2",
+    "ItemsFailedRequest2",
+    "ItemsFailedResponse2",
+    "ItemsRequest2",
+    "ItemsResultMessage2",
+    "ItemsSuccessResponse2",
+    "RequestMessage2",
+    "SuccessResponse2",
+    "ToolkitAPIError",
+]

{cognite_toolkit-0.7.55 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/client/http_client/_client.py

@@ -1,4 +1,3 @@
-import gzip
 import random
 import sys
 import time
@@ -10,17 +9,6 @@ import httpx
 from cognite.client import global_config
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk.client.http_client._data_classes import (
-    BodyRequest,
-    DataBodyRequest,
-    FailedRequestMessage,
-    HTTPMessage,
-    ItemsRequest,
-    ParamRequest,
-    RequestMessage,
-    ResponseList,
-    ResponseMessage,
-)
 from cognite_toolkit._cdf_tk.client.http_client._data_classes2 import (
     BaseRequestMessage,
     ErrorDetails2,
@@ -40,7 +28,6 @@ from cognite_toolkit._cdf_tk.client.http_client._item_classes import (
 )
 from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
 from cognite_toolkit._cdf_tk.utils.auxiliary import get_current_toolkit_version, get_user_agent
-from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -102,63 +89,6 @@ class HTTPClient:
         self.session.close()
         return False  # Do not suppress exceptions
 
-    def request(self, message: RequestMessage) -> Sequence[HTTPMessage]:
-        """Send an HTTP request and return the response.
-
-        Args:
-            message (RequestMessage): The request message to send.
-
-        Returns:
-            Sequence[HTTPMessage]: The response message(s). This can also
-                include RequestMessage(s) to be retried.
-        """
-        if isinstance(message, ItemsRequest) and message.tracker and message.tracker.limit_reached():
-            error_msg = (
-                f"Aborting further splitting of requests after {message.tracker.failed_split_count} failed attempts."
-            )
-            return message.create_failed_request(error_msg)
-        try:
-            response = self._make_request(message)
-            results = self._handle_response(response, message)
-        except Exception as e:
-            results = self._handle_error(e, message)
-        return results
-
-    def request_with_retries(self, message: RequestMessage) -> ResponseList:
-        """Send an HTTP request and handle retries.
-
-        This method will keep retrying the request until it either succeeds or
-        exhausts the maximum number of retries.
-
-        Note this method will use the current thread to process all request, thus
-        it is blocking.
-
-        Args:
-            message (RequestMessage): The request message to send.
-
-        Returns:
-            Sequence[ResponseMessage | FailedRequestMessage]: The final response
-                messages, which can be either successful responses or failed requests.
-        """
-        if message.total_attempts > 0:
-            raise RuntimeError(f"RequestMessage has already been attempted {message.total_attempts} times.")
-        pending_requests: deque[RequestMessage] = deque()
-        pending_requests.append(message)
-        final_responses = ResponseList([])
-        while pending_requests:
-            current_request = pending_requests.popleft()
-            results = self.request(current_request)
-
-            for result in results:
-                if isinstance(result, RequestMessage):
-                    pending_requests.append(result)
-                elif isinstance(result, ResponseMessage | FailedRequestMessage):
-                    final_responses.append(result)
-                else:
-                    raise TypeError(f"Unexpected result type: {type(result)}")
-
-        return final_responses
-
     def _create_thread_safe_session(self) -> httpx.Client:
         return httpx.Client(
             limits=httpx.Limits(
@@ -191,67 +121,6 @@ class HTTPClient:
             headers["Content-Encoding"] = "gzip"
         return headers
 
-    def _make_request(self, item: RequestMessage) -> httpx.Response:
-        headers = self._create_headers(item.api_version, item.content_type, item.accept, item.content_length)
-        params: dict[str, PrimitiveType] | None = None
-        if isinstance(item, ParamRequest):
-            params = item.parameters
-        data: str | bytes | None = None
-        if isinstance(item, BodyRequest):
-            data = item.data()
-            if not global_config.disable_gzip and item.content_length is None:
-                data = gzip.compress(data.encode("utf-8"))
-        elif isinstance(item, DataBodyRequest):
-            data = item.data()
-            if not global_config.disable_gzip and item.content_length is None:
-                data = gzip.compress(data)
-        return self.session.request(
-            method=item.method,
-            url=item.endpoint_url,
-            content=data,
-            headers=headers,
-            params=params,
-            timeout=self.config.timeout,
-            follow_redirects=False,
-        )
-
-    def _handle_response(self, response: httpx.Response, request: RequestMessage) -> Sequence[HTTPMessage]:
-        if 200 <= response.status_code < 300:
-            return request.create_success_response(response)
-        elif (
-            isinstance(request, ItemsRequest)
-            and len(request.items) > 1
-            and response.status_code in self._split_items_status_codes
-        ):
-            # 4XX: Status there is at least one item that is invalid, split the batch to get all valid items processed
-            # 5xx: Server error, split to reduce the number of items in each request, and count as a status attempt
-            status_attempts = request.status_attempt
-            if 500 <= response.status_code < 600:
-                status_attempts += 1
-            splits = request.split(status_attempts=status_attempts)
-            if splits[0].tracker and splits[0].tracker.limit_reached():
-                return request.create_failure_response(response)
-            return splits
-
-        retry_after = self._get_retry_after_in_header(response)
-        if retry_after is not None and response.status_code == 429 and request.status_attempt < self._max_retries:
-            if self._console is not None:
-                short_url = request.endpoint_url.removeprefix(self.config.base_api_url)
-                HighSeverityWarning(
-                    f"Rate limit exceeded for the {short_url!r} endpoint. Retrying after {retry_after} seconds."
-                ).print_warning(console=self._console)
-            request.status_attempt += 1
-            time.sleep(retry_after)
-            return [request]
-
-        if request.status_attempt < self._max_retries and response.status_code in self._retry_status_codes:
-            request.status_attempt += 1
-            time.sleep(self._backoff_time(request.total_attempts))
-            return [request]
-        else:
-            # Permanent failure
-            return request.create_failure_response(response)
-
     @staticmethod
     def _get_retry_after_in_header(response: httpx.Response) -> float | None:
         if "Retry-After" not in response.headers:
@@ -267,42 +136,16 @@ class HTTPClient:
         backoff_time = 0.5 * (2**attempts)
         return min(backoff_time, global_config.max_retry_backoff) * random.uniform(0, 1.0)
 
-    def _handle_error(
-        self,
-        e: Exception,
-        request: RequestMessage,
-    ) -> Sequence[HTTPMessage]:
-        if isinstance(e, httpx.ReadTimeout | httpx.TimeoutException):
-            error_type = "read"
-            request.read_attempt += 1
-            attempts = request.read_attempt
-        elif isinstance(e, ConnectionError | httpx.ConnectError | httpx.ConnectTimeout):
-            error_type = "connect"
-            request.connect_attempt += 1
-            attempts = request.connect_attempt
-        else:
-            error_msg = f"Unexpected exception: {e!s}"
-            return request.create_failed_request(error_msg)
-
-        if attempts <= self._max_retries:
-            time.sleep(self._backoff_time(request.total_attempts))
-            return [request]
-        else:
-            # We have already incremented the attempt count, so we subtract 1 here
-            error_msg = f"RequestException after {request.total_attempts - 1} attempts ({error_type} error): {e!s}"
-
-            return request.create_failed_request(error_msg)
-
     def request_single(self, message: RequestMessage2) -> RequestMessage2 | HTTPResult2:
         """Send an HTTP request and return the response.
 
         Args:
             message (RequestMessage2): The request message to send.
         Returns:
-            HTTPMessage: The response message.
+            RequestMessage2 | HTTPResult2: The response message.
         """
         try:
-            response = self._make_request2(message)
+            response = self._make_request(message)
             result = self._handle_response_single(response, message)
         except Exception as e:
             result = self._handle_error_single(e, message)
@@ -334,7 +177,7 @@ class HTTPClient:
             else:
                 raise TypeError(f"Unexpected result type: {type(result)}")
 
-    def _make_request2(self, message: BaseRequestMessage) -> httpx.Response:
+    def _make_request(self, message: BaseRequestMessage) -> httpx.Response:
         headers = self._create_headers(
             message.api_version,
             message.content_type,
@@ -428,7 +271,7 @@ class HTTPClient:
                 )
             ]
         try:
-            response = self._make_request2(message)
+            response = self._make_request(message)
             results = self._handle_items_response(response, message)
         except Exception as e:
             results = self._handle_items_error(e, message)

{cognite_toolkit-0.7.55 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/client/http_client/_data_classes2.py

@@ -1,23 +1,17 @@
 import gzip
 from abc import ABC, abstractmethod
-from collections.abc import Hashable
 from typing import Any, Literal
 
 import httpx
 from cognite.client import global_config
-from pydantic import BaseModel, JsonValue, TypeAdapter, model_validator
-
-from cognite_toolkit._cdf_tk.client.http_client._data_classes import (
-    ErrorDetails,
-    FailedRequestItems,
-    FailedRequestMessage,
-    FailedResponseItems,
-    ResponseMessage,
-    SuccessResponseItems,
-)
+from pydantic import TYPE_CHECKING, BaseModel, JsonValue, TypeAdapter, model_validator
+
 from cognite_toolkit._cdf_tk.client.http_client._exception import ToolkitAPIError
 from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
 
+if TYPE_CHECKING:
+    from cognite_toolkit._cdf_tk.client.http_client._item_classes import ItemsResultMessage2
+
 
 class HTTPResult2(BaseModel):
     def get_success_or_raise(self) -> "SuccessResponse2":
@@ -35,18 +29,24 @@ class HTTPResult2(BaseModel):
         else:
             raise ToolkitAPIError("Unknown HTTPResult2 type")
 
-    # Todo: Remove when HTTPResult2 is renamed to HTTPResponse and the old HTTPResponse is deleted
-    def as_item_response(self, item_id: Hashable) -> ResponseMessage | FailedRequestMessage:
+    def as_item_response(self, item_id: str) -> "ItemsResultMessage2":
+        # Avoid circular import
+        from cognite_toolkit._cdf_tk.client.http_client._item_classes import (
+            ItemsFailedRequest2,
+            ItemsFailedResponse2,
+            ItemsSuccessResponse2,
+        )
+
         if isinstance(self, SuccessResponse2):
-            return SuccessResponseItems(
+            return ItemsSuccessResponse2(
                 status_code=self.status_code, content=self.content, ids=[item_id], body=self.body
             )
         elif isinstance(self, FailedResponse2):
-            return FailedResponseItems(
+            return ItemsFailedResponse2(
                 status_code=self.status_code,
                 ids=[item_id],
                 body=self.body,
-                error=ErrorDetails(
+                error=ErrorDetails2(
                     code=self.error.code,
                     message=self.error.message,
                     missing=self.error.missing,
@@ -54,9 +54,9 @@ class HTTPResult2(BaseModel):
                 ),
             )
         elif isinstance(self, FailedRequest2):
-            return FailedRequestItems(ids=[item_id], error=self.error)
+            return ItemsFailedRequest2(ids=[item_id], error_message=self.error)
         else:
-            raise ToolkitAPIError("Unknown HTTPResult2 type")
+            raise ToolkitAPIError(f"Unknown {type(self).__name__} type")
 
 
 class FailedRequest2(HTTPResult2):

{cognite_toolkit-0.7.55 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/client/resource_classes/filemetadata.py

@@ -1,4 +1,4 @@
-from typing import ClassVar, Literal
+from typing import Any, ClassVar, Literal
 
 from pydantic import Field, JsonValue
 
@@ -37,6 +37,12 @@ class FileMetadataRequest(FileMetadata, UpdatableRequestResource):
     # from response to request.
     instance_id: NodeReference | None = Field(default=None, exclude=True)
 
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
+        update = super().as_update(mode)
+        # Name cannot be updated.
+        update["update"].pop("name", None)
+        return update
+
 
 class FileMetadataResponse(FileMetadata, ResponseResource[FileMetadataRequest]):
     created_time: int

{cognite_toolkit-0.7.55 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/commands/_migrate/command.py

@@ -9,10 +9,10 @@ from rich.table import Table
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.http_client import (
-    FailedRequestItems,
-    FailedResponseItems,
     HTTPClient,
-    SuccessResponseItems,
+    ItemsFailedRequest2,
+    ItemsFailedResponse2,
+    ItemsSuccessResponse2,
 )
 from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
 from cognite_toolkit._cdf_tk.commands._migrate.creators import MigrationCreator
@@ -187,20 +187,20 @@ class MigrationCommand(ToolkitCommand):
             # Todo: Move logging into the UploadableStorageIO class
             issues: list[WriteIssue] = []
             for item in responses:
-                if isinstance(item, SuccessResponseItems):
+                if isinstance(item, ItemsSuccessResponse2):
                     target.logger.tracker.finalize_item(item.ids, "success")
                     continue
-                if isinstance(item, FailedResponseItems):
+                if isinstance(item, ItemsFailedResponse2):
                     error = item.error
                     for id_ in item.ids:
                         issue = WriteIssue(id=str(id_), status_code=error.code, message=error.message)
                         issues.append(issue)
-                elif isinstance(item, FailedRequestItems):
+                elif isinstance(item, ItemsFailedRequest2):
                     for id_ in item.ids:
-                        issue = WriteIssue(id=str(id_), status_code=0, message=item.error)
+                        issue = WriteIssue(id=str(id_), status_code=0, message=item.error_message)
                         issues.append(issue)
 
-                if isinstance(item, FailedResponseItems | FailedRequestItems):
+                if isinstance(item, ItemsFailedResponse2 | ItemsFailedRequest2):
                     target.logger.tracker.finalize_item(item.ids, "failure")
             if issues:
                 target.logger.log(issues)

{cognite_toolkit-0.7.55 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/commands/_migrate/migration_io.py

@@ -6,14 +6,16 @@ from cognite.client.data_classes.data_modeling import EdgeId, InstanceApply, Nod
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.http_client import (
-    FailedResponse,
     HTTPClient,
-    HTTPMessage,
-    ItemsRequest,
     RequestMessage2,
-    SuccessResponseItems,
     ToolkitAPIError,
 )
+from cognite_toolkit._cdf_tk.client.http_client._item_classes import (
+    ItemsFailedResponse2,
+    ItemsRequest2,
+    ItemsResultList,
+    ItemsSuccessResponse2,
+)
 from cognite_toolkit._cdf_tk.client.resource_classes.legacy.pending_instances_ids import PendingInstanceId
 from cognite_toolkit._cdf_tk.client.resource_classes.three_d import (
     AssetMappingClassicResponse,
@@ -170,20 +172,20 @@ class AssetCentricMigrationIO(
         data_chunk: Sequence[UploadItem[InstanceApply]],
         http_client: HTTPClient,
         selector: AssetCentricMigrationSelector | None = None,
-    ) -> Sequence[HTTPMessage]:
+    ) -> ItemsResultList:
         """Upload items by first linking them using files/set-pending-instance-ids and then uploading the instances."""
         if self.skip_linking:
-            return list(super().upload_items(data_chunk, http_client, None))
+            return super().upload_items(data_chunk, http_client, None)
         elif selector is None:
             raise ToolkitNotImplementedError(f"Selector must be provided for uploading {self.KIND} items.")
         elif selector.kind not in self.PENDING_INSTANCE_ID_ENDPOINT_BY_KIND:
-            return list(super().upload_items(data_chunk, http_client, None))
+            return super().upload_items(data_chunk, http_client, None)
 
         pending_instance_id_endpoint = self.PENDING_INSTANCE_ID_ENDPOINT_BY_KIND[selector.kind]
-        results: list[HTTPMessage] = []
+        results = ItemsResultList()
         to_upload = self.link_asset_centric(data_chunk, http_client, pending_instance_id_endpoint)
         if to_upload:
-            results.extend(list(super().upload_items(to_upload, http_client, None)))
+            results.extend(super().upload_items(to_upload, http_client, None))
         return results
 
     @classmethod
@@ -197,8 +199,8 @@ class AssetCentricMigrationIO(
         config = http_client.config
         successful_linked: set[str] = set()
         for batch in chunker_sequence(data_chunk, cls.CHUNK_SIZE):
-            batch_results = http_client.request_with_retries(
-                message=ItemsRequest(
+            batch_results = http_client.request_items_retries(
+                message=ItemsRequest2(
                     endpoint_url=config.create_api_url(pending_instance_id_endpoint),
                     method="POST",
                     api_version="alpha",
@@ -209,7 +211,7 @@ class AssetCentricMigrationIO(
                 )
             )
             for res in batch_results:
-                if isinstance(res, SuccessResponseItems):
+                if isinstance(res, ItemsSuccessResponse2):
                     successful_linked.update(res.ids)
         to_upload = [item for item in data_chunk if item.source_id in successful_linked]
         return to_upload
@@ -441,26 +443,26 @@ class ThreeDMigrationIO(UploadableStorageIO[ThreeDSelector, ThreeDModelResponse,
         data_chunk: Sequence[UploadItem[ThreeDMigrationRequest]],
         http_client: HTTPClient,
         selector: ThreeDSelector | None = None,
-    ) -> Sequence[HTTPMessage]:
+    ) -> ItemsResultList:
         """Migrate 3D models by uploading them to the migrate/models endpoint."""
         if len(data_chunk) > self.CHUNK_SIZE:
             raise RuntimeError(f"Uploading more than {self.CHUNK_SIZE} 3D models at a time is not supported.")
 
-        results: list[HTTPMessage] = []
-        responses = http_client.request_with_retries(
-            message=ItemsRequest(
+        results = ItemsResultList()
+        responses = http_client.request_items_retries(
+            message=ItemsRequest2(
                 endpoint_url=self.client.config.create_api_url(self.UPLOAD_ENDPOINT),
                 method="POST",
-                items=list(data_chunk),
+                items=data_chunk,
             )
         )
         if (
-            failed_response := next((res for res in responses if isinstance(res, FailedResponse)), None)
+            failed_response := next((res for res in responses if isinstance(res, ItemsFailedResponse2)), None)
         ) and failed_response.status_code == 400:
             raise ToolkitAPIError("3D model migration failed. You need to enable the 3D migration alpha feature flag.")
 
         results.extend(responses)
-        success_ids = {id for res in responses if isinstance(res, SuccessResponseItems) for id in res.ids}
+        success_ids = {id for res in responses if isinstance(res, ItemsSuccessResponse2) for id in res.ids}
         for data in data_chunk:
             if data.source_id not in success_ids:
                 continue
@@ -535,21 +537,21 @@ class ThreeDAssetMappingMigrationIO(
         data_chunk: Sequence[UploadItem[AssetMappingDMRequest]],
         http_client: HTTPClient,
         selector: T_Selector | None = None,
-    ) -> Sequence[HTTPMessage]:
+    ) -> ItemsResultList:
         """Migrate 3D asset mappings by uploading them to the migrate/asset-mappings endpoint."""
         if not data_chunk:
-            return []
+            return ItemsResultList()
         # Assume all items in the chunk belong to the same model and revision, they should
         # if the .stream_data method is used for downloading.
         first = data_chunk[0]
         model_id = first.item.model_id
         revision_id = first.item.revision_id
         endpoint = self.UPLOAD_ENDPOINT.format(modelId=model_id, revisionId=revision_id)
-        responses = http_client.request_with_retries(
-            ItemsRequest(
+        return http_client.request_items_retries(
+            ItemsRequest2(
                 endpoint_url=self.client.config.create_api_url(endpoint),
                 method="POST",
-                items=list(data_chunk),
+                items=data_chunk,
                 extra_body_fields={
                     "dmsContextualizationConfig": {
                         "object3DSpace": self.object_3D_space,
@@ -558,7 +560,6 @@ class ThreeDAssetMappingMigrationIO(
                 },
             )
         )
-        return responses
 
     def json_to_resource(self, item_json: dict[str, JsonVal]) -> AssetMappingDMRequest:
         raise NotImplementedError("Deserializing 3D Asset Mappings from JSON is not supported.")

{cognite_toolkit-0.7.55 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/commands/_purge.py

@@ -1,9 +1,9 @@
 import uuid
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Hashable, Iterable, Sequence
+from collections.abc import Callable, Iterable, Sequence
 from dataclasses import dataclass
 from functools import partial
-from typing import Literal, cast
+from typing import Any, Literal, cast
 
 import questionary
 from cognite.client.data_classes import DataSetUpdate
@@ -11,17 +11,17 @@ from cognite.client.data_classes.data_modeling import Edge, NodeId
 from cognite.client.data_classes.data_modeling.statistics import SpaceStatistics
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils._identifier import InstanceId
+from pydantic import JsonValue
 from rich import print
 from rich.console import Console
 from rich.panel import Panel
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client._resource_base import RequestItem
 from cognite_toolkit._cdf_tk.client.http_client import (
     HTTPClient,
-    ItemsRequest,
     ItemsRequest2,
     ItemsSuccessResponse2,
-    SuccessResponseItems,
 )
 from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import TypedInstanceIdentifier
 from cognite_toolkit._cdf_tk.cruds import (
@@ -79,15 +79,14 @@ class DeleteResults:
     failed: int = 0
 
 
-@dataclass
-class DeleteItem:
-    item: JsonVal
-    as_id_fun: Callable[[JsonVal], Hashable]
+class DeleteItem(RequestItem):
+    item: JsonValue
+    as_id_fun: Callable[[JsonValue], str]
 
-    def dump(self) -> JsonVal:
-        return self.item
+    def dump(self, camel_case: bool = True, exclude_extra: bool = False) -> dict[str, Any]:
+        return self.item  # type: ignore[return-value]
 
-    def as_id(self) -> Hashable:
+    def __str__(self) -> str:
         return self.as_id_fun(self.item)
 
 
@@ -364,16 +363,16 @@ class PurgeCommand(ToolkitCommand):
     ) -> Callable[[list[JsonVal]], None]:
         crud = delete_item.crud
 
-        def as_id(item: JsonVal) -> Hashable:
+        def as_id(item: JsonVal) -> str:
             try:
-                return crud.get_id(item)
+                return str(crud.get_id(item))
             except KeyError:
                 # Fallback to internal ID
-                return crud.get_internal_id(item)
+                return str(crud.get_internal_id(item))
 
         def process(items: list[JsonVal]) -> None:
-            responses = delete_client.request_with_retries(
-                ItemsRequest(
+            responses = delete_client.request_items_retries(
+                ItemsRequest2(
                     endpoint_url=delete_url,
                     method="POST",
                     items=[DeleteItem(item=item, as_id_fun=as_id) for item in items],
@@ -381,10 +380,10 @@ class PurgeCommand(ToolkitCommand):
                 )
             )
             for response in responses:
-                if isinstance(response, SuccessResponseItems):
+                if isinstance(response, ItemsSuccessResponse2):
                     result.deleted += len(response.ids)
                 else:
-                    result.unchanged += len(items)
+                    result.unchanged += len(response.ids)
 
         return process
 

{cognite_toolkit-0.7.55 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/commands/_upload.py

@@ -3,13 +3,11 @@ from collections.abc import Sequence
 from functools import partial
 from pathlib import Path
 
-from cognite.client.data_classes.data_modeling import (
-    ViewId,
-)
+from cognite.client.data_classes.data_modeling import ViewId
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemMessage, SuccessResponseItems
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsResultMessage2, ItemsSuccessResponse2
 from cognite_toolkit._cdf_tk.constants import DATA_MANIFEST_SUFFIX, DATA_RESOURCE_DIR
 from cognite_toolkit._cdf_tk.cruds import ViewCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
@@ -279,10 +277,10 @@ class UploadCommand(ToolkitCommand):
             return
         results = io.upload_items(data_chunk, upload_client, selector)
         for message in results:
-            if isinstance(message, SuccessResponseItems):
+            if isinstance(message, ItemsSuccessResponse2):
                 for id_ in message.ids:
                     tracker.set_progress(id_, step=cls._UPLOAD, status="success")
-            elif isinstance(message, ItemMessage):
+            elif isinstance(message, ItemsResultMessage2):
                 for id_ in message.ids:
                     tracker.set_progress(id_, step=cls._UPLOAD, status="failed")
             else:

{cognite_toolkit-0.7.55 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/protocols.py

@@ -1,6 +1,6 @@
 import sys
 from collections.abc import Collection, Iterator
-from typing import Any, Generic, Protocol, TypeVar
+from typing import Any, Generic, Protocol, TypeVar, runtime_checkable
 
 from cognite.client import CogniteClient
 
@@ -10,6 +10,7 @@ else:
     from typing_extensions import Self
 
 
+@runtime_checkable
 class ResourceRequestProtocol(Protocol):
     @classmethod
     def _load(cls, data: dict[str, Any]) -> Self: ...
@@ -17,6 +18,7 @@ class ResourceRequestProtocol(Protocol):
     def dump(self, camel_case: bool = True) -> dict[str, Any]: ...
 
 
+@runtime_checkable
 class ResourceResponseProtocol(Protocol):
     def as_write(self) -> ResourceRequestProtocol: ...