cognite-toolkit 0.5.44__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/api/streams.py

@@ -0,0 +1,89 @@
+from collections.abc import Sequence
+
+from pydantic import TypeAdapter
+from rich.console import Console
+
+from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse
+from cognite_toolkit._cdf_tk.client.data_classes.streams import StreamRequest, StreamResponse
+from cognite_toolkit._cdf_tk.utils.http_client import (
+    HTTPClient,
+    ItemsRequest2,
+    ParamRequest,
+    RequestMessage2,
+)
+
+
+class StreamsAPI:
+    ENDPOINT = "/streams"
+
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self._console = console
+        self._config = http_client.config
+
+    def create(self, items: Sequence[StreamRequest]) -> list[StreamResponse]:
+        """Create one or more streams.
+
+        Args:
+            items: Sequence of StreamRequest items to create.
+
+        Returns:
+            List of created StreamResponse items.
+        """
+        responses = self._http_client.request_items_retries(
+            ItemsRequest2(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=items,
+            )
+        )
+        responses.raise_for_status()
+        return TypeAdapter(list[StreamResponse]).validate_python(responses.get_items())
+
+    def delete(self, external_id: str) -> None:
+        """Delete stream using its external ID.
+
+        Args:
+            external_id: External ID of the stream to delete.
+        """
+        responses = self._http_client.request_with_retries(
+            ParamRequest(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/{external_id}"),
+                method="DELETE",
+            )
+        )
+        responses.raise_for_status()
+
+    def list(self) -> list[StreamResponse]:
+        """List streams.
+
+        Returns:
+            StreamResponseList containing the listed streams.
+        """
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="GET",
+            )
+        )
+        success = response.get_success_or_raise()
+        return PagedResponse[StreamResponse].model_validate(success.body_json).items
+
+    def retrieve(self, external_id: str, include_statistics: bool = True) -> StreamResponse:
+        """Retrieve a stream by its external ID.
+
+        Args:
+            external_id: External ID of the stream to retrieve.
+            include_statistics: Whether to include usage statistics in the response.
+        Returns:
+            StreamResponse item.
+        """
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/{external_id}"),
+                method="GET",
+                parameters={"includeStatistics": include_statistics},
+            )
+        )
+        success = response.get_success_or_raise()
+        return StreamResponse.model_validate(success.body_json)

cognite_toolkit/_cdf_tk/client/api/three_d.py

@@ -0,0 +1,131 @@
+from collections.abc import Sequence
+
+from rich.console import Console
+
+from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse
+from cognite_toolkit._cdf_tk.client.data_classes.three_d import ThreeDModelClassicRequest, ThreeDModelResponse
+from cognite_toolkit._cdf_tk.utils.http_client import (
+    HTTPClient,
+    ItemsRequest,
+    RequestMessage2,
+    SimpleBodyRequest,
+)
+from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
+
+
+class ThreeDModelAPI:
+    ENDPOINT = "/3d/models"
+    MAX_CLASSIC_MODELS_PER_CREATE_REQUEST = 1000
+    MAX_MODELS_PER_DELETE_REQUEST = 1000
+    _LIST_REQUEST_MAX_LIMIT = 1000
+
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self._console = console
+        self._config = http_client.config
+
+    def create(self, models: Sequence[ThreeDModelClassicRequest]) -> list[ThreeDModelResponse]:
+        """Create 3D models in classic format.
+
+        Args:
+            models (Sequence[ThreeDModelClassicRequest]): The 3D model(s) to create.
+
+        Returns:
+            list[ThreeDModelResponse]: The created 3D model(s).
+        """
+        if not models:
+            return []
+        if len(models) > self.MAX_CLASSIC_MODELS_PER_CREATE_REQUEST:
+            raise ValueError("Cannot create more than 1000 3D models in a single request.")
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=list(models),
+            )
+        )
+        responses.raise_for_status()
+        body = responses.get_first_body()
+        return PagedResponse[ThreeDModelResponse].model_validate(body).items
+
+    def delete(self, ids: Sequence[int]) -> None:
+        """Delete 3D models by their IDs.
+
+        Args:
+            ids (Sequence[int]): The IDs of the 3D models to delete.
+        """
+        if not ids:
+            return None
+        if len(ids) > self.MAX_MODELS_PER_DELETE_REQUEST:
+            raise ValueError("Cannot delete more than 1000 3D models in a single request.")
+        responses = self._http_client.request_with_retries(
+            SimpleBodyRequest(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT + "/delete"),
+                method="POST",
+                body_content={"items": [{"id": id_} for id_ in ids]},
+            )
+        )
+        responses.raise_for_status()
+
+    def iterate(
+        self,
+        published: bool | None = None,
+        include_revision_info: bool = False,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[ThreeDModelResponse]:
+        if not (0 < limit <= self._LIST_REQUEST_MAX_LIMIT):
+            raise ValueError(f"Limit must be between 1 and {self._LIST_REQUEST_MAX_LIMIT}, got {limit}.")
+        parameters: dict[str, PrimitiveType] = {
+            # 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_single_retries(
+            RequestMessage2(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="GET",
+                parameters=parameters,
+            )
+        )
+        success_response = responses.get_success_or_raise()
+        return PagedResponse[ThreeDModelResponse].model_validate(success_response.body_json)
+
+    def list(
+        self,
+        published: bool | None = None,
+        include_revision_info: bool = False,
+        limit: int | None = 100,
+        cursor: str | None = None,
+    ) -> list[ThreeDModelResponse]:
+        results: list[ThreeDModelResponse] = []
+        while True:
+            request_limit = (
+                self._LIST_REQUEST_MAX_LIMIT
+                if limit is None
+                else min(limit - len(results), self._LIST_REQUEST_MAX_LIMIT)
+            )
+            if request_limit <= 0:
+                break
+            page = self.iterate(
+                published=published,
+                include_revision_info=include_revision_info,
+                limit=request_limit,
+                cursor=cursor,
+            )
+            results.extend(page.items)
+            if page.next_cursor is None:
+                break
+            cursor = page.next_cursor
+        return results
+
+
+class ThreeDAPI:
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self.models = ThreeDModelAPI(http_client, console)

cognite_toolkit/_cdf_tk/client/api/token.py

@@ -0,0 +1,111 @@
+from functools import cached_property
+
+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.utils import humanize_collection
+
+_ACL_CLASS_BY_CLASS_NAME = {cap.__name__: cap for cap in _CAPABILITY_CLASS_BY_NAME.values()}
+
+
+class TokenAPI:
+    def __init__(self, client: CogniteClient):
+        self._client = client
+
+    @cached_property
+    def token(self) -> TokenInspection:
+        return self._client.iam.token.inspect()
+
+    def get_scope(self, actions: list[Capability.Action]) -> list[Capability.Scope] | None:
+        """Gets the scopes for the given actions and ACL class from the token.
+
+        Args:
+            actions:  List of actions to get scopes for.
+
+        Returns:
+            A list of scopes that apply to all the actions, or None if no scopes are found.
+        """
+        acl_cls = self._get_acl_class(actions)
+        # First, we find the union of all scopes for a given action,
+        # then we find the intersection of those scopes across all actions.
+        scope_union_by_action_by_scope_cls = self._union_by_action_by_scope_cls(acl_cls, set(actions))
+        if not scope_union_by_action_by_scope_cls:
+            return None
+        return self._intersection_over_actions(scope_union_by_action_by_scope_cls)
+
+    @staticmethod
+    def _get_acl_class(actions: list[Capability.Action]) -> type[Capability]:
+        """Returns the ACL class that matches the given actions."""
+        classes: set[type[Capability]] = set()
+        for action in actions:
+            action_class_name = type(action).__qualname__.split(".")[0]
+            if action_class_name not in _ACL_CLASS_BY_CLASS_NAME:
+                raise ValueError(f"Unknown action class: {action_class_name}")
+            classes.add(_ACL_CLASS_BY_CLASS_NAME[action_class_name])
+        if len(classes) > 1:
+            raise ValueError(
+                f"Actions belong to multiple ACL classes: {humanize_collection([cls.__name__ for cls in classes])}."
+            )
+        if len(classes) == 0:
+            raise ValueError("No actions provided to get_scope")
+        return next(iter(classes))
+
+    @staticmethod
+    def _intersection_over_actions(
+        scopes_by_action: dict[Capability.Action, dict[type[Capability.Scope], Capability.Scope]],
+    ) -> list[Capability.Scope] | None:
+        all_scope_actions = {
+            action for action, scopes_by_cls in scopes_by_action.items() if AllScope in scopes_by_cls.keys()
+        }
+        if len(all_scope_actions) == len(scopes_by_action):
+            # Special case: if AllScope is in all actions, return it directly
+            return [AllScope()]
+        intersection_scopes = set.intersection(
+            *[
+                set(scopes_by_cls.keys())
+                for action, scopes_by_cls in scopes_by_action.items()
+                if action not in all_scope_actions
+            ]
+        )
+        if not intersection_scopes:
+            return None
+        output_scopes: list[Capability.Scope] = []
+        for scope_cls in sorted(intersection_scopes, key=lambda cls: cls.__name__):
+            scopes = [
+                scopes_by_cls[scope_cls] for scopes_by_cls in scopes_by_action.values() if scope_cls in scopes_by_cls
+            ]
+            if len(scopes) == 0:
+                # Should not happen, as we already checked for intersection_scopes
+                continue
+            elif len(scopes) == 1:
+                output_scopes.append(scopes[0])
+            else:
+                intersection: Capability.Scope | None = scopes[0]
+                for scope in scopes[1:]:
+                    intersection = scope_intersection(scope, intersection)
+                    if intersection is None:
+                        break
+                if intersection is None:
+                    # If the intersection is None, it means the scopes do not intersect
+                    continue
+                output_scopes.append(intersection)
+        return output_scopes or None
+
+    def _union_by_action_by_scope_cls(
+        self, acl_cls: type[Capability], actions: set[Capability.Action]
+    ) -> dict[Capability.Action, dict[type[Capability.Scope], Capability.Scope]]:
+        scopes_by_action: dict[Capability.Action, dict[type[Capability.Scope], Capability.Scope]] = {}
+        for action in actions:
+            scopes_by_action[action] = {}
+        for project_capability in self.token.capabilities:
+            capability = project_capability.capability
+            if not isinstance(capability, acl_cls):
+                continue
+            for action in capability.actions:
+                if action in actions:
+                    scopes_by_cls = scopes_by_action[action]
+                    scope_cls = type(capability.scope)
+                    scopes_by_cls[scope_cls] = scope_union(capability.scope, scopes_by_cls.get(scope_cls))
+        return scopes_by_action

cognite_toolkit/_cdf_tk/client/config.py

@@ -0,0 +1,120 @@
+from typing import Literal
+from urllib.parse import urljoin
+
+from cognite.client import ClientConfig
+from cognite.client.credentials import CredentialProvider
+
+
+class ToolkitClientConfig(ClientConfig):
+    def __init__(
+        self,
+        client_name: str,
+        project: str,
+        credentials: CredentialProvider,
+        api_subversion: str | None = None,
+        base_url: str | None = None,
+        max_workers: int | None = None,
+        is_strict_validation: bool = True,
+        headers: dict[str, str] | None = None,
+        timeout: int | None = None,
+        file_transfer_timeout: int | None = None,
+        debug: bool = False,
+    ) -> None:
+        super().__init__(
+            client_name=client_name,
+            project=project,
+            credentials=credentials,
+            api_subversion=api_subversion,
+            base_url=base_url,
+            max_workers=max_workers,
+            headers=headers,
+            timeout=timeout,
+            file_transfer_timeout=file_transfer_timeout,
+            debug=debug,
+        )
+        self.is_strict_validation = is_strict_validation
+
+    @classmethod
+    def from_client_config(cls, config: ClientConfig, is_strict_validation: bool = True) -> "ToolkitClientConfig":
+        return cls(
+            client_name=config.client_name,
+            project=config.project,
+            credentials=config.credentials,
+            api_subversion=config.api_subversion,
+            base_url=config.base_url,
+            max_workers=config.max_workers,
+            headers=config.headers,
+            timeout=config.timeout,
+            file_transfer_timeout=config.file_transfer_timeout,
+            debug=config.debug,
+            is_strict_validation=is_strict_validation,
+        )
+
+    @property
+    def cloud_provider(self) -> Literal["azure", "aws", "gcp", "unknown"]:
+        cdf_cluster = self.cdf_cluster
+        if cdf_cluster is None:
+            return "unknown"
+        elif cdf_cluster.startswith("az-") or cdf_cluster in {"azure-dev", "bluefield", "westeurope-1"}:
+            return "azure"
+        elif cdf_cluster.startswith("aws-") or cdf_cluster in {"orangefield"}:
+            return "aws"
+        elif cdf_cluster.startswith("gc-") or cdf_cluster in {
+            "greenfield",
+            "asia-northeast1-1",
+            "cognitedata-development",
+            "cognitedata-production",
+        }:
+            return "gcp"
+        else:
+            return "unknown"
+
+    @property
+    def is_private_link(self) -> bool:
+        if "cognitedata.com" not in self.base_url:
+            return False
+        subdomain = self.base_url.split("cognitedata.com", maxsplit=1)[0]
+        return "plink" in subdomain
+
+    @property
+    def base_api_url(self) -> str:
+        return f"{self.base_url}/api/v1/projects/{self.project}"
+
+    def create_api_url(self, endpoint: str) -> str:
+        """Create a full API URL for the given endpoint.
+
+        Args:
+            endpoint (str): The API endpoint to append to the base URL.
+
+        Returns:
+            str: The full API URL.
+
+        Examples:
+            >>> config = ToolkitClientConfig(cluster="bluefield", project="my_project", ...)
+            >>> config.create_api_url("/models/instances")
+            "https://bluefield.cognitedata.com/api/v1/my_project/models/instances"
+        """
+        if not endpoint.startswith("/"):
+            endpoint = f"/{endpoint}"
+        return f"{self.base_api_url}{endpoint}"
+
+    def create_app_url(self, endpoint: str) -> str:
+        """Create a full App URL for the given endpoint.
+
+        Args:
+            endpoint (str): The App endpoint to append to the base URL.
+
+        Returns:
+            str: The full App URL.
+
+        Examples:
+            >>> config = ToolkitClientConfig(cluster="bluefield", project="my_project", ...)
+            >>> config.create_app_url("/some/app/endpoint")
+            "https://bluefield.cognitedata.com/apps/v1/projects/my_project/some/app/endpoint"
+        """
+        if not endpoint:
+            raise ValueError("Endpoint must be a non-empty string")
+        if not endpoint.startswith("/"):
+            endpoint = f"/{endpoint}"
+        base_path = f"/apps/v1/projects/{self.project}{endpoint}"
+        return urljoin(self.base_url, base_path)

cognite_toolkit/_cdf_tk/client/data_classes/api_classes.py

@@ -0,0 +1,17 @@
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel, Field, JsonValue
+
+T = TypeVar("T", bound=BaseModel)
+
+
+class PagedResponse(BaseModel, Generic[T]):
+    items: list[T]
+    next_cursor: str | None = Field(None, alias="nextCursor")
+
+
+class QueryResponse(BaseModel, Generic[T]):
+    items: dict[str, list[T]]
+    typing: dict[str, JsonValue] | None = None
+    next_cursor: dict[str, str] = Field(alias="nextCursor")
+    debug: dict[str, JsonValue] | None = None

cognite_toolkit/_cdf_tk/client/data_classes/base.py

@@ -0,0 +1,71 @@
+import sys
+from abc import ABC, abstractmethod
+from collections import UserList
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from pydantic import BaseModel, ConfigDict
+from pydantic.alias_generators import to_camel
+
+from cognite_toolkit._cdf_tk.utils.http_client._data_classes2 import BaseModelObject, RequestResource
+
+if TYPE_CHECKING:
+    from cognite.client import CogniteClient
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+T_RequestResource = TypeVar("T_RequestResource", bound=RequestResource)
+
+
+class ResponseResource(BaseModelObject, Generic[T_RequestResource], ABC):
+    @abstractmethod
+    def as_request_resource(self) -> T_RequestResource:
+        """Convert the response resource to a request resource."""
+        ...
+
+    def as_write(self) -> T_RequestResource:
+        """Alias for as_request_resource to match protocol signature."""
+        return self.as_request_resource()
+
+
+class Identifier(BaseModel):
+    """Base class for all identifier classes."""
+
+    model_config = ConfigDict(alias_generator=to_camel, extra="ignore", populate_by_name=True, frozen=True)
+
+    def dump(self, include_type: bool = True) -> dict[str, Any]:
+        """Dump the identifier to a dictionary.
+
+        Args:
+            include_type (bool): Whether to include the type of the identifier in the output.
+
+        Returns:
+            dict[str, Any]: The dumped identifier.
+        """
+        return self.model_dump(mode="json", by_alias=True, exclude_defaults=not include_type)
+
+    def as_id(self) -> Self:
+        return self
+
+
+T_Resource = TypeVar("T_Resource", bound=RequestResource | ResponseResource)
+
+
+class BaseResourceList(UserList[T_Resource]):
+    """Base class for resource lists."""
+
+    _RESOURCE: type[T_Resource]
+
+    def __init__(self, initlist: list[T_Resource] | None = None, **_: Any) -> None:
+        super().__init__(initlist or [])
+
+    def dump(self, camel_case: bool = True) -> list[dict[str, Any]]:
+        return [item.dump(camel_case) for item in self.data]
+
+    @classmethod
+    def load(cls, data: list[dict[str, Any]], cognite_client: "CogniteClient | None" = None) -> Self:
+        items = [cls._RESOURCE.model_validate(item) for item in data]
+        return cls(items)  # type: ignore[arg-type]