cognite-toolkit 0.7.46__py3-none-any.whl → 0.7.48__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/api/location_filters.py

@@ -0,0 +1,177 @@
+from collections.abc import Iterable, Sequence
+
+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,
+    RequestMessage2,
+    SuccessResponse2,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.location_filter import (
+    LocationFilterRequest,
+    LocationFilterResponse,
+)
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
+
+
+class LocationFiltersAPI(CDFResourceAPI[InternalId, LocationFilterRequest, LocationFilterResponse]):
+    """API for managing Location Filters using the CDFResourceAPI pattern.
+
+    This API manages location filter configurations at:
+    /apps/v1/projects/{project}/storage/config/locationfilters
+    """
+
+    BASE_PATH = "/storage/config/locationfilters"
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path=self.BASE_PATH, item_limit=1),
+                "retrieve": Endpoint(method="POST", path=f"{self.BASE_PATH}/byids", item_limit=1000),
+                "update": Endpoint(method="PUT", path=f"{self.BASE_PATH}/{{id}}", item_limit=1),
+                "delete": Endpoint(method="DELETE", path=f"{self.BASE_PATH}/{{id}}", item_limit=1),
+                "list": Endpoint(method="POST", path=f"{self.BASE_PATH}/list", item_limit=1000),
+            },
+        )
+
+    def _make_url(self, path: str = "") -> str:
+        """Create the full URL for this resource endpoint using the apps URL format."""
+        return self._http_client.config.create_app_url(path)
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[LocationFilterResponse]:
+        return PagedResponse[LocationFilterResponse].model_validate_json(response.body)
+
+    def create(self, items: Sequence[LocationFilterRequest]) -> list[LocationFilterResponse]:
+        """Create a new location filter.
+
+        Args:
+            items: The location filter to create.
+
+        Returns:
+            The created location filter.
+        """
+        endpoint = self._method_endpoint_map["create"]
+        results: list[LocationFilterResponse] = []
+        for item in items:
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path),
+                method=endpoint.method,
+                body_content=item.model_dump(mode="json", by_alias=True),
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            results.append(LocationFilterResponse.model_validate_json(response.body))
+        return results
+
+    def retrieve(self, items: Sequence[InternalId]) -> list[LocationFilterResponse]:
+        """Retrieve a single location filter by ID.
+
+        Args:
+            items: The ID of the location filter to retrieve.
+
+        Returns:
+            The retrieved location filter.
+        """
+        endpoint = self._method_endpoint_map["retrieve"]
+        results: list[LocationFilterResponse] = []
+        for chunk in chunker_sequence(items, endpoint.item_limit):
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path),
+                method=endpoint.method,
+                body_content={"ids": [item.id for item in chunk]},
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            results.extend(self._validate_page_response(response).items)
+        return results
+
+    def update(self, items: Sequence[LocationFilterRequest]) -> list[LocationFilterResponse]:
+        """Update an existing location filter.
+
+        Args:
+            items: The updated location filter data.
+
+        Returns:
+            The updated location filter.
+        """
+        endpoint = self._method_endpoint_map["update"]
+        results: list[LocationFilterResponse] = []
+        for item in items:
+            if item.id is None:
+                raise ValueError("Item must have an ID for update operation.")
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path.format(id=item.id)),
+                method=endpoint.method,
+                body_content=item.model_dump(mode="json", by_alias=True),
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            parsed = LocationFilterResponse.model_validate_json(response.body)
+            parsed.id = item.id
+            results.append(parsed)
+        return results
+
+    def delete(self, items: Sequence[InternalId]) -> list[LocationFilterResponse]:
+        """Delete a location filter.
+
+        Args:
+            items: The ID of the location filter to delete.
+
+        Returns:
+            list[LocationFilterResponse]: The deleted location filters.
+        """
+        endpoint = self._method_endpoint_map["delete"]
+        results: list[LocationFilterResponse] = []
+        for item in items:
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path.format(id=item.id)),
+                method=endpoint.method,
+            )
+            result = self._http_client.request_single_retries(request)
+            response = result.get_success_or_raise()
+            results.append(LocationFilterResponse.model_validate_json(response.body))
+        return results
+
+    def paginate(
+        self,
+        flat: bool = True,
+    ) -> PagedResponse[LocationFilterResponse]:
+        """Get a single page of location filters.
+
+        Args:
+            flat: Whether to return a flat list (default True).
+
+        Returns:
+            PagedResponse of LocationFilterResponse objects.
+        """
+        return self._paginate(cursor=None, limit=100, body={"flat": flat})
+
+    def iterate(
+        self,
+        flat: bool = True,
+    ) -> Iterable[list[LocationFilterResponse]]:
+        """Iterate over all location filters.
+
+        Args:
+            flat: Whether to return a flat list (default True).
+
+        Returns:
+            Iterable of lists of LocationFilterResponse objects.
+        """
+        return self._iterate(limit=None, body={"flat": flat})
+
+    def list(self, flat: bool = True) -> list[LocationFilterResponse]:
+        """List all location filters.
+
+        Args:
+            flat: Whether to return a flat list (default True).
+
+        Returns:
+            List of LocationFilterResponse objects.
+        """
+        return self._list(limit=None, body={"flat": flat})

cognite_toolkit/_cdf_tk/client/api/raw.py

@@ -128,7 +128,7 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
             List of created RAWTable objects.
         """
         result: list[RAWTable] = []
-        for db_name, group in self._group_items_by_text_field(items, "db_name").items():
+        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"
@@ -145,7 +145,7 @@ class RawTablesAPI(CDFResourceAPI[RAWTable, RAWTable, RAWTable]):
         Args:
             items: List of RAWTable objects to delete.
         """
-        for db_name, group in self._group_items_by_text_field(items, "db_name").items():
+        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"

cognite_toolkit/_cdf_tk/client/api/relationships.py

@@ -0,0 +1,133 @@
+"""Relationships API for managing CDF relationships.
+
+Based on the API specification at:
+https://api-docs.cognite.com/20230101/tag/Relationships/operation/createRelationships
+"""
+
+from collections.abc import Iterable, Sequence
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, Endpoint, PagedResponse
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, ItemsSuccessResponse2, SuccessResponse2
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.relationship import RelationshipRequest, RelationshipResponse
+
+
+class RelationshipsAPI(CDFResourceAPI[ExternalId, RelationshipRequest, RelationshipResponse]):
+    """API for managing CDF relationships."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/relationships", item_limit=1000),
+                "retrieve": Endpoint(method="POST", path="/relationships/byids", item_limit=1000),
+                "update": Endpoint(method="POST", path="/relationships/update", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/relationships/delete", item_limit=1000),
+                "list": Endpoint(method="POST", path="/relationships/list", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[RelationshipResponse]:
+        return PagedResponse[RelationshipResponse].model_validate_json(response.body)
+
+    def create(self, items: Sequence[RelationshipRequest]) -> list[RelationshipResponse]:
+        """Create relationships in CDF.
+
+        Args:
+            items: List of RelationshipRequest objects to create.
+
+        Returns:
+            List of created RelationshipResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(
+        self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False, fetch_resources: bool = False
+    ) -> list[RelationshipResponse]:
+        """Retrieve relationships from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+            fetch_resources: If true, will try to fetch the resources referred to in the relationship,
+                based on the users access rights. Will silently fail to attach the resources
+                if the user lacks access to some of them.
+
+        Returns:
+            List of retrieved RelationshipResponse objects.
+        """
+        return self._request_item_response(
+            items,
+            method="retrieve",
+            extra_body={"ignoreUnknownIds": ignore_unknown_ids, "fetchResources": fetch_resources},
+        )
+
+    def update(
+        self, items: Sequence[RelationshipRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[RelationshipResponse]:
+        """Update relationships in CDF.
+
+        Args:
+            items: List of RelationshipRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated RelationshipResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(self, items: Sequence[ExternalId], ignore_unknown_ids: bool = False) -> None:
+        """Delete relationships from CDF.
+
+        Args:
+            items: List of ExternalId 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,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[RelationshipResponse]:
+        """Get a page of relationships from CDF.
+
+        Args:
+            limit: Maximum number of relationships to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of RelationshipResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+        )
+
+    def iterate(
+        self,
+        limit: int | None = None,
+    ) -> Iterable[list[RelationshipResponse]]:
+        """Iterate over all relationships in CDF.
+
+        Args:
+            limit: Maximum total number of relationships to return.
+
+        Returns:
+            Iterable of lists of RelationshipResponse objects.
+        """
+        return self._iterate(limit=limit)
+
+    def list(self, limit: int | None = None) -> list[RelationshipResponse]:
+        """List all relationships in CDF.
+
+        Args:
+            limit: Maximum total number of relationships to return.
+
+        Returns:
+            List of RelationshipResponse objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit/_cdf_tk/client/api/robotics.py

@@ -0,0 +1,19 @@
+from cognite_toolkit._cdf_tk.client.api.robotics_capabilities import CapabilitiesAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_data_postprocessing import DataPostProcessingAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_frames import FramesAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_locations import LocationsAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_maps import MapsAPI
+from cognite_toolkit._cdf_tk.client.api.robotics_robots import RobotsAPI
+from cognite_toolkit._cdf_tk.client.http_client import HTTPClient
+
+
+class RoboticsAPI:
+    """API for Robotics resources."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        self.capabilities = CapabilitiesAPI(http_client)
+        self.data_postprocessing = DataPostProcessingAPI(http_client)
+        self.frames = FramesAPI(http_client)
+        self.locations = LocationsAPI(http_client)
+        self.maps = MapsAPI(http_client)
+        self.robots = RobotsAPI(http_client)

cognite_toolkit/_cdf_tk/client/api/robotics_capabilities.py

@@ -0,0 +1,127 @@
+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.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.robotics._capability import (
+    RobotCapabilityRequest,
+    RobotCapabilityResponse,
+)
+
+
+class CapabilitiesAPI(CDFResourceAPI[ExternalId, RobotCapabilityRequest, RobotCapabilityResponse]):
+    """API for managing Capability resources in CDF."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(
+                    method="POST", path="/robotics/capabilities", item_limit=1000, concurrency_max_workers=1
+                ),
+                "retrieve": Endpoint(
+                    method="POST", path="/robotics/capabilities/byids", item_limit=1000, concurrency_max_workers=1
+                ),
+                "update": Endpoint(
+                    method="POST", path="/robotics/capabilities/update", item_limit=1000, concurrency_max_workers=1
+                ),
+                "delete": Endpoint(
+                    method="POST", path="/robotics/capabilities/delete", item_limit=1000, concurrency_max_workers=1
+                ),
+                "list": Endpoint(method="GET", path="/robotics/capabilities", item_limit=1000),
+            },
+            disable_gzip=True,
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[RobotCapabilityResponse]:
+        return PagedResponse[RobotCapabilityResponse].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[ExternalId]:
+        return ResponseItems[ExternalId].model_validate_json(response.body)
+
+    def create(self, items: Sequence[RobotCapabilityRequest]) -> list[RobotCapabilityResponse]:
+        """Create capabilities in CDF.
+
+        Args:
+            items: List of RobotCapabilityRequest objects to create.
+        Returns:
+            List of created RobotCapabilityResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, items: Sequence[ExternalId]) -> list[RobotCapabilityResponse]:
+        """Retrieve capabilities from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+        Returns:
+            List of retrieved RobotCapabilityResponse objects.
+        """
+        return self._request_item_response(items, method="retrieve")
+
+    def update(
+        self, items: Sequence[RobotCapabilityRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[RobotCapabilityResponse]:
+        """Update capabilities in CDF.
+
+        Args:
+            items: List of RobotCapabilityRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated RobotCapabilityResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(self, items: Sequence[ExternalId]) -> None:
+        """Delete capabilities from CDF.
+
+        Args:
+            items: List of ExternalId objects to delete.
+        """
+        self._request_no_response(items, "delete")
+
+    def paginate(
+        self,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[RobotCapabilityResponse]:
+        """Paginate over capabilities in CDF.
+
+        Args:
+            limit: Maximum number of items per page.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of RobotCapabilityResponse objects.
+        """
+        return self._paginate(cursor=cursor, limit=limit)
+
+    def iterate(
+        self,
+        limit: int | None = 100,
+    ) -> Iterable[list[RobotCapabilityResponse]]:
+        """Iterate over all capabilities in CDF.
+
+        Args:
+            limit: Maximum number of items to return. None returns all.
+
+        Returns:
+            Iterable of lists of RobotCapabilityResponse objects.
+        """
+        return self._iterate(limit=limit)
+
+    def list(self, limit: int | None = 100) -> list[RobotCapabilityResponse]:
+        """List all capabilities in CDF.
+
+        Args:
+            limit: Maximum number of items to return. None returns all.
+
+        Returns:
+            List of RobotCapabilityResponse objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit/_cdf_tk/client/api/robotics_data_postprocessing.py

@@ -0,0 +1,138 @@
+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.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.robotics._data_post_processing import (
+    RobotDataPostProcessingRequest,
+    RobotDataPostProcessingResponse,
+)
+
+
+class DataPostProcessingAPI(
+    CDFResourceAPI[ExternalId, RobotDataPostProcessingRequest, RobotDataPostProcessingResponse]
+):
+    """API for managing DataPostProcessing resources in CDF."""
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(
+                    method="POST", path="/robotics/data_postprocessing", item_limit=1000, concurrency_max_workers=1
+                ),
+                "retrieve": Endpoint(
+                    method="POST",
+                    path="/robotics/data_postprocessing/byids",
+                    item_limit=1000,
+                    concurrency_max_workers=1,
+                ),
+                "update": Endpoint(
+                    method="POST",
+                    path="/robotics/data_postprocessing/update",
+                    item_limit=1000,
+                    concurrency_max_workers=1,
+                ),
+                "delete": Endpoint(
+                    method="POST",
+                    path="/robotics/data_postprocessing/delete",
+                    item_limit=1000,
+                    concurrency_max_workers=1,
+                ),
+                "list": Endpoint(method="GET", path="/robotics/data_postprocessing", item_limit=1000),
+            },
+            disable_gzip=True,
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[RobotDataPostProcessingResponse]:
+        return PagedResponse[RobotDataPostProcessingResponse].model_validate_json(response.body)
+
+    def _reference_response(self, response: SuccessResponse2) -> ResponseItems[ExternalId]:
+        return ResponseItems[ExternalId].model_validate_json(response.body)
+
+    def create(self, items: Sequence[RobotDataPostProcessingRequest]) -> list[RobotDataPostProcessingResponse]:
+        """Create data post-processing configurations in CDF.
+
+        Args:
+            items: List of RobotDataPostProcessingRequest objects to create.
+        Returns:
+            List of created RobotDataPostProcessingResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, items: Sequence[ExternalId]) -> list[RobotDataPostProcessingResponse]:
+        """Retrieve data post-processing configurations from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+        Returns:
+            List of retrieved RobotDataPostProcessingResponse objects.
+        """
+        return self._request_item_response(items, method="retrieve")
+
+    def update(
+        self, items: Sequence[RobotDataPostProcessingRequest], mode: Literal["patch", "replace"] = "replace"
+    ) -> list[RobotDataPostProcessingResponse]:
+        """Update data post-processing configurations in CDF.
+
+        Args:
+            items: List of RobotDataPostProcessingRequest objects to update.
+            mode: Update mode, either "patch" or "replace".
+
+        Returns:
+            List of updated RobotDataPostProcessingResponse objects.
+        """
+        return self._update(items, mode=mode)
+
+    def delete(self, items: Sequence[ExternalId]) -> None:
+        """Delete data post-processing configurations from CDF.
+
+        Args:
+            items: List of ExternalId objects to delete.
+        """
+        self._request_no_response(items, "delete")
+
+    def paginate(
+        self,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[RobotDataPostProcessingResponse]:
+        """Paginate over data post-processing configurations in CDF.
+
+        Args:
+            limit: Maximum number of items per page.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of RobotDataPostProcessingResponse objects.
+        """
+        return self._paginate(cursor=cursor, limit=limit)
+
+    def iterate(
+        self,
+        limit: int | None = 100,
+    ) -> Iterable[list[RobotDataPostProcessingResponse]]:
+        """Iterate over all data post-processing configurations in CDF.
+
+        Args:
+            limit: Maximum number of items to return. None returns all.
+
+        Returns:
+            Iterable of lists of RobotDataPostProcessingResponse objects.
+        """
+        return self._iterate(limit=limit)
+
+    def list(self, limit: int | None = 100) -> list[RobotDataPostProcessingResponse]:
+        """List all data post-processing configurations in CDF.
+
+        Args:
+            limit: Maximum number of items to return. None returns all.
+
+        Returns:
+            List of RobotDataPostProcessingResponse objects.
+        """
+        return self._list(limit=limit)