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

cognite_toolkit/_cdf_tk/client/api/function_schedules.py

@@ -0,0 +1,115 @@
+"""Function Schedules API for managing CDF function schedules.
+
+Based on the API specification at:
+https://api-docs.cognite.com/20230101/tag/Function-schedules/operation/postFunctionSchedules
+"""
+
+from collections.abc import Iterable, Sequence
+
+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.function_schedule import (
+    FunctionScheduleRequest,
+    FunctionScheduleResponse,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalId
+
+
+class FunctionSchedulesAPI(CDFResourceAPI[InternalId, FunctionScheduleRequest, FunctionScheduleResponse]):
+    """API for managing CDF function schedules.
+
+    Note: Function schedules do not support update operations.
+    """
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/functions/schedules", item_limit=1),
+                "retrieve": Endpoint(method="POST", path="/functions/schedules/byids", item_limit=10_000),
+                "delete": Endpoint(method="POST", path="/functions/schedules/delete", item_limit=10_000),
+                "list": Endpoint(method="POST", path="/functions/schedules/list", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[FunctionScheduleResponse]:
+        return PagedResponse[FunctionScheduleResponse].model_validate_json(response.body)
+
+    def create(self, items: Sequence[FunctionScheduleRequest]) -> list[FunctionScheduleResponse]:
+        """Create function schedules in CDF.
+
+        Args:
+            items: List of FunctionScheduleRequest objects to create.
+
+        Returns:
+            List of created FunctionScheduleResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, items: Sequence[InternalId], ignore_unknown_ids: bool = False) -> list[FunctionScheduleResponse]:
+        """Retrieve function schedules from CDF by ID.
+
+        Args:
+            items: List of InternalId objects to retrieve.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+
+        Returns:
+            List of retrieved FunctionScheduleResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"ignoreUnknownIds": ignore_unknown_ids}
+        )
+
+    def delete(self, items: Sequence[InternalId]) -> None:
+        """Delete function schedules from CDF.
+
+        Args:
+            items: List of InternalId objects to delete.
+        """
+        self._request_no_response(items, "delete")
+
+    def paginate(
+        self,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[FunctionScheduleResponse]:
+        """Get a page of function schedules from CDF.
+
+        Args:
+            limit: Maximum number of function schedules to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of FunctionScheduleResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+        )
+
+    def iterate(
+        self,
+        limit: int | None = None,
+    ) -> Iterable[list[FunctionScheduleResponse]]:
+        """Iterate over all function schedules in CDF.
+
+        Args:
+            limit: Maximum total number of function schedules to return.
+
+        Returns:
+            Iterable of lists of FunctionScheduleResponse objects.
+        """
+        return self._iterate(limit=limit)
+
+    def list(self, limit: int | None = None) -> list[FunctionScheduleResponse]:
+        """List all function schedules in CDF.
+
+        Args:
+            limit: Maximum total number of function schedules to return.
+
+        Returns:
+            List of FunctionScheduleResponse objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit/_cdf_tk/client/api/functions.py

@@ -0,0 +1,113 @@
+"""Functions API for managing CDF functions.
+
+Based on the API specification at:
+https://api-docs.cognite.com/20230101/tag/Functions/operation/postFunctions
+"""
+
+from collections.abc import Iterable, Sequence
+
+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.function import FunctionRequest, FunctionResponse
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalId
+
+
+class FunctionsAPI(CDFResourceAPI[InternalId, FunctionRequest, FunctionResponse]):
+    """API for managing CDF functions.
+
+    Note: Functions do not support update operations.
+    """
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/functions", item_limit=1),
+                "retrieve": Endpoint(method="POST", path="/functions/byids", item_limit=10),
+                "delete": Endpoint(method="POST", path="/functions/delete", item_limit=10),
+                "list": Endpoint(method="POST", path="/functions/list", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[FunctionResponse]:
+        return PagedResponse[FunctionResponse].model_validate_json(response.body)
+
+    def create(self, items: Sequence[FunctionRequest]) -> list[FunctionResponse]:
+        """Create functions in CDF.
+
+        Args:
+            items: List of FunctionRequest objects to create.
+
+        Returns:
+            List of created FunctionResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def retrieve(self, items: Sequence[InternalId], ignore_unknown_ids: bool = False) -> list[FunctionResponse]:
+        """Retrieve functions from CDF by ID.
+
+        Args:
+            items: List of InternalId objects to retrieve.
+            ignore_unknown_ids: Whether to ignore unknown IDs.
+
+        Returns:
+            List of retrieved FunctionResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"ignoreUnknownIds": ignore_unknown_ids}
+        )
+
+    def delete(self, items: Sequence[InternalId], ignore_unknown_ids: bool = False) -> None:
+        """Delete functions from CDF.
+
+        Args:
+            items: List of InternalId 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[FunctionResponse]:
+        """Get a page of functions from CDF.
+
+        Args:
+            limit: Maximum number of functions to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of FunctionResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+        )
+
+    def iterate(
+        self,
+        limit: int | None = None,
+    ) -> Iterable[list[FunctionResponse]]:
+        """Iterate over all functions in CDF.
+
+        Args:
+            limit: Maximum total number of functions to return.
+
+        Returns:
+            Iterable of lists of FunctionResponse objects.
+        """
+        return self._iterate(limit=limit)
+
+    def list(self, limit: int | None = None) -> list[FunctionResponse]:
+        """List all functions in CDF.
+
+        Args:
+            limit: Maximum total number of functions to return.
+
+        Returns:
+            List of FunctionResponse objects.
+        """
+        return self._list(limit=limit)

cognite_toolkit/_cdf_tk/client/api/graphql_data_models.py

@@ -0,0 +1,167 @@
+"""GraphQL Data Models API for managing CDF GraphQL/DML data models.
+
+This API provides a wrapper around the legacy DML API for managing GraphQL data models.
+"""
+
+from collections.abc import Iterable, Sequence
+from typing import Any
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, Endpoint, PagedResponse
+from cognite_toolkit._cdf_tk.client.cdf_client.responses import GraphQLUpsertResponse
+from cognite_toolkit._cdf_tk.client.http_client import (
+    HTTPClient,
+    ItemsSuccessResponse2,
+    RequestMessage2,
+    SuccessResponse2,
+    ToolkitAPIError,
+)
+from cognite_toolkit._cdf_tk.client.request_classes.filters import DataModelFilter
+from cognite_toolkit._cdf_tk.client.request_classes.graphql import UPSERT_BODY
+from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling import DataModelReference
+from cognite_toolkit._cdf_tk.client.resource_classes.graphql_data_model import (
+    GraphQLDataModelRequest,
+    GraphQLDataModelResponse,
+)
+
+
+class GraphQLDataModelsAPI(CDFResourceAPI[DataModelReference, GraphQLDataModelRequest, GraphQLDataModelResponse]):
+    """API for managing CDF GraphQL/DML data models.
+
+    This API uses GraphQL mutations to manage data models with DML (Data Modeling Language).
+    """
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "retrieve": Endpoint(method="POST", path="/models/datamodels/byids", item_limit=100),
+                "delete": Endpoint(method="POST", path="/models/datamodels/delete", item_limit=100),
+                "list": Endpoint(method="GET", path="/models/datamodels", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[GraphQLDataModelResponse]:
+        return PagedResponse[GraphQLDataModelResponse].model_validate_json(response.body)
+
+    def _post_graphql(self, payload: dict[str, Any]) -> GraphQLUpsertResponse:
+        """Execute a GraphQL query against the DML endpoint."""
+        request = RequestMessage2(
+            endpoint_url=self._make_url("/dml/graphql"),
+            method="POST",
+            body_content=payload,
+        )
+        result = self._http_client.request_single_retries(request)
+        response = result.get_success_or_raise()
+        parsed = GraphQLUpsertResponse.model_validate_json(response.body)
+        if errors := parsed.upsert_graph_ql_dml_version.errors:
+            raise ToolkitAPIError(f"Failed GraphQL errors: {errors}")
+        return parsed
+
+    def create(self, items: Sequence[GraphQLDataModelRequest]) -> list[GraphQLDataModelResponse]:
+        """Apply (create or update) GraphQL data models in CDF.
+
+        Args:
+            items: List of GraphQLDataModelRequest objects to apply.
+
+        Returns:
+            List of applied GraphQLDataModelResponse objects.
+        """
+        results: list[GraphQLDataModelResponse] = []
+        for item in items:
+            payload = {"query": UPSERT_BODY, "variables": {"dmCreate": item.dump()}}
+            response = self._post_graphql(payload)
+
+            results.append(response.upsert_graph_ql_dml_version.data)
+
+        return results
+
+    def update(self, items: Sequence[GraphQLDataModelRequest]) -> list[GraphQLDataModelResponse]:
+        """Update GraphQL data models in CDF.
+
+        Args:
+            items: List of GraphQLDataModelRequest objects to update.
+        Returns:
+            List of updated GraphQLDataModelResponse objects.
+        """
+        return self.create(items)
+
+    def retrieve(
+        self, items: Sequence[DataModelReference], inline_views: bool = False
+    ) -> list[GraphQLDataModelResponse]:
+        """Retrieve GraphQL data models from CDF.
+
+        Args:
+            items: List of DataModelReference objects to retrieve.
+            inline_views: Whether to include full view definitions in the response.
+
+        Returns:
+            List of retrieved GraphQLDataModelResponse objects.
+        """
+        return self._request_item_response(items, method="retrieve", extra_body={"inlineViews": inline_views})
+
+    def delete(self, items: Sequence[DataModelReference]) -> None:
+        """Delete GraphQL data models from CDF.
+
+        Args:
+            items: List of DataModelReference objects to delete.
+        """
+        self._request_no_response(items, "delete")
+
+    def paginate(
+        self,
+        filter: DataModelFilter | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[GraphQLDataModelResponse]:
+        """Get a page of GraphQL data models from CDF.
+
+        Args:
+            filter: DataModelFilter to filter data models.
+            limit: Maximum number of data models to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of GraphQLDataModelResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+            params=filter.dump() if filter else None,
+        )
+
+    def iterate(
+        self,
+        filter: DataModelFilter | None = None,
+        limit: int | None = None,
+    ) -> Iterable[list[GraphQLDataModelResponse]]:
+        """Iterate over all GraphQL data models in CDF.
+
+        Args:
+            filter: DataModelFilter to filter data models.
+            limit: Maximum total number of data models to return.
+
+        Returns:
+            Iterable of lists of GraphQLDataModelResponse objects.
+        """
+        return self._iterate(
+            limit=limit,
+            params=filter.dump() if filter else None,
+        )
+
+    def list(
+        self,
+        filter: DataModelFilter | None = None,
+        limit: int | None = None,
+    ) -> list[GraphQLDataModelResponse]:
+        """List all GraphQL data models in CDF.
+
+        Args:
+            filter: DataModelFilter to filter data models.
+            limit: Maximum total number of data models to return.
+
+        Returns:
+            List of GraphQLDataModelResponse objects.
+        """
+        return self._list(limit=limit, params=filter.dump() if filter else None)

cognite_toolkit/_cdf_tk/client/api/groups.py

@@ -0,0 +1,121 @@
+"""Groups API for managing CDF access groups.
+
+Based on the API specification at:
+https://api-docs.cognite.com/20230101/tag/Groups/operation/createGroups
+"""
+
+from collections.abc import Iterable, Sequence
+
+from cognite_toolkit._cdf_tk.client.cdf_client import CDFResourceAPI, Endpoint, PagedResponse
+from cognite_toolkit._cdf_tk.client.http_client import (
+    HTTPClient,
+    ItemsSuccessResponse2,
+    RequestMessage2,
+    SuccessResponse2,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.group import GroupRequest, GroupResponse
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalId
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
+
+
+class GroupsAPI(CDFResourceAPI[InternalId, GroupRequest, GroupResponse]):
+    """API for managing CDF access groups.
+
+    Note: Groups do not support update operations.
+    """
+
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "create": Endpoint(method="POST", path="/groups", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/groups/delete", item_limit=1000),
+                "list": Endpoint(method="GET", path="/groups", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[GroupResponse]:
+        return PagedResponse[GroupResponse].model_validate_json(response.body)
+
+    def create(self, items: Sequence[GroupRequest]) -> list[GroupResponse]:
+        """Create groups in CDF.
+
+        Args:
+            items: List of GroupRequest objects to create.
+
+        Returns:
+            List of created GroupResponse objects.
+        """
+        return self._request_item_response(items, "create")
+
+    def delete(self, items: Sequence[InternalId]) -> None:
+        """Delete groups from CDF.
+
+        Args:
+            items: List of InternalId objects to delete.
+        """
+        # Custom implementation since delete does not wrap the items in a {"id": ...} structure
+        endpoint = self._method_endpoint_map["delete"]
+        for chunk in chunker_sequence(items, endpoint.item_limit):
+            request = RequestMessage2(
+                endpoint_url=self._make_url(endpoint.path),
+                method=endpoint.method,
+                body_content={"items": [item.id for item in chunk]},
+            )
+            response = self._http_client.request_single_retries(request)
+            response.get_success_or_raise()
+
+    def paginate(
+        self,
+        all_groups: bool = False,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[GroupResponse]:
+        """Get a page of groups from CDF.
+
+        Args:
+            all_groups: Whether to return all groups (requires admin permissions).
+            limit: Maximum number of groups to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of GroupResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+            params={"all": all_groups} if all_groups else None,
+        )
+
+    def iterate(
+        self,
+        all_groups: bool = False,
+        limit: int | None = None,
+    ) -> Iterable[list[GroupResponse]]:
+        """Iterate over all groups in CDF.
+
+        Args:
+            all_groups: Whether to return all groups (requires admin permissions).
+            limit: Maximum total number of groups to return.
+
+        Returns:
+            Iterable of lists of GroupResponse objects.
+        """
+        return self._iterate(
+            limit=limit,
+            params={"all": all_groups} if all_groups else None,
+        )
+
+    def list(self, all_groups: bool = False, limit: int | None = None) -> list[GroupResponse]:
+        """List all groups in CDF.
+
+        Args:
+            all_groups: Whether to return all groups (requires admin permissions).
+            limit: Maximum total number of groups to return.
+
+        Returns:
+            List of GroupResponse objects.
+        """
+        return self._list(limit=limit, params={"all": all_groups} if all_groups else None)

cognite_toolkit/_cdf_tk/client/api/instances.py

@@ -0,0 +1,139 @@
+from collections.abc import Iterable, 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.http_client import HTTPClient, ItemsSuccessResponse2, SuccessResponse2
+from cognite_toolkit._cdf_tk.client.request_classes.filters import InstanceFilter
+from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling import (
+    InstanceRequest,
+    InstanceResponse,
+    ViewReference,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import TypedInstanceIdentifier
+
+
+class InstancesAPI(CDFResourceAPI[TypedInstanceIdentifier, InstanceRequest, InstanceResponse]):
+    def __init__(self, http_client: HTTPClient) -> None:
+        super().__init__(
+            http_client=http_client,
+            method_endpoint_map={
+                "upsert": Endpoint(method="POST", path="/models/instances", item_limit=1000),
+                "retrieve": Endpoint(method="POST", path="/models/instances/byids", item_limit=1000),
+                "delete": Endpoint(method="POST", path="/models/instances/delete", item_limit=1000),
+                "list": Endpoint(method="POST", path="/models/instances/list", item_limit=1000),
+            },
+        )
+
+    def _validate_page_response(
+        self, response: SuccessResponse2 | ItemsSuccessResponse2
+    ) -> PagedResponse[InstanceResponse]:
+        return PagedResponse[InstanceResponse].model_validate_json(response.body)
+
+    def _validate_response(self, response: SuccessResponse2) -> ResponseItems[TypedInstanceIdentifier]:
+        return ResponseItems[TypedInstanceIdentifier].model_validate_json(response.body)
+
+    def create(self, items: Sequence[InstanceRequest]) -> list[InstanceResponse]:
+        """Create instances in CDF.
+
+        Args:
+            items: List of InstanceRequest objects to create.
+        Returns:
+            List of created InstanceResponse objects.
+        """
+        return self._request_item_response(items, "upsert")
+
+    def retrieve(
+        self, items: Sequence[TypedInstanceIdentifier], source: ViewReference | None = None
+    ) -> list[InstanceResponse]:
+        """Retrieve instances from CDF.
+
+        Args:
+            items: List of ExternalId objects to retrieve.
+            source: Optional ViewReference to specify the source view for the instances.
+        Returns:
+            List of retrieved InstanceResponse objects.
+        """
+        return self._request_item_response(
+            items, method="retrieve", extra_body={"sources": [{"source": source.dump()}]} if source else None
+        )
+
+    def delete(self, items: Sequence[TypedInstanceIdentifier]) -> list[TypedInstanceIdentifier]:
+        """Delete instances from CDF.
+
+        Args:
+            items: List of TypedInstanceIdentifier objects to delete.
+        """
+        response_items: list[TypedInstanceIdentifier] = []
+        for response in self._chunk_requests(items, "delete", self._serialize_items):
+            response_items.extend(self._validate_response(response).items)
+        return response_items
+
+    @staticmethod
+    def _create_sort_body(instance_type: Literal["node", "edge"] | None) -> list[dict]:
+        """We sort by space and externalId to get a stable sort order.
+
+        This is also more performant than sorting by using the default sort, which will sort on
+        internal CDF IDs. This will be slow if you have deleted a lot of instances, as they will be counted.
+        By sorting on space and externalId, we avoid this issue.
+        """
+        instance_type = instance_type or "node"
+        return [
+            {
+                "property": [instance_type, "space"],
+                "direction": "ascending",
+            },
+            {
+                "property": [instance_type, "externalId"],
+                "direction": "ascending",
+            },
+        ]
+
+    @classmethod
+    def _create_body(cls, filter: InstanceFilter | None) -> dict[str, Any]:
+        return {
+            **(filter.model_dump(exclude_none=True) if filter else {}),
+            "sort": cls._create_sort_body(filter.instance_type if filter else "node"),
+        }
+
+    def paginate(
+        self,
+        filter: InstanceFilter | None = None,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[InstanceResponse]:
+        """Iterate over all instances in CDF.
+
+        Args:
+           filter: InstanceFilter to filter instances.
+            limit: Maximum number of items to return.
+            cursor: Cursor for pagination.
+
+        Returns:
+            PagedResponse of InstanceResponse objects.
+        """
+        return self._paginate(
+            cursor=cursor,
+            limit=limit,
+            body=self._create_body(filter),
+        )
+
+    def iterate(self, filter: InstanceFilter | None = None, limit: int = 100) -> Iterable[list[InstanceResponse]]:
+        """Iterate over all instances in CDF.
+
+        Args:
+            filter: InstanceFilter to filter instances.
+            limit: Maximum number of items to return per page.
+
+        Returns:
+            Iterable of lists of InstanceResponse objects.
+        """
+        return self._iterate(limit=limit, body=self._create_body(filter))
+
+    def list(self, filter: InstanceFilter | None = None, limit: int | None = 100) -> list[InstanceResponse]:
+        """List all instances in CDF.
+
+        Returns:
+            List of InstanceResponse objects.
+        """
+        return self._list(limit=limit, body=self._create_body(filter))