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

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/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]

cognite_toolkit/_cdf_tk/client/data_classes/canvas.py

@@ -1,9 +1,17 @@
+import sys
 from abc import ABC
-from collections.abc import Mapping, Sequence
+from collections.abc import Sequence
 from datetime import datetime, timezone
-from typing import Any
+from typing import Any, TypeVar
 from uuid import uuid4
 
+from cognite.client import CogniteClient
+from cognite.client.data_classes._base import (
+    CogniteResource,
+    CogniteResourceList,
+    WriteableCogniteResource,
+    WriteableCogniteResourceList,
+)
 from cognite.client.data_classes.data_modeling import (
     DirectRelationReference,
     EdgeId,
@@ -23,6 +31,13 @@ from cognite.client.data_classes.data_modeling.instances import (
 )
 
 from cognite_toolkit._cdf_tk.client.data_classes.migration import AssetCentricId
+from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
 
 CANVAS_INSTANCE_SPACE = "IndustrialCanvasInstanceSpace"
 SOLUTION_TAG_SPACE = "SolutionTagsInstanceSpace"
@@ -54,6 +69,9 @@ class ExtendedTypedNodeApply(TypedNodeApply, ABC):
         return output
 
 
+T_ExtendedTypedNodeApply = TypeVar("T_ExtendedTypedNodeApply", bound=ExtendedTypedNodeApply)
+
+
 class _CanvasProperties:
     created_by = PropertyOptions("createdBy")
     updated_at = PropertyOptions("updatedAt")
@@ -205,7 +223,7 @@ class Canvas(_CanvasProperties, TypedNode):
             source_canvas_id=self.source_canvas_id,
             is_archived=self.is_archived,
             context=self.context,
-            solution_tags=self.solution_tags,  # type: ignore[arg-type]
+            solution_tags=self.solution_tags,
             existing_version=self.version,
             type=self.type,
         )
@@ -815,7 +833,7 @@ class FdmInstanceContainerReference(_FdmInstanceContainerReferenceProperties, Ty
         )
 
 
-class IndustrialCanvasApply:
+class IndustrialCanvasApply(CogniteResource):
     """This class represents the writing format of IndustrialCanvas.
     It is used to when data is written to CDF.
     Args:
@@ -887,7 +905,7 @@ class IndustrialCanvasApply:
                 raise TypeError(f"Unexpected instance type: {type(instance)}")
         return ids
 
-    def dump(self, keep_existing_version: bool = True) -> dict[str, object]:
+    def dump(self, keep_existing_version: bool = True) -> dict[str, JsonVal]:
         """Dump the IndustrialCanvasApply to a dictionary."""
         return {
             "canvas": self.canvas.dump(keep_existing_version=keep_existing_version),
@@ -936,8 +954,52 @@ class IndustrialCanvasApply:
                 new_item_list.append(new_item)
         return new_container
 
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        """Load an IndustrialCanvasApply instance from a resource dictionary."""
+        if "canvas" not in resource:
+            raise ValueError("Resource does not contain a canvas node.")
+        canvas_resource = resource["canvas"]
+        if isinstance(canvas_resource, dict):
+            canvas = CanvasApply._load(canvas_resource)
+        elif isinstance(canvas_resource, CanvasApply):
+            canvas = canvas_resource
+        elif isinstance(canvas_resource, NodeApply):
+            canvas = CanvasApply._load(canvas_resource.dump())
+        else:
+            raise TypeError(f"Canvas resource {type(canvas_resource)} is not supported.")
+        return cls(
+            canvas=canvas,
+            annotations=cls._load_apply_items(resource.get("annotations"), CanvasAnnotationApply),
+            container_references=cls._load_apply_items(resource.get("containerReferences"), ContainerReferenceApply),
+            fdm_instance_container_references=cls._load_apply_items(
+                resource.get("fdmInstanceContainerReferences"), FdmInstanceContainerReferenceApply
+            ),
+            solution_tags=cls._load_apply_items(resource.get("solutionTags"), CogniteSolutionTagApply),
+        )
 
-class IndustrialCanvas:
+    @classmethod
+    def _load_apply_items(
+        cls, items: object | None, node_cls: type[T_ExtendedTypedNodeApply]
+    ) -> list[T_ExtendedTypedNodeApply]:
+        if items is None:
+            return []
+        elif isinstance(items, Sequence):
+            nodes: list[T_ExtendedTypedNodeApply] = []
+            for node in items:
+                if isinstance(node, dict):
+                    nodes.append(node_cls._load(node))
+                elif isinstance(node, node_cls):
+                    nodes.append(node)
+                elif isinstance(node, NodeApply):
+                    nodes.append(node_cls._load(node.dump()))
+                else:
+                    raise TypeError(f"Expected a sequence of {node_cls.__name__}, got {type(node).__name__}")
+            return nodes
+        raise TypeError(f"Expected a sequence of {node_cls.__name__}, got {type(items).__name__}")
+
+
+class IndustrialCanvas(WriteableCogniteResource[IndustrialCanvasApply]):
     """This class represents one instance of the Canvas with all connected data."""
 
     def __init__(
@@ -957,7 +1019,7 @@ class IndustrialCanvas:
         self.solution_tags = solution_tags or NodeListWithCursor[CogniteSolutionTag]([], None)
 
     @classmethod
-    def load(cls, resource: Mapping[str, list]) -> "IndustrialCanvas":
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> "IndustrialCanvas":
         """Load an IndustrialCanvas instance from a QueryResult."""
         if not ("canvas" in resource and isinstance(resource["canvas"], Sequence) and len(resource["canvas"]) == 1):
             raise ValueError("Resource does not contain a canvas node.")
@@ -1003,8 +1065,10 @@ class IndustrialCanvas:
             )
         raise TypeError(f"Expected a sequence of {node_cls.__name__}, got {type(items).__name__}")
 
-    def dump(self) -> dict[str, list]:
+    def dump(self, camel_case: bool = True) -> dict[str, list]:
         """Dump the IndustrialCanvas to a dictionary."""
+        if not camel_case:
+            raise NotImplementedError("snake_case dump is not supported")
         return {
             "canvas": [self.canvas.dump()],
             "annotations": [annotation.dump() for annotation in self.annotations],
@@ -1027,3 +1091,17 @@ class IndustrialCanvas:
             ],
             solution_tags=[solution_tag.as_write() for solution_tag in self.solution_tags],
         )
+
+    def as_id(self) -> str:
+        return self.canvas.external_id
+
+
+class IndustrialCanvasApplyList(CogniteResourceList):
+    _RESOURCE = IndustrialCanvasApply
+
+
+class IndustrialCanvasList(WriteableCogniteResourceList[IndustrialCanvasApply, IndustrialCanvas]):
+    _RESOURCE = IndustrialCanvas
+
+    def as_write(self) -> CogniteResourceList[IndustrialCanvasApply]:
+        return IndustrialCanvasApplyList([item.as_write() for item in self])

cognite_toolkit/_cdf_tk/client/data_classes/charts.py

@@ -0,0 +1,114 @@
+import sys
+from abc import ABC
+from typing import Any, Literal, TypeAlias
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes._base import (
+    CogniteResourceList,
+    WriteableCogniteResource,
+    WriteableCogniteResourceList,
+)
+
+from cognite_toolkit._cdf_tk.client.data_classes.charts_data import ChartData
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+Visibility: TypeAlias = Literal["PUBLIC", "PRIVATE"]
+
+
+class ChartCore(WriteableCogniteResource["ChartWrite"], ABC):
+    """Base class for the Chart data model.
+
+    Args:
+        external_id (str): Unique identifier for the chart.
+        visibility (Visibility): Visibility of the chart, either 'PUBLIC' or 'PRIVATE'.
+        data (ChartData): The data associated with the chart.
+    """
+
+    def __init__(self, external_id: str, visibility: Visibility, data: ChartData) -> None:
+        self.external_id = external_id
+        self.visibility = visibility
+        self.data = data
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        """Convert the chart to a dictionary representation."""
+        output = super().dump(camel_case=camel_case)
+        output["data"] = self.data.model_dump(mode="json", by_alias=camel_case, exclude_unset=True)
+        return output
+
+
+class ChartWrite(ChartCore):
+    """A chart that can be written to the CDF.
+
+    Args:
+        external_id (str): Unique identifier for the chart.
+        visibility (Visibility): Visibility of the chart, either 'PUBLIC' or 'PRIVATE'.
+        data (ChartData): The data associated with the chart.
+
+    """
+
+    def as_write(self) -> "ChartWrite":
+        return self
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            external_id=resource["externalId"],
+            visibility=resource["visibility"],
+            data=ChartData._load(resource["data"]),
+        )
+
+
+class Chart(ChartCore):
+    """A chart that can be read from the CDF.
+
+    Args:
+        external_id (str): Unique identifier for the chart.
+        created_time (int): Timestamp when the chart was created.
+        last_updated_time (int): Timestamp when the chart was last updated.
+        visibility (Visibility): Visibility of the chart, either 'PUBLIC' or 'PRIVATE'.
+        data (ChartData): The data associated with the chart.
+        owner_id (str): The ID of the user who owns the chart.
+    """
+
+    def __init__(
+        self,
+        external_id: str,
+        created_time: int,
+        last_updated_time: int,
+        visibility: Visibility,
+        data: ChartData,
+        owner_id: str,
+    ) -> None:
+        super().__init__(external_id, visibility, data)
+        self.created_time = created_time
+        self.last_updated_time = last_updated_time
+        self.owner_id = owner_id
+
+    def as_write(self) -> ChartWrite:
+        return ChartWrite(external_id=self.external_id, visibility=self.visibility, data=self.data)
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            external_id=resource["externalId"],
+            created_time=resource["createdTime"],
+            last_updated_time=resource["lastUpdatedTime"],
+            visibility=resource["visibility"],
+            data=ChartData._load(resource["data"]),
+            owner_id=resource["ownerId"],
+        )
+
+
+class ChartWriteList(CogniteResourceList):
+    _RESOURCE = ChartWrite
+
+
+class ChartList(WriteableCogniteResourceList[ChartWrite, Chart]):
+    _RESOURCE = Chart
+
+    def as_write(self) -> ChartWriteList:
+        return ChartWriteList([item.as_write() for item in self])