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

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/file.py

@@ -15,13 +15,8 @@
 
 from collections.abc import Hashable, Iterable, Sequence
 from datetime import date, datetime
-from typing import Any, cast, final
+from typing import Any, final
 
-from cognite.client.data_classes import (
-    FileMetadata,
-    FileMetadataList,
-    FileMetadataWrite,
-)
 from cognite.client.data_classes.capabilities import (
     Capability,
     DataModelInstancesAcl,
@@ -31,9 +26,11 @@ from cognite.client.data_classes.data_modeling import NodeApplyResultList, NodeI
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils._time import convert_data_modelling_timestamp
 from cognite.client.utils.useful_types import SequenceNotStr
-from rich import print
 
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.extendable_cognite_file import (
+from cognite_toolkit._cdf_tk.client.request_classes.filters import ClassicFilter
+from cognite_toolkit._cdf_tk.client.resource_classes.filemetadata import FileMetadataRequest, FileMetadataResponse
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId, InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.extendable_cognite_file import (
     ExtendableCogniteFile,
     ExtendableCogniteFileApply,
     ExtendableCogniteFileList,
@@ -55,11 +52,11 @@ from .datamodel import SpaceCRUD, ViewCRUD
 
 
 @final
-class FileMetadataCRUD(ResourceContainerCRUD[str, FileMetadataWrite, FileMetadata]):
+class FileMetadataCRUD(ResourceContainerCRUD[ExternalId, FileMetadataRequest, FileMetadataResponse]):
     item_name = "file contents"
     folder_name = "files"
-    resource_cls = FileMetadata
-    resource_write_cls = FileMetadataWrite
+    resource_cls = FileMetadataResponse
+    resource_write_cls = FileMetadataRequest
     yaml_cls = FileMetadataYAML
     kind = "FileMetadata"
     dependencies = frozenset({DataSetsCRUD, GroupAllScopedCRUD, LabelCRUD, AssetCRUD})
@@ -72,7 +69,7 @@ class FileMetadataCRUD(ResourceContainerCRUD[str, FileMetadataWrite, FileMetadat
 
     @classmethod
     def get_required_capability(
-        cls, items: Sequence[FileMetadataWrite] | None, read_only: bool
+        cls, items: Sequence[FileMetadataRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -87,22 +84,22 @@ class FileMetadataCRUD(ResourceContainerCRUD[str, FileMetadataWrite, FileMetadat
         return FilesAcl(actions, scope)
 
     @classmethod
-    def get_id(cls, item: FileMetadata | FileMetadataWrite | dict) -> str:
+    def get_id(cls, item: FileMetadataRequest | FileMetadataResponse | dict) -> ExternalId:
         if isinstance(item, dict):
-            return item["externalId"]
+            return ExternalId(external_id=item["externalId"])
         if item.external_id is None:
             raise ToolkitRequiredValueError("FileMetadata must have external_id set.")
-        return item.external_id
+        return ExternalId(external_id=item.external_id)
 
     @classmethod
-    def get_internal_id(cls, item: FileMetadata | dict) -> int:
+    def get_internal_id(cls, item: FileMetadataResponse | 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]]:
@@ -118,71 +115,65 @@ class FileMetadataCRUD(ResourceContainerCRUD[str, FileMetadataWrite, FileMetadat
                 elif isinstance(label, str):
                     yield LabelCRUD, label
         for asset_external_id in item.get("assetExternalIds", []):
-            yield AssetCRUD, asset_external_id
+            yield AssetCRUD, ExternalId(external_id=asset_external_id)
 
-    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> FileMetadataWrite:
-        if resource.get("dataSetExternalId") is not None:
-            ds_external_id = resource.pop("dataSetExternalId")
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> FileMetadataRequest:
+        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", []):
-            security_categories = self.client.lookup.security_categories.id(security_categories_names, is_dry_run)
-            resource["securityCategories"] = security_categories
-        if "assetExternalIds" in resource:
-            resource["assetIds"] = self.client.lookup.assets.id(resource["assetExternalIds"], is_dry_run)
-        return FileMetadataWrite._load(resource)
-
-    def dump_resource(self, resource: FileMetadata, local: dict[str, Any] | None = None) -> dict[str, Any]:
-        dumped = resource.as_write().dump()
-        if ds_id := dumped.pop("dataSetId", None):
-            dumped["dataSetExternalId"] = self.client.lookup.data_sets.external_id(ds_id)
+            resource["securityCategories"] = self.client.lookup.security_categories.id(
+                security_categories_names, is_dry_run
+            )
+        if asset_external_ids := resource.pop("assetExternalIds", None):
+            resource["assetIds"] = self.client.lookup.assets.id(asset_external_ids, is_dry_run)
+        return FileMetadataRequest.model_validate(resource)
+
+    def dump_resource(self, resource: FileMetadataResponse, 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", []):
             dumped["securityCategoryNames"] = self.client.lookup.security_categories.external_id(security_categories)
         if asset_ids := dumped.pop("assetIds", []):
             dumped["assetExternalIds"] = self.client.lookup.assets.external_id(asset_ids)
         return dumped
 
-    def create(self, items: Sequence[FileMetadataWrite]) -> FileMetadataList:
-        created = FileMetadataList([])
-        for meta in items:
-            try:
-                created.append(self.client.files.create(meta))
-            except CogniteAPIError as e:
-                if e.code == 409:
-                    print(f"  [bold yellow]WARNING:[/] File {meta.external_id} already exists, skipping upload.")
-        return created
+    def create(self, items: Sequence[FileMetadataRequest]) -> list[FileMetadataResponse]:
+        return self.client.tool.filemetadata.create(items, overwrite=True)
 
-    def retrieve(self, ids: SequenceNotStr[str]) -> FileMetadataList:
-        return self.client.files.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[FileMetadataResponse]:
+        return self.client.tool.filemetadata.retrieve(list(ids), ignore_unknown_ids=True)
 
-    def update(self, items: Sequence[FileMetadataWrite]) -> FileMetadataList:
-        return self.client.files.update(items, mode="replace")
+    def update(self, items: Sequence[FileMetadataRequest]) -> list[FileMetadataResponse]:
+        return self.client.tool.filemetadata.update(items, mode="replace")
 
-    def delete(self, ids: str | int | SequenceNotStr[str | int] | None) -> int:
-        internal_ids, external_ids = self._split_ids(ids)
-        self.client.files.delete(id=internal_ids, external_id=external_ids)
-        return len(cast(SequenceNotStr[str], ids))
+    def delete(self, ids: SequenceNotStr[InternalOrExternalId]) -> int:
+        if not ids:
+            return 0
+        self.client.tool.filemetadata.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[FileMetadata]:
-        return iter(self.client.files(data_set_external_ids=[data_set_external_id] if data_set_external_id else None))
+    ) -> Iterable[FileMetadataResponse]:
+        filter_ = ClassicFilter.from_asset_subtree_and_data_sets(data_set_id=data_set_external_id)
+        for files in self.client.tool.filemetadata.iterate(filter=filter_, limit=None):
+            yield from files
 
-    def count(self, ids: SequenceNotStr[str]) -> int:
+    def count(self, ids: SequenceNotStr[ExternalId]) -> int:
         return sum(
-            1
-            for meta in self.client.files.retrieve_multiple(external_ids=list(ids), ignore_unknown_ids=True)
-            if meta.uploaded
+            1 for meta in self.client.tool.filemetadata.retrieve(list(ids), ignore_unknown_ids=True) if meta.uploaded
         )
 
-    def drop_data(self, ids: SequenceNotStr[str]) -> int:
-        existing = self.client.files.retrieve_multiple(external_ids=list(ids), ignore_unknown_ids=True)
+    def drop_data(self, ids: SequenceNotStr[ExternalId]) -> int:
+        existing = self.client.tool.filemetadata.retrieve(list(ids), ignore_unknown_ids=True)
         # File and FileMetadata is tightly coupled, so we need to delete the metadata and recreate it
         # without the source set to delete the file.
-        deleted_files = self.delete(existing.as_external_ids())
-        self.create(existing.as_write())
+        deleted_files = self.delete([meta.as_id() for meta in existing])
+        self.create([meta.as_request_resource() for meta in existing])
         return deleted_files
 
 

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/function.py

@@ -31,7 +31,7 @@ from rich import print
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.functions import FunctionScheduleID
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.functions import FunctionScheduleID
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
     ResourceCreationError,

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/industrial_tool.py

@@ -14,7 +14,7 @@ from packaging.requirements import Requirement
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.streamlit_ import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.streamlit_ import (
     Streamlit,
     StreamlitList,
     StreamlitWrite,

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/location.py

@@ -7,7 +7,8 @@ from cognite.client.data_classes.capabilities import Capability, LocationFilters
 from cognite.client.data_classes.data_modeling import DataModelId, ViewId
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.location_filters import (
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.location_filters import (
     LocationFilter,
     LocationFilterList,
     LocationFilterWrite,
@@ -239,14 +240,14 @@ class LocationFilterCRUD(ResourceCRUD[str, LocationFilterWrite, LocationFilter])
                 yield DataSetsCRUD, data_set_external_id
             for asset in asset_centric.get("assetSubtreeIds", []):
                 if "externalId" in asset:
-                    yield AssetCRUD, asset["externalId"]
+                    yield AssetCRUD, ExternalId(external_id=asset["externalId"])
             for subfilter_name in cls.subfilter_names:
                 subfilter = asset_centric.get(subfilter_name, {})
                 for data_set_external_id in subfilter.get("dataSetExternalIds", []):
                     yield DataSetsCRUD, data_set_external_id
                 for asset in subfilter.get("assetSubtreeIds", []):
                     if "externalId" in asset:
-                        yield AssetCRUD, asset["externalId"]
+                        yield AssetCRUD, ExternalId(external_id=asset["externalId"])
         for view in item.get("views", []):
             if in_dict(["space", "externalId", "version"], view):
                 yield ViewCRUD, ViewId(view["space"], view["externalId"], view["version"])

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/migration.py

@@ -6,7 +6,7 @@ from cognite.client.data_classes.capabilities import Capability
 from cognite.client.data_classes.data_modeling import NodeList, ViewId
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.migration import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.migration import (
     ResourceViewMapping,
     ResourceViewMappingApply,
 )

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/raw.py

@@ -29,7 +29,12 @@ from rich import print
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.raw import RawDatabase, RawDatabaseList, RawTable, RawTableList
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.raw import (
+    RawDatabase,
+    RawDatabaseList,
+    RawTable,
+    RawTableList,
+)
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceContainerCRUD, ResourceCRUD
 from cognite_toolkit._cdf_tk.resource_classes import DatabaseYAML, TableYAML
 

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/relationship.py

@@ -11,6 +11,7 @@ from cognite.client.data_classes.capabilities import Capability
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.resource_classes import RelationshipYAML
 
@@ -123,15 +124,15 @@ class RelationshipCRUD(ResourceCRUD[str, RelationshipWrite, Relationship]):
                 if isinstance(id_value, str) and isinstance(type_value, str):
                     type_value = type_value.strip().casefold()
                     if type_value == "asset":
-                        yield AssetCRUD, id_value
+                        yield AssetCRUD, ExternalId(external_id=id_value)
                     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/robotics.py

@@ -9,7 +9,7 @@ from cognite.client.data_classes.capabilities import Capability
 from cognite.client.exceptions import CogniteAPIError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.legacy.robotics import (
+from cognite_toolkit._cdf_tk.client.resource_classes.legacy.robotics import (
     DataPostProcessing,
     DataPostProcessingList,
     DataPostProcessingWrite,

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/simulators.py

@@ -0,0 +1,122 @@
+from collections.abc import Hashable, Iterable, Sequence
+from typing import Any, final
+
+from cognite.client.data_classes.capabilities import Capability
+from cognite.client.utils.useful_types import SequenceNotStr
+
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId, InternalOrExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.simulator_model import (
+    SimulatorModelRequest,
+    SimulatorModelResponse,
+)
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
+from cognite_toolkit._cdf_tk.resource_classes import SimulatorModelYAML
+
+from .data_organization import DataSetsCRUD
+
+
+@final
+class SimulatorModelCRUD(ResourceCRUD[ExternalId, SimulatorModelRequest, SimulatorModelResponse]):
+    folder_name = "simulators"
+    resource_cls = SimulatorModelResponse
+    resource_write_cls = SimulatorModelRequest
+    yaml_cls = SimulatorModelYAML
+    kind = "SimulatorModel"
+    dependencies = frozenset({DataSetsCRUD})
+    _doc_url = "Simulator-Models/operation/create_simulator_model_simulators_models_post"
+
+    @property
+    def display_name(self) -> str:
+        return "simulator models"
+
+    @classmethod
+    def get_id(cls, item: SimulatorModelRequest | SimulatorModelResponse | dict) -> ExternalId:
+        if isinstance(item, dict):
+            return ExternalId(external_id=item["externalId"])
+        if not item.external_id:
+            raise KeyError("SimulatorModel must have external_id")
+        return ExternalId(external_id=item.external_id)
+
+    @classmethod
+    def get_internal_id(cls, item: SimulatorModelResponse | dict) -> int:
+        if isinstance(item, dict):
+            return item["id"]
+        if not item.id:
+            raise KeyError("SimulatorModel must have id")
+        return item.id
+
+    @classmethod
+    def dump_id(cls, id: ExternalId) -> dict[str, Any]:
+        return id.dump()
+
+    @classmethod
+    def get_required_capability(
+        cls, items: Sequence[SimulatorModelRequest] | None, read_only: bool
+    ) -> Capability | list[Capability]:
+        # Simulator ACLs is not yet implemented in the PySDK, which means
+        # that we cannot check for specific capabilities.
+        return []
+
+    def create(self, items: Sequence[SimulatorModelRequest]) -> list[SimulatorModelResponse]:
+        return self.client.tool.simulators.models.create(items)
+
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[SimulatorModelResponse]:
+        return self.client.tool.simulators.models.retrieve(list(ids), ignore_unknown_ids=True)
+
+    def update(self, items: Sequence[SimulatorModelRequest]) -> list[SimulatorModelResponse]:
+        return self.client.tool.simulators.models.update(items, mode="replace")
+
+    def delete(self, ids: SequenceNotStr[ExternalId | InternalOrExternalId]) -> int:
+        if not ids:
+            return 0
+        self.client.tool.simulators.models.delete(list(ids))
+        return len(ids)
+
+    def _iterate(
+        self,
+        data_set_external_id: str | None = None,
+        space: str | None = None,
+        parent_ids: list[Hashable] | None = None,
+    ) -> Iterable[SimulatorModelResponse]:
+        # Note: The SimulatorModelsAPI doesn't support data_set_external_id filtering directly,
+        # so we iterate and filter in memory if needed.
+        cursor: str | None = None
+        data_set_id: int | None = None
+        if data_set_external_id:
+            data_set_id = self.client.lookup.data_sets.id(data_set_external_id, is_dry_run=False)
+        while True:
+            page = self.client.tool.simulators.models.paginate(
+                limit=1000,
+                cursor=cursor,
+            )
+            if data_set_id:
+                # Filter by data_set_external_id in memory
+                for item in page.items:
+                    if item.data_set_id == data_set_id:
+                        yield item
+            else:
+                yield from page.items
+            if not page.next_cursor or not page.items:
+                break
+            cursor = page.next_cursor
+
+    @classmethod
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
+        """Returns all items that this item requires.
+
+        For example, a SimulatorModel requires a DataSet, so this method would return the
+        DataSetsCRUD and identifier of that dataset.
+        """
+        if "dataSetExternalId" in item:
+            yield DataSetsCRUD, item["dataSetExternalId"]
+
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> SimulatorModelRequest:
+        if ds_external_id := resource.pop("dataSetExternalId", None):
+            resource["dataSetId"] = self.client.lookup.data_sets.id(ds_external_id, is_dry_run)
+        return SimulatorModelRequest.model_validate(resource)
+
+    def dump_resource(self, resource: SimulatorModelResponse, 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)
+        return dumped

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/streams.py

@@ -4,20 +4,19 @@ from typing import Any, final
 from cognite.client.data_classes.capabilities import Capability, StreamsAcl
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.streams import (
+from cognite_toolkit._cdf_tk.client.resource_classes.identifiers import ExternalId
+from cognite_toolkit._cdf_tk.client.resource_classes.streams import (
     StreamRequest,
     StreamResponse,
-    StreamResponseList,
 )
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
 from cognite_toolkit._cdf_tk.resource_classes import StreamYAML
-from cognite_toolkit._cdf_tk.utils.http_client import ToolkitAPIError
 
 from .datamodel import ContainerCRUD
 
 
 @final
-class StreamCRUD(ResourceCRUD[str, StreamRequest, StreamResponse]):
+class StreamCRUD(ResourceCRUD[ExternalId, StreamRequest, StreamResponse]):
     folder_name = "streams"
     resource_cls = StreamResponse
     resource_write_cls = StreamRequest
@@ -32,14 +31,14 @@ class StreamCRUD(ResourceCRUD[str, StreamRequest, StreamResponse]):
         return "streams"
 
     @classmethod
-    def get_id(cls, item: StreamRequest | StreamResponse | dict) -> str:
+    def get_id(cls, item: StreamRequest | StreamResponse | dict) -> ExternalId:
         if isinstance(item, dict):
-            return item["externalId"]
-        return item.external_id
+            return ExternalId(external_id=item["externalId"])
+        return ExternalId(external_id=item.external_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(
@@ -55,30 +54,15 @@ class StreamCRUD(ResourceCRUD[str, StreamRequest, StreamResponse]):
         )
         return StreamsAcl(actions, StreamsAcl.Scope.All())
 
-    def create(self, items: Sequence[StreamRequest]) -> StreamResponseList:
-        created = self.client.streams.create(list(items))
-        return StreamResponseList(created)
+    def create(self, items: Sequence[StreamRequest]) -> list[StreamResponse]:
+        return self.client.streams.create(items)
 
-    def retrieve(self, ids: SequenceNotStr[str]) -> StreamResponseList:
-        retrieved: list[StreamResponse] = []
-        for _id in ids:
-            try:
-                _resp = self.client.streams.retrieve(_id)
-            except ToolkitAPIError:
-                continue
-            if _resp is not None:
-                retrieved.append(_resp)
-        return StreamResponseList(retrieved)
+    def retrieve(self, ids: SequenceNotStr[ExternalId]) -> list[StreamResponse]:
+        return self.client.streams.retrieve(list(ids), ignore_unknown_ids=True)
 
-    def delete(self, ids: SequenceNotStr[str]) -> int:
-        count = 0
-        for _id in ids:
-            try:
-                self.client.streams.delete(_id)
-            except ToolkitAPIError:
-                continue
-            count += 1
-        return count
+    def delete(self, ids: SequenceNotStr[ExternalId]) -> int:
+        self.client.streams.delete(list(ids), ignore_unknown_ids=True)
+        return len(ids)
 
     def _iterate(
         self,