cognite-toolkit 0.7.26__tar.gz → 0.7.28__tar.gz

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.26
+Version: 0.7.28
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Author: Cognite AS
 Author-email: Cognite AS <support@cognite.com>

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/cognite_toolkit/_cdf_tk/apps/_migrate_app.py

@@ -8,17 +8,14 @@ from cognite.client.data_classes import Annotation
 from cognite.client.data_classes.data_modeling import ContainerId
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.commands import (
-    MigrationCanvasCommand,
-    MigrationPrepareCommand,
-)
+from cognite_toolkit._cdf_tk.commands import MigrationPrepareCommand
 from cognite_toolkit._cdf_tk.commands._migrate import MigrationCommand
 from cognite_toolkit._cdf_tk.commands._migrate.creators import (
     InfieldV2ConfigCreator,
     InstanceSpaceCreator,
     SourceSystemCreator,
 )
-from cognite_toolkit._cdf_tk.commands._migrate.data_mapper import AssetCentricMapper, ChartMapper
+from cognite_toolkit._cdf_tk.commands._migrate.data_mapper import AssetCentricMapper, CanvasMapper, ChartMapper
 from cognite_toolkit._cdf_tk.commands._migrate.migration_io import (
     AnnotationMigrationIO,
     AssetCentricMigrationIO,
@@ -28,14 +25,15 @@ from cognite_toolkit._cdf_tk.commands._migrate.selectors import (
     MigrateDataSetSelector,
     MigrationCSVFileSelector,
 )
-from cognite_toolkit._cdf_tk.storageio import ChartIO
-from cognite_toolkit._cdf_tk.storageio.selectors import ChartExternalIdSelector
+from cognite_toolkit._cdf_tk.storageio import CanvasIO, ChartIO
+from cognite_toolkit._cdf_tk.storageio.selectors import CanvasExternalIdSelector, ChartExternalIdSelector
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 from cognite_toolkit._cdf_tk.utils.cli_args import parse_view_str
 from cognite_toolkit._cdf_tk.utils.interactive_select import (
     AssetInteractiveSelect,
     DataModelingSelect,
     FileMetadataInteractiveSelect,
+    InteractiveCanvasSelect,
     InteractiveChartSelect,
     ResourceViewMappingInteractiveSelect,
 )
@@ -855,6 +853,23 @@ class MigrateApp(typer.Typer):
                 "performed to select the Canvas to migrate."
             ),
         ] = None,
+        skip_on_missing_ref: Annotated[
+            bool,
+            typer.Option(
+                "--skip-on-missing-ref",
+                "-s",
+                help="If set, the migration will skip Canvases that reference resources that have not been migrated to data modeling. "
+                "If not set, the migration will continue but the result will exclude the missing references.",
+            ),
+        ] = False,
+        log_dir: Annotated[
+            Path,
+            typer.Option(
+                "--log-dir",
+                "-l",
+                help="Path to the directory where migration logs will be stored.",
+            ),
+        ] = Path(f"migration_logs_{TODAY}"),
         dry_run: Annotated[
             bool,
             typer.Option(
@@ -880,12 +895,24 @@ class MigrateApp(typer.Typer):
         is populated with the mapping from Asset-Centric resources to the new data modeling resources.
         """
         client = EnvironmentVariables.create_from_environment().get_client()
+        if external_id is None:
+            interactive = InteractiveCanvasSelect(client)
+            external_id = interactive.select_external_ids()
+            log_dir = questionary.path("Specify log directory for migration logs:", default=str(log_dir)).ask()
+            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).ask()
+            verbose = questionary.confirm("Do you want verbose output?", default=verbose).ask()
+            if any(res is None for res in [log_dir, dry_run, verbose]):
+                raise typer.Abort()
+            log_dir = Path(log_dir)
 
-        cmd = MigrationCanvasCommand()
+        cmd = MigrationCommand()
+        selector = CanvasExternalIdSelector(external_ids=tuple(external_id))
         cmd.run(
-            lambda: cmd.migrate_canvas(
-                client,
-                external_ids=external_id,
+            lambda: cmd.migrate(
+                selected=selector,
+                data=CanvasIO(client, exclude_existing_version=True),
+                mapper=CanvasMapper(client, dry_run=dry_run, skip_on_missing_ref=skip_on_missing_ref),
+                log_dir=log_dir,
                 dry_run=dry_run,
                 verbose=verbose,
             )

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/cognite_toolkit/_cdf_tk/client/data_classes/charts.py

@@ -36,7 +36,7 @@ class ChartCore(WriteableCogniteResource["ChartWrite"], ABC):
     def dump(self, camel_case: bool = True) -> dict[str, Any]:
         """Convert the chart to a dictionary representation."""
         output = super().dump(camel_case=camel_case)
-        output["data"] = self.data.dump(camel_case=camel_case)
+        output["data"] = self.data.model_dump(mode="json", by_alias=camel_case, exclude_unset=True)
         return output
 
 
@@ -58,7 +58,7 @@ class ChartWrite(ChartCore):
         return cls(
             external_id=resource["externalId"],
             visibility=resource["visibility"],
-            data=ChartData._load(resource["data"], cognite_client=cognite_client),
+            data=ChartData._load(resource["data"]),
         )
 
 
@@ -98,7 +98,7 @@ class Chart(ChartCore):
             created_time=resource["createdTime"],
             last_updated_time=resource["lastUpdatedTime"],
             visibility=resource["visibility"],
-            data=ChartData._load(resource["data"], cognite_client=cognite_client),
+            data=ChartData._load(resource["data"]),
             owner_id=resource["ownerId"],
         )
 

cognite_toolkit-0.7.28/cognite_toolkit/_cdf_tk/client/data_classes/charts_data.py

@@ -0,0 +1,184 @@
+from typing import Any
+
+from cognite.client.data_classes.data_modeling import NodeId, ViewId
+from pydantic import JsonValue, field_serializer, field_validator
+
+from .base import BaseModelObject
+
+
+class UserInfo(BaseModelObject):
+    id: str | None = None
+    email: str | None = None
+    display_name: str | None = None
+
+
+class ChartSettings(BaseModelObject):
+    show_y_axis: bool = True
+    show_min_max: bool = True
+    show_gridlines: bool = True
+    merge_units: bool = False
+
+
+class ThresholdFilter(BaseModelObject):
+    min_unit: str | None = None
+    max_unit: str | None = None
+
+
+class ChartCall(BaseModelObject):
+    id: str | None = None
+    hash: int | None = None
+    call_id: str | None = None
+    call_date: int | None = None
+    status: str | None = None
+
+
+class SubSetting(BaseModelObject):
+    auto_align: bool | None = None
+
+
+class ChartPosition(BaseModelObject):
+    x: float | None = None
+    y: float | None = None
+
+
+class FlowElement(BaseModelObject):
+    id: str | None = None
+    type: str | 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
+
+
+class Flow(BaseModelObject):
+    zoom: float | None = None
+    elements: list[FlowElement] | None = None
+    position: tuple[float | None, float | None] | None = None
+
+
+class ChartElement(BaseModelObject):
+    id: str | None = None
+    type: str | None = None
+
+
+class ChartSource(ChartElement): ...
+
+
+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
+    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
+
+    @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
+
+    @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)
+
+
+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
+
+
+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
+
+
+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
+
+
+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
+
+
+class ChartData(BaseModelObject):
+    version: int | None = None
+    name: str | None = None
+    date_from: str | None = None
+    date_to: str | None = None
+    user_info: UserInfo | None = None
+    live_mode: bool | None = None
+    time_series_collection: list[ChartTimeseries] | None = None
+    core_timeseries_collection: list[ChartCoreTimeseries] | None = None
+    workflow_collection: list[ChartWorkflow] | None = None
+    source_collection: list[ChartSource] | None = None
+    threshold_collection: list[ChartThreshold] | None = None
+    scheduled_calculation_collection: list[ChartScheduledCalculation] | None = None
+    settings: ChartSettings | None = None

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/cognite_toolkit/_cdf_tk/commands/__init__.py

@@ -1,6 +1,6 @@
 from ._download import DownloadCommand
 from ._migrate import (
-    MigrationCanvasCommand,
+    MigrationCommand,
     MigrationPrepareCommand,
 )
 from ._profile import ProfileAssetCentricCommand, ProfileAssetCommand, ProfileRawCommand, ProfileTransformationCommand
@@ -30,7 +30,7 @@ __all__ = [
     "DownloadCommand",
     "DumpResourceCommand",
     "InitCommand",
-    "MigrationCanvasCommand",
+    "MigrationCommand",
     "MigrationPrepareCommand",
     "ModulesCommand",
     "ProfileAssetCentricCommand",

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/cognite_toolkit/_cdf_tk/commands/_migrate/__init__.py

@@ -1,9 +1,7 @@
-from .canvas import MigrationCanvasCommand
 from .command import MigrationCommand
 from .prepare import MigrationPrepareCommand
 
 __all__ = [
-    "MigrationCanvasCommand",
     "MigrationCommand",
     "MigrationPrepareCommand",
 ]

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/cognite_toolkit/_cdf_tk/commands/_migrate/data_mapper.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
-from collections.abc import Sequence
+from collections import defaultdict
+from collections.abc import Callable, Sequence
 from typing import Generic, cast
 from uuid import uuid4
 
@@ -11,8 +12,15 @@ from cognite.client.data_classes.data_modeling import (
     View,
     ViewId,
 )
+from cognite.client.exceptions import CogniteException
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.data_classes.canvas import (
+    ContainerReferenceApply,
+    FdmInstanceContainerReferenceApply,
+    IndustrialCanvas,
+    IndustrialCanvasApply,
+)
 from cognite_toolkit._cdf_tk.client.data_classes.charts import Chart, ChartWrite
 from cognite_toolkit._cdf_tk.client.data_classes.charts_data import (
     ChartCoreTimeseries,
@@ -23,13 +31,18 @@ from cognite_toolkit._cdf_tk.client.data_classes.migration import ResourceViewMa
 from cognite_toolkit._cdf_tk.commands._migrate.conversion import DirectRelationCache, asset_centric_to_dm
 from cognite_toolkit._cdf_tk.commands._migrate.data_classes import AssetCentricMapping
 from cognite_toolkit._cdf_tk.commands._migrate.default_mappings import create_default_mappings
-from cognite_toolkit._cdf_tk.commands._migrate.issues import ChartMigrationIssue, ConversionIssue, MigrationIssue
+from cognite_toolkit._cdf_tk.commands._migrate.issues import (
+    CanvasMigrationIssue,
+    ChartMigrationIssue,
+    ConversionIssue,
+    MigrationIssue,
+)
 from cognite_toolkit._cdf_tk.commands._migrate.selectors import AssetCentricMigrationSelector
 from cognite_toolkit._cdf_tk.constants import MISSING_INSTANCE_SPACE
-from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
+from cognite_toolkit._cdf_tk.exceptions import ToolkitMigrationError, ToolkitValueError
 from cognite_toolkit._cdf_tk.protocols import T_ResourceRequest, T_ResourceResponse
 from cognite_toolkit._cdf_tk.storageio._base import T_Selector
-from cognite_toolkit._cdf_tk.storageio.selectors import ChartSelector
+from cognite_toolkit._cdf_tk.storageio.selectors import CanvasSelector, ChartSelector
 from cognite_toolkit._cdf_tk.utils import humanize_collection
 from cognite_toolkit._cdf_tk.utils.useful_types import (
     T_AssetCentricResourceExtended,
@@ -197,16 +210,14 @@ class ChartMapper(DataMapper[ChartSelector, Chart, ChartWrite]):
     def _create_new_timeseries_core(
         self, ts_item: ChartTimeseries, node_id: NodeId, consumer_view_id: ViewId | None
     ) -> ChartCoreTimeseries:
-        dumped = ts_item.dump(camel_case=True)
-        for asset_centric_key in ["tsId", "tsExternalId", "originalUnit"]:
-            dumped.pop(asset_centric_key, None)
-
+        dumped = ts_item.model_dump(mode="json", by_alias=True, exclude_unset=True)
         dumped["nodeReference"] = node_id
         dumped["viewReference"] = consumer_view_id
         new_uuid = str(uuid4())
         dumped["id"] = new_uuid
         dumped["type"] = "coreTimeseries"
-        core_timeseries = ChartCoreTimeseries._load(dumped)
+        # We ignore extra here to only include the fields that are shared between ChartTimeseries and ChartCoreTimeseries
+        core_timeseries = ChartCoreTimeseries.model_validate(dumped, extra="ignore")
         return core_timeseries
 
     def _get_node_id_consumer_view_id(self, ts_item: ChartTimeseries) -> tuple[NodeId | None, ViewId | None]:
@@ -245,3 +256,130 @@ class ChartMapper(DataMapper[ChartSelector, Chart, ChartWrite]):
             new_source_item = ChartSource(id=cast(str, core_ts_item.id), type=cast(str, core_ts_item.type))
             updated_source_collection.append(new_source_item)
         return updated_source_collection
+
+
+class CanvasMapper(DataMapper[CanvasSelector, IndustrialCanvas, IndustrialCanvasApply]):
+    # Note sequences are not supported in Canvas, so we do not include them here.
+    asset_centric_resource_types = tuple(("asset", "event", "timeseries", "file"))
+    DEFAULT_ASSET_VIEW = ViewId("cdf_cdm", "CogniteAsset", "v1")
+    DEFAULT_EVENT_VIEW = ViewId("cdf_cdm", "CogniteActivity", "v1")
+    DEFAULT_FILE_VIEW = ViewId("cdf_cdm", "CogniteFile", "v1")
+    DEFAULT_TIMESERIES_VIEW = ViewId("cdf_cdm", "CogniteTimeSeries", "v1")
+
+    def __init__(self, client: ToolkitClient, dry_run: bool, skip_on_missing_ref: bool = False) -> None:
+        self.client = client
+        self.dry_run = dry_run
+        self.skip_on_missing_ref = skip_on_missing_ref
+
+    def map(self, source: Sequence[IndustrialCanvas]) -> Sequence[tuple[IndustrialCanvasApply | None, MigrationIssue]]:
+        self._populate_cache(source)
+        output: list[tuple[IndustrialCanvasApply | None, MigrationIssue]] = []
+        for item in source:
+            mapped_item, issue = self._map_single_item(item)
+            output.append((mapped_item, issue))
+        return output
+
+    @property
+    def lookup_methods(self) -> dict[str, Callable]:
+        return {
+            "asset": self.client.migration.lookup.assets,
+            "event": self.client.migration.lookup.events,
+            "timeseries": self.client.migration.lookup.time_series,
+            "file": self.client.migration.lookup.files,
+        }
+
+    def _populate_cache(self, source: Sequence[IndustrialCanvas]) -> None:
+        """Populate the internal cache with references from the source canvases.
+
+        Note that the consumption views are also cached as part of the timeseries lookup.
+        """
+        ids_by_type: dict[str, set[int]] = defaultdict(set)
+        for canvas in source:
+            for ref in canvas.container_references or []:
+                if ref.container_reference_type in self.asset_centric_resource_types:
+                    ids_by_type[ref.container_reference_type].add(ref.resource_id)
+
+        for resource_type, lookup_method in self.lookup_methods.items():
+            ids = ids_by_type.get(resource_type)
+            if ids:
+                lookup_method(list(ids))
+
+    def _get_node_id(self, resource_id: int, resource_type: str) -> NodeId | None:
+        """Look up the node ID for a given resource ID and type."""
+        try:
+            return self.lookup_methods[resource_type](resource_id)
+        except KeyError:
+            raise ToolkitValueError(f"Unsupported resource type '{resource_type}' for container reference migration.")
+
+    def _get_consumer_view_id(self, resource_id: int, resource_type: str) -> ViewId:
+        """Look up the consumer view ID for a given resource ID and type."""
+        lookup_map = {
+            "asset": (self.client.migration.lookup.assets.consumer_view, self.DEFAULT_ASSET_VIEW),
+            "event": (self.client.migration.lookup.events.consumer_view, self.DEFAULT_EVENT_VIEW),
+            "timeseries": (self.client.migration.lookup.time_series.consumer_view, self.DEFAULT_TIMESERIES_VIEW),
+            "file": (self.client.migration.lookup.files.consumer_view, self.DEFAULT_FILE_VIEW),
+        }
+        if lookup_tuple := lookup_map.get(resource_type):
+            method, fallback = lookup_tuple
+            return method(resource_id) or fallback
+
+        raise ToolkitValueError(f"Unsupported resource type '{resource_type}' for container reference migration.")
+
+    def _map_single_item(self, canvas: IndustrialCanvas) -> tuple[IndustrialCanvasApply | None, CanvasMigrationIssue]:
+        update = canvas.as_write()
+        issue = CanvasMigrationIssue(canvas_external_id=canvas.canvas.external_id, canvas_name=canvas.canvas.name)
+
+        remaining_container_references: list[ContainerReferenceApply] = []
+        new_fdm_references: list[FdmInstanceContainerReferenceApply] = []
+        for ref in update.container_references or []:
+            if ref.container_reference_type not in self.asset_centric_resource_types:
+                remaining_container_references.append(ref)
+                continue
+            node_id = self._get_node_id(ref.resource_id, ref.container_reference_type)
+            if node_id is None:
+                issue.missing_reference_ids.append(ref.as_asset_centric_id())
+            else:
+                consumer_view = self._get_consumer_view_id(ref.resource_id, ref.container_reference_type)
+                fdm_ref = self.migrate_container_reference(ref, canvas.canvas.external_id, node_id, consumer_view)
+                new_fdm_references.append(fdm_ref)
+        if issue.missing_reference_ids and self.skip_on_missing_ref:
+            return None, issue
+
+        update.container_references = remaining_container_references
+        update.fdm_instance_container_references.extend(new_fdm_references)
+        if not self.dry_run:
+            backup = canvas.as_write().create_backup()
+            try:
+                self.client.canvas.industrial.create(backup)
+            except CogniteException as e:
+                raise ToolkitMigrationError(
+                    f"Failed to create backup for canvas '{canvas.canvas.name}': {e!s}. "
+                ) from e
+
+        return update, issue
+
+    @classmethod
+    def migrate_container_reference(
+        cls, reference: ContainerReferenceApply, canvas_external_id: str, instance_id: NodeId, consumer_view: ViewId
+    ) -> FdmInstanceContainerReferenceApply:
+        """Migrate a single container reference by replacing the asset-centric ID with the data model instance ID."""
+        new_id = str(uuid4())
+        new_external_id = f"{canvas_external_id}_{new_id}"
+        return FdmInstanceContainerReferenceApply(
+            external_id=new_external_id,
+            id_=new_id,
+            container_reference_type="fdmInstance",
+            instance_space=instance_id.space,
+            instance_external_id=instance_id.external_id,
+            view_space=consumer_view.space,
+            view_external_id=consumer_view.external_id,
+            view_version=consumer_view.version,
+            label=reference.label,
+            properties_=reference.properties_,
+            x=reference.x,
+            y=reference.y,
+            width=reference.width,
+            height=reference.height,
+            max_width=reference.max_width,
+            max_height=reference.max_height,
+        )

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/cognite_toolkit/_cdf_tk/commands/_migrate/issues.py

@@ -51,6 +51,18 @@ class ChartMigrationIssue(MigrationIssue):
         )
 
 
+class CanvasMigrationIssue(MigrationIssue):
+    type: ClassVar[str] = "canvasMigration"
+    canvas_external_id: str
+    canvas_name: str
+    missing_reference_ids: list[AssetCentricId] = Field(default_factory=list)
+
+    @property
+    def has_issues(self) -> bool:
+        """Check if there are any issues recorded in this CanvasMigrationIssue."""
+        return bool(self.missing_reference_ids)
+
+
 class ReadIssue(MigrationIssue):
     """Represents a read issue encountered during migration."""
 

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/cognite_toolkit/_cdf_tk/storageio/_applications.py

@@ -1,6 +1,7 @@
 from collections.abc import Iterable, Sequence
 from typing import Any
 
+from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.canvas import (
     IndustrialCanvas,
     IndustrialCanvasApply,
@@ -127,6 +128,15 @@ class ChartIO(UploadableStorageIO[ChartSelector, Chart, ChartWrite]):
 
 
 class CanvasIO(UploadableStorageIO[CanvasSelector, IndustrialCanvas, IndustrialCanvasApply]):
+    """Download and upload Industrial Canvases to/from CDF.
+
+    Args:
+        client (ToolkitClient): The Cognite Toolkit client to use for API interactions.
+        exclude_existing_version (bool): Whether to exclude the 'existingVersion' field when uploading canvases.
+            Defaults to True. If you set this to False, the upload may fail if the existing version in CDF is
+            lower or equal to the one in the uploaded data.
+    """
+
     KIND = "IndustrialCanvas"
     SUPPORTED_DOWNLOAD_FORMATS = frozenset({".ndjson"})
     SUPPORTED_COMPRESSIONS = frozenset({".gz"})
@@ -134,6 +144,10 @@ class CanvasIO(UploadableStorageIO[CanvasSelector, IndustrialCanvas, IndustrialC
     CHUNK_SIZE = 10
     BASE_SELECTOR = CanvasSelector
 
+    def __init__(self, client: ToolkitClient, exclude_existing_version: bool = True) -> None:
+        super().__init__(client)
+        self.exclude_existing_version = exclude_existing_version
+
     def as_id(self, item: IndustrialCanvas) -> str:
         return item.as_id()
 
@@ -171,12 +185,19 @@ class CanvasIO(UploadableStorageIO[CanvasSelector, IndustrialCanvas, IndustrialC
         results: list[HTTPMessage] = []
         for item in data_chunk:
             instances = item.item.as_instances()
+            items: list[dict[str, JsonVal]] = []
+            for instance in instances:
+                dumped = instance.dump()
+                if self.exclude_existing_version:
+                    dumped.pop("existingVersion", None)
+                items.append(dumped)
+
             responses = http_client.request_with_retries(
                 message=SimpleBodyRequest(
                     endpoint_url=config.create_api_url("/models/instances"),
                     method="POST",
                     # MyPy does not understand that .dump is valid json
-                    body_content={"items": [instance.dump() for instance in instances]},
+                    body_content={"items": items},  # type: ignore[dict-item]
                 )
             )
             results.extend(responses.as_item_responses(item.source_id))

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

@@ -12,7 +12,7 @@ jobs:
     environment: dev
     name: Deploy
     container:
-      image: cognite/toolkit:0.7.26
+      image: cognite/toolkit:0.7.28
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml

@@ -10,7 +10,7 @@ jobs:
     environment: dev
     name: Deploy Dry Run
     container:
-      image: cognite/toolkit:0.7.26
+      image: cognite/toolkit:0.7.28
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/cognite_toolkit/_resources/cdf.toml

@@ -4,7 +4,7 @@ default_env = "<DEFAULT_ENV_PLACEHOLDER>"
 [modules]
 # This is the version of the modules. It should not be changed manually.
 # It will be updated by the 'cdf modules upgrade' command.
-version = "0.7.26"
+version = "0.7.28"
 
 
 [plugins]

cognite_toolkit-0.7.28/cognite_toolkit/_version.py

@@ -0,0 +1 @@
+__version__ = "0.7.28"

{cognite_toolkit-0.7.26 → cognite_toolkit-0.7.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cognite_toolkit"
-version = "0.7.26"
+version = "0.7.28"
 description = "Official Cognite Data Fusion tool for project templates and configuration deployment"
 authors = [
     {name ="Cognite AS", email="support@cognite.com"}