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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.54
+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.54 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/apps/_download_app.py

@@ -319,37 +319,26 @@ class DownloadApp(typer.Typer):
             f"Select format to download the {display_name} in:",
             choices=[Choice(title=format_.value, value=format_) for format_ in available_formats],
             default=file_format,
-        ).ask()
+        ).unsafe_ask()
         compression = questionary.select(
             f"Select compression format to use when downloading the {display_name}:",
             choices=[Choice(title=comp.value, value=comp) for comp in CompressionFormat],
             default=compression,
-        ).ask()
+        ).unsafe_ask()
         output_dir = Path(
             questionary.path(
                 f"Where to download the {display_name}:",
                 default=str(output_dir),
                 only_directories=True,
-            ).ask()
+            ).unsafe_ask()
         )
-        while True:
-            limit_str = questionary.text(
+        limit = int(
+            questionary.text(
                 f"The maximum number of {display_name} to download from each dataset. Use -1 to download all {display_name}.",
                 default=str(limit),
-            ).ask()
-            if limit_str is None:
-                raise typer.Abort()
-            try:
-                limit = int(limit_str)
-            except ValueError:
-                print("[red]Please enter a valid integer for the limit.[/]")
-            else:
-                if max_limit is not None and limit > max_limit:
-                    print(
-                        f"[red]The maximum limit for downloading {display_name} is {max_limit}. Please enter a lower value.[/]"
-                    )
-                else:
-                    break
+                validate=lambda value: value.lstrip("-").isdigit() and (max_limit is None or int(value) <= max_limit),
+            ).unsafe_ask()
+        )
         return data_sets, file_format, compression, output_dir, limit
 
     def download_timeseries_cmd(
@@ -584,7 +573,7 @@ class DownloadApp(typer.Typer):
                         Choice(title="Yes", value=True),
                         Choice(title="No", value=False),
                     ],
-                ).ask()
+                ).unsafe_ask()
             else:
                 include_file_contents = False
 
@@ -933,52 +922,40 @@ class DownloadApp(typer.Typer):
                 "Select the type of datapoints to download:",
                 choices=[Choice(title=dt.value, value=dt) for dt in DatapointsDataTypes],
                 default=datapoint_type,
-            ).ask()
+            ).unsafe_ask()
 
             start_time = (
                 questionary.text(
                     "Enter the start time for the datapoints to download (RFC3339 format or relative time, e.g., '1d-ago'). Leave empty to download from the beginning.",
                     default=start_time or "",
-                ).ask()
+                ).unsafe_ask()
                 or None
             )
             end_time = (
                 questionary.text(
                     "Enter the end time for the datapoints to download (RFC3339 format or relative time, e.g., '1d-ago'). Leave empty to download up to the latest.",
                     default=end_time or "",
-                ).ask()
+                ).unsafe_ask()
                 or None
             )
             file_format = questionary.select(
                 "Select format to download the datapoints in:",
                 choices=[Choice(title=format_.value, value=format_) for format_ in DatapointFormats],
                 default=file_format,
-            ).ask()
+            ).unsafe_ask()
             output_dir = Path(
                 questionary.path(
                     "Where to download the datapoints:", default=str(output_dir), only_directories=True
-                ).ask()
+                ).unsafe_ask()
             )
-            while True:
-                limit_str = questionary.text(
+            limit = int(
+                questionary.text(
                     "The maximum number of timeseries to download datapoints from. Use -1 to download all timeseries."
                     "The maximum number of datapoints in total is 10 million and 100 000 per timeseries.",
                     default=str(limit),
-                ).ask()
-                if limit_str is None:
-                    raise typer.Abort()
-                try:
-                    limit = int(limit_str)
-                except ValueError:
-                    print("[red]Please enter a valid integer for the limit.[/]")
-                else:
-                    if limit != -1 and limit < 1:
-                        print("[red]Please enter a valid integer greater than 0 or -1 for unlimited.[/]")
-                    else:
-                        break
-                verbose = questionary.confirm(
-                    "Turn on to get more verbose output when running the command?", default=verbose
-                ).ask()
+                    validate=lambda value: value.lstrip("-").isdigit() and (int(value) == -1 or int(value) > 0),
+                ).unsafe_ask()
+            )
 
         cmd = DownloadCommand()
         selector = DataPointsDataSetSelector(

{cognite_toolkit-0.7.54 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/apps/_migrate_app.py

@@ -159,14 +159,13 @@ class MigrateApp(typer.Typer):
             # Interactive model
             selector = AssetInteractiveSelect(client, "migrate")
             data_set = selector.select_data_sets()
-            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).ask()
-            output_dir = questionary.path(
-                "Specify output directory for instance space definitions:", default=str(output_dir)
-            ).ask()
-            verbose = questionary.confirm("Do you want verbose output?", default=verbose).ask()
-            if any(res is None for res in [dry_run, output_dir, verbose]):
-                raise typer.Abort()
-            output_dir = Path(output_dir)
+            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).unsafe_ask()
+            output_dir = Path(
+                questionary.path(
+                    "Specify output directory for instance space definitions:", default=str(output_dir)
+                ).unsafe_ask()
+            )
+            verbose = questionary.confirm("Do you want verbose output?", default=verbose).unsafe_ask()
 
         cmd = MigrationCommand()
         cmd.run(
@@ -235,14 +234,13 @@ class MigrateApp(typer.Typer):
                 message="In which instance space do you want to create the source system?",
                 include_empty=True,
             )
-            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).ask()
-            output_dir = questionary.path(
-                "Specify output directory for instance space definitions:", default=str(output_dir)
-            ).ask()
-            verbose = questionary.confirm("Do you want verbose output?", default=verbose).ask()
-            if any(res is None for res in [instance_space, dry_run, output_dir, verbose]):
-                raise typer.Abort()
-            output_dir = Path(output_dir)
+            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).unsafe_ask()
+            output_dir = Path(
+                questionary.path(
+                    "Specify output directory for instance space definitions:", default=str(output_dir)
+                ).unsafe_ask()
+            )
+            verbose = questionary.confirm("Do you want verbose output?", default=verbose).unsafe_ask()
         elif data_set is None or instance_space is None:
             raise typer.BadParameter("Both data_set and instance_space must be provided together.")
 
@@ -399,10 +397,9 @@ class MigrateApp(typer.Typer):
                 ingestion_mapping=asset_mapping.external_id,
                 preferred_consumer_view=preferred_consumer_view,
             )
-            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).ask()
-            verbose = questionary.confirm("Do you want verbose output?", default=verbose).ask()
-            if any(res is None for res in [dry_run, verbose]):
-                raise typer.Abort()
+            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).unsafe_ask()
+            verbose = questionary.confirm("Do you want verbose output?", default=verbose).unsafe_ask()
+
         return selected, dry_run, verbose
 
     @classmethod
@@ -593,7 +590,7 @@ class MigrateApp(typer.Typer):
         if data_set_id is None and mapping_file is None:
             skip_linking = not questionary.confirm(
                 "Do you want to link old and new TimeSeries?", default=not skip_linking
-            ).ask()
+            ).unsafe_ask()
 
         cmd = MigrationCommand()
         cmd.run(
@@ -702,7 +699,7 @@ class MigrateApp(typer.Typer):
         if data_set_id is None:
             skip_linking = not questionary.confirm(
                 "Do you want to link old and new Files?", default=not skip_linking
-            ).ask()
+            ).unsafe_ask()
 
         cmd.run(
             lambda: cmd.migrate(
@@ -841,10 +838,8 @@ class MigrateApp(typer.Typer):
                 default_file_annotation_mapping=file_annotation_mapping,
             )
 
-            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).ask()
-            verbose = questionary.confirm("Do you want verbose output?", default=verbose).ask()
-            if any(res is None for res in [dry_run, verbose]):
-                raise typer.Abort()
+            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).unsafe_ask()
+            verbose = questionary.confirm("Do you want verbose output?", default=verbose).unsafe_ask()
 
         cmd = MigrationCommand()
         cmd.run(
@@ -913,12 +908,11 @@ class MigrateApp(typer.Typer):
         if external_id is None:
             interactive = InteractiveCanvasSelect(client)
             external_id = interactive.select_external_ids()
-            log_dir = questionary.path("Specify log directory for migration logs:", default=str(log_dir)).ask()
-            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).ask()
-            verbose = questionary.confirm("Do you want verbose output?", default=verbose).ask()
-            if any(res is None for res in [log_dir, dry_run, verbose]):
-                raise typer.Abort()
-            log_dir = Path(log_dir)
+            log_dir = Path(
+                questionary.path("Specify log directory for migration logs:", default=str(log_dir)).unsafe_ask()
+            )
+            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).unsafe_ask()
+            verbose = questionary.confirm("Do you want verbose output?", default=verbose).unsafe_ask()
 
         cmd = MigrationCommand()
         selector = CanvasExternalIdSelector(external_ids=tuple(external_id))
@@ -1131,10 +1125,8 @@ class MigrateApp(typer.Typer):
                 message="In which instance space do you want to create the CAD Node nodes?",
                 include_empty=False,
             )
-            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).ask()
-            verbose = questionary.confirm("Do you want verbose output?", default=verbose).ask()
-            if any(res is None for res in [dry_run, verbose]):
-                raise typer.Abort()
+            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).unsafe_ask()
+            verbose = questionary.confirm("Do you want verbose output?", default=verbose).unsafe_ask()
 
         if object_3D_space is None or cad_node_space is None:
             raise typer.BadParameter(

{cognite_toolkit-0.7.54 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/apps/_purge.py

@@ -116,24 +116,21 @@ class PurgeApp(typer.Typer):
             skip_data = not questionary.confirm(
                 "Delete data in the dataset (time series, events, files, assets, sequences, relationships, labels, 3D models)?",
                 default=True,
-            ).ask()
+            ).unsafe_ask()
             include_configurations = questionary.confirm(
                 "Delete configurations (workflows, extraction pipelines and transformations) in the dataset?",
                 default=False,
-            ).ask()
+            ).unsafe_ask()
             asset_recursive = questionary.confirm(
                 "When deleting assets, delete all child assets recursively? (WARNING: This can lead "
                 "to assets not in the selected dataset being deleted if they are children of assets in the dataset.)",
                 default=False,
-            ).ask()
-            archive_dataset = questionary.confirm("Archive the dataset itself after purging?", default=False).ask()
-            dry_run = questionary.confirm("Dry run?", default=True).ask()
-            verbose = questionary.confirm("Verbose?", default=True).ask()
-
-            user_options = [archive_dataset, dry_run, verbose, skip_data, include_configurations, asset_recursive]
-
-            if any(selected is None for selected in user_options):
-                raise typer.Abort("Aborted by user.")
+            ).unsafe_ask()
+            archive_dataset = questionary.confirm(
+                "Archive the dataset itself after purging?", default=False
+            ).unsafe_ask()
+            dry_run = questionary.confirm("Dry run?", default=True).unsafe_ask()
+            verbose = questionary.confirm("Verbose?", default=True).unsafe_ask()
 
         cmd.run(
             lambda: cmd.dataset(
@@ -222,11 +219,11 @@ class PurgeApp(typer.Typer):
                 space = interactive.select_schema_space(include_global=False).space
             else:
                 raise ToolkitValueError("Invalid space type selected.")
-            dry_run = questionary.confirm("Dry run?", default=True).ask()
+            dry_run = questionary.confirm("Dry run?", default=True).unsafe_ask()
             if space_type == "empty":
                 include_space = True
             else:
-                include_space = questionary.confirm("Delete the space itself?", default=False).ask()
+                include_space = questionary.confirm("Delete the space itself?", default=False).unsafe_ask()
 
         cmd.run(
             lambda: cmd.space(
@@ -339,8 +336,10 @@ class PurgeApp(typer.Typer):
                 instance_type=selected_instance_type,
                 instance_spaces=tuple(instance_space) if instance_space else None,
             )
-            dry_run = questionary.confirm("Dry run?", default=True).ask()
-            unlink = questionary.confirm("Unlink instances connected to timeseries or files?", default=True).ask()
+            dry_run = questionary.confirm("Dry run?", default=True).unsafe_ask()
+            unlink = questionary.confirm(
+                "Unlink instances connected to timeseries or files?", default=True
+            ).unsafe_ask()
         elif instance_list is not None:
             selector = InstanceFileSelector(datafile=instance_list)
         elif view is not None:

{cognite_toolkit-0.7.54 → cognite_toolkit-0.7.56}/cognite_toolkit/_cdf_tk/apps/_upload_app.py

@@ -73,11 +73,8 @@ class UploadApp(typer.Typer):
             input_dir = questionary.select(
                 "Select the input directory containing the data to upload:",
                 choices=[Choice(str(option.name), value=option) for option in input_candidate],
-            ).ask()
-            if input_dir is None:
-                typer.echo("No input directory selected. Exiting.")
-                raise typer.Exit(code=1)
-            dry_run = questionary.confirm("Proceed with dry run?", default=dry_run).ask()
+            ).unsafe_ask()
+            dry_run = questionary.confirm("Proceed with dry run?", default=dry_run).unsafe_ask()
             if dry_run is None:
                 typer.echo("No selection made for dry run. Exiting.")
                 raise typer.Exit(code=1)
@@ -90,10 +87,7 @@ class UploadApp(typer.Typer):
 
                 deploy_resources = questionary.confirm(
                     f"Deploy resources found in {display_name!r}?", default=deploy_resources
-                ).ask()
-                if deploy_resources is None:
-                    typer.echo("No selection made for deploying resources. Exiting.")
-                    raise typer.Exit(code=1)
+                ).unsafe_ask()
 
         client = EnvironmentVariables.create_from_environment().get_client()
         cmd.run(

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.54 → 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.54 → 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):