cognite-toolkit 0.7.30__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -1,21 +1,26 @@
 from collections.abc import Sequence
 from typing import Any, cast
 
+from pydantic import TypeAdapter
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse, QueryResponse
-from cognite_toolkit._cdf_tk.client.data_classes.infield import (
+from cognite_toolkit._cdf_tk.client.cdf_client.responses import QueryResponse
+from cognite_toolkit._cdf_tk.client.http_client import (
+    HTTPClient,
+    ItemsRequest2,
+    RequestMessage2,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.infield import (
     DataExplorationConfig,
     InFieldCDMLocationConfig,
     InfieldLocationConfig,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.instance_api import (
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import (
     InstanceResponseItem,
     InstanceResult,
-    NodeIdentifier,
+    TypedNodeIdentifier,
 )
 from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ItemsRequest, SimpleBodyRequest
 
 
 class InfieldConfigAPI:
@@ -40,34 +45,34 @@ class InfieldConfigAPI:
             else [item.as_request_item(), item.data_exploration_config.as_request_item()]
             for item in items
         )
-        responses = self._http_client.request_with_retries(
-            ItemsRequest(
+        responses = self._http_client.request_items_retries(
+            ItemsRequest2(
                 endpoint_url=self._config.create_api_url(self.ENDPOINT),
                 method="POST",
                 items=[item for sublist in request_items for item in sublist],
             )
         )
         responses.raise_for_status()
-        return PagedResponse[InstanceResult].model_validate(responses.get_first_body()).items
+        return TypeAdapter(list[InstanceResult]).validate_python(responses.get_items())
 
-    def retrieve(self, items: Sequence[NodeIdentifier]) -> list[InfieldLocationConfig]:
+    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 []
-        responses = self._http_client.request_with_retries(
-            SimpleBodyRequest(
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
                 # We use the query endpoint to be able to retrieve linked DataExplorationConfig items
                 endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
                 method="POST",
                 body_content=self._retrieve_query(items),
             )
         )
-        responses.raise_for_status()
-        parsed_response = QueryResponse[InstanceResponseItem].model_validate(responses.get_first_body())
+        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[NodeIdentifier]:
+    def delete(self, items: Sequence[InfieldLocationConfig]) -> list[TypedNodeIdentifier]:
         if len(items) > 500:
             raise ValueError("Cannot delete more than 500 InfieldLocationConfig items at once.")
 
@@ -77,18 +82,18 @@ class InfieldConfigAPI:
             else [item.as_id(), item.data_exploration_config.as_id()]
             for item in items
         )
-        responses = self._http_client.request_with_retries(
-            ItemsRequest(
+        responses = self._http_client.request_items_retries(
+            ItemsRequest2(
                 endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
                 method="POST",
                 items=[identifier for sublist in identifiers for identifier in sublist],
             )
         )
         responses.raise_for_status()
-        return PagedResponse[NodeIdentifier].model_validate(responses.get_first_body()).items
+        return TypeAdapter(list[TypedNodeIdentifier]).validate_python(responses.get_items())
 
     @classmethod
-    def _retrieve_query(cls, items: Sequence[NodeIdentifier]) -> dict[str, Any]:
+    def _retrieve_query(cls, items: Sequence[TypedNodeIdentifier]) -> dict[str, Any]:
         return {
             "with": {
                 cls.LOCATION_REF: {
@@ -168,49 +173,49 @@ class InFieldCDMConfigAPI:
             raise ValueError("Cannot apply more than 500 InFieldCDMLocationConfig items at once.")
 
         request_items = [item.as_request_item() for item in items]
-        responses = self._http_client.request_with_retries(
-            ItemsRequest(
+        results = self._http_client.request_items_retries(
+            ItemsRequest2(
                 endpoint_url=self._config.create_api_url(self.ENDPOINT),
                 method="POST",
-                items=request_items,  # type: ignore[arg-type]
+                items=request_items,
             )
         )
-        responses.raise_for_status()
-        return PagedResponse[InstanceResult].model_validate(responses.get_first_body()).items
+        results.raise_for_status()
+        return TypeAdapter(list[InstanceResult]).validate_python(results.get_items())
 
-    def retrieve(self, items: Sequence[NodeIdentifier]) -> list[InFieldCDMLocationConfig]:
+    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 []
-        responses = self._http_client.request_with_retries(
-            SimpleBodyRequest(
+        result = self._http_client.request_single_retries(
+            RequestMessage2(
                 endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
                 method="POST",
                 body_content=self._retrieve_query(items),
             )
         )
-        responses.raise_for_status()
-        parsed_response = QueryResponse[InstanceResponseItem].model_validate(responses.get_first_body())
+        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[NodeIdentifier]:
+    def delete(self, items: Sequence[InFieldCDMLocationConfig]) -> list[TypedNodeIdentifier]:
         if len(items) > 500:
             raise ValueError("Cannot delete more than 500 InFieldCDMLocationConfig items at once.")
 
-        identifiers: Sequence = [item.as_id() for item in items]
-        responses = self._http_client.request_with_retries(
-            ItemsRequest(
+        identifiers = [item.as_id() for item in items]
+        responses = self._http_client.request_items_retries(
+            ItemsRequest2(
                 endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
                 method="POST",
-                items=identifiers,  # type: ignore[arg-type]
+                items=identifiers,
             )
         )
         responses.raise_for_status()
-        return PagedResponse[NodeIdentifier].model_validate(responses.get_first_body()).items
+        return TypeAdapter(list[TypedNodeIdentifier]).validate_python(responses.get_items())
 
     @classmethod
-    def _retrieve_query(cls, items: Sequence[NodeIdentifier]) -> dict[str, Any]:
+    def _retrieve_query(cls, items: Sequence[TypedNodeIdentifier]) -> dict[str, Any]:
         return {
             "with": {
                 cls.LOCATION_REF: {

cognite_toolkit/_cdf_tk/client/api/instances.py

@@ -0,0 +1,139 @@
+from collections.abc import Iterable, Sequence
+from typing import Any, 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, ItemsSuccessResponse2, SuccessResponse2
+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.instance_api import TypedInstanceIdentifier
+
+
+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),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[InstanceResponse]:
+        return PagedResponse[InstanceResponse].model_validate_json(response.body)
+
+    def _validate_response(self, response: SuccessResponse2) -> ResponseItems[TypedInstanceIdentifier]:
+        return ResponseItems[TypedInstanceIdentifier].model_validate_json(response.body)
+
+    def create(self, items: Sequence[InstanceRequest]) -> list[InstanceResponse]:
+        """Create instances in CDF.
+
+        Args:
+            items: List of InstanceRequest objects to create.
+        Returns:
+            List of created InstanceResponse objects.
+        """
+        return self._request_item_response(items, "upsert")
+
+    def retrieve(
+        self, items: Sequence[TypedInstanceIdentifier], source: ViewReference | None = None
+    ) -> list[InstanceResponse]:
+        """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": source.dump()}]} if source else None
+        )
+
+    def delete(self, items: Sequence[TypedInstanceIdentifier]) -> list[TypedInstanceIdentifier]:
+        """Delete instances from CDF.
+
+        Args:
+            items: List of TypedInstanceIdentifier objects to delete.
+        """
+        response_items: list[TypedInstanceIdentifier] = []
+        for response in self._chunk_requests(items, "delete", self._serialize_items):
+            response_items.extend(self._validate_response(response).items)
+        return response_items
+
+    @staticmethod
+    def _create_sort_body(instance_type: Literal["node", "edge"] | None) -> list[dict]:
+        """We sort by space and externalId to get a stable sort order.
+
+        This is also more performant than sorting by using the default sort, which will sort on
+        internal CDF IDs. This will be slow if you have deleted a lot of instances, as they will be counted.
+        By sorting on space and externalId, we avoid this issue.
+        """
+        instance_type = instance_type or "node"
+        return [
+            {
+                "property": [instance_type, "space"],
+                "direction": "ascending",
+            },
+            {
+                "property": [instance_type, "externalId"],
+                "direction": "ascending",
+            },
+        ]
+
+    @classmethod
+    def _create_body(cls, filter: InstanceFilter | None) -> dict[str, Any]:
+        return {
+            **(filter.model_dump(exclude_none=True) if filter else {}),
+            "sort": cls._create_sort_body(filter.instance_type if filter else "node"),
+        }
+
+    def paginate(
+        self,
+        filter: InstanceFilter | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[InstanceResponse]:
+        """Iterate over all instances in CDF.
+
+        Args:
+           filter: InstanceFilter to filter instances.
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of InstanceResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+            body=self._create_body(filter),
+        )
+
+    def iterate(self, filter: InstanceFilter | None = None, limit: int = 100) -> Iterable[list[InstanceResponse]]:
+        """Iterate over all instances in CDF.
+
+        Args:
+            filter: InstanceFilter to filter instances.
+            limit: Maximum number of items to return per page.
+
+        Returns:
+            Iterable of lists of InstanceResponse objects.
+        """
+        return self._iterate(limit=limit, body=self._create_body(filter))
+
+    def list(self, filter: InstanceFilter | None = None, limit: int | None = 100) -> list[InstanceResponse]:
+        """List all instances in CDF.
+
+        Returns:
+            List of InstanceResponse objects.
+        """
+        return self._list(limit=limit, body=self._create_body(filter))

cognite_toolkit/_cdf_tk/client/api/labels.py

@@ -0,0 +1,125 @@
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+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, ItemsSuccessResponse2, SuccessResponse2
+from cognite_toolkit._cdf_tk.client.request_classes.filters import ClassicFilter
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.label import LabelRequest, LabelResponse
+
+
+class LabelsAPI(CDFResourceAPI[ExternalId, LabelRequest, LabelResponse]):
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/labels", item_limit=1000),
+                "retrieve": Endpoint(method="POST", path="/labels/byids", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/labels/delete", item_limit=1000),
+                "list": Endpoint(method="POST", path="/labels/list", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[LabelResponse]:
+        return PagedResponse[LabelResponse].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[ExternalId]:
+        return ResponseItems[ExternalId].model_validate_json(response.body)
+
+    def create(self, items: Sequence[LabelRequest]) -> list[LabelResponse]:
+        """Create labels in CDF.
+
+        Args:
+            items: List of LabelRequest objects to create.
+        Returns:
+            List of created LabelResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> list[LabelResponse]:
+        """Retrieve labels from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+        Returns:
+            List of retrieved LabelResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"ignoreUnknownIds": ignore_unknown_ids}
+        )
+
+    def delete(self, items: Sequence[ExternalId]) -> None:
+        """Delete labels from CDF.
+
+        Args:
+            items: List of ExternalId objects to delete.
+        """
+        self._request_no_response(items, "delete")
+
+    def paginate(
+        self,
+        filter: ClassicFilter | None = None,
+        name: str | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[LabelResponse]:
+        """Iterate over all labels in CDF.
+
+        Args:
+            filter: Filter by data set IDs.
+            name: Filter by label name (prefix match).
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of LabelResponse objects.
+        """
+        body: dict[str, Any] = filter.dump() if filter else {}
+        if name:
+            body["name"] = name
+
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+            body=body,
+        )
+
+    def iterate(
+        self,
+        filter: ClassicFilter | None = None,
+        name: str | None = None,
+        limit: int = 100,
+    ) -> Iterable[list[LabelResponse]]:
+        """Iterate over all labels in CDF.
+
+        Args:
+            filter: Filter by data set IDs.
+            name: Filter by label name (prefix match).
+            limit: Maximum number of items to return per page.
+
+        Returns:
+            Iterable of lists of LabelResponse objects.
+        """
+        body: dict[str, Any] = filter.dump() if filter else {}
+        if name:
+            body["name"] = name
+
+        return self._iterate(
+            limit=limit,
+            body=body,
+        )
+
+    def list(
+        self,
+        limit: int | None = 100,
+    ) -> list[LabelResponse]:
+        """List all labels in CDF.
+
+        Returns:
+            List of LabelResponse objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit/_cdf_tk/client/api/{canvas.py → legacy/canvas.py}

@@ -15,7 +15,8 @@ from cognite.client.data_classes.filters import Filter
 from cognite.client.exceptions import CogniteDuplicatedError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.canvas import (
+from cognite_toolkit._cdf_tk.client.api.legacy.extended_data_modeling import ExtendedInstancesAPI
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.canvas import (
     ANNOTATION_EDGE_TYPE,
     CANVAS_INSTANCE_SPACE,
     CONTAINER_REFERENCE_EDGE_TYPE,
@@ -29,11 +30,9 @@ from cognite_toolkit._cdf_tk.client.data_classes.canvas import (
     IndustrialCanvas,
     IndustrialCanvasApply,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.instances import InstancesApplyResultList
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.instances import InstancesApplyResultList
 from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
 
-from .extended_data_modeling import ExtendedInstancesAPI
-
 
 class CanvasAPI:
     def __init__(self, instance_api: ExtendedInstancesAPI) -> None:
@@ -84,7 +83,7 @@ class IndustrialCanvasAPI:
     def create(self, canvas: IndustrialCanvasApply) -> InstancesApplyResultList:
         instance_ids = canvas.as_instance_ids()
         existing = self._instance_api.retrieve(
-            [node for node in instance_ids if isinstance(node, NodeId)],
+            nodes=[node for node in instance_ids if isinstance(node, NodeId)],
             edges=[edge for edge in instance_ids if isinstance(edge, EdgeId)],
         )
         if existing.nodes or existing.edges:
@@ -134,6 +133,9 @@ class IndustrialCanvasAPI:
 
     @classmethod
     def _retrieve_query(cls, external_id: str) -> query.Query:
+        # The limit for canvas components must be high enough to cover all annotations/references in a canvas.
+        # Using 1000 as a safe upper bound (same as _APPLY_LIMIT).
+        query_limit = 1000
         return query.Query(
             with_={
                 "canvas": query.NodeResultSetExpression(
@@ -143,18 +145,21 @@ class IndustrialCanvasAPI:
                 "solutionTags": query.NodeResultSetExpression(
                     from_="canvas",
                     through=Canvas.get_source().as_property_ref("solutionTags"),
+                    limit=query_limit,
                 ),
                 "annotationEdges": query.EdgeResultSetExpression(
                     from_="canvas",
                     filter=filters.Equals(["edge", "type"], ANNOTATION_EDGE_TYPE.dump()),
                     node_filter=filters.HasData(views=[CanvasAnnotation.get_source()]),
                     direction="outwards",
+                    limit=query_limit,
                 ),
                 "containerReferenceEdges": query.EdgeResultSetExpression(
                     from_="canvas",
                     filter=filters.Equals(["edge", "type"], CONTAINER_REFERENCE_EDGE_TYPE.dump()),
                     node_filter=filters.HasData(views=[ContainerReference.get_source()]),
                     direction="outwards",
+                    limit=query_limit,
                 ),
                 "fdmInstanceContainerReferenceEdges": query.EdgeResultSetExpression(
                     from_="canvas",
@@ -164,11 +169,14 @@ class IndustrialCanvasAPI:
                     ),
                     node_filter=filters.HasData(views=[FdmInstanceContainerReference.get_source()]),
                     direction="outwards",
+                    limit=query_limit,
+                ),
+                "annotations": query.NodeResultSetExpression(from_="annotationEdges", limit=query_limit),
+                "containerReferences": query.NodeResultSetExpression(
+                    from_="containerReferenceEdges", limit=query_limit
                 ),
-                "annotations": query.NodeResultSetExpression(from_="annotationEdges"),
-                "containerReferences": query.NodeResultSetExpression(from_="containerReferenceEdges"),
                 "fdmInstanceContainerReferences": query.NodeResultSetExpression(
-                    from_="fdmInstanceContainerReferenceEdges"
+                    from_="fdmInstanceContainerReferenceEdges", limit=query_limit
                 ),
             },
             select={

cognite_toolkit/_cdf_tk/client/api/{charts.py → legacy/charts.py}

@@ -6,7 +6,7 @@ from cognite.client._api_client import APIClient
 from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.charts import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.charts import (
     Chart,
     ChartList,
     ChartWrite,

cognite_toolkit/_cdf_tk/client/api/{extended_data_modeling.py → legacy/extended_data_modeling.py}

@@ -16,7 +16,7 @@ from cognite.client.utils._concurrency import execute_tasks
 from requests import Response
 
 from cognite_toolkit._cdf_tk.client._constants import DATA_MODELING_MAX_DELETE_WORKERS, DATA_MODELING_MAX_WRITE_WORKERS
-from cognite_toolkit._cdf_tk.client.data_classes.instances import InstancesApplyResultList
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.instances import InstancesApplyResultList
 from cognite_toolkit._cdf_tk.client.utils._concurrency import ToolkitConcurrencySettings
 from cognite_toolkit._cdf_tk.client.utils._http_client import ToolkitRetryTracker
 

cognite_toolkit/_cdf_tk/client/api/{extended_files.py → legacy/extended_files.py}

@@ -9,11 +9,11 @@ from cognite.client.utils._concurrency import execute_tasks
 from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.extended_filemetadata import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.extended_filemetadata import (
     ExtendedFileMetadata,
     ExtendedFileMetadataList,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.pending_instances_ids import PendingInstanceId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.pending_instances_ids import PendingInstanceId
 
 
 class ExtendedFileMetadataAPI(FilesAPI):

cognite_toolkit/_cdf_tk/client/api/{extended_functions.py → legacy/extended_functions.py}

@@ -6,8 +6,8 @@ from cognite.client.utils.useful_types import SequenceNotStr
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client.config import ToolkitClientConfig
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, RequestMessage2
 from cognite_toolkit._cdf_tk.utils.collection import chunker
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, SimpleBodyRequest
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
 
@@ -34,21 +34,20 @@ class ExtendedFunctionsAPI(FunctionsAPI):
 
         Args:
             function (FunctionWrite): The function to create.
-            console (Console | None): The rich console to use for printing warnings.
 
         Returns:
             Function: The created function object.
         """
-        result = self._toolkit_http_client.request_with_retries(
-            message=SimpleBodyRequest(
+        result = self._toolkit_http_client.request_single_retries(
+            message=RequestMessage2(
                 endpoint_url=self._toolkit_config.create_api_url("/functions"),
                 method="POST",
                 body_content={"items": [function.dump(camel_case=True)]},
             )
         )
-        result.raise_for_status()
+        success = result.get_success_or_raise()
         # We assume the API response is one item on a successful creation
-        return Function._load(result.get_first_body()["items"][0], cognite_client=self._cognite_client)  # type: ignore[arg-type,index]
+        return Function._load(success.body_json["items"][0], cognite_client=self._cognite_client)
 
     def delete_with_429_retry(self, external_id: SequenceNotStr[str], ignore_unknown_ids: bool = False) -> None:
         """Delete one or more functions with retry handling for 429 Too Many Requests responses.
@@ -70,11 +69,12 @@ class ExtendedFunctionsAPI(FunctionsAPI):
             }
             if ignore_unknown_ids:
                 body_content["ignoreUnknownIds"] = True
-            self._toolkit_http_client.request_with_retries(
-                message=SimpleBodyRequest(
+            result = self._toolkit_http_client.request_single_retries(
+                message=RequestMessage2(
                     endpoint_url=self._toolkit_config.create_api_url("/functions/delete"),
                     method="POST",
                     body_content=body_content,
                 )
-            ).raise_for_status()
+            )
+            result.get_success_or_raise()
         return None

cognite_toolkit/_cdf_tk/client/api/{extended_raw.py → legacy/extended_raw.py}

@@ -1,6 +1,6 @@
 from cognite.client._api.raw import RawAPI
 
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawProfileResults, RawTable
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawProfileResults, RawTable
 
 
 class ExtendedRawAPI(RawAPI):

cognite_toolkit/_cdf_tk/client/api/{extended_timeseries.py → legacy/extended_timeseries.py}

@@ -13,8 +13,11 @@ from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils._validation import prepare_filter_sort, process_asset_subtree_ids, process_data_set_ids
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.extended_timeseries import ExtendedTimeSeries, ExtendedTimeSeriesList
-from cognite_toolkit._cdf_tk.client.data_classes.pending_instances_ids import PendingInstanceId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.extended_timeseries import (
+    ExtendedTimeSeries,
+    ExtendedTimeSeriesList,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.pending_instances_ids import PendingInstanceId
 
 
 class ExtendedTimeSeriesAPI(TimeSeriesAPI):