cognite-toolkit 0.7.50__tar.gz → 0.7.51__tar.gz

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/PKG-INFO

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

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -21,6 +21,7 @@ from .api.extraction_pipelines import ExtractionPipelinesAPI
 from .api.filemetadata import FileMetadataAPI
 from .api.hosted_extractors import HostedExtractorsAPI
 from .api.infield import InfieldAPI
+from .api.instances import InstancesAPI
 from .api.labels import LabelsAPI
 from .api.lookup import LookUpGroup
 from .api.migration import MigrationAPI
@@ -51,6 +52,7 @@ class ToolAPI:
         self.events = EventsAPI(http_client)
         self.extraction_pipelines = ExtractionPipelinesAPI(http_client)
         self.hosted_extractors = HostedExtractorsAPI(http_client)
+        self.instances = InstancesAPI(http_client)
         self.labels = LabelsAPI(http_client)
         self.filemetadata = FileMetadataAPI(http_client)
         self.raw = RawAPI(http_client)

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/cognite_toolkit/_cdf_tk/client/api/legacy/canvas.py

@@ -83,7 +83,7 @@ class IndustrialCanvasAPI:
     def create(self, canvas: IndustrialCanvasApply) -> InstancesApplyResultList:
         instance_ids = canvas.as_instance_ids()
         existing = self._instance_api.retrieve(
-            [node for node in instance_ids if isinstance(node, NodeId)],
+            nodes=[node for node in instance_ids if isinstance(node, NodeId)],
             edges=[edge for edge in instance_ids if isinstance(edge, EdgeId)],
         )
         if existing.nodes or existing.edges:

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/cognite_toolkit/_cdf_tk/client/http_client/_client.py

@@ -336,7 +336,11 @@ class HTTPClient:
 
     def _make_request2(self, message: BaseRequestMessage) -> httpx.Response:
         headers = self._create_headers(
-            message.api_version, message.content_type, message.accept, disable_gzip=message.disable_gzip
+            message.api_version,
+            message.content_type,
+            message.accept,
+            content_length=message.content_length,
+            disable_gzip=message.disable_gzip,
         )
         return self.session.request(
             method=message.method,

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/cognite_toolkit/_cdf_tk/client/http_client/_data_classes2.py

@@ -1,11 +1,20 @@
 import gzip
 from abc import ABC, abstractmethod
+from collections.abc import Hashable
 from typing import Any, Literal
 
 import httpx
 from cognite.client import global_config
 from pydantic import BaseModel, JsonValue, TypeAdapter, model_validator
 
+from cognite_toolkit._cdf_tk.client.http_client._data_classes import (
+    ErrorDetails,
+    FailedRequestItems,
+    FailedRequestMessage,
+    FailedResponseItems,
+    ResponseMessage,
+    SuccessResponseItems,
+)
 from cognite_toolkit._cdf_tk.client.http_client._exception import ToolkitAPIError
 from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
 
@@ -26,6 +35,29 @@ class HTTPResult2(BaseModel):
         else:
             raise ToolkitAPIError("Unknown HTTPResult2 type")
 
+    # Todo: Remove when HTTPResult2 is renamed to HTTPResponse and the old HTTPResponse is deleted
+    def as_item_response(self, item_id: Hashable) -> ResponseMessage | FailedRequestMessage:
+        if isinstance(self, SuccessResponse2):
+            return SuccessResponseItems(
+                status_code=self.status_code, content=self.content, ids=[item_id], body=self.body
+            )
+        elif isinstance(self, FailedResponse2):
+            return FailedResponseItems(
+                status_code=self.status_code,
+                ids=[item_id],
+                body=self.body,
+                error=ErrorDetails(
+                    code=self.error.code,
+                    message=self.error.message,
+                    missing=self.error.missing,
+                    duplicated=self.error.duplicated,
+                ),
+            )
+        elif isinstance(self, FailedRequest2):
+            return FailedRequestItems(ids=[item_id], error=self.error)
+        else:
+            raise ToolkitAPIError("Unknown HTTPResult2 type")
+
 
 class FailedRequest2(HTTPResult2):
     error: str
@@ -75,6 +107,7 @@ class BaseRequestMessage(BaseModel, ABC):
     status_attempt: int = 0
     api_version: str | None = None
     disable_gzip: bool = False
+    content_length: int | None = None
     content_type: str = "application/json"
     accept: str = "application/json"
 

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/cognite_toolkit/_cdf_tk/client/resource_classes/legacy/canvas.py

@@ -1,5 +1,6 @@
 import sys
 from abc import ABC
+from collections import defaultdict
 from collections.abc import Sequence
 from datetime import datetime, timezone
 from typing import Any, TypeVar
@@ -905,54 +906,86 @@ class IndustrialCanvasApply(CogniteResource):
                 raise TypeError(f"Unexpected instance type: {type(instance)}")
         return ids
 
-    def dump(self, keep_existing_version: bool = True) -> dict[str, JsonVal]:
+    def dump(self, camel_case: bool = True, keep_existing_version: bool = True) -> dict[str, JsonVal]:
         """Dump the IndustrialCanvasApply to a dictionary."""
         return {
-            "canvas": self.canvas.dump(keep_existing_version=keep_existing_version),
+            "canvas": self.canvas.dump(camel_case=camel_case, keep_existing_version=keep_existing_version),
             "annotations": [
-                annotation.dump(keep_existing_version=keep_existing_version) for annotation in self.annotations
+                annotation.dump(camel_case=camel_case, keep_existing_version=keep_existing_version)
+                for annotation in self.annotations
             ],
             "containerReferences": [
-                container_ref.dump(keep_existing_version=keep_existing_version)
+                container_ref.dump(camel_case=camel_case, keep_existing_version=keep_existing_version)
                 for container_ref in self.container_references
             ],
             "fdmInstanceContainerReferences": [
-                fdm_instance_container_ref.dump(keep_existing_version=keep_existing_version)
+                fdm_instance_container_ref.dump(camel_case=camel_case, keep_existing_version=keep_existing_version)
                 for fdm_instance_container_ref in self.fdm_instance_container_references
             ],
             "solutionTags": [
-                solution_tag.dump(keep_existing_version=keep_existing_version) for solution_tag in self.solution_tags
+                solution_tag.dump(camel_case=camel_case, keep_existing_version=keep_existing_version)
+                for solution_tag in self.solution_tags
             ],
         }
 
     def create_backup(self) -> "IndustrialCanvasApply":
-        """Create a duplicate of the IndustrialCanvasApply instance."""
+        """Create a backup copy of the IndustrialCanvasApply instance with new IDs."""
         new_canvas_id = str(uuid4())
+
         new_canvas = CanvasApply._load(self.canvas.dump(keep_existing_version=False))
         new_canvas.external_id = new_canvas_id
         new_canvas.source_canvas_id = self.canvas.external_id
         new_canvas.updated_at = datetime.now(tz=timezone.utc)
         # Solution tags are not duplicated, they are reused
-        new_container = IndustrialCanvasApply(new_canvas, [], [], [], solution_tags=self.solution_tags)
+        canvas_backup = IndustrialCanvasApply(new_canvas, [], [], [], solution_tags=self.solution_tags)
         items: list[ContainerReferenceApply] | list[CanvasAnnotationApply] | list[FdmInstanceContainerReferenceApply]
         item_cls: type[CanvasAnnotationApply] | type[ContainerReferenceApply] | type[FdmInstanceContainerReferenceApply]
         new_item_list: list[NodeApply]
+        generator: dict[str, str] = defaultdict(lambda: str(uuid4()))
         for items, item_cls, new_item_list in [  # type: ignore[assignment]
-            (self.annotations, CanvasAnnotationApply, new_container.annotations),
-            (self.container_references, ContainerReferenceApply, new_container.container_references),
+            (self.annotations, CanvasAnnotationApply, canvas_backup.annotations),
+            (self.container_references, ContainerReferenceApply, canvas_backup.container_references),
             (
                 self.fdm_instance_container_references,
                 FdmInstanceContainerReferenceApply,
-                new_container.fdm_instance_container_references,
+                canvas_backup.fdm_instance_container_references,
             ),
         ]:
             for item in items:
                 # Serialize the item to create a new instance
                 new_item = item_cls._load(item.dump(keep_existing_version=False))
-                new_item.id_ = str(uuid4())
-                new_item.external_id = f"{new_canvas_id}_{new_item.external_id}"
+                new_item.id_ = generator[new_item.id_]
+                new_item.external_id = f"{new_canvas_id}_{new_item.id_}"
                 new_item_list.append(new_item)
-        return new_container
+
+        return canvas_backup.replace_ids(generator)
+
+    def replace_ids(self, id_mapping_old_by_new: dict[str, str]) -> "IndustrialCanvasApply":
+        """Replace IDs in the IndustrialCanvasApply instance based on the provided ID mapping.
+
+        Args:
+            id_mapping_old_by_new: A dictionary mapping old IDs to new IDs.
+        Returns:
+            A new IndustrialCanvasApply instance with IDs replaced according to the mapping.
+        """
+        # There can be references to the old IDs in properties, for example, in annotations
+        # the properties field there can be fromId and toId set.
+        # We don't know all the places the Canvas application will have undocumented references,
+        # so we do a recursive search and replace based on the id mapping we have created.
+        dumped_data = self.dump(camel_case=True)
+
+        def _replace_ids_recursively(data: Any, id_map: dict[str, str]) -> Any:
+            if isinstance(data, dict):
+                return {key: _replace_ids_recursively(value, id_map) for key, value in data.items()}
+            if isinstance(data, list):
+                return [_replace_ids_recursively(item, id_map) for item in data]
+            if isinstance(data, str) and data in id_map:
+                return id_map[data]
+            return data
+
+        updated_data = _replace_ids_recursively(dumped_data, id_mapping_old_by_new)
+
+        return IndustrialCanvasApply._load(updated_data)
 
     @classmethod
     def _load(cls, resource: dict[str, Any], cognite_client: CogniteClient | None = None) -> Self:

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/cognite_toolkit/_cdf_tk/commands/_migrate/data_mapper.py

@@ -401,6 +401,7 @@ class CanvasMapper(DataMapper[CanvasSelector, IndustrialCanvas, IndustrialCanvas
 
         remaining_container_references: list[ContainerReferenceApply] = []
         new_fdm_references: list[FdmInstanceContainerReferenceApply] = []
+        uuid_generator: dict[str, str] = defaultdict(lambda: str(uuid4()))
         for ref in update.container_references or []:
             if ref.container_reference_type not in self.asset_centric_resource_types:
                 remaining_container_references.append(ref)
@@ -410,7 +411,9 @@ class CanvasMapper(DataMapper[CanvasSelector, IndustrialCanvas, IndustrialCanvas
                 issue.missing_reference_ids.append(ref.as_asset_centric_id())
             else:
                 consumer_view = self._get_consumer_view_id(ref.resource_id, ref.container_reference_type)
-                fdm_ref = self.migrate_container_reference(ref, canvas.canvas.external_id, node_id, consumer_view)
+                fdm_ref = self.migrate_container_reference(
+                    ref, canvas.canvas.external_id, node_id, consumer_view, uuid_generator
+                )
                 new_fdm_references.append(fdm_ref)
         if issue.missing_reference_ids and self.skip_on_missing_ref:
             return None, issue
@@ -426,14 +429,22 @@ class CanvasMapper(DataMapper[CanvasSelector, IndustrialCanvas, IndustrialCanvas
                     f"Failed to create backup for canvas '{canvas.canvas.name}': {e!s}. "
                 ) from e
 
+        # There might annotations or other components that reference the old IDs, so we need to update those as well.
+        update = update.replace_ids(uuid_generator)
+
         return update, issue
 
     @classmethod
     def migrate_container_reference(
-        cls, reference: ContainerReferenceApply, canvas_external_id: str, instance_id: NodeId, consumer_view: ViewId
+        cls,
+        reference: ContainerReferenceApply,
+        canvas_external_id: str,
+        instance_id: NodeId,
+        consumer_view: ViewId,
+        uuid_generator: dict[str, str],
     ) -> FdmInstanceContainerReferenceApply:
         """Migrate a single container reference by replacing the asset-centric ID with the data model instance ID."""
-        new_id = str(uuid4())
+        new_id = uuid_generator[reference.id_]
         new_external_id = f"{canvas_external_id}_{new_id}"
         return FdmInstanceContainerReferenceApply(
             external_id=new_external_id,

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/cognite_toolkit/_cdf_tk/commands/_migrate/migration_io.py

@@ -10,7 +10,7 @@ from cognite_toolkit._cdf_tk.client.http_client import (
     HTTPClient,
     HTTPMessage,
     ItemsRequest,
-    SimpleBodyRequest,
+    RequestMessage2,
     SuccessResponseItems,
     ToolkitAPIError,
 )
@@ -464,14 +464,14 @@ class ThreeDMigrationIO(UploadableStorageIO[ThreeDSelector, ThreeDModelResponse,
         for data in data_chunk:
             if data.source_id not in success_ids:
                 continue
-            revision = http_client.request_with_retries(
-                message=SimpleBodyRequest(
+            revision = http_client.request_single_retries(
+                message=RequestMessage2(
                     endpoint_url=self.client.config.create_api_url(self.REVISION_ENDPOINT),
                     method="POST",
                     body_content={"items": [data.item.revision.dump(camel_case=True)]},
                 )
             )
-            results.extend(revision.as_item_responses(data.source_id))
+            results.append(revision.as_item_response(data.source_id))
         return results
 
 

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/cognite_toolkit/_cdf_tk/storageio/_applications.py

@@ -1,8 +1,17 @@
 from collections.abc import Iterable, Sequence
+from itertools import zip_longest
 from typing import Any
 
+from pydantic import JsonValue
+
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.http_client import HTTPClient, HTTPMessage, SimpleBodyRequest
+from cognite_toolkit._cdf_tk.client.http_client import (
+    HTTPClient,
+    HTTPMessage,
+    HTTPResult2,
+    RequestMessage2,
+    SuccessResponse2,
+)
 from cognite_toolkit._cdf_tk.client.resource_classes.legacy.canvas import (
     IndustrialCanvas,
     IndustrialCanvasApply,
@@ -185,23 +194,52 @@ class CanvasIO(UploadableStorageIO[CanvasSelector, IndustrialCanvas, IndustrialC
         results: list[HTTPMessage] = []
         for item in data_chunk:
             instances = item.item.as_instances()
-            items: list[dict[str, JsonVal]] = []
+            upsert_items: list[dict[str, JsonValue]] = []
             for instance in instances:
                 dumped = instance.dump()
                 if self.exclude_existing_version:
                     dumped.pop("existingVersion", None)
-                items.append(dumped)
-
-            responses = http_client.request_with_retries(
-                message=SimpleBodyRequest(
-                    endpoint_url=config.create_api_url("/models/instances"),
-                    method="POST",
-                    # MyPy does not understand that .dump is valid json
-                    body_content={"items": items},  # type: ignore[dict-item]
-                )
-            )
-            results.extend(responses.as_item_responses(item.source_id))
+                upsert_items.append(dumped)
+
+            canvas = item.item.canvas
+            existing = self.client.canvas.industrial.retrieve(canvas.external_id)
+            if existing is not None:
+                existing_instance_ids = existing.as_write().as_instance_ids(include_solution_tags=False)
+                delete_set = set(existing_instance_ids) - set(item.item.as_instance_ids())
+                to_delete: list[Any] = [
+                    {
+                        "space": instance_id.space,
+                        "externalId": instance_id.external_id,
+                        "instanceType": instance_id.instance_type,
+                    }
+                    for instance_id in delete_set
+                ]
+            else:
+                to_delete = []
 
+            last_response: HTTPResult2 | None = None
+            for upsert_chunk, delete_chunk in zip_longest(
+                chunker_sequence(upsert_items, 1000), chunker_sequence(to_delete, 1000), fillvalue=None
+            ):
+                body_content: dict[str, JsonValue] = {}
+                if upsert_chunk:
+                    # MyPy fails do understand that list[dict[str, JsonValue]] is a subtype of JsonValue
+                    body_content["items"] = upsert_chunk  # type: ignore[assignment]
+                if delete_chunk:
+                    body_content["delete"] = delete_chunk
+
+                response = http_client.request_single_retries(
+                    message=RequestMessage2(
+                        endpoint_url=config.create_api_url("/models/instances"),
+                        method="POST",
+                        body_content=body_content,
+                    )
+                )
+                if not isinstance(response, SuccessResponse2):
+                    results.append(response.as_item_response(item.source_id))
+                last_response = response
+            if last_response is not None:
+                results.append(last_response.as_item_response(item.source_id))
         return results
 
     def data_to_json_chunk(

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/cognite_toolkit/_cdf_tk/storageio/_file_content.py

@@ -10,14 +10,15 @@ from cognite.client.data_classes.data_modeling import ViewId
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.http_client import (
-    DataBodyRequest,
     ErrorDetails,
-    FailedResponse,
+    FailedResponse2,
     FailedResponseItems,
     HTTPClient,
     HTTPMessage,
-    ResponseList,
+    HTTPResult2,
+    RequestMessage2,
     SimpleBodyRequest,
+    SuccessResponse2,
 )
 from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling import NodeReference
 from cognite_toolkit._cdf_tk.client.resource_classes.filemetadata import FileMetadataRequest, FileMetadataResponse
@@ -274,8 +275,8 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePat
                 continue
 
             content_bytes = item.file_path.read_bytes()
-            upload_response = http_client.request_with_retries(
-                message=DataBodyRequest(
+            upload_response = http_client.request_single_retries(
+                RequestMessage2(
                     endpoint_url=upload_url,
                     method="PUT",
                     content_type=item.mime_type,
@@ -283,21 +284,21 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePat
                     content_length=len(content_bytes),
                 )
             )
-            results.extend(upload_response.as_item_responses(item.as_id()))
+            results.append(upload_response.as_item_response(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(
+        response = http_client.request_single_retries(
+            message=RequestMessage2(
                 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)
+        return self._parse_upload_link_response(response, item, results)
 
     def _upload_url_data_modeling(
         self,
@@ -324,29 +325,27 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePat
         """
         # We know that instance_id is always set for data modeling uploads
         instance_id = cast(NodeReference, item.item.instance_id)
-        responses = http_client.request_with_retries(
-            message=SimpleBodyRequest(
+        response = http_client.request_single_retries(
+            message=RequestMessage2(
                 endpoint_url=http_client.config.create_api_url("/files/uploadlink"),
                 method="POST",
                 body_content={"items": [{"instanceId": instance_id.dump()}]},
             )
         )
-        # 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 isinstance(response, FailedResponse2) 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)
+        return self._parse_upload_link_response(response, item, results)
 
     @classmethod
     def _create_cognite_file_node(
         cls, instance_id: NodeReference, http_client: HTTPClient, upload_id: str, results: MutableSequence[HTTPMessage]
     ) -> bool:
-        node_creation = http_client.request_with_retries(
-            message=SimpleBodyRequest(
+        node_creation = http_client.request_single_retries(
+            message=RequestMessage2(
                 endpoint_url=http_client.config.create_api_url("/models/instances"),
                 method="POST",
                 body_content={
@@ -366,25 +365,33 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePat
                 },
             )
         )
-        try:
-            _ = node_creation.get_first_body()
-        except ValueError:
-            results.extend(node_creation.as_item_responses(upload_id))
-            return False
-        return True
+        if isinstance(node_creation, SuccessResponse2):
+            # Node created successfully
+            return True
+        results.append(node_creation.as_item_response(instance_id))
+        return False
 
     @classmethod
     def _parse_upload_link_response(
-        cls, responses: ResponseList, item: UploadFileContentItem, results: MutableSequence[HTTPMessage]
+        cls, response: HTTPResult2, item: UploadFileContentItem, results: MutableSequence[HTTPMessage]
     ) -> str | None:
+        if not isinstance(response, SuccessResponse2):
+            results.append(response.as_item_response(item.as_id()))
+            return None
         try:
-            body = responses.get_first_body()
+            body = response.body_json
         except ValueError:
-            results.extend(responses.as_item_responses(item.as_id()))
+            results.append(
+                FailedResponseItems(
+                    status_code=response.status_code,
+                    body=response.body,
+                    error=ErrorDetails(code=response.status_code, message="Invalid JSON response"),
+                    ids=[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]
+            body = body["items"][0]
         try:
             upload_url = cast(str, body["uploadUrl"])
         except (KeyError, IndexError):

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

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

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

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/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.50"
+version = "0.7.51"
 
 
 [plugins]

cognite_toolkit-0.7.51/cognite_toolkit/_version.py

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

{cognite_toolkit-0.7.50 → cognite_toolkit-0.7.51}/pyproject.toml

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

cognite_toolkit-0.7.50/cognite_toolkit/_version.py

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