cognite-toolkit 0.7.43__tar.gz → 0.7.44__tar.gz

{cognite_toolkit-0.7.43 → cognite_toolkit-0.7.44}/PKG-INFO

@@ -1,10 +1,20 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.43
+Version: 0.7.44
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Author: Cognite AS
 Author-email: Cognite AS <support@cognite.com>
 License-Expression: Apache-2.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: cognite-sdk>=7.87.0,<8.0.0
 Requires-Dist: httpx>=0.28.1

{cognite_toolkit-0.7.43 → cognite_toolkit-0.7.44}/cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -16,11 +16,14 @@ from cognite_toolkit._cdf_tk.client.http_client import HTTPClient
 
 from .api.assets import AssetsAPI
 from .api.events import EventsAPI
+from .api.filemetadata import FileMetadataAPI
 from .api.infield import InfieldAPI
 from .api.lookup import LookUpGroup
 from .api.migration import MigrationAPI
 from .api.project import ProjectAPI
+from .api.raw import RawAPI
 from .api.search import SearchAPI
+from .api.simulators import SimulatorsAPI
 from .api.streams import StreamsAPI
 from .api.three_d import ThreeDAPI
 from .api.timeseries import TimeSeriesAPI
@@ -37,7 +40,10 @@ class ToolAPI:
         self.three_d = ThreeDAPI(http_client, console)
         self.assets = AssetsAPI(http_client)
         self.timeseries = TimeSeriesAPI(http_client)
+        self.filemetadata = FileMetadataAPI(http_client)
         self.events = EventsAPI(http_client)
+        self.raw = RawAPI(http_client)
+        self.simulators = SimulatorsAPI(http_client)
 
 
 class ToolkitClient(CogniteClient):

cognite_toolkit-0.7.44/cognite_toolkit/_cdf_tk/client/api/filemetadata.py

@@ -0,0 +1,145 @@
+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.filemetadata import FileMetadataRequest, FileMetadataResponse
+from cognite_toolkit._cdf_tk.client.data_classes.identifiers import InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, RequestMessage2, SuccessResponse2
+
+
+class FileMetadataAPI(CDFResourceAPI[InternalOrExternalId, FileMetadataRequest, FileMetadataResponse]):
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/files", item_limit=1, concurrency_max_workers=1),
+                "retrieve": Endpoint(method="POST", path="/files/byids", item_limit=1000, concurrency_max_workers=1),
+                "update": Endpoint(method="POST", path="/files/update", item_limit=1000, concurrency_max_workers=1),
+                "delete": Endpoint(method="POST", path="/files/delete", item_limit=1000, concurrency_max_workers=1),
+                "list": Endpoint(method="POST", path="/files/list", item_limit=1000),
+            },
+        )
+
+    def _page_response(self, response: SuccessResponse2) -> PagedResponse[FileMetadataResponse]:
+        return PagedResponse[FileMetadataResponse].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[FileMetadataRequest], overwrite: bool = False) -> list[FileMetadataResponse]:
+        """Upload file metadata to CDF.
+
+        Args:
+            items: List of FileMetadataRequest objects to upload.
+            overwrite: Whether to overwrite existing file metadata with the same external ID.
+
+        Returns:
+            List of created FileMetadataResponse objects.
+        """
+        # The Files API is different from other APIs, thus we have a custom implementation here.
+        # - It only allow one item per request that is not wrapped in a "items" field.
+        # - It uses a query parameter for "overwrite" instead of including it in the body
+        endpoint = self._method_endpoint_map["create"]
+        results: list[FileMetadataResponse] = []
+        for item in items:
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path),
+                method=endpoint.method,
+                body_content=item.dump(),
+                parameters={"overwrite": overwrite},
+            )
+            response = self._http_client.request_single_retries(request)
+            result = response.get_success_or_raise()
+            results.extend(self._page_response(result).items)
+        return results
+
+    def retrieve(
+        self, items: Sequence[InternalOrExternalId], ignore_unknown_ids: bool = False
+    ) -> list[FileMetadataResponse]:
+        """Retrieve file metadata from CDF.
+
+        Args:
+            items: List of InternalOrExternalId objects to retrieve.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+        Returns:
+            List of retrieved FileMetadataResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"ignoreUnknownIds": ignore_unknown_ids}
+        )
+
+    def update(
+        self, items: Sequence[FileMetadataRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[FileMetadataResponse]:
+        """Update file metadata in CDF.
+
+        Args:
+            items: List of FileMetadataRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated FileMetadataResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(self, items: Sequence[InternalOrExternalId], ignore_unknown_ids: bool = False) -> None:
+        """Delete file metadata 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,
+        data_set_external_ids: list[str] | None = None,
+        asset_subtree_external_ids: list[str] | None = None,
+        directory_prefix: str | None = None,
+        uploaded: bool | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[FileMetadataResponse]:
+        """Iterate over file metadata in CDF.
+
+        Args:
+            data_set_external_ids: Filter by data set external IDs.
+            asset_subtree_external_ids: Filter by asset subtree external IDs.
+            directory_prefix: Filter by directory prefix.
+            uploaded: Filter by upload status.
+            limit: Maximum number of items to return per page.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of FileMetadataResponse objects.
+        """
+        filter_: dict[str, Any] = {}
+        if asset_subtree_external_ids:
+            filter_["assetSubtreeIds"] = [{"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]
+        if directory_prefix is not None:
+            filter_["directoryPrefix"] = directory_prefix
+        if uploaded is not None:
+            filter_["uploaded"] = uploaded
+
+        return self._iterate(
+            cursor=cursor,
+            limit=limit,
+            body={"filter": filter_ or None},
+        )
+
+    def list(
+        self,
+        limit: int | None = 100,
+    ) -> list[FileMetadataResponse]:
+        """List all file metadata in CDF.
+
+        Args:
+            limit: Maximum number of items to return. None for all items.
+
+        Returns:
+            List of FileMetadataResponse objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit-0.7.44/cognite_toolkit/_cdf_tk/client/api/raw.py

@@ -0,0 +1,174 @@
+from collections.abc import Sequence
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, Endpoint, PagedResponse, ResponseItems
+from cognite_toolkit._cdf_tk.client.data_classes.raw import RAWDatabase, RAWTable
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, SuccessResponse2
+
+
+class RawDatabasesAPI(CDFResourceAPI[RAWDatabase, RAWDatabase, RAWDatabase]):
+    """API for managing RAW databases in CDF.
+
+    This API provides methods to create, list, and delete RAW databases.
+    """
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client,
+            {
+                "create": Endpoint(method="POST", path="/raw/dbs", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/raw/dbs/delete", item_limit=1000),
+                "list": Endpoint(method="GET", path="/raw/dbs", item_limit=1000),
+            },
+        )
+
+    def _page_response(self, response: SuccessResponse2) -> PagedResponse[RAWDatabase]:
+        return PagedResponse[RAWDatabase].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[RAWDatabase]:
+        return ResponseItems[RAWDatabase].model_validate_json(response.body)
+
+    def create(self, items: Sequence[RAWDatabase]) -> list[RAWDatabase]:
+        """Create databases in CDF.
+
+        Args:
+            items: List of RAWDatabase objects to create.
+
+        Returns:
+            List of created RAWDatabase objects.
+        """
+        return self._request_item_response(list(items), "create")
+
+    def delete(self, items: Sequence[RAWDatabase], recursive: bool = False) -> None:
+        """Delete databases from CDF.
+
+        Args:
+            items: List of RAWDatabase objects to delete.
+            recursive: Whether to delete tables within the database recursively.
+        """
+        self._request_no_response(list(items), "delete", extra_body={"recursive": recursive})
+
+    def iterate(
+        self,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[RAWDatabase]:
+        """Iterate over all databases in CDF.
+
+        Args:
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of RAWDatabase objects.
+        """
+        return self._iterate(limit=limit, cursor=cursor)
+
+    def list(self, limit: int | None = None) -> list[RAWDatabase]:
+        """List all databases in CDF.
+
+        Args:
+            limit: Maximum number of databases to return. If None, returns all databases.
+
+        Returns:
+            List of RAWDatabase objects.
+        """
+        return self._list(limit=limit)
+
+
+class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
+    """API for managing RAW tables in CDF.
+
+    This API provides methods to create, list, and delete RAW tables within a database.
+
+    Note: This API requires db_name as a path parameter for all operations,
+    so it overrides several base class methods to handle dynamic paths.
+    """
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        # We pass empty endpoint map since paths are dynamic (depend on db_name)
+        super().__init__(
+            http_client,
+            {
+                "create": Endpoint(method="POST", path="/raw/dbs/{dbName}/tables", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/raw/dbs/{dbName}/tables/delete", item_limit=1000),
+                "list": Endpoint(method="GET", path="/raw/dbs/{dbName}/tables", item_limit=1000),
+            },
+        )
+
+    def _page_response(self, response: SuccessResponse2) -> PagedResponse[RAWTable]:
+        """Parse a page response. Note: db_name must be injected separately."""
+        return PagedResponse[RAWTable].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[RAWTable]:
+        """Parse a reference response. Note: db_name must be injected separately."""
+        return ResponseItems[RAWTable].model_validate_json(response.body)
+
+    def create(self, items: Sequence[RAWTable], ensure_parent: bool = False) -> list[RAWTable]:
+        """Create tables in a database in CDF.
+
+        Args:
+            items: List of RAWTable objects to create.
+            ensure_parent: Create database if it doesn't exist already.
+
+        Returns:
+            List of created RAWTable objects.
+        """
+        result: list[RAWTable] = []
+        for db_name, group in self._group_items_by_text_field(items, "db_name").items():
+            if not db_name:
+                raise ValueError("db_name must be set on all RAWTable items for creation.")
+            endpoint = f"/raw/dbs/{db_name}/tables"
+            created = self._request_item_response(
+                group, "create", params={"ensureParent": ensure_parent}, endpoint=endpoint
+            )
+            for table in created:
+                result.append(RAWTable(db_name=db_name, name=table.name))
+        return result
+
+    def delete(self, items: Sequence[RAWTable]) -> None:
+        """Delete tables from a database in CDF.
+
+        Args:
+            items: List of RAWTable objects to delete.
+        """
+        for db_name, group in self._group_items_by_text_field(items, "db_name").items():
+            if not db_name:
+                raise ValueError("db_name must be set on all RAWTable items for deletion.")
+            endpoint = f"/raw/dbs/{db_name}/tables/delete"
+            self._request_no_response(list(group), "delete", endpoint=endpoint)
+
+    def iterate(
+        self,
+        db_name: str,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[RAWTable]:
+        """Iterate over all tables in a database in CDF.
+
+        Args:
+            db_name: The name of the database to list tables from.
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of RAWTable objects.
+        """
+        return self._iterate(cursor=cursor, limit=limit, endpoint_path=f"/raw/dbs/{db_name}/tables")
+
+    def list(self, db_name: str, limit: int | None = None) -> list[RAWTable]:
+        """List all tables in a database in CDF.
+
+        Args:
+            db_name: The name of the database to list tables from.
+            limit: Maximum number of tables to return. If None, returns all tables.
+
+        Returns:
+            List of RAWTable objects.
+        """
+        return self._list(limit, endpoint_path=f"/raw/dbs/{db_name}/tables")
+
+
+class RawAPI:
+    def __init__(self, http_client: HTTPClient) -> None:
+        self.databases = RawDatabasesAPI(http_client)
+        self.tables = RawTablesAPI(http_client)

cognite_toolkit-0.7.44/cognite_toolkit/_cdf_tk/client/api/simulator_models.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.identifiers import InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.data_classes.simulator_model import SimulatorModelRequest, SimulatorModelResponse
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, SuccessResponse2
+
+
+class SimulatorModelsAPI(CDFResourceAPI[InternalOrExternalId, SimulatorModelRequest, SimulatorModelResponse]):
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/simulators/models", item_limit=1, concurrency_max_workers=1),
+                "retrieve": Endpoint(
+                    method="POST", path="/simulators/models/byids", item_limit=1, concurrency_max_workers=1
+                ),
+                "update": Endpoint(
+                    method="POST", path="/simulators/models/update", item_limit=1, concurrency_max_workers=1
+                ),
+                "delete": Endpoint(
+                    method="POST", path="/simulators/models/delete", item_limit=1, concurrency_max_workers=1
+                ),
+                "list": Endpoint(method="POST", path="/simulators/models/list", item_limit=1000),
+            },
+        )
+
+    def _page_response(self, response: SuccessResponse2) -> PagedResponse[SimulatorModelResponse]:
+        return PagedResponse[SimulatorModelResponse].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[SimulatorModelRequest]) -> list[SimulatorModelResponse]:
+        """Create simulator models in CDF.
+
+        Args:
+            items: List of SimulatorModelRequest objects to create.
+
+        Returns:
+            List of created SimulatorModelResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, items: Sequence[InternalOrExternalId]) -> list[SimulatorModelResponse]:
+        """Retrieve simulator models from CDF.
+
+        Args:
+            items: List of InternalOrExternalId objects to retrieve.
+
+        Returns:
+            List of retrieved SimulatorModelResponse objects.
+        """
+        return self._request_item_response(items, method="retrieve")
+
+    def update(
+        self, items: Sequence[SimulatorModelRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[SimulatorModelResponse]:
+        """Update simulator models in CDF.
+
+        Args:
+            items: List of SimulatorModelRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated SimulatorModelResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(self, items: Sequence[InternalOrExternalId]) -> None:
+        """Delete simulator models from CDF.
+
+        Args:
+            items: List of InternalOrExternalId objects to delete.
+        """
+        self._request_no_response(items, "delete")
+
+    def iterate(
+        self,
+        simulator_external_ids: list[str] | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[SimulatorModelResponse]:
+        """Iterate over simulator models in CDF.
+
+        Args:
+            simulator_external_ids: Filter by simulator external IDs.
+            limit: Maximum number of items to return per page.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of SimulatorModelResponse objects.
+        """
+        filter_: dict[str, Any] = {}
+        if simulator_external_ids:
+            filter_["simulatorExternalIds"] = simulator_external_ids
+
+        return self._iterate(
+            cursor=cursor,
+            limit=limit,
+            body={"filter": filter_ or None},
+        )
+
+    def list(
+        self,
+        limit: int | None = 100,
+    ) -> list[SimulatorModelResponse]:
+        """List all simulator models in CDF.
+
+        Args:
+            limit: Maximum number of items to return. None for all items.
+
+        Returns:
+            List of SimulatorModelResponse objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit-0.7.44/cognite_toolkit/_cdf_tk/client/api/simulators.py

@@ -0,0 +1,8 @@
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient
+
+from .simulator_models import SimulatorModelsAPI
+
+
+class SimulatorsAPI:
+    def __init__(self, http_client: HTTPClient) -> None:
+        self.models = SimulatorModelsAPI(http_client)

{cognite_toolkit-0.7.43 → cognite_toolkit-0.7.44}/cognite_toolkit/_cdf_tk/client/cdf_client/__init__.py

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

{cognite_toolkit-0.7.43 → cognite_toolkit-0.7.44}/cognite_toolkit/_cdf_tk/client/cdf_client/api.py

@@ -5,6 +5,7 @@ that handle CRUD operations for CDF Data Modeling API resources.
 """
 
 from abc import ABC, abstractmethod
+from collections import defaultdict
 from collections.abc import Callable, Iterable, Sequence
 from dataclasses import dataclass
 from functools import partial
@@ -97,9 +98,10 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         method: APIMethod,
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
+        endpoint: str | None = None,
     ) -> list[T_ResponseResource]:
         response_items: list[T_ResponseResource] = []
-        for response in self._chunk_requests(items, method, self._serialize_items, params, extra_body):
+        for response in self._chunk_requests(items, method, self._serialize_items, params, extra_body, endpoint):
             response_items.extend(self._page_response(response).items)
         return response_items
 
@@ -121,8 +123,9 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         method: APIMethod,
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
+        endpoint: str | None = None,
     ) -> None:
-        list(self._chunk_requests(items, method, self._serialize_items, params, extra_body))
+        list(self._chunk_requests(items, method, self._serialize_items, params, extra_body, endpoint))
         return None
 
     def _chunk_requests(
@@ -132,14 +135,28 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         serialization: Callable[[Sequence[_T_BaseModel]], list[dict[str, JsonValue]]],
         params: dict[str, Any] | None = None,
         extra_body: dict[str, Any] | None = None,
+        endpoint_path: str | None = None,
     ) -> Iterable[SuccessResponse2]:
+        """Send requests in chunks and yield responses.
+
+        Args:
+            items: The items to process.
+            method: The API method to use. This is used ot look the up the endpoint.
+            serialization: A function to serialize the items to JSON-compatible dicts.
+            params: Optional query parameters for the request.
+            extra_body: Optional extra body content to include in the request.
+            endpoint_path: Optional override for the endpoint path.
+
+        Yields:
+            The successful responses from the API.
+        """
         # 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)}",
+                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]
                 parameters=request_params,
@@ -154,12 +171,24 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
             request_params = {k: v for k, v in params.items() if v is not None}
         return request_params
 
+    @classmethod
+    def _group_items_by_text_field(
+        cls, items: Sequence[_T_BaseModel], field_name: str
+    ) -> dict[str, list[_T_BaseModel]]:
+        """Group items by a text field."""
+        grouped_items: dict[str, list[_T_BaseModel]] = defaultdict(list)
+        for item in items:
+            key = str(getattr(item, field_name))
+            grouped_items[key].append(item)
+        return grouped_items
+
     def _iterate(
         self,
         limit: int,
         cursor: str | None = None,
         params: dict[str, Any] | None = None,
         body: dict[str, Any] | None = None,
+        endpoint_path: str | None = None,
     ) -> PagedResponse[T_ResponseResource]:
         """Fetch a single page of resources.
 
@@ -171,8 +200,11 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
                 - 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.
             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.
         """
@@ -194,7 +226,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
             raise NotImplementedError(f"Unsupported method {endpoint.method} for pagination.")
 
         request = RequestMessage2(
-            endpoint_url=self._make_url(endpoint.path),
+            endpoint_url=self._make_url(endpoint_path or endpoint.path),
             method=endpoint.method,
             parameters=request_params,
             body_content=body,
@@ -203,7 +235,9 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         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]:
+    def _list(
+        self, limit: int | None = None, params: dict[str, Any] | None = None, endpoint_path: str | None = None
+    ) -> list[T_ResponseResource]:
         """List all resources, handling pagination automatically."""
         all_items: list[T_ResponseResource] = []
         next_cursor: str | None = None
@@ -211,7 +245,7 @@ class CDFResourceAPI(Generic[T_Identifier, T_RequestResource, T_ResponseResource
         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)
+            page = self._iterate(limit=page_limit, cursor=next_cursor, params=params, endpoint_path=endpoint_path)
             all_items.extend(page.items)
             total += len(page.items)
             if page.next_cursor is None or (limit is not None and total >= limit):