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

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

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

@@ -0,0 +1,152 @@
+from abc import ABC
+from typing import Annotated, Any, Literal
+
+from pydantic import Field, JsonValue, TypeAdapter, field_serializer
+from pydantic_core.core_schema import FieldSerializationInfo
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject
+
+from ._data_types import DataType
+from ._references import ContainerDirectReference, ContainerReference, NodeReference, ViewDirectReference, ViewReference
+
+
+class ViewPropertyDefinition(BaseModelObject, ABC):
+    connection_type: str
+
+
+class ViewCoreProperty(ViewPropertyDefinition, ABC):
+    # Core properties do not have connection type in the API, but we add it here such that
+    # we can use it as a discriminator in unions. The exclude=True ensures that it is not
+    # sent to the API.
+    connection_type: Literal["primary_property"] = Field(default="primary_property", exclude=True)
+    name: str | None = None
+    description: str | None = None
+    container: ContainerReference
+    container_property_identifier: str
+
+    @field_serializer("container", mode="plain")
+    @classmethod
+    def serialize_container(cls, container: ContainerReference, info: FieldSerializationInfo) -> dict[str, Any]:
+        return {**container.model_dump(**vars(info)), "type": "container"}
+
+
+class ViewCorePropertyRequest(ViewCoreProperty):
+    source: ViewReference | None = None
+
+    @field_serializer("source", mode="plain")
+    @classmethod
+    def serialize_source(cls, source: ViewReference | None, info: FieldSerializationInfo) -> dict[str, Any] | None:
+        if source is None:
+            return None
+        return {**source.model_dump(**vars(info)), "type": "view"}
+
+
+class ConstraintOrIndexState(BaseModelObject):
+    nullability: Literal["current", "pending", "failed"] | None = None
+    max_list_size: Literal["current", "pending", "failed"] | None = None
+    max_text_size: Literal["current", "pending", "failed"] | None = None
+
+
+class ViewCorePropertyResponse(ViewCoreProperty):
+    immutable: bool | None = None
+    nullable: bool | None = None
+    auto_increment: bool | None = None
+    default_value: str | int | bool | dict[str, JsonValue] | None = None
+    constraint_state: ConstraintOrIndexState
+    type: DataType
+
+    def as_request(self) -> ViewCorePropertyRequest:
+        return ViewCorePropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class ConnectionPropertyDefinition(ViewPropertyDefinition, ABC):
+    name: str | None = None
+    description: str | None = None
+
+
+class EdgeProperty(ConnectionPropertyDefinition, ABC):
+    source: ViewReference
+    type: NodeReference
+    edge_source: ViewReference | None = None
+    direction: Literal["outwards", "inwards"] = "outwards"
+
+    @field_serializer("source", "edge_source", mode="plain")
+    @classmethod
+    def serialize_source(cls, source: ViewReference | None, info: FieldSerializationInfo) -> dict[str, Any] | None:
+        if source is None:
+            return None
+        return {**source.model_dump(**vars(info)), "type": "view"}
+
+
+class SingleEdgeProperty(EdgeProperty):
+    connection_type: Literal["single_edge_connection"] = "single_edge_connection"
+
+
+class MultiEdgeProperty(EdgeProperty):
+    connection_type: Literal["multi_edge_connection"] = "multi_edge_connection"
+
+
+class ReverseDirectRelationProperty(ConnectionPropertyDefinition, ABC):
+    source: ViewReference
+    through: ContainerDirectReference | ViewDirectReference
+
+    @field_serializer("source", mode="plain")
+    @classmethod
+    def serialize_source(cls, source: ViewReference, info: FieldSerializationInfo) -> dict[str, Any]:
+        return {**source.model_dump(**vars(info)), "type": "view"}
+
+    @field_serializer("through", mode="plain")
+    @classmethod
+    def serialize_through(
+        cls, through: ContainerDirectReference | ViewDirectReference, info: FieldSerializationInfo
+    ) -> dict[str, Any]:
+        output = through.model_dump(**vars(info))
+        if isinstance(through, ContainerDirectReference):
+            output["source"]["type"] = "container"
+        else:
+            output["source"]["type"] = "view"
+        return output
+
+
+class SingleReverseDirectRelationPropertyRequest(ReverseDirectRelationProperty):
+    connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
+
+
+class MultiReverseDirectRelationPropertyRequest(ReverseDirectRelationProperty):
+    connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
+
+
+class SingleReverseDirectRelationPropertyResponse(ReverseDirectRelationProperty):
+    connection_type: Literal["single_reverse_direct_relation"] = "single_reverse_direct_relation"
+    targets_list: bool
+
+    def as_request(self) -> SingleReverseDirectRelationPropertyRequest:
+        return SingleReverseDirectRelationPropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+class MultiReverseDirectRelationPropertyResponse(ReverseDirectRelationProperty):
+    connection_type: Literal["multi_reverse_direct_relation"] = "multi_reverse_direct_relation"
+    targets_list: bool
+
+    def as_request(self) -> MultiReverseDirectRelationPropertyRequest:
+        return MultiReverseDirectRelationPropertyRequest.model_validate(self.model_dump(by_alias=True))
+
+
+ViewRequestProperty = Annotated[
+    SingleEdgeProperty
+    | MultiEdgeProperty
+    | SingleReverseDirectRelationPropertyRequest
+    | MultiReverseDirectRelationPropertyRequest
+    | ViewCorePropertyRequest,
+    Field(discriminator="connection_type"),
+]
+ViewResponseProperty = Annotated[
+    SingleEdgeProperty
+    | MultiEdgeProperty
+    | SingleReverseDirectRelationPropertyResponse
+    | MultiReverseDirectRelationPropertyResponse
+    | ViewCorePropertyResponse,
+    Field(discriminator="connection_type"),
+]
+
+ViewRequestPropertyAdapter: TypeAdapter[ViewRequestProperty] = TypeAdapter(ViewRequestProperty)

cognite_toolkit/_cdf_tk/client/resource_classes/dataset.py

@@ -0,0 +1,35 @@
+from typing import ClassVar
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId
+
+
+class DataSet(BaseModelObject):
+    external_id: str | None = None
+    name: str | None = None
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    write_protected: bool = False
+
+    def as_id(self) -> ExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert DataSet to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class DataSetRequest(DataSet, UpdatableRequestResource):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata"})
+
+
+class DataSetResponse(DataSet, ResponseResource[DataSetRequest]):
+    id: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> DataSetRequest:
+        return DataSetRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/event.py

@@ -0,0 +1,40 @@
+from typing import ClassVar
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId, InternalOrExternalId
+
+
+class Event(BaseModelObject):
+    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 EventRequest(Event, UpdatableRequestResource):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "asset_ids"})
+
+
+class EventResponse(Event, ResponseResource[EventRequest]):
+    id: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> EventRequest:
+        return EventRequest.model_validate(self.dump(), extra="ignore")