cognite-toolkit 0.7.48__tar.gz → 0.7.50__tar.gz

{cognite_toolkit-0.7.48 → cognite_toolkit-0.7.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.48
+Version: 0.7.50
 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.48 → cognite_toolkit-0.7.50}/cognite_toolkit/_cdf_tk/builders/_function.py

@@ -1,5 +1,8 @@
 import shutil
+import time
 from collections.abc import Callable, Iterable, Sequence
+from pathlib import Path
+from typing import Any
 
 from cognite_toolkit._cdf_tk.builders import Builder
 from cognite_toolkit._cdf_tk.cruds import FunctionCRUD
@@ -10,21 +13,74 @@ from cognite_toolkit._cdf_tk.data_classes import (
     ModuleLocation,
 )
 from cognite_toolkit._cdf_tk.exceptions import ToolkitFileExistsError, ToolkitNotADirectoryError, ToolkitValueError
+from cognite_toolkit._cdf_tk.feature_flags import Flags
 from cognite_toolkit._cdf_tk.tk_warnings import (
     FileReadWarning,
+    FunctionRequirementsValidationWarning,
     HighSeverityWarning,
     LowSeverityWarning,
     MediumSeverityWarning,
     ToolkitWarning,
     WarningList,
 )
+from cognite_toolkit._cdf_tk.utils import validate_requirements_with_pip
+
+# Maximum number of error lines to display in warnings
+_MAX_ERROR_LINES = 3
 
 
 class FunctionBuilder(Builder):
     _resource_folder = FunctionCRUD.folder_name
 
+    def __init__(self, build_dir: Path, warn: Callable[[ToolkitWarning], None]) -> None:
+        super().__init__(build_dir, warn=warn)
+        # Metrics for telemetry
+        self.validation_count = 0
+        self.validation_failures = 0
+        self.validation_credential_errors = 0
+        self.validation_time_ms = 0
+
+    def _validate_function_requirements(
+        self,
+        requirements_txt: Path,
+        raw_function: dict[str, Any],
+        filepath: Path,
+        external_id: str,
+    ) -> FunctionRequirementsValidationWarning | None:
+        """Validate function requirements.txt using pip dry-run."""
+        start_time = time.time()
+        validation_result = validate_requirements_with_pip(
+            requirements_txt_path=requirements_txt,
+            index_url=raw_function.get("indexUrl"),
+            extra_index_urls=raw_function.get("extraIndexUrls"),
+        )
+        elapsed_ms = int((time.time() - start_time) * 1000)
+        self.validation_count += 1
+        self.validation_time_ms += elapsed_ms
+
+        if validation_result.success:
+            return None
+
+        self.validation_failures += 1
+        if validation_result.is_credential_error:
+            self.validation_credential_errors += 1
+
+        error_detail = validation_result.error_message or "Unknown error"
+        relevant_lines = [line for line in error_detail.strip().split("\n") if line.strip()][-_MAX_ERROR_LINES:]
+        error_detail = "\n      ".join(relevant_lines)
+
+        return FunctionRequirementsValidationWarning(
+            filepath=filepath,
+            function_external_id=external_id,
+            error_details=error_detail,
+            is_credential_error=validation_result.is_credential_error,
+        )
+
     def build(
-        self, source_files: list[BuildSourceFile], module: ModuleLocation, console: Callable[[str], None] | None = None
+        self,
+        source_files: list[BuildSourceFile],
+        module: ModuleLocation,
+        console: Callable[[str], None] | None = None,
     ) -> Iterable[BuildDestinationFile | Sequence[ToolkitWarning]]:
         for source_file in source_files:
             if source_file.loaded is None:
@@ -55,7 +111,9 @@ class FunctionBuilder(Builder):
             )
 
     def validate_directory(
-        self, built_resources: BuiltResourceList, module: ModuleLocation
+        self,
+        built_resources: BuiltResourceList,
+        module: ModuleLocation,
     ) -> WarningList[ToolkitWarning]:
         warnings = WarningList[ToolkitWarning]()
         has_config_files = any(resource.kind == FunctionCRUD.kind for resource in built_resources)
@@ -74,7 +132,7 @@ class FunctionBuilder(Builder):
                     f"was not found in {required_location.as_posix()!r}. "
                     f"The file {yaml_source_path.as_posix()!r} is currently "
                     f"considered part of the Function's artifacts and "
-                    f"will not be processed by the Toolkit."
+                    f"will not be processed by the Toolkit.",
                 )
                 warnings.append(warning)
         return warnings
@@ -93,28 +151,42 @@ class FunctionBuilder(Builder):
                 warnings.append(
                     HighSeverityWarning(
                         f"Function in {source_file.source.path.as_posix()!r} has no externalId defined. "
-                        f"This is used to match the function to the function directory."
-                    )
+                        f"This is used to match the function to the function directory.",
+                    ),
                 )
                 continue
             if not function_path:
                 warnings.append(
                     MediumSeverityWarning(
-                        f"Function {external_id} in {source_file.source.path.as_posix()!r} has no function_path defined."
-                    )
+                        f"Function {external_id} in {source_file.source.path.as_posix()!r} has no function_path defined.",
+                    ),
                 )
 
             function_directory = source_file.source.path.with_name(external_id)
 
             if not function_directory.is_dir():
                 raise ToolkitNotADirectoryError(
-                    f"Function directory not found for externalId {external_id} defined in {source_file.source.path.as_posix()!r}."
+                    f"Function directory not found for externalId {external_id} defined in {source_file.source.path.as_posix()!r}.",
+                )
+
+            # Validate requirements.txt if present and feature is enabled
+            if (
+                Flags.FUNCTION_REQUIREMENTS_VALIDATION.is_enabled()
+                and (requirements_txt := function_directory / "requirements.txt").exists()
+            ):
+                warning = self._validate_function_requirements(
+                    requirements_txt,
+                    raw_function,
+                    source_file.source.path,
+                    external_id,
                 )
+                if warning:
+                    warnings.append(warning)
 
             destination = self.build_dir / self.resource_folder / external_id
             if destination.exists():
                 raise ToolkitFileExistsError(
-                    f"Function {external_id!r} is duplicated. If this is unexpected, ensure you have a clean build directory."
+                    f"Function {external_id!r} is duplicated. If this is unexpected, ensure you have a clean build directory.",
                 )
             shutil.copytree(function_directory, destination, ignore=shutil.ignore_patterns("__pycache__"))
 

cognite_toolkit-0.7.48/cognite_toolkit/_cdf_tk/client/resource_classes/base.py → cognite_toolkit-0.7.50/cognite_toolkit/_cdf_tk/client/_resource_base.py

@@ -1,3 +1,5 @@
+"""Base classes for Cognite Client resources and identifiers."""
+
 import sys
 import types
 from abc import ABC, abstractmethod
@@ -43,11 +45,25 @@ class BaseModelObject(BaseModel):
         return cls.model_validate(resource, by_alias=True)
 
 
-class Identifier(BaseModelObject):
+class RequestItem(BaseModelObject, ABC):
+    """A request item is any object that can be sent to the CDF API as part of a request."""
+
+    def __str__(self) -> str:
+        """All request items must implement a string representation.
+
+        This is used to identify the item in error messages and logs.
+        """
+        raise NotImplementedError()
+
+
+T_RequestItem = TypeVar("T_RequestItem", bound=RequestItem)
+
+
+class Identifier(RequestItem):
     """Base class for all identifier objects typically
-    {"externalId": "..."}, {"id": ...}, {"space": "...", "externalId: }."""
+    {"externalId": "..."}, {"id": ...}, {"space": "...", "externalId: "..."}."""
 
-    model_config = ConfigDict(alias_generator=to_camel, extra="ignore", populate_by_name=True, frozen=True)
+    model_config = ConfigDict(alias_generator=to_camel, extra="ignore", frozen=True)
 
     def dump(self, camel_case: bool = True, exclude_extra: bool = False) -> dict[str, Any]:
         """Dump the resource to a dictionary.
@@ -56,14 +72,11 @@ class Identifier(BaseModelObject):
         """
         return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=True)
 
-    def __str__(self) -> str:
-        raise NotImplementedError()
-
 
 T_Identifier = TypeVar("T_Identifier", bound=Identifier)
 
 
-class RequestResource(BaseModelObject, ABC):
+class RequestResource(RequestItem, ABC):
     @abstractmethod
     def as_id(self) -> Identifier:
         raise NotImplementedError()
@@ -75,7 +88,7 @@ class RequestResource(BaseModelObject, ABC):
 T_RequestResource = TypeVar("T_RequestResource", bound=RequestResource)
 
 
-class RequestUpdateable(RequestResource, ABC):
+class UpdatableRequestResource(RequestResource, ABC):
     container_fields: ClassVar[frozenset[str]] = frozenset()
     non_nullable_fields: ClassVar[frozenset[str]] = frozenset()
 
@@ -144,6 +157,8 @@ class ResponseResource(BaseModelObject, Generic[T_RequestResource], ABC):
         """Convert the response resource to a request resource."""
         raise NotImplementedError()
 
+    # Todo remove when CogniteClient data classes are completely removed from the codebase
+    # and we only use the pydantic resource classes instead.from
     def as_write(self) -> T_RequestResource:
         """Alias for as_request_resource to match protocol signature."""
         return self.as_request_resource()
@@ -151,10 +166,10 @@ class ResponseResource(BaseModelObject, Generic[T_RequestResource], ABC):
 
 T_ResponseResource = TypeVar("T_ResponseResource", bound=ResponseResource)
 
+# Todo: Delete this class and use list[T_Resource] directly
 T_Resource = TypeVar("T_Resource", bound=RequestResource | ResponseResource)
 
 
-# Todo: Delete this class and use list[T_Resource] directly
 class BaseResourceList(UserList[T_Resource]):
     """Base class for resource lists."""
 

{cognite_toolkit-0.7.48 → cognite_toolkit-0.7.50}/cognite_toolkit/_cdf_tk/client/cdf_client/api.py

@@ -9,10 +9,17 @@ from collections import defaultdict
 from collections.abc import Callable, Iterable, Sequence
 from dataclasses import dataclass
 from functools import partial
-from typing import Any, Generic, Literal, TypeAlias, TypeVar
+from typing import Any, Generic, Literal, TypeAlias
 
-from pydantic import BaseModel, JsonValue
+from pydantic import JsonValue
 
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    RequestItem,
+    T_Identifier,
+    T_RequestResource,
+    T_ResponseResource,
+    UpdatableRequestResource,
+)
 from cognite_toolkit._cdf_tk.client.http_client import (
     HTTPClient,
     ItemsRequest2,
@@ -20,18 +27,10 @@ from cognite_toolkit._cdf_tk.client.http_client import (
     RequestMessage2,
     SuccessResponse2,
 )
-from cognite_toolkit._cdf_tk.client.resource_classes.base import (
-    RequestUpdateable,
-    T_Identifier,
-    T_RequestResource,
-    T_ResponseResource,
-)
 from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
 
 from .responses import PagedResponse
 
-_T_BaseModel = TypeVar("_T_BaseModel", bound=BaseModel)
-
 
 @dataclass(frozen=True)
 class Endpoint:
@@ -67,13 +66,13 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         self._disable_gzip = disable_gzip
 
     @classmethod
-    def _serialize_items(cls, items: Sequence[BaseModel]) -> list[dict[str, JsonValue]]:
+    def _serialize_items(cls, items: Sequence[RequestItem]) -> list[dict[str, JsonValue]]:
         """Serialize reference objects to JSON-compatible dicts."""
-        return [item.model_dump(mode="json", by_alias=True) for item in items]
+        return [item.dump() for item in items]
 
     @classmethod
     def _serialize_updates(
-        cls, items: Sequence[RequestUpdateable], mode: Literal["patch", "replace"]
+        cls, items: Sequence[UpdatableRequestResource], mode: Literal["patch", "replace"]
     ) -> list[dict[str, JsonValue]]:
         """Serialize updateable objects to JSON-compatible dicts."""
         return [item.as_update(mode=mode) for item in items]
@@ -90,7 +89,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         return self._http_client.config.create_api_url(path)
 
     def _update(
-        self, items: Sequence[RequestUpdateable], mode: Literal["patch", "replace"]
+        self, items: Sequence[UpdatableRequestResource], mode: Literal["patch", "replace"]
     ) -> list[T_ResponseResource]:
         """Update resources in chunks."""
         response_items: list[T_ResponseResource] = []
@@ -102,7 +101,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
 
     def _request_item_response(
         self,
-        items: Sequence[BaseModel],
+        items: Sequence[RequestItem],
         method: APIMethod,
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
@@ -115,7 +114,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
 
     def _request_no_response(
         self,
-        items: Sequence[BaseModel],
+        items: Sequence[RequestItem],
         method: APIMethod,
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
@@ -126,9 +125,9 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
 
     def _chunk_requests(
         self,
-        items: Sequence[_T_BaseModel],
+        items: Sequence[RequestItem],
         method: APIMethod,
-        serialization: Callable[[Sequence[_T_BaseModel]], list[dict[str, JsonValue]]],
+        serialization: Callable[[Sequence[RequestItem]], list[dict[str, JsonValue]]],
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
         endpoint_path: str | None = None,
@@ -163,7 +162,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
 
     def _request_item_split_retries(
         self,
-        items: Sequence[_T_BaseModel],
+        items: Sequence[RequestItem],
         method: APIMethod,
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
@@ -188,7 +187,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
 
     def _request_item_split_retries_no_response(
         self,
-        items: Sequence[_T_BaseModel],
+        items: Sequence[RequestItem],
         method: APIMethod,
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
@@ -209,7 +208,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
 
     def _chunk_requests_items_split_retries(
         self,
-        items: Sequence[_T_BaseModel],
+        items: Sequence[RequestItem],
         method: APIMethod,
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
@@ -258,10 +257,10 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
 
     @classmethod
     def _group_items_by_text_field(
-        cls, items: Sequence[_T_BaseModel], *field_names: str
-    ) -> dict[tuple[str, ...], list[_T_BaseModel]]:
+        cls, items: Sequence[RequestItem], *field_names: str
+    ) -> dict[tuple[str, ...], list[RequestItem]]:
         """Group items by a text field."""
-        grouped_items: dict[tuple[str, ...], list[_T_BaseModel]] = defaultdict(list)
+        grouped_items: dict[tuple[str, ...], list[RequestItem]] = defaultdict(list)
         for item in items:
             key = tuple(str(getattr(item, field_name)) for field_name in field_names)
             grouped_items[key].append(item)

{cognite_toolkit-0.7.48 → cognite_toolkit-0.7.50}/cognite_toolkit/_cdf_tk/client/http_client/__init__.py

@@ -24,15 +24,17 @@ from ._data_classes2 import (
     FailedRequest2,
     FailedResponse2,
     HTTPResult2,
+    RequestMessage2,
+    SuccessResponse2,
+)
+from ._exception import ToolkitAPIError
+from ._item_classes import (
     ItemsFailedRequest2,
     ItemsFailedResponse2,
     ItemsRequest2,
     ItemsResultMessage2,
     ItemsSuccessResponse2,
-    RequestMessage2,
-    SuccessResponse2,
 )
-from ._exception import ToolkitAPIError
 
 __all__ = [
     "T_COVARIANT_ID",

{cognite_toolkit-0.7.48 → cognite_toolkit-0.7.50}/cognite_toolkit/_cdf_tk/client/http_client/_client.py

@@ -27,14 +27,16 @@ from cognite_toolkit._cdf_tk.client.http_client._data_classes2 import (
     FailedRequest2,
     FailedResponse2,
     HTTPResult2,
+    RequestMessage2,
+    SuccessResponse2,
+)
+from cognite_toolkit._cdf_tk.client.http_client._item_classes import (
     ItemsFailedRequest2,
     ItemsFailedResponse2,
     ItemsRequest2,
     ItemsResultList,
     ItemsResultMessage2,
     ItemsSuccessResponse2,
-    RequestMessage2,
-    SuccessResponse2,
 )
 from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
 from cognite_toolkit._cdf_tk.utils.auxiliary import get_current_toolkit_version, get_user_agent

cognite_toolkit-0.7.50/cognite_toolkit/_cdf_tk/client/http_client/_data_classes2.py

@@ -0,0 +1,118 @@
+import gzip
+from abc import ABC, abstractmethod
+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._exception import ToolkitAPIError
+from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
+
+
+class HTTPResult2(BaseModel):
+    def get_success_or_raise(self) -> "SuccessResponse2":
+        """Raises an exception if any response in the list indicates a failure."""
+        if isinstance(self, SuccessResponse2):
+            return self
+        elif isinstance(self, FailedResponse2):
+            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):
+            raise ToolkitAPIError(f"Request failed with error: {self.error}")
+        else:
+            raise ToolkitAPIError("Unknown HTTPResult2 type")
+
+
+class FailedRequest2(HTTPResult2):
+    error: str
+
+
+class SuccessResponse2(HTTPResult2):
+    status_code: int
+    body: str
+    content: bytes
+
+    @property
+    def body_json(self) -> dict[str, Any]:
+        """Parse the response body as JSON."""
+        return TypeAdapter(dict[str, JsonValue]).validate_json(self.body)
+
+
+class ErrorDetails2(BaseModel):
+    """This is the expected structure of error details in the CDF API"""
+
+    code: int
+    message: str
+    missing: list[JsonValue] | None = None
+    duplicated: list[JsonValue] | None = None
+    is_auto_retryable: bool | None = None
+
+    @classmethod
+    def from_response(cls, response: httpx.Response) -> "ErrorDetails2":
+        """Populate the error details from a httpx response."""
+        try:
+            res = TypeAdapter(dict[Literal["error"], ErrorDetails2]).validate_json(response.text)
+        except ValueError:
+            return cls(code=response.status_code, message=response.text)
+        return res["error"]
+
+
+class FailedResponse2(HTTPResult2):
+    status_code: int
+    body: str
+    error: ErrorDetails2
+
+
+class BaseRequestMessage(BaseModel, ABC):
+    endpoint_url: str
+    method: Literal["GET", "POST", "PATCH", "DELETE", "PUT"]
+    connect_attempt: int = 0
+    read_attempt: int = 0
+    status_attempt: int = 0
+    api_version: str | None = None
+    disable_gzip: bool = False
+    content_type: str = "application/json"
+    accept: str = "application/json"
+
+    parameters: dict[str, PrimitiveType] | None = None
+
+    @property
+    def total_attempts(self) -> int:
+        return self.connect_attempt + self.read_attempt + self.status_attempt
+
+    @property
+    @abstractmethod
+    def content(self) -> str | bytes | None: ...
+
+
+class RequestMessage2(BaseRequestMessage):
+    data_content: bytes | None = None
+    body_content: dict[str, JsonValue] | None = None
+
+    @model_validator(mode="before")
+    def check_data_or_body(cls, values: dict[str, Any]) -> dict[str, Any]:
+        if values.get("data_content") is not None and values.get("body_content") is not None:
+            raise ValueError("Only one of data_content or body_content can be set.")
+        return values
+
+    @property
+    def content(self) -> str | bytes | None:
+        data: str | bytes | None = None
+        if self.data_content is not None:
+            data = self.data_content
+            if not global_config.disable_gzip and not self.disable_gzip:
+                data = gzip.compress(data)
+        elif self.body_content is not None:
+            # We serialize using pydantic instead of json.dumps. This is because pydantic is faster
+            # and handles more complex types such as datetime, float('nan'), etc.
+            data = _BODY_SERIALIZER.dump_json(self.body_content)
+            if not global_config.disable_gzip and not self.disable_gzip and isinstance(data, bytes):
+                data = gzip.compress(data)
+        return data
+
+
+_BODY_SERIALIZER = TypeAdapter(dict[str, JsonValue])

cognite_toolkit-0.7.50/cognite_toolkit/_cdf_tk/client/http_client/_item_classes.py

@@ -0,0 +1,118 @@
+"""Data classes for handling item-based requests and responses in the Cognite Toolkit HTTP client."""
+
+import gzip
+from collections import UserList
+from collections.abc import Sequence
+from typing import Any
+
+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 (
+    _BODY_SERIALIZER,
+    BaseRequestMessage,
+    ErrorDetails2,
+)
+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):
+    ids: list[str]
+
+
+class ItemsFailedRequest2(ItemsResultMessage2):
+    error_message: str
+
+
+class ItemsSuccessResponse2(ItemsResultMessage2):
+    status_code: int
+    body: str
+    content: bytes
+
+
+class ItemsFailedResponse2(ItemsResultMessage2):
+    status_code: int
+    error: ErrorDetails2
+    body: str
+
+
+def _set_default_tracker(data: dict[str, Any]) -> ItemsRequestTracker:
+    if "tracker" not in data or data["tracker"] is None:
+        return ItemsRequestTracker(data.get("max_failures_before_abort", 50))
+    return data["tracker"]
+
+
+class ItemsRequest2(BaseRequestMessage):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    items: Sequence[RequestItem]
+    extra_body_fields: dict[str, JsonValue] | None = None
+    max_failures_before_abort: int = 50
+    tracker: ItemsRequestTracker = Field(init=False, default_factory=_set_default_tracker, exclude=True)
+
+    @property
+    def content(self) -> str | bytes | None:
+        body: dict[str, JsonValue] = {"items": [item.dump(camel_case=True) for item in self.items]}
+        if self.extra_body_fields:
+            body.update(self.extra_body_fields)
+        res = _BODY_SERIALIZER.dump_json(body)
+        if not global_config.disable_gzip and not self.disable_gzip and isinstance(res, bytes):
+            return gzip.compress(res)
+        return res
+
+    def split(self, status_attempts: int) -> list["ItemsRequest2"]:
+        """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] = []
+        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
+            messages.append(new_request)
+        return messages
+
+
+class ItemResponse(BaseModel):
+    items: list[dict[str, JsonValue]]
+
+
+class ItemsResultList(UserList[ItemsResultMessage2]):
+    def __init__(self, collection: Sequence[ItemsResultMessage2] | 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)]
+        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)
+        if failed_requests:
+            if error_messages:
+                error_messages += "; "
+            error_messages += "; ".join(f"Request error: {err.error_message}" for err in failed_requests)
+        raise ToolkitAPIError(f"One or more requests failed: {error_messages}")
+
+    @property
+    def has_failed(self) -> bool:
+        """Indicates whether any response in the list indicates a failure.
+
+        Returns:
+            bool: True if there are any failed responses or requests, False otherwise.
+        """
+        for resp in self.data:
+            if isinstance(resp, ItemsFailedResponse2 | ItemsFailedRequest2):
+                return True
+        return False
+
+    def get_items(self) -> list[dict[str, JsonValue]]:
+        """Get the items from all successful responses."""
+        items: list[dict[str, JsonValue]] = []
+        for resp in self.data:
+            if isinstance(resp, ItemsSuccessResponse2):
+                body_json = ItemResponse.model_validate_json(resp.body)
+                items.extend(body_json.items)
+        return items

{cognite_toolkit-0.7.48 → cognite_toolkit-0.7.50}/cognite_toolkit/_cdf_tk/client/resource_classes/agent.py

@@ -2,7 +2,7 @@ from typing import Annotated, Any, Literal
 
 from pydantic import BeforeValidator, Field
 
-from cognite_toolkit._cdf_tk.client.resource_classes.base import BaseModelObject, RequestResource, ResponseResource
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource, ResponseResource
 
 from .identifiers import ExternalId
 

{cognite_toolkit-0.7.48 → cognite_toolkit-0.7.50}/cognite_toolkit/_cdf_tk/client/resource_classes/annotation.py

@@ -2,7 +2,7 @@ from typing import Any, Literal, TypeAlias
 
 from pydantic import Field, JsonValue
 
-from cognite_toolkit._cdf_tk.client.resource_classes.base import BaseModelObject, RequestUpdateable, ResponseResource
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, ResponseResource, UpdatableRequestResource
 
 from .identifiers import InternalId
 
@@ -39,7 +39,7 @@ class Annotation(BaseModelObject):
     status: AnnotationStatus
 
 
-class AnnotationRequest(Annotation, RequestUpdateable):
+class AnnotationRequest(Annotation, UpdatableRequestResource):
     """Request data class for annotations."""
 
     # The 'id' field is not part of the request when creating a new resource,