cognite-toolkit 0.7.31__py3-none-any.whl → 0.7.33__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/_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,16 @@ 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,
+    ThreeDMapper,
+)
 from cognite_toolkit._cdf_tk.commands._migrate.migration_io import (
     AnnotationMigrationIO,
     AssetCentricMigrationIO,
+    ThreeDMigrationIO,
 )
 from cognite_toolkit._cdf_tk.commands._migrate.selectors import (
     AssetCentricMigrationSelector,
@@ -26,7 +32,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 +46,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 +67,7 @@ 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)
         # Uncomment when infield v2 config migration is ready
         # self.command("infield-configs")(self.infield_configs)
 
@@ -980,6 +992,68 @@ 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 infield_configs(
         ctx: typer.Context,

cognite_toolkit/_cdf_tk/client/api/extended_functions.py

@@ -7,7 +7,7 @@ from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client.config import ToolkitClientConfig
 from cognite_toolkit._cdf_tk.utils.collection import chunker
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, SimpleBodyRequest
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, RequestMessage2
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
 
@@ -34,21 +34,20 @@ class ExtendedFunctionsAPI(FunctionsAPI):
 
         Args:
             function (FunctionWrite): The function to create.
-            console (Console | None): The rich console to use for printing warnings.
 
         Returns:
             Function: The created function object.
         """
-        result = self._toolkit_http_client.request_with_retries(
-            message=SimpleBodyRequest(
+        result = self._toolkit_http_client.request_single_retries(
+            message=RequestMessage2(
                 endpoint_url=self._toolkit_config.create_api_url("/functions"),
                 method="POST",
                 body_content={"items": [function.dump(camel_case=True)]},
             )
         )
-        result.raise_for_status()
+        success = result.get_success_or_raise()
         # We assume the API response is one item on a successful creation
-        return Function._load(result.get_first_body()["items"][0], cognite_client=self._cognite_client)  # type: ignore[arg-type,index]
+        return Function._load(success.body_json["items"][0], cognite_client=self._cognite_client)
 
     def delete_with_429_retry(self, external_id: SequenceNotStr[str], ignore_unknown_ids: bool = False) -> None:
         """Delete one or more functions with retry handling for 429 Too Many Requests responses.
@@ -70,11 +69,12 @@ class ExtendedFunctionsAPI(FunctionsAPI):
             }
             if ignore_unknown_ids:
                 body_content["ignoreUnknownIds"] = True
-            self._toolkit_http_client.request_with_retries(
-                message=SimpleBodyRequest(
+            result = self._toolkit_http_client.request_single_retries(
+                message=RequestMessage2(
                     endpoint_url=self._toolkit_config.create_api_url("/functions/delete"),
                     method="POST",
                     body_content=body_content,
                 )
-            ).raise_for_status()
+            )
+            result.get_success_or_raise()
         return None

cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -1,6 +1,7 @@
 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
@@ -15,7 +16,12 @@ from cognite_toolkit._cdf_tk.client.data_classes.instance_api import (
     NodeIdentifier,
 )
 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,
+    ItemsRequest,
+    ItemsRequest2,
+    RequestMessage2,
+)
 
 
 class InfieldConfigAPI:
@@ -40,31 +46,31 @@ 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]:
         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]:
@@ -168,30 +174,30 @@ 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]:
         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]:

cognite_toolkit/_cdf_tk/client/api/project.py

@@ -2,7 +2,7 @@ from cognite.client import CogniteClient
 
 from cognite_toolkit._cdf_tk.client.config import ToolkitClientConfig
 from cognite_toolkit._cdf_tk.client.data_classes.project import ProjectStatusList
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ParamRequest
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, RequestMessage2
 
 
 class ProjectAPI:
@@ -13,11 +13,12 @@ class ProjectAPI:
 
     def status(self) -> ProjectStatusList:
         """Retrieve information about the current project."""
-        response = self._http_client.request_with_retries(
-            ParamRequest(
-                endpoint_url=f"{self._config.base_url}/api/v1/projects?withDataModelingStatus=true", method="GET"
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
+                endpoint_url=f"{self._config.base_url}/api/v1/projects",
+                method="GET",
+                parameters={"withDataModelingStatus": True},
             )
         )
-        response.raise_for_status()
-        body = response.get_first_body()
-        return ProjectStatusList._load(body["items"], cognite_client=self._cognite_client)  # type: ignore[arg-type]
+        success = response.get_success_or_raise()
+        return ProjectStatusList._load(success.body_json["items"], cognite_client=self._cognite_client)

cognite_toolkit/_cdf_tk/client/api/streams.py

@@ -1,10 +1,16 @@
 from collections.abc import Sequence
 
+from pydantic import TypeAdapter
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse
 from cognite_toolkit._cdf_tk.client.data_classes.streams import StreamRequest, StreamResponse
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ItemsRequest, ParamRequest
+from cognite_toolkit._cdf_tk.utils.http_client import (
+    HTTPClient,
+    ItemsRequest2,
+    ParamRequest,
+    RequestMessage2,
+)
 
 
 class StreamsAPI:
@@ -24,15 +30,15 @@ class StreamsAPI:
         Returns:
             List of created StreamResponse 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=list(items),
+                items=items,
             )
         )
         responses.raise_for_status()
-        return PagedResponse[StreamResponse].model_validate(responses.get_first_body()).items
+        return TypeAdapter(list[StreamResponse]).validate_python(responses.get_items())
 
     def delete(self, external_id: str) -> None:
         """Delete stream using its external ID.
@@ -54,14 +60,14 @@ class StreamsAPI:
         Returns:
             StreamResponseList containing the listed streams.
         """
-        responses = self._http_client.request_with_retries(
-            ParamRequest(
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
                 endpoint_url=self._config.create_api_url(self.ENDPOINT),
                 method="GET",
             )
         )
-        responses.raise_for_status()
-        return PagedResponse[StreamResponse].model_validate(responses.get_first_body()).items
+        success = response.get_success_or_raise()
+        return PagedResponse[StreamResponse].model_validate(success.body_json).items
 
     def retrieve(self, external_id: str, include_statistics: bool = True) -> StreamResponse:
         """Retrieve a stream by its external ID.
@@ -72,13 +78,12 @@ class StreamsAPI:
         Returns:
             StreamResponse item.
         """
-        responses = self._http_client.request_with_retries(
-            ParamRequest(
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
                 endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/{external_id}"),
                 method="GET",
                 parameters={"includeStatistics": include_statistics},
             )
         )
-        responses.raise_for_status()
-        response_body = responses.get_first_body()
-        return StreamResponse.model_validate(response_body)
+        success = response.get_success_or_raise()
+        return StreamResponse.model_validate(success.body_json)

cognite_toolkit/_cdf_tk/client/api/three_d.py

@@ -1,19 +1,72 @@
+from collections.abc import Sequence
+
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse
-from cognite_toolkit._cdf_tk.client.data_classes.three_d import ThreeDModelResponse
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ParamRequest
+from cognite_toolkit._cdf_tk.client.data_classes.three_d import ThreeDModelClassicRequest, ThreeDModelResponse
+from cognite_toolkit._cdf_tk.utils.http_client import (
+    HTTPClient,
+    ItemsRequest,
+    RequestMessage2,
+    SimpleBodyRequest,
+)
 from cognite_toolkit._cdf_tk.utils.useful_types import PrimitiveType
 
 
 class ThreeDModelAPI:
     ENDPOINT = "/3d/models"
+    MAX_CLASSIC_MODELS_PER_CREATE_REQUEST = 1000
+    MAX_MODELS_PER_DELETE_REQUEST = 1000
+    _LIST_REQUEST_MAX_LIMIT = 1000
 
     def __init__(self, http_client: HTTPClient, console: Console) -> None:
         self._http_client = http_client
         self._console = console
         self._config = http_client.config
 
+    def create(self, models: Sequence[ThreeDModelClassicRequest]) -> list[ThreeDModelResponse]:
+        """Create 3D models in classic format.
+
+        Args:
+            models (Sequence[ThreeDModelClassicRequest]): The 3D model(s) to create.
+
+        Returns:
+            list[ThreeDModelResponse]: The created 3D model(s).
+        """
+        if not models:
+            return []
+        if len(models) > self.MAX_CLASSIC_MODELS_PER_CREATE_REQUEST:
+            raise ValueError("Cannot create more than 1000 3D models in a single request.")
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=list(models),
+            )
+        )
+        responses.raise_for_status()
+        body = responses.get_first_body()
+        return PagedResponse[ThreeDModelResponse].model_validate(body).items
+
+    def delete(self, ids: Sequence[int]) -> None:
+        """Delete 3D models by their IDs.
+
+        Args:
+            ids (Sequence[int]): The IDs of the 3D models to delete.
+        """
+        if not ids:
+            return None
+        if len(ids) > self.MAX_MODELS_PER_DELETE_REQUEST:
+            raise ValueError("Cannot delete more than 1000 3D models in a single request.")
+        responses = self._http_client.request_with_retries(
+            SimpleBodyRequest(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT + "/delete"),
+                method="POST",
+                body_content={"items": [{"id": id_} for id_ in ids]},
+            )
+        )
+        responses.raise_for_status()
+
     def iterate(
         self,
         published: bool | None = None,
@@ -21,8 +74,8 @@ class ThreeDModelAPI:
         limit: int = 100,
         cursor: str | None = None,
     ) -> PagedResponse[ThreeDModelResponse]:
-        if not (0 < limit <= 1000):
-            raise ValueError("Limit must be between 1 and 1000.")
+        if not (0 < limit <= self._LIST_REQUEST_MAX_LIMIT):
+            raise ValueError(f"Limit must be between 1 and {self._LIST_REQUEST_MAX_LIMIT}, got {limit}.")
         parameters: dict[str, PrimitiveType] = {
             # There is a bug in the API. The parameter includeRevisionInfo is expected to be lower case and not
             # camel case as documented. You get error message: Unrecognized query parameter includeRevisionInfo,
@@ -34,15 +87,43 @@ class ThreeDModelAPI:
             parameters["published"] = published
         if cursor is not None:
             parameters["cursor"] = cursor
-        responses = self._http_client.request_with_retries(
-            ParamRequest(
+        responses = self._http_client.request_single_retries(
+            RequestMessage2(
                 endpoint_url=self._config.create_api_url(self.ENDPOINT),
                 method="GET",
                 parameters=parameters,
             )
         )
-        responses.raise_for_status()
-        return PagedResponse[ThreeDModelResponse].model_validate(responses.get_first_body())
+        success_response = responses.get_success_or_raise()
+        return PagedResponse[ThreeDModelResponse].model_validate(success_response.body_json)
+
+    def list(
+        self,
+        published: bool | None = None,
+        include_revision_info: bool = False,
+        limit: int | None = 100,
+        cursor: str | None = None,
+    ) -> list[ThreeDModelResponse]:
+        results: list[ThreeDModelResponse] = []
+        while True:
+            request_limit = (
+                self._LIST_REQUEST_MAX_LIMIT
+                if limit is None
+                else min(limit - len(results), self._LIST_REQUEST_MAX_LIMIT)
+            )
+            if request_limit <= 0:
+                break
+            page = self.iterate(
+                published=published,
+                include_revision_info=include_revision_info,
+                limit=request_limit,
+                cursor=cursor,
+            )
+            results.extend(page.items)
+            if page.next_cursor is None:
+                break
+            cursor = page.next_cursor
+        return results
 
 
 class ThreeDAPI:

cognite_toolkit/_cdf_tk/client/data_classes/base.py

@@ -6,6 +6,8 @@ from typing import TYPE_CHECKING, Any, Generic, TypeVar
 from pydantic import BaseModel, ConfigDict
 from pydantic.alias_generators import to_camel
 
+from cognite_toolkit._cdf_tk.utils.http_client._data_classes2 import BaseModelObject, RequestResource
+
 if TYPE_CHECKING:
     from cognite.client import CogniteClient
 
@@ -15,28 +17,6 @@ else:
     from typing_extensions import Self
 
 
-class BaseModelObject(BaseModel):
-    """Base class for all object. This includes resources and nested objects."""
-
-    # We allow extra fields to support forward compatibility.
-    model_config = ConfigDict(alias_generator=to_camel, extra="allow")
-
-    def dump(self, camel_case: bool = True) -> dict[str, Any]:
-        """Dump the resource to a dictionary.
-
-        This is the default serialization method for request resources.
-        """
-        return self.model_dump(mode="json", by_alias=camel_case)
-
-    @classmethod
-    def _load(cls, resource: dict[str, Any]) -> "Self":
-        """Load method to match CogniteResource signature."""
-        return cls.model_validate(resource)
-
-
-class RequestResource(BaseModelObject): ...
-
-
 T_RequestResource = TypeVar("T_RequestResource", bound=RequestResource)
 
 
@@ -46,6 +26,10 @@ class ResponseResource(BaseModelObject, Generic[T_RequestResource], ABC):
         """Convert the response resource to a request resource."""
         ...
 
+    def as_write(self) -> T_RequestResource:
+        """Alias for as_request_resource to match protocol signature."""
+        return self.as_request_resource()
+
 
 class Identifier(BaseModel):
     """Base class for all identifier classes."""