cognite-toolkit 0.7.39__py3-none-any.whl → 0.7.41__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -12,8 +12,10 @@ from cognite_toolkit._cdf_tk.client.api.legacy.extended_functions import Extende
 from cognite_toolkit._cdf_tk.client.api.legacy.extended_raw import ExtendedRawAPI
 from cognite_toolkit._cdf_tk.client.api.legacy.extended_timeseries import ExtendedTimeSeriesAPI
 from cognite_toolkit._cdf_tk.client.api.legacy.robotics import RoboticsAPI
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient
 
+from .api.assets import AssetsAPI
+from .api.events import EventsAPI
 from .api.infield import InfieldAPI
 from .api.lookup import LookUpGroup
 from .api.migration import MigrationAPI
@@ -21,6 +23,7 @@ from .api.project import ProjectAPI
 from .api.search import SearchAPI
 from .api.streams import StreamsAPI
 from .api.three_d import ThreeDAPI
+from .api.timeseries import TimeSeriesAPI
 from .api.token import TokenAPI
 from .api.verify import VerifyAPI
 from .config import ToolkitClientConfig
@@ -32,6 +35,9 @@ class ToolAPI:
     def __init__(self, http_client: HTTPClient, console: Console) -> None:
         self.http_client = http_client
         self.three_d = ThreeDAPI(http_client, console)
+        self.assets = AssetsAPI(http_client)
+        self.time_series = TimeSeriesAPI(http_client)
+        self.events = EventsAPI(http_client)
 
 
 class ToolkitClient(CogniteClient):

cognite_toolkit/_cdf_tk/client/api/assets.py

@@ -0,0 +1,118 @@
+from collections.abc import 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.data_classes.asset import AssetRequest, AssetResponse
+from cognite_toolkit._cdf_tk.client.data_classes.identifiers import InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, SuccessResponse2
+
+
+class AssetsAPI(CDFResourceAPI[InternalOrExternalId, AssetRequest, AssetResponse]):
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/assets", item_limit=1000, concurrency_max_workers=1),
+                "retrieve": Endpoint(method="POST", path="/assets/byids", item_limit=1000, concurrency_max_workers=1),
+                "update": Endpoint(method="POST", path="/assets/update", item_limit=1000, concurrency_max_workers=1),
+                "delete": Endpoint(method="POST", path="/assets/delete", item_limit=1000, concurrency_max_workers=1),
+                "list": Endpoint(method="POST", path="/assets/list", item_limit=1000),
+            },
+        )
+
+    def _page_response(self, response: SuccessResponse2) -> PagedResponse[AssetResponse]:
+        return PagedResponse[AssetResponse].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[InternalOrExternalId]:
+        return ResponseItems[InternalOrExternalId].model_validate_json(response.body)
+
+    def create(self, items: Sequence[AssetRequest]) -> list[AssetResponse]:
+        """Create assets in CDF.
+
+        Args:
+            items: List of AssetRequest objects to create.
+        Returns:
+            List of created AssetResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, items: Sequence[InternalOrExternalId], ignore_unknown_ids: bool = False) -> list[AssetResponse]:
+        """Retrieve assets from CDF.
+
+        Args:
+            items: List of InternalOrExternalId objects to retrieve.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+        Returns:
+            List of retrieved AssetResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"ignoreUnknownIds": ignore_unknown_ids}
+        )
+
+    def update(
+        self, items: Sequence[AssetRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[AssetResponse]:
+        """Update assets in CDF.
+
+        Args:
+            items: List of AssetRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated AssetResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(
+        self, items: Sequence[InternalOrExternalId], recursive: bool = False, ignore_unknown_ids: bool = False
+    ) -> None:
+        """Delete assets from CDF.
+
+        Args:
+            items: List of InternalOrExternalId objects to delete.
+            recursive: Whether to delete assets recursively.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+        """
+        self._request_no_response(
+            items, "delete", extra_body={"recursive": recursive, "ignoreUnknownIds": ignore_unknown_ids}
+        )
+
+    def iterate(
+        self,
+        aggregated_properties: bool = False,
+        data_set_external_ids: list[str] | None = None,
+        asset_subtree_external_ids: list[str] | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[AssetResponse]:
+        """Iterate over all assets in CDF.
+
+        Returns:
+            PagedResponse of AssetResponse objects.
+        """
+        filter_: dict[str, Any] = {}
+        if asset_subtree_external_ids:
+            filter_["assetSubtreeExternalIds"] = [{"externalId": ext_id} for ext_id in asset_subtree_external_ids]
+        if data_set_external_ids:
+            filter_["dataSetIds"] = [{"externalId": ds_id} for ds_id in data_set_external_ids]
+
+        return self._iterate(
+            cursor=cursor,
+            limit=limit,
+            body={
+                "aggregatedProperties": ["childCount", "path", "depth"] if aggregated_properties else [],
+                "filter": filter_ or None,
+            },
+        )
+
+    def list(
+        self,
+        limit: int | None = 100,
+    ) -> list[AssetResponse]:
+        """List all asset references in CDF.
+
+        Returns:
+            ResponseItems of T_Identifier objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit/_cdf_tk/client/api/events.py

@@ -0,0 +1,97 @@
+from collections.abc import Sequence
+from typing import 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.data_classes.event import EventRequest, EventResponse
+from cognite_toolkit._cdf_tk.client.data_classes.identifiers import InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, SuccessResponse2
+
+
+class EventsAPI(CDFResourceAPI[InternalOrExternalId, EventRequest, EventResponse]):
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/events", item_limit=1000, concurrency_max_workers=1),
+                "retrieve": Endpoint(method="POST", path="/events/byids", item_limit=1000, concurrency_max_workers=1),
+                "update": Endpoint(method="POST", path="/events/update", item_limit=1000, concurrency_max_workers=1),
+                "delete": Endpoint(method="POST", path="/events/delete", item_limit=1000, concurrency_max_workers=1),
+                "list": Endpoint(method="POST", path="/events/list", item_limit=1000),
+            },
+        )
+
+    def _page_response(self, response: SuccessResponse2) -> PagedResponse[EventResponse]:
+        return PagedResponse[EventResponse].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[InternalOrExternalId]:
+        return ResponseItems[InternalOrExternalId].model_validate_json(response.body)
+
+    def create(self, items: Sequence[EventRequest]) -> list[EventResponse]:
+        """Create events in CDF.
+
+        Args:
+            items: List of EventRequest objects to create.
+        Returns:
+            List of created EventResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, items: Sequence[InternalOrExternalId], ignore_unknown_ids: bool = False) -> list[EventResponse]:
+        """Retrieve events from CDF.
+
+        Args:
+            items: List of InternalOrExternalId objects to retrieve.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+        Returns:
+            List of retrieved EventResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"ignoreUnknownIds": ignore_unknown_ids}
+        )
+
+    def update(
+        self, items: Sequence[EventRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[EventResponse]:
+        """Update events in CDF.
+
+        Args:
+            items: List of EventRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated EventResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(self, items: Sequence[InternalOrExternalId], ignore_unknown_ids: bool = False) -> None:
+        """Delete events from CDF.
+
+        Args:
+            items: List of InternalOrExternalId objects to delete.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+        """
+        self._request_no_response(items, "delete", extra_body={"ignoreUnknownIds": ignore_unknown_ids})
+
+    def iterate(
+        self,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[EventResponse]:
+        """Iterate over all events in CDF.
+
+        Returns:
+            PagedResponse of EventResponse objects.
+        """
+        return self._iterate(cursor=cursor, limit=limit)
+
+    def list(
+        self,
+        limit: int | None = 100,
+    ) -> list[EventResponse]:
+        """List all events in CDF.
+
+        Returns:
+            List of EventResponse objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -4,7 +4,7 @@ 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 QueryResponse
+from cognite_toolkit._cdf_tk.client.cdf_client.responses import QueryResponse
 from cognite_toolkit._cdf_tk.client.data_classes.infield import (
     DataExplorationConfig,
     InFieldCDMLocationConfig,
@@ -15,12 +15,12 @@ from cognite_toolkit._cdf_tk.client.data_classes.instance_api import (
     InstanceResult,
     TypedNodeIdentifier,
 )
-from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
-from cognite_toolkit._cdf_tk.utils.http_client import (
+from cognite_toolkit._cdf_tk.client.http_client import (
     HTTPClient,
     ItemsRequest2,
     RequestMessage2,
 )
+from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
 
 
 class InfieldConfigAPI:

cognite_toolkit/_cdf_tk/client/api/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, RequestMessage2
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
 

cognite_toolkit/_cdf_tk/client/api/project.py

@@ -2,7 +2,7 @@ from cognite.client import CogniteClient
 
 from cognite_toolkit._cdf_tk.client.config import ToolkitClientConfig
 from cognite_toolkit._cdf_tk.client.data_classes.legacy.project import ProjectStatusList
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, RequestMessage2
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, RequestMessage2
 
 
 class ProjectAPI:

cognite_toolkit/_cdf_tk/client/api/streams.py

@@ -3,9 +3,9 @@ from collections.abc import Sequence
 from pydantic import TypeAdapter
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse
+from cognite_toolkit._cdf_tk.client.cdf_client.responses import PagedResponse
 from cognite_toolkit._cdf_tk.client.data_classes.streams import StreamRequest, StreamResponse
-from cognite_toolkit._cdf_tk.utils.http_client import (
+from cognite_toolkit._cdf_tk.client.http_client import (
     HTTPClient,
     ItemsRequest2,
     RequestMessage2,

cognite_toolkit/_cdf_tk/client/api/three_d.py

@@ -5,7 +5,8 @@ from typing import Any, TypeVar
 from pydantic import TypeAdapter
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk.client.data_classes.api_classes import InternalIdRequest, PagedResponse
+from cognite_toolkit._cdf_tk.client.cdf_client.responses import PagedResponse
+from cognite_toolkit._cdf_tk.client.data_classes.identifiers import InternalId
 from cognite_toolkit._cdf_tk.client.data_classes.three_d import (
     AssetMappingClassicRequest,
     AssetMappingDMRequest,
@@ -13,12 +14,12 @@ from cognite_toolkit._cdf_tk.client.data_classes.three_d import (
     ThreeDModelClassicRequest,
     ThreeDModelResponse,
 )
-from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
-from cognite_toolkit._cdf_tk.utils.http_client import (
+from cognite_toolkit._cdf_tk.client.http_client import (
     HTTPClient,
     ItemsRequest2,
     RequestMessage2,
 )
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
 from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
 
 
@@ -70,7 +71,7 @@ class ThreeDModelAPI:
             ItemsRequest2(
                 endpoint_url=self._config.create_api_url(self.ENDPOINT + "/delete"),
                 method="POST",
-                items=InternalIdRequest.from_ids(list(ids)),
+                items=InternalId.from_ids(list(ids)),
             )
         )
         responses.raise_for_status()

cognite_toolkit/_cdf_tk/client/api/timeseries.py

@@ -0,0 +1,105 @@
+from collections.abc import Sequence
+from typing import 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.data_classes.identifiers import InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.data_classes.timeseries import TimeSeriesRequest, TimeSeriesResponse
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, SuccessResponse2
+
+
+class TimeSeriesAPI(CDFResourceAPI[InternalOrExternalId, TimeSeriesRequest, TimeSeriesResponse]):
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/timeseries", item_limit=1000, concurrency_max_workers=1),
+                "retrieve": Endpoint(
+                    method="POST", path="/timeseries/byids", item_limit=1000, concurrency_max_workers=1
+                ),
+                "update": Endpoint(
+                    method="POST", path="/timeseries/update", item_limit=1000, concurrency_max_workers=1
+                ),
+                "delete": Endpoint(
+                    method="POST", path="/timeseries/delete", item_limit=1000, concurrency_max_workers=1
+                ),
+                "list": Endpoint(method="POST", path="/timeseries/list", item_limit=1000),
+            },
+        )
+
+    def _page_response(self, response: SuccessResponse2) -> PagedResponse[TimeSeriesResponse]:
+        return PagedResponse[TimeSeriesResponse].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[InternalOrExternalId]:
+        return ResponseItems[InternalOrExternalId].model_validate_json(response.body)
+
+    def create(self, items: Sequence[TimeSeriesRequest]) -> list[TimeSeriesResponse]:
+        """Create time series in CDF.
+
+        Args:
+            items: List of TimeSeriesRequest objects to create.
+        Returns:
+            List of created TimeSeriesResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(
+        self, items: Sequence[InternalOrExternalId], ignore_unknown_ids: bool = False
+    ) -> list[TimeSeriesResponse]:
+        """Retrieve time series from CDF.
+
+        Args:
+            items: List of InternalOrExternalId objects to retrieve.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+        Returns:
+            List of retrieved TimeSeriesResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"ignoreUnknownIds": ignore_unknown_ids}
+        )
+
+    def update(
+        self, items: Sequence[TimeSeriesRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[TimeSeriesResponse]:
+        """Update time series in CDF.
+
+        Args:
+            items: List of TimeSeriesRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated TimeSeriesResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(self, items: Sequence[InternalOrExternalId], ignore_unknown_ids: bool = False) -> None:
+        """Delete time series from CDF.
+
+        Args:
+            items: List of InternalOrExternalId objects to delete.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+        """
+        self._request_no_response(items, "delete", extra_body={"ignoreUnknownIds": ignore_unknown_ids})
+
+    def iterate(
+        self,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[TimeSeriesResponse]:
+        """Iterate over all time series in CDF.
+
+        Returns:
+            PagedResponse of TimeSeriesResponse objects.
+        """
+        return self._iterate(cursor=cursor, limit=limit)
+
+    def list(
+        self,
+        limit: int | None = 100,
+    ) -> list[TimeSeriesResponse]:
+        """List all time series in CDF.
+
+        Returns:
+            List of TimeSeriesResponse objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit/_cdf_tk/client/cdf_client/__init__.py

@@ -0,0 +1,9 @@
+from .api import CDFResourceAPI
+from .responses import PagedResponse, QueryResponse, ResponseItems
+
+__all__ = [
+    "CDFResourceAPI",
+    "PagedResponse",
+    "QueryResponse",
+    "ResponseItems",
+]

cognite_toolkit/_cdf_tk/client/cdf_client/api.py

@@ -0,0 +1,220 @@
+"""Base classes for resource clients.
+
+This module provides the base infrastructure for resource-specific clients
+that handle CRUD operations for CDF Data Modeling API resources.
+"""
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable, Iterable, Sequence
+from dataclasses import dataclass
+from functools import partial
+from typing import Any, Generic, Literal, TypeAlias, TypeVar
+
+from pydantic import BaseModel, JsonValue
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    RequestUpdateable,
+    T_Identifier,
+    T_RequestResource,
+    T_ResponseResource,
+)
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, RequestMessage2, SuccessResponse2
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
+
+from .responses import PagedResponse, ResponseItems
+
+_T_BaseModel = TypeVar("_T_BaseModel", bound=BaseModel)
+
+
+@dataclass(frozen=True)
+class Endpoint:
+    method: Literal["GET", "POST", "PUT", "PATCH", "DELETE"]
+    path: str
+    item_limit: int
+    concurrency_max_workers: int = 1
+
+
+APIMethod: TypeAlias = Literal["create", "retrieve", "update", "delete", "list"]
+
+
+class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource], ABC):
+    """Generic resource API for CDF APIs
+
+    This class provides the logic for working with CDF resources,
+    including creating, retrieving, deleting, and listing resources.
+    """
+
+    def __init__(self, http_client: HTTPClient, method_endpoint_map: dict[APIMethod, Endpoint]) -> None:
+        """Initialize the resource API.
+
+        Args:
+            http_client: The HTTP client to use for API requests.
+            method_endpoint_map: A mapping of endpoint suffixes to their properties.
+        """
+        self._http_client = http_client
+        self._method_endpoint_map = method_endpoint_map
+
+    @classmethod
+    def _serialize_items(cls, items: Sequence[BaseModel]) -> list[dict[str, JsonValue]]:
+        """Serialize reference objects to JSON-compatible dicts."""
+        return [item.model_dump(mode="json", by_alias=True) for item in items]
+
+    @classmethod
+    def _serialize_updates(
+        cls, items: Sequence[RequestUpdateable], 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]
+
+    @abstractmethod
+    def _page_response(self, response: SuccessResponse2) -> PagedResponse[T_ResponseResource]:
+        """Parse a single item response."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[T_Identifier]:
+        """Parse a reference response."""
+        raise NotImplementedError()
+
+    def _make_url(self, path: str = "") -> str:
+        """Create the full URL for this resource endpoint."""
+        return self._http_client.config.create_api_url(path)
+
+    def _update(
+        self, items: Sequence[RequestUpdateable], mode: Literal["patch", "replace"]
+    ) -> list[T_ResponseResource]:
+        """Update resources in chunks."""
+        response_items: list[T_ResponseResource] = []
+        for response in self._chunk_requests(
+            items, "update", serialization=partial(self._serialize_updates, mode=mode)
+        ):
+            response_items.extend(self._page_response(response).items)
+        return response_items
+
+    def _request_item_response(
+        self,
+        items: Sequence[BaseModel],
+        method: APIMethod,
+        params: dict[str, Any] | None = None,
+        extra_body: dict[str, Any] | None = None,
+    ) -> list[T_ResponseResource]:
+        response_items: list[T_ResponseResource] = []
+        for response in self._chunk_requests(items, method, self._serialize_items, params, extra_body):
+            response_items.extend(self._page_response(response).items)
+        return response_items
+
+    def _request_reference_response(
+        self,
+        items: Sequence[BaseModel],
+        method: APIMethod,
+        params: dict[str, Any] | None = None,
+        extra_body: dict[str, Any] | None = None,
+    ) -> list[T_Identifier]:
+        all_ids: list[T_Identifier] = []
+        for response in self._chunk_requests(items, method, self._serialize_items, params, extra_body):
+            all_ids.extend(self._reference_response(response).items)
+        return all_ids
+
+    def _request_no_response(
+        self,
+        items: Sequence[BaseModel],
+        method: APIMethod,
+        params: dict[str, Any] | None = None,
+        extra_body: dict[str, Any] | None = None,
+    ) -> None:
+        list(self._chunk_requests(items, method, self._serialize_items, params, extra_body))
+        return None
+
+    def _chunk_requests(
+        self,
+        items: Sequence[_T_BaseModel],
+        method: APIMethod,
+        serialization: Callable[[Sequence[_T_BaseModel]], list[dict[str, JsonValue]]],
+        params: dict[str, Any] | None = None,
+        extra_body: dict[str, Any] | None = None,
+    ) -> Iterable[SuccessResponse2]:
+        # Filter out None
+        request_params = self._filter_out_none_values(params)
+        endpoint = self._method_endpoint_map[method]
+
+        for chunk in chunker_sequence(items, endpoint.item_limit):
+            request = RequestMessage2(
+                endpoint_url=f"{self._make_url(endpoint.path)}",
+                method=endpoint.method,
+                body_content={"items": serialization(chunk), **(extra_body or {})},  # type: ignore[dict-item]
+                parameters=request_params,
+            )
+            response = self._http_client.request_single_retries(request)
+            yield response.get_success_or_raise()
+
+    @classmethod
+    def _filter_out_none_values(cls, params: dict[str, Any] | None) -> dict[str, Any] | None:
+        request_params: dict[str, Any] | None = None
+        if params:
+            request_params = {k: v for k, v in params.items() if v is not None}
+        return request_params
+
+    def _iterate(
+        self,
+        limit: int,
+        cursor: str | None = None,
+        params: dict[str, Any] | None = None,
+        body: dict[str, Any] | None = None,
+    ) -> PagedResponse[T_ResponseResource]:
+        """Fetch a single page of resources.
+
+        Args:
+            params: Query parameters for the request. Supported parameters depend on
+                the resource type but typically include:
+                - cursor: Cursor for pagination
+                - limit: Maximum number of items (defaults to list limit)
+                - space: Filter by space
+                - includeGlobal: Whether to include global resources
+            body : Body content for the request, if applicable.
+            limit: Maximum number of items to return in the page.
+            cursor: Cursor for pagination.
+        Returns:
+            A Page containing the items and the cursor for the next page.
+        """
+        endpoint = self._method_endpoint_map["list"]
+        if not (0 < limit <= endpoint.item_limit):
+            raise ValueError(f"Limit must be between 1 and {endpoint.item_limit}, got {limit}.")
+
+        request_params = self._filter_out_none_values(params) or {}
+        body = self._filter_out_none_values(body) or {}
+        if endpoint.method == "GET":
+            request_params["limit"] = limit
+            if cursor is not None:
+                request_params["cursor"] = cursor
+        elif endpoint.method in {"POST", "PUT", "PATCH"}:
+            body["limit"] = limit
+            if cursor is not None:
+                body["cursor"] = cursor
+        else:
+            raise NotImplementedError(f"Unsupported method {endpoint.method} for pagination.")
+
+        request = RequestMessage2(
+            endpoint_url=self._make_url(endpoint.path),
+            method=endpoint.method,
+            parameters=request_params,
+            body_content=body,
+        )
+        result = self._http_client.request_single_retries(request)
+        response = result.get_success_or_raise()
+        return self._page_response(response)
+
+    def _list(self, limit: int | None = None, params: dict[str, Any] | None = None) -> list[T_ResponseResource]:
+        """List all resources, handling pagination automatically."""
+        all_items: list[T_ResponseResource] = []
+        next_cursor: str | None = None
+        total = 0
+        endpoint = self._method_endpoint_map["list"]
+        while True:
+            page_limit = endpoint.item_limit if limit is None else min(limit - total, endpoint.item_limit)
+            page = self._iterate(limit=page_limit, cursor=next_cursor, params=params)
+            all_items.extend(page.items)
+            total += len(page.items)
+            if page.next_cursor is None or (limit is not None and total >= limit):
+                break
+            next_cursor = page.next_cursor
+        return all_items