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

cognite_toolkit/_cdf_tk/apps/_migrate_app.py

@@ -19,11 +19,13 @@ from cognite_toolkit._cdf_tk.commands._migrate.data_mapper import (
     AssetCentricMapper,
     CanvasMapper,
     ChartMapper,
+    ThreeDAssetMapper,
     ThreeDMapper,
 )
 from cognite_toolkit._cdf_tk.commands._migrate.migration_io import (
     AnnotationMigrationIO,
     AssetCentricMigrationIO,
+    ThreeDAssetMappingMigrationIO,
     ThreeDMigrationIO,
 )
 from cognite_toolkit._cdf_tk.commands._migrate.selectors import (
@@ -68,6 +70,7 @@ class MigrateApp(typer.Typer):
         self.command("canvas")(self.canvas)
         self.command("charts")(self.charts)
         self.command("3d")(self.three_d)
+        self.command("3d-mappings")(self.three_d_asset_mapping)
         # Uncomment when infield v2 config migration is ready
         # self.command("infield-configs")(self.infield_configs)
 
@@ -1054,6 +1057,104 @@ class MigrateApp(typer.Typer):
             )
         )
 
+    @staticmethod
+    def three_d_asset_mapping(
+        ctx: typer.Context,
+        model_id: Annotated[
+            list[int] | None,
+            typer.Argument(
+                help="The IDs of the 3D model to migrate asset mappings for. If not provided, an interactive selection will be "
+                "performed to select the."
+            ),
+        ] = None,
+        object_3D_space: Annotated[
+            str | None,
+            typer.Option(
+                "--object-3d-space",
+                "-o",
+                help="The instance space to ceate the 3D object nodes in.",
+            ),
+        ] = None,
+        cad_node_space: Annotated[
+            str | None,
+            typer.Option(
+                "--cad-node-space",
+                "-c",
+                help="The instance space to create the CAD node nodes in.",
+            ),
+        ] = None,
+        log_dir: Annotated[
+            Path,
+            typer.Option(
+                "--log-dir",
+                "-l",
+                help="Path to the directory where migration logs will be stored.",
+            ),
+        ] = Path(f"migration_logs_{TODAY}"),
+        dry_run: Annotated[
+            bool,
+            typer.Option(
+                "--dry-run",
+                "-d",
+                help="If set, the migration will not be executed, but only a report of what would be done is printed.",
+            ),
+        ] = False,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """Migrate 3D Model Asset Mappings from Asset-Centric to data modeling in CDF.
+
+        This command expects that the selected 3D model has already been migrated to data modeling.
+        """
+        client = EnvironmentVariables.create_from_environment().get_client()
+        selected_ids: list[int]
+        if model_id is not None:
+            selected_ids = model_id
+        else:
+            # Interactive selection
+            selected_models = ThreeDInteractiveSelect(client, "migrate").select_three_d_models("dm")
+            selected_ids = [model.id for model in selected_models]
+            space_selector = DataModelingSelect(client, "migrate")
+            object_3D_space = space_selector.select_instance_space(
+                multiselect=False,
+                message="In which instance space do you want to create the 3D Object nodes?",
+                include_empty=False,
+            )
+            cad_node_space = space_selector.select_instance_space(
+                multiselect=False,
+                message="In which instance space do you want to create the CAD Node nodes?",
+                include_empty=False,
+            )
+            dry_run = questionary.confirm("Do you want to perform a dry run?", default=dry_run).ask()
+            verbose = questionary.confirm("Do you want verbose output?", default=verbose).ask()
+            if any(res is None for res in [dry_run, verbose]):
+                raise typer.Abort()
+
+        if object_3D_space is None or cad_node_space is None:
+            raise typer.BadParameter(
+                "--object-3d-space and --cad-node-space are required when specifying IDs directly."
+            )
+
+        cmd = MigrationCommand()
+        cmd.run(
+            lambda: cmd.migrate(
+                selected=ThreeDModelIdSelector(ids=tuple(selected_ids)),
+                data=ThreeDAssetMappingMigrationIO(
+                    client, object_3D_space=object_3D_space, cad_node_space=cad_node_space
+                ),
+                mapper=ThreeDAssetMapper(client),
+                log_dir=log_dir,
+                dry_run=dry_run,
+                verbose=verbose,
+            )
+        )
+
     @staticmethod
     def infield_configs(
         ctx: typer.Context,

cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -4,7 +4,7 @@ from typing import Any, cast
 from pydantic import TypeAdapter
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse, QueryResponse
+from cognite_toolkit._cdf_tk.client.data_classes.api_classes import QueryResponse
 from cognite_toolkit._cdf_tk.client.data_classes.infield import (
     DataExplorationConfig,
     InFieldCDMLocationConfig,
@@ -13,12 +13,11 @@ from cognite_toolkit._cdf_tk.client.data_classes.infield import (
 from cognite_toolkit._cdf_tk.client.data_classes.instance_api import (
     InstanceResponseItem,
     InstanceResult,
-    NodeIdentifier,
+    TypedNodeIdentifier,
 )
 from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
 from cognite_toolkit._cdf_tk.utils.http_client import (
     HTTPClient,
-    ItemsRequest,
     ItemsRequest2,
     RequestMessage2,
 )
@@ -56,7 +55,7 @@ class InfieldConfigAPI:
         responses.raise_for_status()
         return TypeAdapter(list[InstanceResult]).validate_python(responses.get_items())
 
-    def retrieve(self, items: Sequence[NodeIdentifier]) -> list[InfieldLocationConfig]:
+    def retrieve(self, items: Sequence[TypedNodeIdentifier]) -> list[InfieldLocationConfig]:
         if len(items) > 100:
             raise ValueError("Cannot retrieve more than 100 InfieldLocationConfig items at once.")
         if not items:
@@ -73,7 +72,7 @@ class InfieldConfigAPI:
         parsed_response = QueryResponse[InstanceResponseItem].model_validate(success.body_json)
         return self._parse_retrieve_response(parsed_response)
 
-    def delete(self, items: Sequence[InfieldLocationConfig]) -> list[NodeIdentifier]:
+    def delete(self, items: Sequence[InfieldLocationConfig]) -> list[TypedNodeIdentifier]:
         if len(items) > 500:
             raise ValueError("Cannot delete more than 500 InfieldLocationConfig items at once.")
 
@@ -83,18 +82,18 @@ class InfieldConfigAPI:
             else [item.as_id(), item.data_exploration_config.as_id()]
             for item in items
         )
-        responses = self._http_client.request_with_retries(
-            ItemsRequest(
+        responses = self._http_client.request_items_retries(
+            ItemsRequest2(
                 endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
                 method="POST",
                 items=[identifier for sublist in identifiers for identifier in sublist],
             )
         )
         responses.raise_for_status()
-        return PagedResponse[NodeIdentifier].model_validate(responses.get_first_body()).items
+        return TypeAdapter(list[TypedNodeIdentifier]).validate_python(responses.get_items())
 
     @classmethod
-    def _retrieve_query(cls, items: Sequence[NodeIdentifier]) -> dict[str, Any]:
+    def _retrieve_query(cls, items: Sequence[TypedNodeIdentifier]) -> dict[str, Any]:
         return {
             "with": {
                 cls.LOCATION_REF: {
@@ -184,7 +183,7 @@ class InFieldCDMConfigAPI:
         results.raise_for_status()
         return TypeAdapter(list[InstanceResult]).validate_python(results.get_items())
 
-    def retrieve(self, items: Sequence[NodeIdentifier]) -> list[InFieldCDMLocationConfig]:
+    def retrieve(self, items: Sequence[TypedNodeIdentifier]) -> list[InFieldCDMLocationConfig]:
         if len(items) > 100:
             raise ValueError("Cannot retrieve more than 100 InFieldCDMLocationConfig items at once.")
         if not items:
@@ -200,23 +199,23 @@ class InFieldCDMConfigAPI:
         parsed_response = QueryResponse[InstanceResponseItem].model_validate(success.body_json)
         return self._parse_retrieve_response(parsed_response)
 
-    def delete(self, items: Sequence[InFieldCDMLocationConfig]) -> list[NodeIdentifier]:
+    def delete(self, items: Sequence[InFieldCDMLocationConfig]) -> list[TypedNodeIdentifier]:
         if len(items) > 500:
             raise ValueError("Cannot delete more than 500 InFieldCDMLocationConfig items at once.")
 
-        identifiers: Sequence = [item.as_id() for item in items]
-        responses = self._http_client.request_with_retries(
-            ItemsRequest(
+        identifiers = [item.as_id() for item in items]
+        responses = self._http_client.request_items_retries(
+            ItemsRequest2(
                 endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
                 method="POST",
-                items=identifiers,  # type: ignore[arg-type]
+                items=identifiers,
             )
         )
         responses.raise_for_status()
-        return PagedResponse[NodeIdentifier].model_validate(responses.get_first_body()).items
+        return TypeAdapter(list[TypedNodeIdentifier]).validate_python(responses.get_items())
 
     @classmethod
-    def _retrieve_query(cls, items: Sequence[NodeIdentifier]) -> dict[str, Any]:
+    def _retrieve_query(cls, items: Sequence[TypedNodeIdentifier]) -> dict[str, Any]:
         return {
             "with": {
                 cls.LOCATION_REF: {

cognite_toolkit/_cdf_tk/client/api/streams.py

@@ -8,7 +8,6 @@ from cognite_toolkit._cdf_tk.client.data_classes.streams import StreamRequest, S
 from cognite_toolkit._cdf_tk.utils.http_client import (
     HTTPClient,
     ItemsRequest2,
-    ParamRequest,
     RequestMessage2,
 )
 
@@ -46,13 +45,13 @@ class StreamsAPI:
         Args:
             external_id: External ID of the stream to delete.
         """
-        responses = self._http_client.request_with_retries(
-            ParamRequest(
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
                 endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/{external_id}"),
                 method="DELETE",
             )
         )
-        responses.raise_for_status()
+        _ = response.get_success_or_raise()
 
     def list(self) -> list[StreamResponse]:
         """List streams.

cognite_toolkit/_cdf_tk/client/api/three_d.py

@@ -1,14 +1,23 @@
-from collections.abc import Sequence
+from collections import defaultdict
+from collections.abc import Iterable, Sequence
+from typing import Any, TypeVar
 
+from pydantic import TypeAdapter
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse
-from cognite_toolkit._cdf_tk.client.data_classes.three_d import ThreeDModelClassicRequest, ThreeDModelResponse
+from cognite_toolkit._cdf_tk.client.data_classes.api_classes import InternalIdRequest, PagedResponse
+from cognite_toolkit._cdf_tk.client.data_classes.three_d import (
+    AssetMappingClassicRequest,
+    AssetMappingDMRequest,
+    AssetMappingResponse,
+    ThreeDModelClassicRequest,
+    ThreeDModelResponse,
+)
+from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
 from cognite_toolkit._cdf_tk.utils.http_client import (
     HTTPClient,
-    ItemsRequest,
+    ItemsRequest2,
     RequestMessage2,
-    SimpleBodyRequest,
 )
 from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
 
@@ -37,16 +46,15 @@ class ThreeDModelAPI:
             return []
         if len(models) > self.MAX_CLASSIC_MODELS_PER_CREATE_REQUEST:
             raise ValueError("Cannot create more than 1000 3D models in a single request.")
-        responses = self._http_client.request_with_retries(
-            ItemsRequest(
+        responses = self._http_client.request_items_retries(
+            ItemsRequest2(
                 endpoint_url=self._config.create_api_url(self.ENDPOINT),
                 method="POST",
-                items=list(models),
+                items=models,
             )
         )
         responses.raise_for_status()
-        body = responses.get_first_body()
-        return PagedResponse[ThreeDModelResponse].model_validate(body).items
+        return TypeAdapter(list[ThreeDModelResponse]).validate_python(responses.get_items())
 
     def delete(self, ids: Sequence[int]) -> None:
         """Delete 3D models by their IDs.
@@ -58,11 +66,11 @@ class ThreeDModelAPI:
             return None
         if len(ids) > self.MAX_MODELS_PER_DELETE_REQUEST:
             raise ValueError("Cannot delete more than 1000 3D models in a single request.")
-        responses = self._http_client.request_with_retries(
-            SimpleBodyRequest(
+        responses = self._http_client.request_items_retries(
+            ItemsRequest2(
                 endpoint_url=self._config.create_api_url(self.ENDPOINT + "/delete"),
                 method="POST",
-                body_content={"items": [{"id": id_} for id_ in ids]},
+                items=InternalIdRequest.from_ids(list(ids)),
             )
         )
         responses.raise_for_status()
@@ -126,6 +134,251 @@ class ThreeDModelAPI:
         return results
 
 
+T_RequestMapping = TypeVar("T_RequestMapping", bound=AssetMappingClassicRequest | AssetMappingDMRequest)
+
+
+class ThreeDAssetMappingAPI:
+    ENDPOINT = "/3d/models/{modelId}/revisions/{revisionId}/mappings"
+    CREATE_CLASSIC_MAX_MAPPINGS_PER_REQUEST = 1000
+    CREATE_DM_MAX_MAPPINGS_PER_REQUEST = 100
+    DELETE_CLASSIC_MAX_MAPPINGS_PER_REQUEST = 1000
+    DELETE_DM_MAX_MAPPINGS_PER_REQUEST = 100
+    LIST_REQUEST_MAX_LIMIT = 1000
+
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self._console = console
+        self._config = http_client.config
+
+    def create(self, mappings: Sequence[AssetMappingClassicRequest]) -> list[AssetMappingResponse]:
+        """Create 3D asset mappings.
+
+        Args:
+            mappings (Sequence[AssetMappingClassicRequest]):
+                The 3D asset mapping(s) to create.
+
+        Returns:
+            list[AssetMappingResponse]: The created 3D asset mapping(s).
+        """
+        results: list[AssetMappingResponse] = []
+        for endpoint, model_id, revision_id, revision_mappings in self._chunk_mappings_by_endpoint(
+            mappings, self.CREATE_CLASSIC_MAX_MAPPINGS_PER_REQUEST
+        ):
+            responses = self._http_client.request_items_retries(
+                ItemsRequest2(
+                    endpoint_url=self._config.create_api_url(endpoint),
+                    method="POST",
+                    items=revision_mappings,
+                )
+            )
+            responses.raise_for_status()
+            items = responses.get_items()
+            for item in items:
+                # We append modelId and revisionId to each item since the API does not return them
+                # this is needed to fully populate the AssetMappingResponse data class
+                item["modelId"] = model_id
+                item["revisionId"] = revision_id
+            results.extend(TypeAdapter(list[AssetMappingResponse]).validate_python(items))
+        return results
+
+    def create_dm(
+        self, mappings: Sequence[AssetMappingDMRequest], object_3d_space: str, cad_node_space: str
+    ) -> list[AssetMappingResponse]:
+        """Create 3D asset mappings in Data Modeling format.
+
+        Args:
+            mappings (Sequence[AssetMappingDMRequest]):
+                The 3D asset mapping(s) to create
+            object_3d_space (str):
+                The instance space where the Cognite3DObject are located.
+            cad_node_space (str):
+                The instance space where the CogniteCADNode are located.
+        Returns:
+            list[AssetMappingResponse]: The created 3D asset mapping(s).
+        """
+        results: list[AssetMappingResponse] = []
+        for endpoint, model_id, revision_id, revision_mappings in self._chunk_mappings_by_endpoint(
+            mappings, self.CREATE_DM_MAX_MAPPINGS_PER_REQUEST
+        ):
+            responses = self._http_client.request_items_retries(
+                ItemsRequest2(
+                    endpoint_url=self._config.create_api_url(endpoint),
+                    method="POST",
+                    items=revision_mappings,
+                    extra_body_fields={
+                        "dmsContextualizationConfig": {
+                            "object3DSpace": object_3d_space,
+                            "cadNodeSpace": cad_node_space,
+                        }
+                    },
+                )
+            )
+            responses.raise_for_status()
+            items = responses.get_items()
+            for item in items:
+                # We append modelId and revisionId to each item since the API does not return them
+                # this is needed to fully populate the AssetMappingResponse data class
+                item["modelId"] = model_id
+                item["revisionId"] = revision_id
+            results.extend(TypeAdapter(list[AssetMappingResponse]).validate_python(items))
+        return results
+
+    @classmethod
+    def _chunk_mappings_by_endpoint(
+        cls, mappings: Sequence[T_RequestMapping], chunk_size: int
+    ) -> Iterable[tuple[str, int, int, list[T_RequestMapping]]]:
+        chunked_mappings: dict[tuple[int, int], list[T_RequestMapping]] = defaultdict(list)
+        for mapping in mappings:
+            key = mapping.model_id, mapping.revision_id
+            chunked_mappings[key].append(mapping)
+        for (model_id, revision_id), revision_mappings in chunked_mappings.items():
+            endpoint = cls.ENDPOINT.format(modelId=model_id, revisionId=revision_id)
+            for chunk in chunker_sequence(revision_mappings, chunk_size):
+                yield endpoint, model_id, revision_id, chunk
+
+    def delete(self, mappings: Sequence[AssetMappingClassicRequest]) -> None:
+        """Delete 3D asset mappings.
+
+        Args:
+            mappings (Sequence[AssetMappingClassicRequest]):
+                The 3D asset mapping(s) to delete.
+        """
+        for endpoint, *_, revision_mappings in self._chunk_mappings_by_endpoint(
+            mappings, self.DELETE_CLASSIC_MAX_MAPPINGS_PER_REQUEST
+        ):
+            responses = self._http_client.request_items_retries(
+                ItemsRequest2(
+                    endpoint_url=self._config.create_api_url(f"{endpoint}/delete"),
+                    method="DELETE",
+                    items=revision_mappings,
+                )
+            )
+            responses.raise_for_status()
+        return None
+
+    def delete_dm(self, mappings: Sequence[AssetMappingDMRequest], object_3d_space: str, cad_node_space: str) -> None:
+        """Delete 3D asset mappings in Data Modeling format.
+
+        Args:
+            mappings (Sequence[AssetMappingDMRequest]):
+                The 3D asset mapping(s) to delete.
+            object_3d_space (str):
+                The instance space where the Cognite3DObject are located.
+            cad_node_space (str):
+                The instance space where the CogniteCADNode are located.
+        """
+        for endpoint, *_, revision_mappings in self._chunk_mappings_by_endpoint(
+            mappings, self.DELETE_DM_MAX_MAPPINGS_PER_REQUEST
+        ):
+            responses = self._http_client.request_items_retries(
+                ItemsRequest2(
+                    endpoint_url=self._config.create_api_url(f"{endpoint}/delete"),
+                    method="DELETE",
+                    items=revision_mappings,
+                    extra_body_fields={
+                        "dmsContextualizationConfig": {
+                            "object3DSpace": object_3d_space,
+                            "cadNodeSpace": cad_node_space,
+                        }
+                    },
+                )
+            )
+            responses.raise_for_status()
+        return None
+
+    def iterate(
+        self,
+        model_id: int,
+        revision_id: int,
+        asset_ids: list[int] | None = None,
+        asset_instance_ids: list[str] | None = None,
+        node_ids: list[int] | None = None,
+        tree_indexes: list[int] | None = None,
+        get_dms_instances: bool = False,
+        limit: int = 100,
+        cursor: str | None = None,
+    ) -> PagedResponse[AssetMappingResponse]:
+        if not (0 < limit <= self.LIST_REQUEST_MAX_LIMIT):
+            raise ValueError(f"Limit must be between 1 and {self.LIST_REQUEST_MAX_LIMIT}, got {limit}.")
+        if sum(param is not None for param in [asset_ids, asset_instance_ids, node_ids, tree_indexes]) > 1:
+            raise ValueError("Only one of asset_ids, asset_instance_ids, node_ids, or tree_indexes can be provided.")
+        body: dict[str, Any] = {
+            "getDmsInstances": get_dms_instances,
+            "limit": limit,
+        }
+        if asset_ids is not None:
+            if not (0 < len(asset_ids) <= 100):
+                raise ValueError("asset_ids must contain between 1 and 100 IDs.")
+            body["filter"] = {"assetIds": asset_ids}
+        elif asset_instance_ids is not None:
+            if not (0 < len(asset_instance_ids) <= 100):
+                raise ValueError("asset_instance_ids must contain between 1 and 100 IDs.")
+            body["filter"] = {"assetInstanceIds": asset_instance_ids}
+        elif node_ids is not None:
+            if not (0 < len(node_ids) <= 100):
+                raise ValueError("node_ids must contain between 1 and 100 IDs.")
+            body["filter"] = {"nodeIds": node_ids}
+        elif tree_indexes is not None:
+            if not (0 < len(tree_indexes) <= 100):
+                raise ValueError("tree_indexes must contain between 1 and 100 indexes.")
+            body["filter"] = {"treeIndexes": tree_indexes}
+        if cursor is not None:
+            body["cursor"] = cursor
+
+        endpoint = self.ENDPOINT.format(modelId=model_id, revisionId=revision_id)
+        responses = self._http_client.request_single_retries(
+            RequestMessage2(
+                endpoint_url=self._config.create_api_url(f"{endpoint}/list"),
+                method="POST",
+                body_content=body,
+            )
+        )
+        success_response = responses.get_success_or_raise()
+        body_json = success_response.body_json
+        # Add modelId and revisionId to items since the API does not return them
+        for item in body_json.get("items", []):
+            item["modelId"] = model_id
+            item["revisionId"] = revision_id
+        return PagedResponse[AssetMappingResponse].model_validate(body_json)
+
+    def list(
+        self,
+        model_id: int,
+        revision_id: int,
+        asset_ids: list[int] | None = None,
+        asset_instance_ids: list[str] | None = None,
+        node_ids: list[int] | None = None,
+        tree_indexes: list[int] | None = None,
+        get_dms_instances: bool = False,
+        limit: int | None = 100,
+    ) -> list[AssetMappingResponse]:
+        results: list[AssetMappingResponse] = []
+        cursor: str | None = None
+        while True:
+            request_limit = (
+                self.LIST_REQUEST_MAX_LIMIT if limit is None else min(limit - len(results), self.LIST_REQUEST_MAX_LIMIT)
+            )
+            if request_limit <= 0:
+                break
+            page = self.iterate(
+                model_id=model_id,
+                revision_id=revision_id,
+                asset_ids=asset_ids,
+                asset_instance_ids=asset_instance_ids,
+                node_ids=node_ids,
+                tree_indexes=tree_indexes,
+                get_dms_instances=get_dms_instances,
+                limit=request_limit,
+                cursor=cursor,
+            )
+            results.extend(page.items)
+            if page.next_cursor is None:
+                break
+            cursor = page.next_cursor
+        return results
+
+
 class ThreeDAPI:
     def __init__(self, http_client: HTTPClient, console: Console) -> None:
         self.models = ThreeDModelAPI(http_client, console)
+        self.asset_mappings = ThreeDAssetMappingAPI(http_client, console)

cognite_toolkit/_cdf_tk/client/data_classes/api_classes.py

@@ -2,6 +2,8 @@ from typing import Generic, TypeVar
 
 from pydantic import BaseModel, Field, JsonValue
 
+from cognite_toolkit._cdf_tk.utils.http_client._data_classes2 import RequestResource
+
 T = TypeVar("T", bound=BaseModel)
 
 
@@ -15,3 +17,14 @@ class QueryResponse(BaseModel, Generic[T]):
     typing: dict[str, JsonValue] | None = None
     next_cursor: dict[str, str] = Field(alias="nextCursor")
     debug: dict[str, JsonValue] | None = None
+
+
+class InternalIdRequest(RequestResource):
+    id: int
+
+    def as_id(self) -> int:
+        return self.id
+
+    @classmethod
+    def from_ids(cls, ids: list[int]) -> list["InternalIdRequest"]:
+        return [cls(id=id_) for id_ in ids]

cognite_toolkit/_cdf_tk/client/data_classes/base.py

@@ -3,7 +3,7 @@ from abc import ABC, abstractmethod
 from collections import UserList
 from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
-from pydantic import BaseModel, ConfigDict
+from pydantic import ConfigDict
 from pydantic.alias_generators import to_camel
 
 from cognite_toolkit._cdf_tk.utils.http_client._data_classes2 import BaseModelObject, RequestResource
@@ -31,21 +31,17 @@ class ResponseResource(BaseModelObject, Generic[T_RequestResource], ABC):
         return self.as_request_resource()
 
 
-class Identifier(BaseModel):
+class Identifier(RequestResource, ABC):
     """Base class for all identifier classes."""
 
     model_config = ConfigDict(alias_generator=to_camel, extra="ignore", populate_by_name=True, frozen=True)
 
-    def dump(self, include_type: bool = True) -> dict[str, Any]:
-        """Dump the identifier to a dictionary.
+    def dump(self, camel_case: bool = True, include_type: bool = True) -> dict[str, Any]:
+        """Dump the resource to a dictionary.
 
-        Args:
-            include_type (bool): Whether to include the type of the identifier in the output.
-
-        Returns:
-            dict[str, Any]: The dumped identifier.
+        This is the default serialization method for request resources.
         """
-        return self.model_dump(mode="json", by_alias=True, exclude_defaults=not include_type)
+        return self.model_dump(mode="json", by_alias=camel_case, exclude_unset=not include_type)
 
     def as_id(self) -> Self:
         return self

cognite_toolkit/_cdf_tk/client/data_classes/instance_api.py

@@ -15,19 +15,19 @@ class TypedInstanceIdentifier(Identifier):
     external_id: str
 
 
-class InstanceIdentifier(Identifier):
-    space: str
-    external_id: str
-
-
-class NodeIdentifier(TypedInstanceIdentifier):
+class TypedNodeIdentifier(TypedInstanceIdentifier):
     instance_type: Literal["node"] = "node"
 
 
-class EdgeIdentifier(TypedInstanceIdentifier):
+class TypedEdgeIdentifier(TypedInstanceIdentifier):
     instance_type: Literal["edge"] = "edge"
 
 
+class InstanceIdentifier(Identifier):
+    space: str
+    external_id: str
+
+
 class InstanceResult(BaseModelObject):
     instance_type: InstanceType
     version: int

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/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,
@@ -469,3 +475,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/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.36
       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.36
       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.36"
 
 
 [plugins]

cognite_toolkit/_version.py

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

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

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

@@ -10,7 +10,7 @@ cognite_toolkit/_cdf_tk/apps/_download_app.py,sha256=s8-lkfvzGwQSuBcLEetlTTg7wVR
 cognite_toolkit/_cdf_tk/apps/_dump_app.py,sha256=X7uh9lQAE-U24z0FrNsechSOyczjVHW8BGjw3wFfwUU,37134
 cognite_toolkit/_cdf_tk/apps/_import_app.py,sha256=5n5AF40HJ0Q_3LENCknG0MxH4pMUS8OwsqvtCYj_t7w,2086
 cognite_toolkit/_cdf_tk/apps/_landing_app.py,sha256=YR9z83OY7PhhgBVC5gmRLgo9iTXoGoZfRhOU3gd_r2o,888
-cognite_toolkit/_cdf_tk/apps/_migrate_app.py,sha256=R7BsckVnPe59Z26mY06NsWSGjq21DwobPBJ3tMfqRhs,43707
+cognite_toolkit/_cdf_tk/apps/_migrate_app.py,sha256=YUs5V5oJzLeWqFSTW2NfwTptJUC22kjZIQ30xUw-U7s,47665
 cognite_toolkit/_cdf_tk/apps/_modules_app.py,sha256=t0SPvulgbgkF_OO2E68mQ_ZUcJ6HoaurYe0IkmXie0o,7449
 cognite_toolkit/_cdf_tk/apps/_profile_app.py,sha256=vSRJW54bEvIul8_4rOqyOYA7ztXx7TFOvZRZWZTxMbg,7007
 cognite_toolkit/_cdf_tk/apps/_purge.py,sha256=KYI1wFy7yHFEM1qJnTYc4_8E2FVGu4QhPsWsxop1sZA,14242
@@ -31,7 +31,7 @@ cognite_toolkit/_cdf_tk/client/__init__.py,sha256=a6rQXDGfW2g7K5WwrOW5oakh1TdFlB
 cognite_toolkit/_cdf_tk/client/_constants.py,sha256=COUGcea37mDF2sf6MGqJXWmecTY_6aCImslxXrYW1I0,73
 cognite_toolkit/_cdf_tk/client/_toolkit_client.py,sha256=S2D0N3Cea39Bhl2NIu8jbQy8Xbq1RS1rldG238CvfQ4,3750
 cognite_toolkit/_cdf_tk/client/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_toolkit/_cdf_tk/client/api/infield.py,sha256=r_KeHEFs9slr6Zw3N6Ka3-_JBhU8yVW4KcjQ3u5OSFw,11071
+cognite_toolkit/_cdf_tk/client/api/infield.py,sha256=B7sydnhE1cKhp9OJxkjmTAfRREWZTaD8EuSvscZoE8w,11039
 cognite_toolkit/_cdf_tk/client/api/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite_toolkit/_cdf_tk/client/api/legacy/canvas.py,sha256=2TVKPlgtXviPxW9tOX_tv7I06K-SnYovg5c9sxBE3f4,8843
 cognite_toolkit/_cdf_tk/client/api/legacy/charts.py,sha256=YZ2jjHoKinRiqOBzosq6abvzStA4B6VezI1wSy3_U2k,4960
@@ -57,19 +57,19 @@ cognite_toolkit/_cdf_tk/client/api/lookup.py,sha256=c-cvtgfGGGYyk8ROcJu44qlo1ocq
 cognite_toolkit/_cdf_tk/client/api/migration.py,sha256=6q3ncT-_I2P7fWYzAcv_UG55VnrVRTSymwaf10aosJA,23102
 cognite_toolkit/_cdf_tk/client/api/project.py,sha256=5DDnyDF9WN8m8wNP3WhqX0gT6nDaG-2ekC1VSMMrdV8,1088
 cognite_toolkit/_cdf_tk/client/api/search.py,sha256=wl6MjmkELCWmkXf9yYM03LElLC5l0_DwwifsZc_tXSg,694
-cognite_toolkit/_cdf_tk/client/api/streams.py,sha256=qOUFHdpz75PSlfImIizVCtschLLHttR8AUV0Jw3DTRM,3055
-cognite_toolkit/_cdf_tk/client/api/three_d.py,sha256=zvzyeeAz8P2h0_yC-i-PAqe-kl8ocyOAZbQ3Y3_O3Wo,4949
+cognite_toolkit/_cdf_tk/client/api/streams.py,sha256=uOD5UBsfkmMaiJ-UrtZI9I0O4fQlp2H627o0PJqzefY,3048
+cognite_toolkit/_cdf_tk/client/api/three_d.py,sha256=C8lPVMceJnK1qJOvNNeQgbic0MIEY2up4oL-REZXN5I,15934
 cognite_toolkit/_cdf_tk/client/api/token.py,sha256=8SiA44Dwsx0j_X8lgIxl2rdNCQSdEiSfoD_4ybxMtFA,5131
 cognite_toolkit/_cdf_tk/client/api/verify.py,sha256=-x6z6lMaOZG91adi0m9NtJ4wIQgoZURbzluPALXM-ps,3730
 cognite_toolkit/_cdf_tk/client/api_client.py,sha256=CQdD_gfDqQkz5OYHrTnKvBvEvzHPdHDB1BkZPWRoahg,440
 cognite_toolkit/_cdf_tk/client/config.py,sha256=weMR43z-gqHMn-Jqvfmh_nJ0HbgEdyeCGtISuEf3OuY,4269
 cognite_toolkit/_cdf_tk/client/data_classes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cognite_toolkit/_cdf_tk/client/data_classes/api_classes.py,sha256=X-aGFnYzSxXYDxlFP2rqJ8P10Um7bcRRUZxVVzblYBw,477
-cognite_toolkit/_cdf_tk/client/data_classes/base.py,sha256=VtqQv2xVV5J81Ls8Y-tvsITKnUCOfjhQwFijwqNIIuU,2303
+cognite_toolkit/_cdf_tk/client/data_classes/api_classes.py,sha256=_B0BRfLbhibwx-K4rfsq4IRq1V05KzUNCNN_2AlDhFg,801
+cognite_toolkit/_cdf_tk/client/data_classes/base.py,sha256=0XsvidoFPAQ_j1cTcBJ0dLv2fP2Nwh7zQAW49hj-ZAk,2224
 cognite_toolkit/_cdf_tk/client/data_classes/capabilities.py,sha256=muqpAC2JLCFcEpRPzuh_3sS3o_q42WFyfsGzl-LfB_U,8773
 cognite_toolkit/_cdf_tk/client/data_classes/charts_data.py,sha256=-dFfY53cos5DwASLU18aBfYF1VC6bfaUshC2HiGJ2uI,5571
 cognite_toolkit/_cdf_tk/client/data_classes/infield.py,sha256=xZDpHw190FgX2vK6zk_r8dUJA7J6UzdS8227VOu74ms,4298
-cognite_toolkit/_cdf_tk/client/data_classes/instance_api.py,sha256=ajOCEzRf9OrwR3JyGKNvBkru_Nfpe4PxmcPc8mYB8PE,5065
+cognite_toolkit/_cdf_tk/client/data_classes/instance_api.py,sha256=3NPKpD0OLzac_tvxXm54NeYw9LO6RC8NEUolthwPD_Q,5075
 cognite_toolkit/_cdf_tk/client/data_classes/legacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite_toolkit/_cdf_tk/client/data_classes/legacy/apm_config_v1.py,sha256=0bPq7R0qvdf8SMFS06kX7TXHIClDcJNHwdTBweQB-GU,20150
 cognite_toolkit/_cdf_tk/client/data_classes/legacy/canvas.py,sha256=T5XLaUAFlh4NjWiJLGh4rjdS9BSeTUEsbhh9nbRd0s4,50728
@@ -91,7 +91,7 @@ cognite_toolkit/_cdf_tk/client/data_classes/legacy/search_config.py,sha256=Reo_r
 cognite_toolkit/_cdf_tk/client/data_classes/legacy/sequences.py,sha256=02d34fPcJ1H7U5ZnCCfOi36z5WJ4WnRfCWwkp99mW2E,6234
 cognite_toolkit/_cdf_tk/client/data_classes/legacy/streamlit_.py,sha256=nEk00FH3i-px2r6ql4kk1VVL4sytjUn0_sTkEdDSHVc,6746
 cognite_toolkit/_cdf_tk/client/data_classes/streams.py,sha256=DHSDrBax81fUzneIikn9hUMVgQVbdaiQ9aY-bRaTK38,2459
-cognite_toolkit/_cdf_tk/client/data_classes/three_d.py,sha256=9NvZNkbdkHlfzZqV_Kr43eHjpfyfOOxcL9ry7Y_zZ0I,1406
+cognite_toolkit/_cdf_tk/client/data_classes/three_d.py,sha256=Tk8ujB_aN7rfpqbBNV2Ps2Onp_F7Ipt-EUItUIspTaE,3424
 cognite_toolkit/_cdf_tk/client/testing.py,sha256=xD1Pg7Cb5Th_o_XbyqyMSNGVlBEa-AlS54ezjRsQ4JA,7386
 cognite_toolkit/_cdf_tk/client/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 cognite_toolkit/_cdf_tk/client/utils/_concurrency.py,sha256=3GtQbKDaosyKHEt-KzxKK9Yie4TvZPdoou2vUk6dUa8,2298
@@ -107,15 +107,15 @@ cognite_toolkit/_cdf_tk/commands/_migrate/command.py,sha256=l2P0Em05aEJvNZH4WkEI
 cognite_toolkit/_cdf_tk/commands/_migrate/conversion.py,sha256=VxoFLS0Xi9uviICShxHHXbUU_wliqNZL3PxD0qveOSU,16810
 cognite_toolkit/_cdf_tk/commands/_migrate/creators.py,sha256=hQ9o_N2aY9nqHOKlwP7tI7mAYLCPkPLSJGe_QTwglWc,9612
 cognite_toolkit/_cdf_tk/commands/_migrate/data_classes.py,sha256=__o2JZ3GkD0uqtjjpumHJF8KLdqCFrbMZOoEQHAeOLo,11488
-cognite_toolkit/_cdf_tk/commands/_migrate/data_mapper.py,sha256=59Ep9I3t0DxWfekh1LBwDJESEJETmejeOFRSutNadgs,22276
+cognite_toolkit/_cdf_tk/commands/_migrate/data_mapper.py,sha256=282o0zDiY5_zqMNTQApn5uaM73vgo_FuNnQo3sicq9Y,24366
 cognite_toolkit/_cdf_tk/commands/_migrate/data_model.py,sha256=i1eUsNX6Dueol9STIEwyksBnBsWUk13O8qHIjW964pM,7860
 cognite_toolkit/_cdf_tk/commands/_migrate/default_mappings.py,sha256=HRh-VlVWbOLjQfP968lReYtZFptjUEa4JbbZxiw5Qy8,5551
 cognite_toolkit/_cdf_tk/commands/_migrate/issues.py,sha256=uEMI5azCpHWAvEauRY9ZvsvNO0_aaUpdNP7_nM7oBC4,7547
-cognite_toolkit/_cdf_tk/commands/_migrate/migration_io.py,sha256=TCeu6zf2wIaAX1xwnwS4gGrfcaLKRuNbAEYwkulIU_s,21756
+cognite_toolkit/_cdf_tk/commands/_migrate/migration_io.py,sha256=7gD7uKOy8kPa9u9rvRcOnZsuLGTD0WhU8szKGQ3GDoM,26782
 cognite_toolkit/_cdf_tk/commands/_migrate/prepare.py,sha256=RfqaNoso5CyBwc-p6ckwcYqBfZXKhdJgdGIyd0TATaI,2635
 cognite_toolkit/_cdf_tk/commands/_migrate/selectors.py,sha256=N1H_-rBpPUD6pbrlcofn1uEK1bA694EUXEe1zIXeqyo,2489
 cognite_toolkit/_cdf_tk/commands/_profile.py,sha256=8E3U4WyJmGPeOXLEWtRaFpB05MFWgA5Y4vFKPay6OfY,43127
-cognite_toolkit/_cdf_tk/commands/_purge.py,sha256=HqN2T0OrHG53BfQrolYLi0kFa-_KuJjbZldFtQdMdnY,32914
+cognite_toolkit/_cdf_tk/commands/_purge.py,sha256=MzBi-fTiNWFdAodOtraOWgtqG9rOSttKS49rCGL3XfQ,32764
 cognite_toolkit/_cdf_tk/commands/_questionary_style.py,sha256=h-w7fZKkGls3TrzIGBKjsZSGoXJJIYchgD1StfA40r8,806
 cognite_toolkit/_cdf_tk/commands/_upload.py,sha256=SBqevUZjNW_-hGXSI8YzwgQ7AgJH15M0S3avm7Wmqpw,13040
 cognite_toolkit/_cdf_tk/commands/_utils.py,sha256=UxMJW5QYKts4om5n6x2Tq2ihvfO9gWjhQKeqZNFTlKg,402
@@ -149,7 +149,7 @@ cognite_toolkit/_cdf_tk/cruds/_resource_cruds/configuration.py,sha256=OniGxzx0XM
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/data_organization.py,sha256=U0ItuoNr1KEtoFQAiIe-K19_72ht9-kGndFVgF-iC10,9524
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/datamodel.py,sha256=4uTr3Mx89yaPsr23mcR7hD7h9XBpB4dUPCeNacI8mB0,64874
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/extraction_pipeline.py,sha256=nvMIDeAksJ_0iWvorK8k1BemSrTAUhll_JgCMNiUjZ4,17708
-cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py,sha256=X1u_uNvtui8EpmEbxcXBUuRI2B3X5VKK6Nt4KvuT6Ys,20669
+cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py,sha256=4DL6koP_wwBqfgRveSAYbTVkcTJfjvrj0s2JXJ_p8yQ,20750
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/file.py,sha256=YGsrp0_yLcpyUvVc_-EW7Rb6LTl_cKtWNmuJDbxbqhs,14862
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/function.py,sha256=QHihJsyCc9EJImPQSIZDQsxDewCglBc6iSHXjLeutMs,28402
 cognite_toolkit/_cdf_tk/cruds/_resource_cruds/group_scoped.py,sha256=WEg8-CxMP64WfE_XXIlH114zM51K0uLaYa4atd992zI,1690
@@ -289,7 +289,7 @@ cognite_toolkit/_cdf_tk/utils/hashing.py,sha256=3NyNfljyYNTqAyAFBd6XlyWaj43jRzEN
 cognite_toolkit/_cdf_tk/utils/http_client/__init__.py,sha256=MG3rAi5IiLxqlCMyVvzyfsKXMb_3fVxwAZ7uyPXrMvs,1483
 cognite_toolkit/_cdf_tk/utils/http_client/_client.py,sha256=1nKMop_ORrGXybG-KDmC3rlcKs8cseLWSkPkMTFWRyw,22493
 cognite_toolkit/_cdf_tk/utils/http_client/_data_classes.py,sha256=tpU2pswtbGn5E45izm-B4qIc4RSyh5gGDBj8kA0Gs7o,14964
-cognite_toolkit/_cdf_tk/utils/http_client/_data_classes2.py,sha256=Qqy7OEg8MGF9EksDUcn39fq6GpC_SrbWbyt-UGqD80Q,8811
+cognite_toolkit/_cdf_tk/utils/http_client/_data_classes2.py,sha256=kes6bUeHv8icMqcPbIXszl8GKtxpc5AIN4nUIHFoSV4,8761
 cognite_toolkit/_cdf_tk/utils/http_client/_exception.py,sha256=fC9oW6BN0HbUe2AkYABMP7Kj0-9dNYXVFBY5RQztq2c,126
 cognite_toolkit/_cdf_tk/utils/http_client/_tracker.py,sha256=pu6oA-XpOeaOLdoeD_mGfJXC3BFGWfh5oGcRDpb6maw,1407
 cognite_toolkit/_cdf_tk/utils/interactive_select.py,sha256=XeTyxfcrbgxo5a7rIGXB0hF1rJ_vHYsat3Wl31XM-hI,37907
@@ -309,14 +309,14 @@ 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=oRTIMwg3E-WwV3a4BgMPLT_I_-45appBab-4dXfVk_M,667
-cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml,sha256=9xSaRlqZoEoogjFEry-yJhX1jBsJETzEqs5eu5aJXXk,2430
-cognite_toolkit/_resources/cdf.toml,sha256=X8Bwz7uEfAwKlp9XCv1bWkKYh2LAA1NIVpYCMsF9jPg,475
-cognite_toolkit/_version.py,sha256=T20GoRCjdih7BMGVy6MaNmk6gD2Y_Vzyc4VjBcPeFRk,23
+cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml,sha256=ofqsT_RZbUsrih1RE9qrzOOQK72T9aM4HwIu5OOdM20,667
+cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml,sha256=Lul-1240VOiishKOBBWDJua7KIEuJziNJXcpgz8mRgE,2430
+cognite_toolkit/_resources/cdf.toml,sha256=DIpC1r6ql-BAasLk7nvhpPLpQeykwAU-XYG57VF8-iQ,475
+cognite_toolkit/_version.py,sha256=s_fO2Pb37oajrH9N1MYPwjM5YVV5bZvqGHD_GGAAiec,23
 cognite_toolkit/config.dev.yaml,sha256=M33FiIKdS3XKif-9vXniQ444GTZ-bLXV8aFH86u9iUQ,332
 cognite_toolkit/demo/__init__.py,sha256=-m1JoUiwRhNCL18eJ6t7fZOL7RPfowhCuqhYFtLgrss,72
 cognite_toolkit/demo/_base.py,sha256=6xKBUQpXZXGQ3fJ5f7nj7oT0s2n7OTAGIa17ZlKHZ5U,8052
-cognite_toolkit-0.7.35.dist-info/WHEEL,sha256=xDCZ-UyfvkGuEHPeI7BcJzYKIZzdqN8A8o1M5Om8IyA,79
-cognite_toolkit-0.7.35.dist-info/entry_points.txt,sha256=EtZ17K2mUjh-AY0QNU1CPIB_aDSSOdmtNI_4Fj967mA,84
-cognite_toolkit-0.7.35.dist-info/METADATA,sha256=I_SSGGmlwY9k8AXGAOdcjMahvnbDAtrX8UJZlZS29I0,4507
-cognite_toolkit-0.7.35.dist-info/RECORD,,
+cognite_toolkit-0.7.36.dist-info/WHEEL,sha256=xDCZ-UyfvkGuEHPeI7BcJzYKIZzdqN8A8o1M5Om8IyA,79
+cognite_toolkit-0.7.36.dist-info/entry_points.txt,sha256=EtZ17K2mUjh-AY0QNU1CPIB_aDSSOdmtNI_4Fj967mA,84
+cognite_toolkit-0.7.36.dist-info/METADATA,sha256=IVa9xEH1DSyQh4n7Ipr0HyVjKHPLoZUAgI0hole3qjo,4507
+cognite_toolkit-0.7.36.dist-info/RECORD,,