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

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,157 @@
+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 InstanceIdentifier(Identifier):
+    """Identifier for an Instance instance."""
+
+    instance_type: InstanceType
+    space: str
+    external_id: str
+
+
+class NodeIdentifier(InstanceIdentifier):
+    instance_type: Literal["node"] = "node"
+
+
+class EdgeIdentifier(InstanceIdentifier):
+    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) -> InstanceIdentifier:
+        return InstanceIdentifier(
+            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) -> InstanceIdentifier:
+        return InstanceIdentifier(
+            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(BaseModelObject):
+    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) -> InstanceIdentifier:
+        return InstanceIdentifier(
+            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: InstanceIdentifier | 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) -> InstanceIdentifier:
+        return InstanceIdentifier(
+            instance_type=self.instance_type,
+            space=self.space,
+            external_id=self.external_id,
+        )

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 AssetCentric
+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: AssetCentric
+    resource_type: AssetCentricTypeExtended
     id_: int
 
     @classmethod
@@ -97,7 +97,7 @@ class InstanceSource(_InstanceSourceProperties, TypedNode):
         last_updated_time: int,
         created_time: int,
         *,
-        resource_type: Literal["asset", "event", "file", "sequence", "timeseries"],
+        resource_type: AssetCentricType,
         id_: int,
         data_set_id: int | None = None,
         classic_external_id: str | None = None,
@@ -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:
@@ -151,6 +159,9 @@ class InstanceSource(_InstanceSourceProperties, TypedNode):
         }[self.resource_type]
         return ViewId("cdf_cdm", external_id, "v1")
 
+    def as_direct_relation_reference(self) -> DirectRelationReference:
+        return DirectRelationReference(space=self.space, external_id=self.external_id)
+
 
 class _ResourceViewMapping:
     resource_type = PropertyOptions("resourceType")
@@ -347,3 +358,100 @@ class ResourceViewMapping(_ResourceViewMapping, TypedNode):
             "viewId": self.view_id.dump(),
             "propertyMapping": self.property_mapping,
         }
+
+
+class CreatedSourceSystem(TypedNode):
+    """This represents the reading format of instance source.
+
+    It is used to when data is read from CDF.
+
+    The source of the instance in asset-centric resources.
+
+    Args:
+        space: The space where the node is located.
+        external_id: The external id of the instance source.
+        version (int): DMS version.
+        last_updated_time (int): The number of milliseconds since 00:00:00 Thursday, 1 January 1970,
+            Coordinated Universal Time (UTC), minus leap seconds.
+        created_time (int): The number of milliseconds since 00:00:00 Thursday, 1 January 1970,
+            Coordinated Universal Time (UTC), minus leap seconds.
+        source: The source string from the asset-centric Asset, Event, or FileMetadata source property.
+        type: Direct relation pointing to the type node.
+        deleted_time: The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time
+            (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances
+            are filtered out of query results, but present in sync results
+    """
+
+    def __init__(
+        self,
+        space: str,
+        external_id: str,
+        version: int,
+        last_updated_time: int,
+        created_time: int,
+        *,
+        source: str,
+        type: DirectRelationReference | None = None,
+        deleted_time: int | None = None,
+    ) -> None:
+        TypedNode.__init__(self, space, external_id, version, last_updated_time, created_time, deleted_time, type)
+        self.source = source
+
+    @classmethod
+    def get_source(cls) -> ViewId:
+        return ViewId("cognite_migration", "CreatedSourceSystem", "v1")
+
+    def as_direct_relation_reference(self) -> DirectRelationReference:
+        return DirectRelationReference(space=self.space, external_id=self.external_id)
+
+
+class SpaceSource(TypedNode):
+    """This represents the reading format of space source.
+
+    It is used to when data is read from CDF.
+
+    The source dataSet of an instance space
+
+    Args:
+        space: The space where the node is located.
+        external_id: The external id of the node.
+        version (int): DMS version.
+        last_updated_time (int): The number of milliseconds since 00:00:00 Thursday, 1 January 1970,
+            Coordinated Universal Time (UTC), minus leap seconds.
+        created_time (int): The number of milliseconds since 00:00:00 Thursday, 1 January 1970,
+            Coordinated Universal Time (UTC), minus leap seconds.
+        instance_space (str): The instance space name.
+        data_set_id: The data set id associated with the instance space.
+        data_set_external_id: The classic external id associated with the instance space.
+        type: Direct relation pointing to the type node.
+        deleted_time: The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time
+            (UTC), minus leap seconds. Timestamp when the instance was soft deleted. Note that deleted instances
+            are filtered out of query results, but present in sync results
+    """
+
+    instance_space = PropertyOptions("instanceSpace")
+    data_set_id = PropertyOptions("dataSetId")
+    data_set_external_id = PropertyOptions("dataSetExternalId")
+
+    def __init__(
+        self,
+        space: str,
+        external_id: str,
+        version: int,
+        last_updated_time: int,
+        created_time: int,
+        *,
+        instance_space: str,
+        data_set_id: int,
+        data_set_external_id: str | None = None,
+        type: DirectRelationReference | None = None,
+        deleted_time: int | None = None,
+    ) -> None:
+        TypedNode.__init__(self, space, external_id, version, last_updated_time, created_time, deleted_time, type)
+        self.instance_space = instance_space
+        self.data_set_id = data_set_id
+        self.data_set_external_id = data_set_external_id
+
+    @classmethod
+    def get_source(cls) -> ViewId:
+        return ViewId("cognite_migration", "SpaceSource", "v1")

cognite_toolkit/_cdf_tk/client/data_classes/project.py

@@ -0,0 +1,41 @@
+import sys
+from dataclasses import dataclass
+from typing import Any, Literal
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes._base import CogniteResource, CogniteResourceList
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+@dataclass
+class ProjectStatus(CogniteResource):
+    """Project status information."""
+
+    data_modeling_status: Literal["HYBRID", "DATA_MODELING_ONLY"]
+    url_name: str
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            data_modeling_status=resource["dataModelingStatus"],
+            url_name=resource["urlName"],
+        )
+
+
+class ProjectStatusList(CogniteResourceList[ProjectStatus]):
+    """List of ProjectStatus items."""
+
+    _RESOURCE = ProjectStatus
+
+    @property
+    def this_project(self) -> ProjectStatus:
+        """Returns the ProjectStatus of the current project."""
+        project = self._cognite_client.config.project
+        for item in self:
+            if item.url_name == project:
+                return item
+        raise ValueError(f"Project '{project}' not found in the list of projects.")

cognite_toolkit/_cdf_tk/client/data_classes/search_config.py

@@ -17,6 +17,9 @@ class ViewId(CogniteObject):
     external_id: str
     space: str
 
+    def __str__(self) -> str:
+        return f"({self.external_id}, {self.space})"
+
     @classmethod
     def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
         return cls(

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())