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

cognite_toolkit/_cdf_tk/client/data_classes/charts_data.py

@@ -0,0 +1,184 @@
+from typing import Any
+
+from cognite.client.data_classes.data_modeling import NodeId, ViewId
+from pydantic import JsonValue, field_serializer, field_validator
+
+from .base import BaseModelObject
+
+
+class UserInfo(BaseModelObject):
+    id: str | None = None
+    email: str | None = None
+    display_name: str | None = None
+
+
+class ChartSettings(BaseModelObject):
+    show_y_axis: bool = True
+    show_min_max: bool = True
+    show_gridlines: bool = True
+    merge_units: bool = False
+
+
+class ThresholdFilter(BaseModelObject):
+    min_unit: str | None = None
+    max_unit: str | None = None
+
+
+class ChartCall(BaseModelObject):
+    id: str | None = None
+    hash: int | None = None
+    call_id: str | None = None
+    call_date: int | None = None
+    status: str | None = None
+
+
+class SubSetting(BaseModelObject):
+    auto_align: bool | None = None
+
+
+class ChartPosition(BaseModelObject):
+    x: float | None = None
+    y: float | None = None
+
+
+class FlowElement(BaseModelObject):
+    id: str | None = None
+    type: str | None = None
+    position: ChartPosition | None = None
+    data: JsonValue | None = None
+    source: str | None = None
+    target: str | None = None
+    source_handle: str | None = None
+    target_handle: str | None = None
+
+
+class Flow(BaseModelObject):
+    zoom: float | None = None
+    elements: list[FlowElement] | None = None
+    position: tuple[float | None, float | None] | None = None
+
+
+class ChartElement(BaseModelObject):
+    id: str | None = None
+    type: str | None = None
+
+
+class ChartSource(ChartElement): ...
+
+
+class ChartCoreTimeseries(ChartElement):
+    node_reference: NodeId | None = None
+    view_reference: ViewId | None = None
+    display_mode: str | None = None
+    color: str | None = None
+    created_at: int | None = None
+    enabled: bool | None = None
+    interpolation: str | None = None
+    line_style: str | None = None
+    line_weight: float | None = None
+    name: str | None = None
+    preferred_unit: str | None = None
+    range: list[float | None] | None = None
+
+    @field_serializer("node_reference", when_used="always")
+    def serialize_node_reference(self, node_reference: NodeId | None) -> dict[str, Any] | None:
+        if node_reference:
+            return node_reference.dump(include_instance_type=False)
+        return None
+
+    @field_serializer("view_reference", when_used="always")
+    def serialize_view_reference(self, view_reference: ViewId | None) -> dict[str, Any] | None:
+        if view_reference:
+            return view_reference.dump(include_type=False)
+        return None
+
+    @field_validator("node_reference", mode="before")
+    @classmethod
+    def validate_node_reference(cls, value: Any) -> NodeId | None:
+        if value is None or isinstance(value, NodeId):
+            return value
+        return NodeId.load(value)
+
+    @field_validator("view_reference", mode="before")
+    @classmethod
+    def validate_view_reference(cls, value: Any) -> ViewId | None:
+        if value is None or isinstance(value, ViewId):
+            return value
+        return ViewId.load(value)
+
+
+class ChartTimeseries(ChartElement):
+    color: str | None = None
+    created_at: int | None = None
+    enabled: bool | None = None
+    interpolation: str | None = None
+    line_style: str | None = None
+    line_weight: float | None = None
+    name: str | None = None
+    preferred_unit: str | None = None
+    range: list[float | None] | None = None
+    unit: str | None = None
+    ts_id: int | None = None
+    ts_external_id: str | None = None
+    display_mode: str | None = None
+    original_unit: str | None = None
+    description: str | None = None
+
+
+class ChartWorkflow(ChartElement):
+    version: str | None = None
+    name: str | None = None
+    color: str | None = None
+    enabled: bool | None = None
+    line_weight: float | None = None
+    line_style: str | None = None
+    interpolation: str | None = None
+    unit: str | None = None
+    preferred_unit: str | None = None
+    range: list[float | None] | None = None
+    created_at: int | None = None
+    settings: SubSetting | None = None
+    flow: Flow | None = None
+    calls: list[ChartCall] | None = None
+
+
+class ChartThreshold(ChartElement):
+    visible: bool | None = None
+    name: str | None = None
+    source_id: str | None = None
+    upper_limit: float | None = None
+    filter: ThresholdFilter | None = None
+    calls: list[ChartCall] | None = None
+
+
+class ChartScheduledCalculation(ChartElement):
+    color: str | None = None
+    created_at: int | None = None
+    description: str | None = None
+    enabled: bool | None = None
+    interpolation: str | None = None
+    line_style: str | None = None
+    line_weight: float | None = None
+    name: str | None = None
+    preferred_unit: str | None = None
+    range: list[float | None] | None = None
+    unit: str | None = None
+    version: str | None = None
+    settings: SubSetting | None = None
+    flow: Flow | None = None
+
+
+class ChartData(BaseModelObject):
+    version: int | None = None
+    name: str | None = None
+    date_from: str | None = None
+    date_to: str | None = None
+    user_info: UserInfo | None = None
+    live_mode: bool | None = None
+    time_series_collection: list[ChartTimeseries] | None = None
+    core_timeseries_collection: list[ChartCoreTimeseries] | None = None
+    workflow_collection: list[ChartWorkflow] | None = None
+    source_collection: list[ChartSource] | None = None
+    threshold_collection: list[ChartThreshold] | None = None
+    scheduled_calculation_collection: list[ChartScheduledCalculation] | None = None
+    settings: ChartSettings | None = None

cognite_toolkit/_cdf_tk/client/data_classes/infield.py

@@ -0,0 +1,116 @@
+import sys
+from typing import Any, ClassVar, Literal
+
+from pydantic import JsonValue, field_validator
+from pydantic_core.core_schema import ValidationInfo
+
+from cognite_toolkit._cdf_tk.protocols import (
+    ResourceRequestListProtocol,
+    ResourceResponseListProtocol,
+)
+from cognite_toolkit._cdf_tk.utils.text import sanitize_instance_external_id
+
+from .base import BaseResourceList, ResponseResource
+from .instance_api import InstanceRequestResource, ViewReference
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+INFIELD_LOCATION_CONFIG_VIEW_ID = ViewReference(space="cdf_infield", external_id="InFieldLocationConfig", version="v1")
+INFIELD_CDM_LOCATION_CONFIG_VIEW_ID = ViewReference(
+    space="infield_cdm_source_desc_sche_asset_file_ts", external_id="InFieldCDMLocationConfig", version="v1"
+)
+DATA_EXPLORATION_CONFIG_VIEW_ID = ViewReference(space="cdf_infield", external_id="DataExplorationConfig", version="v1")
+
+
+class DataExplorationConfig(InstanceRequestResource):
+    """Data Exploration Configuration resource class."""
+
+    VIEW_ID: ClassVar[ViewReference] = DATA_EXPLORATION_CONFIG_VIEW_ID
+    instance_type: Literal["node"] = "node"
+
+    observations: dict[str, JsonValue] | None = None
+    activities: dict[str, JsonValue] | None = None
+    documents: dict[str, JsonValue] | None = None
+    notifications: dict[str, JsonValue] | None = None
+    assets: dict[str, JsonValue] | None = None
+
+
+class InfieldLocationConfig(
+    ResponseResource["InfieldLocationConfig"],
+    InstanceRequestResource,
+):
+    """Infield Location Configuration resource class.
+
+    This class is used for both the response and request resource for Infield Location Configuration nodes.
+    """
+
+    VIEW_ID: ClassVar[ViewReference] = INFIELD_LOCATION_CONFIG_VIEW_ID
+    instance_type: Literal["node"] = "node"
+
+    root_location_external_id: str | None = None
+    feature_toggles: dict[str, JsonValue] | None = None
+    app_instance_space: str | None = None
+    access_management: dict[str, JsonValue] | None = None
+    data_filters: dict[str, JsonValue] | None = None
+    data_exploration_config: DataExplorationConfig | None = None
+
+    def as_request_resource(self) -> "InfieldLocationConfig":
+        return self
+
+    def as_write(self) -> Self:
+        return self
+
+    @field_validator("data_exploration_config", mode="before")
+    @classmethod
+    def generate_identifier_if_missing(cls, value: Any, info: ValidationInfo) -> Any:
+        """We do not require the user to specify the space and externalId for the data exploration config."""
+        if isinstance(value, dict):
+            if value.get("space") is None:
+                value["space"] = info.data["space"]
+            if value.get("externalId") is None:
+                external_id = info.data["external_id"]
+                candidate = f"{external_id}_data_exploration_config"
+                value["externalId"] = sanitize_instance_external_id(candidate)
+        return value
+
+
+class InfieldLocationConfigList(
+    BaseResourceList[InfieldLocationConfig],
+    ResourceResponseListProtocol,
+    ResourceRequestListProtocol,
+):
+    """A list of InfieldLocationConfig objects."""
+
+    _RESOURCE = InfieldLocationConfig
+
+    def as_write(self) -> Self:
+        return self
+
+
+class InFieldCDMLocationConfig(ResponseResource["InFieldCDMLocationConfig"], InstanceRequestResource):
+    """InField CDM Location Configuration resource class.
+
+    This class is used for both the response and request resource for InField CDM Location Configuration nodes.
+    """
+
+    VIEW_ID: ClassVar[ViewReference] = INFIELD_CDM_LOCATION_CONFIG_VIEW_ID
+    instance_type: Literal["node"] = "node"
+
+    name: str | None = None
+    description: str | None = None
+    feature_toggles: dict[str, JsonValue] | None = None
+    access_management: dict[str, JsonValue] | None = None
+    data_filters: dict[str, JsonValue] | None = None
+    data_storage: dict[str, JsonValue] | None = None
+    view_mappings: dict[str, JsonValue] | None = None
+    disciplines: list[dict[str, JsonValue]] | None = None
+    data_exploration_config: dict[str, JsonValue] | None = None
+
+    def as_request_resource(self) -> "InFieldCDMLocationConfig":
+        return self
+
+    def as_write(self) -> Self:
+        return self

cognite_toolkit/_cdf_tk/client/data_classes/instance_api.py

@@ -0,0 +1,162 @@
+from typing import Any, ClassVar, Literal, TypeAlias
+
+from pydantic import ConfigDict, JsonValue, model_serializer
+
+from .base import BaseModelObject, Identifier, RequestResource
+
+InstanceType: TypeAlias = Literal["node", "edge"]
+
+
+class TypedInstanceIdentifier(Identifier):
+    """Identifier for an Instance instance."""
+
+    instance_type: InstanceType
+    space: str
+    external_id: str
+
+
+class InstanceIdentifier(Identifier):
+    space: str
+    external_id: str
+
+
+class NodeIdentifier(TypedInstanceIdentifier):
+    instance_type: Literal["node"] = "node"
+
+
+class EdgeIdentifier(TypedInstanceIdentifier):
+    instance_type: Literal["edge"] = "edge"
+
+
+class InstanceResult(BaseModelObject):
+    instance_type: InstanceType
+    version: int
+    was_modified: bool
+    space: str
+    external_id: str
+    created_time: int
+    last_updated_time: int
+
+    def as_id(self) -> TypedInstanceIdentifier:
+        return TypedInstanceIdentifier(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+        )
+
+
+class ViewReference(Identifier):
+    type: Literal["view"] = "view"
+    space: str
+    external_id: str
+    version: str
+
+
+######################################################
+# The classes below are helper classes for making instances request/responses.
+# By using these, we can avoid having to include the instances specific classes in the DTO classes
+# that are instance. Instead, these classes can now only have the properties they need to define.
+#######################################################
+
+
+class InstanceRequestResource(RequestResource):
+    """This is a base class for resources that are Instances."""
+
+    VIEW_ID: ClassVar[ViewReference]
+    instance_type: InstanceType
+    space: str
+    external_id: str
+
+    def as_id(self) -> TypedInstanceIdentifier:
+        return TypedInstanceIdentifier(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+        )
+
+    def as_request_item(self) -> "InstanceRequestItem":
+        return InstanceRequestItem(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+            sources=[InstanceSource(source=self.VIEW_ID, resource=self)],
+        )
+
+
+class InstanceSource(BaseModelObject):
+    source: ViewReference
+    resource: InstanceRequestResource
+
+    @model_serializer(mode="plain")
+    def serialize_resource(self) -> dict[str, Any]:
+        properties: dict[str, JsonValue] = {}
+        for field_id, field in type(self.resource).model_fields.items():
+            if field_id in InstanceRequestResource.model_fields:
+                # Skip space, external_id, instance_type
+                continue
+            key = field.alias or field_id
+            properties[key] = self._serialize_property(getattr(self.resource, field_id))
+
+        return {
+            "source": self.source.model_dump(by_alias=True),
+            "properties": properties,
+        }
+
+    @classmethod
+    def _serialize_property(cls, value: Any) -> JsonValue:
+        """Handles serialization of direct relations."""
+        if isinstance(value, InstanceRequestResource):
+            return {"space": value.space, "externalId": value.external_id}
+        elif isinstance(value, list):
+            return [cls._serialize_property(v) for v in value]
+        return value
+
+
+class InstanceRequestItem(RequestResource):
+    model_config = ConfigDict(populate_by_name=True)
+    instance_type: InstanceType
+    space: str
+    external_id: str
+    existing_version: int | None = None
+    sources: list[InstanceSource] | None = None
+
+    def as_id(self) -> TypedInstanceIdentifier:
+        return TypedInstanceIdentifier(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+        )
+
+
+class InstanceResponseItem(BaseModelObject):
+    instance_type: InstanceType
+    space: str
+    external_id: str
+    version: int
+    type: TypedInstanceIdentifier | None = None
+    created_time: int
+    last_updated_time: int
+    deleted_time: int | None = None
+    properties: dict[str, dict[str, dict[str, JsonValue]]] | None = None
+
+    def get_properties_for_source(
+        self, source: ViewReference, include_identifier: bool = False
+    ) -> dict[str, JsonValue]:
+        output: dict[str, JsonValue] = (
+            {"space": self.space, "externalId": self.external_id} if include_identifier else {}
+        )
+        if not self.properties:
+            return output
+        if source.space not in self.properties:
+            return output
+        space_properties = self.properties[source.space]
+        view_version = f"{source.external_id}/{source.version}"
+        output.update(space_properties.get(view_version, {}))
+        return output
+
+    def as_id(self) -> TypedInstanceIdentifier:
+        return TypedInstanceIdentifier(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+        )

cognite_toolkit/_cdf_tk/client/data_classes/instances.py

@@ -2,9 +2,15 @@ from collections.abc import Iterable
 from typing import Any
 
 from cognite.client import CogniteClient
-from cognite.client.data_classes._base import CogniteResourceList
+from cognite.client.data_classes._base import CogniteResourceList, WriteableCogniteResourceList
 from cognite.client.data_classes.data_modeling import EdgeId, NodeId
-from cognite.client.data_classes.data_modeling.instances import EdgeApplyResult, InstanceApplyResult, NodeApplyResult
+from cognite.client.data_classes.data_modeling.instances import (
+    EdgeApplyResult,
+    Instance,
+    InstanceApply,
+    InstanceApplyResult,
+    NodeApplyResult,
+)
 
 
 class InstanceApplyResultAdapter(InstanceApplyResult):
@@ -40,3 +46,19 @@ class InstancesApplyResultList(CogniteResourceList[InstanceApplyResult]):
             else EdgeId(item.space, item.external_id)
             for item in self
         ]
+
+
+class InstanceApplyList(CogniteResourceList[InstanceApply]):
+    """A list of instances to be applied (created or updated)."""
+
+    _RESOURCE = InstanceApply
+
+
+class InstanceList(WriteableCogniteResourceList[InstanceApply, Instance]):
+    """A list of instances that can be written to CDF."""
+
+    _RESOURCE = Instance
+
+    def as_write(self) -> InstanceApplyList:
+        """Converts the instance list to a list of writeable instances."""
+        return InstanceApplyList([item.as_write() for item in self])