cognite-toolkit 0.5.97__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/streams.py

@@ -0,0 +1,94 @@
+from collections.abc import Hashable, Iterable, Sequence
+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 (
+    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]):
+    folder_name = "streams"
+    resource_cls = StreamResponse
+    resource_write_cls = StreamRequest
+    kind = "Streams"
+    yaml_cls = StreamYAML
+    dependencies = frozenset({ContainerCRUD})
+    _doc_url = "Streams/operation/createStream"
+    support_update = False
+
+    @property
+    def display_name(self) -> str:
+        return "streams"
+
+    @classmethod
+    def get_id(cls, item: StreamRequest | StreamResponse | dict) -> str:
+        if isinstance(item, dict):
+            return item["externalId"]
+        return item.external_id
+
+    @classmethod
+    def dump_id(cls, id: str) -> dict[str, Any]:
+        return {"externalId": id}
+
+    @classmethod
+    def get_required_capability(
+        cls, items: Sequence[StreamRequest] | None, read_only: bool
+    ) -> Capability | list[Capability]:
+        if not items and items is not None:
+            return []
+
+        actions = (
+            [StreamsAcl.Action.Read]
+            if read_only
+            else [StreamsAcl.Action.Read, StreamsAcl.Action.Create, StreamsAcl.Action.Delete]
+        )
+        return StreamsAcl(actions, StreamsAcl.Scope.All())
+
+    def create(self, items: Sequence[StreamRequest]) -> StreamResponseList:
+        created = self.client.streams.create(list(items))
+        return StreamResponseList(created)
+
+    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 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 _iterate(
+        self,
+        data_set_external_id: str | None = None,
+        space: str | None = None,
+        parent_ids: list[Hashable] | None = None,
+    ) -> Iterable[StreamResponse]:
+        if data_set_external_id or space or parent_ids:
+            # These filters are not supported for Streams
+            return iter([])
+
+        all_streams = self.client.streams.list()
+        return iter(all_streams)

cognite_toolkit/_cdf_tk/{loaders/_resource_loaders/three_d_model_loaders.py → cruds/_resource_cruds/three_d_model.py}

@@ -1,5 +1,4 @@
 from collections.abc import Hashable, Iterable, Sequence
-from functools import lru_cache
 from typing import Any, final
 
 from cognite.client.data_classes import (
@@ -7,33 +6,26 @@ from cognite.client.data_classes import (
     ThreeDModelList,
     ThreeDModelUpdate,
     ThreeDModelWrite,
-    ThreeDModelWriteList,
     capabilities,
 )
 from cognite.client.data_classes.capabilities import Capability
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk._parameters import ParameterSpec, ParameterSpecSet
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceContainerCRUD, ResourceCRUD
 from cognite_toolkit._cdf_tk.exceptions import ToolkitMissingResourceError
-from cognite_toolkit._cdf_tk.loaders._base_loaders import ResourceContainerLoader, ResourceLoader
 from cognite_toolkit._cdf_tk.resource_classes import ThreeDModelYAML
 
-from .data_organization_loaders import DataSetsLoader
+from .data_organization import DataSetsCRUD
 
 
 @final
-class ThreeDModelLoader(
-    ResourceContainerLoader[str, ThreeDModelWrite, ThreeDModel, ThreeDModelWriteList, ThreeDModelList]
-):
+class ThreeDModelCRUD(ResourceContainerCRUD[str, ThreeDModelWrite, ThreeDModel]):
     folder_name = "3dmodels"
-    filename_pattern = r"^.*\.3DModel$"  # Matches all yaml files whose stem ends with '.3DModel'.
     resource_cls = ThreeDModel
     resource_write_cls = ThreeDModelWrite
-    list_cls = ThreeDModelList
-    list_write_cls = ThreeDModelWriteList
     kind = "3DModel"
     yaml_cls = ThreeDModelYAML
-    dependencies = frozenset({DataSetsLoader})
+    dependencies = frozenset({DataSetsCRUD})
     _doc_url = "3D-Models/operation/create3DModels"
     item_name = "revisions"
 
@@ -85,12 +77,9 @@ class ThreeDModelLoader(
             ]
         )
 
-        return capabilities.ThreeDAcl(
-            actions,
-            scope,  # type: ignore[arg-type]
-        )
+        return capabilities.ThreeDAcl(actions, scope)
 
-    def create(self, items: ThreeDModelWriteList) -> ThreeDModelList:
+    def create(self, items: Sequence[ThreeDModelWrite]) -> ThreeDModelList:
         created = ThreeDModelList([])
         for item in items:
             new_item = self.client.three_d.models.create(**item.dump(camel_case=False))
@@ -112,7 +101,7 @@ class ThreeDModelLoader(
                     break
         return output
 
-    def update(self, items: ThreeDModelWriteList) -> ThreeDModelList:
+    def update(self, items: Sequence[ThreeDModelWrite]) -> ThreeDModelList:
         found = self.retrieve([item.name for item in items])
         id_by_name = {model.name: model.id for model in found}
         # 3D Model does not have an external identifier, only internal.
@@ -167,25 +156,14 @@ class ThreeDModelLoader(
         return count
 
     @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Added by toolkit
-        spec.add(ParameterSpec(("dataSetExternalId",), frozenset({"str"}), is_required=False, _is_nullable=False))
-
-        # Should not be used, used for dataSetExternalId instead
-        spec.discard(ParameterSpec(("dataSetId",), frozenset({"int"}), is_required=False, _is_nullable=False))
-        return spec
-
-    @classmethod
-    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceLoader], Hashable]]:
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         """Returns all items that this item requires.
 
         For example, a TimeSeries requires a DataSet, so this method would return the
         DatasetLoader and identifier of that dataset.
         """
         if "dataSetExternalId" in item:
-            yield DataSetsLoader, item["dataSetExternalId"]
+            yield DataSetsCRUD, item["dataSetExternalId"]
 
     def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> ThreeDModelWrite:
         if ds_external_id := resource.pop("dataSetExternalId", None):

cognite_toolkit/_cdf_tk/{loaders/_resource_loaders/timeseries_loaders.py → cruds/_resource_cruds/timeseries.py}

@@ -1,56 +1,54 @@
 import json
 from collections.abc import Hashable, Iterable, Sequence
-from functools import lru_cache
+from itertools import zip_longest
 from pathlib import Path
-from typing import Any, cast, final
+from typing import Any, Literal, cast, final
 
 from cognite.client.data_classes import (
-    DatapointsList,
     DatapointSubscription,
     DatapointSubscriptionList,
+    DataPointSubscriptionUpdate,
     DataPointSubscriptionWrite,
-    DatapointSubscriptionWriteList,
     TimeSeries,
     TimeSeriesList,
     TimeSeriesWrite,
-    TimeSeriesWriteList,
 )
 from cognite.client.data_classes.capabilities import (
     Capability,
     TimeSeriesAcl,
     TimeSeriesSubscriptionsAcl,
 )
+from cognite.client.data_classes.data_modeling import NodeId
+from cognite.client.data_classes.datapoints_subscriptions import TimeSeriesIDList
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk._parameters import ANY_STR, ANYTHING, ParameterSpec, ParameterSpecSet
 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 (
     ToolkitRequiredValueError,
+    ToolkitValueError,
 )
-from cognite_toolkit._cdf_tk.loaders._base_loaders import ResourceContainerLoader, ResourceLoader
-from cognite_toolkit._cdf_tk.resource_classes import TimeSeriesYAML
+from cognite_toolkit._cdf_tk.resource_classes import DatapointSubscriptionYAML, TimeSeriesYAML
 from cognite_toolkit._cdf_tk.utils import calculate_hash
+from cognite_toolkit._cdf_tk.utils.collection import chunker
 from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_hashable, diff_list_identifiable, dm_identifier
 from cognite_toolkit._cdf_tk.utils.text import suffix_description
 
-from .auth_loaders import GroupAllScopedLoader, SecurityCategoryLoader
-from .classic_loaders import AssetLoader
-from .data_organization_loaders import DataSetsLoader
+from .auth import GroupAllScopedCRUD, SecurityCategoryCRUD
+from .classic import AssetCRUD
+from .data_organization import DataSetsCRUD
 
 
 @final
-class TimeSeriesLoader(ResourceContainerLoader[str, TimeSeriesWrite, TimeSeries, TimeSeriesWriteList, TimeSeriesList]):
+class TimeSeriesCRUD(ResourceContainerCRUD[str, TimeSeriesWrite, TimeSeries]):
     item_name = "datapoints"
     folder_name = "timeseries"
-    filename_pattern = r"^(?!.*DatapointSubscription$).*"
     resource_cls = TimeSeries
     resource_write_cls = TimeSeriesWrite
-    list_cls = TimeSeriesList
-    list_write_cls = TimeSeriesWriteList
     yaml_cls = TimeSeriesYAML
     kind = "TimeSeries"
-    dependencies = frozenset({DataSetsLoader, GroupAllScopedLoader, AssetLoader})
+    dependencies = frozenset({DataSetsCRUD, GroupAllScopedCRUD, AssetCRUD})
     _doc_url = "Time-series/operation/postTimeSeries"
 
     @property
@@ -71,10 +69,7 @@ class TimeSeriesLoader(ResourceContainerLoader[str, TimeSeriesWrite, TimeSeries,
             if dataset_ids := {item.data_set_id for item in items if item.data_set_id}:
                 scope = TimeSeriesAcl.Scope.DataSet(list(dataset_ids))
 
-        return TimeSeriesAcl(
-            actions,
-            scope,  # type: ignore[arg-type]
-        )
+        return TimeSeriesAcl(actions, scope)
 
     @classmethod
     def get_id(cls, item: TimeSeries | TimeSeriesWrite | dict) -> str:
@@ -95,14 +90,14 @@ class TimeSeriesLoader(ResourceContainerLoader[str, TimeSeriesWrite, TimeSeries,
         return {"externalId": id}
 
     @classmethod
-    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceLoader], Hashable]]:
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if "dataSetExternalId" in item:
-            yield DataSetsLoader, item["dataSetExternalId"]
+            yield DataSetsCRUD, item["dataSetExternalId"]
         if "securityCategoryNames" in item:
             for security_category in item["securityCategoryNames"]:
-                yield SecurityCategoryLoader, security_category
+                yield SecurityCategoryCRUD, security_category
         if "assetExternalId" in item:
-            yield AssetLoader, item["assetExternalId"]
+            yield AssetCRUD, item["assetExternalId"]
 
     def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> TimeSeriesWrite:
         if ds_external_id := resource.pop("dataSetExternalId", None):
@@ -125,7 +120,7 @@ class TimeSeriesLoader(ResourceContainerLoader[str, TimeSeriesWrite, TimeSeries,
             dumped["assetExternalId"] = self.client.lookup.assets.external_id(asset_id)
         return dumped
 
-    def create(self, items: TimeSeriesWriteList) -> TimeSeriesList:
+    def create(self, items: Sequence[TimeSeriesWrite]) -> TimeSeriesList:
         return self.client.time_series.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str | int]) -> TimeSeriesList:
@@ -134,7 +129,7 @@ class TimeSeriesLoader(ResourceContainerLoader[str, TimeSeriesWrite, TimeSeries,
             ids=internal_ids, external_ids=external_ids, ignore_unknown_ids=True
         )
 
-    def update(self, items: TimeSeriesWriteList) -> TimeSeriesList:
+    def update(self, items: Sequence[TimeSeriesWrite]) -> TimeSeriesList:
         return self.client.time_series.update(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str | int]) -> int:
@@ -154,18 +149,15 @@ class TimeSeriesLoader(ResourceContainerLoader[str, TimeSeriesWrite, TimeSeries,
         )
 
     def count(self, ids: str | dict[str, Any] | SequenceNotStr[str | dict[str, Any]] | None) -> int:
-        datapoints = cast(
-            DatapointsList,
-            self.client.time_series.data.retrieve(
-                external_id=cast(SequenceNotStr[str], ids),
-                start=MIN_TIMESTAMP_MS,
-                end=MAX_TIMESTAMP_MS + 1,
-                aggregates="count",
-                granularity="1000d",
-                ignore_unknown_ids=True,
-            ),
+        datapoints = self.client.time_series.data.retrieve(
+            external_id=ids,  # type: ignore[arg-type]
+            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)
+        return sum(sum(data.count or []) for data in datapoints)  # type: ignore[union-attr, misc, arg-type]
 
     def drop_data(self, ids: SequenceNotStr[str] | None) -> int:
         count = self.count(ids)
@@ -178,50 +170,35 @@ class TimeSeriesLoader(ResourceContainerLoader[str, TimeSeriesWrite, TimeSeries,
             )
         return count
 
-    @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Added by toolkit
-        spec.add(ParameterSpec(("dataSetExternalId",), frozenset({"str"}), is_required=False, _is_nullable=False))
-
-        spec.add(ParameterSpec(("securityCategoryNames",), frozenset({"list"}), is_required=False, _is_nullable=False))
-
-        spec.add(
-            ParameterSpec(("securityCategoryNames", ANY_STR), frozenset({"str"}), is_required=False, _is_nullable=False)
-        )
-        spec.add(ParameterSpec(("assetExternalId",), frozenset({"str"}), is_required=False, _is_nullable=False))
-        spec.discard(ParameterSpec(("assetId",), frozenset({"int"}), is_required=False, _is_nullable=False))
-        return spec
-
 
 @final
-class DatapointSubscriptionLoader(
-    ResourceLoader[
+class DatapointSubscriptionCRUD(
+    ResourceCRUD[
         str,
         DataPointSubscriptionWrite,
         DatapointSubscription,
-        DatapointSubscriptionWriteList,
-        DatapointSubscriptionList,
     ]
 ):
     folder_name = "timeseries"
-    filename_pattern = r"^.*DatapointSubscription$"  # Matches all yaml files who end with *DatapointSubscription.
     resource_cls = DatapointSubscription
     resource_write_cls = DataPointSubscriptionWrite
-    list_cls = DatapointSubscriptionList
-    list_write_cls = DatapointSubscriptionWriteList
     kind = "DatapointSubscription"
     _doc_url = "Data-point-subscriptions/operation/postSubscriptions"
     dependencies = frozenset(
         {
-            TimeSeriesLoader,
-            GroupAllScopedLoader,
+            TimeSeriesCRUD,
+            GroupAllScopedCRUD,
         }
     )
+    yaml_cls = DatapointSubscriptionYAML
 
     _hash_key = "cdf-hash"
     _description_character_limit = 1000
+    # A datapoint subscription can hold 10,000 timeseries, but the API
+    # only supports 100 timeseries per request. Thus, if a subscription
+    # has more than 100 timeseries, we need to split it into multiple requests.
+    _TIMESERIES_ID_REQUEST_LIMIT = 100
+    _MAX_TIMESERIES_IDS = 10_000
 
     @property
     def display_name(self) -> str:
@@ -238,29 +215,11 @@ class DatapointSubscriptionLoader(
         return {"externalId": id}
 
     @classmethod
-    @lru_cache(maxsize=1)
-    def get_write_cls_parameter_spec(cls) -> ParameterSpecSet:
-        spec = super().get_write_cls_parameter_spec()
-        # Added by toolkit
-        spec.add(ParameterSpec(("dataSetExternalId",), frozenset({"str"}), is_required=False, _is_nullable=False))
-        # The Filter class in the SDK class View implementation is deviating from the API.
-        # So we need to modify the spec to match the API.
-        parameter_path = ("filter",)
-        length = len(parameter_path)
-        for item in spec:
-            if len(item.path) >= length + 1 and item.path[:length] == parameter_path[:length]:
-                # Add extra ANY_STR layer
-                # The spec class is immutable, so we use this trick to modify it.
-                object.__setattr__(item, "path", (*item.path[:length], ANY_STR, *item.path[length:]))
-        spec.add(ParameterSpec(("filter", ANYTHING), frozenset({"dict"}), is_required=False, _is_nullable=False))
-        return spec
-
-    @classmethod
-    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceLoader], Hashable]]:
+    def get_dependent_items(cls, item: dict) -> Iterable[tuple[type[ResourceCRUD], Hashable]]:
         if "dataSetExternalId" in item:
-            yield DataSetsLoader, item["dataSetExternalId"]
+            yield DataSetsCRUD, item["dataSetExternalId"]
         for timeseries_id in item.get("timeSeriesIds", []):
-            yield TimeSeriesLoader, timeseries_id
+            yield TimeSeriesCRUD, timeseries_id
 
     @classmethod
     def get_required_capability(
@@ -282,16 +241,17 @@ class DatapointSubscriptionLoader(
             if data_set_ids := {item.data_set_id for item in items if item.data_set_id}:
                 scope = TimeSeriesSubscriptionsAcl.Scope.DataSet(list(data_set_ids))
 
-        return TimeSeriesSubscriptionsAcl(
-            actions,
-            scope,  # type: ignore[arg-type]
-        )
+        return TimeSeriesSubscriptionsAcl(actions, scope)
 
-    def create(self, items: DatapointSubscriptionWriteList) -> DatapointSubscriptionList:
-        created = DatapointSubscriptionList([])
+    def create(self, items: Sequence[DataPointSubscriptionWrite]) -> DatapointSubscriptionList:
+        created_list = DatapointSubscriptionList([])
         for item in items:
-            created.append(self.client.time_series.subscriptions.create(item))
-        return created
+            to_create, batches = self.create_split_timeseries_ids(item)
+            created = self.client.time_series.subscriptions.create(to_create)
+            for batch_item in batches:
+                created = self.client.time_series.subscriptions.update(batch_item)
+            created_list.append(created)
+        return created_list
 
     def retrieve(self, ids: SequenceNotStr[str]) -> DatapointSubscriptionList:
         items = DatapointSubscriptionList([])
@@ -301,16 +261,20 @@ class DatapointSubscriptionLoader(
                 items.append(retrieved)
         return items
 
-    def update(self, items: DatapointSubscriptionWriteList) -> DatapointSubscriptionList:
-        updated = DatapointSubscriptionList([])
+    def update(self, items: Sequence[DataPointSubscriptionWrite]) -> DatapointSubscriptionList:
+        updated_list = DatapointSubscriptionList([])
         for item in items:
+            current = self.client.time_series.subscriptions.list_member_time_series(item.external_id, limit=-1)
+            to_update, batches = self.update_split_timeseries_ids(item, current)
             # There are two versions of a TimeSeries Subscription, one selects timeseries based filter
             # and the other selects timeseries based on timeSeriesIds. If we use mode='replace', we try
             # to set timeSeriesIds to an empty list, while the filter is set. This will result in an error.
-            update = self.client.time_series.subscriptions.update(item, mode="replace_ignore_null")
-            updated.append(update)
+            updated = self.client.time_series.subscriptions.update(to_update, mode="replace_ignore_null")
+            for batch_item in batches:
+                updated = self.client.time_series.subscriptions.update(batch_item)
+            updated_list.append(updated)
 
-        return updated
+        return updated_list
 
     def delete(self, ids: SequenceNotStr[str]) -> int:
         try:
@@ -394,3 +358,143 @@ class DatapointSubscriptionLoader(
         elif json_path == ("instanceIds",):
             return diff_list_identifiable(local, cdf, get_identifier=dm_identifier)
         return super().diff_list(local, cdf, json_path)
+
+    @classmethod
+    def create_split_timeseries_ids(
+        cls, subscription: DataPointSubscriptionWrite
+    ) -> tuple[DataPointSubscriptionWrite, list[DataPointSubscriptionUpdate]]:
+        """Split the time series IDs into batches of 100.
+        This is needed because the API only supports 100 time series IDs per request.
+
+        Note this is the total of time series IDs and instance IDs.
+        """
+        total_timeseries = len(subscription.time_series_ids or []) + len(subscription.instance_ids or [])
+        cls._validate_total_below_limit(subscription, total_timeseries)
+        if total_timeseries <= cls._TIMESERIES_ID_REQUEST_LIMIT:
+            # If the subscription has less than or equal to 100 time series IDs, we can return it as is.
+            # No need to split into batches.
+            return subscription, []
+
+        # Serialization to create a copy of the subscription
+        to_create = DataPointSubscriptionWrite.load(subscription.dump())
+        all_timeseries_ids = to_create.time_series_ids or []
+        all_instance_ids = to_create.instance_ids or []
+
+        # Create the first batch for the create/update call, prioritizing time_series_ids
+        to_create.time_series_ids = all_timeseries_ids[: cls._TIMESERIES_ID_REQUEST_LIMIT]
+        space_in_first_batch = cls._TIMESERIES_ID_REQUEST_LIMIT - len(to_create.time_series_ids)
+        to_create.instance_ids = all_instance_ids[:space_in_first_batch]
+
+        # Prepare remaining IDs for update batches
+        remaining_timeseries_ids = all_timeseries_ids[len(to_create.time_series_ids) :]
+        remaining_instance_ids = all_instance_ids[len(to_create.instance_ids) :]
+
+        # Using a list of tuples to preserve the type of ID
+        all_remaining_ids = [("ts", id) for id in remaining_timeseries_ids] + [
+            ("instance", id) for id in remaining_instance_ids
+        ]
+
+        batches: list[DataPointSubscriptionUpdate] = []
+        for chunk in chunker(all_remaining_ids, cls._TIMESERIES_ID_REQUEST_LIMIT):
+            update = DataPointSubscriptionUpdate(external_id=subscription.external_id)
+            ts_ids_in_chunk, instance_ids_in_chunk = cls._split_ts_instance_ids(chunk)
+            if ts_ids_in_chunk:
+                update.time_series_ids.add(ts_ids_in_chunk)
+            if instance_ids_in_chunk:
+                update.instance_ids.add(instance_ids_in_chunk)
+            batches.append(update)
+        return to_create, batches
+
+    @classmethod
+    def _validate_total_below_limit(cls, subscription: DataPointSubscriptionWrite, total_timeseries: int) -> None:
+        if total_timeseries > cls._MAX_TIMESERIES_IDS:
+            raise ToolkitValueError(
+                f'Subscription "{subscription.external_id}" has {total_timeseries:,} time series, '
+                f"which is more than the limit of {cls._MAX_TIMESERIES_IDS:,}."
+            )
+
+    @classmethod
+    def _split_ts_instance_ids(
+        cls, ids: list[tuple[Literal["ts"], str] | tuple[Literal["instance"], NodeId]]
+    ) -> tuple[list[str], list[NodeId]]:
+        ts_ids, instance_ids = [], []
+        for id_type, identifier in ids:
+            if id_type == "ts":
+                ts_ids.append(identifier)
+            else:
+                instance_ids.append(identifier)
+        # MyPy fails to understand the logic above ensures that ts_ids is a list of str
+        # and instance_ids is a list of NodeId.
+        return ts_ids, instance_ids  # type: ignore[return-value]
+
+    @classmethod
+    def update_split_timeseries_ids(
+        cls, subscription: DataPointSubscriptionWrite, current_ts: TimeSeriesIDList
+    ) -> tuple[DataPointSubscriptionWrite, list[DataPointSubscriptionUpdate]]:
+        """Split the time series IDs into batches of 100.
+        This is needed because the API only supports 100 time series IDs per request.
+
+        Note this is the total of time series IDs and instance IDs.
+
+        In addition, this method will compare to the current times series IDs and
+        update the subscription with adding and removing time series IDs as needed.
+        """
+        if subscription.time_series_ids is None and subscription.instance_ids is None:
+            # The subscription is using a filter, so we can return it as is.
+            return subscription, []
+        total_timeseries = len(subscription.time_series_ids or []) + len(subscription.instance_ids or [])
+        cls._validate_total_below_limit(subscription, total_timeseries)
+
+        # Serialization to create a copy of the subscription
+        to_update = DataPointSubscriptionWrite.load(subscription.dump())
+
+        # Get desired time series IDs
+        desired_timeseries_ids = set(to_update.time_series_ids or [])
+        desired_instance_ids = set(to_update.instance_ids or [])
+
+        # Get current time series IDs from the subscription
+        current_timeseries_ids: set[str] = set()
+        current_instance_ids: set[NodeId] = set()
+        for ts in current_ts:
+            if ts.external_id and ts.instance_id is None:
+                current_timeseries_ids.add(ts.external_id)
+            elif ts.instance_id and ts.external_id is None:
+                current_instance_ids.add(ts.instance_id)
+            else:
+                raise ValueError(f"External ID and instance ID are both set for time series {ts.external_id}.")
+
+        # Calculate what needs to be added and removed
+        ts_to_add = desired_timeseries_ids - current_timeseries_ids
+        ts_to_remove = current_timeseries_ids - desired_timeseries_ids
+        instance_to_add = desired_instance_ids - current_instance_ids
+        instance_to_remove = current_instance_ids - desired_instance_ids
+
+        # Clear the time series IDs from the main update to avoid conflicts
+        # The to_update object is used to update all other properties of the subscription.
+        to_update.time_series_ids = None
+        to_update.instance_ids = None
+
+        # Create update batches for changes
+        batches: list[DataPointSubscriptionUpdate] = []
+        all_removals = [("ts", id_) for id_ in ts_to_remove] + [("instance", id_) for id_ in instance_to_remove]
+        all_additions = [("ts", id_) for id_ in ts_to_add] + [("instance", id_) for id_ in instance_to_add]
+        for removals, additions in zip_longest(
+            chunker(all_removals, cls._TIMESERIES_ID_REQUEST_LIMIT),
+            chunker(all_additions, cls._TIMESERIES_ID_REQUEST_LIMIT),
+            fillvalue=None,
+        ):
+            update = DataPointSubscriptionUpdate(external_id=subscription.external_id)
+            ts_ids_to_remove, instance_ids_to_remove = cls._split_ts_instance_ids(removals or [])
+            if ts_ids_to_remove:
+                update.time_series_ids.remove(ts_ids_to_remove)
+            if instance_ids_to_remove:
+                update.instance_ids.remove(instance_ids_to_remove)
+
+            ts_ids_to_add, instance_ids_to_add = cls._split_ts_instance_ids(additions or [])
+            if ts_ids_to_add:
+                update.time_series_ids.add(ts_ids_to_add)
+            if instance_ids_to_add:
+                update.instance_ids.add(instance_ids_to_add)
+            batches.append(update)
+
+        return to_update, batches