cognite-toolkit 0.7.43__py3-none-any.whl → 0.7.45__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/data_classes/sequence.py

@@ -0,0 +1,45 @@
+from typing import ClassVar, Literal
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestUpdateable,
+    ResponseResource,
+)
+
+from .identifiers import ExternalId
+
+
+class SequenceColumn(BaseModelObject):
+    external_id: str
+    name: str | None = None
+    description: str | None = None
+    metadata: dict[str, str] | None = None
+    value_type: Literal["STRING", "DOUBLE", "LONG"] | None = None
+
+
+class Sequence(BaseModelObject):
+    external_id: str | None = None
+    name: str | None = None
+    description: str | None = None
+    asset_id: int | None = None
+    data_set_id: int | None = None
+    metadata: dict[str, str] | None = None
+    columns: list[SequenceColumn]
+
+    def as_id(self) -> ExternalId:
+        if self.external_id is None:
+            raise ValueError("Cannot convert Sequence to ExternalId when external_id is None")
+        return ExternalId(external_id=self.external_id)
+
+
+class SequenceRequest(Sequence, RequestUpdateable):
+    container_fields: ClassVar[frozenset[str]] = frozenset({"metadata", "columns"})
+
+
+class SequenceResponse(Sequence, ResponseResource[SequenceRequest]):
+    id: int
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> SequenceRequest:
+        return SequenceRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/data_classes/transformation.py

@@ -0,0 +1,140 @@
+from typing import Annotated, ClassVar, Literal
+
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestUpdateable,
+    ResponseResource,
+)
+
+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, RequestUpdateable):
+    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/data_classes/workflow.py

@@ -0,0 +1,27 @@
+from cognite_toolkit._cdf_tk.client.data_classes.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/data_classes/workflow_trigger.py

@@ -0,0 +1,63 @@
+from typing import Annotated, Literal
+
+from pydantic import Field, JsonValue
+
+from cognite_toolkit._cdf_tk.client.data_classes.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")

cognite_toolkit/_cdf_tk/client/data_classes/workflow_version.py

@@ -0,0 +1,155 @@
+from typing import Annotated, Any, Literal
+
+from pydantic import Field, JsonValue, field_validator
+from pydantic_core.core_schema import ValidationInfo
+
+from cognite_toolkit._cdf_tk.client.data_classes.base import (
+    BaseModelObject,
+    RequestResource,
+    ResponseResource,
+)
+
+from .identifiers import Identifier, WorkflowVersionId
+
+
+class TaskId(Identifier):
+    external_id: str
+
+    def __str__(self) -> str:
+        return f"externalId='{self.external_id}'"
+
+
+class TaskParameterDefinition(BaseModelObject):
+    type: str
+
+
+class CogniteFunctionRef(BaseModelObject):
+    external_id: str
+    data: JsonValue | str | None = None
+
+
+class FunctionTaskParameters(TaskParameterDefinition):
+    type: Literal["function"] = Field("function", exclude=True)
+    function: CogniteFunctionRef
+    is_async_complete: bool | None = None
+
+
+class TransformationRef(BaseModelObject):
+    external_id: str
+    concurrency_policy: Literal["fail", "waitForCurrent", "restartAfterCurrent"] | None = None
+    use_transformation_credentials: bool | None = None
+
+
+class TransformationTaskParameters(TaskParameterDefinition):
+    type: Literal["transformation"] = Field("transformation", exclude=True)
+    transformation: TransformationRef
+
+
+class CDFRequest(BaseModelObject):
+    resource_path: str
+    method: str
+    query_parameters: JsonValue | str | None = None
+    body: JsonValue | str | None = None
+    request_timeout_in_millis: float | str | None = None
+    cdf_version_header: str | None = None
+
+
+class CDFTaskParameters(TaskParameterDefinition):
+    type: Literal["cdf"] = Field("cdf", exclude=True)
+    cdf_request: CDFRequest
+
+
+class DynamicRef(BaseModelObject):
+    tasks: str
+
+
+class DynamicTaskParameters(TaskParameterDefinition):
+    type: Literal["dynamic"] = Field("dynamic", exclude=True)
+    dynamic: DynamicRef
+
+
+class SubworkflowRef(BaseModelObject):
+    tasks: "list[Task]"
+
+
+class SubworkflowTaskParameters(TaskParameterDefinition):
+    type: Literal["subworkflow"] = Field("subworkflow", exclude=True)
+    subworkflow: WorkflowVersionId | SubworkflowRef
+
+
+class SimulatorInputUnit(BaseModelObject):
+    name: str
+
+
+class SimulatorInput(BaseModelObject):
+    reference_id: str
+    value: str | int | float | list[str] | list[int] | list[float]
+    unit: SimulatorInputUnit | None = None
+
+
+class SimulationRef(BaseModelObject):
+    routine_external_id: str
+    run_time: int | None = None
+    inputs: list[SimulatorInput] | None = None
+
+
+class SimulationTaskParameters(TaskParameterDefinition):
+    type: Literal["simulation"] = Field("simulation", exclude=True)
+    simulation: SimulationRef
+
+
+Parameter = Annotated[
+    FunctionTaskParameters
+    | TransformationTaskParameters
+    | CDFTaskParameters
+    | DynamicTaskParameters
+    | SubworkflowTaskParameters
+    | SimulationTaskParameters,
+    Field(discriminator="type"),
+]
+
+
+class Task(BaseModelObject):
+    external_id: str
+    type: str
+    name: str | None = None
+    description: str | None = None
+    retries: int | None = None
+    timeout: int | None = None
+    on_failure: Literal["abortWorkflow", "skipTask"] = "abortWorkflow"
+    depends_on: list[TaskId] | None = None
+    parameters: Parameter | None = None
+
+    @field_validator("parameters", mode="before")
+    @classmethod
+    def move_type_to_field(cls, value: Any, info: ValidationInfo) -> Any:
+        if not isinstance(value, dict) or "type" not in info.data:
+            return value
+        value = dict(value)
+        value["type"] = info.data["type"]
+        return value
+
+
+class WorkflowDefinition(BaseModelObject):
+    description: str | None = None
+    tasks: list[Task]
+
+
+class WorkflowVersion(BaseModelObject):
+    workflow_external_id: str
+    version: str
+    workflow_definition: WorkflowDefinition
+
+    def as_id(self) -> WorkflowVersionId:
+        return WorkflowVersionId(workflow_external_id=self.workflow_external_id, version=self.version)
+
+
+class WorkflowVersionRequest(WorkflowVersion, RequestResource): ...
+
+
+class WorkflowVersionResponse(WorkflowVersion, ResponseResource[WorkflowVersionRequest]):
+    created_time: int
+    last_updated_time: int
+
+    def as_request_resource(self) -> WorkflowVersionRequest:
+        return WorkflowVersionRequest.model_validate(self.dump(), extra="ignore")

cognite_toolkit/_cdf_tk/client/testing.py

@@ -7,12 +7,14 @@ from cognite.client._api.datapoints import DatapointsAPI
 from cognite.client._api.datapoints_subscriptions import DatapointsSubscriptionAPI
 from cognite.client._api.functions import FunctionCallsAPI, FunctionSchedulesAPI
 from cognite.client._api.raw import RawDatabasesAPI, RawRowsAPI, RawTablesAPI
+from cognite.client._api.simulators import SimulatorModelsAPI, SimulatorsAPI
 from cognite.client._api.synthetic_time_series import SyntheticDatapointsAPI
 from cognite.client.testing import CogniteClientMock
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client._toolkit_client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.api.assets import AssetsAPI
+from cognite_toolkit._cdf_tk.client.api.filemetadata import FileMetadataAPI
 from cognite_toolkit._cdf_tk.client.api.legacy.canvas import CanvasAPI, IndustrialCanvasAPI
 from cognite_toolkit._cdf_tk.client.api.legacy.charts import ChartsAPI
 from cognite_toolkit._cdf_tk.client.api.legacy.dml import DMLAPI
@@ -143,7 +145,10 @@ class ToolkitClientMock(CogniteClientMock):
         self.tool.three_d.models = MagicMock(spec_set=ThreeDModelAPI)
         self.tool.assets = MagicMock(spec_set=AssetsAPI)
         self.tool.timeseries = MagicMock(spec_set=TimeSeriesAPI)
+        self.tool.filemetadata = MagicMock(spec_set=FileMetadataAPI)
         self.tool.events = MagicMock(spec_set=EventsAPI)
+        self.tool.simulators = MagicMock(spec=SimulatorsAPI)
+        self.tool.simulators.models = MagicMock(spec_set=SimulatorModelsAPI)
 
         self.streams = MagicMock(spec=StreamsAPI)
 

cognite_toolkit/_cdf_tk/commands/_migrate/conversion.py

@@ -1,7 +1,7 @@
 from collections.abc import Iterable, Mapping, Set
 from typing import Any, ClassVar, cast
 
-from cognite.client.data_classes import Annotation, FileMetadata
+from cognite.client.data_classes import Annotation
 from cognite.client.data_classes.data_modeling import (
     DirectRelation,
     DirectRelationReference,
@@ -18,6 +18,7 @@ from cognite.client.utils._identifier import InstanceId
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.asset import AssetResponse
 from cognite_toolkit._cdf_tk.client.data_classes.event import EventResponse
+from cognite_toolkit._cdf_tk.client.data_classes.filemetadata import FileMetadataResponse
 from cognite_toolkit._cdf_tk.client.data_classes.legacy.migration import (
     AssetCentricId,
     ResourceViewMappingApply,
@@ -117,7 +118,7 @@ class DirectRelationCache:
                     source_ids.add(resource.source)
                 if resource.parent_id is not None:
                     asset_ids.add(resource.parent_id)
-            elif isinstance(resource, FileMetadata):
+            elif isinstance(resource, FileMetadataResponse):
                 if resource.source:
                     source_ids.add(resource.source)
                 if resource.asset_ids:
@@ -248,7 +249,7 @@ def asset_centric_to_dm(
 def _lookup_resource_type(resource_type: AssetCentricResourceExtended) -> AssetCentricTypeExtended:
     if isinstance(resource_type, AssetResponse):
         return "asset"
-    elif isinstance(resource_type, FileMetadata):
+    elif isinstance(resource_type, FileMetadataResponse):
         return "file"
     elif isinstance(resource_type, EventResponse):
         return "event"

cognite_toolkit/_cdf_tk/cruds/__init__.py

@@ -60,6 +60,7 @@ from ._resource_cruds import (
     SecurityCategoryCRUD,
     SequenceCRUD,
     SequenceRowCRUD,
+    SimulatorModelCRUD,
     SpaceCRUD,
     StreamCRUD,
     StreamlitCRUD,
@@ -86,7 +87,8 @@ if not FeatureFlag.is_enabled(Flags.MIGRATE):
     _EXCLUDED_CRUDS.add(ResourceViewMappingCRUD)
 if not FeatureFlag.is_enabled(Flags.STREAMS):
     _EXCLUDED_CRUDS.add(StreamCRUD)
-
+if not FeatureFlag.is_enabled(Flags.SIMULATORS):
+    _EXCLUDED_CRUDS.add(SimulatorModelCRUD)
 
 CRUDS_BY_FOLDER_NAME: dict[str, list[type[Loader]]] = {}
 for _loader in itertools.chain(
@@ -142,6 +144,7 @@ ResourceTypes: TypeAlias = Literal[
     "functions",
     "raw",
     "robotics",
+    "simulators",
     "streams",
     "streamlit",
     "workflows",
@@ -209,6 +212,7 @@ __all__ = [
     "SecurityCategoryCRUD",
     "SequenceCRUD",
     "SequenceRowCRUD",
+    "SimulatorModelCRUD",
     "SpaceCRUD",
     "StreamlitCRUD",
     "ThreeDModelCRUD",

cognite_toolkit/_cdf_tk/cruds/_data_cruds.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING, cast, final
 import pandas as pd
 from cognite.client.data_classes import FileMetadataWrite
 
+from cognite_toolkit._cdf_tk.client.data_classes.identifiers import ExternalId
 from cognite_toolkit._cdf_tk.client.data_classes.legacy.extendable_cognite_file import ExtendableCogniteFileApply
 from cognite_toolkit._cdf_tk.client.data_classes.legacy.raw import RawTable
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
@@ -119,11 +120,14 @@ class FileCRUD(DataCRUD):
                 if not datafile.exists():
                     continue
 
+                identifier = resource.identifier
+                if isinstance(identifier, ExternalId):
+                    identifier = identifier.external_id
                 if dry_run:
-                    yield f" Would upload file '{datafile!s}' to file with {id_name}={resource.identifier!r}", 1
+                    yield f" Would upload file '{datafile!s}' to file with {id_name}={identifier!r}", 1
                 else:
-                    self.client.files.upload_content(path=str(datafile), **{id_name: resource.identifier})
-                    yield f" Uploaded file '{datafile!s}' to file with {id_name}={resource.identifier!r}", 1
+                    self.client.files.upload_content(path=str(datafile), **{id_name: identifier})
+                    yield f" Uploaded file '{datafile!s}' to file with {id_name}={identifier!r}", 1
 
     @staticmethod
     def _read_metadata(

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/__init__.py

@@ -35,6 +35,7 @@ from .robotics import (
     RoboticMapCRUD,
     RoboticsDataPostProcessingCRUD,
 )
+from .simulators import SimulatorModelCRUD
 from .streams import StreamCRUD
 from .three_d_model import ThreeDModelCRUD
 from .timeseries import DatapointSubscriptionCRUD, TimeSeriesCRUD
@@ -83,6 +84,7 @@ __all__ = [
     "SecurityCategoryCRUD",
     "SequenceCRUD",
     "SequenceRowCRUD",
+    "SimulatorModelCRUD",
     "SpaceCRUD",
     "StreamCRUD",
     "StreamlitCRUD",