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

cognite_toolkit/_cdf_tk/client/resource_classes/streamlit_.py

@@ -0,0 +1,71 @@
+from typing import Any, Literal
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .filemetadata import FileMetadataRequest
+from .identifiers import ExternalId
+
+
+class StreamlitFile(BaseModelObject):
+    """Base class for Streamlit app with common fields."""
+
+    external_id: str
+    name: str
+    creator: str
+    entrypoint: str | None = None
+    description: str | None = None
+    published: bool = False
+    theme: Literal["Light", "Dark"] = "Light"
+    thumbnail: str | None = None
+    data_set_id: int | None = None
+    cognite_toolkit_app_hash: str | None = None
+
+
+class StreamlitRequest(StreamlitFile, UpdatableRequestResource):
+    """Request resource for creating/updating Streamlit apps."""
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+    def as_file(self) -> FileMetadataRequest:
+        metadata: dict[str, str] = {
+            "creator": self.creator,
+            "name": self.name,
+            "published": str(self.published),
+            "theme": str(self.theme),
+        }
+        if self.description:
+            metadata["description"] = self.description
+        if self.thumbnail:
+            metadata["thumbnail"] = self.thumbnail
+        if self.cognite_toolkit_app_hash:
+            metadata["cdf-toolkit-app-hash"] = self.cognite_toolkit_app_hash
+        if self.entrypoint:
+            metadata["entrypoint"] = self.entrypoint
+        return FileMetadataRequest(
+            external_id=self.external_id,
+            name=f"{self.name}-source.json",
+            data_set_id=self.data_set_id,
+            directory="/streamlit-apps/",
+            metadata=metadata,
+        )
+
+    def dump(self, camel_case: bool = True, exclude_extra: bool = False) -> dict[str, Any]:
+        return self.as_file().dump(camel_case=camel_case, exclude_extra=exclude_extra)
+
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
+        return self.as_file().as_update(mode)
+
+
+class StreamlitResponse(StreamlitFile, ResponseResource[StreamlitRequest]):
+    """Response resource for Streamlit apps."""
+
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> StreamlitRequest:
+        return StreamlitRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/{data_classes → resource_classes}/streams.py

@@ -1,34 +1,27 @@
 from typing import Literal
 
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource, ResponseResource
 from cognite_toolkit._cdf_tk.constants import StreamTemplateName
-from cognite_toolkit._cdf_tk.protocols import (
-    ResourceRequestListProtocol,
-    ResourceResponseListProtocol,
-)
 
-from .base import BaseModelObject, BaseResourceList, RequestResource, ResponseResource
+from .identifiers import ExternalId
 
 
-class StreamRequest(RequestResource):
-    """Stream request resource class."""
-
+class Stream(BaseModelObject):
     external_id: str
-    settings: dict[Literal["template"], dict[Literal["name"], StreamTemplateName]]
 
-    def as_id(self) -> str:
-        return self.external_id
 
+class StreamRequest(Stream, RequestResource):
+    """Stream request resource class."""
 
-class StreamRequestList(BaseResourceList[StreamRequest], ResourceRequestListProtocol):
-    """List of Stream request resources."""
+    settings: dict[Literal["template"], dict[Literal["name"], StreamTemplateName]]
 
-    _RESOURCE = StreamRequest
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
 
 
 class LifecycleObject(BaseModelObject):
     """Lifecycle object."""
 
-    hot_phase_duration: str | None = None
     data_deleted_after: str | None = None
     retained_after_soft_delete: str
 
@@ -55,10 +48,9 @@ class StreamSettings(BaseModelObject):
     limits: LimitsObject
 
 
-class StreamResponse(ResponseResource["StreamRequest"]):
+class StreamResponse(Stream, ResponseResource[StreamRequest]):
     """Stream response resource class."""
 
-    external_id: str
     created_time: int
     created_from_template: StreamTemplateName
     type: Literal["Mutable", "Immutable"]
@@ -79,12 +71,3 @@ class StreamResponse(ResponseResource["StreamRequest"]):
                 "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/resource_classes/three_d.py

@@ -0,0 +1,135 @@
+import sys
+from typing import ClassVar, Literal
+
+from pydantic import Field
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    Identifier,
+    RequestResource,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import InternalId
+from .instance_api import NodeReference
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+
+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
+    # This field is part of the path request and not the body schema.
+    # but is needed for identifier conversion.
+    id: int | None = Field(None, exclude=True)
+
+    def as_id(self) -> InternalId:
+        if self.id is None:
+            raise ValueError("Cannot convert to InternalId when id is None.")
+        return InternalId(id=self.id)
+
+
+class ThreeDModelClassicRequest(ThreeDModelRequest, UpdatableRequestResource):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata"})
+    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())
+
+
+class AssetMappingDMRequest(RequestResource, Identifier):
+    node_id: int
+    asset_instance_id: NodeReference
+    # These fields are part of the path request and not the body schema.
+    model_id: int = Field(exclude=True)
+    revision_id: int = Field(exclude=True)
+
+    def as_id(self) -> Self:
+        return self
+
+    def __str__(self) -> str:
+        return f"{self.model_id}_{self.revision_id}_{self.node_id}_{self.asset_instance_id.space}_{self.asset_instance_id.external_id}"
+
+
+class AssetMappingClassicRequest(RequestResource, Identifier):
+    node_id: int
+    asset_id: int | None = None
+    asset_instance_id: NodeReference | None = None
+    # These fields are part of the path request and not the body schema.
+    model_id: int = Field(exclude=True)
+    revision_id: int = Field(exclude=True)
+
+    def as_id(self) -> Self:
+        return self
+
+    def __str__(self) -> str:
+        asset_part = (
+            f"assetId:{self.asset_id}"
+            if self.asset_id is not None
+            else f"assetInstance:{self.asset_instance_id.space}_{self.asset_instance_id.external_id}"
+            if self.asset_instance_id is not None
+            else "noAsset"
+        )
+        return f"{self.model_id}_{self.revision_id}_{self.node_id}_{asset_part}"
+
+
+class AssetMappingClassicResponse(ResponseResource[AssetMappingClassicRequest]):
+    node_id: int
+    asset_id: int | None = None
+    asset_instance_id: NodeReference | None = None
+    tree_index: int | None = None
+    subtree_size: int | None = None
+    # These fields are part of the path request and response, but they are included here for convenience.
+    model_id: int = Field(-1, exclude=True)
+    revision_id: int = Field(-1, exclude=True)
+
+    def as_request_resource(self) -> AssetMappingClassicRequest:
+        return AssetMappingClassicRequest.model_validate(
+            {**self.dump(), "modelId": self.model_id, "revisionId": self.revision_id}
+        )
+
+
+class AssetMappingDMResponse(ResponseResource[AssetMappingDMRequest]):
+    node_id: int
+    asset_instance_id: NodeReference
+    tree_index: int | None = None
+    subtree_size: int | None = None
+    # These fields are part of the path request and response, but they are included here for convenience.
+    model_id: int = Field(-1, exclude=True)
+    revision_id: int = Field(-1, exclude=True)
+
+    def as_request_resource(self) -> AssetMappingDMRequest:
+        return AssetMappingDMRequest.model_validate(
+            {**self.dump(), "modelId": self.model_id, "revisionId": self.revision_id}
+        )

cognite_toolkit/_cdf_tk/client/resource_classes/timeseries.py

@@ -0,0 +1,52 @@
+from typing import Any, ClassVar, Literal
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId, InternalOrExternalId
+from .instance_api import NodeReference
+
+
+class TimeSeries(BaseModelObject):
+    external_id: str | None = None
+    name: str | None = None
+    is_string: bool = False
+    metadata: dict[str, str] | None = None
+    unit: str | None = None
+    unit_external_id: str | None = None
+    asset_id: int | None = None
+    is_step: bool = False
+    description: str | None = None
+    security_categories: list[int] | None = None
+    data_set_id: int | None = None
+
+    def as_id(self) -> InternalOrExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert TimeSeriesRequest to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class TimeSeriesRequest(TimeSeries, UpdatableRequestResource):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "security_categories"})
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"is_step"})
+
+    def as_update(self, mode: Literal["patch", "replace"]) -> dict[str, Any]:
+        dumped = super().as_update(mode)
+        update = dumped["update"] if "update" in dumped else dumped
+        # isString is immutable in CDF, so we remove it from update payloads
+        update.pop("isString", None)
+        return dumped
+
+
+class TimeSeriesResponse(TimeSeries, ResponseResource[TimeSeriesRequest]):
+    id: int
+    instance_id: NodeReference | None = None
+    type: str
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> TimeSeriesRequest:
+        return TimeSeriesRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/transformation.py

@@ -0,0 +1,140 @@
+from typing import Annotated, ClassVar, Literal
+
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    ResponseResource,
+    UpdatableRequestResource,
+)
+
+from .identifiers import ExternalId
+
+
+class NonceCredentials(BaseModelObject):
+    nonce: str
+
+
+class DestinationDefinition(BaseModelObject):
+    type: str
+
+
+class DataModelInfo(BaseModelObject):
+    space: str
+    external_id: str
+    version: str
+    destination_type: str
+    destination_relationship_from_type: str | None = None
+
+
+class ViewInfo(BaseModelObject):
+    space: str
+    external_id: str
+    version: str
+
+
+class EdgeType(BaseModelObject):
+    space: str
+    external_id: str
+
+
+class AssetCentricDataSource(DestinationDefinition):
+    type: Literal[
+        "assets",
+        "events",
+        "asset_hierarchy",
+        "datapoints",
+        "string_datapoints",
+        "timeseries",
+        "sequences",
+        "files",
+        "labels",
+        "relationships",
+        "data_sets",
+    ]
+
+
+class DataModelSource(DestinationDefinition):
+    type: Literal["instances"] = "instances"
+    data_model: DataModelInfo
+    instance_space: str | None = None
+
+
+class ViewDataSource(DestinationDefinition):
+    type: Literal["nodes", "edges"]
+    view: ViewInfo
+    edge_type: EdgeType | None = None
+    instance_space: str | None = None
+
+
+class RawDataSource(DestinationDefinition):
+    type: Literal["raw_tables"] = "raw_tables"
+    database: str
+    table: str
+
+
+class SequenceRowDataSource(DestinationDefinition):
+    type: Literal["sequence_rows"] = "sequence_rows"
+    external_id: str
+
+
+Destination = Annotated[
+    AssetCentricDataSource | DataModelSource | ViewDataSource | RawDataSource | SequenceRowDataSource,
+    Field(discriminator="type"),
+]
+
+
+class BlockedInfo(BaseModelObject):
+    reason: str
+    created_time: int
+
+
+class SessionInfo(BaseModelObject):
+    client_id: str
+    session_id: str
+    project_name: str
+
+
+class Transformation(BaseModelObject):
+    external_id: str
+    name: str
+    ignore_null_fields: bool
+    data_set_id: int | None = None
+    tags: list[str] | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class TransformationRequest(Transformation, UpdatableRequestResource):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"tags"})
+    non_nullable_fields: ClassVar[frozenset[str]] = frozenset({"is_public", "query", "destination"})
+    query: str | None = None
+    conflict_mode: str | None = None
+    destination: Destination | None = None
+    source_nonce: NonceCredentials | None = None
+    destination_nonce: NonceCredentials | None = None
+    is_public: bool | None = None
+
+
+class TransformationResponse(Transformation, ResponseResource[TransformationRequest]):
+    id: int
+    created_time: int
+    last_updated_time: int
+    query: str
+    is_public: bool
+    conflict_mode: str
+    destination: Destination
+    blocked: BlockedInfo | None = None
+    owner: str
+    owner_is_current_user: bool
+    has_source_oidc_credentials: bool
+    has_destination_oidc_credentials: bool
+    source_session: SessionInfo | None = None
+    destination_session: SessionInfo | None = None
+    last_finished_job: dict[str, JsonValue] | None = None
+    running_job: dict[str, JsonValue] | None = None
+    schedule: dict[str, JsonValue] | None = None
+
+    def as_request_resource(self) -> TransformationRequest:
+        return TransformationRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/workflow.py

@@ -0,0 +1,27 @@
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .identifiers import ExternalId
+
+
+class Workflow(BaseModelObject):
+    external_id: str
+    description: str | None = None
+    data_set_id: int | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class WorkflowRequest(Workflow, RequestResource): ...
+
+
+class WorkflowResponse(Workflow, ResponseResource[WorkflowRequest]):
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> WorkflowRequest:
+        return WorkflowRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/resource_classes/workflow_trigger.py

@@ -0,0 +1,63 @@
+from typing import Annotated, Literal
+
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.client._resource_base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .identifiers import ExternalId
+
+
+class TriggerRuleDefinition(BaseModelObject):
+    trigger_type: str
+
+
+class ScheduleTriggerRule(BaseModelObject):
+    trigger_type: Literal["schedule"] = "schedule"
+    cron_expression: str
+    timezone: str | None = None
+
+
+class DataModelingTriggerRule(BaseModelObject):
+    trigger_type: Literal["dataModeling"] = "dataModeling"
+    data_modeling_query: JsonValue
+    batch_size: int
+    batch_timeout: int
+
+
+TriggerRule = Annotated[
+    ScheduleTriggerRule | DataModelingTriggerRule,
+    Field(discriminator="trigger_type"),
+]
+
+
+class NonceCredentials(BaseModelObject):
+    nonce: str
+
+
+class WorkflowTrigger(BaseModelObject):
+    external_id: str
+    trigger_rule: TriggerRule
+    workflow_external_id: str
+    workflow_version: str
+    input: JsonValue | None = None
+    metadata: dict[str, str] | None = None
+
+    def as_id(self) -> ExternalId:
+        return ExternalId(external_id=self.external_id)
+
+
+class WorkflowTriggerRequest(WorkflowTrigger, RequestResource):
+    authentication: NonceCredentials
+
+
+class WorkflowTriggerResponse(WorkflowTrigger, ResponseResource[WorkflowTriggerRequest]):
+    created_time: int
+    last_updated_time: int
+    is_paused: bool
+
+    def as_request_resource(self) -> WorkflowTriggerRequest:
+        return WorkflowTriggerRequest.model_validate(self.dump(), extra="ignore")