cognite-toolkit 0.6.116__tar.gz → 0.6.118__tar.gz

{cognite_toolkit-0.6.116 → cognite_toolkit-0.6.118}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.6.116
+Version: 0.6.118
 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.6.116 → cognite_toolkit-0.6.118}/cdf.toml

@@ -33,7 +33,7 @@ dev = 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.6.116"
+version = "0.6.118"
 
 
 [library.toolkit-data]

{cognite_toolkit-0.6.116 → cognite_toolkit-0.6.118}/cognite_toolkit/_cdf_tk/storageio/_applications.py

@@ -8,6 +8,7 @@ from cognite_toolkit._cdf_tk.client.data_classes.charts import Chart, ChartList,
 from cognite_toolkit._cdf_tk.exceptions import ToolkitNotImplementedError
 from cognite_toolkit._cdf_tk.tk_warnings import MediumSeverityWarning
 from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, HTTPMessage, SimpleBodyRequest
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
 from ._base import Page, UploadableStorageIO, UploadItem
@@ -159,6 +160,28 @@ class CanvasIO(UploadableStorageIO[CanvasSelector, IndustrialCanvas, IndustrialC
             raise ToolkitNotImplementedError(f"Unsupported selector type {type(selector).__name__!r} for CanvasIO")
         return len(selector.external_ids)
 
+    def upload_items(
+        self,
+        data_chunk: Sequence[UploadItem[IndustrialCanvasApply]],
+        http_client: HTTPClient,
+        selector: CanvasSelector | None = None,
+    ) -> Sequence[HTTPMessage]:
+        config = http_client.config
+        results: list[HTTPMessage] = []
+        for item in data_chunk:
+            instances = item.item.as_instances()
+            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]},
+                )
+            )
+            results.extend(responses.as_item_responses(item.source_id))
+
+        return results
+
     def data_to_json_chunk(
         self, data_chunk: Sequence[IndustrialCanvas], selector: CanvasSelector | None = None
     ) -> list[dict[str, JsonVal]]:

cognite_toolkit-0.6.118/cognite_toolkit/_cdf_tk/storageio/_file_content.py

@@ -0,0 +1,252 @@
+import json
+import mimetypes
+from collections.abc import Iterable, MutableSequence, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import cast
+
+from cognite.client.data_classes import FileMetadata, FileMetadataWrite
+from cognite.client.data_classes.data_modeling import NodeId, ViewId
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.cruds import FileMetadataCRUD
+from cognite_toolkit._cdf_tk.exceptions import ToolkitNotImplementedError
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
+from cognite_toolkit._cdf_tk.utils.fileio import MultiFileReader
+from cognite_toolkit._cdf_tk.utils.http_client import (
+    DataBodyRequest,
+    ErrorDetails,
+    FailedResponse,
+    FailedResponseItems,
+    HTTPClient,
+    HTTPMessage,
+    ResponseList,
+    SimpleBodyRequest,
+)
+from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
+
+from ._base import Page, UploadableStorageIO, UploadItem
+from .selectors import FileContentSelector, FileMetadataTemplateSelector
+from .selectors._file_content import FILEPATH, FileDataModelingTemplateSelector
+
+COGNITE_FILE_VIEW = ViewId("cdf_cdm", "CogniteFile", "v1")
+
+
+@dataclass
+class UploadFileContentItem(UploadItem[FileMetadataWrite]):
+    file_path: Path
+    mime_type: str
+
+
+class FileContentIO(UploadableStorageIO[FileContentSelector, FileMetadata, FileMetadataWrite]):
+    SUPPORTED_DOWNLOAD_FORMATS = frozenset({".ndjson"})
+    SUPPORTED_COMPRESSIONS = frozenset({".gz"})
+    CHUNK_SIZE = 10
+    BASE_SELECTOR = FileContentSelector
+    KIND = "FileContent"
+    SUPPORTED_READ_FORMATS = frozenset({".ndjson"})
+    UPLOAD_ENDPOINT = "/files"
+
+    def __init__(self, client: ToolkitClient) -> None:
+        super().__init__(client)
+        self._crud = FileMetadataCRUD(client, None, None)
+
+    def as_id(self, item: FileMetadata) -> str:
+        return item.external_id or str(item.id)
+
+    def stream_data(self, selector: FileContentSelector, limit: int | None = None) -> Iterable[Page]:
+        raise NotImplementedError("Download of FileContent is not yet supported")
+
+    def count(self, selector: FileContentSelector) -> int | None:
+        return None
+
+    def data_to_json_chunk(
+        self, data_chunk: Sequence[FileMetadata], selector: FileContentSelector | None = None
+    ) -> list[dict[str, JsonVal]]:
+        raise NotImplementedError("Download of FileContent is not yet supported")
+
+    def json_chunk_to_data(self, data_chunk: list[tuple[str, dict[str, JsonVal]]]) -> Sequence[UploadFileContentItem]:
+        """Convert a JSON-compatible chunk of data back to a writable Cognite resource list.
+
+        Args:
+            data_chunk: A list of tuples, each containing a source ID and a dictionary representing
+                the data in a JSON-compatible format.
+        Returns:
+            A writable Cognite resource list representing the data.
+        """
+        result: list[UploadFileContentItem] = []
+        for source_id, item_json in data_chunk:
+            item = self.json_to_resource(item_json)
+            filepath = cast(Path, item_json[FILEPATH])
+            mime_type, _ = mimetypes.guess_type(filepath)
+            # application/octet-stream is the standard fallback for binary data when the type is unknown. (at least Claude thinks so)
+            result.append(
+                UploadFileContentItem(
+                    source_id=source_id,
+                    item=item,
+                    file_path=filepath,
+                    mime_type=mime_type or "application/octet-stream",
+                )
+            )
+        return result
+
+    def json_to_resource(self, item_json: dict[str, JsonVal]) -> FileMetadataWrite:
+        return self._crud.load_resource(item_json)
+
+    def upload_items(
+        self,
+        data_chunk: Sequence[UploadItem[FileMetadataWrite]],
+        http_client: HTTPClient,
+        selector: FileContentSelector | None = None,
+    ) -> Sequence[HTTPMessage]:
+        results: MutableSequence[HTTPMessage] = []
+        if isinstance(selector, FileMetadataTemplateSelector):
+            upload_url_getter = self._upload_url_asset_centric
+        elif isinstance(selector, FileDataModelingTemplateSelector):
+            upload_url_getter = self._upload_url_data_modeling
+        elif selector is None:
+            raise ToolkitNotImplementedError("Selector must be provided for FileContentIO upload")
+        else:
+            raise ToolkitNotImplementedError(
+                f"Upload for the given selector, {type(selector).__name__}, is not supported for FileContentIO"
+            )
+
+        for item in cast(Sequence[UploadFileContentItem], data_chunk):
+            if not (upload_url := upload_url_getter(item, http_client, results)):
+                continue
+
+            upload_response = http_client.request_with_retries(
+                message=DataBodyRequest(
+                    endpoint_url=upload_url,
+                    method="PUT",
+                    content_type=item.mime_type,
+                    data_content=item.file_path.read_bytes(),
+                )
+            )
+            results.extend(upload_response.as_item_responses(item.as_id()))
+        return results
+
+    def _upload_url_asset_centric(
+        self, item: UploadFileContentItem, http_client: HTTPClient, results: MutableSequence[HTTPMessage]
+    ) -> str | None:
+        responses = http_client.request_with_retries(
+            message=SimpleBodyRequest(
+                endpoint_url=http_client.config.create_api_url(self.UPLOAD_ENDPOINT),
+                method="POST",
+                # MyPy does not understand that .dump is valid json
+                body_content=item.dump(),  # type: ignore[arg-type]
+            )
+        )
+        return self._parse_upload_link_response(responses, item, results)
+
+    def _upload_url_data_modeling(
+        self,
+        item: UploadFileContentItem,
+        http_client: HTTPClient,
+        results: MutableSequence[HTTPMessage],
+        created_node: bool = False,
+    ) -> str | None:
+        """Get upload URL for data modeling file upload.
+
+        We first try to get the upload link assuming the CogniteFile node already exists.
+        If we get a "not found" error, we create the CogniteFile node and try again.
+
+        Args:
+            item: The upload item containing file metadata.
+            http_client: The HTTP client to use for requests.
+            results: A mutable sequence to collect HTTP messages and errors.
+            created_node: A flag indicating whether the CogniteFile node has already been created.
+                This prevents infinite recursion.
+
+        Returns:
+            The upload URL as a string, or None if there was an error.
+
+        """
+        # We know that instance_id is always set for data modeling uploads
+        instance_id = cast(NodeId, item.item.instance_id)
+        responses = http_client.request_with_retries(
+            message=SimpleBodyRequest(
+                endpoint_url=http_client.config.create_api_url("/files/uploadlink"),
+                method="POST",
+                body_content={"items": [{"instanceId": instance_id.dump(include_instance_type=False)}]},  # type: ignore[dict-item]
+            )
+        )
+        # We know there is only one response since we only requested one upload link
+        response = responses[0]
+        if isinstance(response, FailedResponse) and response.error.missing and not created_node:
+            if self._create_cognite_file_node(instance_id, http_client, item.as_id(), results):
+                return self._upload_url_data_modeling(item, http_client, results, created_node=True)
+            else:
+                return None
+
+        return self._parse_upload_link_response(responses, item, results)
+
+    @classmethod
+    def _create_cognite_file_node(
+        cls, instance_id: NodeId, http_client: HTTPClient, upload_id: str, results: MutableSequence[HTTPMessage]
+    ) -> bool:
+        node_creation = http_client.request_with_retries(
+            message=SimpleBodyRequest(
+                endpoint_url=http_client.config.create_api_url("/models/instances"),
+                method="POST",
+                body_content={
+                    "items": [
+                        {
+                            "space": instance_id.space,
+                            "externalId": instance_id.external_id,
+                            "instanceType": "node",
+                            # When we create a node with properties in CogniteFile View even with empty properties,
+                            # CDF will fill in empty values for all properties defined in the view (note this is only
+                            # possible because CogniteFile view has all properties as optional). This includes properties
+                            # in the CogniteFile container, which will trigger the file syncer to create a FileMetadata
+                            # and link it to the CogniteFile node.
+                            "sources": [{"source": COGNITE_FILE_VIEW.dump(include_type=True), "properties": {}}],  # type: ignore[dict-item]
+                        }
+                    ]
+                },
+            )
+        )
+        try:
+            _ = node_creation.get_first_body()
+        except ValueError:
+            results.extend(node_creation.as_item_responses(upload_id))
+            return False
+        return True
+
+    @classmethod
+    def _parse_upload_link_response(
+        cls, responses: ResponseList, item: UploadFileContentItem, results: MutableSequence[HTTPMessage]
+    ) -> str | None:
+        try:
+            body = responses.get_first_body()
+        except ValueError:
+            results.extend(responses.as_item_responses(item.as_id()))
+            return None
+
+        if "items" in body and isinstance(body["items"], list) and len(body["items"]) > 0:
+            body = body["items"][0]  # type: ignore[assignment]
+        try:
+            upload_url = cast(str, body["uploadUrl"])
+        except (KeyError, IndexError):
+            results.append(
+                FailedResponseItems(
+                    status_code=200,
+                    body=json.dumps(body),
+                    error=ErrorDetails(code=200, message="Malformed response"),
+                    ids=[item.as_id()],
+                )
+            )
+            return None
+        return upload_url
+
+    @classmethod
+    def read_chunks(
+        cls, reader: MultiFileReader, selector: FileContentSelector
+    ) -> Iterable[list[tuple[str, dict[str, JsonVal]]]]:
+        for chunk in chunker_sequence(reader.input_files, cls.CHUNK_SIZE):
+            batch: list[tuple[str, dict[str, JsonVal]]] = []
+            for file_path in chunk:
+                metadata = selector.create_instance(file_path)
+                metadata[FILEPATH] = file_path
+                batch.append((str(file_path), metadata))
+            yield batch

{cognite_toolkit-0.6.116 → cognite_toolkit-0.6.118}/cognite_toolkit/_cdf_tk/storageio/selectors/__init__.py

@@ -15,6 +15,7 @@ from ._datapoints import (
 )
 from ._file_content import (
     FileContentSelector,
+    FileDataModelingTemplate,
     FileDataModelingTemplateSelector,
     FileMetadataTemplate,
     FileMetadataTemplateSelector,
@@ -64,6 +65,7 @@ __all__ = [
     "DataSetSelector",
     "ExternalIdColumn",
     "FileContentSelector",
+    "FileDataModelingTemplate",
     "FileDataModelingTemplateSelector",
     "FileMetadataTemplate",
     "FileMetadataTemplateSelector",

{cognite_toolkit-0.6.116 → cognite_toolkit-0.6.118}/cognite_toolkit/_cdf_tk/storageio/selectors/_file_content.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, Literal
 
-from pydantic import ConfigDict, field_validator
+from pydantic import ConfigDict, field_validator, model_validator
 
 from ._base import DataSelector, SelectorObject
 from ._instances import SelectedView
@@ -64,7 +64,7 @@ class FileMetadataTemplateSelector(FileContentSelector):
         return self.template.create_instance(filepath.name)
 
 
-class FileDataModelingTemplate(FileTemplate):
+class TemplateNodeId(SelectorObject):
     space: str
     external_id: str
 
@@ -79,9 +79,23 @@ class FileDataModelingTemplate(FileTemplate):
         return v
 
 
+class FileDataModelingTemplate(FileTemplate):
+    instance_id: TemplateNodeId
+    # Name is required for FileMetadata but not for CogniteFiles. This is the same default behavior as in CDF.
+    name: str = "untitled"
+
+    @model_validator(mode="before")
+    def _move_space_external_id(cls, data: dict[str, Any]) -> dict[str, Any]:
+        if "space" in data and "externalId" in data:
+            data["instanceId"] = {"space": data.pop("space"), "externalId": data.pop("externalId")}
+        elif "space" in data and "external_id" in data:
+            data["instance_id"] = {"space": data.pop("space"), "external_id": data.pop("external_id")}
+        return data
+
+
 class FileDataModelingTemplateSelector(FileContentSelector):
     type: Literal["fileDataModelingTemplate"] = "fileDataModelingTemplate"
-    view_id: SelectedView
+    view_id: SelectedView = SelectedView(space="cdf_cdm", external_id="CogniteFile", version="v1")
     template: FileDataModelingTemplate
 
     @property

{cognite_toolkit-0.6.116 → cognite_toolkit-0.6.118}/cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

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

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

{cognite_toolkit-0.6.116 → cognite_toolkit-0.6.118}/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.6.116"
+version = "0.6.118"
 
 [alpha_flags]
 external-libraries = true

cognite_toolkit-0.6.118/cognite_toolkit/_version.py

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

cognite_toolkit-0.6.118/last_changelog_entry.md

@@ -0,0 +1,5 @@
+## Changelog 
+
+### Added
+
+- [alpha] The upload command, `cdf data upload` now support canvas.

cognite_toolkit-0.6.118/last_git_message.txt

@@ -0,0 +1,19 @@
+[CDF-24746] 🧑‍🎨Upload canvas (#2227)
+
+# Description
+
+<img width="908" height="701" alt="image"
+src="https://github.com/user-attachments/assets/c6e17dea-6ed3-4ca3-9460-3487df75ff79"
+/>
+
+## Bump
+
+- [x] Patch
+- [ ] Skip
+
+## Changelog
+
+### Added
+
+- [alpha] The upload command, `cdf data upload` now support canvas.
+

cognite_toolkit-0.6.118/last_version.txt

@@ -0,0 +1 @@
+0.6.117

{cognite_toolkit-0.6.116 → cognite_toolkit-0.6.118}/pyproject.toml

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

cognite_toolkit-0.6.118/tests/test_integration/test_storageio/test_applications.py

@@ -0,0 +1,108 @@
+from typing import Any
+
+import pytest
+from cognite.client.data_classes import DataSet, Event, EventWrite
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.storageio import CanvasIO
+from cognite_toolkit._cdf_tk.utils import humanize_collection
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, SuccessResponse
+
+
+@pytest.fixture
+def canvas_event(toolkit_client: ToolkitClient, toolkit_dataset: DataSet) -> Event:
+    event = EventWrite(
+        external_id="canvas_event_integration_test",
+        start_time=1_600_000_000_000,
+        end_time=1_600_000_360_000,
+        data_set_id=toolkit_dataset.id,
+        description="Integration test event for canvas",
+        type="canvas_test_event",
+        subtype="canvas_test_event",
+    )
+    if existing := toolkit_client.events.retrieve(external_id=event.external_id):
+        return existing
+    created_event = toolkit_client.events.create(event)
+    return created_event
+
+
+@pytest.fixture
+def canvas_raw_data(canvas_event: Event) -> dict[str, Any]:
+    user_id = "ndTFZh9K9-m2W9WBKc30-Q"
+    canvas_id = "70c66b27-c16e-4f6c-bc1e-940f086ec2f7"
+    event_ref = "167ab784-9f33-4130-831e-91d820359ce9"
+    return {
+        "canvas": {
+            "externalId": canvas_id,
+            "instanceType": "node",
+            "space": "IndustrialCanvasInstanceSpace",
+            "sources": [
+                {
+                    "source": {
+                        "space": "cdf_industrial_canvas",
+                        "externalId": "Canvas",
+                        "version": "v7",
+                        "type": "view",
+                    },
+                    "properties": {
+                        "createdBy": user_id,
+                        "isLocked": None,
+                        "visibility": "public",
+                        "sourceCanvasId": None,
+                        "isArchived": None,
+                        "context": [{"type": "FILTERS", "payload": {"filters": []}}],
+                        "name": "Toolkit Integration Test Canvas",
+                        "solutionTags": None,
+                        "updatedAt": "2025-11-23T08:09:13.183+00:00",
+                        "updatedBy": user_id,
+                    },
+                }
+            ],
+        },
+        "containerReferences": [
+            {
+                "externalId": f"{canvas_id}_{event_ref}",
+                "instanceType": "node",
+                "space": "IndustrialCanvasInstanceSpace",
+                "sources": [
+                    {
+                        "source": {
+                            "space": "cdf_industrial_canvas",
+                            "externalId": "ContainerReference",
+                            "version": "v2",
+                            "type": "view",
+                        },
+                        "properties": {
+                            "chartsId": None,
+                            "containerReferenceType": "event",
+                            "height": 500,
+                            "id": event_ref,
+                            "label": "canvas_test_event: canvas_event_integration_test",
+                            "properties": {"zIndex": 0, "unscaledWidth": 600, "unscaledHeight": 500},
+                            "maxHeight": None,
+                            "maxWidth": None,
+                            "resourceExternalId": canvas_event.external_id,
+                            "resourceSubId": None,
+                            "width": 600,
+                            "x": -10,
+                            "y": 418,
+                        },
+                    }
+                ],
+            },
+        ],
+    }
+
+
+class TestCanvasIO:
+    def test_upload_canvas(self, toolkit_client: ToolkitClient, canvas_raw_data: dict[str, Any]) -> None:
+        io = CanvasIO(toolkit_client)
+        upload_items = io.json_chunk_to_data([("canvas_data.json", canvas_raw_data)])
+
+        assert len(upload_items) == 1
+
+        with HTTPClient(toolkit_client.config) as http_client:
+            upload_result = io.upload_items(upload_items, http_client)
+
+        not_success = [message for message in upload_result if not isinstance(message, SuccessResponse)]
+        assert len(not_success) == 0, f"Some canvas items failed to upload: {humanize_collection(not_success)}"

cognite_toolkit-0.6.118/tests/test_integration/test_storageio/test_filecontent.py

@@ -0,0 +1,101 @@
+import time
+from pathlib import Path
+
+from cognite.client.data_classes import FileMetadataWrite
+from cognite.client.data_classes.data_modeling import NodeId, Space
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.storageio import FileContentIO
+from cognite_toolkit._cdf_tk.storageio._file_content import UploadFileContentItem
+from cognite_toolkit._cdf_tk.storageio.selectors import (
+    FileDataModelingTemplate,
+    FileDataModelingTemplateSelector,
+    FileMetadataTemplate,
+    FileMetadataTemplateSelector,
+)
+from cognite_toolkit._cdf_tk.storageio.selectors._file_content import FILENAME_VARIABLE, TemplateNodeId
+from cognite_toolkit._cdf_tk.utils.fileio import MultiFileReader
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient
+from tests.test_integration.constants import RUN_UNIQUE_ID
+
+
+class TestFileContentIO:
+    def test_upload_file(self, toolkit_client: ToolkitClient, tmp_path: Path) -> None:
+        my_text_file = tmp_path / "my_file.txt"
+        my_text_file.write_text("This is some test content.", encoding="utf-8")
+        metadata = FileMetadataWrite(
+            name="my_file.txt",
+            external_id=f"test_upload_file_001_{RUN_UNIQUE_ID}",
+            source="TestUpload",
+        )
+
+        io = FileContentIO(toolkit_client)
+        try:
+            with HTTPClient(toolkit_client.config) as http_client:
+                io.upload_items(
+                    [
+                        UploadFileContentItem(
+                            source_id=my_text_file.name,
+                            item=metadata,
+                            file_path=my_text_file,
+                            mime_type="text/plain",
+                        )
+                    ],
+                    http_client,
+                    FileMetadataTemplateSelector(
+                        file_directory=Path("does not matter"),
+                        template=FileMetadataTemplate(name=FILENAME_VARIABLE, external_id=FILENAME_VARIABLE),
+                    ),
+                )
+            # Verify upload
+            uploaded_file = toolkit_client.files.retrieve(external_id=metadata.external_id)
+            assert uploaded_file is not None
+            assert uploaded_file.name == "my_file.txt"
+            assert uploaded_file.uploaded is True
+        finally:
+            # Clean up
+            toolkit_client.files.delete(external_id=metadata.external_id, ignore_unknown_ids=True)
+
+    def test_read_deserialize_upload_dm_file(
+        self, toolkit_client: ToolkitClient, tmp_path: Path, toolkit_space: Space
+    ) -> None:
+        external_id = f"test_upload_dm_file_001_{RUN_UNIQUE_ID}.txt"
+        my_text_file = tmp_path / external_id
+        my_text_file.write_text("This is some test content for data modeling.", encoding="utf-8")
+        instance_id = NodeId(space=toolkit_space.space, external_id=external_id)
+        selector = FileDataModelingTemplateSelector(
+            file_directory=tmp_path,
+            template=FileDataModelingTemplate(
+                instance_id=TemplateNodeId(
+                    space=toolkit_space.space,
+                    external_id=FILENAME_VARIABLE,
+                )
+            ),
+        )
+        io = FileContentIO(toolkit_client)
+        reader = MultiFileReader([my_text_file])
+
+        read_chunks = list(io.read_chunks(reader, selector))
+        assert len(read_chunks) == 1
+        read_chunk = read_chunks[0]
+
+        upload_content = io.json_chunk_to_data(read_chunk)
+        assert len(upload_content) == 1
+
+        try:
+            with HTTPClient(toolkit_client.config) as http_client:
+                io.upload_items(upload_content, http_client, selector)
+
+            t0 = time.perf_counter()
+            while True:
+                uploaded_file = toolkit_client.files.retrieve(instance_id=instance_id)
+                assert uploaded_file is not None
+                if uploaded_file.uploaded is True:
+                    break
+                # The file syncer may take some time to update CogniteFile -> FileMetadata uploaded status
+                if time.perf_counter() - t0 > 30:
+                    raise AssertionError("Timeout waiting for file to be uploaded.")
+                time.sleep(1)
+        finally:
+            # Clean up
+            toolkit_client.data_modeling.instances.delete(nodes=instance_id)

{cognite_toolkit-0.6.116 → cognite_toolkit-0.6.118}/uv.lock

@@ -272,7 +272,7 @@ wheels = [
 
 [[package]]
 name = "cognite-toolkit"
-version = "0.6.116"
+version = "0.6.118"
 source = { editable = "." }
 dependencies = [
     { name = "cognite-sdk" },