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

cognite_toolkit/_cdf_tk/client/data_classes/charts_data.py

@@ -1,70 +1,30 @@
-import sys
-from dataclasses import dataclass, field, fields
-from functools import lru_cache
 from typing import Any
 
-from cognite.client import CogniteClient
-from cognite.client.data_classes._base import CogniteObject
 from cognite.client.data_classes.data_modeling import NodeId, ViewId
-from cognite.client.utils._auxiliary import to_camel_case
+from pydantic import JsonValue, field_serializer, field_validator
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+from .base import BaseModelObject
 
 
-@dataclass
-class ChartObject(CogniteObject):
-    # ChartObjects are used in the frontend and the backend does not do any validation of these fields.
-    # Therefore, to ensure that we do not lose any data, we store unknown fields in a separate dictionary.
-    # This allows unknown fields to be preserved when loading and dumping ChartObjects
-    # (serialization and deserialization).
-    _unknown_fields: dict[str, object] | None = field(default=None, init=False, repr=False)
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        """Load a ChartObject from a dictionary."""
-        instance = super()._load(resource, cognite_client=cognite_client)
-        instance._unknown_fields = {k: v for k, v in resource.items() if k not in cls._known_camel_case_props()}
-        return instance
-
-    @classmethod
-    @lru_cache(maxsize=1)
-    def _known_camel_case_props(cls) -> set[str]:
-        return {to_camel_case(f.name) for f in fields(cls)}
-
-    def dump(self, camel_case: bool = True) -> dict[str, Any]:
-        """Dump the ChartObject to a dictionary."""
-        data = super().dump(camel_case=camel_case)
-        if self._unknown_fields:
-            data.update(self._unknown_fields)
-        return data
-
-
-@dataclass
-class UserInfo(ChartObject):
+class UserInfo(BaseModelObject):
     id: str | None = None
     email: str | None = None
     display_name: str | None = None
 
 
-@dataclass
-class ChartSettings(ChartObject):
+class ChartSettings(BaseModelObject):
     show_y_axis: bool = True
     show_min_max: bool = True
     show_gridlines: bool = True
     merge_units: bool = False
 
 
-@dataclass
-class ThresholdFilter(ChartObject):
+class ThresholdFilter(BaseModelObject):
     min_unit: str | None = None
     max_unit: str | None = None
 
 
-@dataclass
-class ChartCall(ChartObject):
+class ChartCall(BaseModelObject):
     id: str | None = None
     hash: int | None = None
     call_id: str | None = None
@@ -72,162 +32,143 @@ class ChartCall(ChartObject):
     status: str | None = None
 
 
-@dataclass
-class SubSetting(ChartObject):
+class SubSetting(BaseModelObject):
     auto_align: bool | None = None
 
 
-@dataclass
-class FlowElement(ChartObject):
+class ChartPosition(BaseModelObject):
+    x: float | None = None
+    y: float | None = None
+
+
+class FlowElement(BaseModelObject):
     id: str | None = None
     type: str | None = None
-    position: tuple[float | None, float | None] | None = None
-    data: dict[str, object] | 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
 
 
-@dataclass
-class Flow(ChartObject):
+class Flow(BaseModelObject):
     zoom: float | None = None
     elements: list[FlowElement] | None = None
     position: tuple[float | None, float | None] | None = None
 
-    def dump(self, camel_case: bool = True) -> dict[str, Any]:
-        data = super().dump(camel_case=camel_case)
-        if self.elements:
-            data["elements"] = [el.dump(camel_case=camel_case) for el in self.elements]
-        return data
 
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        """Load a Flow object from a dictionary."""
-        instance = super()._load(resource, cognite_client=cognite_client)
-        if "elements" in resource:
-            instance.elements = [FlowElement._load(el, cognite_client=cognite_client) for el in resource["elements"]]
-        return instance
+class ChartElement(BaseModelObject):
+    id: str | None = None
+    type: str | None = None
 
 
-@dataclass
-class ChartSource(ChartObject):
-    type: str | None = None
-    id: str | None = None
+class ChartSource(ChartElement): ...
 
 
-@dataclass
-class BaseChartElement(ChartObject):
-    type: str | None = None
-    id: str | None = None
-    name: str | None = None
+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
-    line_weight: float | None = None
-    line_style: str | None = None
     interpolation: str | None = None
-    unit: str | None = None
+    line_style: str | None = None
+    line_weight: float | None = None
+    name: str | None = None
     preferred_unit: str | None = None
-    created_at: int | None = None
-    range: tuple[float | None, float | None] | None = None
-    description: 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
 
-@dataclass
-class ChartCoreTimeseries(BaseChartElement):
-    node_reference: NodeId | None = None
-    view_reference: ViewId | None = None
-    display_mode: str | None = 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)
 
 
-@dataclass
-class ChartTimeseries(BaseChartElement):
+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
 
 
-@dataclass
-class ChartWorkflow(BaseChartElement):
+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
 
-    def dump(self, camel_case: bool = True) -> dict[str, Any]:
-        data = super().dump(camel_case=camel_case)
-        if self.settings:
-            data["settings"] = self.settings.dump(camel_case=camel_case)
-        if self.flow:
-            data["flow"] = self.flow.dump(camel_case=camel_case)
-        if self.calls:
-            data["calls"] = [c.dump(camel_case=camel_case) for c in self.calls]
-        return data
 
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        """Load a ChartWorkflow object from a dictionary."""
-        instance = super()._load(resource, cognite_client=cognite_client)
-        if "settings" in resource:
-            instance.settings = SubSetting._load(resource["settings"], cognite_client=cognite_client)
-        if "flow" in resource:
-            instance.flow = Flow._load(resource["flow"], cognite_client=cognite_client)
-        if "calls" in resource:
-            instance.calls = [ChartCall._load(call, cognite_client=cognite_client) for call in resource["calls"]]
-        return instance
-
-
-@dataclass
-class ChartThreshold(BaseChartElement):
+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
 
-    def dump(self, camel_case: bool = True) -> dict[str, Any]:
-        data = super().dump(camel_case=camel_case)
-        if self.filter:
-            data["filter"] = self.filter.dump(camel_case=camel_case)
-        if self.calls:
-            data["calls"] = [c.dump(camel_case=camel_case) for c in self.calls]
-        return data
 
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        """Load a ChartThreshold object from a dictionary."""
-        instance = super()._load(resource, cognite_client=cognite_client)
-        if "filter" in resource:
-            instance.filter = ThresholdFilter._load(resource["filter"], cognite_client=cognite_client)
-        if "calls" in resource:
-            instance.calls = [ChartCall._load(call, cognite_client=cognite_client) for call in resource["calls"]]
-        return instance
-
-
-@dataclass
-class ChartScheduledCalculation(BaseChartElement):
+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
 
-    def dump(self, camel_case: bool = True) -> dict[str, Any]:
-        data = super().dump(camel_case=camel_case)
-        if self.settings:
-            data["settings"] = self.settings.dump(camel_case=camel_case)
-        if self.flow:
-            data["flow"] = self.flow.dump(camel_case=camel_case)
-        return data
 
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        """Load a ChartScheduledCalculation object from a dictionary."""
-        instance = super()._load(resource, cognite_client=cognite_client)
-        if "settings" in resource:
-            instance.settings = SubSetting._load(resource["settings"], cognite_client=cognite_client)
-        if "flow" in resource:
-            instance.flow = Flow._load(resource["flow"], cognite_client=cognite_client)
-        return instance
-
-
-@dataclass
-class ChartData(ChartObject):
+class ChartData(BaseModelObject):
     version: int | None = None
     name: str | None = None
     date_from: str | None = None
@@ -241,62 +182,3 @@ class ChartData(ChartObject):
     threshold_collection: list[ChartThreshold] | None = None
     scheduled_calculation_collection: list[ChartScheduledCalculation] | None = None
     settings: ChartSettings | None = None
-
-    def dump(self, camel_case: bool = True) -> dict[str, Any]:
-        """Dump the ChartData object to a dictionary."""
-        data = super().dump(camel_case=camel_case)
-        list_attrs = [
-            "time_series_collection",
-            "core_timeseries_collection",
-            "workflow_collection",
-            "source_collection",
-            "threshold_collection",
-            "scheduled_calculation_collection",
-        ]
-        for attr_name in list_attrs:
-            if collection := getattr(self, attr_name):
-                key = to_camel_case(attr_name) if camel_case else attr_name
-                data[key] = [item.dump(camel_case=camel_case) for item in collection]
-
-        single_attrs_map = {
-            "user_info": "userInfo",
-            "settings": "settings",
-        }
-        for attr_name, camel_key in single_attrs_map.items():
-            if item := getattr(self, attr_name):
-                key = camel_key if camel_case else attr_name
-                data[key] = item.dump(camel_case=camel_case)
-        return data
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
-        """Load a ChartData object from a dictionary."""
-        instance = super()._load(resource, cognite_client=cognite_client)
-        collections_map = [
-            ("timeSeriesCollection", "time_series_collection", ChartTimeseries),
-            ("coreTimeseriesCollection", "core_timeseries_collection", ChartCoreTimeseries),
-            ("workflowCollection", "workflow_collection", ChartWorkflow),
-            ("sourceCollection", "source_collection", ChartSource),
-            ("thresholdCollection", "threshold_collection", ChartThreshold),
-            ("scheduledCalculationCollection", "scheduled_calculation_collection", ChartScheduledCalculation),
-        ]
-        for resource_key, attr_name, subclass in collections_map:
-            if resource_key in resource:
-                setattr(
-                    instance,
-                    attr_name,
-                    [subclass._load(item, cognite_client=cognite_client) for item in resource[resource_key]],  # type: ignore[attr-defined]
-                )
-        attribute_map = [
-            ("userInfo", "user_info", UserInfo),
-            ("settings", "settings", ChartSettings),
-        ]
-        for resource_key, attr_name, subclass in attribute_map:
-            if resource_key in resource:
-                setattr(
-                    instance,
-                    attr_name,
-                    subclass._load(resource[resource_key], cognite_client=cognite_client),  # type: ignore[attr-defined]
-                )
-
-        return instance

cognite_toolkit/_cdf_tk/client/data_classes/infield.py

@@ -1,15 +1,16 @@
 import sys
-from collections import UserList
 from typing import Any, ClassVar, Literal
 
-from cognite.client import CogniteClient
 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.protocols import (
+    ResourceRequestListProtocol,
+    ResourceResponseListProtocol,
+)
 from cognite_toolkit._cdf_tk.utils.text import sanitize_instance_external_id
 
-from .base import ResponseResource
+from .base import BaseResourceList, ResponseResource
 from .instance_api import InstanceRequestResource, ViewReference
 
 if sys.version_info >= (3, 11):
@@ -18,6 +19,9 @@ 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")
 
 
@@ -74,29 +78,39 @@ class InfieldLocationConfig(
 
 
 class InfieldLocationConfigList(
-    UserList[InfieldLocationConfig],
+    BaseResourceList[InfieldLocationConfig],
     ResourceResponseListProtocol,
     ResourceRequestListProtocol,
 ):
     """A list of InfieldLocationConfig objects."""
 
     _RESOURCE = InfieldLocationConfig
-    data: list[InfieldLocationConfig]
 
-    def __init__(self, initlist: list[InfieldLocationConfig] | None = None, **_: Any) -> None:
-        super().__init__(initlist or [])
+    def as_write(self) -> Self:
+        return self
+
 
-    def dump(self, camel_case: bool = True) -> list[dict[str, Any]]:
-        """Serialize the list of InfieldLocationConfig objects to a list of dictionaries."""
-        return [item.dump(camel_case) for item in self.data]
+class InFieldCDMLocationConfig(ResponseResource["InFieldCDMLocationConfig"], InstanceRequestResource):
+    """InField CDM Location Configuration resource class.
 
-    @classmethod
-    def load(
-        cls, data: list[dict[str, Any]], cognite_client: CogniteClient | None = None
-    ) -> "InfieldLocationConfigList":
-        """Deserialize a list of dictionaries to an InfieldLocationConfigList."""
-        items = [InfieldLocationConfig.model_validate(item) for item in data]
-        return cls(items)
+    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/migration.py

@@ -16,7 +16,7 @@ from cognite.client.data_classes.data_modeling.instances import (
 
 from cognite_toolkit._cdf_tk.constants import COGNITE_MIGRATION_SPACE
 from cognite_toolkit._cdf_tk.tk_warnings import IgnoredValueWarning
-from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricType
+from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricType, AssetCentricTypeExtended
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -26,7 +26,7 @@ else:
 
 @dataclass(frozen=True)
 class AssetCentricId(CogniteObject):
-    resource_type: AssetCentricType
+    resource_type: AssetCentricTypeExtended
     id_: int
 
     @classmethod
@@ -114,6 +114,14 @@ class InstanceSource(_InstanceSourceProperties, TypedNode):
         self.preferred_consumer_view_id = preferred_consumer_view_id
         self.ingestion_view = DirectRelationReference.load(ingestion_view) if ingestion_view else None
 
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        output = super().dump(camel_case)
+        if self.preferred_consumer_view_id:
+            output["properties"]["cognite_migration"]["InstanceSource/v1"]["preferredConsumerViewId"] = (
+                self.preferred_consumer_view_id.dump(camel_case=camel_case)
+            )
+        return output
+
     @classmethod
     def _load_properties(cls, resource: dict[str, Any]) -> dict[str, Any]:
         if "preferredConsumerViewId" in resource:

cognite_toolkit/_cdf_tk/client/data_classes/streams.py

@@ -0,0 +1,90 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.constants import StreamTemplateName
+from cognite_toolkit._cdf_tk.protocols import (
+    ResourceRequestListProtocol,
+    ResourceResponseListProtocol,
+)
+
+from .base import BaseModelObject, BaseResourceList, RequestResource, ResponseResource
+
+
+class StreamRequest(RequestResource):
+    """Stream request resource class."""
+
+    external_id: str
+    settings: dict[Literal["template"], dict[Literal["name"], StreamTemplateName]]
+
+    def as_id(self) -> str:
+        return self.external_id
+
+
+class StreamRequestList(BaseResourceList[StreamRequest], ResourceRequestListProtocol):
+    """List of Stream request resources."""
+
+    _RESOURCE = StreamRequest
+
+
+class LifecycleObject(BaseModelObject):
+    """Lifecycle object."""
+
+    hot_phase_duration: str | None = None
+    data_deleted_after: str | None = None
+    retained_after_soft_delete: str
+
+
+class ResourceUsage(BaseModelObject):
+    """Resource quota with provisioned and consumed values."""
+
+    provisioned: int
+    consumed: int | None = None
+
+
+class LimitsObject(BaseModelObject):
+    """Limits object."""
+
+    max_records_total: ResourceUsage
+    max_giga_bytes_total: ResourceUsage
+    max_filtering_interval: str | None = None
+
+
+class StreamSettings(BaseModelObject):
+    """Stream settings object."""
+
+    lifecycle: LifecycleObject
+    limits: LimitsObject
+
+
+class StreamResponse(ResponseResource["StreamRequest"]):
+    """Stream response resource class."""
+
+    external_id: str
+    created_time: int
+    created_from_template: StreamTemplateName
+    type: Literal["Mutable", "Immutable"]
+    settings: StreamSettings | None = None
+
+    def as_request_resource(self) -> StreamRequest:
+        return StreamRequest.model_validate(
+            {
+                "externalId": self.external_id,
+                "settings": {"template": {"name": self.created_from_template}},
+            }
+        )
+
+    def as_write(self) -> StreamRequest:
+        return StreamRequest.model_validate(
+            {
+                "externalId": self.external_id,
+                "settings": {"template": {"name": self.created_from_template}},
+            }
+        )
+
+
+class StreamResponseList(BaseResourceList[StreamResponse], ResourceResponseListProtocol):
+    """List of Stream response resources."""
+
+    _RESOURCE = StreamResponse
+
+    def as_write(self) -> StreamRequestList:
+        return StreamRequestList([item.as_write() for item in self.data])

cognite_toolkit/_cdf_tk/client/data_classes/three_d.py

@@ -0,0 +1,47 @@
+from typing import Literal
+
+from .base import BaseModelObject, RequestResource, ResponseResource
+
+
+class NodeReference(BaseModelObject):
+    space: str
+    external_id: str
+
+
+class RevisionStatus(BaseModelObject):
+    status: Literal["Queued", "Processing", "Done", "Failed"] | None = None
+    revision_id: int | None = None
+    created_time: int | None = None
+    revision_count: int | None = None
+    types: list[str] | None = None
+
+
+class ThreeDModelRequest(RequestResource):
+    name: str
+
+
+class ThreeDModelClassicRequest(ThreeDModelRequest):
+    data_set_id: int | None = None
+    metadata: dict[str, str] | None = None
+
+
+class ThreeDModelDMSRequest(ThreeDModelRequest):
+    space: str
+    type: Literal["CAD", "PointCloud", "Image360"]
+    thumbnail_reference: NodeReference | None = None
+
+
+class ThreeDModelResponse(ResponseResource[ThreeDModelRequest]):
+    name: str
+    id: int
+    created_time: int
+    data_set_id: int | None = None
+    metadata: dict[str, str] | None = None
+    space: str | None = None
+    last_revision_info: RevisionStatus | None = None
+
+    def as_request_resource(self) -> ThreeDModelRequest:
+        if self.space is None:
+            return ThreeDModelClassicRequest._load(self.dump())
+        else:
+            return ThreeDModelDMSRequest._load(self.dump())