cognite-toolkit 0.7.16__py3-none-any.whl → 0.7.17__py3-none-any.whl

cognite_toolkit/_cdf_tk/apps/_download_app.py

@@ -15,6 +15,7 @@ from cognite_toolkit._cdf_tk.storageio import (
     AssetIO,
     CanvasIO,
     ChartIO,
+    DatapointsIO,
     DataSelector,
     EventIO,
     FileContentIO,
@@ -31,6 +32,7 @@ from cognite_toolkit._cdf_tk.storageio.selectors import (
     CanvasSelector,
     ChartExternalIdSelector,
     ChartSelector,
+    DataPointsDataSetSelector,
     DataSetSelector,
     FileIdentifierSelector,
     InstanceSpaceSelector,
@@ -73,6 +75,16 @@ class HierarchyFormats(str, Enum):
     ndjson = "ndjson"
 
 
+class DatapointFormats(str, Enum):
+    csv = "csv"
+    parquet = "parquet"
+
+
+class DatapointsDataTypes(str, Enum):
+    numeric = "numeric"
+    string = "string"
+
+
 class InstanceFormats(str, Enum):
     ndjson = "ndjson"
 
@@ -108,6 +120,8 @@ class DownloadApp(typer.Typer):
         self.command("events")(self.download_events_cmd)
         self.command("files")(self.download_files_cmd)
         self.command("hierarchy")(self.download_hierarchy_cmd)
+        if Flags.EXTEND_DOWNLOAD.is_enabled():
+            self.command("datapoints")(self.download_datapoints_cmd)
         self.command("instances")(self.download_instances_cmd)
         self.command("charts")(self.download_charts_cmd)
         self.command("canvas")(self.download_canvas_cmd)
@@ -841,6 +855,150 @@ class DownloadApp(typer.Typer):
             )
         )
 
+    @staticmethod
+    def download_datapoints_cmd(
+        dataset: Annotated[
+            str | None,
+            typer.Argument(
+                help="The dataset to download timeseries from. If not provided, an interactive selection will be made.",
+            ),
+        ] = None,
+        start_time: Annotated[
+            str | None,
+            typer.Option(
+                "--start-time",
+                "-s",
+                help="The start time for the datapoints to download. Can be in RFC3339 format or as a relative time (e.g., '1d-ago'). If not provided, all datapoints from the beginning will be downloaded.",
+            ),
+        ] = None,
+        end_time: Annotated[
+            str | None,
+            typer.Option(
+                "--end-time",
+                "-e",
+                help="The end time for the datapoints to download. Can be in RFC3339 format or as a relative time (e.g., '1d-ago'). If not provided, all datapoints up to the latest will be downloaded.",
+            ),
+        ] = None,
+        datapoint_type: Annotated[
+            DatapointsDataTypes,
+            typer.Option(
+                "--data-type",
+                "-d",
+                help="The type of datapoints to download.",
+            ),
+        ] = DatapointsDataTypes.numeric,
+        file_format: Annotated[
+            DatapointFormats,
+            typer.Option(
+                "--format",
+                "-f",
+                help="Format for downloading the datapoints.",
+            ),
+        ] = DatapointFormats.csv,
+        output_dir: Annotated[
+            Path,
+            typer.Option(
+                "--output-dir",
+                "-o",
+                help="Where to download the datapoints.",
+                allow_dash=True,
+            ),
+        ] = DEFAULT_DOWNLOAD_DIR,
+        limit: Annotated[
+            int,
+            typer.Option(
+                "--limit",
+                "-l",
+                help="The maximum number of timeseries to download datapoints from. Use -1 to download all timeseries."
+                "The maximum number of datapoints in total is 10 million and 100 000 per timeseries.",
+                max=10_000_000,
+            ),
+        ] = 1000,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """This command will download Datapoints from CDF into a temporary ."""
+        client = EnvironmentVariables.create_from_environment().get_client()
+        if dataset is None:
+            interactive = TimeSeriesInteractiveSelect(client, "download datapoints")
+            dataset = interactive.select_data_set(allow_empty=False)
+
+            datapoint_type = questionary.select(
+                "Select the type of datapoints to download:",
+                choices=[Choice(title=dt.value, value=dt) for dt in DatapointsDataTypes],
+                default=datapoint_type,
+            ).ask()
+
+            start_time = (
+                questionary.text(
+                    "Enter the start time for the datapoints to download (RFC3339 format or relative time, e.g., '1d-ago'). Leave empty to download from the beginning.",
+                    default=start_time or "",
+                ).ask()
+                or None
+            )
+            end_time = (
+                questionary.text(
+                    "Enter the end time for the datapoints to download (RFC3339 format or relative time, e.g., '1d-ago'). Leave empty to download up to the latest.",
+                    default=end_time or "",
+                ).ask()
+                or None
+            )
+            file_format = questionary.select(
+                "Select format to download the datapoints in:",
+                choices=[Choice(title=format_.value, value=format_) for format_ in DatapointFormats],
+                default=file_format,
+            ).ask()
+            output_dir = Path(
+                questionary.path(
+                    "Where to download the datapoints:", default=str(output_dir), only_directories=True
+                ).ask()
+            )
+            while True:
+                limit_str = questionary.text(
+                    "The maximum number of timeseries to download datapoints from. Use -1 to download all timeseries."
+                    "The maximum number of datapoints in total is 10 million and 100 000 per timeseries.",
+                    default=str(limit),
+                ).ask()
+                if limit_str is None:
+                    raise typer.Abort()
+                try:
+                    limit = int(limit_str)
+                except ValueError:
+                    print("[red]Please enter a valid integer for the limit.[/]")
+                else:
+                    if limit != -1 and limit < 1:
+                        print("[red]Please enter a valid integer greater than 0 or -1 for unlimited.[/]")
+                    else:
+                        break
+                verbose = questionary.confirm(
+                    "Turn on to get more verbose output when running the command?", default=verbose
+                ).ask()
+
+        cmd = DownloadCommand()
+        selector = DataPointsDataSetSelector(
+            data_set_external_id=dataset,
+            start=start_time,
+            end=end_time,
+            data_type=datapoint_type.value,
+        )
+        cmd.run(
+            lambda: cmd.download(
+                selectors=[selector],
+                io=DatapointsIO(client),
+                output_dir=output_dir,
+                file_format=f".{file_format.value}",
+                compression="none",
+                limit=limit if limit != -1 else None,
+                verbose=verbose,
+            )
+        )
+
     @staticmethod
     def download_charts_cmd(
         ctx: typer.Context,

cognite_toolkit/_cdf_tk/commands/_download.py

@@ -5,10 +5,21 @@ from pathlib import Path
 from cognite_toolkit._cdf_tk.constants import DATA_MANIFEST_STEM, DATA_RESOURCE_DIR
 from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
 from cognite_toolkit._cdf_tk.protocols import T_ResourceResponse
-from cognite_toolkit._cdf_tk.storageio import ConfigurableStorageIO, Page, StorageIO, T_Selector, TableStorageIO
+from cognite_toolkit._cdf_tk.storageio import (
+    ConfigurableStorageIO,
+    Page,
+    StorageIO,
+    T_Selector,
+    TableStorageIO,
+)
 from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning
 from cognite_toolkit._cdf_tk.utils.file import safe_write, sanitize_filename, yaml_safe_dump
-from cognite_toolkit._cdf_tk.utils.fileio import TABLE_WRITE_CLS_BY_FORMAT, Compression, FileWriter, SchemaColumn
+from cognite_toolkit._cdf_tk.utils.fileio import (
+    TABLE_WRITE_CLS_BY_FORMAT,
+    Compression,
+    FileWriter,
+    SchemaColumn,
+)
 from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 

cognite_toolkit/_cdf_tk/commands/_migrate/command.py

@@ -188,7 +188,11 @@ class MigrationCommand(ToolkitCommand):
                 return None
             responses: Sequence[HTTPMessage]
             if dry_run:
-                responses = [SuccessResponseItems(200, "", [item.source_id for item in data_item])]
+                responses = [
+                    SuccessResponseItems(
+                        status_code=200, body="", content=b"", ids=[item.source_id for item in data_item]
+                    )
+                ]
             else:
                 responses = target.upload_items(data_chunk=data_item, http_client=write_client, selector=selected)
 

cognite_toolkit/_cdf_tk/feature_flags.py

@@ -55,7 +55,7 @@ class Flags(Enum):
     )
     EXTEND_DOWNLOAD = FlagMetadata(
         visible=True,
-        description="Enables extended download to support downloading file content",
+        description="Enables extended download to support downloading file content and datapoints",
     )
 
     def is_enabled(self) -> bool:

cognite_toolkit/_cdf_tk/storageio/_applications.py

@@ -214,7 +214,7 @@ class CanvasIO(UploadableStorageIO[CanvasSelector, IndustrialCanvas, IndustrialC
             self.client.lookup.files.external_id(list(file_ids))
 
     def _dump_resource(self, canvas: IndustrialCanvas) -> dict[str, JsonVal]:
-        dumped = canvas.as_write().dump()
+        dumped = canvas.as_write().dump(keep_existing_version=False)
         references = dumped.get("containerReferences", [])
         if not isinstance(references, list):
             return dumped
@@ -230,10 +230,18 @@ class CanvasIO(UploadableStorageIO[CanvasSelector, IndustrialCanvas, IndustrialC
             properties = source["properties"]
             if not isinstance(properties, dict):
                 continue
+            reference_type = properties.get("containerReferenceType")
+            if (
+                reference_type
+                in {
+                    "charts",
+                    "dataGrid",
+                }
+            ):  # These container reference types are special cases with a resourceId statically set to -1, which is why we skip them
+                continue
             resource_id = properties.pop("resourceId", None)
             if not isinstance(resource_id, int):
                 continue
-            reference_type = properties.get("containerReferenceType")
             if reference_type == "asset":
                 external_id = self.client.lookup.assets.external_id(resource_id)
             elif reference_type == "timeseries":

cognite_toolkit/_cdf_tk/storageio/_datapoints.py

@@ -1,4 +1,5 @@
 from collections.abc import Iterable, Mapping, Sequence
+from itertools import groupby
 from typing import Any, ClassVar, cast
 
 from cognite.client._proto.data_point_insertion_request_pb2 import DataPointInsertionItem, DataPointInsertionRequest
@@ -9,33 +10,51 @@ from cognite.client._proto.data_points_pb2 import (
     StringDatapoint,
     StringDatapoints,
 )
+from cognite.client.data_classes import TimeSeriesFilter
+from cognite.client.data_classes.filters import Exists
+from cognite.client.data_classes.time_series import TimeSeriesProperty
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.exceptions import ToolkitNotImplementedError
 from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
+from cognite_toolkit._cdf_tk.utils import humanize_collection
 from cognite_toolkit._cdf_tk.utils.dtype_conversion import (
     _EpochConverter,
     _Float64Converter,
     _TextConverter,
     _ValueConverter,
 )
+from cognite_toolkit._cdf_tk.utils.fileio import SchemaColumn
 from cognite_toolkit._cdf_tk.utils.fileio._readers import MultiFileReader
-from cognite_toolkit._cdf_tk.utils.http_client import DataBodyRequest, HTTPClient, HTTPMessage
+from cognite_toolkit._cdf_tk.utils.http_client import (
+    DataBodyRequest,
+    HTTPClient,
+    HTTPMessage,
+    SimpleBodyRequest,
+    SuccessResponse,
+)
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
-from ._base import Page, TableUploadableStorageIO, UploadItem
-from .selectors import DataPointsFileSelector
+from ._base import Page, TableStorageIO, TableUploadableStorageIO, UploadItem
+from .selectors import DataPointsDataSetSelector, DataPointsFileSelector, DataPointsSelector
 
 
-class DatapointsIO(TableUploadableStorageIO[DataPointsFileSelector, DataPointListResponse, DataPointInsertionRequest]):
+class DatapointsIO(
+    TableStorageIO[DataPointsSelector, DataPointListResponse],
+    TableUploadableStorageIO[DataPointsSelector, DataPointListResponse, DataPointInsertionRequest],
+):
     SUPPORTED_DOWNLOAD_FORMATS = frozenset({".csv"})
     SUPPORTED_COMPRESSIONS = frozenset({".gz"})
     CHUNK_SIZE = 10_000
-    BASE_SELECTOR = DataPointsFileSelector
+    DOWNLOAD_CHUNK_SIZE = 100
+    BASE_SELECTOR = DataPointsSelector
     KIND = "Datapoints"
     SUPPORTED_READ_FORMATS = frozenset({".csv"})
     UPLOAD_ENDPOINT = "/timeseries/data"
     UPLOAD_EXTRA_ARGS: ClassVar[Mapping[str, JsonVal] | None] = None
+    MAX_TOTAL_DATAPOINTS = 10_000_000
+    MAX_PER_REQUEST_DATAPOINTS = 100_000
+    MAX_PER_REQUEST_DATAPOINTS_AGGREGATION = 10_000
 
     def __init__(self, client: ToolkitClient) -> None:
         super().__init__(client)
@@ -47,24 +66,181 @@ class DatapointsIO(TableUploadableStorageIO[DataPointsFileSelector, DataPointLis
     def as_id(self, item: DataPointListResponse) -> str:
         raise NotImplementedError()
 
-    def stream_data(self, selector: DataPointsFileSelector, limit: int | None = None) -> Iterable[Page]:
-        raise NotImplementedError(f"Download of {type(DatapointsIO).__name__.removesuffix('IO')} is not yet supported")
+    def get_schema(self, selector: DataPointsSelector) -> list[SchemaColumn]:
+        return [
+            SchemaColumn(name="externalId", type="string"),
+            SchemaColumn(name="timestamp", type="epoch"),
+            SchemaColumn(
+                name="value",
+                type="string"
+                if isinstance(selector, DataPointsDataSetSelector) and selector.data_type == "string"
+                else "float",
+            ),
+        ]
 
-    def count(self, selector: DataPointsFileSelector) -> int | None:
-        raise NotImplementedError(f"Download of {type(DatapointsIO).__name__.removesuffix('IO')} is not yet supported")
+    def stream_data(
+        self, selector: DataPointsSelector, limit: int | None = None
+    ) -> Iterable[Page[DataPointListResponse]]:
+        if not isinstance(selector, DataPointsDataSetSelector):
+            raise RuntimeError(
+                f"{type(self).__name__} only supports streaming data for DataPointsDataSetSelector selectors. Got {type(selector).__name__}."
+            )
+        timeseries_count = self.count(selector)
+        if limit is not None:
+            timeseries_count = min(timeseries_count or 0, limit)
+        limit_per_timeseries = (
+            (self.MAX_TOTAL_DATAPOINTS // timeseries_count) if timeseries_count else self.MAX_PER_REQUEST_DATAPOINTS
+        )
+        limit_per_timeseries = min(limit_per_timeseries, self.MAX_PER_REQUEST_DATAPOINTS)
+        config = self.client.config
+        for timeseries in self.client.time_series(
+            data_set_external_ids=[selector.data_set_external_id],
+            chunk_size=self.DOWNLOAD_CHUNK_SIZE,
+            is_string=True if selector.data_type == "string" else False,
+            advanced_filter=Exists(TimeSeriesProperty.external_id),
+            limit=limit,
+            # We cannot use partitions here as it is not thread safe. This spawn multiple threads
+            # that are not shut down until all data is downloaded. We need to be able to abort.
+            partitions=None,
+        ):
+            if not timeseries:
+                continue
+            # Aggregation of datapoints per timeseries
+            items = [
+                {
+                    "id": ts.id,
+                    "start": selector.start,
+                    "end": selector.end,
+                    "limit": self.MAX_PER_REQUEST_DATAPOINTS_AGGREGATION // len(timeseries),
+                    "aggregates": ["count"],
+                    "granularity": "1200mo",
+                }
+                for ts in timeseries
+            ]
+            responses = self.client.http_client.request_with_retries(
+                SimpleBodyRequest(
+                    endpoint_url=config.create_api_url("/timeseries/data/list"),
+                    method="POST",
+                    accept="application/protobuf",
+                    content_type="application/json",
+                    body_content={"items": items},  # type: ignore[dict-item]
+                )
+            )
+            first_success = next((resp for resp in responses if isinstance(resp, SuccessResponse)), None)
+            if first_success is None:
+                continue
+            aggregate_response: DataPointListResponse = DataPointListResponse.FromString(first_success.content)
+            timeseries_ids_with_data: dict[int, int] = {}
+            for dp in aggregate_response.items:
+                if dp.aggregateDatapoints.datapoints:
+                    ts_datapoint_count = int(sum(agg.count for agg in dp.aggregateDatapoints.datapoints))
+                    timeseries_ids_with_data[dp.id] = ts_datapoint_count
+            total_datapoints = int(sum(timeseries_ids_with_data.values()))
+            if total_datapoints == 0:
+                continue
+
+            batch: list[dict[str, Any]] = []
+            batch_count = 0
+            for ts_id, count in timeseries_ids_with_data.items():
+                count = min(count, limit_per_timeseries)
+                ts_limit = count
+                left_over = 0
+                if (batch_count + ts_limit) > self.MAX_PER_REQUEST_DATAPOINTS:
+                    ts_limit = self.MAX_PER_REQUEST_DATAPOINTS - batch_count
+                    left_over = count - ts_limit
+                batch.append(
+                    {
+                        "id": ts_id,
+                        "start": selector.start,
+                        "end": selector.end,
+                        "limit": ts_limit,
+                    }
+                )
+                batch_count += ts_limit
+                if batch_count >= self.MAX_PER_REQUEST_DATAPOINTS:
+                    if page := self._fetch_datapoints_batch(batch, config):
+                        yield page
+                    batch = []
+
+                if left_over > 0:
+                    batch.append(
+                        {
+                            "id": ts_id,
+                            "start": selector.start,
+                            "end": selector.end,
+                            "limit": left_over,
+                        }
+                    )
+                    batch_count += left_over
+            if batch and (page := self._fetch_datapoints_batch(batch, config)):
+                yield page
+
+    def _fetch_datapoints_batch(self, batch: list[dict[str, Any]], config: Any) -> Page[DataPointListResponse] | None:
+        responses = self.client.http_client.request_with_retries(
+            SimpleBodyRequest(
+                endpoint_url=config.create_api_url("/timeseries/data/list"),
+                method="POST",
+                accept="application/protobuf",
+                content_type="application/json",
+                body_content={"items": batch},  # type: ignore[dict-item]
+            )
+        )
+        first_success = next((resp for resp in responses if isinstance(resp, SuccessResponse)), None)
+        if first_success is None:
+            return None
+        data_response: DataPointListResponse = DataPointListResponse.FromString(first_success.content)
+        return Page("Main", [data_response])
+
+    def count(self, selector: DataPointsSelector) -> int | None:
+        if isinstance(selector, DataPointsDataSetSelector):
+            return self.client.time_series.aggregate_count(
+                filter=TimeSeriesFilter(
+                    data_set_ids=[{"externalId": selector.data_set_external_id}],
+                    is_string=True if selector.data_type == "string" else False,
+                ),
+                # We only want time series that have externalID set.
+                advanced_filter=Exists(TimeSeriesProperty.external_id),
+            )
+        return None
 
     def data_to_json_chunk(
-        self, data_chunk: Sequence[DataPointListResponse], selector: DataPointsFileSelector | None = None
+        self, data_chunk: Sequence[DataPointListResponse], selector: DataPointsSelector | None = None
     ) -> list[dict[str, JsonVal]]:
         raise ToolkitNotImplementedError(
             f"Download of {type(DatapointsIO).__name__.removesuffix('IO')} does not support json format."
         )
 
+    def data_to_row(
+        self, data_chunk: Sequence[DataPointListResponse], selector: DataPointsSelector | None = None
+    ) -> list[dict[str, JsonVal]]:
+        output: list[dict[str, JsonVal]] = []
+        for response in data_chunk:
+            for item in response.items:
+                if item.numericDatapoints.datapoints:
+                    for dp in item.numericDatapoints.datapoints:
+                        output.append(
+                            {
+                                "externalId": item.externalId,
+                                "timestamp": dp.timestamp,
+                                "value": dp.value,
+                            }
+                        )
+                if item.stringDatapoints.datapoints:
+                    for dp in item.stringDatapoints.datapoints:
+                        output.append(
+                            {
+                                "externalId": item.externalId,
+                                "timestamp": dp.timestamp,
+                                "value": dp.value,
+                            }
+                        )
+        return output
+
     def upload_items(
         self,
         data_chunk: Sequence[UploadItem[DataPointInsertionRequest]],
         http_client: HTTPClient,
-        selector: DataPointsFileSelector | None = None,
+        selector: DataPointsSelector | None = None,
     ) -> Sequence[HTTPMessage]:
         results: list[HTTPMessage] = []
         for item in data_chunk:
@@ -80,12 +256,25 @@ class DatapointsIO(TableUploadableStorageIO[DataPointsFileSelector, DataPointLis
         return results
 
     def row_to_resource(
-        self, source_id: str, row: dict[str, JsonVal], selector: DataPointsFileSelector | None = None
+        self, source_id: str, row: dict[str, JsonVal], selector: DataPointsSelector | None = None
     ) -> DataPointInsertionRequest:
         if selector is None:
             raise ValueError("Selector must be provided to convert row to DataPointInsertionItem.")
         # We assume that the row was read using the read_chunks method.
         rows = cast(dict[str, list[Any]], row)
+        if isinstance(selector, DataPointsFileSelector):
+            datapoints_items = self._rows_to_datapoint_items_file_selector(rows, selector, source_id)
+        elif isinstance(selector, DataPointsDataSetSelector):
+            datapoints_items = self._rows_to_datapoint_items_data_set_selector(rows, selector, source_id)
+        else:
+            raise RuntimeError(
+                f"Unsupported selector type {type(selector).__name__} for {type(self).__name__}. Trying to transform {source_id!r} from rows to DataPointInsertionRequest."
+            )
+        return DataPointInsertionRequest(items=datapoints_items)
+
+    def _rows_to_datapoint_items_file_selector(
+        self, rows: dict[str, list[Any]], selector: DataPointsFileSelector, source_id: str
+    ) -> list[DataPointInsertionItem]:
         if selector.timestamp_column not in rows:
             raise RuntimeError(f"Timestamp column '{selector.timestamp_column}' not found.")
 
@@ -133,7 +322,66 @@ class DatapointsIO(TableUploadableStorageIO[DataPointsFileSelector, DataPointLis
                 raise RuntimeError(f"Unsupported dtype {column.dtype} for column {col}.")
 
             datapoints_items.append(DataPointInsertionItem(**args))
-        return DataPointInsertionRequest(items=datapoints_items)
+
+        return datapoints_items
+
+    def _rows_to_datapoint_items_data_set_selector(
+        self, rows: dict[str, list[Any]], selector: DataPointsDataSetSelector, source_id: str
+    ) -> list[DataPointInsertionItem]:
+        if "externalId" not in rows:
+            raise RuntimeError("Column 'externalId' not found.")
+        if "value" not in rows:
+            raise RuntimeError("Column 'value' not found.")
+        if "timestamp" not in rows:
+            raise RuntimeError("Column 'timestamp' not found.")
+
+        external_ids = rows["externalId"]
+        timestamps = list(
+            self._convert_values(
+                rows["timestamp"],
+                self._epoc_converter,
+                "timestamps (column 'timestamp')",
+                source_id,
+            )
+        )
+        values = list(
+            self._convert_values(
+                rows["value"],
+                self._numeric_converter if selector.data_type == "numeric" else self._string_converter,
+                "values (column 'value')",
+                source_id,
+            )
+        )
+        sorted_datapoints = sorted(zip(external_ids, timestamps, values), key=lambda x: x[0])
+        datapoints_items: list[DataPointInsertionItem] = []
+        if selector.data_type == "numeric":
+            for external_id, datapoints in groupby(sorted_datapoints, key=lambda x: x[0]):
+                datapoints_items.append(
+                    DataPointInsertionItem(
+                        externalId=external_id,
+                        numericDatapoints=NumericDatapoints(
+                            datapoints=[
+                                NumericDatapoint(timestamp=timestamp, value=value) for _, timestamp, value in datapoints
+                            ]
+                        ),
+                    )
+                )
+        elif selector.data_type == "string":
+            for external_id, datapoints in groupby(sorted_datapoints, key=lambda x: x[0]):
+                datapoints_items.append(
+                    DataPointInsertionItem(
+                        externalId=external_id,
+                        stringDatapoints=StringDatapoints(
+                            datapoints=[
+                                StringDatapoint(timestamp=timestamp, value=value) for _, timestamp, value in datapoints
+                            ]
+                        ),
+                    )
+                )
+        else:
+            raise RuntimeError(f"Unsupported data_type {selector.data_type} for DataPointsDataSetSelector.")
+
+        return datapoints_items
 
     def _convert_values(
         self, values: list[Any], converter: _ValueConverter, name: str, source_id: str
@@ -165,10 +413,11 @@ class DatapointsIO(TableUploadableStorageIO[DataPointsFileSelector, DataPointLis
 
     @classmethod
     def read_chunks(
-        cls, reader: MultiFileReader, selector: DataPointsFileSelector
+        cls, reader: MultiFileReader, selector: DataPointsSelector
     ) -> Iterable[list[tuple[str, dict[str, JsonVal]]]]:
         if not reader.is_table:
-            raise RuntimeError("DatapointsIO can only read from TableReader instances.")
+            raise RuntimeError(f"{cls.__name__} can only read from TableReader instances.")
+
         iterator = iter(reader.read_chunks_with_line_numbers())
         try:
             start_row, first = next(iterator)
@@ -176,6 +425,12 @@ class DatapointsIO(TableUploadableStorageIO[DataPointsFileSelector, DataPointLis
             # Empty file
             return
         column_names = list(first.keys())
+        if isinstance(selector, DataPointsDataSetSelector):
+            if set(column_names) != selector.required_columns:
+                raise RuntimeError(
+                    "When uploading datapoints using a dataset manifest for datapoints, you must have exacatly the "
+                    f"columns: {humanize_collection(selector.required_columns)} in the file. Got {humanize_collection(column_names)}. "
+                )
         batch: dict[str, list[Any]] = {col: [value] for col, value in first.items()}
         last_row = start_row
         for row_no, chunk in iterator:
@@ -189,5 +444,5 @@ class DatapointsIO(TableUploadableStorageIO[DataPointsFileSelector, DataPointLis
                 start_row = row_no + 1
                 batch = {col: [] for col in column_names}
             last_row = row_no
-        if any(batch.values()):
-            yield [(f"rows {start_row} to{last_row}", batch)]  # type: ignore[list-item]
+            if any(batch.values()):
+                yield [(f"rows {start_row} to{last_row}", batch)]  # type: ignore[list-item]

cognite_toolkit/_cdf_tk/storageio/selectors/__init__.py

@@ -7,7 +7,9 @@ from ._base import DataSelector
 from ._canvas import CanvasExternalIdSelector, CanvasSelector
 from ._charts import AllChartsSelector, ChartExternalIdSelector, ChartOwnerSelector, ChartSelector
 from ._datapoints import (
+    DataPointsDataSetSelector,
     DataPointsFileSelector,
+    DataPointsSelector,
     ExternalIdColumn,
     InstanceColumn,
     InternalIdColumn,
@@ -40,6 +42,7 @@ Selector = Annotated[
     | AssetSubtreeSelector
     | AssetCentricFileSelector
     | DataSetSelector
+    | DataPointsDataSetSelector
     | DataPointsFileSelector
     | ChartExternalIdSelector
     | CanvasExternalIdSelector
@@ -62,7 +65,9 @@ __all__ = [
     "ChartExternalIdSelector",
     "ChartOwnerSelector",
     "ChartSelector",
+    "DataPointsDataSetSelector",
     "DataPointsFileSelector",
+    "DataPointsSelector",
     "DataSelector",
     "DataSetSelector",
     "ExternalIdColumn",

cognite_toolkit/_cdf_tk/storageio/selectors/_datapoints.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from functools import cached_property
-from typing import Annotated, Any, Literal
+from typing import Annotated, Any, ClassVar, Literal
 
 from cognite.client._proto.data_points_pb2 import (
     InstanceId,
@@ -50,10 +50,13 @@ TimeSeriesColumn = Annotated[
 ]
 
 
-class DataPointsFileSelector(DataSelector):
-    type: Literal["datapointsFile"] = "datapointsFile"
+class DataPointsSelector(DataSelector, ABC):
     kind: Literal["Datapoints"] = "Datapoints"
 
+
+class DataPointsFileSelector(DataPointsSelector):
+    type: Literal["datapointsFile"] = "datapointsFile"
+
     timestamp_column: str
     columns: tuple[TimeSeriesColumn, ...]
 
@@ -67,3 +70,20 @@ class DataPointsFileSelector(DataSelector):
     @cached_property
     def id_by_column(self) -> dict[str, Column]:
         return {col.column: col for col in self.columns}
+
+
+class DataPointsDataSetSelector(DataPointsSelector):
+    required_columns: ClassVar[frozenset[str]] = frozenset({"externalId", "timestamp", "value"})
+    type: Literal["datapointsDataSet"] = "datapointsDataSet"
+
+    data_set_external_id: str
+    start: int | str | None = None
+    end: int | str | None = None
+    data_type: Literal["numeric", "string"] = "numeric"
+
+    @property
+    def group(self) -> str:
+        return f"DataSet_{self.data_set_external_id}"
+
+    def __str__(self) -> str:
+        return f"datapoints_dataset_{self.data_set_external_id}"

cognite_toolkit/_cdf_tk/utils/http_client/_data_classes.py

@@ -115,6 +115,13 @@ class RequestMessage(HTTPMessage):
 @dataclass
 class SuccessResponse(ResponseMessage):
     body: str
+    content: bytes
+
+    def dump(self) -> dict[str, JsonVal]:
+        output = super().dump()
+        # We cannot serialize bytes, so we indicate its presence instead
+        output["content"] = "<bytes>" if self.content else None
+        return output
 
 
 @dataclass
@@ -134,7 +141,7 @@ class SimpleRequest(RequestMessage):
 
     @classmethod
     def create_success_response(cls, response: httpx.Response) -> Sequence[ResponseMessage]:
-        return [SuccessResponse(status_code=response.status_code, body=response.text)]
+        return [SuccessResponse(status_code=response.status_code, body=response.text, content=response.content)]
 
     @classmethod
     def create_failure_response(cls, response: httpx.Response) -> Sequence[HTTPMessage]:
@@ -309,7 +316,11 @@ class ItemsRequest(Generic[T_COVARIANT_ID], BodyRequest):
 
     def create_success_response(self, response: httpx.Response) -> Sequence[HTTPMessage]:
         ids = [item.as_id() for item in self.items]
-        return [SuccessResponseItems(status_code=response.status_code, ids=ids, body=response.text)]
+        return [
+            SuccessResponseItems(
+                status_code=response.status_code, ids=ids, body=response.text, content=response.content
+            )
+        ]
 
     def create_failure_response(self, response: httpx.Response) -> Sequence[HTTPMessage]:
         error = ErrorDetails.from_response(response)
@@ -369,7 +380,11 @@ class ResponseList(UserList[ResponseMessage | FailedRequestMessage]):
         results: list[ResponseMessage | FailedRequestMessage] = []
         for message in self.data:
             if isinstance(message, SuccessResponse):
-                results.append(SuccessResponseItems(status_code=message.status_code, ids=[item_id], body=message.body))
+                results.append(
+                    SuccessResponseItems(
+                        status_code=message.status_code, content=message.content, ids=[item_id], body=message.body
+                    )
+                )
             elif isinstance(message, FailedResponse):
                 results.append(
                     FailedResponseItems(

cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

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

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.16
+      image: cognite/toolkit:0.7.17
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

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.16"
+version = "0.7.17"
 
 
 [plugins]

cognite_toolkit/_version.py

@@ -1 +1 @@
-__version__ = "0.7.16"
+__version__ = "0.7.17"

{cognite_toolkit-0.7.16.dist-info → cognite_toolkit-0.7.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.16
+Version: 0.7.17
 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.7.16.dist-info → cognite_toolkit-0.7.17.dist-info}/RECORD

@@ -1,12 +1,12 @@
 cognite_toolkit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite_toolkit/_cdf.py,sha256=sefGD2JQuOTBZhEqSj_ECbNZ7nTRN4AwGwX1pSUhoow,5636
-cognite_toolkit/_version.py,sha256=KMhjynKNFAEDq-e3uMcLQxUln7LSjXz2vHkhD1Nf1c8,23
+cognite_toolkit/_version.py,sha256=OaW7Nqbk6j_afc_1rZbViV0T5t8K2yQ3XoJdd50o-lc,23
 cognite_toolkit/config.dev.yaml,sha256=M33FiIKdS3XKif-9vXniQ444GTZ-bLXV8aFH86u9iUQ,332
 cognite_toolkit/_cdf_tk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite_toolkit/_cdf_tk/cdf_toml.py,sha256=VSWV9h44HusWIaKpWgjrOMrc3hDoPTTXBXlp6-NOrIM,9079
 cognite_toolkit/_cdf_tk/constants.py,sha256=TplKm2J9pGRHq7nAnLI0caTMHetS04OIz3hfq-jvGzo,7236
 cognite_toolkit/_cdf_tk/exceptions.py,sha256=xG0jMwi5A20nvPvyo6sCyz_cyKycynPyIzpYiGR4gcU,6064
-cognite_toolkit/_cdf_tk/feature_flags.py,sha256=nCI71ldaZyoXEu0zI53XMFzcAMQW08KaM6CmuBIOJyw,2056
+cognite_toolkit/_cdf_tk/feature_flags.py,sha256=ESxrtl2hbe0Fr6e1535MAjSIM326Zc6W7d2PtfjAWkk,2071
 cognite_toolkit/_cdf_tk/hints.py,sha256=UI1ymi2T5wCcYOpEbKbVaDnlyFReFy8TDtMVt-5E1h8,6493
 cognite_toolkit/_cdf_tk/plugins.py,sha256=0V14rceAWLZQF8iWdyL5QmK7xB796YaDEtb9RIj5AOc,836
 cognite_toolkit/_cdf_tk/protocols.py,sha256=Lc8XnBfmDZN6dwmSopmK7cFE9a9jZ2zdUryEeCXn27I,3052
@@ -17,7 +17,7 @@ cognite_toolkit/_cdf_tk/apps/_auth_app.py,sha256=ER7uYb3ViwsHMXiQEZpyhwU6TIjKaB9
 cognite_toolkit/_cdf_tk/apps/_core_app.py,sha256=YK0MOK7Tv3cDSe5_6o9GtM5n_6sE7I0Wm-Se4eJnyNM,13744
 cognite_toolkit/_cdf_tk/apps/_data_app.py,sha256=LeplXlxXtyIymRPgbatQrRFodU4VZBFxI0bqDutLSbg,806
 cognite_toolkit/_cdf_tk/apps/_dev_app.py,sha256=FaY67PFdKwdiMKgJbTcjHT1X2Xfbog2PKL6T-kcawyc,2818
-cognite_toolkit/_cdf_tk/apps/_download_app.py,sha256=gcmcYZmB_ppWTiqDxc_6aVS9zoIACoV_cVU1sZVYwXY,34985
+cognite_toolkit/_cdf_tk/apps/_download_app.py,sha256=2nPn9P_9br9poynSpKKSZF7WYTYT--BfxlxXkSEeH-8,41156
 cognite_toolkit/_cdf_tk/apps/_dump_app.py,sha256=EPq6fWSaScj9ncKfRY253rRJ37er47PIM60IFgkQK_k,37127
 cognite_toolkit/_cdf_tk/apps/_landing_app.py,sha256=YR9z83OY7PhhgBVC5gmRLgo9iTXoGoZfRhOU3gd_r2o,888
 cognite_toolkit/_cdf_tk/apps/_migrate_app.py,sha256=g4S_53kbIgk57ziPLdRMuR6xUe434gkMqa69VmVm5Vg,39619
@@ -107,7 +107,7 @@ cognite_toolkit/_cdf_tk/commands/__init__.py,sha256=HQIHw18EU09fdo7bxbDXi8-0Lc5t
 cognite_toolkit/_cdf_tk/commands/_base.py,sha256=1gl8Y-yqfedRMfdbwM3iPTIUIZriX1UvC1deLsJSJwM,2667
 cognite_toolkit/_cdf_tk/commands/_changes.py,sha256=sU0KaTtPVSJgAZcaZ1Tkcajj36pmhd13kh7V8QbIED8,22987
 cognite_toolkit/_cdf_tk/commands/_cli_commands.py,sha256=TK6U_rm6VZT_V941kTyHMoulWgJzbDC8YIIQDPJ5x3w,1011
-cognite_toolkit/_cdf_tk/commands/_download.py,sha256=gOUjsu-YaiIyKGd5kZDW-1lsgY7sQwGxg2Pwk6TlWdY,6823
+cognite_toolkit/_cdf_tk/commands/_download.py,sha256=dVddH9t7oGx1kdQ3CCYYQb96Uxxy-xC8Opph98lo46U,6869
 cognite_toolkit/_cdf_tk/commands/_profile.py,sha256=_4iX3AHAI6eLmRVUlWXCSvVHx1BZW2yDr_i2i9ECg6U,43120
 cognite_toolkit/_cdf_tk/commands/_purge.py,sha256=HqN2T0OrHG53BfQrolYLi0kFa-_KuJjbZldFtQdMdnY,32914
 cognite_toolkit/_cdf_tk/commands/_questionary_style.py,sha256=h-w7fZKkGls3TrzIGBKjsZSGoXJJIYchgD1StfA40r8,806
@@ -129,7 +129,7 @@ cognite_toolkit/_cdf_tk/commands/resources.py,sha256=NeHVA1b1TMsP-2wgd5u1vif_N6n
 cognite_toolkit/_cdf_tk/commands/run.py,sha256=JyX9jLEQej9eRrHVCCNlw4GuF80qETSol3-T5CCofgw,37331
 cognite_toolkit/_cdf_tk/commands/_migrate/__init__.py,sha256=i5ldcTah59K0E4fH5gHTV0GRvtDCEvVses9WQzn9Lno,226
 cognite_toolkit/_cdf_tk/commands/_migrate/canvas.py,sha256=R-z0yfOFcJZj-zRLhN-7z_-SLxqzSmONMgrbzNF9dGs,8843
-cognite_toolkit/_cdf_tk/commands/_migrate/command.py,sha256=Kdv3Tgg8vqywljVLfie-jJXoZ8fRIxTXzpdCHT0utRs,14096
+cognite_toolkit/_cdf_tk/commands/_migrate/command.py,sha256=l2P0Em05aEJvNZH4WkEIm-QfO3TAjG1rc_YxELuQIQM,14214
 cognite_toolkit/_cdf_tk/commands/_migrate/conversion.py,sha256=Ew9JRYrd-Ol9G9csTzpnhXAgCFnX67MwDYOTsdJLP3E,16803
 cognite_toolkit/_cdf_tk/commands/_migrate/creators.py,sha256=FTu7w3G8KyPY8pagG3KdPpOmpLcjehaAg2auEy6iM7A,9605
 cognite_toolkit/_cdf_tk/commands/_migrate/data_classes.py,sha256=_vMS_qAPj4yup1VnmmojPVigAZtyPQH7PM0Raby5tao,10619
@@ -244,20 +244,20 @@ cognite_toolkit/_cdf_tk/resource_classes/robotics/location.py,sha256=dbc9HT-bc2Q
 cognite_toolkit/_cdf_tk/resource_classes/robotics/map.py,sha256=j77z7CzCMiMj8r94BdUKCum9EuZRUjaSlUAy9K9DL_Q,942
 cognite_toolkit/_cdf_tk/storageio/__init__.py,sha256=h5Wr4i7zNIgsslrsRJxmp7ls4bNRKl0uZzQ7GLRMP7g,1920
 cognite_toolkit/_cdf_tk/storageio/_annotations.py,sha256=JI_g18_Y9S7pbc9gm6dZMyo3Z-bCndJXF9C2lOva0bQ,4848
-cognite_toolkit/_cdf_tk/storageio/_applications.py,sha256=vena8BW7erki6i-hGdcdiOmDbMU3P9M_Kn_5dPG6Yzw,16084
+cognite_toolkit/_cdf_tk/storageio/_applications.py,sha256=VlTRHqp8jVu16SW7LtrN05BNYZHSPtJ_wf9EsBAAsvE,16419
 cognite_toolkit/_cdf_tk/storageio/_asset_centric.py,sha256=GZZSQ8NLCP8tSQKOc8BUb2NCZAvw_BoCVcA1Og7vnIs,30821
 cognite_toolkit/_cdf_tk/storageio/_base.py,sha256=ElvqhIEBnhcz0yY1Ds164wVN0_7CFNK-uT0-z7LcR9U,13067
 cognite_toolkit/_cdf_tk/storageio/_data_classes.py,sha256=s3TH04BJ1q7rXndRhEbVMEnoOXjxrGg4n-w9Z5uUL-o,3480
-cognite_toolkit/_cdf_tk/storageio/_datapoints.py,sha256=AGTQm9CBRbu1oXbBh0X7UGzFrHnlWZExqNvAohT0hM0,8641
+cognite_toolkit/_cdf_tk/storageio/_datapoints.py,sha256=xE1YgoP98-mJjIeF5536KwChzhVY90KYl-bW5sRVhFQ,20206
 cognite_toolkit/_cdf_tk/storageio/_file_content.py,sha256=qcJDk7YGUZ7YmVTYUDAi8eOK2sozEoxmehpmWrA45Ak,17127
 cognite_toolkit/_cdf_tk/storageio/_instances.py,sha256=t9fNpHnT6kCk8LDoPj3qZXmHpyDbPF5BZ6pI8ziTyFw,10810
 cognite_toolkit/_cdf_tk/storageio/_raw.py,sha256=pgZN5MbqDwMZl9Ow1KouDJUO2Ngga8_b6hwv7H31SVQ,5161
-cognite_toolkit/_cdf_tk/storageio/selectors/__init__.py,sha256=eJkVXJpXt9iWRppO8kMyZB2Er6prCiVc0-48tZnjKbY,2312
+cognite_toolkit/_cdf_tk/storageio/selectors/__init__.py,sha256=VUK1A76zsu4a25A3oaPUrQEEuRcCpUBK6o8UMMKw7qg,2458
 cognite_toolkit/_cdf_tk/storageio/selectors/_asset_centric.py,sha256=7Iv_ccVX6Vzt3ZLFZ0Er3hN92iEsFTm9wgF-yermOWE,1467
 cognite_toolkit/_cdf_tk/storageio/selectors/_base.py,sha256=hjFkbmNGsK3QIW-jnJV_8YNmvVROERxzG82qIZhU7SM,3065
 cognite_toolkit/_cdf_tk/storageio/selectors/_canvas.py,sha256=E9S-wr-JUqRosI_2cSCfR0tF8MdIFTrMxDItuWRcuO4,597
 cognite_toolkit/_cdf_tk/storageio/selectors/_charts.py,sha256=lQHuNtF3i6SEIMPAlziMm0QlqRcvZJ7MKIug6HMTDrs,1012
-cognite_toolkit/_cdf_tk/storageio/selectors/_datapoints.py,sha256=tMdSa-xj_Mf94SwGE8E1I4l_UpioK9OvE8vA8SbBeqY,1719
+cognite_toolkit/_cdf_tk/storageio/selectors/_datapoints.py,sha256=qdR9wttPUoHZIRQjt2RiLO0cPH8C4CD09GsH1KA5KF4,2343
 cognite_toolkit/_cdf_tk/storageio/selectors/_file_content.py,sha256=A2ikNImKTC-WuG5c-WLEJ6LfaB7FytXS57-D2ORuA1k,5326
 cognite_toolkit/_cdf_tk/storageio/selectors/_instances.py,sha256=NCFSJrAw52bNX6UTfOali8PvNjlqHnvxzL0hYBr7ZmA,4934
 cognite_toolkit/_cdf_tk/storageio/selectors/_raw.py,sha256=sZq9C4G9DMe3S46_usKet0FphQ6ow7cWM_PfXrEAakk,503
@@ -297,7 +297,7 @@ cognite_toolkit/_cdf_tk/utils/fileio/_readers.py,sha256=IjOSHyW0GiID_lKdgAwQZao9
 cognite_toolkit/_cdf_tk/utils/fileio/_writers.py,sha256=mc23m0kJgl57FUDvwLmS7yR3xVZWQguPJa_63-qQ_L0,17731
 cognite_toolkit/_cdf_tk/utils/http_client/__init__.py,sha256=G8b7Bg4yIet5R4Igh3dS2SntWzE6I0iTGBeNlNsSxkQ,857
 cognite_toolkit/_cdf_tk/utils/http_client/_client.py,sha256=NTRfloXkCiS_rl5Vl1D_hsyTTowMKWDsiIR4oGwTADI,11208
-cognite_toolkit/_cdf_tk/utils/http_client/_data_classes.py,sha256=wbSDEtd4tXPwYp4VOKaasbz6WD3DlVpmUHroD1TjmUc,14313
+cognite_toolkit/_cdf_tk/utils/http_client/_data_classes.py,sha256=6A4qinERG2MhnmNlYogfi0La4Y7Kk19_Mn4QDmg5QHQ,14779
 cognite_toolkit/_cdf_tk/utils/http_client/_exception.py,sha256=fC9oW6BN0HbUe2AkYABMP7Kj0-9dNYXVFBY5RQztq2c,126
 cognite_toolkit/_cdf_tk/utils/http_client/_tracker.py,sha256=EBBnd-JZ7nc_jYNFJokCHN2UZ9sx0McFLZvlceUYYic,1215
 cognite_toolkit/_repo_files/.env.tmpl,sha256=UmgKZVvIp-OzD8oOcYuwb_6c7vSJsqkLhuFaiVgK7RI,972
@@ -305,13 +305,13 @@ cognite_toolkit/_repo_files/.gitignore,sha256=ip9kf9tcC5OguF4YF4JFEApnKYw0nG0vPi
 cognite_toolkit/_repo_files/AzureDevOps/.devops/README.md,sha256=OLA0D7yCX2tACpzvkA0IfkgQ4_swSd-OlJ1tYcTBpsA,240
 cognite_toolkit/_repo_files/AzureDevOps/.devops/deploy-pipeline.yml,sha256=brULcs8joAeBC_w_aoWjDDUHs3JheLMIR9ajPUK96nc,693
 cognite_toolkit/_repo_files/AzureDevOps/.devops/dry-run-pipeline.yml,sha256=OBFDhFWK1mlT4Dc6mDUE2Es834l8sAlYG50-5RxRtHk,723
-cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml,sha256=tQGFHkGPl1tMrbL7-zREOly0-pNGJOcuCQ6Jm0QNOi4,667
-cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml,sha256=Xyt9kh70zNHddbMwusNlKPUdmfu8A4hzEAzpyw7_uCM,2430
-cognite_toolkit/_resources/cdf.toml,sha256=Qg_SSteYWDQezqeetdDQSiTKqxSfBKZ59Mi6afqpFwM,475
+cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml,sha256=EUzITcPyar_jQHyPpumj-oz8Wh29jxcxyuHGWgEacyI,667
+cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml,sha256=8dZ8qd7ULG37B1OZSolqH1YWjRlQnOIozjz9d633z5A,2430
+cognite_toolkit/_resources/cdf.toml,sha256=MCLdFpOFpEYVnJyvVUyEQp-oOnKFrsnCkxIBxsmakjw,475
 cognite_toolkit/demo/__init__.py,sha256=-m1JoUiwRhNCL18eJ6t7fZOL7RPfowhCuqhYFtLgrss,72
 cognite_toolkit/demo/_base.py,sha256=6xKBUQpXZXGQ3fJ5f7nj7oT0s2n7OTAGIa17ZlKHZ5U,8052
-cognite_toolkit-0.7.16.dist-info/METADATA,sha256=FpUqVqIV2gkmQBL3ArJIHpC-mjmOAF5fs0gL4h56GZA,4501
-cognite_toolkit-0.7.16.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-cognite_toolkit-0.7.16.dist-info/entry_points.txt,sha256=JlR7MH1_UMogC3QOyN4-1l36VbrCX9xUdQoHGkuJ6-4,83
-cognite_toolkit-0.7.16.dist-info/licenses/LICENSE,sha256=CW0DRcx5tL-pCxLEN7ts2S9g2sLRAsWgHVEX4SN9_Mc,752
-cognite_toolkit-0.7.16.dist-info/RECORD,,
+cognite_toolkit-0.7.17.dist-info/METADATA,sha256=KYWmME0vzKZxaYwIG8MBMW9V746d9Ndb1RTiTd_KqMY,4501
+cognite_toolkit-0.7.17.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+cognite_toolkit-0.7.17.dist-info/entry_points.txt,sha256=JlR7MH1_UMogC3QOyN4-1l36VbrCX9xUdQoHGkuJ6-4,83
+cognite_toolkit-0.7.17.dist-info/licenses/LICENSE,sha256=CW0DRcx5tL-pCxLEN7ts2S9g2sLRAsWgHVEX4SN9_Mc,752
+cognite_toolkit-0.7.17.dist-info/RECORD,,