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

cognite_toolkit/_cdf_tk/client/data_classes/{migration.py → legacy/migration.py}

@@ -16,7 +16,7 @@ from cognite.client.data_classes.data_modeling.instances import (
 
 from cognite_toolkit._cdf_tk.constants import COGNITE_MIGRATION_SPACE
 from cognite_toolkit._cdf_tk.tk_warnings import IgnoredValueWarning
-from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricType
+from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricType, AssetCentricTypeExtended
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -26,7 +26,7 @@ else:
 
 @dataclass(frozen=True)
 class AssetCentricId(CogniteObject):
-    resource_type: AssetCentricType
+    resource_type: AssetCentricTypeExtended
     id_: int
 
     @classmethod
@@ -114,6 +114,14 @@ class InstanceSource(_InstanceSourceProperties, TypedNode):
         self.preferred_consumer_view_id = preferred_consumer_view_id
         self.ingestion_view = DirectRelationReference.load(ingestion_view) if ingestion_view else None
 
+    def dump(self, camel_case: bool = True) -> dict[str, Any]:
+        output = super().dump(camel_case)
+        if self.preferred_consumer_view_id:
+            output["properties"]["cognite_migration"]["InstanceSource/v1"]["preferredConsumerViewId"] = (
+                self.preferred_consumer_view_id.dump(camel_case=camel_case)
+            )
+        return output
+
     @classmethod
     def _load_properties(cls, resource: dict[str, Any]) -> dict[str, Any]:
         if "preferredConsumerViewId" in resource:

cognite_toolkit/_cdf_tk/client/data_classes/streams.py

@@ -0,0 +1,90 @@
+from typing import Literal
+
+from cognite_toolkit._cdf_tk.constants import StreamTemplateName
+from cognite_toolkit._cdf_tk.protocols import (
+    ResourceRequestListProtocol,
+    ResourceResponseListProtocol,
+)
+
+from .base import BaseModelObject, BaseResourceList, RequestResource, ResponseResource
+
+
+class StreamRequest(RequestResource):
+    """Stream request resource class."""
+
+    external_id: str
+    settings: dict[Literal["template"], dict[Literal["name"], StreamTemplateName]]
+
+    def as_id(self) -> str:
+        return self.external_id
+
+
+class StreamRequestList(BaseResourceList[StreamRequest], ResourceRequestListProtocol):
+    """List of Stream request resources."""
+
+    _RESOURCE = StreamRequest
+
+
+class LifecycleObject(BaseModelObject):
+    """Lifecycle object."""
+
+    hot_phase_duration: str | None = None
+    data_deleted_after: str | None = None
+    retained_after_soft_delete: str
+
+
+class ResourceUsage(BaseModelObject):
+    """Resource quota with provisioned and consumed values."""
+
+    provisioned: int
+    consumed: int | None = None
+
+
+class LimitsObject(BaseModelObject):
+    """Limits object."""
+
+    max_records_total: ResourceUsage
+    max_giga_bytes_total: ResourceUsage
+    max_filtering_interval: str | None = None
+
+
+class StreamSettings(BaseModelObject):
+    """Stream settings object."""
+
+    lifecycle: LifecycleObject
+    limits: LimitsObject
+
+
+class StreamResponse(ResponseResource["StreamRequest"]):
+    """Stream response resource class."""
+
+    external_id: str
+    created_time: int
+    created_from_template: StreamTemplateName
+    type: Literal["Mutable", "Immutable"]
+    settings: StreamSettings | None = None
+
+    def as_request_resource(self) -> StreamRequest:
+        return StreamRequest.model_validate(
+            {
+                "externalId": self.external_id,
+                "settings": {"template": {"name": self.created_from_template}},
+            }
+        )
+
+    def as_write(self) -> StreamRequest:
+        return StreamRequest.model_validate(
+            {
+                "externalId": self.external_id,
+                "settings": {"template": {"name": self.created_from_template}},
+            }
+        )
+
+
+class StreamResponseList(BaseResourceList[StreamResponse], ResourceResponseListProtocol):
+    """List of Stream response resources."""
+
+    _RESOURCE = StreamResponse
+
+    def as_write(self) -> StreamRequestList:
+        return StreamRequestList([item.as_write() for item in self.data])

cognite_toolkit/_cdf_tk/client/data_classes/three_d.py

@@ -0,0 +1,112 @@
+from collections.abc import Hashable
+from typing import Literal
+
+from pydantic import Field
+
+from .base import BaseModelObject, RequestResource, ResponseResource
+
+
+class NodeReference(BaseModelObject):
+    space: str
+    external_id: str
+
+
+class RevisionStatus(BaseModelObject):
+    status: Literal["Queued", "Processing", "Done", "Failed"] | None = None
+    revision_id: int | None = None
+    created_time: int | None = None
+    revision_count: int | None = None
+    types: list[str] | None = None
+
+
+class ThreeDModelRequest(RequestResource):
+    name: str
+
+    def as_id(self) -> str:
+        return self.name
+
+
+class ThreeDModelClassicRequest(ThreeDModelRequest):
+    data_set_id: int | None = None
+    metadata: dict[str, str] | None = None
+
+    def as_id(self) -> str:
+        return self.name
+
+
+class ThreeDModelDMSRequest(ThreeDModelRequest):
+    space: str
+    type: Literal["CAD", "PointCloud", "Image360"]
+    thumbnail_reference: NodeReference | None = None
+
+
+class ThreeDModelResponse(ResponseResource[ThreeDModelRequest]):
+    name: str
+    id: int
+    created_time: int
+    data_set_id: int | None = None
+    metadata: dict[str, str] | None = None
+    space: str | None = None
+    last_revision_info: RevisionStatus | None = None
+
+    def as_request_resource(self) -> ThreeDModelRequest:
+        if self.space is None:
+            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/client/testing.py

@@ -12,17 +12,27 @@ from cognite.client.testing import CogniteClientMock
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client._toolkit_client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.api.legacy.canvas import CanvasAPI, IndustrialCanvasAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.charts import ChartsAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.dml import DMLAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.extended_data_modeling import ExtendedInstancesAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.extended_files import ExtendedFileMetadataAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.extended_functions import ExtendedFunctionsAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.extended_raw import ExtendedRawAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.extended_timeseries import ExtendedTimeSeriesAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.location_filters import LocationFiltersAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.robotics import (
+    CapabilitiesAPI,
+    DataPostProcessingAPI,
+    FramesAPI,
+    MapsAPI,
+    RoboticsAPI,
+)
+from cognite_toolkit._cdf_tk.client.api.legacy.robotics import LocationsAPI as RoboticsLocationsAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.search_config import SearchConfigurationsAPI
 
-from .api.canvas import CanvasAPI, IndustrialCanvasAPI
-from .api.charts import ChartsAPI
-from .api.dml import DMLAPI
-from .api.extended_data_modeling import ExtendedInstancesAPI
-from .api.extended_files import ExtendedFileMetadataAPI
-from .api.extended_functions import ExtendedFunctionsAPI
-from .api.extended_raw import ExtendedRawAPI
-from .api.extended_timeseries import ExtendedTimeSeriesAPI
-from .api.infield import InfieldAPI, InfieldConfigAPI
-from .api.location_filters import LocationFiltersAPI
+from ._toolkit_client import ToolAPI
+from .api.infield import InfieldAPI, InFieldCDMConfigAPI, InfieldConfigAPI
 from .api.lookup import (
     AssetLookUpAPI,
     DataSetLookUpAPI,
@@ -35,16 +45,18 @@ from .api.lookup import (
     SecurityCategoriesLookUpAPI,
     TimeSeriesLookUpAPI,
 )
-from .api.migration import CreatedSourceSystemAPI, InstanceSourceAPI, MigrationAPI, ResourceViewMappingAPI
+from .api.migration import (
+    CreatedSourceSystemAPI,
+    InstanceSourceAPI,
+    LookupAPI,
+    MigrationAPI,
+    MigrationLookupAPI,
+    ResourceViewMappingAPI,
+)
 from .api.project import ProjectAPI
-from .api.robotics import RoboticsAPI
-from .api.robotics.capabilities import CapabilitiesAPI
-from .api.robotics.data_postprocessing import DataPostProcessingAPI
-from .api.robotics.frames import FramesAPI
-from .api.robotics.locations import LocationsAPI as RoboticsLocationsAPI
-from .api.robotics.maps import MapsAPI
 from .api.search import SearchAPI
-from .api.search_config import SearchConfigurationsAPI
+from .api.streams import StreamsAPI
+from .api.three_d import ThreeDAPI, ThreeDModelAPI
 from .api.token import TokenAPI
 from .api.verify import VerifyAPI
 
@@ -76,6 +88,7 @@ class ToolkitClientMock(CogniteClientMock):
         self.functions.schedules = MagicMock(spec_set=FunctionSchedulesAPI)
         self.infield = MagicMock(spec=InfieldAPI)
         self.infield.config = MagicMock(spec_set=InfieldConfigAPI)
+        self.infield.cdm_config = MagicMock(spec_set=InFieldCDMConfigAPI)
 
         self.project = MagicMock(spec_set=ProjectAPI)
 
@@ -95,6 +108,11 @@ class ToolkitClientMock(CogniteClientMock):
         self.lookup.functions = MagicMock(spec_set=FunctionLookUpAPI)
         self.migration = MagicMock(spec=MigrationAPI)
         self.migration.instance_source = MagicMock(spec_set=InstanceSourceAPI)
+        self.migration.lookup = MagicMock(spec=MigrationLookupAPI)
+        self.migration.lookup.assets = MagicMock(spec_set=LookupAPI)
+        self.migration.lookup.events = MagicMock(spec_set=LookupAPI)
+        self.migration.lookup.files = MagicMock(spec_set=LookupAPI)
+        self.migration.lookup.time_series = MagicMock(spec_set=LookupAPI)
         self.migration.resource_view_mapping = MagicMock(spec_set=ResourceViewMappingAPI)
         self.migration.created_source_system = MagicMock(spec_set=CreatedSourceSystemAPI)
         self.raw = MagicMock(spec=ExtendedRawAPI)
@@ -117,6 +135,12 @@ class ToolkitClientMock(CogniteClientMock):
         self.time_series.data.synthetic = MagicMock(spec_set=SyntheticDatapointsAPI)
         self.time_series.subscriptions = MagicMock(spec_set=DatapointsSubscriptionAPI)
 
+        self.tool = MagicMock(spec=ToolAPI)
+        self.tool.three_d = MagicMock(spec=ThreeDAPI)
+        self.tool.three_d.models = MagicMock(spec_set=ThreeDModelAPI)
+
+        self.streams = MagicMock(spec=StreamsAPI)
+
         # This is a helper API, not a real API.
         self.token = TokenAPI(self)
         self.verify = MagicMock(spec_set=VerifyAPI)

cognite_toolkit/_cdf_tk/commands/__init__.py

@@ -1,37 +1,37 @@
 from ._download import DownloadCommand
 from ._migrate import (
-    MigrationCanvasCommand,
+    MigrationCommand,
     MigrationPrepareCommand,
 )
 from ._profile import ProfileAssetCentricCommand, ProfileAssetCommand, ProfileRawCommand, ProfileTransformationCommand
 from ._purge import PurgeCommand
 from ._upload import UploadCommand
+from .about import AboutCommand
 from .auth import AuthCommand
 from .build_cmd import BuildCommand
 from .clean import CleanCommand
 from .collect import CollectCommand
 from .deploy import DeployCommand
-from .dump_data import DumpDataCommand
 from .dump_resource import DumpResourceCommand
-from .featureflag import FeatureFlagCommand
 from .init import InitCommand
 from .modules import ModulesCommand
 from .pull import PullCommand
 from .repo import RepoCommand
+from .resources import ResourcesCommand
 from .run import RunFunctionCommand, RunTransformationCommand, RunWorkflowCommand
 
 __all__ = [
+    "AboutCommand",
     "AuthCommand",
     "BuildCommand",
+    "BuildCommandV2",
     "CleanCommand",
     "CollectCommand",
     "DeployCommand",
     "DownloadCommand",
-    "DumpDataCommand",
     "DumpResourceCommand",
-    "FeatureFlagCommand",
     "InitCommand",
-    "MigrationCanvasCommand",
+    "MigrationCommand",
     "MigrationPrepareCommand",
     "ModulesCommand",
     "ProfileAssetCentricCommand",
@@ -41,6 +41,7 @@ __all__ = [
     "PullCommand",
     "PurgeCommand",
     "RepoCommand",
+    "ResourcesCommand",
     "RunFunctionCommand",
     "RunTransformationCommand",
     "RunWorkflowCommand",

cognite_toolkit/_cdf_tk/commands/_changes.py

@@ -11,9 +11,8 @@ from packaging.version import Version
 from packaging.version import parse as parse_version
 from rich import print
 
-from cognite_toolkit._cdf_tk.builders import get_loader
+from cognite_toolkit._cdf_tk.cdf_toml import CDFToml
 from cognite_toolkit._cdf_tk.constants import DOCKER_IMAGE_NAME
-from cognite_toolkit._cdf_tk.data_classes import ModuleDirectories
 from cognite_toolkit._cdf_tk.utils import iterate_modules, read_yaml_file, safe_read, safe_write
 from cognite_toolkit._version import __version__
 
@@ -51,40 +50,6 @@ class ManualChange(Change):
         return ""
 
 
-class SetKindOnFile(AutomaticChange):
-    """Adds the kind to the filename of all resource files.
-
-Before `your_file.yaml`:
-After `your_file.FileMetadata.yaml`:
-    """
-
-    deprecated_from = Version("0.4.0")
-    has_file_changes = True
-
-    def do(self) -> set[Path]:
-        module_directories = ModuleDirectories.load(self._organization_dir)
-        changed: set[Path] = set()
-        for module in module_directories:
-            for resource_folder, source_files in module.source_paths_by_resource_folder.items():
-                for source_file in source_files:
-                    if source_file.suffix not in {".yaml", ".yml"}:
-                        continue
-                    loader, _ = get_loader(source_file, resource_folder, force_pattern=True)
-                    if loader is None:
-                        print(f"Could not find loader for {source_file}")
-                        continue
-                    if source_file.stem.casefold().endswith(loader.kind.casefold()):
-                        continue
-                    new_name = source_file.with_name(f"{source_file.stem}.{loader.kind}{source_file.suffix}")
-                    source_file.rename(new_name)
-                    changed.add(source_file)
-                    for suffix in [".sql", ".csv", ".parquet"]:
-                        if (adjacent_file := source_file.with_suffix(suffix)).exists():
-                            adjacent_file.rename(new_name.with_suffix(suffix))
-                            changed.add(adjacent_file)
-
-        return changed
-
 
 class FixViewBasedLocationFilter(AutomaticChange):
     """The created view-based location filter has been fixed to be compatible with the CDF API.
@@ -362,7 +327,6 @@ After:
 
     def do(self) -> set[Path]:
         # Avoid circular import
-        from .modules import ModulesCommand
 
         system_yaml = self._organization_dir / "_system.yaml"
         if not system_yaml.exists():
@@ -372,11 +336,8 @@ After:
         content = read_yaml_file(system_yaml)
         current_version = content.get("cdf_toolkit_version", __version__)
 
-        cdf_toml_content = ModulesCommand(skip_tracking=True).create_cdf_toml(self._organization_dir)
-        cdf_toml_content = cdf_toml_content.replace(f'version = "{__version__}"', f'version = "{current_version}"')
-
-        cdf_toml_path = Path.cwd() / "cdf.toml"
-        cdf_toml_path.write_text(cdf_toml_content, encoding="utf-8")
+        CDFToml.write(self._organization_dir, version=current_version)
+        cdf_toml_path = Path.cwd() / CDFToml.file_name
         system_yaml.unlink()
         return {cdf_toml_path, system_yaml}
 

cognite_toolkit/_cdf_tk/commands/_download.py

@@ -2,14 +2,24 @@ from collections.abc import Callable, Iterable
 from functools import partial
 from pathlib import Path
 
-from cognite.client.data_classes._base import T_CogniteResource
-
 from cognite_toolkit._cdf_tk.constants import DATA_MANIFEST_STEM, DATA_RESOURCE_DIR
 from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
-from cognite_toolkit._cdf_tk.storageio import ConfigurableStorageIO, Page, StorageIO, T_Selector, TableStorageIO
+from cognite_toolkit._cdf_tk.protocols import T_ResourceResponse
+from cognite_toolkit._cdf_tk.storageio import (
+    ConfigurableStorageIO,
+    Page,
+    StorageIO,
+    T_Selector,
+    TableStorageIO,
+)
 from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning
 from cognite_toolkit._cdf_tk.utils.file import safe_write, sanitize_filename, yaml_safe_dump
-from cognite_toolkit._cdf_tk.utils.fileio import TABLE_WRITE_CLS_BY_FORMAT, Compression, FileWriter, SchemaColumn
+from cognite_toolkit._cdf_tk.utils.fileio import (
+    TABLE_WRITE_CLS_BY_FORMAT,
+    Compression,
+    FileWriter,
+    SchemaColumn,
+)
 from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
@@ -20,7 +30,7 @@ class DownloadCommand(ToolkitCommand):
     def download(
         self,
         selectors: Iterable[T_Selector],
-        io: StorageIO[T_Selector, T_CogniteResource],
+        io: StorageIO[T_Selector, T_ResourceResponse],
         output_dir: Path,
         verbose: bool,
         file_format: str,
@@ -68,7 +78,7 @@ class DownloadCommand(ToolkitCommand):
             with FileWriter.create_from_format(
                 file_format, target_dir, selector.kind, compression_cls, columns=columns
             ) as writer:
-                executor = ProducerWorkerExecutor[Page[T_CogniteResource], list[dict[str, JsonVal]]](
+                executor = ProducerWorkerExecutor[Page[T_ResourceResponse], list[dict[str, JsonVal]]](
                     download_iterable=io.stream_data(selector, limit),
                     process=self.create_data_process(io=io, selector=selector, is_table=is_table),
                     write=partial(writer.write_chunks, filestem=filestem),
@@ -95,7 +105,7 @@ class DownloadCommand(ToolkitCommand):
 
     @staticmethod
     def _get_iteration_count(
-        io: StorageIO[T_Selector, T_CogniteResource],
+        io: StorageIO[T_Selector, T_ResourceResponse],
         selector: T_Selector,
         limit: int | None,
     ) -> int | None:
@@ -126,19 +136,19 @@ class DownloadCommand(ToolkitCommand):
 
     @staticmethod
     def create_data_process(
-        io: StorageIO[T_Selector, T_CogniteResource],
+        io: StorageIO[T_Selector, T_ResourceResponse],
         selector: T_Selector,
         is_table: bool,
-    ) -> Callable[[Page[T_CogniteResource]], list[dict[str, JsonVal]]]:
+    ) -> Callable[[Page[T_ResourceResponse]], list[dict[str, JsonVal]]]:
         """Creates a data processing function based on the IO type and whether the output is a table."""
         if is_table and isinstance(io, TableStorageIO):
 
-            def row_data_process(chunk: Page[T_CogniteResource]) -> list[dict[str, JsonVal]]:
+            def row_data_process(chunk: Page[T_ResourceResponse]) -> list[dict[str, JsonVal]]:
                 return io.data_to_row(chunk.items, selector)
 
             return row_data_process
 
-        def chunk_data_process(data_page: Page[T_CogniteResource]) -> list[dict[str, JsonVal]]:
+        def chunk_data_process(data_page: Page[T_ResourceResponse]) -> list[dict[str, JsonVal]]:
             return io.data_to_json_chunk(data_page.items, selector)
 
         return chunk_data_process

cognite_toolkit/_cdf_tk/commands/_migrate/__init__.py

@@ -1,9 +1,7 @@
-from .canvas import MigrationCanvasCommand
 from .command import MigrationCommand
 from .prepare import MigrationPrepareCommand
 
 __all__ = [
-    "MigrationCanvasCommand",
     "MigrationCommand",
     "MigrationPrepareCommand",
 ]

cognite_toolkit/_cdf_tk/commands/_migrate/command.py

@@ -2,7 +2,6 @@ from collections.abc import Callable, Iterable, Sequence
 from enum import Enum
 from pathlib import Path
 
-from cognite.client.data_classes._base import T_CogniteResource
 from rich import print
 from rich.console import Console
 from rich.table import Table
@@ -20,6 +19,7 @@ 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 import T_Selector, UploadableStorageIO, UploadItem
 from cognite_toolkit._cdf_tk.utils import humanize_collection, safe_write, sanitize_filename
 from cognite_toolkit._cdf_tk.utils.file import yaml_safe_dump
@@ -27,7 +27,6 @@ from cognite_toolkit._cdf_tk.utils.fileio import Chunk, CSVWriter, NDJsonWriter,
 from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, HTTPMessage, ItemMessage, SuccessResponseItems
 from cognite_toolkit._cdf_tk.utils.producer_worker import ProducerWorkerExecutor
 from cognite_toolkit._cdf_tk.utils.progress_tracker import AVAILABLE_STATUS, ProgressTracker, Status
-from cognite_toolkit._cdf_tk.utils.useful_types import T_WriteCogniteResource
 
 from .data_model import INSTANCE_SOURCE_VIEW_ID, MODEL_ID, RESOURCE_VIEW_MAPPING_VIEW_ID
 
@@ -45,8 +44,8 @@ class MigrationCommand(ToolkitCommand):
     def migrate(
         self,
         selected: T_Selector,
-        data: UploadableStorageIO[T_Selector, T_CogniteResource, T_WriteCogniteResource],
-        mapper: DataMapper[T_Selector, T_CogniteResource, T_WriteCogniteResource],
+        data: UploadableStorageIO[T_Selector, T_ResourceResponse, T_ResourceRequest],
+        mapper: DataMapper[T_Selector, T_ResourceResponse, T_ResourceRequest],
         log_dir: Path,
         dry_run: bool = False,
         verbose: bool = False,
@@ -71,9 +70,7 @@ class MigrationCommand(ToolkitCommand):
             NDJsonWriter(log_dir, kind=f"{selected.kind}MigrationIssues", compression=Uncompressed) as log_file,
             HTTPClient(config=data.client.config) as write_client,
         ):
-            executor = ProducerWorkerExecutor[
-                Sequence[T_CogniteResource], Sequence[UploadItem[T_WriteCogniteResource]]
-            ](
+            executor = ProducerWorkerExecutor[Sequence[T_ResourceResponse], Sequence[UploadItem[T_ResourceRequest]]](
                 download_iterable=self._download_iterable(selected, data, tracker),
                 process=self._convert(mapper, data, tracker, log_file),
                 write=self._upload(selected, write_client, data, tracker, log_file, dry_run),
@@ -141,9 +138,9 @@ class MigrationCommand(ToolkitCommand):
     def _download_iterable(
         self,
         selected: T_Selector,
-        data: UploadableStorageIO[T_Selector, T_CogniteResource, T_WriteCogniteResource],
+        data: UploadableStorageIO[T_Selector, T_ResourceResponse, T_ResourceRequest],
         tracker: ProgressTracker[str],
-    ) -> Iterable[Sequence[T_CogniteResource]]:
+    ) -> Iterable[Sequence[T_ResourceResponse]]:
         for page in data.stream_data(selected):
             for item in page.items:
                 tracker.set_progress(data.as_id(item), self.Steps.DOWNLOAD, "success")
@@ -151,16 +148,17 @@ class MigrationCommand(ToolkitCommand):
 
     def _convert(
         self,
-        mapper: DataMapper[T_Selector, T_CogniteResource, T_WriteCogniteResource],
-        data: UploadableStorageIO[T_Selector, T_CogniteResource, T_WriteCogniteResource],
+        mapper: DataMapper[T_Selector, T_ResourceResponse, T_ResourceRequest],
+        data: UploadableStorageIO[T_Selector, T_ResourceResponse, T_ResourceRequest],
         tracker: ProgressTracker[str],
         log_file: NDJsonWriter,
-    ) -> Callable[[Sequence[T_CogniteResource]], Sequence[UploadItem[T_WriteCogniteResource]]]:
-        def track_mapping(source: Sequence[T_CogniteResource]) -> list[UploadItem[T_WriteCogniteResource]]:
+    ) -> Callable[[Sequence[T_ResourceResponse]], Sequence[UploadItem[T_ResourceRequest]]]:
+        def track_mapping(source: Sequence[T_ResourceResponse]) -> list[UploadItem[T_ResourceRequest]]:
+            mapped = mapper.map(source)
             issues: list[Chunk] = []
-            targets: list[UploadItem[T_WriteCogniteResource]] = []
-            for item in source:
-                target, issue = mapper.map(item)
+            targets: list[UploadItem[T_ResourceRequest]] = []
+
+            for (target, issue), item in zip(mapped, source):
                 id_ = data.as_id(item)
                 result: Status = "failed" if target is None else "success"
                 tracker.set_progress(id_, step=self.Steps.CONVERT, status=result)
@@ -180,17 +178,21 @@ class MigrationCommand(ToolkitCommand):
         self,
         selected: T_Selector,
         write_client: HTTPClient,
-        target: UploadableStorageIO[T_Selector, T_CogniteResource, T_WriteCogniteResource],
+        target: UploadableStorageIO[T_Selector, T_ResourceResponse, T_ResourceRequest],
         tracker: ProgressTracker[str],
         log_file: NDJsonWriter,
         dry_run: bool,
-    ) -> Callable[[Sequence[UploadItem[T_WriteCogniteResource]]], None]:
-        def upload_items(data_item: Sequence[UploadItem[T_WriteCogniteResource]]) -> None:
+    ) -> Callable[[Sequence[UploadItem[T_ResourceRequest]]], None]:
+        def upload_items(data_item: Sequence[UploadItem[T_ResourceRequest]]) -> None:
             if not data_item:
                 return None
             responses: Sequence[HTTPMessage]
             if dry_run:
-                responses = [SuccessResponseItems(200, "", [item.source_id for item in data_item])]
+                responses = [
+                    SuccessResponseItems(
+                        status_code=200, body="", content=b"", ids=[item.source_id for item in data_item]
+                    )
+                ]
             else:
                 responses = target.upload_items(data_chunk=data_item, http_client=write_client, selector=selected)