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

cognite_toolkit/_cdf_tk/client/api/{charts.py → legacy/charts.py}

@@ -6,7 +6,7 @@ from cognite.client._api_client import APIClient
 from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.charts import (
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.charts import (
     Chart,
     ChartList,
     ChartWrite,

cognite_toolkit/_cdf_tk/client/api/{extended_data_modeling.py → legacy/extended_data_modeling.py}

@@ -16,7 +16,7 @@ from cognite.client.utils._concurrency import execute_tasks
 from requests import Response
 
 from cognite_toolkit._cdf_tk.client._constants import DATA_MODELING_MAX_DELETE_WORKERS, DATA_MODELING_MAX_WRITE_WORKERS
-from cognite_toolkit._cdf_tk.client.data_classes.instances import InstancesApplyResultList
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.instances import InstancesApplyResultList
 from cognite_toolkit._cdf_tk.client.utils._concurrency import ToolkitConcurrencySettings
 from cognite_toolkit._cdf_tk.client.utils._http_client import ToolkitRetryTracker
 

cognite_toolkit/_cdf_tk/client/api/{extended_files.py → legacy/extended_files.py}

@@ -9,11 +9,11 @@ from cognite.client.utils._concurrency import execute_tasks
 from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.extended_filemetadata import (
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.extended_filemetadata import (
     ExtendedFileMetadata,
     ExtendedFileMetadataList,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.pending_instances_ids import PendingInstanceId
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.pending_instances_ids import PendingInstanceId
 
 
 class ExtendedFileMetadataAPI(FilesAPI):

cognite_toolkit/_cdf_tk/client/api/{extended_functions.py → legacy/extended_functions.py}

@@ -7,7 +7,7 @@ from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client.config import ToolkitClientConfig
 from cognite_toolkit._cdf_tk.utils.collection import chunker
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, SimpleBodyRequest
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, RequestMessage2
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
 
@@ -17,15 +17,16 @@ class ExtendedFunctionsAPI(FunctionsAPI):
         config: ToolkitClientConfig,
         api_version: str | None,
         cognite_client: CogniteClient,
+        console: Console | None = None,
     ) -> None:
         """
         Extended Functions API to include custom headers and payload preparation.
         """
         super().__init__(config, api_version, cognite_client)
         self._toolkit_config = config
-        self._toolkit_http_client = HTTPClient(config, max_retries=global_config.max_retries)
+        self._toolkit_http_client = HTTPClient(config, max_retries=global_config.max_retries, console=console)
 
-    def create_with_429_retry(self, function: FunctionWrite, console: Console | None = None) -> Function:
+    def create_with_429_retry(self, function: FunctionWrite) -> Function:
         """Create a function with manual retry handling for 429 Too Many Requests responses.
 
         This method is a workaround for scenarios where the function creation API is temporarily unavailable
@@ -33,26 +34,22 @@ class ExtendedFunctionsAPI(FunctionsAPI):
 
         Args:
             function (FunctionWrite): The function to create.
-            console (Console | None): The rich console to use for printing warnings.
 
         Returns:
             Function: The created function object.
         """
-        result = self._toolkit_http_client.request_with_retries(
-            message=SimpleBodyRequest(
+        result = self._toolkit_http_client.request_single_retries(
+            message=RequestMessage2(
                 endpoint_url=self._toolkit_config.create_api_url("/functions"),
                 method="POST",
                 body_content={"items": [function.dump(camel_case=True)]},
-            ),
-            console=console,
+            )
         )
-        result.raise_for_status()
+        success = result.get_success_or_raise()
         # We assume the API response is one item on a successful creation
-        return Function._load(result.get_first_body()["items"][0], cognite_client=self._cognite_client)  # type: ignore[arg-type,index]
+        return Function._load(success.body_json["items"][0], cognite_client=self._cognite_client)
 
-    def delete_with_429_retry(
-        self, external_id: SequenceNotStr[str], ignore_unknown_ids: bool = False, console: Console | None = None
-    ) -> None:
+    def delete_with_429_retry(self, external_id: SequenceNotStr[str], ignore_unknown_ids: bool = False) -> None:
         """Delete one or more functions with retry handling for 429 Too Many Requests responses.
 
         This method is an improvement over the standard delete method in the FunctionsAPI.
@@ -72,12 +69,12 @@ class ExtendedFunctionsAPI(FunctionsAPI):
             }
             if ignore_unknown_ids:
                 body_content["ignoreUnknownIds"] = True
-            self._toolkit_http_client.request_with_retries(
-                message=SimpleBodyRequest(
+            result = self._toolkit_http_client.request_single_retries(
+                message=RequestMessage2(
                     endpoint_url=self._toolkit_config.create_api_url("/functions/delete"),
                     method="POST",
                     body_content=body_content,
-                ),
-                console=console,
-            ).raise_for_status()
+                )
+            )
+            result.get_success_or_raise()
         return None

cognite_toolkit/_cdf_tk/client/api/{extended_raw.py → legacy/extended_raw.py}

@@ -1,6 +1,6 @@
 from cognite.client._api.raw import RawAPI
 
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawProfileResults, RawTable
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.raw import RawProfileResults, RawTable
 
 
 class ExtendedRawAPI(RawAPI):

cognite_toolkit/_cdf_tk/client/api/{extended_timeseries.py → legacy/extended_timeseries.py}

@@ -13,8 +13,11 @@ from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils._validation import prepare_filter_sort, process_asset_subtree_ids, process_data_set_ids
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.extended_timeseries import ExtendedTimeSeries, ExtendedTimeSeriesList
-from cognite_toolkit._cdf_tk.client.data_classes.pending_instances_ids import PendingInstanceId
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.extended_timeseries import (
+    ExtendedTimeSeries,
+    ExtendedTimeSeriesList,
+)
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.pending_instances_ids import PendingInstanceId
 
 
 class ExtendedTimeSeriesAPI(TimeSeriesAPI):

cognite_toolkit/_cdf_tk/client/api/{location_filters.py → legacy/location_filters.py}

@@ -6,7 +6,7 @@ from cognite.client._api_client import APIClient
 from cognite.client.config import ClientConfig
 from cognite.client.utils._identifier import IdentifierSequence
 
-from cognite_toolkit._cdf_tk.client.data_classes.location_filters import (
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.location_filters import (
     LocationFilter,
     LocationFilterList,
     LocationFilterWrite,

cognite_toolkit/_cdf_tk/client/api/legacy/robotics/__init__.py

@@ -0,0 +1,8 @@
+from .api import RoboticsAPI
+from .capabilities import CapabilitiesAPI
+from .data_postprocessing import DataPostProcessingAPI
+from .frames import FramesAPI
+from .locations import LocationsAPI
+from .maps import MapsAPI
+
+__all__ = ["CapabilitiesAPI", "DataPostProcessingAPI", "FramesAPI", "LocationsAPI", "MapsAPI", "RoboticsAPI"]

cognite_toolkit/_cdf_tk/client/api/{robotics → legacy/robotics}/capabilities.py

@@ -5,7 +5,7 @@ from cognite.client._api_client import APIClient
 from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.robotics import (
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.robotics import (
     RobotCapability,
     RobotCapabilityList,
     RobotCapabilityWrite,

cognite_toolkit/_cdf_tk/client/api/{robotics → legacy/robotics}/data_postprocessing.py

@@ -5,7 +5,7 @@ from cognite.client._api_client import APIClient
 from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.robotics import (
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.robotics import (
     DataPostProcessing,
     DataPostProcessingList,
     DataPostProcessingWrite,

cognite_toolkit/_cdf_tk/client/api/{robotics → legacy/robotics}/frames.py

@@ -5,7 +5,7 @@ from cognite.client._api_client import APIClient
 from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.robotics import (
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.robotics import (
     Frame,
     FrameList,
     FrameWrite,

cognite_toolkit/_cdf_tk/client/api/{robotics → legacy/robotics}/locations.py

@@ -5,7 +5,7 @@ from cognite.client._api_client import APIClient
 from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.robotics import (
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.robotics import (
     Location,
     LocationList,
     LocationWrite,

cognite_toolkit/_cdf_tk/client/api/{robotics → legacy/robotics}/maps.py

@@ -5,7 +5,7 @@ from cognite.client._api_client import APIClient
 from cognite.client.utils._identifier import IdentifierSequence
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.robotics import (
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.robotics import (
     Map,
     MapList,
     MapWrite,

cognite_toolkit/_cdf_tk/client/api/{robotics → legacy/robotics}/robots.py

@@ -3,8 +3,8 @@ from typing import overload
 
 from cognite.client._api_client import APIClient
 
-from cognite_toolkit._cdf_tk.client.api.robotics.utlis import tmp_disable_gzip
-from cognite_toolkit._cdf_tk.client.data_classes.robotics import Robot, RobotList, RobotWrite, _RobotUpdate
+from cognite_toolkit._cdf_tk.client.api.legacy.robotics.utlis import tmp_disable_gzip
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.robotics import Robot, RobotList, RobotWrite, _RobotUpdate
 
 
 class RobotsAPI(APIClient):

cognite_toolkit/_cdf_tk/client/api/{search_config.py → legacy/search_config.py}

@@ -4,7 +4,11 @@ from cognite.client import CogniteClient
 from cognite.client._api_client import APIClient
 from cognite.client.config import ClientConfig
 
-from cognite_toolkit._cdf_tk.client.data_classes.search_config import SearchConfig, SearchConfigList, SearchConfigWrite
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.search_config import (
+    SearchConfig,
+    SearchConfigList,
+    SearchConfigWrite,
+)
 
 
 class SearchConfigurationsAPI(APIClient):

cognite_toolkit/_cdf_tk/client/api/migration.py

@@ -1,7 +1,7 @@
 import warnings
 from collections.abc import Sequence
 from itertools import groupby
-from typing import TypeVar, overload
+from typing import Literal, TypeVar, cast, overload
 
 from cognite.client._constants import DEFAULT_LIMIT_READ
 from cognite.client.data_classes.data_modeling import (
@@ -10,12 +10,14 @@ from cognite.client.data_classes.data_modeling import (
     NodeApplyResultList,
     NodeId,
     NodeList,
+    ViewId,
     filters,
     query,
 )
 from cognite.client.utils.useful_types import SequenceNotStr
 
-from cognite_toolkit._cdf_tk.client.data_classes.migration import (
+from cognite_toolkit._cdf_tk.client.api.legacy.extended_data_modeling import ExtendedInstancesAPI
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.migration import (
     AssetCentricId,
     CreatedSourceSystem,
     InstanceSource,
@@ -28,8 +30,6 @@ from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
 from cognite_toolkit._cdf_tk.utils.collection import chunker_sequence
 from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricType
 
-from .extended_data_modeling import ExtendedInstancesAPI
-
 
 class InstanceSourceAPI:
     def __init__(self, instance_api: ExtendedInstancesAPI) -> None:
@@ -347,9 +347,182 @@ class SpaceSourceAPI:
         return results
 
 
+_T_Cached = TypeVar("_T_Cached", bound=NodeId | ViewId)
+
+
+class LookupAPI:
+    def __init__(self, instance_api: ExtendedInstancesAPI, resource_type: AssetCentricType) -> None:
+        self._instance_api = instance_api
+        self._resource_type = resource_type
+        self._view_id = InstanceSource.get_source()
+        self._node_id_by_id: dict[int, NodeId | None] = {}
+        self._node_id_by_external_id: dict[str, NodeId | None] = {}
+        self._consumer_view_id_by_id: dict[int, ViewId | None] = {}
+        self._consumer_view_id_by_external_id: dict[str, ViewId | None] = {}
+        self._RETRIEVE_LIMIT = 1000
+
+    @overload
+    def __call__(self, id: int, external_id: None = None) -> NodeId | None: ...
+
+    @overload
+    def __call__(self, id: SequenceNotStr[int], external_id: None = None) -> dict[int, NodeId]: ...
+
+    @overload
+    def __call__(self, *, external_id: str) -> NodeId | None: ...
+
+    @overload
+    def __call__(self, *, external_id: SequenceNotStr[str]) -> dict[str, NodeId]: ...
+
+    def __call__(
+        self, id: int | SequenceNotStr[int] | None = None, external_id: str | SequenceNotStr[str] | None = None
+    ) -> dict[int, NodeId] | dict[str, NodeId] | NodeId | None:
+        """Lookup NodeId by either internal ID or external ID.
+
+        Args:
+            id (int | Sequence[int] | None): The internal ID(s) to lookup.
+            external_id (str | SequenceNotStr[str] | None): The external ID(s) to lookup.
+
+        Returns:
+            NodeId | dict[int, NodeId] | dict[str, NodeId] | None: The corresponding NodeId(s) if found, otherwise None.
+
+        """
+        if id is not None and external_id is None:
+            return self._lookup(
+                identifier=id,
+                cache=self._node_id_by_id,
+                property_name="id",
+                return_type=NodeId,
+                input_type=int,
+            )
+        elif external_id is not None and id is None:
+            return self._lookup(
+                identifier=external_id,
+                cache=self._node_id_by_external_id,
+                property_name="classicExternalId",
+                return_type=NodeId,
+                input_type=str,
+            )
+        else:
+            raise TypeError("Either id or external_id must be provided, but not both.")
+
+    @overload
+    def consumer_view(self, id: int, external_id: None = None) -> ViewId | None: ...
+
+    @overload
+    def consumer_view(self, id: SequenceNotStr[int], external_id: None = None) -> dict[int, ViewId]: ...
+
+    @overload
+    def consumer_view(self, *, external_id: str) -> ViewId | None: ...
+
+    @overload
+    def consumer_view(self, *, external_id: SequenceNotStr[str]) -> dict[str, ViewId]: ...
+
+    def consumer_view(
+        self, id: int | SequenceNotStr[int] | None = None, external_id: str | SequenceNotStr[str] | None = None
+    ) -> dict[int, ViewId] | dict[str, ViewId] | ViewId | None:
+        """Lookup Consumer ViewId by either internal ID or external ID.
+
+        Args:
+            id (int | Sequence[int] | None): The internal ID(s) to lookup.
+            external_id (str | SequenceNotStr[str] | None): The external ID(s) to lookup.
+        Returns:
+            ViewId | dict[int, ViewId] | dict[str, ViewId] | None
+        """
+        if id is not None and external_id is None:
+            return self._lookup(
+                identifier=id,
+                cache=self._consumer_view_id_by_id,
+                property_name="id",
+                return_type=ViewId,
+                input_type=int,
+            )
+        elif external_id is not None and id is None:
+            return self._lookup(
+                identifier=external_id,
+                cache=self._consumer_view_id_by_external_id,
+                property_name="classicExternalId",
+                return_type=ViewId,
+                input_type=str,
+            )
+        else:
+            raise TypeError("Either id or external_id must be provided, but not both.")
+
+    def _lookup(
+        self,
+        identifier: _T | SequenceNotStr[_T],
+        cache: dict[_T, _T_Cached | None],
+        property_name: Literal["id", "classicExternalId"],
+        return_type: type[_T_Cached],
+        input_type: type[_T],
+    ) -> dict[_T, _T_Cached] | _T_Cached | None:
+        """Generic lookup method for both NodeId and ViewId by id or external_id."""
+        is_single = isinstance(identifier, input_type)
+        # MyPy does not understand that if is_single is True, identifier is _T, else SequenceNotStr[_T].
+        identifiers: list[_T] = [identifier] if is_single else list(identifier)  # type: ignore[arg-type, list-item]
+
+        missing = [id_ for id_ in identifiers if id_ not in cache]
+        if missing:
+            self._fetch_and_cache(missing, by=property_name)
+
+        if is_single:
+            return cache.get(identifier)  # type: ignore[arg-type]
+
+        return {id_: value for id_ in identifiers if isinstance(value := cache.get(id_), return_type)}
+
+    def _fetch_and_cache(self, identifiers: Sequence[int | str], by: Literal["id", "classicExternalId"]) -> None:
+        for chunk in chunker_sequence(identifiers, self._RETRIEVE_LIMIT):
+            retrieve_query = query.Query(
+                with_={
+                    "instanceSource": query.NodeResultSetExpression(
+                        filter=filters.And(
+                            filters.HasData(views=[self._view_id]),
+                            filters.Equals(self._view_id.as_property_ref("resourceType"), self._resource_type),
+                            filters.In(self._view_id.as_property_ref(by), list(chunk)),
+                        ),
+                        limit=len(chunk),
+                    ),
+                },
+                select={"instanceSource": query.Select([query.SourceSelector(self._view_id, ["*"])])},
+            )
+            chunk_response = self._instance_api.query(retrieve_query)
+            items = chunk_response.get("instanceSource", [])
+            for item in items:
+                instance_source = InstanceSource._load(item.dump())
+                node_id = instance_source.as_id()
+                self._node_id_by_id[instance_source.id_] = node_id
+                self._consumer_view_id_by_id[instance_source.id_] = instance_source.consumer_view()
+                if instance_source.classic_external_id:
+                    self._node_id_by_external_id[instance_source.classic_external_id] = node_id
+                    self._consumer_view_id_by_external_id[instance_source.classic_external_id] = (
+                        instance_source.consumer_view()
+                    )
+            missing = set(chunk) - set(self._node_id_by_id.keys()) - set(self._node_id_by_external_id.keys())
+            if by == "id":
+                for missing_id in cast(set[int], missing):
+                    if missing_id not in self._node_id_by_id:
+                        self._node_id_by_id[missing_id] = None
+                    if missing_id not in self._consumer_view_id_by_id:
+                        self._consumer_view_id_by_id[missing_id] = None
+            elif by == "classicExternalId":
+                for missing_ext_id in cast(set[str], missing):
+                    if missing_ext_id not in self._node_id_by_external_id:
+                        self._node_id_by_external_id[missing_ext_id] = None
+                    if missing_ext_id not in self._consumer_view_id_by_external_id:
+                        self._consumer_view_id_by_external_id[missing_ext_id] = None
+
+
+class MigrationLookupAPI:
+    def __init__(self, instance_api: ExtendedInstancesAPI) -> None:
+        self.assets = LookupAPI(instance_api, "asset")
+        self.events = LookupAPI(instance_api, "event")
+        self.files = LookupAPI(instance_api, "file")
+        self.time_series = LookupAPI(instance_api, "timeseries")
+
+
 class MigrationAPI:
     def __init__(self, instance_api: ExtendedInstancesAPI) -> None:
         self.instance_source = InstanceSourceAPI(instance_api)
         self.resource_view_mapping = ResourceViewMappingAPI(instance_api)
         self.created_source_system = CreatedSourceSystemAPI(instance_api)
         self.space_source = SpaceSourceAPI(instance_api)
+        self.lookup = MigrationLookupAPI(instance_api)

cognite_toolkit/_cdf_tk/client/api/project.py

@@ -1,8 +1,8 @@
 from cognite.client import CogniteClient
 
 from cognite_toolkit._cdf_tk.client.config import ToolkitClientConfig
-from cognite_toolkit._cdf_tk.client.data_classes.project import ProjectStatusList
-from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, ParamRequest
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.project import ProjectStatusList
+from cognite_toolkit._cdf_tk.utils.http_client import HTTPClient, RequestMessage2
 
 
 class ProjectAPI:
@@ -13,11 +13,12 @@ class ProjectAPI:
 
     def status(self) -> ProjectStatusList:
         """Retrieve information about the current project."""
-        response = self._http_client.request_with_retries(
-            ParamRequest(
-                endpoint_url=f"{self._config.base_url}/api/v1/projects?withDataModelingStatus=true", method="GET"
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
+                endpoint_url=f"{self._config.base_url}/api/v1/projects",
+                method="GET",
+                parameters={"withDataModelingStatus": True},
             )
         )
-        response.raise_for_status()
-        body = response.get_first_body()
-        return ProjectStatusList._load(body["items"], cognite_client=self._cognite_client)  # type: ignore[arg-type]
+        success = response.get_success_or_raise()
+        return ProjectStatusList._load(success.body_json["items"], cognite_client=self._cognite_client)

cognite_toolkit/_cdf_tk/client/api/search.py

@@ -2,8 +2,8 @@ from cognite.client import CogniteClient
 from cognite.client._api_client import APIClient
 from cognite.client.config import ClientConfig
 
-from .location_filters import LocationFiltersAPI
-from .search_config import SearchConfigurationsAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.location_filters import LocationFiltersAPI
+from cognite_toolkit._cdf_tk.client.api.legacy.search_config import SearchConfigurationsAPI
 
 
 class SearchAPI(APIClient):

cognite_toolkit/_cdf_tk/client/api/streams.py

@@ -0,0 +1,88 @@
+from collections.abc import Sequence
+
+from pydantic import TypeAdapter
+from rich.console import Console
+
+from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse
+from cognite_toolkit._cdf_tk.client.data_classes.streams import StreamRequest, StreamResponse
+from cognite_toolkit._cdf_tk.utils.http_client import (
+    HTTPClient,
+    ItemsRequest2,
+    RequestMessage2,
+)
+
+
+class StreamsAPI:
+    ENDPOINT = "/streams"
+
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self._console = console
+        self._config = http_client.config
+
+    def create(self, items: Sequence[StreamRequest]) -> list[StreamResponse]:
+        """Create one or more streams.
+
+        Args:
+            items: Sequence of StreamRequest items to create.
+
+        Returns:
+            List of created StreamResponse items.
+        """
+        responses = self._http_client.request_items_retries(
+            ItemsRequest2(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=items,
+            )
+        )
+        responses.raise_for_status()
+        return TypeAdapter(list[StreamResponse]).validate_python(responses.get_items())
+
+    def delete(self, external_id: str) -> None:
+        """Delete stream using its external ID.
+
+        Args:
+            external_id: External ID of the stream to delete.
+        """
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/{external_id}"),
+                method="DELETE",
+            )
+        )
+        _ = response.get_success_or_raise()
+
+    def list(self) -> list[StreamResponse]:
+        """List streams.
+
+        Returns:
+            StreamResponseList containing the listed streams.
+        """
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="GET",
+            )
+        )
+        success = response.get_success_or_raise()
+        return PagedResponse[StreamResponse].model_validate(success.body_json).items
+
+    def retrieve(self, external_id: str, include_statistics: bool = True) -> StreamResponse:
+        """Retrieve a stream by its external ID.
+
+        Args:
+            external_id: External ID of the stream to retrieve.
+            include_statistics: Whether to include usage statistics in the response.
+        Returns:
+            StreamResponse item.
+        """
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/{external_id}"),
+                method="GET",
+                parameters={"includeStatistics": include_statistics},
+            )
+        )
+        success = response.get_success_or_raise()
+        return StreamResponse.model_validate(success.body_json)