cognite-toolkit 0.7.30__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/api/three_d.py

@@ -1,50 +1,401 @@
-from rich.console import Console
+from collections.abc import Iterable, Sequence
+from typing import TypeVar
 
-from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse
-from cognite_toolkit._cdf_tk.client.data_classes.three_d import ThreeDModelResponse
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ParamRequest
-from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, PagedResponse
+from cognite_toolkit._cdf_tk.client.cdf_client.api import Endpoint
+from cognite_toolkit._cdf_tk.client.http_client import (
+    HTTPClient,
+    ItemsSuccessResponse2,
+    SuccessResponse2,
+)
+from cognite_toolkit._cdf_tk.client.request_classes.filters import ThreeDAssetMappingFilter
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.three_d import (
+    AssetMappingClassicRequest,
+    AssetMappingClassicResponse,
+    AssetMappingDMRequest,
+    AssetMappingDMResponse,
+    ThreeDModelClassicRequest,
+    ThreeDModelResponse,
+)
 
 
-class ThreeDModelAPI:
-    ENDPOINT = "/3d/models"
-
-    def __init__(self, http_client: HTTPClient, console: Console) -> None:
-        self._http_client = http_client
-        self._console = console
-        self._config = http_client.config
+class ThreeDClassicModelsAPI(CDFResourceAPI[InternalId, ThreeDModelClassicRequest, ThreeDModelResponse]):
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/3d/models", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/3d/models/delete", item_limit=1000),
+                "update": Endpoint(method="POST", path="/3d/models/update", item_limit=1000),
+                "retrieve": Endpoint(method="GET", path="/3d/models/{modelId}", item_limit=1000),
+                "list": Endpoint(method="GET", path="/3d/models", item_limit=1000),
+            },
+        )
 
-    def iterate(
-        self,
-        published: bool | None = None,
-        include_revision_info: bool = False,
-        limit: int = 100,
-        cursor: str | None = None,
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
     ) -> PagedResponse[ThreeDModelResponse]:
-        if not (0 < limit <= 1000):
-            raise ValueError("Limit must be between 1 and 1000.")
-        parameters: dict[str, PrimitiveType] = {
+        return PagedResponse[ThreeDModelResponse].model_validate_json(response.body)
+
+    def create(self, items: Sequence[ThreeDModelClassicRequest]) -> list[ThreeDModelResponse]:
+        """Create 3D models in classic format.
+
+        Args:
+            items (Sequence[ThreeDModelClassicRequest]): The 3D model(s) to create.
+
+        Returns:
+            list[ThreeDModelResponse]: The created 3D model(s).
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, ids: Sequence[InternalId]) -> list[ThreeDModelResponse]:
+        """Retrieve 3D models by their IDs.
+
+        Args:
+            ids (Sequence[int]): The IDs of the 3D models to retrieve.
+
+        Returns:
+            list[ThreeDModelResponse]: The retrieved 3D model(s).
+        """
+        return self._request_item_response(ids, "retrieve")
+
+    def update(self, items: Sequence[ThreeDModelClassicRequest]) -> list[ThreeDModelResponse]:
+        """Update 3D models in classic format.
+
+        Args:
+            items (Sequence[ThreeDModelClassicRequest]): The 3D model(s) to update.
+
+        Returns:
+            list[ThreeDModelResponse]: The updated 3D model(s).
+        """
+        return self._request_item_response(items, "update")
+
+    def delete(self, ids: Sequence[InternalId]) -> None:
+        """Delete 3D models by their IDs.
+
+        Args:
+            ids (Sequence[int]): The IDs of the 3D models to delete.
+        """
+        self._request_no_response(ids, "delete")
+
+    @staticmethod
+    def _create_list_filter(include_revision_info: bool, published: bool | None) -> dict[str, bool]:
+        params = {
             # There is a bug in the API. The parameter includeRevisionInfo is expected to be lower case and not
             # camel case as documented. You get error message: Unrecognized query parameter includeRevisionInfo,
             # did you mean includerevisioninfo?
             "includerevisioninfo": include_revision_info,
-            "limit": limit,
         }
         if published is not None:
-            parameters["published"] = published
-        if cursor is not None:
-            parameters["cursor"] = cursor
-        responses = self._http_client.request_with_retries(
-            ParamRequest(
-                endpoint_url=self._config.create_api_url(self.ENDPOINT),
-                method="GET",
-                parameters=parameters,
+            params["published"] = published
+        return params
+
+    def paginate(
+        self,
+        published: bool | None = None,
+        include_revision_info: bool = False,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[ThreeDModelResponse]:
+        params = self._create_list_filter(include_revision_info, published)
+        return self._paginate(limit=limit, cursor=cursor, params=params)
+
+    def iterate(
+        self,
+        published: bool | None = None,
+        include_revision_info: bool = False,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> Iterable[list[ThreeDModelResponse]]:
+        params = self._create_list_filter(include_revision_info, published)
+        return self._iterate(limit=limit, cursor=cursor, params=params)
+
+    def list(
+        self,
+        published: bool | None = None,
+        include_revision_info: bool = False,
+        limit: int | None = 100,
+    ) -> list[ThreeDModelResponse]:
+        params = self._create_list_filter(include_revision_info, published)
+        return self._list(limit=limit, params=params)
+
+
+T_RequestMapping = TypeVar("T_RequestMapping", bound=AssetMappingClassicRequest | AssetMappingDMRequest)
+
+
+class ThreeDClassicAssetMappingAPI(
+    CDFResourceAPI[AssetMappingClassicRequest, AssetMappingClassicRequest, AssetMappingClassicResponse]
+):
+    ENDPOINT = "/3d/models/{modelId}/revisions/{revisionId}/mappings"
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                # These endpoints are parameterized, so the paths are templates
+                "create": Endpoint(method="POST", path=self.ENDPOINT, item_limit=1000),
+                "delete": Endpoint(method="POST", path=f"{self.ENDPOINT}/delete", item_limit=1000),
+                "list": Endpoint(method="POST", path=f"{self.ENDPOINT}/list", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[AssetMappingClassicResponse]:
+        return PagedResponse[AssetMappingClassicResponse].model_validate_json(response.body)
+
+    def create(self, mappings: Sequence[AssetMappingClassicRequest]) -> list[AssetMappingClassicResponse]:
+        """Create 3D asset mappings.
+
+        Args:
+            mappings (Sequence[AssetMappingClassicRequest]):
+                The 3D asset mapping(s) to create.
+
+        Returns:
+            list[AssetMappingClassicResponse]: The created 3D asset mapping(s).
+        """
+        results: list[AssetMappingClassicResponse] = []
+        endpoint = self._method_endpoint_map["create"]
+        for (model_id, revision_id), group in self._group_items_by_text_field(
+            mappings, "model_id", "revision_id"
+        ).items():
+            path = endpoint.path.format(modelId=model_id, revisionId=revision_id)
+            result = self._request_item_response(group, "create", endpoint=path)
+            for item in result:
+                # We append modelId and revisionId to each item since the API does not return them
+                # this is needed to fully populate the AssetMappingResponse data class
+                object.__setattr__(item, "model_id", int(model_id))
+                object.__setattr__(item, "revision_id", int(revision_id))
+            results.extend(result)
+        return results
+
+    def delete(self, mappings: Sequence[AssetMappingClassicRequest]) -> None:
+        """Delete 3D asset mappings.
+
+        Args:
+            mappings (Sequence[AssetMappingClassicRequest]):
+                The 3D asset mapping(s) to delete.
+        """
+        endpoint = self._method_endpoint_map["delete"]
+        for (model_id, revision_id), group in self._group_items_by_text_field(
+            mappings, "model_id", "revision_id"
+        ).items():
+            path = endpoint.path.format(modelId=model_id, revisionId=revision_id)
+            self._request_no_response(group, "delete", endpoint=path)
+        return None
+
+    def paginate(
+        self,
+        model_id: int,
+        revision_id: int,
+        filter: ThreeDAssetMappingFilter | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[AssetMappingClassicResponse]:
+        endpoint = self._method_endpoint_map["list"]
+        path = endpoint.path.format(modelId=model_id, revisionId=revision_id)
+        page = self._paginate(
+            limit=limit,
+            cursor=cursor,
+            body={"filter": filter.dump() if filter else None, "getDmsInstances": False},
+            endpoint_path=path,
+        )
+        # Add modelId and revisionId to items since the API does not return them
+        for item in page.items:
+            object.__setattr__(item, "model_id", model_id)
+            object.__setattr__(item, "revision_id", revision_id)
+        return page
+
+    def iterate(
+        self,
+        model_id: int,
+        revision_id: int,
+        filter: ThreeDAssetMappingFilter | None = None,
+        limit: int = 100,
+    ) -> Iterable[list[AssetMappingClassicResponse]]:
+        endpoint = self._method_endpoint_map["list"]
+        path = endpoint.path.format(modelId=model_id, revisionId=revision_id)
+        for items in self._iterate(
+            body={"filter": filter.dump() if filter else None, "getDmsInstances": False},
+            limit=limit,
+            endpoint_path=path,
+        ):
+            # Add modelId and revisionId to items since the API does not return them
+            for item in items:
+                object.__setattr__(item, "model_id", model_id)
+                object.__setattr__(item, "revision_id", revision_id)
+            yield items
+
+    def list(
+        self,
+        model_id: int,
+        revision_id: int,
+        filter: ThreeDAssetMappingFilter | None = None,
+        limit: int | None = 100,
+    ) -> list[AssetMappingClassicResponse]:
+        endpoint = self._method_endpoint_map["list"]
+        path = endpoint.path.format(modelId=model_id, revisionId=revision_id)
+        items = self._list(
+            body={"filter": filter.dump() if filter else None, "getDmsInstances": False},
+            limit=limit,
+            endpoint_path=path,
+        )
+        # Add modelId and revisionId to items since the API does not return them
+        for item in items:
+            object.__setattr__(item, "model_id", model_id)
+            object.__setattr__(item, "revision_id", revision_id)
+        return items
+
+
+class ThreeDDMAssetMappingAPI(CDFResourceAPI[AssetMappingDMRequest, AssetMappingDMRequest, AssetMappingDMResponse]):
+    ENDPOINT = "/3d/models/{modelId}/revisions/{revisionId}/mappings"
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                # These endpoints are parameterized, so the paths are templates
+                "create": Endpoint(method="POST", path=self.ENDPOINT, item_limit=100),
+                "delete": Endpoint(method="POST", path=f"{self.ENDPOINT}/delete", item_limit=100),
+                "list": Endpoint(method="POST", path=f"{self.ENDPOINT}/list", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[AssetMappingDMResponse]:
+        return PagedResponse[AssetMappingDMResponse].model_validate_json(response.body)
+
+    def create(
+        self, mappings: Sequence[AssetMappingDMRequest], object_3d_space: str, cad_node_space: str
+    ) -> list[AssetMappingDMResponse]:
+        """Create 3D asset mappings in Data Modeling format.
+
+        Args:
+            mappings (Sequence[AssetMappingDMRequest]):
+                The 3D asset mapping(s) to create
+            object_3d_space (str):
+                The instance space where the Cognite3DObject are located.
+            cad_node_space (str):
+                The instance space where the CogniteCADNode are located.
+        Returns:
+            list[AssetMappingDMResponse]: The created 3D asset mapping(s).
+        """
+        results: list[AssetMappingDMResponse] = []
+        for (model_id, revision_id), group in self._group_items_by_text_field(
+            mappings, "model_id", "revision_id"
+        ).items():
+            path = self.ENDPOINT.format(modelId=model_id, revisionId=revision_id)
+            result = self._request_item_response(
+                group,
+                "create",
+                endpoint=path,
+                extra_body={
+                    "dmsContextualizationConfig": {
+                        "object3DSpace": object_3d_space,
+                        "cadNodeSpace": cad_node_space,
+                    }
+                },
             )
+            for item in result:
+                # We append modelId and revisionId to each item since the API does not return them
+                # this is needed to fully populate the AssetMappingDMResponse data class
+                object.__setattr__(item, "model_id", int(model_id))
+                object.__setattr__(item, "revision_id", int(revision_id))
+            results.extend(result)
+        return results
+
+    def delete(self, mappings: Sequence[AssetMappingDMRequest], object_3d_space: str, cad_node_space: str) -> None:
+        """Delete 3D asset mappings in Data Modeling format.
+
+        Args:
+            mappings (Sequence[AssetMappingDMRequest]):
+                The 3D asset mapping(s) to delete.
+            object_3d_space (str):
+                The instance space where the Cognite3DObject are located.
+            cad_node_space (str):
+                The instance space where the CogniteCADNode are located.
+        """
+        endpoint = self._method_endpoint_map["delete"]
+        for (model_id, revision_id), group in self._group_items_by_text_field(
+            mappings, "model_id", "revision_id"
+        ).items():
+            path = endpoint.path.format(modelId=model_id, revisionId=revision_id)
+            self._request_no_response(
+                group,
+                "delete",
+                endpoint=path,
+                extra_body={
+                    "dmsContextualizationConfig": {
+                        "object3DSpace": object_3d_space,
+                        "cadNodeSpace": cad_node_space,
+                    }
+                },
+            )
+        return None
+
+    def paginate(
+        self,
+        model_id: int,
+        revision_id: int,
+        filter: ThreeDAssetMappingFilter | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[AssetMappingDMResponse]:
+        endpoint = self._method_endpoint_map["list"]
+        path = endpoint.path.format(modelId=model_id, revisionId=revision_id)
+        page = self._paginate(
+            limit=limit,
+            cursor=cursor,
+            body={"filter": filter.dump() if filter else None, "getDmsInstances": True},
+            endpoint_path=path,
+        )
+        # Add modelId and revisionId to items since the API does not return them
+        for item in page.items:
+            object.__setattr__(item, "model_id", model_id)
+            object.__setattr__(item, "revision_id", revision_id)
+        return page
+
+    def iterate(
+        self,
+        model_id: int,
+        revision_id: int,
+        filter: ThreeDAssetMappingFilter | None = None,
+        limit: int = 100,
+    ) -> Iterable[list[AssetMappingDMResponse]]:
+        endpoint = self._method_endpoint_map["list"]
+        path = endpoint.path.format(modelId=model_id, revisionId=revision_id)
+        for items in self._iterate(
+            body={"filter": filter.dump() if filter else None, "getDmsInstances": True}, limit=limit, endpoint_path=path
+        ):
+            # Add modelId and revisionId to items since the API does not return them
+            for item in items:
+                object.__setattr__(item, "model_id", model_id)
+                object.__setattr__(item, "revision_id", revision_id)
+            yield items
+
+    def list(
+        self,
+        model_id: int,
+        revision_id: int,
+        filter: ThreeDAssetMappingFilter | None = None,
+        limit: int | None = 100,
+    ) -> list[AssetMappingDMResponse]:
+        endpoint = self._method_endpoint_map["list"]
+        path = endpoint.path.format(modelId=model_id, revisionId=revision_id)
+        items = self._list(
+            body={"filter": filter.dump() if filter else None, "getDmsInstances": True}, limit=limit, endpoint_path=path
         )
-        responses.raise_for_status()
-        return PagedResponse[ThreeDModelResponse].model_validate(responses.get_first_body())
+        # Add modelId and revisionId to items since the API does not return them
+        for item in items:
+            object.__setattr__(item, "model_id", model_id)
+            object.__setattr__(item, "revision_id", revision_id)
+        return items
 
 
 class ThreeDAPI:
-    def __init__(self, http_client: HTTPClient, console: Console) -> None:
-        self.models = ThreeDModelAPI(http_client, console)
+    def __init__(self, http_client: HTTPClient) -> None:
+        self.models_classic = ThreeDClassicModelsAPI(http_client)
+        self.asset_mappings_classic = ThreeDClassicAssetMappingAPI(http_client)
+        self.asset_mappings_dm = ThreeDDMAssetMappingAPI(http_client)

cognite_toolkit/_cdf_tk/client/api/timeseries.py

@@ -0,0 +1,137 @@
+from collections.abc import Iterable, 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.http_client import HTTPClient, ItemsSuccessResponse2, SuccessResponse2
+from cognite_toolkit._cdf_tk.client.request_classes.filters import ClassicFilter
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.timeseries import TimeSeriesRequest, TimeSeriesResponse
+
+
+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 _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> 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 paginate(
+        self,
+        filter: ClassicFilter | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[TimeSeriesResponse]:
+        """Iterate over all time series in CDF.
+
+        Args:
+            filter: Filter by data set IDs and/or asset subtree IDs.
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of TimeSeriesResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+            body={"filter": filter.dump() if filter else None},
+        )
+
+    def iterate(
+        self,
+        filter: ClassicFilter | None = None,
+        limit: int | None = 100,
+    ) -> Iterable[list[TimeSeriesResponse]]:
+        """Iterate over all time series in CDF.
+
+        Args:
+            filter: Filter by data set IDs and/or asset subtree IDs.
+            limit: Maximum number of items to return per page.
+
+        Returns:
+            Iterable of lists of TimeSeriesResponse objects.
+        """
+        return self._iterate(
+            limit=limit,
+            body={"filter": filter.dump() if filter else None},
+        )
+
+    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/api/token.py

@@ -4,7 +4,7 @@ from cognite.client import CogniteClient
 from cognite.client.data_classes.capabilities import _CAPABILITY_CLASS_BY_NAME, AllScope, Capability
 from cognite.client.data_classes.iam import TokenInspection
 
-from cognite_toolkit._cdf_tk.client.data_classes.capabilities import scope_intersection, scope_union
+from cognite_toolkit._cdf_tk.client.resource_classes.capabilities import scope_intersection, scope_union
 from cognite_toolkit._cdf_tk.utils import humanize_collection
 
 _ACL_CLASS_BY_CLASS_NAME = {cap.__name__: cap for cap in _CAPABILITY_CLASS_BY_NAME.values()}