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

cognite_toolkit/_cdf_tk/client/data_classes/extended_filemetdata.py

@@ -0,0 +1,113 @@
+import sys
+from collections.abc import Sequence
+from typing import Any, cast
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes import GeoLocation, Label
+from cognite.client.data_classes.data_modeling import NodeId
+from cognite.client.data_classes.files import FileMetadata, FileMetadataList
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+class ExtendedFileMetadata(FileMetadata):
+    """Extended FileMetadata with pending instance ID support.
+    Args:
+        external_id (str | None): The external ID provided by the client. Must be unique for the resource type.
+        instance_id (NodeId | None): The Instance ID for the file. (Only applicable for files created in DMS)
+        name (str | None): Name of the file.
+        source (str | None): The source of the file.
+        mime_type (str | None): File type. E.g., text/plain, application/pdf, ...
+        metadata (dict[str, str] | None): Custom, application-specific metadata. String key -> String value. Limits: Maximum length of key is 32 bytes, value 512 bytes, up to 16 key-value pairs.
+        directory (str | None): Directory associated with the file. It must be an absolute, unix-style path.
+        asset_ids (Sequence[int] | None): No description.
+        data_set_id (int | None): The dataSet ID for the item.
+        labels (Sequence[Label] | None): A list of the labels associated with this resource item.
+        geo_location (GeoLocation | None): The geographic metadata of the file.
+        source_created_time (int | None): The timestamp for when the file was originally created in the source system.
+        source_modified_time (int | None): The timestamp for when the file was last modified in the source system.
+        security_categories (Sequence[int] | None): The security category IDs required to access this file.
+        id (int | None): A server-generated ID for the object.
+        uploaded (bool | None): Whether the actual file is uploaded. This field is returned only by the API, it has no effect in a post body.
+        uploaded_time (int | None): The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
+        created_time (int | None): The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
+        last_updated_time (int | None): The number of milliseconds since 00:00:00 Thursday, 1 January 1970, Coordinated Universal Time (UTC), minus leap seconds.
+        pending_instance_id( NodeId | None): The pending instance ID for the file, used in upgrading files from asset centric to data modeling.
+        cognite_client (CogniteClient | None): The client to associate with this object.
+    """
+
+    def __init__(
+        self,
+        external_id: str | None = None,
+        instance_id: NodeId | None = None,
+        name: str | None = None,
+        source: str | None = None,
+        mime_type: str | None = None,
+        metadata: dict[str, str] | None = None,
+        directory: str | None = None,
+        asset_ids: Sequence[int] | None = None,
+        data_set_id: int | None = None,
+        labels: Sequence[Label] | None = None,
+        geo_location: GeoLocation | None = None,
+        source_created_time: int | None = None,
+        source_modified_time: int | None = None,
+        security_categories: Sequence[int] | None = None,
+        id: int | None = None,
+        uploaded: bool | None = None,
+        uploaded_time: int | None = None,
+        created_time: int | None = None,
+        last_updated_time: int | None = None,
+        pending_instance_id: NodeId | None = None,
+        cognite_client: CogniteClient | None = None,
+    ) -> None:
+        super().__init__(
+            external_id=external_id,
+            instance_id=instance_id,
+            name=name,
+            directory=directory,
+            source=source,
+            mime_type=mime_type,
+            metadata=metadata,
+            asset_ids=asset_ids,
+            data_set_id=data_set_id,
+            labels=labels,
+            geo_location=geo_location,
+            source_created_time=source_created_time,
+            source_modified_time=source_modified_time,
+            security_categories=security_categories,
+        )
+        # id/created_time/last_updated_time are required when using the class to read,
+        # but don't make sense passing in when creating a new object. So in order to make the typing
+        # correct here (i.e. int and not Optional[int]), we force the type to be int rather than
+        # Optional[int].
+        # TODO: In the next major version we can make these properties required in the constructor
+        self.id: int = id  # type: ignore
+        self.created_time: int = created_time  # type: ignore
+        self.last_updated_time: int = last_updated_time  # type: ignore
+        self.uploaded = uploaded
+        self.uploaded_time = uploaded_time
+        self._cognite_client = cast("CogniteClient", cognite_client)
+        self.pending_instance_id = pending_instance_id
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        instance = super()._load(resource, cognite_client)
+        if isinstance(instance.pending_instance_id, dict):
+            instance.pending_instance_id = NodeId.load(instance.pending_instance_id)
+        return instance
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        """Dump the object to a dictionary"""
+        output = super().dump(camel_case=camel_case)
+        if self.pending_instance_id is not None:
+            output["pendingInstanceId" if camel_case else "pending_instance_id"] = self.pending_instance_id.dump(
+                camel_case=camel_case, include_instance_type=False
+            )
+        return output
+
+
+class ExtendedFileMetadataList(FileMetadataList):
+    _RESOURCE = ExtendedFileMetadata  # type: ignore[assignment]

cognite_toolkit/_cdf_tk/client/data_classes/functions.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from dataclasses import dataclass
 from typing import Any
 

cognite_toolkit/_cdf_tk/client/data_classes/graphql_data_models.py

@@ -1,5 +1,4 @@
-from __future__ import annotations
-
+import sys
 from abc import ABC
 from typing import Any
 
@@ -8,6 +7,11 @@ from cognite.client.data_classes._base import CogniteResourceList, WriteableCogn
 from cognite.client.data_classes.data_modeling import DataModelId, ViewId
 from cognite.client.data_classes.data_modeling.core import DataModelingSchemaResource
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
 
 class _GraphQLDataModelCore(DataModelingSchemaResource["GraphQLDataModelWrite"], ABC):
     def __init__(
@@ -38,7 +42,7 @@ class GraphQLDataModelWrite(_GraphQLDataModelCore):
         self.preserve_dml = preserve_dml
 
     @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> GraphQLDataModelWrite:
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
         return cls(
             space=resource["space"],
             external_id=resource["externalId"],
@@ -50,7 +54,7 @@ class GraphQLDataModelWrite(_GraphQLDataModelCore):
             preserve_dml=resource.get("preserveDml"),
         )
 
-    def as_write(self) -> GraphQLDataModelWrite:
+    def as_write(self) -> Self:
         return self
 
 
@@ -83,7 +87,7 @@ class GraphQLDataModel(_GraphQLDataModelCore):
         )
 
     @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> GraphQLDataModel:
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
         return cls(
             space=resource["space"],
             external_id=resource["externalId"],

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

cognite_toolkit/_cdf_tk/client/data_classes/location_filters.py

@@ -1,5 +1,3 @@
-from __future__ import annotations
-
 from abc import ABC
 from dataclasses import dataclass
 
@@ -94,7 +92,7 @@ class AssetCentricFilter(CogniteObject):
         return None
 
     @classmethod
-    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> AssetCentricFilter:
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
         return cls(
             assets=cls._load_subfilter(resource, "assets"),
             events=cls._load_subfilter(resource, "events"),
@@ -163,7 +161,7 @@ class LocationFilterCore(WriteableCogniteResource["LocationFilterWrite"], ABC):
         self.data_modeling_type = data_modeling_type
         self._parent_external_id = _parent_external_id  # This is an internal property used to temporarily hold the parentExternalId when lookup is deferred
 
-    def as_write(self) -> LocationFilterWrite:
+    def as_write(self) -> "LocationFilterWrite":
         return LocationFilterWrite(
             external_id=self.external_id,
             name=self.name,
@@ -253,7 +251,7 @@ class LocationFilter(LocationFilterCore):
         asset_centric: AssetCentricFilter | None = None,
         views: list[LocationFilterView] | None = None,
         data_modeling_type: Literal["HYBRID", "DATA_MODELING_ONLY"] | None = None,
-        locations: LocationFilterList | None = None,
+        locations: "LocationFilterList | None" = None,
     ) -> None:
         super().__init__(
             external_id,