cognite-toolkit 0.7.55__py3-none-any.whl → 0.7.57__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/cdf_client/api.py

@@ -22,10 +22,10 @@ from cognite_toolkit._cdf_tk.client._resource_base import (
 )
 from cognite_toolkit._cdf_tk.client.http_client import (
     HTTPClient,
-    ItemsRequest2,
-    ItemsSuccessResponse2,
-    RequestMessage2,
-    SuccessResponse2,
+    ItemsRequest,
+    ItemsSuccessResponse,
+    RequestMessage,
+    SuccessResponse,
 )
 from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
 
@@ -79,7 +79,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
 
     @abstractmethod
     def _validate_page_response(
-        self, response: SuccessResponse2 | ItemsSuccessResponse2
+        self, response: SuccessResponse | ItemsSuccessResponse
     ) -> PagedResponse[T_ResponseResource]:
         """Parse a single item response."""
         raise NotImplementedError()
@@ -131,7 +131,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
         endpoint_path: str | None = None,
-    ) -> Iterable[SuccessResponse2]:
+    ) -> Iterable[SuccessResponse]:
         """Send requests in chunks and yield responses.
 
         Args:
@@ -150,7 +150,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         endpoint = self._method_endpoint_map[method]
 
         for chunk in chunker_sequence(items, endpoint.item_limit):
-            request = RequestMessage2(
+            request = RequestMessage(
                 endpoint_url=f"{self._make_url(endpoint_path or endpoint.path)}",
                 method=endpoint.method,
                 body_content={"items": serialization(chunk), **(extra_body or {})},  # type: ignore[dict-item]
@@ -212,7 +212,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         method: APIMethod,
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
-    ) -> Iterable[ItemsSuccessResponse2]:
+    ) -> Iterable[ItemsSuccessResponse]:
         """Request items with retries and splitting on failures.
 
         This method handles large batches of items by chunking them according to the endpoint's item limit.
@@ -235,7 +235,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         endpoint = self._method_endpoint_map[method]
 
         for chunk in chunker_sequence(items, endpoint.item_limit):
-            request = ItemsRequest2(
+            request = ItemsRequest(
                 endpoint_url=f"{self._make_url(endpoint.path)}",
                 method=endpoint.method,
                 parameters=request_params,
@@ -245,7 +245,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
             )
             responses = self._http_client.request_items_retries(request)
             for response in responses:
-                if isinstance(response, ItemsSuccessResponse2):
+                if isinstance(response, ItemsSuccessResponse):
                     yield response
 
     @classmethod
@@ -309,7 +309,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         else:
             raise NotImplementedError(f"Unsupported method {endpoint.method} for pagination.")
 
-        request = RequestMessage2(
+        request = RequestMessage(
             endpoint_url=self._make_url(endpoint_path or endpoint.path),
             method=endpoint.method,
             parameters=request_params,

cognite_toolkit/_cdf_tk/client/http_client/__init__.py

@@ -1,71 +1,33 @@
 from ._client import HTTPClient
 from ._data_classes import (
-    T_COVARIANT_ID,
-    DataBodyRequest,
     ErrorDetails,
-    FailedRequestItems,
-    FailedRequestMessage,
+    FailedRequest,
     FailedResponse,
-    FailedResponseItems,
-    HTTPMessage,
-    ItemMessage,
-    ItemsRequest,
-    ParamRequest,
-    RequestItem,
+    HTTPResult,
     RequestMessage,
-    ResponseList,
-    ResponseMessage,
-    SimpleBodyRequest,
     SuccessResponse,
-    SuccessResponseItems,
-)
-from ._data_classes2 import (
-    ErrorDetails2,
-    FailedRequest2,
-    FailedResponse2,
-    HTTPResult2,
-    RequestMessage2,
-    SuccessResponse2,
 )
 from ._exception import ToolkitAPIError
 from ._item_classes import (
-    ItemsFailedRequest2,
-    ItemsFailedResponse2,
-    ItemsRequest2,
-    ItemsResultMessage2,
-    ItemsSuccessResponse2,
+    ItemsFailedRequest,
+    ItemsFailedResponse,
+    ItemsRequest,
+    ItemsResultMessage,
+    ItemsSuccessResponse,
 )
 
 __all__ = [
-    "T_COVARIANT_ID",
-    "DataBodyRequest",
     "ErrorDetails",
-    "ErrorDetails2",
-    "FailedRequest2",
-    "FailedRequestItems",
-    "FailedRequestMessage",
+    "FailedRequest",
     "FailedResponse",
-    "FailedResponse2",
-    "FailedResponseItems",
     "HTTPClient",
-    "HTTPMessage",
-    "HTTPResult2",
-    "ItemMessage",
-    "ItemsFailedRequest2",
-    "ItemsFailedResponse2",
+    "HTTPResult",
+    "ItemsFailedRequest",
+    "ItemsFailedResponse",
     "ItemsRequest",
-    "ItemsRequest2",
-    "ItemsResultMessage2",
-    "ItemsSuccessResponse2",
-    "ParamRequest",
-    "RequestItem",
+    "ItemsResultMessage",
+    "ItemsSuccessResponse",
     "RequestMessage",
-    "RequestMessage2",
-    "ResponseList",
-    "ResponseMessage",
-    "SimpleBodyRequest",
     "SuccessResponse",
-    "SuccessResponse2",
-    "SuccessResponseItems",
     "ToolkitAPIError",
 ]

cognite_toolkit/_cdf_tk/client/http_client/_client.py

@@ -1,4 +1,3 @@
-import gzip
 import random
 import sys
 import time
@@ -11,36 +10,24 @@ 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,
-    FailedRequest2,
-    FailedResponse2,
-    HTTPResult2,
-    RequestMessage2,
-    SuccessResponse2,
+    ErrorDetails,
+    FailedRequest,
+    FailedResponse,
+    HTTPResult,
+    RequestMessage,
+    SuccessResponse,
 )
 from cognite_toolkit._cdf_tk.client.http_client._item_classes import (
-    ItemsFailedRequest2,
-    ItemsFailedResponse2,
-    ItemsRequest2,
+    ItemsFailedRequest,
+    ItemsFailedResponse,
+    ItemsRequest,
     ItemsResultList,
-    ItemsResultMessage2,
-    ItemsSuccessResponse2,
+    ItemsResultMessage,
+    ItemsSuccessResponse,
 )
 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,48 +136,22 @@ 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:
+    def request_single(self, message: RequestMessage) -> RequestMessage | HTTPResult:
         """Send an HTTP request and return the response.
 
         Args:
-            message (RequestMessage2): The request message to send.
+            message (RequestMessage): The request message to send.
         Returns:
-            HTTPMessage: The response message.
+            RequestMessage2 | HTTPResult: 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)
         return result
 
-    def request_single_retries(self, message: RequestMessage2) -> HTTPResult2:
+    def request_single_retries(self, message: RequestMessage) -> HTTPResult:
         """Send an HTTP request and handle retries.
 
         This method will keep retrying the request until it either succeeds or
@@ -318,7 +161,7 @@ class HTTPClient:
         it is blocking.
 
         Args:
-            message (RequestMessage2): The request message to send.
+            message (RequestMessage): The request message to send.
         Returns:
             HTTPMessage2: The final response message, which can be either successful response or failed request.
         """
@@ -327,14 +170,14 @@ class HTTPClient:
         current_request = message
         while True:
             result = self.request_single(current_request)
-            if isinstance(result, RequestMessage2):
+            if isinstance(result, RequestMessage):
                 current_request = result
-            elif isinstance(result, HTTPResult2):
+            elif isinstance(result, HTTPResult):
                 return result
             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,
@@ -352,11 +195,9 @@ class HTTPClient:
             follow_redirects=False,
         )
 
-    def _handle_response_single(
-        self, response: httpx.Response, request: RequestMessage2
-    ) -> RequestMessage2 | HTTPResult2:
+    def _handle_response_single(self, response: httpx.Response, request: RequestMessage) -> RequestMessage | HTTPResult:
         if 200 <= response.status_code < 300:
-            return SuccessResponse2(
+            return SuccessResponse(
                 status_code=response.status_code,
                 body=response.text,
                 content=response.content,
@@ -365,10 +206,10 @@ class HTTPClient:
             return retry_request
         else:
             # Permanent failure
-            return FailedResponse2(
+            return FailedResponse(
                 status_code=response.status_code,
                 body=response.text,
-                error=ErrorDetails2.from_response(response),
+                error=ErrorDetails.from_response(response),
             )
 
     def _retry_request(self, response: httpx.Response, request: _T_Request_Message) -> _T_Request_Message | None:
@@ -389,7 +230,7 @@ class HTTPClient:
             return request
         return None
 
-    def _handle_error_single(self, e: Exception, request: RequestMessage2) -> RequestMessage2 | HTTPResult2:
+    def _handle_error_single(self, e: Exception, request: RequestMessage) -> RequestMessage | HTTPResult:
         if isinstance(e, httpx.ReadTimeout | httpx.TimeoutException):
             error_type = "read"
             request.read_attempt += 1
@@ -400,7 +241,7 @@ class HTTPClient:
             attempts = request.connect_attempt
         else:
             error_msg = f"Unexpected exception: {e!s}"
-            return FailedRequest2(error=error_msg)
+            return FailedRequest(error=error_msg)
 
         if attempts <= self._max_retries:
             time.sleep(self._backoff_time(request.total_attempts))
@@ -409,32 +250,32 @@ class HTTPClient:
             # 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 FailedRequest2(error=error_msg)
+            return FailedRequest(error=error_msg)
 
-    def request_items(self, message: ItemsRequest2) -> Sequence[ItemsRequest2 | ItemsResultMessage2]:
+    def request_items(self, message: ItemsRequest) -> Sequence[ItemsRequest | ItemsResultMessage]:
         """Send an HTTP request with multiple items and return the response.
 
         Args:
-            message (ItemsRequest2): The request message to send.
+            message (ItemsRequest): The request message to send.
         Returns:
-            Sequence[ItemsRequest2 | ItemsResultMessage2]: The response message(s). This can also
+            Sequence[ItemsRequest2 | ItemsResultMessage]: The response message(s). This can also
                 include ItemsRequest2(s) to be retried or split.
         """
         if message.tracker and message.tracker.limit_reached():
             return [
-                ItemsFailedRequest2(
+                ItemsFailedRequest(
                     ids=[str(item) for item in message.items],
                     error_message=f"Aborting further splitting of requests after {message.tracker.failed_split_count} failed attempts.",
                 )
             ]
         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)
         return results
 
-    def request_items_retries(self, message: ItemsRequest2) -> ItemsResultList:
+    def request_items_retries(self, message: ItemsRequest) -> ItemsResultList:
         """Send an HTTP request with multiple items and handle retries.
 
         This method will keep retrying the request until it either succeeds or
@@ -444,13 +285,13 @@ class HTTPClient:
         it is blocking.
 
         Args:
-            message (ItemsRequest2): The request message to send.
+            message (ItemsRequest): The request message to send.
         Returns:
-            Sequence[ItemsResultMessage2]: The final response message, which can be either successful response or failed request.
+            Sequence[ItemsResultMessage]: The final response message, which can be either successful response or failed request.
         """
         if message.total_attempts > 0:
             raise RuntimeError(f"ItemsRequest2 has already been attempted {message.total_attempts} times.")
-        pending_requests: deque[ItemsRequest2] = deque()
+        pending_requests: deque[ItemsRequest] = deque()
         pending_requests.append(message)
         final_responses = ItemsResultList([])
         while pending_requests:
@@ -458,9 +299,9 @@ class HTTPClient:
             results = self.request_items(current_request)
 
             for result in results:
-                if isinstance(result, ItemsRequest2):
+                if isinstance(result, ItemsRequest):
                     pending_requests.append(result)
-                elif isinstance(result, ItemsResultMessage2):
+                elif isinstance(result, ItemsResultMessage):
                     final_responses.append(result)
                 else:
                     raise TypeError(f"Unexpected result type: {type(result)}")
@@ -468,11 +309,11 @@ class HTTPClient:
         return final_responses
 
     def _handle_items_response(
-        self, response: httpx.Response, request: ItemsRequest2
-    ) -> Sequence[ItemsRequest2 | ItemsResultMessage2]:
+        self, response: httpx.Response, request: ItemsRequest
+    ) -> Sequence[ItemsRequest | ItemsResultMessage]:
         if 200 <= response.status_code < 300:
             return [
-                ItemsSuccessResponse2(
+                ItemsSuccessResponse(
                     ids=[str(item) for item in request.items],
                     status_code=response.status_code,
                     body=response.text,
@@ -488,11 +329,11 @@ class HTTPClient:
             splits = request.split(status_attempts=status_attempts)
             if splits[0].tracker and splits[0].tracker.limit_reached():
                 return [
-                    ItemsFailedResponse2(
+                    ItemsFailedResponse(
                         ids=[str(item) for item in request.items],
                         status_code=response.status_code,
                         body=response.text,
-                        error=ErrorDetails2.from_response(response),
+                        error=ErrorDetails.from_response(response),
                     )
                 ]
             return splits
@@ -502,17 +343,15 @@ class HTTPClient:
         else:
             # Permanent failure
             return [
-                ItemsFailedResponse2(
+                ItemsFailedResponse(
                     ids=[str(item) for item in request.items],
                     status_code=response.status_code,
                     body=response.text,
-                    error=ErrorDetails2.from_response(response),
+                    error=ErrorDetails.from_response(response),
                 )
             ]
 
-    def _handle_items_error(
-        self, e: Exception, request: ItemsRequest2
-    ) -> Sequence[ItemsRequest2 | ItemsResultMessage2]:
+    def _handle_items_error(self, e: Exception, request: ItemsRequest) -> Sequence[ItemsRequest | ItemsResultMessage]:
         if isinstance(e, httpx.ReadTimeout | httpx.TimeoutException):
             error_type = "read"
             request.read_attempt += 1
@@ -524,7 +363,7 @@ class HTTPClient:
         else:
             error_msg = f"Unexpected exception: {e!s}"
             return [
-                ItemsFailedRequest2(
+                ItemsFailedRequest(
                     ids=[str(item) for item in request.items],
                     error_message=error_msg,
                 )
@@ -538,7 +377,7 @@ class HTTPClient:
             error_msg = f"RequestException after {request.total_attempts - 1} attempts ({error_type} error): {e!s}"
 
             return [
-                ItemsFailedRequest2(
+                ItemsFailedRequest(
                     ids=[str(item) for item in request.items],
                     error_message=error_msg,
                 )