cognite-toolkit 0.7.35__py3-none-any.whl → 0.7.37__py3-none-any.whl

cognite_toolkit/_cdf_tk/client/data_classes/three_d.py

@@ -1,5 +1,8 @@
+from collections.abc import Hashable
 from typing import Literal
 
+from pydantic import Field
+
 from .base import BaseModelObject, RequestResource, ResponseResource
 
 
@@ -51,3 +54,59 @@ class ThreeDModelResponse(ResponseResource[ThreeDModelRequest]):
             return ThreeDModelClassicRequest._load(self.dump())
         else:
             return ThreeDModelDMSRequest._load(self.dump())
+
+
+class AssetMappingDMRequest(RequestResource):
+    node_id: int
+    asset_instance_id: NodeReference
+    # These fields are part of the path request and not the body schema.
+    model_id: int = Field(exclude=True)
+    revision_id: int = Field(exclude=True)
+
+    def as_id(self) -> Hashable:
+        return (
+            self.model_id,
+            self.revision_id,
+            self.node_id,
+            self.asset_instance_id.space,
+            self.asset_instance_id.external_id,
+        )
+
+
+class AssetMappingClassicRequest(RequestResource):
+    node_id: int
+    asset_id: int | None = None
+    asset_instance_id: NodeReference | None = None
+    # These fields are part of the path request and not the body schema.
+    model_id: int = Field(exclude=True)
+    revision_id: int = Field(exclude=True)
+
+    def as_id(self) -> Hashable:
+        if self.asset_id:
+            return self.model_id, self.revision_id, self.node_id, self.asset_id
+        elif self.asset_instance_id:
+            return (
+                self.model_id,
+                self.revision_id,
+                self.node_id,
+                self.asset_instance_id.space,
+                self.asset_instance_id.external_id,
+            )
+        else:
+            raise AttributeError("asset_id or asset_instance_id is required")
+
+
+class AssetMappingResponse(ResponseResource[AssetMappingClassicRequest]):
+    node_id: int
+    asset_id: int | None = None
+    asset_instance_id: NodeReference | None = None
+    tree_index: int | None = None
+    subtree_size: int | None = None
+    # These fields are part of the path request and response, but they are included here for convenience.
+    model_id: int = Field(exclude=True)
+    revision_id: int = Field(exclude=True)
+
+    def as_request_resource(self) -> AssetMappingClassicRequest:
+        return AssetMappingClassicRequest.model_validate(
+            {**self.dump(), "modelId": self.model_id, "revisionId": self.revision_id}
+        )

cognite_toolkit/_cdf_tk/commands/_migrate/conversion.py

@@ -9,6 +9,7 @@ from cognite.client.data_classes.data_modeling import (
     MappedProperty,
     NodeApply,
     NodeId,
+    ViewId,
 )
 from cognite.client.data_classes.data_modeling.instances import EdgeApply, NodeOrEdgeData, PropertyValueWrite
 from cognite.client.data_classes.data_modeling.views import ViewProperty
@@ -29,7 +30,7 @@ from cognite_toolkit._cdf_tk.utils.useful_types import (
     AssetCentricTypeExtended,
 )
 
-from .data_model import INSTANCE_SOURCE_VIEW_ID
+from .data_model import COGNITE_MIGRATION_SPACE_ID, INSTANCE_SOURCE_VIEW_ID
 from .issues import ConversionIssue, FailedConversion, InvalidPropertyDataType
 
 
@@ -169,6 +170,7 @@ def asset_centric_to_dm(
     view_source: ResourceViewMappingApply,
     view_properties: dict[str, ViewProperty],
     direct_relation_cache: DirectRelationCache,
+    preferred_consumer_view: ViewId | None = None,
 ) -> tuple[NodeApply | EdgeApply | None, ConversionIssue]:
     """Convert an asset-centric resource to a data model instance.
 
@@ -178,6 +180,7 @@ def asset_centric_to_dm(
         view_source (ResourceViewMappingApply): The view source defining how to map the resource to the data model.
         view_properties (dict[str, ViewProperty]): The defined properties referenced in the view source mapping.
         direct_relation_cache (DirectRelationCache): Cache for direct relation references.
+        preferred_consumer_view (ViewId | None): The preferred consumer view for the instance.
 
     Returns:
         tuple[NodeApply | EdgeApply, ConversionIssue]: A tuple containing the converted NodeApply and any ConversionIssue encountered.
@@ -213,7 +216,10 @@ def asset_centric_to_dm(
             "id": id_,
             "dataSetId": data_set_id,
             "classicExternalId": external_id,
+            "resourceViewMapping": {"space": COGNITE_MIGRATION_SPACE_ID, "externalId": view_source.external_id},
         }
+        if preferred_consumer_view:
+            instance_source_properties["preferredConsumerViewId"] = preferred_consumer_view.dump()
         sources.append(NodeOrEdgeData(source=INSTANCE_SOURCE_VIEW_ID, properties=instance_source_properties))
 
     instance: NodeApply | EdgeApply

cognite_toolkit/_cdf_tk/commands/_migrate/data_mapper.py

@@ -29,7 +29,13 @@ from cognite_toolkit._cdf_tk.client.data_classes.legacy.canvas import (
 )
 from cognite_toolkit._cdf_tk.client.data_classes.legacy.charts import Chart, ChartWrite
 from cognite_toolkit._cdf_tk.client.data_classes.legacy.migration import ResourceViewMappingApply
-from cognite_toolkit._cdf_tk.client.data_classes.three_d import RevisionStatus, ThreeDModelResponse
+from cognite_toolkit._cdf_tk.client.data_classes.three_d import (
+    AssetMappingDMRequest,
+    AssetMappingResponse,
+    NodeReference,
+    RevisionStatus,
+    ThreeDModelResponse,
+)
 from cognite_toolkit._cdf_tk.commands._migrate.conversion import DirectRelationCache, asset_centric_to_dm
 from cognite_toolkit._cdf_tk.commands._migrate.data_classes import (
     Model,
@@ -141,6 +147,7 @@ class AssetCentricMapper(
             view_source=view_source,
             view_properties=view_properties,
             direct_relation_cache=self._direct_relation_cache,
+            preferred_consumer_view=mapping.preferred_consumer_view,
         )
         if mapping.instance_id.space == MISSING_INSTANCE_SPACE:
             conversion_issue.missing_instance_space = f"Missing instance space for dataset ID {mapping.data_set_id!r}"
@@ -469,3 +476,45 @@ class ThreeDMapper(DataMapper[ThreeDSelector, ThreeDModelResponse, ThreeDMigrati
             return "PointCloud"
         else:
             return None
+
+
+class ThreeDAssetMapper(DataMapper[ThreeDSelector, AssetMappingResponse, AssetMappingDMRequest]):
+    def __init__(self, client: ToolkitClient) -> None:
+        self.client = client
+
+    def map(
+        self, source: Sequence[AssetMappingResponse]
+    ) -> Sequence[tuple[AssetMappingDMRequest | None, MigrationIssue]]:
+        output: list[tuple[AssetMappingDMRequest | None, MigrationIssue]] = []
+        self._populate_cache(source)
+        for item in source:
+            mapped_item, issue = self._map_single_item(item)
+            output.append((mapped_item, issue))
+        return output
+
+    def _populate_cache(self, source: Sequence[AssetMappingResponse]) -> None:
+        asset_ids: set[int] = set()
+        for mapping in source:
+            if mapping.asset_id is not None:
+                asset_ids.add(mapping.asset_id)
+        self.client.migration.lookup.assets(list(asset_ids))
+
+    def _map_single_item(
+        self, item: AssetMappingResponse
+    ) -> tuple[AssetMappingDMRequest | None, ThreeDModelMigrationIssue]:
+        issue = ThreeDModelMigrationIssue(model_name=f"AssetMapping_{item.model_id}", model_id=item.model_id)
+        asset_instance_id = item.asset_instance_id
+        if item.asset_id and asset_instance_id is None:
+            asset_node_id = self.client.migration.lookup.assets(item.asset_id)
+            if asset_node_id is None:
+                issue.error_message.append(f"Missing asset instance for asset ID {item.asset_id!r}")
+                return None, issue
+            asset_instance_id = NodeReference(space=asset_node_id.space, externalId=asset_node_id.external_id)
+
+        if asset_instance_id is None:
+            issue.error_message.append("Neither assetInstanceId nor assetId provided for mapping.")
+            return None, issue
+        mapped_request = AssetMappingDMRequest(
+            modelId=item.model_id, revisionId=item.revision_id, nodeId=item.node_id, assetInstanceId=asset_instance_id
+        )
+        return mapped_request, issue

cognite_toolkit/_cdf_tk/commands/_migrate/data_model.py

@@ -4,6 +4,7 @@ from cognite.client.data_classes.data_modeling.containers import BTreeIndex
 SPACE = dm.SpaceApply(
     "cognite_migration", description="Space for the asset-centric to data modeling migration", name="cdf_migration"
 )
+COGNITE_MIGRATION_SPACE_ID = SPACE.space
 
 RESOURCE_VIEW_MAPPING = dm.ContainerApply(
     space=SPACE.space,

cognite_toolkit/_cdf_tk/commands/_migrate/migration_io.py

@@ -1,12 +1,16 @@
 from collections.abc import Iterable, Iterator, Mapping, Sequence
-from typing import ClassVar, cast
+from typing import ClassVar, Literal, cast
 
 from cognite.client.data_classes import Annotation
 from cognite.client.data_classes.data_modeling import EdgeId, InstanceApply, NodeId
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.legacy.pending_instances_ids import PendingInstanceId
-from cognite_toolkit._cdf_tk.client.data_classes.three_d import ThreeDModelResponse
+from cognite_toolkit._cdf_tk.client.data_classes.three_d import (
+    AssetMappingDMRequest,
+    AssetMappingResponse,
+    ThreeDModelResponse,
+)
 from cognite_toolkit._cdf_tk.commands._migrate.data_classes import ThreeDMigrationRequest
 from cognite_toolkit._cdf_tk.constants import MISSING_EXTERNAL_ID, MISSING_INSTANCE_SPACE
 from cognite_toolkit._cdf_tk.exceptions import ToolkitNotImplementedError, ToolkitValueError
@@ -14,6 +18,7 @@ from cognite_toolkit._cdf_tk.storageio import (
     AnnotationIO,
     HierarchyIO,
     InstanceIO,
+    T_Selector,
     UploadableStorageIO,
 )
 from cognite_toolkit._cdf_tk.storageio._base import Page, UploadItem
@@ -366,6 +371,14 @@ class AnnotationMigrationIO(
 
 
 class ThreeDMigrationIO(UploadableStorageIO[ThreeDSelector, ThreeDModelResponse, ThreeDMigrationRequest]):
+    """IO class for downloading and migrating 3D models.
+
+    Args:
+        client: The ToolkitClient to use for CDF interactions.
+        data_model_type: The type of 3D data model to download. Either "classic" or "DM".
+
+    """
+
     KIND = "3DMigration"
     SUPPORTED_DOWNLOAD_FORMATS = frozenset({".ndjson"})
     SUPPORTED_COMPRESSIONS = frozenset({".gz"})
@@ -375,9 +388,22 @@ class ThreeDMigrationIO(UploadableStorageIO[ThreeDSelector, ThreeDModelResponse,
     UPLOAD_ENDPOINT = "/3d/migrate/models"
     REVISION_ENDPOINT = "/3d/migrate/revisions"
 
+    def __init__(self, client: ToolkitClient, data_model_type: Literal["classic", "data modeling"] = "classic") -> None:
+        super().__init__(client)
+        self.data_model_type = data_model_type
+
     def as_id(self, item: ThreeDModelResponse) -> str:
         return f"{item.name}_{item.id!s}"
 
+    def _is_selected(self, item: ThreeDModelResponse, included_models: set[int] | None) -> bool:
+        return self._is_correct_type(item) and (included_models is None or item.id in included_models)
+
+    def _is_correct_type(self, item: ThreeDModelResponse) -> bool:
+        if self.data_model_type == "classic":
+            return item.space is None
+        else:
+            return item.space is not None
+
     def stream_data(self, selector: ThreeDSelector, limit: int | None = None) -> Iterable[Page[ThreeDModelResponse]]:
         published: bool | None = None
         if isinstance(selector, ThreeDModelFilteredSelector):
@@ -392,12 +418,7 @@ class ThreeDMigrationIO(UploadableStorageIO[ThreeDSelector, ThreeDModelResponse,
             response = self.client.tool.three_d.models.iterate(
                 published=published, include_revision_info=True, limit=request_limit, cursor=cursor
             )
-            # Only include asset-centric 3D models
-            items = [
-                item
-                for item in response.items
-                if item.space is None and (included_models is None or item.id in included_models)
-            ]
+            items = [item for item in response.items if self._is_selected(item, included_models)]
             total += len(items)
             if items:
                 yield Page(worker_id="main", items=items, next_cursor=response.next_cursor)
@@ -454,3 +475,93 @@ class ThreeDMigrationIO(UploadableStorageIO[ThreeDSelector, ThreeDModelResponse,
             )
             results.extend(revision.as_item_responses(data.source_id))
         return results
+
+
+class ThreeDAssetMappingMigrationIO(UploadableStorageIO[ThreeDSelector, AssetMappingResponse, AssetMappingDMRequest]):
+    KIND = "3DMigrationAssetMapping"
+    SUPPORTED_DOWNLOAD_FORMATS = frozenset({".ndjson"})
+    SUPPORTED_COMPRESSIONS = frozenset({".gz"})
+    SUPPORTED_READ_FORMATS = frozenset({".ndjson"})
+    DOWNLOAD_LIMIT = 1000
+    CHUNK_SIZE = 100
+    UPLOAD_ENDPOINT = "/3d/models/{modelId}/revisions/{revisionId}/mappings"
+
+    def __init__(self, client: ToolkitClient, object_3D_space: str, cad_node_space: str) -> None:
+        super().__init__(client)
+        self.object_3D_space = object_3D_space
+        self.cad_node_space = cad_node_space
+        # We can only migrate asset mappings for 3D models that are already migrated to data modeling.
+        self._3D_io = ThreeDMigrationIO(client, data_model_type="data modeling")
+
+    def as_id(self, item: AssetMappingResponse) -> str:
+        return f"AssetMapping_{item.model_id!s}_{item.revision_id!s}_{item.asset_id!s}"
+
+    def stream_data(self, selector: ThreeDSelector, limit: int | None = None) -> Iterable[Page[AssetMappingResponse]]:
+        total = 0
+        for three_d_page in self._3D_io.stream_data(selector, None):
+            for model in three_d_page.items:
+                if model.last_revision_info is None or model.last_revision_info.revision_id is None:
+                    # No revisions, so no asset mappings to
+                    continue
+                cursor: str | None = None
+                while True:
+                    request_limit = (
+                        min(self.DOWNLOAD_LIMIT, limit - total) if limit is not None else self.DOWNLOAD_LIMIT
+                    )
+                    if limit is not None and total >= limit:
+                        return
+                    response = self.client.tool.three_d.asset_mappings.iterate(
+                        model_id=model.id,
+                        revision_id=model.last_revision_info.revision_id,
+                        cursor=cursor,
+                        limit=request_limit,
+                    )
+                    items = response.items
+                    total += len(items)
+                    if items:
+                        yield Page(worker_id="main", items=items, next_cursor=response.next_cursor)
+                    if response.next_cursor is None:
+                        break
+                    cursor = response.next_cursor
+
+    def count(self, selector: ThreeDSelector) -> int | None:
+        # There is no efficient way to count 3D asset mappings in CDF.
+        return None
+
+    def upload_items(
+        self,
+        data_chunk: Sequence[UploadItem[AssetMappingDMRequest]],
+        http_client: HTTPClient,
+        selector: T_Selector | None = None,
+    ) -> Sequence[HTTPMessage]:
+        """Migrate 3D asset mappings by uploading them to the migrate/asset-mappings endpoint."""
+        if not data_chunk:
+            return []
+        # Assume all items in the chunk belong to the same model and revision, they should
+        # if the .stream_data method is used for downloading.
+        first = data_chunk[0]
+        model_id = first.item.model_id
+        revision_id = first.item.revision_id
+        endpoint = self.UPLOAD_ENDPOINT.format(modelId=model_id, revisionId=revision_id)
+        responses = http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self.client.config.create_api_url(endpoint),
+                method="POST",
+                items=list(data_chunk),
+                extra_body_fields={
+                    "dmsContextualizationConfig": {
+                        "object3DSpace": self.object_3D_space,
+                        "cadNodeSpace": self.cad_node_space,
+                    }
+                },
+            )
+        )
+        return responses
+
+    def json_to_resource(self, item_json: dict[str, JsonVal]) -> AssetMappingDMRequest:
+        raise NotImplementedError("Deserializing 3D Asset Mappings from JSON is not supported.")
+
+    def data_to_json_chunk(
+        self, data_chunk: Sequence[AssetMappingResponse], selector: ThreeDSelector | None = None
+    ) -> list[dict[str, JsonVal]]:
+        raise NotImplementedError("Serializing 3D Asset Mappings to JSON is not supported.")

cognite_toolkit/_cdf_tk/commands/_purge.py

@@ -16,6 +16,7 @@ from rich.console import Console
 from rich.panel import Panel
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.data_classes.instance_api import TypedInstanceIdentifier
 from cognite_toolkit._cdf_tk.cruds import (
     AssetCRUD,
     ContainerCRUD,
@@ -59,10 +60,10 @@ from cognite_toolkit._cdf_tk.utils.aggregators import (
     TimeSeriesAggregator,
 )
 from cognite_toolkit._cdf_tk.utils.http_client import (
-    FailedRequestItems,
-    FailedResponseItems,
     HTTPClient,
     ItemsRequest,
+    ItemsRequest2,
+    ItemsSuccessResponse2,
     SuccessResponseItems,
 )
 from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
@@ -714,21 +715,18 @@ class PurgeCommand(ToolkitCommand):
             results.deleted += len(items)
             return
 
-        responses = delete_client.request_with_retries(
-            ItemsRequest(
-                delete_client.config.create_api_url("/models/instances/delete"),
+        responses = delete_client.request_items_retries(
+            ItemsRequest2(
+                endpoint_url=delete_client.config.create_api_url("/models/instances/delete"),
                 method="POST",
-                # MyPy does not understand that InstanceId.load handles dict[str, JsonVal]
-                items=[DeleteItem(item=item, as_id_fun=InstanceId.load) for item in items],  # type: ignore[arg-type]
+                items=[TypedInstanceIdentifier._load(item) for item in items],
             )
         )
         for response in responses:
-            if isinstance(response, SuccessResponseItems):
+            if isinstance(response, ItemsSuccessResponse2):
                 results.deleted += len(response.ids)
-            elif isinstance(response, FailedResponseItems | FailedRequestItems):
-                results.failed += len(response.ids)
             else:
-                results.failed += len(items)
+                results.failed += len(response.ids)
 
     @staticmethod
     def _unlink_timeseries(

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py

@@ -13,7 +13,7 @@ from cognite_toolkit._cdf_tk.client.data_classes.infield import (
     InfieldLocationConfig,
     InfieldLocationConfigList,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.instance_api import InstanceResult, NodeIdentifier
+from cognite_toolkit._cdf_tk.client.data_classes.instance_api import InstanceResult, TypedNodeIdentifier
 from cognite_toolkit._cdf_tk.client.data_classes.legacy.apm_config_v1 import (
     APMConfig,
     APMConfigList,
@@ -246,7 +246,7 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig]):
 
 
 @final
-class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConfig, InfieldLocationConfig]):
+class InFieldLocationConfigCRUD(ResourceCRUD[TypedNodeIdentifier, InfieldLocationConfig, InfieldLocationConfig]):
     folder_name = "cdf_applications"
     resource_cls = InfieldLocationConfig
     resource_write_cls = InfieldLocationConfig
@@ -260,13 +260,13 @@ class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConf
         return "infield location configs"
 
     @classmethod
-    def get_id(cls, item: InfieldLocationConfig | dict) -> NodeIdentifier:
+    def get_id(cls, item: InfieldLocationConfig | dict) -> TypedNodeIdentifier:
         if isinstance(item, dict):
-            return NodeIdentifier(space=item["space"], external_id=item["externalId"])
-        return NodeIdentifier(space=item.space, external_id=item.external_id)
+            return TypedNodeIdentifier(space=item["space"], external_id=item["externalId"])
+        return TypedNodeIdentifier(space=item.space, external_id=item.external_id)
 
     @classmethod
-    def dump_id(cls, id: NodeIdentifier) -> dict[str, Any]:
+    def dump_id(cls, id: TypedNodeIdentifier) -> dict[str, Any]:
         return id.dump(include_type=False)
 
     @classmethod
@@ -308,13 +308,13 @@ class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConf
         # as we only want to count the infield location configs here.
         return [res for res in created if res.as_id() in config_ids]
 
-    def retrieve(self, ids: SequenceNotStr[NodeIdentifier]) -> InfieldLocationConfigList:
+    def retrieve(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> InfieldLocationConfigList:
         return InfieldLocationConfigList(self.client.infield.config.retrieve(list(ids)))
 
     def update(self, items: Sequence[InfieldLocationConfig]) -> Sized:
         return self.create(items)
 
-    def delete(self, ids: SequenceNotStr[NodeIdentifier]) -> int:
+    def delete(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> int:
         # We must retrieve the full resource to get hte DataExplorationConfig linked resource deleted as well.
         retrieved = self.retrieve(list(ids))
         # Then, we pass the entire resource to the delete method, which will delete both the InfieldLocationConfig
@@ -345,7 +345,9 @@ class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConf
 
 
 @final
-class InFieldCDMLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InFieldCDMLocationConfig, InFieldCDMLocationConfig]):
+class InFieldCDMLocationConfigCRUD(
+    ResourceCRUD[TypedNodeIdentifier, InFieldCDMLocationConfig, InFieldCDMLocationConfig]
+):
     folder_name = "cdf_applications"
     resource_cls = InFieldCDMLocationConfig
     resource_write_cls = InFieldCDMLocationConfig
@@ -359,13 +361,13 @@ class InFieldCDMLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InFieldCDMLocati
         return "infield CDM location configs"
 
     @classmethod
-    def get_id(cls, item: InFieldCDMLocationConfig | dict) -> NodeIdentifier:
+    def get_id(cls, item: InFieldCDMLocationConfig | dict) -> TypedNodeIdentifier:
         if isinstance(item, dict):
-            return NodeIdentifier(space=item["space"], external_id=item["externalId"])
-        return NodeIdentifier(space=item.space, external_id=item.external_id)
+            return TypedNodeIdentifier(space=item["space"], external_id=item["externalId"])
+        return TypedNodeIdentifier(space=item.space, external_id=item.external_id)
 
     @classmethod
-    def dump_id(cls, id: NodeIdentifier) -> dict[str, Any]:
+    def dump_id(cls, id: TypedNodeIdentifier) -> dict[str, Any]:
         return id.dump(include_type=False)
 
     @classmethod
@@ -397,13 +399,13 @@ class InFieldCDMLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InFieldCDMLocati
     def create(self, items: Sequence[InFieldCDMLocationConfig]) -> list[InstanceResult]:
         return self.client.infield.cdm_config.apply(items)
 
-    def retrieve(self, ids: SequenceNotStr[NodeIdentifier]) -> list[InFieldCDMLocationConfig]:
+    def retrieve(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> list[InFieldCDMLocationConfig]:
         return self.client.infield.cdm_config.retrieve(list(ids))
 
     def update(self, items: Sequence[InFieldCDMLocationConfig]) -> Sized:
         return self.create(items)
 
-    def delete(self, ids: SequenceNotStr[NodeIdentifier]) -> int:
+    def delete(self, ids: SequenceNotStr[TypedNodeIdentifier]) -> int:
         # We must retrieve the full resource to delete it.
         retrieved = self.retrieve(list(ids))
         _ = self.client.infield.cdm_config.delete(retrieved)

cognite_toolkit/_cdf_tk/utils/http_client/_data_classes2.py

@@ -26,9 +26,7 @@ class HTTPResult2(BaseModel):
         if isinstance(self, SuccessResponse2):
             return self
         elif isinstance(self, FailedResponse2):
-            raise ToolkitAPIError(
-                f"Request failed with status code {self.status_code}: {self.error.code} - {self.error.message}"
-            )
+            raise ToolkitAPIError(f"Request failed with status code {self.status_code}: {self.error.message}")
         elif isinstance(self, FailedRequest2):
             raise ToolkitAPIError(f"Request failed with error: {self.error}")
         else:

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

@@ -12,7 +12,7 @@ jobs:
     environment: dev
     name: Deploy
     container:
-      image: cognite/toolkit:0.7.35
+      image: cognite/toolkit:0.7.37
       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.35
+      image: cognite/toolkit:0.7.37
       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.35"
+version = "0.7.37"
 
 
 [plugins]

cognite_toolkit/_version.py

@@ -1 +1 @@
-__version__ = "0.7.35"
+__version__ = "0.7.37"

{cognite_toolkit-0.7.35.dist-info → cognite_toolkit-0.7.37.dist-info}/METADATA

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