cognite-toolkit 0.7.56__py3-none-any.whl → 0.7.58__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,33 +1,33 @@
 from ._client import HTTPClient
-from ._data_classes2 import (
-    ErrorDetails2,
-    FailedRequest2,
-    FailedResponse2,
-    HTTPResult2,
-    RequestMessage2,
-    SuccessResponse2,
+from ._data_classes import (
+    ErrorDetails,
+    FailedRequest,
+    FailedResponse,
+    HTTPResult,
+    RequestMessage,
+    SuccessResponse,
 )
 from ._exception import ToolkitAPIError
 from ._item_classes import (
-    ItemsFailedRequest2,
-    ItemsFailedResponse2,
-    ItemsRequest2,
-    ItemsResultMessage2,
-    ItemsSuccessResponse2,
+    ItemsFailedRequest,
+    ItemsFailedResponse,
+    ItemsRequest,
+    ItemsResultMessage,
+    ItemsSuccessResponse,
 )
 
 __all__ = [
-    "ErrorDetails2",
-    "FailedRequest2",
-    "FailedResponse2",
+    "ErrorDetails",
+    "FailedRequest",
+    "FailedResponse",
     "HTTPClient",
-    "HTTPResult2",
-    "ItemsFailedRequest2",
-    "ItemsFailedResponse2",
-    "ItemsRequest2",
-    "ItemsResultMessage2",
-    "ItemsSuccessResponse2",
-    "RequestMessage2",
-    "SuccessResponse2",
+    "HTTPResult",
+    "ItemsFailedRequest",
+    "ItemsFailedResponse",
+    "ItemsRequest",
+    "ItemsResultMessage",
+    "ItemsSuccessResponse",
+    "RequestMessage",
+    "SuccessResponse",
     "ToolkitAPIError",
 ]

cognite_toolkit/_cdf_tk/client/http_client/_client.py

@@ -9,22 +9,22 @@ import httpx
 from cognite.client import global_config
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk.client.http_client._data_classes2 import (
+from cognite_toolkit._cdf_tk.client.http_client._data_classes 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
@@ -136,13 +136,13 @@ class HTTPClient:
         backoff_time = 0.5 * (2**attempts)
         return min(backoff_time, global_config.max_retry_backoff) * random.uniform(0, 1.0)
 
-    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:
-            RequestMessage2 | HTTPResult2: The response message.
+            RequestMessage2 | HTTPResult: The response message.
         """
         try:
             response = self._make_request(message)
@@ -151,7 +151,7 @@ class HTTPClient:
             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
@@ -161,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.
         """
@@ -170,9 +170,9 @@ 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)}")
@@ -195,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,
@@ -208,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:
@@ -232,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
@@ -243,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))
@@ -252,20 +250,20 @@ 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.",
                 )
@@ -277,7 +275,7 @@ class HTTPClient:
             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
@@ -287,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:
@@ -301,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)}")
@@ -311,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,
@@ -331,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
@@ -345,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
@@ -367,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,
                 )
@@ -381,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,
                 )

cognite_toolkit/_cdf_tk/client/http_client/{_data_classes2.py → _data_classes.py}

@@ -10,60 +10,60 @@ from cognite_toolkit._cdf_tk.client.http_client._exception import ToolkitAPIErro
 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
+    from cognite_toolkit._cdf_tk.client.http_client._item_classes import ItemsResultMessage
 
 
-class HTTPResult2(BaseModel):
-    def get_success_or_raise(self) -> "SuccessResponse2":
+class HTTPResult(BaseModel):
+    def get_success_or_raise(self) -> "SuccessResponse":
         """Raises an exception if any response in the list indicates a failure."""
-        if isinstance(self, SuccessResponse2):
+        if isinstance(self, SuccessResponse):
             return self
-        elif isinstance(self, FailedResponse2):
+        elif isinstance(self, FailedResponse):
             raise ToolkitAPIError(
                 f"Request failed with status code {self.status_code}: {self.error.message}",
                 missing=self.error.missing,  # type: ignore[arg-type]
                 duplicated=self.error.duplicated,  # type: ignore[arg-type]
             )
-        elif isinstance(self, FailedRequest2):
+        elif isinstance(self, FailedRequest):
             raise ToolkitAPIError(f"Request failed with error: {self.error}")
         else:
             raise ToolkitAPIError("Unknown HTTPResult2 type")
 
-    def as_item_response(self, item_id: str) -> "ItemsResultMessage2":
+    def as_item_response(self, item_id: str) -> "ItemsResultMessage":
         # Avoid circular import
         from cognite_toolkit._cdf_tk.client.http_client._item_classes import (
-            ItemsFailedRequest2,
-            ItemsFailedResponse2,
-            ItemsSuccessResponse2,
+            ItemsFailedRequest,
+            ItemsFailedResponse,
+            ItemsSuccessResponse,
         )
 
-        if isinstance(self, SuccessResponse2):
-            return ItemsSuccessResponse2(
+        if isinstance(self, SuccessResponse):
+            return ItemsSuccessResponse(
                 status_code=self.status_code, content=self.content, ids=[item_id], body=self.body
             )
-        elif isinstance(self, FailedResponse2):
-            return ItemsFailedResponse2(
+        elif isinstance(self, FailedResponse):
+            return ItemsFailedResponse(
                 status_code=self.status_code,
                 ids=[item_id],
                 body=self.body,
-                error=ErrorDetails2(
+                error=ErrorDetails(
                     code=self.error.code,
                     message=self.error.message,
                     missing=self.error.missing,
                     duplicated=self.error.duplicated,
                 ),
             )
-        elif isinstance(self, FailedRequest2):
-            return ItemsFailedRequest2(ids=[item_id], error_message=self.error)
+        elif isinstance(self, FailedRequest):
+            return ItemsFailedRequest(ids=[item_id], error_message=self.error)
         else:
             raise ToolkitAPIError(f"Unknown {type(self).__name__} type")
 
 
-class FailedRequest2(HTTPResult2):
+class FailedRequest(HTTPResult):
     error: str
 
 
-class SuccessResponse2(HTTPResult2):
+class SuccessResponse(HTTPResult):
     status_code: int
     body: str
     content: bytes
@@ -74,7 +74,7 @@ class SuccessResponse2(HTTPResult2):
         return TypeAdapter(dict[str, JsonValue]).validate_json(self.body)
 
 
-class ErrorDetails2(BaseModel):
+class ErrorDetails(BaseModel):
     """This is the expected structure of error details in the CDF API"""
 
     code: int
@@ -84,19 +84,19 @@ class ErrorDetails2(BaseModel):
     is_auto_retryable: bool | None = None
 
     @classmethod
-    def from_response(cls, response: httpx.Response) -> "ErrorDetails2":
+    def from_response(cls, response: httpx.Response) -> "ErrorDetails":
         """Populate the error details from a httpx response."""
         try:
-            res = TypeAdapter(dict[Literal["error"], ErrorDetails2]).validate_json(response.text)
+            res = TypeAdapter(dict[Literal["error"], ErrorDetails]).validate_json(response.text)
         except ValueError:
             return cls(code=response.status_code, message=response.text)
         return res["error"]
 
 
-class FailedResponse2(HTTPResult2):
+class FailedResponse(HTTPResult):
     status_code: int
     body: str
-    error: ErrorDetails2
+    error: ErrorDetails
 
 
 class BaseRequestMessage(BaseModel, ABC):
@@ -122,7 +122,7 @@ class BaseRequestMessage(BaseModel, ABC):
     def content(self) -> str | bytes | None: ...
 
 
-class RequestMessage2(BaseRequestMessage):
+class RequestMessage(BaseRequestMessage):
     data_content: bytes | None = None
     body_content: dict[str, JsonValue] | None = None
 

cognite_toolkit/_cdf_tk/client/http_client/_item_classes.py

@@ -9,32 +9,32 @@ from cognite.client import global_config
 from pydantic import BaseModel, ConfigDict, Field, JsonValue
 
 from cognite_toolkit._cdf_tk.client._resource_base import RequestItem
-from cognite_toolkit._cdf_tk.client.http_client._data_classes2 import (
+from cognite_toolkit._cdf_tk.client.http_client._data_classes import (
     _BODY_SERIALIZER,
     BaseRequestMessage,
-    ErrorDetails2,
+    ErrorDetails,
 )
 from cognite_toolkit._cdf_tk.client.http_client._exception import ToolkitAPIError
 from cognite_toolkit._cdf_tk.client.http_client._tracker import ItemsRequestTracker
 
 
-class ItemsResultMessage2(BaseModel):
+class ItemsResultMessage(BaseModel):
     ids: list[str]
 
 
-class ItemsFailedRequest2(ItemsResultMessage2):
+class ItemsFailedRequest(ItemsResultMessage):
     error_message: str
 
 
-class ItemsSuccessResponse2(ItemsResultMessage2):
+class ItemsSuccessResponse(ItemsResultMessage):
     status_code: int
     body: str
     content: bytes
 
 
-class ItemsFailedResponse2(ItemsResultMessage2):
+class ItemsFailedResponse(ItemsResultMessage):
     status_code: int
-    error: ErrorDetails2
+    error: ErrorDetails
     body: str
 
 
@@ -44,7 +44,7 @@ def _set_default_tracker(data: dict[str, Any]) -> ItemsRequestTracker:
     return data["tracker"]
 
 
-class ItemsRequest2(BaseRequestMessage):
+class ItemsRequest(BaseRequestMessage):
     model_config = ConfigDict(arbitrary_types_allowed=True)
     items: Sequence[RequestItem]
     extra_body_fields: dict[str, JsonValue] | None = None
@@ -61,13 +61,13 @@ class ItemsRequest2(BaseRequestMessage):
             return gzip.compress(res)
         return res
 
-    def split(self, status_attempts: int) -> list["ItemsRequest2"]:
+    def split(self, status_attempts: int) -> list["ItemsRequest"]:
         """Split the request into multiple requests with a single item each."""
         mid = len(self.items) // 2
         if mid == 0:
             return [self]
         self.tracker.register_failure()
-        messages: list[ItemsRequest2] = []
+        messages: list[ItemsRequest] = []
         for part in (self.items[:mid], self.items[mid:]):
             new_request = self.model_copy(update={"items": part, "status_attempt": status_attempts})
             new_request.tracker = self.tracker
@@ -79,14 +79,14 @@ class ItemResponse(BaseModel):
     items: list[dict[str, JsonValue]]
 
 
-class ItemsResultList(UserList[ItemsResultMessage2]):
-    def __init__(self, collection: Sequence[ItemsResultMessage2] | None = None) -> None:
+class ItemsResultList(UserList[ItemsResultMessage]):
+    def __init__(self, collection: Sequence[ItemsResultMessage] | None = None) -> None:
         super().__init__(collection or [])
 
     def raise_for_status(self) -> None:
         """Raises an exception if any response in the list indicates a failure."""
-        failed_responses = [resp for resp in self.data if isinstance(resp, ItemsFailedResponse2)]
-        failed_requests = [resp for resp in self.data if isinstance(resp, ItemsFailedRequest2)]
+        failed_responses = [resp for resp in self.data if isinstance(resp, ItemsFailedResponse)]
+        failed_requests = [resp for resp in self.data if isinstance(resp, ItemsFailedRequest)]
         if not failed_responses and not failed_requests:
             return
         error_messages = "; ".join(f"Status {err.status_code}: {err.error.message}" for err in failed_responses)
@@ -104,7 +104,7 @@ class ItemsResultList(UserList[ItemsResultMessage2]):
             bool: True if there are any failed responses or requests, False otherwise.
         """
         for resp in self.data:
-            if isinstance(resp, ItemsFailedResponse2 | ItemsFailedRequest2):
+            if isinstance(resp, ItemsFailedResponse | ItemsFailedRequest):
                 return True
         return False
 
@@ -112,7 +112,7 @@ class ItemsResultList(UserList[ItemsResultMessage2]):
         """Get the items from all successful responses."""
         items: list[dict[str, JsonValue]] = []
         for resp in self.data:
-            if isinstance(resp, ItemsSuccessResponse2):
+            if isinstance(resp, ItemsSuccessResponse):
                 body_json = ItemResponse.model_validate_json(resp.body)
                 items.extend(body_json.items)
         return items

cognite_toolkit/_cdf_tk/client/resource_classes/project.py

@@ -0,0 +1,30 @@
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject
+
+
+class UserProfilesConfiguration(BaseModelObject):
+    enabled: bool
+
+
+class Claim(BaseModelObject):
+    claim_name: str
+
+
+class OidcConfiguration(BaseModelObject):
+    jwks_url: str
+    token_url: str | None = None
+    issuer: str
+    audience: str
+    skew_ms: int | None = None
+    access_claims: list[Claim]
+    scope_claims: list[Claim]
+    log_claims: list[Claim]
+    is_group_callback_enabled: bool | None = None
+    identity_provider_scope: str | None = None
+
+
+class OrganizationResponse(BaseModelObject):
+    name: str
+    url_name: str
+    organization: str
+    user_profiles_configuration: UserProfilesConfiguration
+    oidc_configuration: OidcConfiguration | None = None