cognite-toolkit 0.7.38__py3-none-any.whl → 0.7.40__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/data_classes/asset.py

@@ -0,0 +1,54 @@
+from typing import Literal
+
+from pydantic import JsonValue
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import BaseModelObject, RequestUpdateable, ResponseResource
+
+from .identifiers import ExternalId
+
+
+class AssetRequest(RequestUpdateable):
+    container_fields = frozenset({"metadata", "labels"})
+    non_nullable_fields = frozenset({"parent_id", "parent_external_id"})
+    external_id: str | None = None
+    name: str
+    parent_id: int | None = None
+    parent_external_id: str | None = None
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    data_set_id: int | None = None
+    source: str | None = None
+    labels: list[dict[Literal["externalId"], str]] | None = None
+    geo_location: dict[str, JsonValue] | None = None
+
+    def as_id(self) -> ExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert AssetRequest to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class AssetAggregateItem(BaseModelObject):
+    child_count: int
+    depth: int
+    path: list[dict[Literal["id"], int]]
+
+
+class AssetResponse(ResponseResource[AssetRequest]):
+    created_time: int
+    last_updated_time: int
+    root_id: int
+    aggregates: AssetAggregateItem | None = None
+    id: int
+    external_id: str | None = None
+    name: str
+    parent_id: int | None = None
+    parent_external_id: str | None = None
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    data_set_id: int | None = None
+    source: str | None = None
+    labels: list[dict[Literal["externalId"], str]] | None = None
+    geo_location: dict[str, JsonValue] | None = None
+
+    def as_request_resource(self) -> AssetRequest:
+        return AssetRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/base.py

@@ -1,55 +1,150 @@
 import sys
+import types
 from abc import ABC, abstractmethod
 from collections import UserList
-from typing import TYPE_CHECKING, Any, Generic, TypeVar
+from typing import Any, ClassVar, Generic, Literal, TypeVar, Union, get_args, get_origin
 
-from pydantic import ConfigDict
+from cognite.client import CogniteClient
+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 BaseModelObject(BaseModel):
+    """Base class for all object. This includes resources and nested objects."""
 
+    # We allow extra fields to support forward compatibility.
+    model_config = ConfigDict(alias_generator=to_camel, extra="allow")
 
-class ResponseResource(BaseModelObject, Generic[T_RequestResource], ABC):
-    @abstractmethod
-    def as_request_resource(self) -> T_RequestResource:
-        """Convert the response resource to a request resource."""
-        ...
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
 
-    def as_write(self) -> T_RequestResource:
-        """Alias for as_request_resource to match protocol signature."""
-        return self.as_request_resource()
+        This is the default serialization method for request resources.
+        """
+        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=True)
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any]) -> Self:
+        """Load method to match CogniteResource signature."""
+        return cls.model_validate(resource)
 
 
-class Identifier(RequestResource, ABC):
-    """Base class for all identifier classes."""
+class Identifier(BaseModelObject):
+    """Base class for all identifier objects typically
+    {"externalId": "..."}, {"id": ...}, {"space": "...", "externalId: }."""
 
     model_config = ConfigDict(alias_generator=to_camel, extra="ignore", populate_by_name=True, frozen=True)
 
-    def dump(self, camel_case: bool = True, include_type: bool = True) -> dict[str, Any]:
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
         """Dump the resource to a dictionary.
 
         This is the default serialization method for request resources.
         """
-        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=not include_type)
+        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=True)
+
+    def __str__(self) -> str:
+        raise NotImplementedError()
+
+
+T_Identifier = TypeVar("T_Identifier", bound=Identifier)
+
+
+class RequestResource(BaseModelObject, ABC):
+    @abstractmethod
+    def as_id(self) -> Identifier:
+        raise NotImplementedError()
+
+    def __str__(self) -> str:
+        return str(self.as_id())
+
+
+T_RequestResource = TypeVar("T_RequestResource", bound=RequestResource)
+
+
+class RequestUpdateable(RequestResource, ABC):
+    container_fields: ClassVar[frozenset[str]] = frozenset()
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset()
+
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
+        """Convert the request resource to an update item."""
+        update_item = self.as_id().dump(camel_case=True)
+        update: dict[str, Any] = {}
+        field_by_name = {info.alias or field_id: (field_id, info) for field_id, info in type(self).model_fields.items()}
+        # When mode is "patch", we only include fields that are set
+        exclude_unset = mode == "patch"
+        for key, value in self.model_dump(mode="json", by_alias=True, exclude_unset=exclude_unset).items():
+            if key in update_item:
+                # Skip identifier fields
+                continue
+            if key not in field_by_name:
+                # Skip unknown fields
+                continue
+            field_id, info = field_by_name[key]
+            if field_id in self.container_fields:
+                if mode == "patch":
+                    update[key] = {"add": value}
+                elif mode == "replace":
+                    if value is None:
+                        origin = _get_annotation_origin(info.annotation)
+                        if origin is list:
+                            update[key] = {"set": []}
+                        elif origin is dict:
+                            update[key] = {"set": {}}
+                        else:
+                            raise NotImplementedError(
+                                f'Cannot replace container field "{key}" with None when its type is unknown.'
+                            )
+                    else:
+                        update[key] = {"set": value}
+                else:
+                    raise NotImplementedError(f'Update mode "{mode}" is not supported for container fields.')
+            elif value is None:
+                if field_id not in self.non_nullable_fields:
+                    update[key] = {"setNull": True}
+            else:
+                update[key] = {"set": value}
+        update_item["update"] = update
+        return update_item
+
+
+def _get_annotation_origin(field_type: Any) -> Any:
+    origin = get_origin(field_type)
+    args = get_args(field_type)
+
+    # Check for Union type (both typing.Union and | syntax from Python 3.10+)
+    is_union = origin is Union or isinstance(field_type, getattr(types, "UnionType", ()))
+
+    if is_union:
+        # Handle Optional[T] by filtering out NoneType
+        none_types = (type(None), types.NoneType)
+        non_none_args = [arg for arg in args if arg not in none_types]
+        if len(non_none_args) == 1:
+            field_type = non_none_args[0]
+            origin = get_origin(field_type) or field_type
+    return origin
+
+
+class ResponseResource(BaseModelObject, Generic[T_RequestResource], ABC):
+    @abstractmethod
+    def as_request_resource(self) -> T_RequestResource:
+        """Convert the response resource to a request resource."""
+        raise NotImplementedError()
+
+    def as_write(self) -> T_RequestResource:
+        """Alias for as_request_resource to match protocol signature."""
+        return self.as_request_resource()
 
-    def as_id(self) -> Self:
-        return self
 
+T_ResponseResource = TypeVar("T_ResponseResource", bound=ResponseResource)
 
 T_Resource = TypeVar("T_Resource", bound=RequestResource | ResponseResource)
 
 
+# Todo: Delete this class and use list[T_Resource] directly
 class BaseResourceList(UserList[T_Resource]):
     """Base class for resource lists."""
 

cognite_toolkit/_cdf_tk/client/data_classes/event.py

@@ -0,0 +1,40 @@
+from cognite_toolkit._cdf_tk.client.data_classes.base import RequestResource, ResponseResource
+
+from .identifiers import ExternalId, InternalOrExternalId
+
+
+class EventRequest(RequestResource):
+    external_id: str | None = None
+    data_set_id: int | None = None
+    start_time: int | None = None
+    end_time: int | None = None
+    type: str | None = None
+    subtype: str | None = None
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    asset_ids: list[int] | None = None
+    source: str | None = None
+
+    def as_id(self) -> InternalOrExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert EventRequest to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class EventResponse(ResponseResource[EventRequest]):
+    external_id: str | None = None
+    data_set_id: int | None = None
+    start_time: int | None = None
+    end_time: int | None = None
+    type: str | None = None
+    subtype: str | None = None
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    asset_ids: list[int] | None = None
+    source: str | None = None
+    id: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> EventRequest:
+        return EventRequest.model_validate(self.dump())

cognite_toolkit/_cdf_tk/client/data_classes/identifiers.py

@@ -0,0 +1,44 @@
+from collections.abc import Sequence
+from typing import Annotated, Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import Identifier
+
+
+class InternalOrExternalIdDefinition(Identifier):
+    type: str
+
+
+class InternalId(InternalOrExternalIdDefinition):
+    type: Literal["id"] = Field("id", exclude=True)
+    id: int
+
+    @classmethod
+    def from_ids(cls, ids: Sequence[int]) -> list["InternalId"]:
+        return [cls(id=id_) for id_ in ids]
+
+    def __str__(self) -> str:
+        return f"id={self.id}"
+
+
+class ExternalId(InternalOrExternalIdDefinition):
+    type: Literal["externalId"] = Field("externalId", exclude=True)
+    external_id: str
+
+    @classmethod
+    def from_external_ids(cls, external_ids: list[str]) -> list["ExternalId"]:
+        return [cls(external_id=ext_id) for ext_id in external_ids]
+
+    def __str__(self) -> str:
+        return f"externalId='{self.external_id}'"
+
+
+InternalOrExternalId = Annotated[InternalId | ExternalId, Field(discriminator="type")]
+
+
+class NameId(Identifier):
+    name: str
+
+    def __str__(self) -> str:
+        return f"name='{self.name}'"

cognite_toolkit/_cdf_tk/client/data_classes/instance_api.py

@@ -14,19 +14,38 @@ class TypedInstanceIdentifier(Identifier):
     space: str
     external_id: str
 
+    def __str__(self) -> str:
+        return f"Instance({self.instance_type}, {self.space}, {self.external_id})"
+
+    def dump(self, camel_case: bool = True, include_type: bool = True) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
+
+        This is the default serialization method for request resources.
+        """
+        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=not include_type)
+
 
 class TypedNodeIdentifier(TypedInstanceIdentifier):
     instance_type: Literal["node"] = "node"
 
+    def __str__(self) -> str:
+        return f"Node({self.space}, {self.external_id})"
+
 
 class TypedEdgeIdentifier(TypedInstanceIdentifier):
     instance_type: Literal["edge"] = "edge"
 
+    def __str__(self) -> str:
+        return f"Edge({self.space}, {self.external_id})"
+
 
 class InstanceIdentifier(Identifier):
     space: str
     external_id: str
 
+    def __str__(self) -> str:
+        return f"Instance({self.space}, {self.external_id})"
+
 
 class InstanceResult(BaseModelObject):
     instance_type: InstanceType
@@ -51,6 +70,16 @@ class ViewReference(Identifier):
     external_id: str
     version: str
 
+    def __str__(self) -> str:
+        return f"View({self.space}, {self.external_id}, v{self.version})"
+
+    def dump(self, camel_case: bool = True, include_type: bool = True) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
+
+        This is the default serialization method for request resources.
+        """
+        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=not include_type)
+
 
 ######################################################
 # The classes below are helper classes for making instances request/responses.
@@ -160,3 +189,8 @@ class InstanceResponseItem(BaseModelObject):
             space=self.space,
             external_id=self.external_id,
         )
+
+
+class NodeReference(BaseModelObject):
+    space: str
+    external_id: str

cognite_toolkit/_cdf_tk/client/data_classes/streams.py

@@ -7,6 +7,7 @@ from cognite_toolkit._cdf_tk.protocols import (
 )
 
 from .base import BaseModelObject, BaseResourceList, RequestResource, ResponseResource
+from .identifiers import ExternalId
 
 
 class StreamRequest(RequestResource):
@@ -15,8 +16,8 @@ class StreamRequest(RequestResource):
     external_id: str
     settings: dict[Literal["template"], dict[Literal["name"], StreamTemplateName]]
 
-    def as_id(self) -> str:
-        return self.external_id
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
 
 
 class StreamRequestList(BaseResourceList[StreamRequest], ResourceRequestListProtocol):

cognite_toolkit/_cdf_tk/client/data_classes/three_d.py

@@ -1,14 +1,16 @@
-from collections.abc import Hashable
+import sys
 from typing import Literal
 
 from pydantic import Field
 
-from .base import BaseModelObject, RequestResource, ResponseResource
+from .base import BaseModelObject, Identifier, RequestResource, ResponseResource
+from .identifiers import NameId
+from .instance_api import NodeReference
 
-
-class NodeReference(BaseModelObject):
-    space: str
-    external_id: str
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
 
 
 class RevisionStatus(BaseModelObject):
@@ -22,17 +24,14 @@ class RevisionStatus(BaseModelObject):
 class ThreeDModelRequest(RequestResource):
     name: str
 
-    def as_id(self) -> str:
-        return self.name
+    def as_id(self) -> NameId:
+        return NameId(name=self.name)
 
 
 class ThreeDModelClassicRequest(ThreeDModelRequest):
     data_set_id: int | None = None
     metadata: dict[str, str] | None = None
 
-    def as_id(self) -> str:
-        return self.name
-
 
 class ThreeDModelDMSRequest(ThreeDModelRequest):
     space: str
@@ -56,24 +55,21 @@ class ThreeDModelResponse(ResponseResource[ThreeDModelRequest]):
             return ThreeDModelDMSRequest._load(self.dump())
 
 
-class AssetMappingDMRequest(RequestResource):
+class AssetMappingDMRequest(RequestResource, Identifier):
     node_id: int
     asset_instance_id: NodeReference
     # These fields are part of the path request and not the body schema.
     model_id: int = Field(exclude=True)
     revision_id: int = Field(exclude=True)
 
-    def as_id(self) -> Hashable:
-        return (
-            self.model_id,
-            self.revision_id,
-            self.node_id,
-            self.asset_instance_id.space,
-            self.asset_instance_id.external_id,
-        )
+    def as_id(self) -> Self:
+        return self
 
+    def __str__(self) -> str:
+        return f"{self.model_id}_{self.revision_id}_{self.node_id}_{self.asset_instance_id.space}_{self.asset_instance_id.external_id}"
 
-class AssetMappingClassicRequest(RequestResource):
+
+class AssetMappingClassicRequest(RequestResource, Identifier):
     node_id: int
     asset_id: int | None = None
     asset_instance_id: NodeReference | None = None
@@ -81,19 +77,18 @@ class AssetMappingClassicRequest(RequestResource):
     model_id: int = Field(exclude=True)
     revision_id: int = Field(exclude=True)
 
-    def as_id(self) -> Hashable:
-        if self.asset_id:
-            return self.model_id, self.revision_id, self.node_id, self.asset_id
-        elif self.asset_instance_id:
-            return (
-                self.model_id,
-                self.revision_id,
-                self.node_id,
-                self.asset_instance_id.space,
-                self.asset_instance_id.external_id,
-            )
-        else:
-            raise AttributeError("asset_id or asset_instance_id is required")
+    def as_id(self) -> Self:
+        return self
+
+    def __str__(self) -> str:
+        asset_part = (
+            f"assetId:{self.asset_id}"
+            if self.asset_id is not None
+            else f"assetInstance:{self.asset_instance_id.space}_{self.asset_instance_id.external_id}"
+            if self.asset_instance_id is not None
+            else "noAsset"
+        )
+        return f"{self.model_id}_{self.revision_id}_{self.node_id}_{asset_part}"
 
 
 class AssetMappingResponse(ResponseResource[AssetMappingClassicRequest]):

cognite_toolkit/_cdf_tk/client/data_classes/timeseries.py

@@ -0,0 +1,45 @@
+from cognite_toolkit._cdf_tk.client.data_classes.base import RequestResource, ResponseResource
+
+from .identifiers import ExternalId, InternalOrExternalId
+from .instance_api import NodeReference
+
+
+class TimeSeriesRequest(RequestResource):
+    external_id: str | None = None
+    name: str | None = None
+    is_sting: bool = False
+    metadata: dict[str, str] | None = None
+    unit: str | None = None
+    unit_external_id: str | None = None
+    asset_id: int | None = None
+    is_step: bool = False
+    description: str | None = None
+    security_categories: list[int] | None = None
+    data_set_id: int | None = None
+
+    def as_id(self) -> InternalOrExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert TimeSeriesRequest to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class TimeSeriesResponse(ResponseResource[TimeSeriesRequest]):
+    id: int
+    instance_id: NodeReference | None = None
+    external_id: str | None = None
+    name: str | None = None
+    is_sting: bool
+    metadata: dict[str, str] | None = None
+    unit: str | None = None
+    type: str
+    unit_external_id: str | None = None
+    asset_id: int | None = None
+    is_step: bool
+    description: str | None = None
+    security_categories: list[int] | None = None
+    data_set_id: int | None = None
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> TimeSeriesRequest:
+        return TimeSeriesRequest.model_validate(self.dump())

cognite_toolkit/_cdf_tk/{utils → client}/http_client/__init__.py

@@ -1,5 +1,6 @@
 from ._client import HTTPClient
 from ._data_classes import (
+    T_COVARIANT_ID,
     DataBodyRequest,
     ErrorDetails,
     FailedRequestItems,
@@ -10,6 +11,7 @@ from ._data_classes import (
     ItemMessage,
     ItemsRequest,
     ParamRequest,
+    RequestItem,
     RequestMessage,
     ResponseList,
     ResponseMessage,
@@ -18,7 +20,6 @@ from ._data_classes import (
     SuccessResponseItems,
 )
 from ._data_classes2 import (
-    BaseModelObject,
     ErrorDetails2,
     FailedRequest2,
     FailedResponse2,
@@ -29,13 +30,12 @@ from ._data_classes2 import (
     ItemsResultMessage2,
     ItemsSuccessResponse2,
     RequestMessage2,
-    RequestResource,
     SuccessResponse2,
 )
 from ._exception import ToolkitAPIError
 
 __all__ = [
-    "BaseModelObject",
+    "T_COVARIANT_ID",
     "DataBodyRequest",
     "ErrorDetails",
     "ErrorDetails2",
@@ -56,9 +56,9 @@ __all__ = [
     "ItemsResultMessage2",
     "ItemsSuccessResponse2",
     "ParamRequest",
+    "RequestItem",
     "RequestMessage",
     "RequestMessage2",
-    "RequestResource",
     "ResponseList",
     "ResponseMessage",
     "SimpleBodyRequest",

cognite_toolkit/_cdf_tk/{utils → client}/http_client/_client.py

@@ -10,9 +10,7 @@ import httpx
 from cognite.client import global_config
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
-from cognite_toolkit._cdf_tk.utils.auxiliary import get_current_toolkit_version, get_user_agent
-from cognite_toolkit._cdf_tk.utils.http_client._data_classes import (
+from cognite_toolkit._cdf_tk.client.http_client._data_classes import (
     BodyRequest,
     DataBodyRequest,
     FailedRequestMessage,
@@ -23,7 +21,7 @@ from cognite_toolkit._cdf_tk.utils.http_client._data_classes import (
     ResponseList,
     ResponseMessage,
 )
-from cognite_toolkit._cdf_tk.utils.http_client._data_classes2 import (
+from cognite_toolkit._cdf_tk.client.http_client._data_classes2 import (
     BaseRequestMessage,
     ErrorDetails2,
     FailedRequest2,
@@ -38,6 +36,8 @@ from cognite_toolkit._cdf_tk.utils.http_client._data_classes2 import (
     RequestMessage2,
     SuccessResponse2,
 )
+from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
+from cognite_toolkit._cdf_tk.utils.auxiliary import get_current_toolkit_version, get_user_agent
 from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
 
 if sys.version_info >= (3, 11):
@@ -414,7 +414,7 @@ class HTTPClient:
         if message.tracker and message.tracker.limit_reached():
             return [
                 ItemsFailedRequest2(
-                    ids=[item.as_id() for item in message.items],
+                    ids=[str(item) for item in message.items],
                     error_message=f"Aborting further splitting of requests after {message.tracker.failed_split_count} failed attempts.",
                 )
             ]
@@ -464,7 +464,7 @@ class HTTPClient:
         if 200 <= response.status_code < 300:
             return [
                 ItemsSuccessResponse2(
-                    ids=[item.as_id() for item in request.items],
+                    ids=[str(item) for item in request.items],
                     status_code=response.status_code,
                     body=response.text,
                     content=response.content,
@@ -480,7 +480,7 @@ class HTTPClient:
             if splits[0].tracker and splits[0].tracker.limit_reached():
                 return [
                     ItemsFailedResponse2(
-                        ids=[item.as_id() for item in request.items],
+                        ids=[str(item) for item in request.items],
                         status_code=response.status_code,
                         body=response.text,
                         error=ErrorDetails2.from_response(response),
@@ -494,7 +494,7 @@ class HTTPClient:
             # Permanent failure
             return [
                 ItemsFailedResponse2(
-                    ids=[item.as_id() for item in request.items],
+                    ids=[str(item) for item in request.items],
                     status_code=response.status_code,
                     body=response.text,
                     error=ErrorDetails2.from_response(response),
@@ -516,7 +516,7 @@ class HTTPClient:
             error_msg = f"Unexpected exception: {e!s}"
             return [
                 ItemsFailedRequest2(
-                    ids=[item.as_id() for item in request.items],
+                    ids=[str(item) for item in request.items],
                     error_message=error_msg,
                 )
             ]
@@ -530,7 +530,7 @@ class HTTPClient:
 
             return [
                 ItemsFailedRequest2(
-                    ids=[item.as_id() for item in request.items],
+                    ids=[str(item) for item in request.items],
                     error_message=error_msg,
                 )
             ]