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

cognite_toolkit/_cdf_tk/commands/_migrate/data_mapper.py

@@ -15,24 +15,23 @@ 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.charts_data import (
+from cognite_toolkit._cdf_tk.client.resource_classes.charts_data import (
     ChartCoreTimeseries,
     ChartSource,
     ChartTimeseries,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.instance_api import InstanceIdentifier
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.canvas import (
+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.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 (
+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,
-    AssetMappingResponse,
-    NodeReference,
     RevisionStatus,
     ThreeDModelResponse,
 )
@@ -47,22 +46,26 @@ from cognite_toolkit._cdf_tk.commands._migrate.issues import (
     CanvasMigrationIssue,
     ChartMigrationIssue,
     ConversionIssue,
-    MigrationIssue,
     ThreeDModelMigrationIssue,
 )
 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.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.
 
@@ -74,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.")
@@ -91,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)
@@ -119,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(
@@ -155,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:
@@ -185,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:
@@ -281,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
@@ -341,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)
@@ -354,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
@@ -370,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,
@@ -400,17 +467,26 @@ class CanvasMapper(DataMapper[CanvasSelector, IndustrialCanvas, IndustrialCanvas
 
 
 class ThreeDMapper(DataMapper[ThreeDSelector, ThreeDModelResponse, ThreeDMigrationRequest]):
-    def __init__(self, client: ToolkitClient) -> None:
-        self.client = client
-
-    def map(
-        self, source: Sequence[ThreeDModelResponse]
-    ) -> Sequence[tuple[ThreeDMigrationRequest | None, MigrationIssue]]:
+    def map(self, source: Sequence[ThreeDModelResponse]) -> Sequence[ThreeDMigrationRequest | None]:
         self._populate_cache(source)
-        output: list[tuple[ThreeDMigrationRequest | None, MigrationIssue]] = []
+        output: list[ThreeDMigrationRequest | None] = []
+        issues: list[ThreeDModelMigrationIssue] = []
         for item in source:
             mapped_item, issue = self._map_single_item(item)
-            output.append((mapped_item, issue))
+            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:
@@ -423,7 +499,7 @@ class ThreeDMapper(DataMapper[ThreeDSelector, ThreeDModelResponse, ThreeDMigrati
     def _map_single_item(
         self, item: ThreeDModelResponse
     ) -> tuple[ThreeDMigrationRequest | None, ThreeDModelMigrationIssue]:
-        issue = ThreeDModelMigrationIssue(model_name=item.name, model_id=item.id)
+        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
@@ -450,15 +526,15 @@ class ThreeDMapper(DataMapper[ThreeDSelector, ThreeDModelResponse, ThreeDMigrati
             return None, issue
 
         mapped_request = ThreeDMigrationRequest(
-            modelId=item.id,
+            model_id=item.id,
             type=model_type,
             space=instance_space,
             revision=ThreeDRevisionMigrationRequest(
                 space=instance_space,
                 type=model_type,
-                revisionId=last_revision_id,
+                revision_id=last_revision_id,
                 model=Model(
-                    instanceId=InstanceIdentifier(
+                    instance_id=InstanceIdentifier(
                         space=instance_space,
                         external_id=f"cog_3d_model_{item.id!s}",
                     )
@@ -478,21 +554,31 @@ class ThreeDMapper(DataMapper[ThreeDSelector, ThreeDModelResponse, ThreeDMigrati
             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]] = []
+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)
-            output.append((mapped_item, issue))
+            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[AssetMappingResponse]) -> None:
+    def _populate_cache(self, source: Sequence[AssetMappingClassicResponse]) -> None:
         asset_ids: set[int] = set()
         for mapping in source:
             if mapping.asset_id is not None:
@@ -500,21 +586,26 @@ class ThreeDAssetMapper(DataMapper[ThreeDSelector, AssetMappingResponse, AssetMa
         self.client.migration.lookup.assets(list(asset_ids))
 
     def _map_single_item(
-        self, item: AssetMappingResponse
+        self, item: AssetMappingClassicResponse
     ) -> tuple[AssetMappingDMRequest | None, ThreeDModelMigrationIssue]:
-        issue = ThreeDModelMigrationIssue(model_name=f"AssetMapping_{item.model_id}", model_id=item.model_id)
+        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, externalId=asset_node_id.external_id)
+            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(
-            modelId=item.model_id, revisionId=item.revision_id, nodeId=item.node_id, assetInstanceId=asset_instance_id
+            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/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.legacy.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"

cognite_toolkit/_cdf_tk/commands/_migrate/issues.py

@@ -1,34 +1,27 @@
-import json
-from typing import Any, ClassVar
+from typing import Any, Literal
 
-from cognite.client.data_classes.data_modeling import NodeId
-from cognite.client.utils._identifier import InstanceId
-from cognite.client.utils._text import to_camel_case
 from pydantic import BaseModel, Field, field_serializer
+from pydantic.alias_generators import to_camel
 
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.migration import AssetCentricId
-from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
+from cognite_toolkit._cdf_tk.client.resource_classes.data_modeling import NodeReference
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import AssetCentricId
+from cognite_toolkit._cdf_tk.storageio.logger import LogEntry
 
 
-class MigrationObject(BaseModel, alias_generator=to_camel_case, extra="ignore", populate_by_name=True): ...
-
-
-class MigrationIssue(MigrationObject):
+class MigrationIssue(LogEntry):
     """Represents an issue encountered during migration."""
 
-    type: ClassVar[str]
-
-    def dump(self) -> dict[str, JsonVal]:
-        # Dump json to ensure it is serializable
-        dumped = json.loads(self.model_dump_json(by_alias=True))
-        dumped["type"] = self.type
-        return dumped
+    type: str
 
     @property
     def has_issues(self) -> bool:
         """Check if there are any issues recorded in this MigrationIssue."""
         return True
 
+    def dump(self) -> dict[str, Any]:
+        """Serialize the MigrationIssue to a dictionary."""
+        return self.model_dump(by_alias=True)
+
 
 class ThreeDModelMigrationIssue(MigrationIssue):
     """Represents a 3D model migration issue encountered during migration.
@@ -37,7 +30,7 @@ class ThreeDModelMigrationIssue(MigrationIssue):
         model_external_id (str): The external ID of the 3D model that could not be migrated.
     """
 
-    type: ClassVar[str] = "threeDModelMigration"
+    type: Literal["threeDModelMigration"] = "threeDModelMigration"
     model_name: str
     model_id: int
     error_message: list[str] = Field(default_factory=list)
@@ -55,7 +48,7 @@ class ChartMigrationIssue(MigrationIssue):
         chart_external_id (str): The external ID of the chart that could not be migrated.
     """
 
-    type: ClassVar[str] = "chartMigration"
+    type: Literal["chartMigration"] = "chartMigration"
     chart_external_id: str
     missing_timeseries_ids: list[int] = Field(default_factory=list)
     missing_timeseries_external_ids: list[str] = Field(default_factory=list)
@@ -70,7 +63,7 @@ class ChartMigrationIssue(MigrationIssue):
 
 
 class CanvasMigrationIssue(MigrationIssue):
-    type: ClassVar[str] = "canvasMigration"
+    type: Literal["canvasMigration"] = "canvasMigration"
     canvas_external_id: str
     canvas_name: str
     missing_reference_ids: list[AssetCentricId] = Field(default_factory=list)
@@ -84,7 +77,7 @@ class CanvasMigrationIssue(MigrationIssue):
 class ReadIssue(MigrationIssue):
     """Represents a read issue encountered during migration."""
 
-    type: ClassVar[str] = "read"
+    ...
 
 
 class ReadFileIssue(ReadIssue):
@@ -95,7 +88,7 @@ class ReadFileIssue(ReadIssue):
         error (str | None): An optional error message providing additional details about the read issue.
     """
 
-    type: ClassVar[str] = "fileRead"
+    type: Literal["fileRead"] = "fileRead"
 
     row_no: int
     error: str | None = None
@@ -109,7 +102,7 @@ class ReadAPIIssue(ReadIssue):
         error (str | None): An optional error message providing additional details about the read issue.
     """
 
-    type: ClassVar[str] = "apiRead"
+    type: Literal["apiRead"] = "apiRead"
     asset_centric_id: AssetCentricId
     error: str | None = None
 
@@ -121,7 +114,7 @@ class ReadAPIIssue(ReadIssue):
         }
 
 
-class FailedConversion(MigrationObject):
+class FailedConversion(BaseModel, alias_generator=to_camel, extra="ignore", populate_by_name=True):
     """Represents a property that failed to convert during migration.
 
     Attributes:
@@ -135,7 +128,7 @@ class FailedConversion(MigrationObject):
     error: str
 
 
-class InvalidPropertyDataType(MigrationObject):
+class InvalidPropertyDataType(BaseModel, alias_generator=to_camel, extra="ignore", populate_by_name=True):
     """Represents a property with an invalid type during migration.
 
     Attributes:
@@ -160,9 +153,9 @@ class ConversionIssue(MigrationIssue):
         failed_conversions (list[FailedConversion]): List of properties that failed to convert with reasons.
     """
 
-    type: ClassVar[str] = "conversion"
+    type: Literal["conversion"] = "conversion"
     asset_centric_id: AssetCentricId
-    instance_id: InstanceId
+    instance_id: NodeReference
     missing_asset_centric_properties: list[str] = Field(default_factory=list)
     missing_instance_properties: list[str] = Field(default_factory=list)
     invalid_instance_property_types: list[InvalidPropertyDataType] = Field(default_factory=list)
@@ -181,10 +174,6 @@ class ConversionIssue(MigrationIssue):
             or self.missing_instance_space
         )
 
-    @field_serializer("instance_id")
-    def serialize_instance_id(self, instance_id: NodeId) -> dict[str, str]:
-        return instance_id.dump(include_instance_type=True)
-
     @field_serializer("asset_centric_id")
     def serialize_asset_centric_id(self, asset_centric_id: AssetCentricId) -> dict[str, Any]:
         return {
@@ -197,16 +186,10 @@ class WriteIssue(MigrationIssue):
     """Represents a write issue encountered during migration.
 
     Attributes:
-        instance_id (InstanceId): The InstanceId of the data model instance that could not be written.
         status_code (int): The HTTP status code returned during the write operation.
         message (str | None): An optional message providing additional details about the write issue.
     """
 
-    type: ClassVar[str] = "write"
-    instance_id: InstanceId
+    type: Literal["write"] = "write"
     status_code: int
     message: str | None = None
-
-    @field_serializer("instance_id")
-    def serialize_instance_id(self, instance_id: NodeId) -> dict[str, str]:
-        return instance_id.dump(include_instance_type=True)