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

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.legacy.extendable_cognite_file import ExtendableCogniteFileApply
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.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.legacy.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.legacy.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.legacy.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.legacy.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.legacy.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 (

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py

@@ -8,13 +8,14 @@ from cognite.client.data_classes.data_modeling import NodeApplyResultList, NodeI
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.infield import (
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.infield import (
     InFieldCDMLocationConfig,
     InfieldLocationConfig,
     InfieldLocationConfigList,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.instance_api import InstanceResult, TypedNodeIdentifier
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.apm_config_v1 import (
+from cognite_toolkit._cdf_tk.client.resource_classes.instance_api import InstanceResult, TypedNodeIdentifier
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.apm_config_v1 import (
     APMConfig,
     APMConfigList,
     APMConfigWrite,
@@ -139,7 +140,7 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig]):
             yield SpaceCRUD, customer_data_space_id
         for config in cls._get_root_location_configurations(item) or []:
             if isinstance(asset_external_id := config.get("assetExternalId"), str):
-                yield AssetCRUD, asset_external_id
+                yield AssetCRUD, ExternalId(external_id=asset_external_id)
             if isinstance(data_set_external_id := config.get("dataSetExternalId"), str):
                 yield DataSetsCRUD, data_set_external_id
             if isinstance(app_data_instance_space := config.get("appDataInstanceSpace"), str):
@@ -162,7 +163,7 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig]):
                         yield DataSetsCRUD, data_set_external_id
                 for asset_external_id in filter_.get("assetSubtreeExternalIds", []):
                     if isinstance(asset_external_id, str):
-                        yield AssetCRUD, asset_external_id
+                        yield AssetCRUD, ExternalId(external_id=asset_external_id)
                 if app_data_instance_space := filter_.get("appDataInstanceSpace"):
                     if isinstance(app_data_instance_space, str):
                         yield SpaceCRUD, app_data_instance_space
@@ -267,7 +268,10 @@ class InFieldLocationConfigCRUD(ResourceCRUD[TypedNodeIdentifier, InfieldLocatio
 
     @classmethod
     def dump_id(cls, id: TypedNodeIdentifier) -> dict[str, Any]:
-        return id.dump(include_type=False)
+        return {
+            "space": id.space,
+            "externalId": id.external_id,
+        }
 
     @classmethod
     def get_required_capability(
@@ -368,7 +372,10 @@ class InFieldCDMLocationConfigCRUD(
 
     @classmethod
     def dump_id(cls, id: TypedNodeIdentifier) -> dict[str, Any]:
-        return id.dump(include_type=False)
+        return {
+            "space": id.space,
+            "externalId": id.external_id,
+        }
 
     @classmethod
     def get_required_capability(