cognite-toolkit 0.7.42__py3-none-any.whl → 0.7.44__py3-none-any.whl

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
@@ -36,8 +39,11 @@ class ToolAPI:
         self.http_client = http_client
         self.three_d = ThreeDAPI(http_client, console)
         self.assets = AssetsAPI(http_client)
-        self.time_series = TimeSeriesAPI(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/_cdf_tk/client/api/events.py

@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from typing import Literal
+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
@@ -75,15 +75,33 @@ class EventsAPI(CDFResourceAPI[InternalOrExternalId, EventRequest, EventResponse
 
     def iterate(
         self,
+        data_set_external_ids: list[str] | None = None,
+        asset_subtree_external_ids: list[str] | None = None,
         limit: int = 100,
         cursor: str | None = None,
     ) -> PagedResponse[EventResponse]:
         """Iterate over all events in CDF.
 
+        Args:
+            data_set_external_ids: Filter by data set external IDs.
+            asset_subtree_external_ids: Filter by asset subtree external IDs.
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
         Returns:
             PagedResponse of EventResponse objects.
         """
-        return self._iterate(cursor=cursor, limit=limit)
+        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]
+
+        return self._iterate(
+            cursor=cursor,
+            limit=limit,
+            body={"filter": filter_ or None},
+        )
 
     def list(
         self,

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/_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/_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/_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/_cdf_tk/client/api/timeseries.py

@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from typing import Literal
+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
@@ -83,15 +83,33 @@ class TimeSeriesAPI(CDFResourceAPI[InternalOrExternalId, TimeSeriesRequest, Time
 
     def iterate(
         self,
+        data_set_external_ids: list[str] | None = None,
+        asset_subtree_external_ids: list[str] | None = None,
         limit: int = 100,
         cursor: str | None = None,
     ) -> PagedResponse[TimeSeriesResponse]:
         """Iterate over all time series in CDF.
 
+        Args:
+            data_set_external_ids: Filter by data set external IDs.
+            asset_subtree_external_ids: Filter by asset subtree external IDs.
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
         Returns:
             PagedResponse of TimeSeriesResponse objects.
         """
-        return self._iterate(cursor=cursor, limit=limit)
+        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]
+
+        return self._iterate(
+            cursor=cursor,
+            limit=limit,
+            body={"filter": filter_ or None},
+        )
 
     def list(
         self,

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",