cognite-toolkit 0.7.30__py3-none-any.whl → 0.7.51__py3-none-any.whl

cognite_toolkit/_cdf_tk/commands/_migrate/conversion.py

@@ -1,7 +1,7 @@
 from collections.abc import Iterable, Mapping, Set
 from typing import Any, ClassVar, cast
 
-from cognite.client.data_classes import Annotation, Asset, Event, FileMetadata, TimeSeries
+from cognite.client.data_classes import Annotation
 from cognite.client.data_classes.data_modeling import (
     DirectRelation,
     DirectRelationReference,
@@ -9,27 +9,31 @@ 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
 from cognite.client.utils._identifier import InstanceId
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.migration import (
+from cognite_toolkit._cdf_tk.client.resource_classes.asset import AssetResponse
+from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling import NodeReference
+from cognite_toolkit._cdf_tk.client.resource_classes.event import EventResponse
+from cognite_toolkit._cdf_tk.client.resource_classes.filemetadata import FileMetadataResponse
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import (
     AssetCentricId,
     ResourceViewMappingApply,
 )
+from cognite_toolkit._cdf_tk.client.resource_classes.timeseries import TimeSeriesResponse
 from cognite_toolkit._cdf_tk.utils.collection import flatten_dict_json_path
 from cognite_toolkit._cdf_tk.utils.dtype_conversion import (
     asset_centric_convert_to_primary_property,
     convert_to_primary_property,
 )
-from cognite_toolkit._cdf_tk.utils.useful_types import (
-    AssetCentricResourceExtended,
-    AssetCentricTypeExtended,
-)
+from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricTypeExtended
+from cognite_toolkit._cdf_tk.utils.useful_types2 import AssetCentricResourceExtended
 
-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
 
 
@@ -110,22 +114,22 @@ class DirectRelationCache:
                         file_ids.add(file_id)
                     if isinstance(file_external_id := file_ref.get("externalId"), str):
                         file_external_ids.add(file_external_id)
-            elif isinstance(resource, Asset):
+            elif isinstance(resource, AssetResponse):
                 if resource.source:
                     source_ids.add(resource.source)
                 if resource.parent_id is not None:
                     asset_ids.add(resource.parent_id)
-            elif isinstance(resource, FileMetadata):
+            elif isinstance(resource, FileMetadataResponse):
                 if resource.source:
                     source_ids.add(resource.source)
                 if resource.asset_ids:
                     asset_ids.update(resource.asset_ids)
-            elif isinstance(resource, Event):
+            elif isinstance(resource, EventResponse):
                 if resource.source:
                     source_ids.add(resource.source)
                 if resource.asset_ids:
                     asset_ids.update(resource.asset_ids)
-            elif isinstance(resource, TimeSeries):
+            elif isinstance(resource, TimeSeriesResponse):
                 if resource.asset_id is not None:
                     asset_ids.add(resource.asset_id)
         if asset_ids:
@@ -169,6 +173,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 +183,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.
@@ -193,7 +199,11 @@ def asset_centric_to_dm(
     data_set_id = dumped.pop("dataSetId", None)
     external_id = dumped.pop("externalId", None)
 
-    issue = ConversionIssue(asset_centric_id=AssetCentricId(resource_type, id_=id_), instance_id=instance_id)
+    issue = ConversionIssue(
+        id=str(AssetCentricId(resource_type, id_=id_)),
+        asset_centric_id=AssetCentricId(resource_type, id_=id_),
+        instance_id=NodeReference(space=instance_id.space, external_id=instance_id.external_id),
+    )
 
     properties = create_properties(
         dumped,
@@ -213,7 +223,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
@@ -239,13 +252,13 @@ def asset_centric_to_dm(
 
 
 def _lookup_resource_type(resource_type: AssetCentricResourceExtended) -> AssetCentricTypeExtended:
-    if isinstance(resource_type, Asset):
+    if isinstance(resource_type, AssetResponse):
         return "asset"
-    elif isinstance(resource_type, FileMetadata):
+    elif isinstance(resource_type, FileMetadataResponse):
         return "file"
-    elif isinstance(resource_type, Event):
+    elif isinstance(resource_type, EventResponse):
         return "event"
-    elif isinstance(resource_type, TimeSeries):
+    elif isinstance(resource_type, TimeSeriesResponse):
         return "timeseries"
     elif isinstance(resource_type, Annotation):
         if resource_type.annotated_resource_type == "file" and resource_type.annotation_type in (

cognite_toolkit/_cdf_tk/commands/_migrate/creators.py

@@ -20,7 +20,7 @@ from cognite.client.data_classes.documents import SourceFileProperty
 from cognite.client.data_classes.events import EventProperty
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.apm_config_v1 import APMConfig, APMConfigList
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.apm_config_v1 import APMConfig, APMConfigList
 from cognite_toolkit._cdf_tk.cruds import NodeCRUD, ResourceCRUD, SpaceCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitMissingResourceError, ToolkitRequiredValueError
 from cognite_toolkit._cdf_tk.utils import humanize_collection

cognite_toolkit/_cdf_tk/commands/_migrate/data_classes.py

@@ -9,11 +9,14 @@ from cognite.client.data_classes._base import (
 from cognite.client.data_classes.data_modeling import EdgeId, InstanceApply, NodeId, ViewId
 from cognite.client.utils._identifier import InstanceId
 from cognite.client.utils._text import to_camel_case
-from pydantic import BaseModel, BeforeValidator, field_validator, model_validator
-
-from cognite_toolkit._cdf_tk.client.data_classes.instances import InstanceApplyList
-from cognite_toolkit._cdf_tk.client.data_classes.migration import AssetCentricId
-from cognite_toolkit._cdf_tk.client.data_classes.pending_instances_ids import PendingInstanceId
+from pydantic import BaseModel, BeforeValidator, Field, field_validator, model_validator
+
+from cognite_toolkit._cdf_tk.client._resource_base import BaseModelObject, RequestResource
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import InternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import InstanceIdentifier
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.instances import InstanceApplyList
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import AssetCentricId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.pending_instances_ids import PendingInstanceId
 from cognite_toolkit._cdf_tk.commands._migrate.default_mappings import (
     ASSET_ANNOTATIONS_ID,
     FILE_ANNOTATIONS_ID,
@@ -24,8 +27,8 @@ from cognite_toolkit._cdf_tk.storageio._data_classes import ModelList
 from cognite_toolkit._cdf_tk.utils.useful_types import (
     AssetCentricKindExtended,
     JsonVal,
-    T_AssetCentricResourceExtended,
 )
+from cognite_toolkit._cdf_tk.utils.useful_types2 import T_AssetCentricResourceExtended
 
 
 class MigrationMapping(BaseModel, alias_generator=to_camel_case, extra="ignore", populate_by_name=True):
@@ -261,3 +264,32 @@ class AssetCentricMappingList(
 
     def as_write(self) -> InstanceApplyList:
         return InstanceApplyList([item.as_write() for item in self])
+
+
+class Model(BaseModelObject):
+    instance_id: InstanceIdentifier
+
+
+class Thumbnail(BaseModelObject):
+    instance_id: InstanceIdentifier
+
+
+class ThreeDRevisionMigrationRequest(RequestResource):
+    space: str
+    type: Literal["CAD", "PointCloud", "Image360"]
+    revision_id: int
+    model: Model
+
+    def as_id(self) -> InternalId:
+        return InternalId(id=self.revision_id)
+
+
+class ThreeDMigrationRequest(RequestResource):
+    model_id: int
+    type: Literal["CAD", "PointCloud", "Image360"]
+    space: str
+    thumbnail: Thumbnail | None = None
+    revision: ThreeDRevisionMigrationRequest = Field(exclude=True)
+
+    def as_id(self) -> InternalId:
+        return InternalId(id=self.model_id)

cognite_toolkit/_cdf_tk/commands/_migrate/data_mapper.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from collections.abc import Callable, Sequence
-from typing import Generic, cast
+from typing import Generic, Literal, cast
 from uuid import uuid4
 
 from cognite.client.data_classes.data_modeling import (
@@ -15,41 +15,57 @@ from cognite.client.data_classes.data_modeling import (
 from cognite.client.exceptions import CogniteException
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.canvas import (
+from cognite_toolkit._cdf_tk.client.resource_classes.charts_data import (
+    ChartCoreTimeseries,
+    ChartSource,
+    ChartTimeseries,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import InstanceIdentifier, NodeReference
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.canvas import (
     ContainerReferenceApply,
     FdmInstanceContainerReferenceApply,
     IndustrialCanvas,
     IndustrialCanvasApply,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.charts import Chart, ChartWrite
-from cognite_toolkit._cdf_tk.client.data_classes.charts_data import (
-    ChartCoreTimeseries,
-    ChartSource,
-    ChartTimeseries,
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.charts import Chart, ChartWrite
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import ResourceViewMappingApply
+from cognite_toolkit._cdf_tk.client.resource_classes.three_d import (
+    AssetMappingClassicResponse,
+    AssetMappingDMRequest,
+    RevisionStatus,
+    ThreeDModelResponse,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.migration import ResourceViewMappingApply
 from cognite_toolkit._cdf_tk.commands._migrate.conversion import DirectRelationCache, asset_centric_to_dm
-from cognite_toolkit._cdf_tk.commands._migrate.data_classes import AssetCentricMapping
+from cognite_toolkit._cdf_tk.commands._migrate.data_classes import (
+    Model,
+    ThreeDMigrationRequest,
+    ThreeDRevisionMigrationRequest,
+)
 from cognite_toolkit._cdf_tk.commands._migrate.default_mappings import create_default_mappings
 from cognite_toolkit._cdf_tk.commands._migrate.issues import (
     CanvasMigrationIssue,
     ChartMigrationIssue,
     ConversionIssue,
-    MigrationIssue,
+    ThreeDModelMigrationIssue,
 )
-from cognite_toolkit._cdf_tk.commands._migrate.selectors import AssetCentricMigrationSelector
 from cognite_toolkit._cdf_tk.constants import MISSING_INSTANCE_SPACE
 from cognite_toolkit._cdf_tk.exceptions import ToolkitMigrationError, ToolkitValueError
 from cognite_toolkit._cdf_tk.protocols import T_ResourceRequest, T_ResourceResponse
 from cognite_toolkit._cdf_tk.storageio._base import T_Selector
-from cognite_toolkit._cdf_tk.storageio.selectors import CanvasSelector, ChartSelector
+from cognite_toolkit._cdf_tk.storageio.logger import DataLogger, NoOpLogger
+from cognite_toolkit._cdf_tk.storageio.selectors import CanvasSelector, ChartSelector, ThreeDSelector
 from cognite_toolkit._cdf_tk.utils import humanize_collection
-from cognite_toolkit._cdf_tk.utils.useful_types import (
-    T_AssetCentricResourceExtended,
-)
+from cognite_toolkit._cdf_tk.utils.useful_types2 import T_AssetCentricResourceExtended
+
+from .data_classes import AssetCentricMapping
+from .selectors import AssetCentricMigrationSelector
 
 
 class DataMapper(Generic[T_Selector, T_ResourceResponse, T_ResourceRequest], ABC):
+    def __init__(self, client: ToolkitClient) -> None:
+        self.client = client
+        self.logger: DataLogger = NoOpLogger()
+
     def prepare(self, source_selector: T_Selector) -> None:
         """Prepare the data mapper with the given source selector.
 
@@ -61,14 +77,14 @@ class DataMapper(Generic[T_Selector, T_ResourceResponse, T_ResourceRequest], ABC
         pass
 
     @abstractmethod
-    def map(self, source: Sequence[T_ResourceResponse]) -> Sequence[tuple[T_ResourceRequest | None, MigrationIssue]]:
+    def map(self, source: Sequence[T_ResourceResponse]) -> Sequence[T_ResourceRequest | None]:
         """Map a chunk of source data to the target format.
 
         Args:
             source: The source data chunk to be mapped.
 
         Returns:
-            A tuple containing the mapped data and a list of any issues encountered during mapping.
+            A sequence of mapped target data.
 
         """
         raise NotImplementedError("Subclasses must implement this method.")
@@ -78,7 +94,7 @@ class AssetCentricMapper(
     DataMapper[AssetCentricMigrationSelector, AssetCentricMapping[T_AssetCentricResourceExtended], InstanceApply]
 ):
     def __init__(self, client: ToolkitClient) -> None:
-        self.client = client
+        super().__init__(client)
         self._ingestion_view_by_id: dict[ViewId, View] = {}
         self._view_mapping_by_id: dict[str, ResourceViewMappingApply] = {}
         self._direct_relation_cache = DirectRelationCache(client)
@@ -106,14 +122,37 @@ class AssetCentricMapper(
 
     def map(
         self, source: Sequence[AssetCentricMapping[T_AssetCentricResourceExtended]]
-    ) -> Sequence[tuple[InstanceApply | None, ConversionIssue]]:
+    ) -> Sequence[InstanceApply | None]:
         """Map a chunk of asset-centric data to InstanceApplyList format."""
         # We update the direct relation cache in bulk for all resources in the chunk.
         self._direct_relation_cache.update(item.resource for item in source)
-        output: list[tuple[InstanceApply | None, ConversionIssue]] = []
+        output: list[InstanceApply | None] = []
+        issues: list[ConversionIssue] = []
         for item in source:
             instance, conversion_issue = self._map_single_item(item)
-            output.append((instance, conversion_issue))
+            identifier = str(item.mapping.as_asset_centric_id())
+
+            if conversion_issue.missing_instance_space:
+                self.logger.tracker.add_issue(identifier, "Missing instance space")
+            if conversion_issue.failed_conversions:
+                self.logger.tracker.add_issue(identifier, "Failed conversions")
+            if conversion_issue.invalid_instance_property_types:
+                self.logger.tracker.add_issue(identifier, "Invalid instance property types")
+            if conversion_issue.missing_asset_centric_properties:
+                self.logger.tracker.add_issue(identifier, "Missing asset-centric properties")
+            if conversion_issue.missing_instance_properties:
+                self.logger.tracker.add_issue(identifier, "Missing instance properties")
+            if conversion_issue.ignored_asset_centric_properties:
+                self.logger.tracker.add_issue(identifier, "Ignored asset-centric properties")
+
+            if conversion_issue.has_issues:
+                issues.append(conversion_issue)
+
+            if instance is None:
+                self.logger.tracker.finalize_item(identifier, "failure")
+            output.append(instance)
+        if issues:
+            self.logger.log(issues)
         return output
 
     def _map_single_item(
@@ -134,6 +173,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}"
@@ -141,15 +181,29 @@ class AssetCentricMapper(
 
 
 class ChartMapper(DataMapper[ChartSelector, Chart, ChartWrite]):
-    def __init__(self, client: ToolkitClient) -> None:
-        self.client = client
-
-    def map(self, source: Sequence[Chart]) -> Sequence[tuple[ChartWrite | None, MigrationIssue]]:
+    def map(self, source: Sequence[Chart]) -> Sequence[ChartWrite | None]:
         self._populate_cache(source)
-        output: list[tuple[ChartWrite | None, MigrationIssue]] = []
+        output: list[ChartWrite | None] = []
+        issues: list[ChartMigrationIssue] = []
         for item in source:
             mapped_item, issue = self._map_single_item(item)
-            output.append((mapped_item, issue))
+            identifier = item.external_id
+
+            if issue.missing_timeseries_ids:
+                self.logger.tracker.add_issue(identifier, "Missing timeseries IDs")
+            if issue.missing_timeseries_external_ids:
+                self.logger.tracker.add_issue(identifier, "Missing timeseries external IDs")
+            if issue.missing_timeseries_identifier:
+                self.logger.tracker.add_issue(identifier, "Missing timeseries identifier")
+
+            if issue.has_issues:
+                issues.append(issue)
+
+            if mapped_item is None:
+                self.logger.tracker.finalize_item(identifier, "failure")
+            output.append(mapped_item)
+        if issues:
+            self.logger.log(issues)
         return output
 
     def _populate_cache(self, source: Sequence[Chart]) -> None:
@@ -171,7 +225,7 @@ class ChartMapper(DataMapper[ChartSelector, Chart, ChartWrite]):
             self.client.migration.lookup.time_series(external_id=list(timeseries_external_ids))
 
     def _map_single_item(self, item: Chart) -> tuple[ChartWrite | None, ChartMigrationIssue]:
-        issue = ChartMigrationIssue(chart_external_id=item.external_id)
+        issue = ChartMigrationIssue(chart_external_id=item.external_id, id=item.external_id)
         time_series_collection = item.data.time_series_collection or []
         timeseries_core_collection = self._create_timeseries_core_collection(time_series_collection, issue)
         if issue.has_issues:
@@ -267,16 +321,30 @@ class CanvasMapper(DataMapper[CanvasSelector, IndustrialCanvas, IndustrialCanvas
     DEFAULT_TIMESERIES_VIEW = ViewId("cdf_cdm", "CogniteTimeSeries", "v1")
 
     def __init__(self, client: ToolkitClient, dry_run: bool, skip_on_missing_ref: bool = False) -> None:
-        self.client = client
+        super().__init__(client)
         self.dry_run = dry_run
         self.skip_on_missing_ref = skip_on_missing_ref
 
-    def map(self, source: Sequence[IndustrialCanvas]) -> Sequence[tuple[IndustrialCanvasApply | None, MigrationIssue]]:
+    def map(self, source: Sequence[IndustrialCanvas]) -> Sequence[IndustrialCanvasApply | None]:
         self._populate_cache(source)
-        output: list[tuple[IndustrialCanvasApply | None, MigrationIssue]] = []
+        output: list[IndustrialCanvasApply | None] = []
+        issues: list[CanvasMigrationIssue] = []
         for item in source:
             mapped_item, issue = self._map_single_item(item)
-            output.append((mapped_item, issue))
+            identifier = item.as_id()
+
+            if issue.missing_reference_ids:
+                self.logger.tracker.add_issue(identifier, "Missing reference IDs")
+
+            if issue.has_issues:
+                issues.append(issue)
+
+            if mapped_item is None:
+                self.logger.tracker.finalize_item(identifier, "failure")
+
+            output.append(mapped_item)
+        if issues:
+            self.logger.log(issues)
         return output
 
     @property
@@ -327,10 +395,13 @@ class CanvasMapper(DataMapper[CanvasSelector, IndustrialCanvas, IndustrialCanvas
 
     def _map_single_item(self, canvas: IndustrialCanvas) -> tuple[IndustrialCanvasApply | None, CanvasMigrationIssue]:
         update = canvas.as_write()
-        issue = CanvasMigrationIssue(canvas_external_id=canvas.canvas.external_id, canvas_name=canvas.canvas.name)
+        issue = CanvasMigrationIssue(
+            canvas_external_id=canvas.canvas.external_id, canvas_name=canvas.canvas.name, id=canvas.canvas.name
+        )
 
         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)
@@ -340,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
@@ -356,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,
@@ -383,3 +464,148 @@ class CanvasMapper(DataMapper[CanvasSelector, IndustrialCanvas, IndustrialCanvas
             max_width=reference.max_width,
             max_height=reference.max_height,
         )
+
+
+class ThreeDMapper(DataMapper[ThreeDSelector, ThreeDModelResponse, ThreeDMigrationRequest]):
+    def map(self, source: Sequence[ThreeDModelResponse]) -> Sequence[ThreeDMigrationRequest | None]:
+        self._populate_cache(source)
+        output: list[ThreeDMigrationRequest | None] = []
+        issues: list[ThreeDModelMigrationIssue] = []
+        for item in source:
+            mapped_item, issue = self._map_single_item(item)
+            identifier = item.name
+
+            if issue.error_message:
+                for error in issue.error_message:
+                    self.logger.tracker.add_issue(identifier, error)
+
+            if issue.has_issues:
+                issues.append(issue)
+
+            if mapped_item is None:
+                self.logger.tracker.finalize_item(identifier, "failure")
+            output.append(mapped_item)
+        if issues:
+            self.logger.log(issues)
+        return output
+
+    def _populate_cache(self, source: Sequence[ThreeDModelResponse]) -> None:
+        dataset_ids: set[int] = set()
+        for model in source:
+            if model.data_set_id is not None:
+                dataset_ids.add(model.data_set_id)
+        self.client.migration.space_source.retrieve(list(dataset_ids))
+
+    def _map_single_item(
+        self, item: ThreeDModelResponse
+    ) -> tuple[ThreeDMigrationRequest | None, ThreeDModelMigrationIssue]:
+        issue = ThreeDModelMigrationIssue(model_name=item.name, model_id=item.id, id=item.name)
+        instance_space: str | None = None
+        last_revision_id: int | None = None
+        model_type: Literal["CAD", "PointCloud", "Image360"] | None = None
+        if item.data_set_id is None:
+            issue.error_message.append("3D model is not associated with any dataset.")
+        else:
+            space_source = self.client.migration.space_source.retrieve(item.data_set_id)
+            if space_source is not None:
+                instance_space = space_source.instance_space
+        if instance_space is None and item.data_set_id is not None:
+            issue.error_message.append(f"Missing instance space for dataset ID {item.data_set_id!r}")
+        if item.last_revision_info is None:
+            issue.error_message.append("3D model has no revisions.")
+        else:
+            model_type = self._get_type(item.last_revision_info)
+            last_revision_id = item.last_revision_info.revision_id
+            if last_revision_id is None:
+                issue.error_message.append("3D model's last revision has no revision ID.")
+
+        if model_type is None:
+            issue.error_message.append("3D model's last revision has no recognized type.")
+
+        if instance_space is None or last_revision_id is None or model_type is None or issue.has_issues:
+            return None, issue
+
+        mapped_request = ThreeDMigrationRequest(
+            model_id=item.id,
+            type=model_type,
+            space=instance_space,
+            revision=ThreeDRevisionMigrationRequest(
+                space=instance_space,
+                type=model_type,
+                revision_id=last_revision_id,
+                model=Model(
+                    instance_id=InstanceIdentifier(
+                        space=instance_space,
+                        external_id=f"cog_3d_model_{item.id!s}",
+                    )
+                ),
+            ),
+        )
+        return mapped_request, issue
+
+    @staticmethod
+    def _get_type(revision: RevisionStatus) -> Literal["CAD", "PointCloud", "Image360"] | None:
+        types = revision.types or []
+        if any("gltf-directory" in t for t in types):
+            return "CAD"
+        elif any("ept-pointcloud" in t for t in types):
+            return "PointCloud"
+        else:
+            return None
+
+
+class ThreeDAssetMapper(DataMapper[ThreeDSelector, AssetMappingClassicResponse, AssetMappingDMRequest]):
+    def map(self, source: Sequence[AssetMappingClassicResponse]) -> Sequence[AssetMappingDMRequest | None]:
+        output: list[AssetMappingDMRequest | None] = []
+        issues: list[ThreeDModelMigrationIssue] = []
+        self._populate_cache(source)
+        for item in source:
+            mapped_item, issue = self._map_single_item(item)
+            identifier = f"AssetMapping_{item.model_id!s}_{item.revision_id!s}_{item.asset_id!s}"
+
+            if issue.error_message:
+                for error in issue.error_message:
+                    self.logger.tracker.add_issue(identifier, error)
+
+            if issue.has_issues:
+                issues.append(issue)
+
+            if mapped_item is None:
+                self.logger.tracker.finalize_item(identifier, "failure")
+
+            output.append(mapped_item)
+        if issues:
+            self.logger.log(issues)
+        return output
+
+    def _populate_cache(self, source: Sequence[AssetMappingClassicResponse]) -> 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: AssetMappingClassicResponse
+    ) -> tuple[AssetMappingDMRequest | None, ThreeDModelMigrationIssue]:
+        issue = ThreeDModelMigrationIssue(
+            model_name=f"AssetMapping_{item.model_id}", model_id=item.model_id, id=f"AssetMapping_{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, external_id=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(
+            model_id=item.model_id,
+            revision_id=item.revision_id,
+            node_id=item.node_id,
+            asset_instance_id=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/default_mappings.py

@@ -2,7 +2,7 @@ from functools import lru_cache
 
 from cognite.client.data_classes.data_modeling import ViewId
 
-from cognite_toolkit._cdf_tk.client.data_classes.migration import ResourceViewMappingApply
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import ResourceViewMappingApply
 
 ASSET_ID = "cdf_asset_mapping"
 EVENT_ID = "cdf_event_mapping"