cognite-toolkit 0.5.62__tar.gz → 0.5.64__tar.gz

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.5.62
+Version: 0.5.64
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Project-URL: Homepage, https://docs.cognite.com/cdf/deploy/cdf_toolkit/
 Project-URL: Changelog, https://github.com/cognitedata/toolkit/releases

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/cdf.toml

@@ -25,4 +25,4 @@ dump = true
 [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.5.62"
+version = "0.5.64"

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/cognite_toolkit/_builtin_modules/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.5.62"
+version = "0.5.64"
 
 
 [plugins]

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/cognite_toolkit/_cdf_tk/apps/_profile_app.py

@@ -1,9 +1,9 @@
-from typing import Any
+from typing import Annotated, Any
 
 import typer
 from rich import print
 
-from cognite_toolkit._cdf_tk.commands import ProfileAssetCentricCommand
+from cognite_toolkit._cdf_tk.commands import ProfileAssetCentricCommand, ProfileTransformationCommand
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 
 
@@ -12,6 +12,7 @@ class ProfileApp(typer.Typer):
         super().__init__(*args, **kwargs)
         self.callback(invoke_without_command=True)(self.main)
         self.command("asset-centric")(self.asset_centric)
+        self.command("transformations")(self.transformations)
 
     def main(self, ctx: typer.Context) -> None:
         """Commands profile functionality"""
@@ -34,3 +35,32 @@ class ProfileApp(typer.Typer):
                 verbose,
             )
         )
+
+    @staticmethod
+    def transformations(
+        destination: Annotated[
+            str,
+            typer.Option(
+                "--destination",
+                "-d",
+                help="Destination type the transformations data should be written to. This can be 'assets', 'events', 'files',"
+                "'timeseries', or 'sequences'.",
+            ),
+        ],
+        verbose: bool = False,
+    ) -> None:
+        """This command gives an overview over the transformations that write to the given destination.
+        It works by checking all transformations that writes to the given destination, lists the sources of the data,
+        and the target columns.
+        This is intended to show the flow of data from raw into CDF. This can, for example, be used to determine the
+        source of the data in a specific CDF resource.
+        """
+        client = EnvironmentVariables.create_from_environment().get_client()
+        cmd = ProfileTransformationCommand()
+        cmd.run(
+            lambda: cmd.transformation(
+                client,
+                destination,
+                verbose,
+            )
+        )

cognite_toolkit-0.5.64/cognite_toolkit/_cdf_tk/client/data_classes/search_config.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from abc import ABC
+from dataclasses import dataclass
+from typing import Any
+
+from cognite.client import CogniteClient
+from cognite.client.data_classes._base import (
+    CogniteObject,
+    CogniteResourceList,
+    WriteableCogniteResource,
+    WriteableCogniteResourceList,
+)
+from typing_extensions import Self
+
+
+@dataclass
+class SearchConfigView(CogniteObject):
+    external_id: str
+    space: str
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            external_id=resource["externalId"],
+            space=resource["space"],
+        )
+
+
+@dataclass
+class SearchConfigViewProperty(CogniteObject):
+    property: str
+    disabled: bool | None = None
+    selected: bool | None = None
+    hidden: bool | None = None
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            property=resource["property"],
+            disabled=resource.get("disabled"),
+            selected=resource.get("selected"),
+            hidden=resource.get("hidden"),
+        )
+
+
+class SearchConfigCore(WriteableCogniteResource["SearchConfigWrite"], ABC):
+    """
+    Core model for a single Configuration.
+
+    Args:
+        view: The configuration for one specific view.
+        id: A server-generated ID for the object.
+        use_as_name: The name of property to use for the name column in the UI.
+        use_as_description: The name of property to use for the description column in the UI.
+        column_layout: Array of column configurations per property.
+        filter_layout: Array of filter configurations per property.
+        properties_layout: Array of property configurations per property.
+    """
+
+    def __init__(
+        self,
+        view: SearchConfigView,
+        id: int | None = None,
+        use_as_name: str | None = None,
+        use_as_description: str | None = None,
+        column_layout: list[SearchConfigViewProperty] | None = None,
+        filter_layout: list[SearchConfigViewProperty] | None = None,
+        properties_layout: list[SearchConfigViewProperty] | None = None,
+    ) -> None:
+        self.view = view
+        self.id = id
+        self.use_as_name = use_as_name
+        self.use_as_description = use_as_description
+        self.column_layout = column_layout
+        self.filter_layout = filter_layout
+        self.properties_layout = properties_layout
+
+    def as_write(self) -> SearchConfigWrite:
+        return SearchConfigWrite(
+            view=self.view,
+            id=self.id,
+            use_as_name=self.use_as_name,
+            use_as_description=self.use_as_description,
+            column_layout=self.column_layout,
+            filter_layout=self.filter_layout,
+            properties_layout=self.properties_layout,
+        )
+
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        output = super().dump(camel_case)
+        if self.column_layout:
+            output["columLayout" if camel_case else "column_layout"] = [
+                _data.dump(camel_case) for _data in self.column_layout
+            ]
+        if self.filter_layout:
+            output["filterLayout" if camel_case else "filter_layout"] = [
+                _data.dump(camel_case) for _data in self.filter_layout
+            ]
+        if self.properties_layout:
+            output["propertiesLayout" if camel_case else "properties_layout"] = [
+                _data.dump(camel_case) for _data in self.properties_layout
+            ]
+        if self.view:
+            output["view"] = self.view.dump(camel_case)
+        return output
+
+
+class SearchConfigWrite(SearchConfigCore):
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            id=resource.get("id"),
+            view=SearchConfigView.load(resource["view"]),
+            use_as_name=resource.get("useAsName"),
+            use_as_description=resource.get("useAsDescription"),
+            column_layout=[SearchConfigViewProperty.load(item) for item in resource.get("columnLayout", [])]
+            if resource.get("columnLayout")
+            else None,
+            filter_layout=[SearchConfigViewProperty.load(item) for item in resource.get("filterLayout", [])]
+            if resource.get("filterLayout")
+            else None,
+            properties_layout=[SearchConfigViewProperty.load(item) for item in resource.get("propertiesLayout", [])]
+            if resource.get("propertiesLayout")
+            else None,
+        )
+
+
+class SearchConfig(SearchConfigCore):
+    """
+    Response model for a single Configuration.
+
+    Args:
+        view: The configuration for one specific view.
+        id: A server-generated ID for the object.
+        created_time: The time when the search config was created.
+        updated_time: The time when the search config was last updated.
+        use_as_name: The name of property to use for the name column in the UI.
+        use_as_description: The name of property to use for the description column in the UI.
+        column_layout: Array of column configurations per property.
+        filter_layout: Array of filter configurations per property.
+        properties_layout: Array of property configurations per property.
+    """
+
+    def __init__(
+        self,
+        view: SearchConfigView,
+        id: int,
+        created_time: int,
+        updated_time: int,
+        use_as_name: str | None = None,
+        use_as_description: str | None = None,
+        column_layout: list[SearchConfigViewProperty] | None = None,
+        filter_layout: list[SearchConfigViewProperty] | None = None,
+        properties_layout: list[SearchConfigViewProperty] | None = None,
+    ) -> None:
+        super().__init__(
+            view,
+            id,
+            use_as_name,
+            use_as_description,
+            column_layout,
+            filter_layout,
+            properties_layout,
+        )
+        self.created_time = created_time
+        self.updated_time = updated_time
+
+    @classmethod
+    def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:
+        return cls(
+            view=SearchConfigView.load(resource["view"]),
+            id=resource["id"],
+            created_time=resource["createdTime"],
+            updated_time=resource["lastUpdatedTime"],
+            use_as_name=resource.get("useAsName"),
+            use_as_description=resource.get("useAsDescription"),
+            column_layout=[SearchConfigViewProperty.load(item) for item in resource.get("columnLayout", [])]
+            if resource.get("columnLayout")
+            else None,
+            filter_layout=[SearchConfigViewProperty.load(item) for item in resource.get("filterLayout", [])]
+            if resource.get("filterLayout")
+            else None,
+            properties_layout=[SearchConfigViewProperty.load(item) for item in resource.get("propertiesLayout", [])]
+            if resource.get("propertiesLayout")
+            else None,
+        )
+
+
+class SearchConfigWriteList(CogniteResourceList):
+    _RESOURCE = SearchConfigWrite
+
+
+class SearchConfigList(WriteableCogniteResourceList[SearchConfigWrite, SearchConfig]):
+    _RESOURCE = SearchConfig
+
+    def as_write(self) -> SearchConfigWriteList:
+        return SearchConfigWriteList([searchConfig.as_write() for searchConfig in self])

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/cognite_toolkit/_cdf_tk/commands/__init__.py

@@ -1,6 +1,6 @@
 from ._migrate import MigrateTimeseriesCommand, MigrationPrepareCommand
 from ._populate import PopulateCommand
-from ._profile import ProfileAssetCentricCommand
+from ._profile import ProfileAssetCentricCommand, ProfileTransformationCommand
 from ._purge import PurgeCommand
 from .auth import AuthCommand
 from .build_cmd import BuildCommand
@@ -31,6 +31,7 @@ __all__ = [
     "ModulesCommand",
     "PopulateCommand",
     "ProfileAssetCentricCommand",
+    "ProfileTransformationCommand",
     "PullCommand",
     "PurgeCommand",
     "RepoCommand",

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/cognite_toolkit/_cdf_tk/commands/_profile.py

@@ -1,9 +1,11 @@
+import itertools
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Mapping
+from collections.abc import Callable, Iterable, Mapping
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from functools import cached_property
 from typing import ClassVar, Literal, TypeAlias, overload
 
+from cognite.client.data_classes import Transformation
 from cognite.client.exceptions import CogniteException
 from rich import box
 from rich.console import Console
@@ -12,6 +14,8 @@ from rich.spinner import Spinner
 from rich.table import Table
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
+from cognite_toolkit._cdf_tk.utils import humanize_collection
 from cognite_toolkit._cdf_tk.utils.aggregators import (
     AssetAggregator,
     AssetCentricAggregator,
@@ -24,6 +28,7 @@ from cognite_toolkit._cdf_tk.utils.aggregators import (
     SequenceAggregator,
     TimeSeriesAggregator,
 )
+from cognite_toolkit._cdf_tk.utils.sql_parser import SQLParser, SQLTable
 
 from ._base import ToolkitCommand
 
@@ -237,3 +242,71 @@ class ProfileAssetCentricCommand(ProfileCommand):
         elif col == self.Columns.Transformation:
             return aggregator.transformation_count
         raise ValueError(f"Unknown column: {col} for row: {row}")
+
+
+class ProfileTransformationCommand(ProfileCommand):
+    valid_destinations: frozenset[str] = frozenset({"assets", "files", "events", "timeseries", "sequences"})
+
+    def __init__(self, print_warning: bool = True, skip_tracking: bool = False, silent: bool = False) -> None:
+        super().__init__(print_warning, skip_tracking, silent)
+        self.table_title = "Transformation Profile"
+        self.destination_type: Literal["assets", "files", "events", "timeseries", "sequences"] | None = None
+
+    class Columns:
+        Transformation = "Transformation"
+        Source = "Sources"
+        DestinationColumns = "Destination Columns"
+        Destination = "Destination"
+        ConflictMode = "Conflict Mode"
+        IsPaused = "Is Paused"
+
+    def transformation(
+        self, client: ToolkitClient, destination_type: str | None = None, verbose: bool = False
+    ) -> list[dict[str, CellValue]]:
+        self.destination_type = self._validate_destination_type(destination_type)
+        return self.create_profile_table(client)
+
+    @classmethod
+    def _validate_destination_type(
+        cls, destination_type: str | None
+    ) -> Literal["assets", "files", "events", "timeseries", "sequences"]:
+        if destination_type is None or destination_type not in cls.valid_destinations:
+            raise ToolkitValueError(
+                f"Invalid destination type: {destination_type}. Must be one of {humanize_collection(cls.valid_destinations)}."
+            )
+        # We validated the destination type above
+        return destination_type  # type: ignore[return-value]
+
+    def create_initial_table(self, client: ToolkitClient) -> dict[tuple[str, str], PendingCellValue]:
+        if self.valid_destinations is None:
+            raise ToolkitValueError("Destination type must be set before calling create_initial_table.")
+        iterable: Iterable[Transformation] = client.transformations.list(
+            destination_type=self.destination_type, limit=-1
+        )
+        if self.destination_type == "assets":
+            iterable = itertools.chain(iterable, client.transformations(destination_type="asset_hierarchy", limit=-1))
+        table: dict[tuple[str, str], PendingCellValue] = {}
+        for transformation in iterable:
+            sources: list[SQLTable] = []
+            destination_columns: list[str] = []
+            if transformation.query:
+                parser = SQLParser(transformation.query, operation="Profile transformations")
+                sources = parser.sources
+                destination_columns = parser.destination_columns
+            index = str(transformation.id)
+            table[(index, self.Columns.Transformation)] = transformation.name or transformation.external_id or "Unknown"
+            table[(index, self.Columns.Source)] = ", ".join(map(str, sources))
+            table[(index, self.Columns.DestinationColumns)] = (
+                ", ".join(destination_columns) or None if destination_columns else None
+            )
+            table[(index, self.Columns.Destination)] = (
+                transformation.destination.type or "Unknown" if transformation.destination else "Unknown"
+            )
+            table[(index, self.Columns.ConflictMode)] = transformation.conflict_mode or "Unknown"
+            table[(index, self.Columns.IsPaused)] = (
+                str(transformation.schedule.is_paused) if transformation.schedule else "No schedule"
+            )
+        return table
+
+    def call_api(self, row: str, col: str, client: ToolkitClient) -> Callable:
+        raise NotImplementedError(f"{type(self).__name__} does not support API calls for {col} in row {row}.")

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/cognite_toolkit/_cdf_tk/loaders/_resource_loaders/function_loaders.py

@@ -46,6 +46,7 @@ from cognite_toolkit._cdf_tk.utils import (
     calculate_secure_hash,
 )
 from cognite_toolkit._cdf_tk.utils.cdf import read_auth, try_find_error
+from cognite_toolkit._cdf_tk.utils.text import suffix_description
 
 from .auth_loaders import GroupAllScopedLoader
 from .data_organization_loaders import DataSetsLoader
@@ -464,20 +465,15 @@ class FunctionScheduleLoader(
             )
             self.authentication_by_id[identifier] = credentials
             auth_hash = calculate_secure_hash(credentials.dump(camel_case=True), shorten=True)
-            extra_str = f" {self._hash_key}: {auth_hash}"
-            if "description" not in resource:
-                resource["description"] = extra_str[1:]
-            elif resource["description"].endswith(extra_str[1:]):
-                # The hash is already in the description
-                ...
-            elif len(resource["description"]) + len(extra_str) < self._description_character_limit:
-                resource["description"] += f"{extra_str}"
-            else:
-                LowSeverityWarning(f"Description is too long for schedule {identifier!r}. Truncating...").print_warning(
-                    console=self.console
-                )
-                truncation = self._description_character_limit - len(extra_str) - 3
-                resource["description"] = f"{resource['description'][:truncation]}...{extra_str}"
+            extra_str = f"{self._hash_key}: {auth_hash}"
+            resource["description"] = suffix_description(
+                extra_str,
+                resource.get("description"),
+                self._description_character_limit,
+                self.get_id(resource),
+                self.display_name,
+                self.console,
+            )
         return resources
 
     def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> FunctionScheduleWrite:

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/cognite_toolkit/_cdf_tk/loaders/_resource_loaders/timeseries_loaders.py

@@ -1,5 +1,7 @@
+import json
 from collections.abc import Hashable, Iterable, Sequence
 from functools import lru_cache
+from pathlib import Path
 from typing import Any, cast, final
 
 from cognite.client.data_classes import (
@@ -28,7 +30,9 @@ from cognite_toolkit._cdf_tk.exceptions import (
 )
 from cognite_toolkit._cdf_tk.loaders._base_loaders import ResourceContainerLoader, ResourceLoader
 from cognite_toolkit._cdf_tk.resource_classes import TimeSeriesYAML
+from cognite_toolkit._cdf_tk.utils import calculate_hash
 from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_hashable, diff_list_identifiable, dm_identifier
+from cognite_toolkit._cdf_tk.utils.text import suffix_description
 
 from .auth_loaders import GroupAllScopedLoader, SecurityCategoryLoader
 from .classic_loaders import AssetLoader
@@ -216,6 +220,9 @@ class DatapointSubscriptionLoader(
         }
     )
 
+    _hash_key = "cdf-hash"
+    _description_character_limit = 1000
+
     @property
     def display_name(self) -> str:
         return "timeseries subscriptions"
@@ -325,25 +332,58 @@ class DatapointSubscriptionLoader(
     ) -> Iterable[DatapointSubscription]:
         return iter(self.client.time_series.subscriptions)
 
+    def load_resource_file(
+        self, filepath: Path, environment_variables: dict[str, str | None] | None = None
+    ) -> list[dict[str, Any]]:
+        resources = super().load_resource_file(filepath, environment_variables)
+        for resource in resources:
+            if "timeSeriesIds" not in resource and "instanceIds" not in resource:
+                continue
+            # If the timeSeriesIds or instanceIds is set, we need to add the auth hash to the description.
+            # such that we can detect if the subscription has changed.
+            content: dict[str, object] = {}
+            if "timeSeriesIds" in resource:
+                content["timeSeriesIds"] = resource["timeSeriesIds"]
+            if "instanceIds" in resource:
+                content["instanceIds"] = resource["instanceIds"]
+            timeseries_hash = calculate_hash(json.dumps(content), shorten=True)
+            extra_str = f"{self._hash_key}: {timeseries_hash}"
+            resource["description"] = suffix_description(
+                extra_str,
+                resource.get("description"),
+                self._description_character_limit,
+                self.get_id(resource),
+                self.display_name,
+                self.console,
+            )
+
+        return resources
+
     def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> DataPointSubscriptionWrite:
         if ds_external_id := resource.pop("dataSetExternalId", None):
             resource["dataSetId"] = self.client.lookup.data_sets.id(ds_external_id, is_dry_run)
         return DataPointSubscriptionWrite._load(resource)
 
     def dump_resource(self, resource: DatapointSubscription, local: dict[str, Any] | None = None) -> dict[str, Any]:
-        dumped = resource.as_write().dump()
+        if resource.filter is not None:
+            dumped = resource.as_write().dump()
+        else:
+            # If filter is not set, the subscription uses explicit timeSeriesIds, which are not returned in the
+            # response. Calling .as_write() in this case raises ValueError because either filter or
+            # timeSeriesIds must be set.
+            dumped = resource.dump()
+            for server_prop in ("createdTime", "lastUpdatedTime", "timeSeriesCount"):
+                dumped.pop(server_prop, None)
         local = local or {}
         if data_set_id := dumped.pop("dataSetId", None):
             dumped["dataSetExternalId"] = self.client.lookup.data_sets.external_id(data_set_id)
-        if "timeSeriesIds" not in dumped:
-            return dumped
-        # Sorting the timeSeriesIds in the local order
-        # Sorting in the same order as the local file.
-        ts_order_by_id = {ts_id: no for no, ts_id in enumerate(local.get("timeSeriesIds", []))}
-        end_of_list = len(ts_order_by_id)
-        dumped["timeSeriesIds"] = sorted(
-            dumped["timeSeriesIds"], key=lambda ts_id: ts_order_by_id.get(ts_id, end_of_list)
-        )
+        # timeSeriesIds and instanceIds are not returned in the response, so we need to add them
+        # to the dumped resource if they are set in the local resource. If there is a discrepancy between
+        # the local and dumped resource, th hash added to the description will change.
+        if "timeSeriesIds" in local:
+            dumped["timeSeriesIds"] = local["timeSeriesIds"]
+        if "instanceIds" in local:
+            dumped["instanceIds"] = local["instanceIds"]
         return dumped
 
     def diff_list(

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/cognite_toolkit/_cdf_tk/utils/sql_parser.py

@@ -14,6 +14,10 @@ class SQLTable:
     schema: str
     name: str
 
+    def __str__(self) -> str:
+        """Return the table name in the format 'schema.table'."""
+        return f"{self.schema}.{self.name}"
+
 
 class SQLParser:
     def __init__(self, query: str, operation: str) -> None:

cognite_toolkit-0.5.64/cognite_toolkit/_cdf_tk/utils/text.py

@@ -0,0 +1,42 @@
+from collections.abc import Hashable
+
+from rich.console import Console
+
+from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning
+
+
+def suffix_description(
+    suffix: str,
+    description: str | None,
+    description_character_limit: int,
+    identifier: Hashable,
+    resource_type: str,
+    console: Console | None = None,
+) -> str:
+    """Appends a suffix to a description if it is not already present.
+    If the description is too long after appending the suffix, it will be truncated to fit within the character limit.
+
+    Args:
+        suffix: The suffix to append to the description.
+        description: The original description to which the suffix will be appended.
+        description_character_limit: The maximum number of characters allowed in the description after appending the suffix.
+        identifier: Hashable identifier for the resource, used in warnings.
+        resource_type:  Type of the resource, used in warnings.
+        console: Console object for printing warnings.
+
+    Returns:
+        str: The modified description with the suffix appended, or truncated if necessary.
+    """
+    if description is None or description == "":
+        return suffix
+    elif description.endswith(suffix):
+        # The suffix is already in the description
+        return description
+    elif len(description) + len(suffix) + 1 < description_character_limit:
+        return f"{description} {suffix}"
+    else:
+        LowSeverityWarning(f"Description is too long for {resource_type} {identifier!r}. Truncating...").print_warning(
+            console=console
+        )
+        truncation = description_character_limit - len(suffix) - 3
+        return f"{description[:truncation]}...{suffix}"

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

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

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/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.5.62
+      image: cognite/toolkit:0.5.64
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

cognite_toolkit-0.5.64/cognite_toolkit/_version.py

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

cognite_toolkit-0.5.64/last_changelog_entry.md

@@ -0,0 +1,11 @@
+## cdf 
+
+### Fixed
+
+- Running `cdf deploy` with a `DatapointSubscription` defined with
+timeseries IDs no longer raise a `ValueError` when the
+`DatapointSubscription` has already been deployed.
+
+## templates
+
+No changes.

cognite_toolkit-0.5.64/last_git_message.txt

@@ -0,0 +1,31 @@
+[CDF-25010] 🪨Datapoint subscription with timeSeriesIds or InstanceIds (#1659)
+
+# Description
+
+In Toolkit we assume that datapoint subscription resources defined with
+timeseries IDs, returns these timeseries IDs when retrieving. This is
+not the case and thus is causing the current bug.
+
+In addition, this means that if a datapoint subscription is defined with
+timeseries IDs or instance IDs, we will not be able to detect that the
+changes between the local and CDF version of the timeseries. To account
+for this, I add a hash to the description and can be used to detect
+changes.
+
+## Changelog
+
+- [x] Patch
+- [ ] Minor
+- [ ] Skip
+
+## cdf
+
+### Fixed
+
+- Running `cdf deploy` with a `DatapointSubscription` defined with
+timeseries IDs no longer raise a `ValueError` when the
+`DatapointSubscription` has already been deployed.
+
+## templates
+
+No changes.

cognite_toolkit-0.5.64/last_version.txt

@@ -0,0 +1 @@
+0.5.63

{cognite_toolkit-0.5.62 → cognite_toolkit-0.5.64}/pyproject.toml

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