cognite-toolkit 0.7.42__py3-none-any.whl → 0.7.44__py3-none-any.whl

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/relationship.py

@@ -128,11 +128,11 @@ class RelationshipCRUD(ResourceCRUD[str, RelationshipWrite, Relationship]):
                     elif type_value == "sequence":
                         yield SequenceCRUD, id_value
                     elif type_value == "timeseries":
-                        yield TimeSeriesCRUD, id_value
+                        yield TimeSeriesCRUD, ExternalId(external_id=id_value)
                     elif type_value == "file":
-                        yield FileMetadataCRUD, id_value
+                        yield FileMetadataCRUD, ExternalId(external_id=id_value)
                     elif type_value == "event":
-                        yield EventCRUD, id_value
+                        yield EventCRUD, ExternalId(external_id=id_value)
 
     def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> RelationshipWrite:
         if ds_external_id := resource.pop("dataSetExternalId", None):

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/timeseries.py

@@ -2,16 +2,13 @@ import json
 from collections.abc import Hashable, Iterable, Sequence
 from itertools import zip_longest
 from pathlib import Path
-from typing import Any, Literal, cast, final
+from typing import Any, Literal, final
 
 from cognite.client.data_classes import (
     DatapointSubscription,
     DatapointSubscriptionList,
     DataPointSubscriptionUpdate,
     DataPointSubscriptionWrite,
-    TimeSeries,
-    TimeSeriesList,
-    TimeSeriesWrite,
 )
 from cognite.client.data_classes.capabilities import (
     Capability,
@@ -23,7 +20,8 @@ from cognite.client.data_classes.datapoints_subscriptions import TimeSeriesIDLis
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.data_classes.identifiers import ExternalId, InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.data_classes.timeseries import TimeSeriesRequest, TimeSeriesResponse
 from cognite_toolkit._cdf_tk.constants import MAX_TIMESTAMP_MS, MIN_TIMESTAMP_MS
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceContainerCRUD, ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
@@ -42,11 +40,11 @@ from .data_organization import DataSetsCRUD
 
 
 @final
-class TimeSeriesCRUD(ResourceContainerCRUD[str, TimeSeriesWrite, TimeSeries]):
+class TimeSeriesCRUD(ResourceContainerCRUD[ExternalId, TimeSeriesRequest, TimeSeriesResponse]):
     item_name = "datapoints"
     folder_name = "timeseries"
-    resource_cls = TimeSeries
-    resource_write_cls = TimeSeriesWrite
+    resource_cls = TimeSeriesResponse
+    resource_write_cls = TimeSeriesRequest
     yaml_cls = TimeSeriesYAML
     kind = "TimeSeries"
     dependencies = frozenset({DataSetsCRUD, GroupAllScopedCRUD, AssetCRUD})
@@ -58,7 +56,7 @@ class TimeSeriesCRUD(ResourceContainerCRUD[str, TimeSeriesWrite, TimeSeries]):
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[TimeSeriesWrite] | None, read_only: bool
+        cls, items: Sequence[TimeSeriesRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -73,22 +71,22 @@ class TimeSeriesCRUD(ResourceContainerCRUD[str, TimeSeriesWrite, TimeSeries]):
         return TimeSeriesAcl(actions, scope)
 
     @classmethod
-    def get_id(cls, item: TimeSeries | TimeSeriesWrite | dict) -> str:
+    def get_id(cls, item: TimeSeriesRequest | TimeSeriesResponse | dict) -> ExternalId:
         if isinstance(item, dict):
-            return item["externalId"]
+            return ExternalId(external_id=item["externalId"])
         if item.external_id is None:
             raise ToolkitRequiredValueError("TimeSeries must have external_id set.")
-        return item.external_id
+        return ExternalId(external_id=item.external_id)
 
     @classmethod
-    def get_internal_id(cls, item: TimeSeries | dict) -> int:
+    def get_internal_id(cls, item: TimeSeriesResponse | dict) -> int:
         if isinstance(item, dict):
             return item["id"]
         return item.id
 
     @classmethod
-    def dump_id(cls, id: str) -> dict[str, Any]:
-        return {"externalId": id}
+    def dump_id(cls, id: ExternalId) -> dict[str, Any]:
+        return id.dump()
 
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
@@ -100,7 +98,7 @@ class TimeSeriesCRUD(ResourceContainerCRUD[str, TimeSeriesWrite, TimeSeries]):
         if "assetExternalId" in item:
             yield AssetCRUD, ExternalId(external_id=item["assetExternalId"])
 
-    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> TimeSeriesWrite:
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> TimeSeriesRequest:
         if ds_external_id := resource.pop("dataSetExternalId", None):
             resource["dataSetId"] = self.client.lookup.data_sets.id(ds_external_id, is_dry_run)
         if security_categories_names := resource.pop("securityCategoryNames", []):
@@ -109,10 +107,10 @@ class TimeSeriesCRUD(ResourceContainerCRUD[str, TimeSeriesWrite, TimeSeries]):
             )
         if asset_external_id := resource.pop("assetExternalId", None):
             resource["assetId"] = self.client.lookup.assets.id(asset_external_id, is_dry_run)
-        return TimeSeriesWrite._load(resource)
+        return TimeSeriesRequest.model_validate(resource)
 
-    def dump_resource(self, resource: TimeSeries, local: dict[str, Any] | None = None) -> dict[str, Any]:
-        dumped = resource.as_write().dump()
+    def dump_resource(self, resource: TimeSeriesResponse, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.as_request_resource().dump()
         if data_set_id := dumped.pop("dataSetId", None):
             dumped["dataSetExternalId"] = self.client.lookup.data_sets.external_id(data_set_id)
         if security_categories := dumped.pop("securityCategories", []):
@@ -121,53 +119,56 @@ class TimeSeriesCRUD(ResourceContainerCRUD[str, TimeSeriesWrite, TimeSeries]):
             dumped["assetExternalId"] = self.client.lookup.assets.external_id(asset_id)
         return dumped
 
-    def create(self, items: Sequence[TimeSeriesWrite]) -> TimeSeriesList:
-        return self.client.time_series.create(items)
+    def create(self, items: Sequence[TimeSeriesRequest]) -> list[TimeSeriesResponse]:
+        return self.client.tool.timeseries.create(items)
 
-    def retrieve(self, ids: SequenceNotStr[str | int]) -> TimeSeriesList:
-        internal_ids, external_ids = self._split_ids(ids)
-        return self.client.time_series.retrieve_multiple(
-            ids=internal_ids, external_ids=external_ids, ignore_unknown_ids=True
-        )
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[TimeSeriesResponse]:
+        return self.client.tool.timeseries.retrieve(list(ids), ignore_unknown_ids=True)
 
-    def update(self, items: Sequence[TimeSeriesWrite]) -> TimeSeriesList:
-        return self.client.time_series.update(items, mode="replace")
+    def update(self, items: Sequence[TimeSeriesRequest]) -> list[TimeSeriesResponse]:
+        return self.client.tool.timeseries.update(items, mode="replace")
 
-    def delete(self, ids: SequenceNotStr[str | int]) -> int:
-        existing = self.retrieve(ids)
-        if existing:
-            self.client.time_series.delete(id=existing.as_ids(), ignore_unknown_ids=True)
-        return len(existing)
+    def delete(self, ids: SequenceNotStr[InternalOrExternalId]) -> int:
+        if not ids:
+            return 0
+        self.client.tool.timeseries.delete(list(ids), ignore_unknown_ids=True)
+        return len(ids)
 
     def _iterate(
         self,
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[TimeSeries]:
-        return iter(
-            self.client.time_series(data_set_external_ids=[data_set_external_id] if data_set_external_id else None)
-        )
+    ) -> Iterable[TimeSeriesResponse]:
+        cursor: str | None = None
+        while True:
+            page = self.client.tool.timeseries.iterate(
+                data_set_external_ids=[data_set_external_id] if data_set_external_id else None,
+                limit=1000,
+                cursor=cursor,
+            )
+            yield from page.items
+            if not page.next_cursor or not page.items:
+                break
+            cursor = page.next_cursor
 
-    def count(self, ids: str | dict[str, Any] | SequenceNotStr[str | dict[str, Any]] | None) -> int:
+    def count(self, ids: SequenceNotStr[ExternalId]) -> int:
         datapoints = self.client.time_series.data.retrieve(
-            external_id=ids,  # type: ignore[arg-type]
+            external_id=[id.external_id for id in ids],
             start=MIN_TIMESTAMP_MS,
             end=MAX_TIMESTAMP_MS + 1,
             aggregates="count",
             granularity="1000d",
             ignore_unknown_ids=True,
         )
-        return sum(sum(data.count or []) for data in datapoints)  # type: ignore[union-attr, misc, arg-type]
+        return sum(sum(data.count or []) for data in datapoints)
 
-    def drop_data(self, ids: SequenceNotStr[str] | None) -> int:
+    def drop_data(self, ids: SequenceNotStr[ExternalId]) -> int:
         count = self.count(ids)
-        existing = self.client.time_series.retrieve_multiple(
-            external_ids=cast(SequenceNotStr[str], ids), ignore_unknown_ids=True
-        ).as_external_ids()
-        for external_id in existing:
+        existing = self.client.tool.timeseries.retrieve(list(ids), ignore_unknown_ids=True)
+        for ts in existing:
             self.client.time_series.data.delete_range(
-                external_id=external_id, start=MIN_TIMESTAMP_MS, end=MAX_TIMESTAMP_MS + 1
+                external_id=ts.external_id, start=MIN_TIMESTAMP_MS, end=MAX_TIMESTAMP_MS + 1
             )
         return count
 
@@ -220,7 +221,7 @@ class DatapointSubscriptionCRUD(
         if "dataSetExternalId" in item:
             yield DataSetsCRUD, item["dataSetExternalId"]
         for timeseries_id in item.get("timeSeriesIds", []):
-            yield TimeSeriesCRUD, timeseries_id
+            yield TimeSeriesCRUD, ExternalId(external_id=timeseries_id)
 
     @classmethod
     def get_required_capability(

cognite_toolkit/_cdf_tk/resource_classes/__init__.py

@@ -40,6 +40,7 @@ from .robotics import RobotCapabilityYAML, RobotDataPostProcessingYAML, RobotFra
 from .search_config import SearchConfigYAML
 from .securitycategories import SecurityCategoriesYAML
 from .sequence import SequenceRowYAML, SequenceYAML
+from .simulator_model import SimulatorModelYAML
 from .space import SpaceYAML
 from .streamlit_ import StreamlitYAML
 from .streams import StreamYAML
@@ -94,6 +95,7 @@ __all__ = [
     "SecurityCategoriesYAML",
     "SequenceRowYAML",
     "SequenceYAML",
+    "SimulatorModelYAML",
     "SpaceYAML",
     "StreamYAML",
     "StreamlitYAML",

cognite_toolkit/_cdf_tk/resource_classes/simulator_model.py

@@ -0,0 +1,17 @@
+from pydantic import Field
+
+from .base import ToolkitResource
+
+
+class SimulatorModelYAML(ToolkitResource):
+    """Simulator model YAML resource class.
+
+    Based on: https://api-docs.cognite.com/20230101/tag/Simulator-Models/operation/create_simulator_model_simulators_models_post
+    """
+
+    external_id: str = Field(description="External ID of the simulator model.", min_length=1, max_length=255)
+    simulator_external_id: str = Field(description="External id of the simulator.", min_length=1, max_length=50)
+    name: str = Field(description="The name of the simulator model.", min_length=1, max_length=50)
+    description: str | None = Field(None, description="Description of the simulator model.", max_length=500)
+    data_set_external_id: str = Field(description="The external ID of the dataset this simulator model belongs to.")
+    type: str = Field(description="The type of the simulator model.", min_length=1, max_length=50)

cognite_toolkit/_cdf_tk/storageio/_asset_centric.py

@@ -3,22 +3,14 @@ from collections import defaultdict
 from collections.abc import Iterable, Sequence
 from typing import Any, ClassVar, Generic
 
-from cognite.client.data_classes import (
-    Event,
-    EventList,
-    EventWrite,
-    FileMetadata,
-    FileMetadataList,
-    Label,
-    LabelDefinition,
-    TimeSeries,
-    TimeSeriesList,
-    TimeSeriesWrite,
-)
+from cognite.client.data_classes import Label, LabelDefinition
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.asset import AssetAggregateItem, AssetRequest, AssetResponse
+from cognite_toolkit._cdf_tk.client.data_classes.event import EventRequest, EventResponse
+from cognite_toolkit._cdf_tk.client.data_classes.filemetadata import FileMetadataResponse
 from cognite_toolkit._cdf_tk.client.data_classes.identifiers import InternalId
+from cognite_toolkit._cdf_tk.client.data_classes.timeseries import TimeSeriesRequest, TimeSeriesResponse
 from cognite_toolkit._cdf_tk.cruds import (
     AssetCRUD,
     DataSetsCRUD,
@@ -111,13 +103,16 @@ class AssetCentricIO(
 
     def _collect_dependencies(
         self,
-        resources: Sequence[AssetResponse] | FileMetadataList | TimeSeriesList | EventList,
+        resources: Sequence[AssetResponse]
+        | Sequence[FileMetadataResponse]
+        | Sequence[TimeSeriesResponse]
+        | Sequence[EventResponse],
         selector: AssetCentricSelector,
     ) -> None:
         for resource in resources:
             if resource.data_set_id:
                 self._downloaded_data_sets_by_selector[selector].add(resource.data_set_id)
-            if isinstance(resource, AssetResponse | FileMetadata):
+            if isinstance(resource, AssetResponse | FileMetadataResponse):
                 for label in resource.labels or []:
                     if isinstance(label, str):
                         self._downloaded_labels_by_selector[selector].add(label)
@@ -149,17 +144,19 @@ class AssetCentricIO(
     def create_internal_identifier(cls, internal_id: int, project: str) -> str:
         return f"INTERNAL_ID_project_{project}_{internal_id!s}"
 
-    def _populate_data_set_id_cache(self, chunk: Sequence[AssetResponse | FileMetadata | TimeSeries | Event]) -> None:
+    def _populate_data_set_id_cache(
+        self, chunk: Sequence[AssetResponse | FileMetadataResponse | TimeSeriesResponse | EventResponse]
+    ) -> None:
         data_set_ids = {item.data_set_id for item in chunk if item.data_set_id is not None}
         self.client.lookup.data_sets.external_id(list(data_set_ids))
 
-    def _populate_security_category_cache(self, chunk: Sequence[FileMetadata | TimeSeries]) -> None:
+    def _populate_security_category_cache(self, chunk: Sequence[FileMetadataResponse | TimeSeriesResponse]) -> None:
         security_category_ids: set[int] = set()
         for item in chunk:
             security_category_ids.update(item.security_categories or [])
         self.client.lookup.security_categories.external_id(list(security_category_ids))
 
-    def _populate_asset_id_cache(self, chunk: Sequence[FileMetadata | Event]) -> None:
+    def _populate_asset_id_cache(self, chunk: Sequence[FileMetadataResponse | EventResponse]) -> None:
         asset_ids: set[int] = set()
         for item in chunk:
             asset_ids.update(item.asset_ids or [])
@@ -381,7 +378,7 @@ class AssetIO(UploadableAssetCentricIO[AssetResponse, AssetRequest]):
             current_depth += 1
 
 
-class FileMetadataIO(AssetCentricIO[FileMetadata]):
+class FileMetadataIO(AssetCentricIO[FileMetadataResponse]):
     KIND = "FileMetadata"
     RESOURCE_TYPE = "file"
     SUPPORTED_DOWNLOAD_FORMATS = frozenset({".parquet", ".csv", ".ndjson"})
@@ -393,7 +390,7 @@ class FileMetadataIO(AssetCentricIO[FileMetadata]):
         super().__init__(client)
         self._crud = FileMetadataCRUD.create_loader(self.client)
 
-    def as_id(self, item: FileMetadata) -> str:
+    def as_id(self, item: FileMetadataResponse) -> str:
         return item.external_id if item.external_id is not None else self._create_identifier(item.id)
 
     def _get_aggregator(self) -> AssetCentricAggregator:
@@ -436,25 +433,31 @@ class FileMetadataIO(AssetCentricIO[FileMetadata]):
         ]
         return file_schema + metadata_schema
 
-    def stream_data(self, selector: AssetCentricSelector, limit: int | None = None) -> Iterable[Page[FileMetadata]]:
+    def stream_data(
+        self, selector: AssetCentricSelector, limit: int | None = None
+    ) -> Iterable[Page[FileMetadataResponse]]:
         asset_subtree_external_ids, data_set_external_ids = self._get_hierarchy_dataset_pair(selector)
-        for file_list in self.client.files(
-            chunk_size=self.CHUNK_SIZE,
-            limit=limit,
-            asset_subtree_external_ids=asset_subtree_external_ids,
-            data_set_external_ids=data_set_external_ids,
-            # We cannot use partitions here as it is not thread safe. This spawn multiple threads
-            # that are not shut down until all data is downloaded. We need to be able to abort.
-            partitions=None,
-        ):
-            self._collect_dependencies(file_list, selector)
-            yield Page(worker_id="main", items=file_list)
-
-    def retrieve(self, ids: Sequence[int]) -> FileMetadataList:
-        return self.client.files.retrieve_multiple(ids)
+        cursor: str | None = None
+        total_count = 0
+        while True:
+            page = self.client.tool.filemetadata.iterate(
+                data_set_external_ids=data_set_external_ids,
+                asset_subtree_external_ids=asset_subtree_external_ids,
+                limit=self.CHUNK_SIZE,
+                cursor=cursor,
+            )
+            self._collect_dependencies(page.items, selector)
+            yield Page(worker_id="main", items=page.items)
+            total_count += len(page.items)
+            if page.next_cursor is None or (limit is not None and total_count >= limit):
+                break
+            cursor = page.next_cursor
+
+    def retrieve(self, ids: Sequence[int]) -> list[FileMetadataResponse]:
+        return self.client.tool.filemetadata.retrieve(InternalId.from_ids(ids))
 
     def data_to_json_chunk(
-        self, data_chunk: Sequence[FileMetadata], selector: AssetCentricSelector | None = None
+        self, data_chunk: Sequence[FileMetadataResponse], selector: AssetCentricSelector | None = None
     ) -> list[dict[str, JsonVal]]:
         # Ensure data sets/assets/security-categories are looked up to populate cache.
         # This is to avoid looking up each data set id individually in the .dump_resource call
@@ -465,7 +468,7 @@ class FileMetadataIO(AssetCentricIO[FileMetadata]):
         return [self._crud.dump_resource(item) for item in data_chunk]
 
 
-class TimeSeriesIO(UploadableAssetCentricIO[TimeSeries, TimeSeriesWrite]):
+class TimeSeriesIO(UploadableAssetCentricIO[TimeSeriesResponse, TimeSeriesRequest]):
     KIND = "TimeSeries"
     SUPPORTED_DOWNLOAD_FORMATS = frozenset({".parquet", ".csv", ".ndjson"})
     SUPPORTED_COMPRESSIONS = frozenset({".gz"})
@@ -477,31 +480,35 @@ class TimeSeriesIO(UploadableAssetCentricIO[TimeSeries, TimeSeriesWrite]):
         super().__init__(client)
         self._crud = TimeSeriesCRUD.create_loader(self.client)
 
-    def as_id(self, item: TimeSeries) -> str:
+    def as_id(self, item: TimeSeriesResponse) -> str:
         return item.external_id if item.external_id is not None else self._create_identifier(item.id)
 
     def _get_aggregator(self) -> AssetCentricAggregator:
         return TimeSeriesAggregator(self.client)
 
-    def retrieve(self, ids: Sequence[int]) -> TimeSeriesList:
-        return self.client.time_series.retrieve_multiple(ids=ids)
+    def retrieve(self, ids: Sequence[int]) -> list[TimeSeriesResponse]:
+        return self.client.tool.timeseries.retrieve(InternalId.from_ids(ids))
 
     def stream_data(self, selector: AssetCentricSelector, limit: int | None = None) -> Iterable[Page]:
         asset_subtree_external_ids, data_set_external_ids = self._get_hierarchy_dataset_pair(selector)
-        for ts_list in self.client.time_series(
-            chunk_size=self.CHUNK_SIZE,
-            limit=limit,
-            asset_subtree_external_ids=asset_subtree_external_ids,
-            data_set_external_ids=data_set_external_ids,
-            # We cannot use partitions here as it is not thread safe. This spawn multiple threads
-            # that are not shut down until all data is downloaded. We need to be able to abort.
-            partitions=None,
-        ):
-            self._collect_dependencies(ts_list, selector)
-            yield Page(worker_id="main", items=ts_list)
+        cursor: str | None = None
+        total_count = 0
+        while True:
+            page = self.client.tool.timeseries.iterate(
+                data_set_external_ids=data_set_external_ids,
+                asset_subtree_external_ids=asset_subtree_external_ids,
+                limit=self.CHUNK_SIZE,
+                cursor=cursor,
+            )
+            self._collect_dependencies(page.items, selector)
+            yield Page(worker_id="main", items=page.items)
+            total_count += len(page.items)
+            if page.next_cursor is None or (limit is not None and total_count >= limit):
+                break
+            cursor = page.next_cursor
 
     def data_to_json_chunk(
-        self, data_chunk: Sequence[TimeSeries], selector: AssetCentricSelector | None = None
+        self, data_chunk: Sequence[TimeSeriesResponse], selector: AssetCentricSelector | None = None
     ) -> list[dict[str, JsonVal]]:
         # Ensure data sets/assets/security categories are looked up to populate cache.
         self._populate_data_set_id_cache(data_chunk)
@@ -513,14 +520,14 @@ class TimeSeriesIO(UploadableAssetCentricIO[TimeSeries, TimeSeriesWrite]):
 
     def json_chunk_to_data(
         self, data_chunk: list[tuple[str, dict[str, JsonVal]]]
-    ) -> Sequence[UploadItem[TimeSeriesWrite]]:
+    ) -> Sequence[UploadItem[TimeSeriesRequest]]:
         chunks = [item_json for _, item_json in data_chunk]
         self._populate_asset_external_ids_cache(chunks)
         self._populate_data_set_external_id_cache(chunks)
         self._populate_security_category_name_cache(chunks)
         return super().json_chunk_to_data(data_chunk)
 
-    def json_to_resource(self, item_json: dict[str, JsonVal]) -> TimeSeriesWrite:
+    def json_to_resource(self, item_json: dict[str, JsonVal]) -> TimeSeriesRequest:
         return self._crud.load_resource(item_json)
 
     def get_schema(self, selector: AssetCentricSelector) -> list[SchemaColumn]:
@@ -561,7 +568,7 @@ class TimeSeriesIO(UploadableAssetCentricIO[TimeSeries, TimeSeriesWrite]):
         return ts_schema + metadata_schema
 
 
-class EventIO(UploadableAssetCentricIO[Event, EventWrite]):
+class EventIO(UploadableAssetCentricIO[EventResponse, EventRequest]):
     KIND = "Events"
     SUPPORTED_DOWNLOAD_FORMATS = frozenset({".parquet", ".csv", ".ndjson"})
     SUPPORTED_COMPRESSIONS = frozenset({".gz"})
@@ -573,7 +580,7 @@ class EventIO(UploadableAssetCentricIO[Event, EventWrite]):
         super().__init__(client)
         self._crud = EventCRUD.create_loader(self.client)
 
-    def as_id(self, item: Event) -> str:
+    def as_id(self, item: EventResponse) -> str:
         return item.external_id if item.external_id is not None else self._create_identifier(item.id)
 
     def _get_aggregator(self) -> AssetCentricAggregator:
@@ -618,20 +625,24 @@ class EventIO(UploadableAssetCentricIO[Event, EventWrite]):
 
     def stream_data(self, selector: AssetCentricSelector, limit: int | None = None) -> Iterable[Page]:
         asset_subtree_external_ids, data_set_external_ids = self._get_hierarchy_dataset_pair(selector)
-        for event_list in self.client.events(
-            chunk_size=self.CHUNK_SIZE,
-            limit=limit,
-            asset_subtree_external_ids=asset_subtree_external_ids,
-            data_set_external_ids=data_set_external_ids,
-            # We cannot use partitions here as it is not thread safe. This spawn multiple threads
-            # that are not shut down until all data is downloaded. We need to be able to abort.
-            partitions=None,
-        ):
-            self._collect_dependencies(event_list, selector)
-            yield Page(worker_id="main", items=event_list)
+        cursor: str | None = None
+        total_count = 0
+        while True:
+            page = self.client.tool.events.iterate(
+                data_set_external_ids=data_set_external_ids,
+                asset_subtree_external_ids=asset_subtree_external_ids,
+                limit=self.CHUNK_SIZE,
+                cursor=cursor,
+            )
+            self._collect_dependencies(page.items, selector)
+            yield Page(worker_id="main", items=page.items)
+            total_count += len(page.items)
+            if page.next_cursor is None or (limit is not None and total_count >= limit):
+                break
+            cursor = page.next_cursor
 
     def data_to_json_chunk(
-        self, data_chunk: Sequence[Event], selector: AssetCentricSelector | None = None
+        self, data_chunk: Sequence[EventResponse], selector: AssetCentricSelector | None = None
     ) -> list[dict[str, JsonVal]]:
         # Ensure data sets/assets are looked up to populate cache.
         self._populate_data_set_id_cache(data_chunk)
@@ -639,17 +650,19 @@ class EventIO(UploadableAssetCentricIO[Event, EventWrite]):
 
         return [self._crud.dump_resource(item) for item in data_chunk]
 
-    def json_chunk_to_data(self, data_chunk: list[tuple[str, dict[str, JsonVal]]]) -> Sequence[UploadItem[EventWrite]]:
+    def json_chunk_to_data(
+        self, data_chunk: list[tuple[str, dict[str, JsonVal]]]
+    ) -> Sequence[UploadItem[EventRequest]]:
         chunks = [item_json for _, item_json in data_chunk]
         self._populate_asset_external_ids_cache(chunks)
         self._populate_data_set_external_id_cache(chunks)
         return super().json_chunk_to_data(data_chunk)
 
-    def json_to_resource(self, item_json: dict[str, JsonVal]) -> EventWrite:
+    def json_to_resource(self, item_json: dict[str, JsonVal]) -> EventRequest:
         return self._crud.load_resource(item_json)
 
-    def retrieve(self, ids: Sequence[int]) -> EventList:
-        return self.client.events.retrieve_multiple(ids)
+    def retrieve(self, ids: Sequence[int]) -> list[EventResponse]:
+        return self.client.tool.events.retrieve(InternalId.from_ids(ids))
 
 
 class HierarchyIO(ConfigurableStorageIO[AssetCentricSelector, AssetCentricResource]):

cognite_toolkit/_cdf_tk/storageio/_file_content.py

@@ -6,10 +6,11 @@ from pathlib import Path
 from typing import cast
 
 import httpx
-from cognite.client.data_classes import FileMetadata, FileMetadataWrite
-from cognite.client.data_classes.data_modeling import NodeId, ViewId
+from cognite.client.data_classes.data_modeling import ViewId
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.data_classes.data_modeling import NodeReference
+from cognite_toolkit._cdf_tk.client.data_classes.filemetadata import FileMetadataRequest, FileMetadataResponse
 from cognite_toolkit._cdf_tk.client.http_client import (
     DataBodyRequest,
     ErrorDetails,
@@ -45,21 +46,24 @@ COGNITE_FILE_VIEW = ViewId("cdf_cdm", "CogniteFile", "v1")
 
 
 @dataclass
-class UploadFileContentItem(UploadItem[FileMetadataWrite]):
+class UploadFileContentItem(UploadItem[FileMetadataRequest]):
     file_path: Path
     mime_type: str
 
+    def dump(self) -> JsonVal:
+        return self.item.dump(camel_case=True, exclude_extra=True)
+
 
 @dataclass
 class MetadataWithFilePath(ResourceResponseProtocol):
-    metadata: FileMetadata
+    metadata: FileMetadataResponse
     file_path: Path
 
-    def as_write(self) -> FileMetadataWrite:
-        return self.metadata.as_write()
+    def as_write(self) -> FileMetadataRequest:
+        return self.metadata.as_request_resource()
 
 
-class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePath, FileMetadataWrite]):
+class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePath, FileMetadataRequest]):
     SUPPORTED_DOWNLOAD_FORMATS = frozenset({".ndjson"})
     SUPPORTED_COMPRESSIONS = frozenset({".gz"})
     CHUNK_SIZE = 10
@@ -116,7 +120,7 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePat
                 )
             yield Page(items=downloaded_files, worker_id="Main")
 
-    def _retrieve_metadata(self, identifiers: Sequence[FileIdentifier]) -> Sequence[FileMetadata] | None:
+    def _retrieve_metadata(self, identifiers: Sequence[FileIdentifier]) -> Sequence[FileMetadataResponse] | None:
         config = self.client.config
         responses = self.client.http_client.request_with_retries(
             message=SimpleBodyRequest(
@@ -137,12 +141,11 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePat
         items_data = body.get("items", [])
         if not isinstance(items_data, list):
             return None
-        # MyPy does not understand that JsonVal is valid dict[Any, Any]
-        return [FileMetadata._load(item) for item in items_data]  # type: ignore[arg-type]
+        return [FileMetadataResponse.model_validate(item) for item in items_data]
 
     @staticmethod
-    def _as_metadata_map(metadata: Sequence[FileMetadata]) -> dict[FileIdentifier, FileMetadata]:
-        identifiers_map: dict[FileIdentifier, FileMetadata] = {}
+    def _as_metadata_map(metadata: Sequence[FileMetadataResponse]) -> dict[FileIdentifier, FileMetadataResponse]:
+        identifiers_map: dict[FileIdentifier, FileMetadataResponse] = {}
         for item in metadata:
             if item.id is not None:
                 identifiers_map[FileInternalID(internal_id=item.id)] = item
@@ -158,9 +161,9 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePat
                 ] = item
         return identifiers_map
 
-    def _create_filepath(self, meta: FileMetadata, selector: FileIdentifierSelector) -> Path:
+    def _create_filepath(self, meta: FileMetadataResponse, selector: FileIdentifierSelector) -> Path:
         # We now that metadata always have name set
-        filename = Path(sanitize_filename(cast(str, meta.name)))
+        filename = Path(sanitize_filename(meta.name))
         if len(filename.suffix) == 0 and meta.mime_type:
             if mime_ext := mimetypes.guess_extension(meta.mime_type):
                 filename = filename.with_suffix(mime_ext)
@@ -245,12 +248,12 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePat
             )
         return result
 
-    def json_to_resource(self, item_json: dict[str, JsonVal]) -> FileMetadataWrite:
+    def json_to_resource(self, item_json: dict[str, JsonVal]) -> FileMetadataRequest:
         return self._crud.load_resource(item_json)
 
     def upload_items(
         self,
-        data_chunk: Sequence[UploadItem[FileMetadataWrite]],
+        data_chunk: Sequence[UploadItem[FileMetadataRequest]],
         http_client: HTTPClient,
         selector: FileContentSelector | None = None,
     ) -> Sequence[HTTPMessage]:
@@ -320,12 +323,12 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePat
 
         """
         # We know that instance_id is always set for data modeling uploads
-        instance_id = cast(NodeId, item.item.instance_id)
+        instance_id = cast(NodeReference, item.item.instance_id)
         responses = http_client.request_with_retries(
             message=SimpleBodyRequest(
                 endpoint_url=http_client.config.create_api_url("/files/uploadlink"),
                 method="POST",
-                body_content={"items": [{"instanceId": instance_id.dump(include_instance_type=False)}]},  # type: ignore[dict-item]
+                body_content={"items": [{"instanceId": instance_id.dump()}]},
             )
         )
         # We know there is only one response since we only requested one upload link
@@ -340,7 +343,7 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, MetadataWithFilePat
 
     @classmethod
     def _create_cognite_file_node(
-        cls, instance_id: NodeId, http_client: HTTPClient, upload_id: str, results: MutableSequence[HTTPMessage]
+        cls, instance_id: NodeReference, http_client: HTTPClient, upload_id: str, results: MutableSequence[HTTPMessage]
     ) -> bool:
         node_creation = http_client.request_with_retries(
             message=SimpleBodyRequest(