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

cognite_toolkit/_cdf.py

@@ -27,6 +27,7 @@ from cognite_toolkit._cdf_tk.apps import (
     DataApp,
     DevApp,
     DumpApp,
+    ImportApp,
     LandingApp,
     MigrateApp,
     ModulesApp,
@@ -42,7 +43,7 @@ from cognite_toolkit._cdf_tk.constants import HINT_LEAD_TEXT, URL, USE_SENTRY
 from cognite_toolkit._cdf_tk.exceptions import (
     ToolkitError,
 )
-from cognite_toolkit._cdf_tk.feature_flags import FeatureFlag, Flags
+from cognite_toolkit._cdf_tk.feature_flags import Flags
 from cognite_toolkit._cdf_tk.plugins import Plugins
 from cognite_toolkit._cdf_tk.tracker import Tracker
 from cognite_toolkit._cdf_tk.utils import (
@@ -108,6 +109,9 @@ if Flags.PROFILE.is_enabled():
 if Flags.MIGRATE.is_enabled():
     _app.add_typer(MigrateApp(**default_typer_kws), name="migrate")
 
+if Flags.IMPORT_CMD.is_enabled():
+    _app.add_typer(ImportApp(**default_typer_kws), name="import")
+
 if Plugins.data.value.is_enabled():
     _app.add_typer(DataApp(**default_typer_kws), name="data")
 
@@ -126,11 +130,6 @@ def app() -> NoReturn:
     # --- Main entry point ---
     # Users run 'app()' directly, but that doesn't allow us to control excepton handling:
     try:
-        if FeatureFlag.is_enabled(Flags.IMPORT_CMD):
-            from cognite_toolkit._cdf_tk.prototypes.import_app import import_app
-
-            _app.add_typer(import_app, name="import")
-
         _app()
     except ToolkitError as err:
         if "--verbose" in sys.argv:

cognite_toolkit/_cdf_tk/apps/__init__.py

@@ -4,6 +4,7 @@ from ._data_app import DataApp
 from ._dev_app import DevApp
 from ._download_app import DownloadApp
 from ._dump_app import DumpApp
+from ._import_app import ImportApp
 from ._landing_app import LandingApp
 from ._migrate_app import MigrateApp
 from ._modules_app import ModulesApp
@@ -20,6 +21,7 @@ __all__ = [
     "DevApp",
     "DownloadApp",
     "DumpApp",
+    "ImportApp",
     "LandingApp",
     "MigrateApp",
     "ModulesApp",

cognite_toolkit/_cdf_tk/apps/_core_app.py

@@ -13,8 +13,10 @@ from rich.panel import Panel
 from cognite_toolkit._cdf_tk.cdf_toml import CDFToml
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.commands import BuildCommand, CleanCommand, DeployCommand
+from cognite_toolkit._cdf_tk.commands.build_v2.build_cmd import BuildCommand as BuildCommandV2
 from cognite_toolkit._cdf_tk.commands.clean import AVAILABLE_DATA_TYPES
 from cognite_toolkit._cdf_tk.exceptions import ToolkitFileNotFoundError
+from cognite_toolkit._cdf_tk.feature_flags import Flags
 from cognite_toolkit._cdf_tk.utils import get_cicd_environment
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 from cognite_toolkit._version import __version__ as current_version
@@ -207,7 +209,11 @@ class CoreApp(typer.Typer):
         if exit_on_warning:
             print_warning = False
 
-        cmd = BuildCommand(print_warning=print_warning)
+        cmd = (
+            BuildCommandV2(print_warning=print_warning)
+            if Flags.v08.is_enabled()
+            else BuildCommand(print_warning=print_warning)
+        )
         cmd.run(
             lambda: cmd.execute(
                 verbose,

cognite_toolkit/_cdf_tk/apps/_download_app.py

@@ -7,7 +7,7 @@ import typer
 from questionary import Choice
 from rich import print
 
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawTable
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.raw import RawTable
 from cognite_toolkit._cdf_tk.commands import DownloadCommand
 from cognite_toolkit._cdf_tk.constants import DATA_DEFAULT_DIR
 from cognite_toolkit._cdf_tk.feature_flags import Flags
@@ -616,7 +616,7 @@ class DownloadApp(typer.Typer):
                 file_format = AssetCentricFormats.ndjson
             files = client.files.list(data_set_external_ids=data_sets, limit=limit)
             selector = FileIdentifierSelector(
-                identifiers=tuple([FileInternalID(internal_id=file.id) for file in files])  # type: ignore[call-arg]
+                identifiers=tuple([FileInternalID(internal_id=file.id) for file in files])
             )
             selectors = [selector]
             io = FileContentIO(client, output_dir / sanitize_filename(selector.group))

cognite_toolkit/_cdf_tk/apps/_dump_app.py

@@ -6,7 +6,7 @@ from cognite.client.data_classes import WorkflowVersionId
 from cognite.client.data_classes.data_modeling import DataModelId, ViewId
 from rich import print
 
-from cognite_toolkit._cdf_tk.client.data_classes.search_config import ViewId as SearchConfigViewId
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.search_config import ViewId as SearchConfigViewId
 from cognite_toolkit._cdf_tk.commands import DumpResourceCommand
 from cognite_toolkit._cdf_tk.commands.dump_resource import (
     AgentFinder,

cognite_toolkit/_cdf_tk/apps/_import_app.py

@@ -0,0 +1,41 @@
+from pathlib import Path
+from typing import Any
+
+import typer
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.commands._import_cmd import ImportTransformationCLI
+from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
+
+
+class ImportApp(typer.Typer):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.callback(invoke_without_command=True)(self.main)
+        self.command("transformation-cli")(self.transformation_cli)
+
+    def main(self, ctx: typer.Context) -> None:
+        """PREVIEW FEATURE Import resources into Cognite-Toolkit."""
+        if ctx.invoked_subcommand is None:
+            print("Use [bold yellow]cdf-tk import --help[/] for more information.")
+        return None
+
+    @staticmethod
+    def transformation_cli(
+        source: Path = typer.Argument(..., help="Path to the transformation CLI manifest directory or files."),
+        destination: Path = typer.Argument(..., help="Path to the destination directory."),
+        overwrite: bool = typer.Option(False, help="Overwrite destination if it already exists."),
+        flatten: bool = typer.Option(False, help="Flatten the directory structure."),
+        clean: bool = typer.Option(False, help="Remove the source directory after import."),
+        verbose: bool = typer.Option(False, help="Turn on to get more verbose output when running the command"),
+    ) -> None:
+        """Import transformation CLI manifests into Cognite-Toolkit modules."""
+
+        # We are lazy loading the client as we only need it if we need to look up dataset ids.
+        # This is to ensure the command can be executed without a client if the user does not need to look up dataset ids.
+        # (which is likely 99% of the time)
+        def get_client() -> ToolkitClient:
+            return EnvironmentVariables.create_from_environment().get_client()
+
+        cmd = ImportTransformationCLI(print_warning=True, get_client=get_client)
+        cmd.execute(source, destination, overwrite, flatten, clean, verbose=verbose)

cognite_toolkit/_cdf_tk/apps/_migrate_app.py

@@ -15,10 +15,18 @@ from cognite_toolkit._cdf_tk.commands._migrate.creators import (
     InstanceSpaceCreator,
     SourceSystemCreator,
 )
-from cognite_toolkit._cdf_tk.commands._migrate.data_mapper import AssetCentricMapper, CanvasMapper, ChartMapper
+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 (
     AssetCentricMigrationSelector,
@@ -26,7 +34,11 @@ from cognite_toolkit._cdf_tk.commands._migrate.selectors import (
     MigrationCSVFileSelector,
 )
 from cognite_toolkit._cdf_tk.storageio import CanvasIO, ChartIO
-from cognite_toolkit._cdf_tk.storageio.selectors import CanvasExternalIdSelector, ChartExternalIdSelector
+from cognite_toolkit._cdf_tk.storageio.selectors import (
+    CanvasExternalIdSelector,
+    ChartExternalIdSelector,
+    ThreeDModelIdSelector,
+)
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 from cognite_toolkit._cdf_tk.utils.cli_args import parse_view_str
 from cognite_toolkit._cdf_tk.utils.interactive_select import (
@@ -36,6 +48,7 @@ from cognite_toolkit._cdf_tk.utils.interactive_select import (
     InteractiveCanvasSelect,
     InteractiveChartSelect,
     ResourceViewMappingInteractiveSelect,
+    ThreeDInteractiveSelect,
 )
 from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricKind
 
@@ -56,6 +69,8 @@ class MigrateApp(typer.Typer):
         self.command("annotations")(self.annotations)
         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)
 
@@ -980,6 +995,166 @@ class MigrateApp(typer.Typer):
             )
         )
 
+    @staticmethod
+    def three_d(
+        ctx: typer.Context,
+        id: Annotated[
+            list[int] | None,
+            typer.Argument(
+                help="The ID of the 3D Model to migrate. If not provided, an interactive selection will be "
+                "performed to select the 3D Models to migrate."
+            ),
+        ] = 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. This is useful for checking that all resources referenced by the 3D Models "
+                "have been migrated to the new data modeling resources in CDF.",
+            ),
+        ] = False,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """Migrate 3D Models from Asset-Centric to data modeling in CDF.
+
+        This command expects that the CogniteMigration data model is already deployed, and that the Mapping view
+        is populated with the mapping from Asset-Centric resources to the new data modeling resources.
+        """
+        client = EnvironmentVariables.create_from_environment().get_client()
+        selected_ids: list[int]
+        if id:
+            selected_ids = id
+        else:
+            selected_models = ThreeDInteractiveSelect(client, "migrate").select_three_d_models("classic")
+            selected_ids = [model.id for model in selected_models]
+
+        cmd = MigrationCommand()
+        cmd.run(
+            lambda: cmd.migrate(
+                selected=ThreeDModelIdSelector(ids=tuple(selected_ids)),
+                data=ThreeDMigrationIO(client),
+                mapper=ThreeDMapper(client),
+                log_dir=log_dir,
+                dry_run=dry_run,
+                verbose=verbose,
+            )
+        )
+
+    @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/builders/_raw.py

@@ -3,7 +3,7 @@ from collections.abc import Callable, Iterable, Sequence
 from typing import Any
 
 from cognite_toolkit._cdf_tk.builders import Builder
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawDatabase
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.raw import RawDatabase
 from cognite_toolkit._cdf_tk.cruds import RawDatabaseCRUD, RawTableCRUD, ResourceCRUD
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildDestinationFile,

cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -3,21 +3,21 @@ from typing import cast
 from cognite.client import CogniteClient
 from rich.console import Console
 
+from cognite_toolkit._cdf_tk.client.api.legacy.canvas import CanvasAPI
+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 ExtendedDataModelingAPI
+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.robotics import RoboticsAPI
 from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient
 
-from .api.canvas import CanvasAPI
-from .api.charts import ChartsAPI
-from .api.dml import DMLAPI
-from .api.extended_data_modeling import ExtendedDataModelingAPI
-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
 from .api.lookup import LookUpGroup
 from .api.migration import MigrationAPI
 from .api.project import ProjectAPI
-from .api.robotics import RoboticsAPI
 from .api.search import SearchAPI
 from .api.streams import StreamsAPI
 from .api.three_d import ThreeDAPI

cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -1,9 +1,10 @@
 from collections.abc import Sequence
 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,
@@ -12,10 +13,14 @@ 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, SimpleBodyRequest
+from cognite_toolkit._cdf_tk.utils.http_client import (
+    HTTPClient,
+    ItemsRequest2,
+    RequestMessage2,
+)
 
 
 class InfieldConfigAPI:
@@ -40,34 +45,34 @@ class InfieldConfigAPI:
             else [item.as_request_item(), item.data_exploration_config.as_request_item()]
             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(self.ENDPOINT),
                 method="POST",
                 items=[item for sublist in request_items for item in sublist],
             )
         )
         responses.raise_for_status()
-        return PagedResponse[InstanceResult].model_validate(responses.get_first_body()).items
+        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:
             return []
-        responses = self._http_client.request_with_retries(
-            SimpleBodyRequest(
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
                 # We use the query endpoint to be able to retrieve linked DataExplorationConfig items
                 endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
                 method="POST",
                 body_content=self._retrieve_query(items),
             )
         )
-        responses.raise_for_status()
-        parsed_response = QueryResponse[InstanceResponseItem].model_validate(responses.get_first_body())
+        success = response.get_success_or_raise()
+        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.")
 
@@ -77,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: {
@@ -168,49 +173,49 @@ class InFieldCDMConfigAPI:
             raise ValueError("Cannot apply more than 500 InFieldCDMLocationConfig items at once.")
 
         request_items = [item.as_request_item() for item in items]
-        responses = self._http_client.request_with_retries(
-            ItemsRequest(
+        results = self._http_client.request_items_retries(
+            ItemsRequest2(
                 endpoint_url=self._config.create_api_url(self.ENDPOINT),
                 method="POST",
-                items=request_items,  # type: ignore[arg-type]
+                items=request_items,
             )
         )
-        responses.raise_for_status()
-        return PagedResponse[InstanceResult].model_validate(responses.get_first_body()).items
+        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:
             return []
-        responses = self._http_client.request_with_retries(
-            SimpleBodyRequest(
+        result = self._http_client.request_single_retries(
+            RequestMessage2(
                 endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
                 method="POST",
                 body_content=self._retrieve_query(items),
             )
         )
-        responses.raise_for_status()
-        parsed_response = QueryResponse[InstanceResponseItem].model_validate(responses.get_first_body())
+        success = result.get_success_or_raise()
+        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/{canvas.py → legacy/canvas.py}

@@ -15,7 +15,8 @@ from cognite.client.data_classes.filters import Filter
 from cognite.client.exceptions import CogniteDuplicatedError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.canvas import (
+from cognite_toolkit._cdf_tk.client.api.legacy.extended_data_modeling import ExtendedInstancesAPI
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.canvas import (
     ANNOTATION_EDGE_TYPE,
     CANVAS_INSTANCE_SPACE,
     CONTAINER_REFERENCE_EDGE_TYPE,
@@ -29,11 +30,9 @@ from cognite_toolkit._cdf_tk.client.data_classes.canvas import (
     IndustrialCanvas,
     IndustrialCanvasApply,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.instances import InstancesApplyResultList
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.instances import InstancesApplyResultList
 from cognite_toolkit._cdf_tk.exceptions import ToolkitValueError
 
-from .extended_data_modeling import ExtendedInstancesAPI
-
 
 class CanvasAPI:
     def __init__(self, instance_api: ExtendedInstancesAPI) -> None:
@@ -134,6 +133,9 @@ class IndustrialCanvasAPI:
 
     @classmethod
     def _retrieve_query(cls, external_id: str) -> query.Query:
+        # The limit for canvas components must be high enough to cover all annotations/references in a canvas.
+        # Using 1000 as a safe upper bound (same as _APPLY_LIMIT).
+        query_limit = 1000
         return query.Query(
             with_={
                 "canvas": query.NodeResultSetExpression(
@@ -143,18 +145,21 @@ class IndustrialCanvasAPI:
                 "solutionTags": query.NodeResultSetExpression(
                     from_="canvas",
                     through=Canvas.get_source().as_property_ref("solutionTags"),
+                    limit=query_limit,
                 ),
                 "annotationEdges": query.EdgeResultSetExpression(
                     from_="canvas",
                     filter=filters.Equals(["edge", "type"], ANNOTATION_EDGE_TYPE.dump()),
                     node_filter=filters.HasData(views=[CanvasAnnotation.get_source()]),
                     direction="outwards",
+                    limit=query_limit,
                 ),
                 "containerReferenceEdges": query.EdgeResultSetExpression(
                     from_="canvas",
                     filter=filters.Equals(["edge", "type"], CONTAINER_REFERENCE_EDGE_TYPE.dump()),
                     node_filter=filters.HasData(views=[ContainerReference.get_source()]),
                     direction="outwards",
+                    limit=query_limit,
                 ),
                 "fdmInstanceContainerReferenceEdges": query.EdgeResultSetExpression(
                     from_="canvas",
@@ -164,11 +169,14 @@ class IndustrialCanvasAPI:
                     ),
                     node_filter=filters.HasData(views=[FdmInstanceContainerReference.get_source()]),
                     direction="outwards",
+                    limit=query_limit,
+                ),
+                "annotations": query.NodeResultSetExpression(from_="annotationEdges", limit=query_limit),
+                "containerReferences": query.NodeResultSetExpression(
+                    from_="containerReferenceEdges", limit=query_limit
                 ),
-                "annotations": query.NodeResultSetExpression(from_="annotationEdges"),
-                "containerReferences": query.NodeResultSetExpression(from_="containerReferenceEdges"),
                 "fdmInstanceContainerReferences": query.NodeResultSetExpression(
-                    from_="fdmInstanceContainerReferenceEdges"
+                    from_="fdmInstanceContainerReferenceEdges", limit=query_limit
                 ),
             },
             select={

cognite_toolkit/_cdf_tk/client/api/{charts.py → legacy/charts.py}

@@ -6,7 +6,7 @@ from cognite.client._api_client import APIClient
 from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.charts import (
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.charts import (
     Chart,
     ChartList,
     ChartWrite,

cognite_toolkit/_cdf_tk/client/api/{extended_data_modeling.py → legacy/extended_data_modeling.py}

@@ -16,7 +16,7 @@ from cognite.client.utils._concurrency import execute_tasks
 from requests import Response
 
 from cognite_toolkit._cdf_tk.client._constants import DATA_MODELING_MAX_DELETE_WORKERS, DATA_MODELING_MAX_WRITE_WORKERS
-from cognite_toolkit._cdf_tk.client.data_classes.instances import InstancesApplyResultList
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.instances import InstancesApplyResultList
 from cognite_toolkit._cdf_tk.client.utils._concurrency import ToolkitConcurrencySettings
 from cognite_toolkit._cdf_tk.client.utils._http_client import ToolkitRetryTracker