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

cognite_toolkit/_cdf_tk/commands/pull.py

@@ -1,5 +1,6 @@
 import dataclasses
 import itertools
+import json
 import re
 import sys
 import tempfile
@@ -28,6 +29,7 @@ from cognite_toolkit._cdf_tk.cruds import (
     HostedExtractorSourceCRUD,
     ResourceCRUD,
     StreamlitCRUD,
+    ViewCRUD,
 )
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildEnvironment,
@@ -643,6 +645,44 @@ class PullCommand(ToolkitCommand):
         loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         source_file: Path,
     ) -> tuple[str, dict[Path, str]]:
+        """Convert resource data from CDF into YAML file content ready to be written to disk.
+
+        This method takes the raw CDF resource data and transforms it back into a properly
+        formatted YAML file that preserves:
+        - Template variables (e.g., {{ variable_name }}) instead of their resolved values
+        - YAML comments from the original source file
+        - The original key ordering in dictionaries
+
+        The transformation process:
+        1. Replace all template variables with unique placeholders
+        2. Load source YAML content while preserving comments
+        3. Update the resource data with placeholder values where variables were used
+        4. Dump the updated data back to YAML format
+        5. Replace placeholders with the original template variable syntax
+        6. Restore the YAML comments
+
+        Args:
+            source: The original YAML file content as a string.
+            to_write: A mapping from resource identifiers to their updated data dictionaries
+                pulled from CDF.
+            resources: The list of built resources containing build variables and metadata.
+            environment_variables: A mapping of environment variable names to their values,
+                used to resolve variables like ${VAR_NAME} in template values.
+            loader: The ResourceCRUD loader instance for this resource type.
+            source_file: The path to the source file being processed.
+
+        Returns:
+            A tuple containing:
+            - The final YAML content string ready to be written to disk.
+            - A dictionary mapping extra file paths to their content (for resources
+              that have additional files, like SQL queries for transformations).
+
+        Raises:
+            ValueError: If the loaded YAML structure doesn't match between the original
+                and placeholder versions.
+            ToolkitMissingResourceError: If a resource identifier is not found in the
+                to_write or resources mappings.
+        """
         # 1. Replace all variables with placeholders
         # 2. Load source and keep the comments
         # 3. Update the to_write dict with the placeholders
@@ -762,9 +802,22 @@ class PullCommand(ToolkitCommand):
 
 
 class ResourceReplacer:
-    """Replaces values in a local resource directory with the updated values from CDF.
+    """Replaces values in a local resource dictionary with the updated values from CDF.
 
     The local resource dict order is maintained. In addition, placeholders are used for variables.
+
+    This class is responsible for merging CDF resource values back into local configuration files
+    while preserving:
+    - The original key ordering in dictionaries
+    - Template variable placeholders (e.g., {{ variable_name }})
+    - Comments and formatting where possible
+
+    Args:
+        value_by_placeholder: A mapping from placeholder strings to their corresponding
+            BuildVariable objects. Placeholders are temporary substitutes for template
+            variables during processing.
+        loader: The ResourceCRUD loader instance used to determine how to diff lists
+            and handle resource-specific logic.
     """
 
     def __init__(self, value_by_placeholder: dict[str, BuildVariable], loader: ResourceCRUD) -> None:
@@ -777,7 +830,49 @@ class ResourceReplacer:
         placeholder: dict[str, Any],
         to_write: dict[str, Any],
     ) -> dict[str, Any]:
-        return self._replace_dict(current, placeholder, to_write, tuple())
+        """Replace values in a local resource dict with updated values from CDF.
+
+        Merges the CDF resource values into the local configuration while maintaining
+        the original dictionary key ordering and preserving template variable placeholders.
+
+        Args:
+            current: The current local resource dictionary with resolved variable values.
+                This represents the source file content after template variables have
+                been substituted with their actual values.
+            placeholder: The local resource dictionary with placeholder strings instead
+                of resolved values. Used to identify which values contain template
+                variables that should be preserved.
+            to_write: The resource dictionary from CDF containing the updated values
+                to merge into the local configuration.
+
+        Returns:
+            A new dictionary with CDF values merged in, maintaining the original key
+            order from `current`. Template variables are preserved as placeholders
+            (to be converted back to {{ variable }} syntax by the caller). New keys
+            from CDF are appended at the end, and removed keys are omitted.
+
+        Raises:
+            ToolkitValueError: If a list variable has changed and cannot be updated,
+                or if there's a type mismatch between local and CDF values.
+        """
+        has_stringified_view_filter = False
+        if isinstance(self._loader, ViewCRUD):
+            # view.filter are recursive nested dicts that are complex. To avoid issues with comparing
+            # lists inside the filters, we stringify them before processing such that they are compared
+            # as strings.
+            processed = []
+            for d in (current, placeholder, to_write):
+                if isinstance(d.get("filter"), dict):
+                    d = d.copy()
+                    d["filter"] = json.dumps(d["filter"])
+                    has_stringified_view_filter = True
+                processed.append(d)
+            current, placeholder, to_write = processed
+        output = self._replace_dict(current, placeholder, to_write, tuple())
+        if has_stringified_view_filter and "filter" in output:
+            # Special case for ViewCRUD where the filter is stringified in CDF
+            output["filter"] = json.loads(output["filter"])
+        return output
 
     def _replace_dict(
         self,

cognite_toolkit/_cdf_tk/commands/run.py

@@ -30,7 +30,7 @@ from rich.progress import Progress
 from rich.table import Table
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient, ToolkitClientConfig
-from cognite_toolkit._cdf_tk.client.data_classes.functions import FunctionScheduleID
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.functions import FunctionScheduleID
 from cognite_toolkit._cdf_tk.constants import _RUNNING_IN_BROWSER
 from cognite_toolkit._cdf_tk.cruds import FunctionCRUD, FunctionScheduleCRUD, WorkflowVersionCRUD
 from cognite_toolkit._cdf_tk.cruds._resource_cruds.workflow import WorkflowTriggerCRUD

cognite_toolkit/_cdf_tk/cruds/__init__.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import itertools
+from collections import defaultdict
 from typing import Literal, TypeAlias
 
 from cognite_toolkit._cdf_tk.feature_flags import FeatureFlag, Flags
@@ -60,6 +61,7 @@ from ._resource_cruds import (
     SecurityCategoryCRUD,
     SequenceCRUD,
     SequenceRowCRUD,
+    SimulatorModelCRUD,
     SpaceCRUD,
     StreamCRUD,
     StreamlitCRUD,
@@ -86,26 +88,31 @@ if not FeatureFlag.is_enabled(Flags.MIGRATE):
     _EXCLUDED_CRUDS.add(ResourceViewMappingCRUD)
 if not FeatureFlag.is_enabled(Flags.STREAMS):
     _EXCLUDED_CRUDS.add(StreamCRUD)
+if not FeatureFlag.is_enabled(Flags.SIMULATORS):
+    _EXCLUDED_CRUDS.add(SimulatorModelCRUD)
 
-
-CRUDS_BY_FOLDER_NAME: dict[str, list[type[Loader]]] = {}
+CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA: defaultdict[str, list[type[Loader]]] = defaultdict(list)
+CRUDS_BY_FOLDER_NAME: defaultdict[str, list[type[Loader]]] = defaultdict(list)
 for _loader in itertools.chain(
     ResourceCRUD.__subclasses__(),
     ResourceContainerCRUD.__subclasses__(),
     DataCRUD.__subclasses__(),
     GroupCRUD.__subclasses__(),
 ):
-    if _loader in [ResourceCRUD, ResourceContainerCRUD, DataCRUD, GroupCRUD] or _loader in _EXCLUDED_CRUDS:
+    if _loader in [ResourceCRUD, ResourceContainerCRUD, DataCRUD, GroupCRUD]:
         # Skipping base classes
         continue
-    if _loader.folder_name not in CRUDS_BY_FOLDER_NAME:  # type: ignore[attr-defined]
-        CRUDS_BY_FOLDER_NAME[_loader.folder_name] = []  # type: ignore[attr-defined]
     # MyPy bug: https://github.com/python/mypy/issues/4717
-    CRUDS_BY_FOLDER_NAME[_loader.folder_name].append(_loader)  # type: ignore[arg-type, attr-defined]
+    CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA[_loader.folder_name].append(_loader)  # type: ignore[arg-type, attr-defined]
+
+    if _loader not in _EXCLUDED_CRUDS:
+        CRUDS_BY_FOLDER_NAME[_loader.folder_name].append(_loader)  # type: ignore[arg-type, attr-defined]
 del _loader  # cleanup module namespace
 
+
 # For backwards compatibility
 CRUDS_BY_FOLDER_NAME["data_models"] = CRUDS_BY_FOLDER_NAME["data_modeling"]  # Todo: Remove in v1.0
+CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA["data_models"] = CRUDS_BY_FOLDER_NAME_INCLUDE_ALPHA["data_modeling"]
 RESOURCE_CRUD_BY_FOLDER_NAME = {
     folder_name: cruds
     for folder_name, loaders in CRUDS_BY_FOLDER_NAME.items()
@@ -142,6 +149,7 @@ ResourceTypes: TypeAlias = Literal[
     "functions",
     "raw",
     "robotics",
+    "simulators",
     "streams",
     "streamlit",
     "workflows",
@@ -163,6 +171,7 @@ __all__ = [
     "RESOURCE_CRUD_CONTAINER_LIST",
     "RESOURCE_CRUD_LIST",
     "RESOURCE_DATA_CRUD_LIST",
+    "_EXCLUDED_CRUDS",
     "AgentCRUD",
     "AssetCRUD",
     "CogniteFileCRUD",
@@ -209,6 +218,7 @@ __all__ = [
     "SecurityCategoryCRUD",
     "SequenceCRUD",
     "SequenceRowCRUD",
+    "SimulatorModelCRUD",
     "SpaceCRUD",
     "StreamlitCRUD",
     "ThreeDModelCRUD",

cognite_toolkit/_cdf_tk/cruds/_data_cruds.py

@@ -6,8 +6,9 @@ from typing import TYPE_CHECKING, cast, final
 import pandas as pd
 from cognite.client.data_classes import FileMetadataWrite
 
-from cognite_toolkit._cdf_tk.client.data_classes.extendable_cognite_file import ExtendableCogniteFileApply
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawTable
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.extendable_cognite_file import ExtendableCogniteFileApply
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawTable
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
 from cognite_toolkit._cdf_tk.protocols import (
     T_ResourceRequest,
@@ -119,11 +120,14 @@ class FileCRUD(DataCRUD):
                 if not datafile.exists():
                     continue
 
+                identifier = resource.identifier
+                if isinstance(identifier, ExternalId):
+                    identifier = identifier.external_id
                 if dry_run:
-                    yield f" Would upload file '{datafile!s}' to file with {id_name}={resource.identifier!r}", 1
+                    yield f" Would upload file '{datafile!s}' to file with {id_name}={identifier!r}", 1
                 else:
-                    self.client.files.upload_content(path=str(datafile), **{id_name: resource.identifier})
-                    yield f" Uploaded file '{datafile!s}' to file with {id_name}={resource.identifier!r}", 1
+                    self.client.files.upload_content(path=str(datafile), **{id_name: identifier})
+                    yield f" Uploaded file '{datafile!s}' to file with {id_name}={identifier!r}", 1
 
     @staticmethod
     def _read_metadata(

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/__init__.py

@@ -35,6 +35,7 @@ from .robotics import (
     RoboticMapCRUD,
     RoboticsDataPostProcessingCRUD,
 )
+from .simulators import SimulatorModelCRUD
 from .streams import StreamCRUD
 from .three_d_model import ThreeDModelCRUD
 from .timeseries import DatapointSubscriptionCRUD, TimeSeriesCRUD
@@ -83,6 +84,7 @@ __all__ = [
     "SecurityCategoryCRUD",
     "SequenceCRUD",
     "SequenceRowCRUD",
+    "SimulatorModelCRUD",
     "SpaceCRUD",
     "StreamCRUD",
     "StreamlitCRUD",

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/auth.py

@@ -41,7 +41,8 @@ from rich.console import Console
 from rich.markup import escape
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawDatabase, RawTable
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawDatabase, RawTable
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitWrongResourceError
 from cognite_toolkit._cdf_tk.resource_classes import GroupYAML, SecurityCategoriesYAML
@@ -190,7 +191,10 @@ class GroupCRUD(ResourceCRUD[str, GroupWrite, Group]):
                             loader = LocationFilterCRUD
                         if loader is not None and isinstance(ids, dict) and "ids" in ids:
                             for id_ in ids["ids"]:
-                                yield loader, id_
+                                if loader is TimeSeriesCRUD:
+                                    yield TimeSeriesCRUD, ExternalId(external_id=id_)
+                                else:
+                                    yield loader, id_
 
     def _substitute_scope_ids(self, group: dict[str, Any], is_dry_run: bool, reverse: bool = False) -> dict[str, Any]:
         replace_method_by_acl = self._create_replace_method_by_acl_and_scope()

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/classic.py

@@ -5,26 +5,27 @@ from pathlib import Path
 from typing import Any, final
 
 import pandas as pd
+from cognite.client.data_classes import Sequence as CDFSequence
 from cognite.client.data_classes import (
-    AggregateResultItem,
-    Asset,
-    AssetList,
-    AssetWrite,
-    Event,
-    EventList,
-    EventWrite,
     SequenceList,
     SequenceWrite,
     capabilities,
 )
-from cognite.client.data_classes import Sequence as CDFSequence
 from cognite.client.data_classes.capabilities import Capability
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.sequences import (
+from cognite_toolkit._cdf_tk.client.request_classes.filters import ClassicFilter
+from cognite_toolkit._cdf_tk.client.resource_classes.asset import (
+    AssetAggregateItem,
+    AssetRequest,
+    AssetResponse,
+)
+from cognite_toolkit._cdf_tk.client.resource_classes.event import EventRequest, EventResponse
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId, InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.sequences import (
     ToolkitSequenceRows,
     ToolkitSequenceRowsList,
     ToolkitSequenceRowsWrite,
@@ -44,10 +45,10 @@ _DEPRECATION_WARNING_ISSUED = False
 
 
 @final
-class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset]):
+class AssetCRUD(ResourceCRUD[ExternalId, AssetRequest, AssetResponse]):
     folder_name = "classic"
-    resource_cls = Asset
-    resource_write_cls = AssetWrite
+    resource_cls = AssetResponse
+    resource_write_cls = AssetRequest
     yaml_cls = AssetYAML
     kind = "Asset"
     dependencies = frozenset({DataSetsCRUD, LabelCRUD})
@@ -78,15 +79,15 @@ class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset]):
         return "assets"
 
     @classmethod
-    def get_id(cls, item: Asset | AssetWrite | dict) -> str:
+    def get_id(cls, item: AssetRequest | AssetResponse | dict) -> ExternalId:
         if isinstance(item, dict):
-            return item["externalId"]
+            return ExternalId(external_id=item["externalId"])
         if not item.external_id:
             raise KeyError("Asset must have external_id")
-        return item.external_id
+        return ExternalId(external_id=item.external_id)
 
     @classmethod
-    def get_internal_id(cls, item: Asset | dict) -> int:
+    def get_internal_id(cls, item: AssetResponse | dict) -> int:
         if isinstance(item, dict):
             return item["id"]
         if not item.id:
@@ -94,12 +95,12 @@ class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset]):
         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_required_capability(
-        cls, items: collections.abc.Sequence[AssetWrite] | None, read_only: bool
+        cls, items: collections.abc.Sequence[AssetRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -119,45 +120,30 @@ class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset]):
 
         return capabilities.AssetsAcl(actions, scope)
 
-    def create(self, items: Sequence[AssetWrite]) -> AssetList:
-        return self.client.assets.create(items)
+    def create(self, items: collections.abc.Sequence[AssetRequest]) -> list[AssetResponse]:
+        return self.client.tool.assets.create(items)
 
-    def retrieve(self, ids: SequenceNotStr[str]) -> AssetList:
-        return self.client.assets.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[AssetResponse]:
+        return self.client.tool.assets.retrieve(list(ids), ignore_unknown_ids=True)
 
-    def update(self, items: Sequence[AssetWrite]) -> AssetList:
-        return self.client.assets.update(items, mode="replace")
+    def update(self, items: collections.abc.Sequence[AssetRequest]) -> list[AssetResponse]:
+        return self.client.tool.assets.update(items, mode="replace")
 
-    def delete(self, ids: SequenceNotStr[str | int]) -> int:
+    def delete(self, ids: SequenceNotStr[InternalOrExternalId]) -> int:
         if not ids:
             return 0
-        internal_ids, external_ids = self._split_ids(ids)
-        try:
-            self.client.assets.delete(id=internal_ids, external_id=external_ids)
-        except CogniteNotFoundError as e:
-            # Do a CogniteNotFoundError instead of passing 'ignore_unknown_ids=True' to the delete method
-            # to obtain an accurate list of deleted assets.
-            non_existing = set(e.failed or [])
-            if existing := [id_ for id_ in ids if id_ not in non_existing]:
-                internal_ids, external_ids = self._split_ids(existing)
-                self.client.assets.delete(id=internal_ids, external_id=external_ids)
-            return len(existing)
-        else:
-            return len(ids)
+        self.client.tool.assets.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[Asset]:
-        return iter(
-            self.client.assets(
-                data_set_external_ids=[data_set_external_id] if data_set_external_id else None,
-                # This is used in the purge command to delete the children before the parent.
-                aggregated_properties=["depth", "child_count", "path"],
-            )
-        )
+    ) -> Iterable[AssetResponse]:
+        filter_ = ClassicFilter.from_asset_subtree_and_data_sets(data_set_id=data_set_external_id)
+        for assets in self.client.tool.assets.iterate(aggregated_properties=True, filter=filter_, limit=None):
+            yield from assets
 
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
@@ -202,7 +188,7 @@ class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset]):
 
         return resources
 
-    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> AssetWrite:
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> AssetRequest:
         # Unpack metadata keys from table formats (e.g. csv, parquet)
         metadata: dict = resource.get("metadata", {})
         for key, value in list(resource.items()):
@@ -219,10 +205,10 @@ class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset]):
 
         if ds_external_id := resource.pop("dataSetExternalId", None):
             resource["dataSetId"] = self.client.lookup.data_sets.id(ds_external_id, is_dry_run)
-        return AssetWrite._load(resource)
+        return AssetRequest.model_validate(resource)
 
-    def dump_resource(self, resource: Asset, local: dict[str, Any] | None = None) -> dict[str, Any]:
-        dumped = resource.as_write().dump()
+    def dump_resource(self, resource: AssetResponse, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.as_request_resource().dump()
         local = local or {}
         if data_set_id := dumped.pop("dataSetId", None):
             dumped["dataSetExternalId"] = self.client.lookup.data_sets.external_id(data_set_id)
@@ -234,7 +220,7 @@ class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset]):
             # This is only included when the asset is downloaded/migrated with aggregated properties
             aggregates = (
                 resource.aggregates.dump()
-                if isinstance(resource.aggregates, AggregateResultItem)
+                if isinstance(resource.aggregates, AssetAggregateItem)
                 else resource.aggregates
             )
             if "path" in aggregates:
@@ -372,7 +358,7 @@ class SequenceCRUD(ResourceCRUD[str, SequenceWrite, CDFSequence]):
         if "dataSetExternalId" in item:
             yield DataSetsCRUD, item["dataSetExternalId"]
         if "assetExternalId" in item:
-            yield AssetCRUD, item["assetExternalId"]
+            yield AssetCRUD, ExternalId(external_id=item["assetExternalId"])
 
 
 @final
@@ -500,10 +486,10 @@ class SequenceRowCRUD(ResourceCRUD[str, ToolkitSequenceRowsWrite, ToolkitSequenc
 
 
 @final
-class EventCRUD(ResourceCRUD[str, EventWrite, Event]):
+class EventCRUD(ResourceCRUD[ExternalId, EventRequest, EventResponse]):
     folder_name = "classic"
-    resource_cls = Event
-    resource_write_cls = EventWrite
+    resource_cls = EventResponse
+    resource_write_cls = EventRequest
     yaml_cls = EventYAML
     kind = "Event"
     dependencies = frozenset({DataSetsCRUD, AssetCRUD})
@@ -514,15 +500,15 @@ class EventCRUD(ResourceCRUD[str, EventWrite, Event]):
         return "events"
 
     @classmethod
-    def get_id(cls, item: Event | EventWrite | dict) -> str:
+    def get_id(cls, item: EventRequest | EventResponse | dict) -> ExternalId:
         if isinstance(item, dict):
-            return item["externalId"]
+            return ExternalId(external_id=item["externalId"])
         if not item.external_id:
             raise KeyError("Event must have external_id")
-        return item.external_id
+        return ExternalId(external_id=item.external_id)
 
     @classmethod
-    def get_internal_id(cls, item: Event | dict) -> int:
+    def get_internal_id(cls, item: EventResponse | dict) -> int:
         if isinstance(item, dict):
             return item["id"]
         if not item.id:
@@ -530,12 +516,12 @@ class EventCRUD(ResourceCRUD[str, EventWrite, Event]):
         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_required_capability(
-        cls, items: collections.abc.Sequence[EventWrite] | None, read_only: bool
+        cls, items: collections.abc.Sequence[EventRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -555,35 +541,30 @@ class EventCRUD(ResourceCRUD[str, EventWrite, Event]):
 
         return capabilities.EventsAcl(actions, scope)
 
-    def create(self, items: Sequence[EventWrite]) -> EventList:
-        return self.client.events.create(items)
+    def create(self, items: collections.abc.Sequence[EventRequest]) -> list[EventResponse]:
+        return self.client.tool.events.create(items)
 
-    def retrieve(self, ids: SequenceNotStr[str]) -> EventList:
-        return self.client.events.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[EventResponse]:
+        return self.client.tool.events.retrieve(list(ids), ignore_unknown_ids=True)
 
-    def update(self, items: Sequence[EventWrite]) -> EventList:
-        return self.client.events.update(items, mode="replace")
+    def update(self, items: collections.abc.Sequence[EventRequest]) -> list[EventResponse]:
+        return self.client.tool.events.update(items, mode="replace")
 
-    def delete(self, ids: SequenceNotStr[str | int]) -> int:
-        internal_ids, external_ids = self._split_ids(ids)
-        try:
-            self.client.events.delete(id=internal_ids, external_id=external_ids)
-        except (CogniteAPIError, CogniteNotFoundError) as e:
-            non_existing = set(e.failed or [])
-            if existing := [id_ for id_ in ids if id_ not in non_existing]:
-                internal_ids, external_ids = self._split_ids(existing)
-                self.client.events.delete(id=internal_ids, external_id=external_ids)
-            return len(existing)
-        else:
-            return len(ids)
+    def delete(self, ids: SequenceNotStr[InternalOrExternalId]) -> int:
+        if not ids:
+            return 0
+        self.client.tool.events.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[Event]:
-        return iter(self.client.events(data_set_external_ids=[data_set_external_id] if data_set_external_id else None))
+    ) -> Iterable[EventResponse]:
+        filter_ = ClassicFilter.from_asset_subtree_and_data_sets(data_set_id=data_set_external_id)
+        for events in self.client.tool.events.iterate(filter=filter_, limit=None):
+            yield from events
 
     @classmethod
     def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
@@ -596,17 +577,17 @@ class EventCRUD(ResourceCRUD[str, EventWrite, Event]):
             yield DataSetsCRUD, item["dataSetExternalId"]
         for asset_id in item.get("assetExternalIds", []):
             if isinstance(asset_id, str):
-                yield AssetCRUD, asset_id
+                yield AssetCRUD, ExternalId(external_id=asset_id)
 
-    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> EventWrite:
-        if ds_external_id := resource.get("dataSetExternalId", None):
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> EventRequest:
+        if ds_external_id := resource.pop("dataSetExternalId", None):
             resource["dataSetId"] = self.client.lookup.data_sets.id(ds_external_id, is_dry_run)
         if asset_external_ids := resource.pop("assetExternalIds", []):
             resource["assetIds"] = self.client.lookup.assets.id(asset_external_ids, is_dry_run)
-        return EventWrite._load(resource)
+        return EventRequest.model_validate(resource)
 
-    def dump_resource(self, resource: Event, local: dict[str, Any] | None = None) -> dict[str, Any]:
-        dumped = resource.as_write().dump()
+    def dump_resource(self, resource: EventResponse, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.as_request_resource().dump()
         local = local or {}
         if data_set_id := dumped.pop("dataSetId", None):
             dumped["dataSetExternalId"] = self.client.lookup.data_sets.external_id(data_set_id)

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/configuration.py

@@ -7,7 +7,7 @@ from cognite.client.utils.useful_types import SequenceNotStr
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.search_config import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.search_config import (
     SearchConfig,
     SearchConfigList,
     SearchConfigWrite,

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/datamodel.py

@@ -73,7 +73,7 @@ from rich.panel import Panel
 
 from cognite_toolkit._cdf_tk import constants
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.graphql_data_models import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.graphql_data_models import (
     GraphQLDataModel,
     GraphQLDataModelList,
     GraphQLDataModelWrite,

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/extraction_pipeline.py

@@ -35,7 +35,7 @@ from cognite.client.data_classes.extractionpipelines import (
 from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawDatabase, RawTable
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import RawDatabase, RawTable
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (