cognite-toolkit 0.7.39__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/resource_classes/data_modeling/_container.py

@@ -0,0 +1,50 @@
+from abc import ABC
+from typing import Literal
+
+from pydantic import JsonValue
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource, ResponseResource
+
+from ._constraints import Constraint
+from ._data_types import DataType
+from ._indexes import Index
+from ._references import ContainerReference
+
+
+class ContainerPropertyDefinition(BaseModelObject):
+    immutable: bool | None = None
+    nullable: bool | None = None
+    auto_increment: bool | None = None
+    default_value: str | int | float | bool | dict[str, JsonValue] | None = None
+    description: str | None = None
+    name: str | None = None
+    type: DataType
+
+
+class Container(BaseModelObject, ABC):
+    space: str
+    external_id: str
+    name: str | None = None
+    description: str | None = None
+    used_for: Literal["node", "edge", "all"] | None = None
+    properties: dict[str, ContainerPropertyDefinition]
+    constraints: dict[str, Constraint] | None = None
+    indexes: dict[str, Index] | None = None
+
+    def as_id(self) -> ContainerReference:
+        return ContainerReference(
+            space=self.space,
+            external_id=self.external_id,
+        )
+
+
+class ContainerRequest(Container, RequestResource): ...
+
+
+class ContainerResponse(Container, ResponseResource[ContainerRequest]):
+    created_time: int
+    last_updated_time: int
+    is_global: bool
+
+    def as_request_resource(self) -> "ContainerRequest":
+        return ContainerRequest.model_validate(self.model_dump(by_alias=True))

cognite_toolkit/_cdf_tk/client/resource_classes/data_modeling/_data_model.py

@@ -0,0 +1,73 @@
+from abc import ABC
+from typing import Any
+
+from pydantic import field_serializer
+from pydantic_core.core_schema import FieldSerializationInfo
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource, ResponseResource
+
+from ._references import DataModelReference, ViewReference
+from ._view import ViewResponse
+
+
+class DataModel(BaseModelObject, ABC):
+    """Cognite Data Model resource.
+
+    Data models group and structure views into reusable collections.
+    A data model contains a set of views where the node types can
+    refer to each other with direct relations and edges.
+    """
+
+    space: str
+    external_id: str
+    version: str
+    description: str | None = None
+
+    def as_id(self) -> DataModelReference:
+        return DataModelReference(
+            space=self.space,
+            external_id=self.external_id,
+            version=self.version,
+        )
+
+
+class DataModelRequest(DataModel, RequestResource):
+    views: list[ViewReference] | None = None
+
+    @field_serializer("views", mode="plain")
+    @classmethod
+    def serialize_views(
+        cls, views: list[ViewReference] | None, info: FieldSerializationInfo
+    ) -> list[dict[str, Any]] | None:
+        if views is None:
+            return None
+        return [{**view.model_dump(**vars(info)), "type": "view"} for view in views]
+
+
+class DataModelResponse(DataModel, ResponseResource[DataModelRequest]):
+    views: list[ViewReference] | None = None
+    created_time: int
+    last_updated_time: int
+    is_global: bool
+
+    def as_request_resource(self) -> DataModelRequest:
+        return DataModelRequest.model_validate(self.model_dump(by_alias=True), extra="ignore")
+
+    @field_serializer("views", mode="plain")
+    @classmethod
+    def serialize_views(
+        cls, views: list[ViewReference] | None, info: FieldSerializationInfo
+    ) -> list[dict[str, Any]] | None:
+        if views is None:
+            return None
+        return [{**view.model_dump(**vars(info)), "type": "view"} for view in views]
+
+
+class DataModelResponseWithViews(DataModel, ResponseResource[DataModelRequest]):
+    views: list[ViewResponse] | None = None
+    created_time: int
+    last_updated_time: int
+    is_global: bool
+
+    def as_request_resource(self) -> DataModelRequest:
+        return DataModelRequest.model_validate(self.model_dump(by_alias=True), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/data_modeling/_data_types.py

@@ -0,0 +1,116 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from pydantic import Field, TypeAdapter
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject
+
+from ._references import ContainerReference, ViewReference
+
+
+class PropertyTypeDefinition(BaseModelObject, ABC):
+    type: str
+
+
+class ListablePropertyTypeDefinition(PropertyTypeDefinition, ABC):
+    list: bool | None = None
+    max_list_size: int | None = None
+
+
+class TextProperty(ListablePropertyTypeDefinition):
+    type: Literal["text"] = "text"
+    max_text_size: int | None = None
+    collation: str | None = None
+
+
+class Unit(BaseModelObject):
+    external_id: str
+    source_unit: str | None = None
+
+
+class FloatProperty(ListablePropertyTypeDefinition, ABC):
+    unit: Unit | None = None
+
+
+class Float32Property(FloatProperty):
+    type: Literal["float32"] = "float32"
+
+
+class Float64Property(FloatProperty):
+    type: Literal["float64"] = "float64"
+
+
+class BooleanProperty(ListablePropertyTypeDefinition):
+    type: Literal["boolean"] = "boolean"
+
+
+class Int32Property(ListablePropertyTypeDefinition):
+    type: Literal["int32"] = "int32"
+
+
+class Int64Property(ListablePropertyTypeDefinition):
+    type: Literal["int64"] = "int64"
+
+
+class TimestampProperty(ListablePropertyTypeDefinition):
+    type: Literal["timestamp"] = "timestamp"
+
+
+class DateProperty(ListablePropertyTypeDefinition):
+    type: Literal["date"] = "date"
+
+
+class JSONProperty(ListablePropertyTypeDefinition):
+    type: Literal["json"] = "json"
+
+
+class TimeseriesCDFExternalIdReference(ListablePropertyTypeDefinition):
+    type: Literal["timeseries"] = "timeseries"
+
+
+class FileCDFExternalIdReference(ListablePropertyTypeDefinition):
+    type: Literal["file"] = "file"
+
+
+class SequenceCDFExternalIdReference(ListablePropertyTypeDefinition):
+    type: Literal["sequence"] = "sequence"
+
+
+class DirectNodeRelation(ListablePropertyTypeDefinition):
+    type: Literal["direct"] = "direct"
+    container: ContainerReference | None = None
+    # This property is only available in the response object. It will be ignored in the request object.
+    # In the request object, use ViewCoreProperty.source instead.
+    source: ViewReference | None = Field(None, exclude=True)
+
+
+class EnumValue(BaseModelObject):
+    name: str | None = None
+    description: str | None = None
+
+
+class EnumProperty(PropertyTypeDefinition):
+    type: Literal["enum"] = "enum"
+    unknown_value: str | None = None
+    values: dict[str, EnumValue]
+
+
+DataType = Annotated[
+    TextProperty
+    | Float32Property
+    | Float64Property
+    | BooleanProperty
+    | Int32Property
+    | Int64Property
+    | TimestampProperty
+    | DateProperty
+    | JSONProperty
+    | TimeseriesCDFExternalIdReference
+    | FileCDFExternalIdReference
+    | SequenceCDFExternalIdReference
+    | EnumProperty
+    | DirectNodeRelation,
+    Field(discriminator="type"),
+]
+
+DataTypeAdapter: TypeAdapter[DataType] = TypeAdapter(DataType)

cognite_toolkit/_cdf_tk/client/resource_classes/data_modeling/_indexes.py

@@ -0,0 +1,26 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from pydantic import Field, TypeAdapter
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject
+
+
+class IndexDefinition(BaseModelObject, ABC):
+    index_type: str
+    properties: list[str]
+
+
+class BtreeIndex(IndexDefinition):
+    index_type: Literal["btree"] = "btree"
+    by_space: bool | None = None
+    cursorable: bool | None = None
+
+
+class InvertedIndex(IndexDefinition):
+    index_type: Literal["inverted"] = "inverted"
+
+
+Index = Annotated[BtreeIndex | InvertedIndex, Field(discriminator="index_type")]
+
+IndexAdapter: TypeAdapter[Index] = TypeAdapter(Index)

cognite_toolkit/_cdf_tk/client/resource_classes/data_modeling/_instance.py

@@ -0,0 +1,154 @@
+from abc import ABC
+from typing import Annotated, Any, Generic, Literal, TypeAlias
+
+from pydantic import Field, JsonValue, field_serializer, field_validator
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+    T_RequestResource,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import TypedEdgeIdentifier, TypedNodeIdentifier
+
+from ._references import ContainerReference, NodeReference, ViewReference
+
+
+class InstanceDefinition(BaseModelObject, ABC):
+    """Base class for node and edge instances."""
+
+    instance_type: str  # "node" | "edge"
+    space: str
+    external_id: str
+
+
+class InstanceSource(BaseModelObject):
+    source: ViewReference | ContainerReference
+    properties: dict[str, JsonValue] | None = None
+
+
+class InstanceRequestDefinition(InstanceDefinition, RequestResource, ABC):
+    existing_version: int | None = None
+    sources: list[InstanceSource]
+
+
+class InstanceResponseDefinition(InstanceDefinition, ResponseResource, Generic[T_RequestResource], ABC):
+    version: int
+    created_time: int
+    last_updated_time: int
+    deleted_time: int | None = None
+    properties: dict[ViewReference | ContainerReference, dict[str, JsonValue]] | None = None
+
+    @field_validator("properties", mode="before")
+    def parse_reference(cls, value: Any) -> Any:
+        if not isinstance(value, dict):
+            return value
+        parsed: dict[ViewReference | ContainerReference, dict[str, Any]] = {}
+        for space, inner_dict in value.items():
+            if not isinstance(inner_dict, dict) or not isinstance(space, str):
+                raise ValueError(
+                    f"Invalid properties format expected dict[str, dict[...]], got: dict[{type(space).__name__}, {type(inner_dict).__name__}]"
+                )
+            for view_or_container_identifier, prop in inner_dict.items():
+                if not isinstance(view_or_container_identifier, str):
+                    raise ValueError(
+                        "Invalid properties format expected dict[str, dict[str, ...]]], "
+                        f"got: dict[{type(space).__name__}, "
+                        f"dict[{type(view_or_container_identifier).__name__}, ...]]"
+                    )
+                source_ref: ViewReference | ContainerReference
+                if "/" in view_or_container_identifier:
+                    external_id, version = view_or_container_identifier.split("/", 1)
+                    source_ref = ViewReference(space=space, external_id=external_id, version=version)
+                else:
+                    source_ref = ContainerReference(space=space, external_id=view_or_container_identifier)
+                parsed[source_ref] = prop
+        return parsed
+
+    @field_serializer("properties", mode="plain")
+    def serialize_properties(self, value: dict[ViewReference | ContainerReference, dict[str, Any]] | None) -> Any:
+        if value is None:
+            return None
+        serialized: dict[str, dict[str, Any]] = {}
+        for source_ref, props in value.items():
+            space = source_ref.space
+            if space not in serialized:
+                serialized[space] = {}
+            if isinstance(source_ref, ViewReference):
+                identifier = f"{source_ref.external_id}/{source_ref.version}"
+            else:
+                identifier = source_ref.external_id
+            serialized[space][identifier] = props
+        return serialized
+
+
+class NodeRequest(InstanceRequestDefinition):
+    """A node request resource."""
+
+    instance_type: Literal["node"] = "node"
+    type: NodeReference | None = None
+
+    def as_id(self) -> TypedNodeIdentifier:
+        return TypedNodeIdentifier(space=self.space, external_id=self.external_id)
+
+
+class EdgeRequest(InstanceRequestDefinition):
+    """An edge request resource."""
+
+    instance_type: Literal["edge"] = "edge"
+    type: NodeReference
+    start_node: NodeReference
+    end_node: NodeReference
+
+    def as_id(self) -> TypedEdgeIdentifier:
+        return TypedEdgeIdentifier(space=self.space, external_id=self.external_id)
+
+
+class NodeResponse(InstanceResponseDefinition[NodeRequest]):
+    """A node response from the API."""
+
+    instance_type: Literal["node"] = "node"
+    type: NodeReference | None = None
+
+    def as_id(self) -> TypedNodeIdentifier:
+        return TypedNodeIdentifier(space=self.space, external_id=self.external_id)
+
+    def as_request_resource(self) -> NodeRequest:
+        dumped = self.dump()
+        if self.properties:
+            dumped["sources"] = [
+                InstanceSource(source=source_ref, properties=props) for source_ref, props in self.properties.items()
+            ]
+        dumped["existingVersion"] = dumped.pop("version", None)
+        return NodeRequest.model_validate(dumped, extra="ignore")
+
+
+class EdgeResponse(InstanceResponseDefinition[EdgeRequest]):
+    """An edge response from the API."""
+
+    instance_type: Literal["edge"] = "edge"
+    type: NodeReference
+    start_node: NodeReference
+    end_node: NodeReference
+
+    def as_id(self) -> TypedEdgeIdentifier:
+        return TypedEdgeIdentifier(space=self.space, external_id=self.external_id)
+
+    def as_request_resource(self) -> EdgeRequest:
+        dumped = self.dump()
+        if self.properties:
+            dumped["sources"] = [
+                InstanceSource(source=source_ref, properties=props) for source_ref, props in self.properties.items()
+            ]
+        dumped["existingVersion"] = dumped.pop("version", None)
+        return EdgeRequest.model_validate(dumped, extra="ignore")
+
+
+InstanceRequest: TypeAlias = Annotated[
+    NodeRequest | EdgeRequest,
+    Field(discriminator="instance_type"),
+]
+InstanceResponse: TypeAlias = Annotated[
+    NodeResponse | EdgeResponse,
+    Field(discriminator="instance_type"),
+]

cognite_toolkit/_cdf_tk/client/resource_classes/data_modeling/_references.py

@@ -0,0 +1,86 @@
+from typing import Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import Identifier
+
+
+class SpaceReference(Identifier):
+    space: str
+
+    def __str__(self) -> str:
+        return self.space
+
+
+class ContainerReference(Identifier):
+    type: Literal["container"] = Field("container", exclude=True)
+    space: str
+    external_id: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}"
+
+
+class ViewReference(Identifier):
+    type: Literal["view"] = Field("view", exclude=True)
+    space: str
+    external_id: str
+    version: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}(version={self.version})"
+
+
+class DataModelReference(Identifier):
+    space: str
+    external_id: str
+    version: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}(version={self.version})"
+
+
+class NodeReference(Identifier):
+    space: str
+    external_id: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}"
+
+
+class EdgeReference(Identifier):
+    space: str
+    external_id: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}"
+
+
+class ContainerDirectReference(Identifier):
+    source: ContainerReference
+    identifier: str
+
+    def __str__(self) -> str:
+        return f"{self.source!s}.{self.identifier}"
+
+
+class ViewDirectReference(Identifier):
+    source: ViewReference
+    identifier: str
+
+    def __str__(self) -> str:
+        return f"{self.source!s}.{self.identifier}"
+
+
+class ContainerIndexReference(ContainerReference):
+    identifier: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}(index={self.identifier})"
+
+
+class ContainerConstraintReference(ContainerReference):
+    identifier: str
+
+    def __str__(self) -> str:
+        return f"{self.space}:{self.external_id}(constraint={self.identifier})"

cognite_toolkit/_cdf_tk/client/resource_classes/data_modeling/_space.py

@@ -0,0 +1,26 @@
+from abc import ABC
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource, ResponseResource
+
+from ._references import SpaceReference
+
+
+class Space(BaseModelObject, ABC):
+    space: str
+    name: str | None = None
+    description: str | None = None
+
+    def as_id(self) -> SpaceReference:
+        return SpaceReference(space=self.space)
+
+
+class SpaceRequest(Space, RequestResource): ...
+
+
+class SpaceResponse(Space, ResponseResource[SpaceRequest]):
+    created_time: int
+    last_updated_time: int
+    is_global: bool
+
+    def as_request_resource(self) -> SpaceRequest:
+        return SpaceRequest.model_validate(self.model_dump(by_alias=True), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/data_modeling/_view.py

@@ -0,0 +1,143 @@
+from abc import ABC
+from typing import Any, Literal
+
+from pydantic import Field, JsonValue, field_serializer, model_validator
+from pydantic_core.core_schema import FieldSerializationInfo
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource, ResponseResource
+
+from ._data_types import DirectNodeRelation
+from ._references import ContainerReference, ViewReference
+from ._view_property import (
+    MultiReverseDirectRelationPropertyResponse,
+    SingleReverseDirectRelationPropertyResponse,
+    ViewCorePropertyRequest,
+    ViewCorePropertyResponse,
+    ViewRequestProperty,
+    ViewResponseProperty,
+)
+
+
+class View(BaseModelObject, ABC):
+    space: str
+    external_id: str
+    version: str
+    name: str | None = None
+    description: str | None = None
+    filter: JsonValue | None
+    implements: list[ViewReference] | None = None
+
+    def as_id(self) -> ViewReference:
+        return ViewReference(space=self.space, external_id=self.external_id, version=self.version)
+
+    @model_validator(mode="before")
+    def set_connection_type_on_primary_properties(cls, data: dict[str, Any]) -> dict[str, Any]:
+        if "properties" not in data:
+            return data
+        properties = data["properties"]
+        if not isinstance(properties, dict):
+            return data
+        # We assume all properties without connectionType are core properties.
+        # The reason we set connectionType is to make it easy for pydantic to discriminate the union.
+        # This also leads to better error messages, as if there is a union and pydantic does not know which
+        # type to pick it will give errors from all type in the union.
+        new_properties: dict[str, Any] = {}
+        for prop_id, prop in properties.items():
+            if isinstance(prop, dict) and "connectionType" not in prop:
+                prop_copy = prop.copy()
+                prop_copy["connectionType"] = "primary_property"
+                new_properties[prop_id] = prop_copy
+            else:
+                new_properties[prop_id] = prop
+        if new_properties:
+            new_data = data.copy()
+            new_data["properties"] = new_properties
+            return new_data
+
+        return data
+
+    @field_serializer("implements", mode="plain")
+    @classmethod
+    def serialize_implements(
+        cls, implements: list[ViewReference] | None, info: FieldSerializationInfo
+    ) -> list[dict[str, Any]] | None:
+        if implements is None:
+            return None
+        output: list[dict[str, Any]] = []
+        for view in implements:
+            dumped = view.model_dump(**vars(info))
+            dumped["type"] = "view"
+            output.append(dumped)
+        return output
+
+
+class ViewRequest(View, RequestResource):
+    properties: dict[str, ViewRequestProperty] = Field(
+        description="View with included properties and expected edges, indexed by a unique space-local identifier."
+    )
+
+    @property
+    def used_containers(self) -> set[ContainerReference]:
+        """Get all containers referenced by this view."""
+        return {prop.container for prop in self.properties.values() if isinstance(prop, ViewCorePropertyRequest)}
+
+
+class ViewResponse(View, ResponseResource[ViewRequest]):
+    properties: dict[str, ViewResponseProperty]
+
+    created_time: int
+    last_updated_time: int
+    writable: bool
+    queryable: bool
+    used_for: Literal["node", "edge", "all"]
+    is_global: bool
+    mapped_containers: list[ContainerReference]
+
+    def as_request_resource(self) -> ViewRequest:
+        dumped = self.model_dump(by_alias=True, exclude={"properties"})
+        properties: dict[str, Any] = {}
+        for key, value in self.properties.items():
+            if isinstance(value, ViewCorePropertyResponse) and isinstance(value.type, DirectNodeRelation):
+                # Special case. In the request the source of DirectNodeRelation is set on the Property object,
+                # while in the response it is set on the DirectNodeRelation object.
+                request_object = value.as_request().model_dump(by_alias=True)
+                request_object["source"] = value.type.source.model_dump(by_alias=True) if value.type.source else None
+                properties[key] = request_object
+            elif isinstance(
+                value,
+                ViewCorePropertyResponse
+                | SingleReverseDirectRelationPropertyResponse
+                | MultiReverseDirectRelationPropertyResponse,
+            ):
+                properties[key] = value.as_request().model_dump(by_alias=True)
+            else:
+                properties[key] = value.model_dump(by_alias=True)
+
+        dumped["properties"] = properties
+        return ViewRequest.model_validate(dumped, extra="ignore")
+
+    @field_serializer("mapped_containers", mode="plain")
+    @classmethod
+    def serialize_mapped_containers(
+        cls, mapped_containers: list[ContainerReference], info: FieldSerializationInfo
+    ) -> list[dict[str, Any]]:
+        return [container.model_dump(**vars(info)) | {"type": "container"} for container in mapped_containers]
+
+    @field_serializer("properties", mode="plain")
+    @classmethod
+    def serialize_properties_special_handling_direct_relation_with_source(
+        cls, properties: dict[str, ViewResponseProperty], info: FieldSerializationInfo
+    ) -> dict[str, dict[str, Any]]:
+        output: dict[str, dict[str, Any]] = {}
+        for prop_id, prop in properties.items():
+            output[prop_id] = prop.model_dump(**vars(info))
+            if (
+                isinstance(prop, ViewCorePropertyResponse)
+                and isinstance(prop.type, DirectNodeRelation)
+                and prop.type.source
+            ):
+                # We manually include the source as this is excluded by default. The reason why this is excluded
+                # is that the DirectNodeRelation is used for both request and response, and in the request the source
+                # does not exist on the DirectNodeRelation, but on the Property object.
+                output[prop_id]["type"]["source"] = prop.type.source.model_dump(**vars(info)) | {"type": "view"}
+        return output