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

cognite_toolkit/_cdf_tk/client/api/charts.py

@@ -0,0 +1,125 @@
+from collections.abc import Sequence
+from typing import overload
+from urllib.parse import urljoin
+
+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 (
+    Chart,
+    ChartList,
+    ChartWrite,
+    Visibility,
+)
+from cognite_toolkit._cdf_tk.utils.collection import chunker
+
+
+class ChartsAPI(APIClient):
+    _RESOURCE_PATH = "/storage/charts/charts"
+
+    def _get_base_url_with_base_path(self) -> str:
+        """
+        This method is overridden to provide the correct base path for the Search Configurations API.
+        This method in base class APIClient appends /api/{api_version}/ to the base URL,
+        but for Charts API, we need a different path structure.
+        """
+        base_path = ""
+        if self._api_version:
+            base_path = f"/apps/{self._api_version}/projects/{self._config.project}"
+        return urljoin(self._config.base_url, base_path)
+
+    @overload
+    def upsert(self, items: ChartWrite) -> Chart: ...
+
+    @overload
+    def upsert(self, items: Sequence[ChartWrite]) -> ChartList: ...
+
+    def upsert(self, items: ChartWrite | Sequence[ChartWrite]) -> Chart | ChartList:
+        """Upsert one or more charts in CDF.
+
+        Args:
+            items (ChartWrite | Sequence[ChartWrite]): Chart(s) to upsert. Can be a single ChartWrite or a sequence of ChartWrite.
+
+        Returns:
+            Chart | ChartList: List of upserted charts if multiple items are provided, otherwise a single Chart.
+        """
+        item_sequence = items if isinstance(items, Sequence) else [items]
+        result = ChartList([])
+        # We are avoiding concurrency here as the Charts backend it not necessarily designed for it.
+        for chunk in chunker(item_sequence, self._CREATE_LIMIT):
+            body = {"items": [chunk_item.as_write().dump() for chunk_item in chunk]}
+            response = self._put(
+                url_path=self._RESOURCE_PATH,
+                json=body,
+            )
+            result.extend([Chart._load(item, cognite_client=self._cognite_client) for item in response.json()["items"]])
+
+        if not result:
+            raise ValueError("No charts were upserted. This may indicate an issue with the upsert endpoint.")
+
+        if isinstance(items, ChartWrite):
+            if len(result) != 1:
+                raise ValueError(
+                    "Expected a single chart to be returned, but multiple charts were returned. "
+                    "This may indicate an issue with the upsert operation."
+                )
+            return result[0]
+        elif len(result) != len(items):
+            raise ValueError(
+                "The number of upserted charts does not match the number of input charts. "
+                "This may indicate an issue with the upsert endpoint."
+            )
+        return result
+
+    @overload
+    def retrieve(self, external_id: str) -> Chart: ...
+
+    @overload
+    def retrieve(self, external_id: SequenceNotStr[str]) -> ChartList: ...
+
+    def retrieve(self, external_id: str | SequenceNotStr[str]) -> Chart | ChartList:
+        """Retrieve one or more charts by their external ID.
+
+        Args:
+            external_id (str | Sequence[str]): External ID(s) of the chart(s) to retrieve.
+
+        Returns:
+            Chart | ChartList: A single Chart if a single external ID is provided, otherwise a ChartList.
+        """
+        return self._retrieve_multiple(
+            list_cls=ChartList, resource_cls=Chart, identifiers=IdentifierSequence.load(external_ids=external_id)
+        )
+
+    def delete(self, external_id: str | SequenceNotStr[str]) -> None:
+        """Delete one or more charts by their external ID.
+
+        Args:
+            external_id (str | Sequence[str]): External ID(s) of the chart(s) to delete.
+        """
+        self._delete_multiple(
+            identifiers=IdentifierSequence.load(external_ids=external_id),
+            wrap_ids=True,
+        )
+
+    def list(self, visibility: Visibility | None = None, is_owned: bool | None = None) -> ChartList:
+        """List charts based on visibility and ownership.
+
+        Args:
+            visibility (Visibility): Visibility of the charts to list, either 'PUBLIC' or 'PRIVATE'.
+            is_owned (bool): Whether to list only owned charts.
+
+        Returns:
+            ChartList: List of charts matching the criteria.
+        """
+        filter_: dict[str, str | bool] = {}
+        if visibility is not None:
+            filter_["visibility"] = visibility.upper()
+        if is_owned is not None:
+            filter_["isOwned"] = is_owned
+
+        response = self._post(
+            url_path=self._RESOURCE_PATH + "/list",
+            json={"filter": filter_} if filter_ else {},
+        )
+        return ChartList._load(response.json()["items"], cognite_client=self._cognite_client)

cognite_toolkit/_cdf_tk/client/api/extended_data_modeling.py

@@ -13,7 +13,6 @@ from cognite.client.data_classes.data_modeling import EdgeId, InstanceApply, Nod
 from cognite.client.exceptions import CogniteConnectionError, CogniteReadTimeout
 from cognite.client.utils import _json
 from cognite.client.utils._concurrency import execute_tasks
-from cognite.client.utils._identifier import InstanceId
 from requests import Response
 
 from cognite_toolkit._cdf_tk.client._constants import DATA_MODELING_MAX_DELETE_WORKERS, DATA_MODELING_MAX_WRITE_WORKERS
@@ -107,15 +106,9 @@ class ExtendedInstancesAPI(InstancesAPI):
             else:
                 return el
 
-        def str_format_element(el: T) -> str | T:
-            if isinstance(el, InstanceApply):
-                return f"{el.space}:{el.external_id}"
-            return el
-
         summary.raise_compound_exception_if_failed_tasks(
             task_unwrap_fn=lambda task: task[1]["items"],
             task_list_element_unwrap_fn=unwrap_element,
-            str_format_element_fn=str_format_element,
         )
         created_resources = summary.joined_results(lambda res: res.json()["items"])
 
@@ -162,15 +155,9 @@ class ExtendedInstancesAPI(InstancesAPI):
             else:
                 return el
 
-        def str_format_element(el: T) -> str | T:
-            if isinstance(el, InstanceId):
-                return f"{el.space}:{el.external_id}"
-            return el
-
         summary.raise_compound_exception_if_failed_tasks(
             task_unwrap_fn=lambda task: task[1]["items"],
             task_list_element_unwrap_fn=unwrap_element,
-            str_format_element_fn=str_format_element,
         )
         deleted_resources = summary.joined_results(lambda res: res.json()["items"])
         result: list[NodeId | EdgeId] = []

cognite_toolkit/_cdf_tk/client/api/extended_files.py

@@ -53,9 +53,9 @@ class ExtendedFileMetadataAPI(FilesAPI):
             and isinstance(instance_id[0], str)
             and isinstance(instance_id[1], str)
         ):
-            return self._set_pending_ids([PendingInstanceId(NodeId.load(instance_id), id=id, external_id=external_id)])[
+            return self._set_pending_ids([PendingInstanceId(NodeId.load(instance_id), id=id, external_id=external_id)])[  # type: ignore[return-value]
                 0
-            ]  # type: ignore[return-value, arg-type]
+            ]
         elif isinstance(instance_id, Sequence) and all(isinstance(item, PendingInstanceId) for item in instance_id):
             return self._set_pending_ids(instance_id)  # type: ignore[arg-type]
         else:
@@ -159,3 +159,69 @@ class ExtendedFileMetadataAPI(FilesAPI):
             ignore_unknown_ids=ignore_unknown_ids,
             api_subversion="alpha",
         )
+
+    @overload
+    def unlink_instance_ids(
+        self,
+        id: int | None = None,
+        external_id: str | None = None,
+    ) -> ExtendedFileMetadata | None: ...
+
+    @overload
+    def unlink_instance_ids(
+        self,
+        id: Sequence[int] | None = None,
+        external_id: SequenceNotStr[str] | None = None,
+    ) -> ExtendedFileMetadataList: ...
+
+    def unlink_instance_ids(
+        self,
+        id: int | Sequence[int] | None = None,
+        external_id: str | SequenceNotStr[str] | None = None,
+    ) -> ExtendedFileMetadata | ExtendedFileMetadataList | None:
+        """Unlink instance IDs from files.
+
+        This allows a CogniteFile node in Data Modeling to be deleted without deleting the underlying file content.
+
+        Args:
+            id (int | Sequence[int] | None): The ID(s) of the files.
+            external_id (str | SequenceNotStr[str] | None): The external ID(s) of the files.
+
+        Returns:
+            ExtendedFileMetadata | ExtendedFileMetadataList | None: The updated file metadata object(s). For single item requests, returns `None` if the file is not found.
+        """
+        if id is None and external_id is None:
+            raise ValueError("At least one of id or external_id must be provided.")
+        if isinstance(id, int) and isinstance(external_id, str):
+            raise ValueError("Cannot specify both id and external_id as single values. Use one or the other.")
+        is_list = isinstance(id, Sequence) or (isinstance(external_id, Sequence) and not isinstance(external_id, str))
+        identifiers = IdentifierSequence.load(id, external_id)
+
+        tasks = [
+            {
+                "url_path": f"{self._RESOURCE_PATH}/unlink-instance-ids",
+                "json": {"items": id_chunk},
+                "api_subversion": "alpha",
+            }
+            for id_chunk in split_into_chunks(identifiers.as_dicts(), 1000)
+        ]
+        tasks_summary = execute_tasks(
+            self._post,
+            tasks,
+            max_workers=self._config.max_workers,
+            fail_fast=True,
+        )
+        tasks_summary.raise_compound_exception_if_failed_tasks(
+            task_unwrap_fn=unpack_items_in_payload,
+        )
+
+        retrieved_items = tasks_summary.joined_results(lambda res: res.json()["items"])
+
+        result = ExtendedFileMetadataList._load(retrieved_items, cognite_client=self._cognite_client)
+        if is_list:
+            return result
+        if len(result) == 0:
+            return None
+        if len(result) > 1:
+            raise ValueError("Expected a single file, but multiple were returned.")
+        return result[0]  # type: ignore[return-value]

cognite_toolkit/_cdf_tk/client/api/extended_functions.py

@@ -0,0 +1,80 @@
+from cognite.client import CogniteClient
+from cognite.client._api.functions import FunctionsAPI
+from cognite.client.config import global_config
+from cognite.client.data_classes import Function, FunctionWrite
+from cognite.client.utils.useful_types import SequenceNotStr
+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, RequestMessage2
+from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
+
+
+class ExtendedFunctionsAPI(FunctionsAPI):
+    def __init__(
+        self,
+        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, console=console)
+
+    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
+        due to a full queue on the server side.
+
+        Args:
+            function (FunctionWrite): The function to create.
+
+        Returns:
+            Function: The created function object.
+        """
+        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)]},
+            )
+        )
+        success = result.get_success_or_raise()
+        # We assume the API response is one item on a successful creation
+        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) -> 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.
+
+
+        Args:
+            external_id (SequenceNotStr[str]): The external IDs of the functions to delete.
+            ignore_unknown_ids (bool): Ignore IDs and external IDs that are not found.
+            console (Console | None): The rich console to use for printing warnings.
+
+        Returns:
+            None
+        """
+        for chunk in chunker(external_id, self._DELETE_LIMIT):
+            body_content: dict[str, JsonVal] = {
+                "items": [{"externalId": eid} for eid in chunk],
+            }
+            if ignore_unknown_ids:
+                body_content["ignoreUnknownIds"] = True
+            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,
+                )
+            )
+            result.get_success_or_raise()
+        return None

cognite_toolkit/_cdf_tk/client/api/extended_timeseries.py

@@ -156,7 +156,7 @@ class ExtendedTimeSeriesAPI(TimeSeriesAPI):
             if len(result) > 1:
                 raise ValueError("Expected a single time series, but multiple were returned.")
             return cast(ExtendedTimeSeries, result[0])
-        return cast(ExtendedTimeSeriesList, result)
+        return result
 
     def retrieve(
         self, id: int | None = None, external_id: str | None = None, instance_id: NodeId | None = None

cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -0,0 +1,254 @@
+from collections.abc import Sequence
+from typing import Any, cast
+
+from pydantic import TypeAdapter
+from rich.console import Console
+
+from cognite_toolkit._cdf_tk.client.data_classes.api_classes import PagedResponse, QueryResponse
+from cognite_toolkit._cdf_tk.client.data_classes.infield import (
+    DataExplorationConfig,
+    InFieldCDMLocationConfig,
+    InfieldLocationConfig,
+)
+from cognite_toolkit._cdf_tk.client.data_classes.instance_api import (
+    InstanceResponseItem,
+    InstanceResult,
+    NodeIdentifier,
+)
+from cognite_toolkit._cdf_tk.tk_warnings import HighSeverityWarning
+from cognite_toolkit._cdf_tk.utils.http_client import (
+    HTTPClient,
+    ItemsRequest,
+    ItemsRequest2,
+    RequestMessage2,
+)
+
+
+class InfieldConfigAPI:
+    ENDPOINT = "/models/instances"
+    LOCATION_REF = "locationConfig"
+    EXPLORATION_REF = "explorerConfig"
+    # We know that this key exists and it has alias set.
+    DATA_EXPLORATION_PROP_ID = cast(str, InfieldLocationConfig.model_fields["data_exploration_config"].alias)
+
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self._console = console
+        self._config = http_client.config
+
+    def apply(self, items: Sequence[InfieldLocationConfig]) -> list[InstanceResult]:
+        if len(items) > 500:
+            raise ValueError("Cannot apply more than 500 InfieldLocationConfig items at once.")
+
+        request_items = (
+            [item.as_request_item()]
+            if item.data_exploration_config is None
+            else [item.as_request_item(), item.data_exploration_config.as_request_item()]
+            for item in items
+        )
+        responses = self._http_client.request_items_retries(
+            ItemsRequest2(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=[item for sublist in request_items for item in sublist],
+            )
+        )
+        responses.raise_for_status()
+        return TypeAdapter(list[InstanceResult]).validate_python(responses.get_items())
+
+    def retrieve(self, items: Sequence[NodeIdentifier]) -> list[InfieldLocationConfig]:
+        if len(items) > 100:
+            raise ValueError("Cannot retrieve more than 100 InfieldLocationConfig items at once.")
+        if not items:
+            return []
+        response = self._http_client.request_single_retries(
+            RequestMessage2(
+                # We use the query endpoint to be able to retrieve linked DataExplorationConfig items
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
+                method="POST",
+                body_content=self._retrieve_query(items),
+            )
+        )
+        success = response.get_success_or_raise()
+        parsed_response = QueryResponse[InstanceResponseItem].model_validate(success.body_json)
+        return self._parse_retrieve_response(parsed_response)
+
+    def delete(self, items: Sequence[InfieldLocationConfig]) -> list[NodeIdentifier]:
+        if len(items) > 500:
+            raise ValueError("Cannot delete more than 500 InfieldLocationConfig items at once.")
+
+        identifiers = (
+            [item.as_id()]
+            if item.data_exploration_config is None
+            else [item.as_id(), item.data_exploration_config.as_id()]
+            for item in items
+        )
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
+                method="POST",
+                items=[identifier for sublist in identifiers for identifier in sublist],
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[NodeIdentifier].model_validate(responses.get_first_body()).items
+
+    @classmethod
+    def _retrieve_query(cls, items: Sequence[NodeIdentifier]) -> dict[str, Any]:
+        return {
+            "with": {
+                cls.LOCATION_REF: {
+                    "limit": len(items),
+                    "nodes": {
+                        "filter": {
+                            "instanceReferences": [
+                                {"space": item.space, "externalId": item.external_id} for item in items
+                            ]
+                        },
+                    },
+                },
+                cls.EXPLORATION_REF: {
+                    "nodes": {
+                        "from": "locationConfig",
+                        "direction": "outwards",
+                        "through": {
+                            "source": InfieldLocationConfig.VIEW_ID.dump(),
+                            "identifier": cls.DATA_EXPLORATION_PROP_ID,
+                        },
+                    }
+                },
+            },
+            "select": {
+                cls.LOCATION_REF: {
+                    "sources": [{"source": InfieldLocationConfig.VIEW_ID.dump(), "properties": ["*"]}],
+                },
+                cls.EXPLORATION_REF: {
+                    "sources": [{"source": DataExplorationConfig.VIEW_ID.dump(), "properties": ["*"]}],
+                },
+            },
+        }
+
+    def _parse_retrieve_response(
+        self, parsed_response: QueryResponse[InstanceResponseItem]
+    ) -> list[InfieldLocationConfig]:
+        data_exploration_results = (
+            DataExplorationConfig.model_validate(
+                item.get_properties_for_source(DataExplorationConfig.VIEW_ID, include_identifier=True)
+            )
+            for item in parsed_response.items[self.EXPLORATION_REF]
+        )
+        data_exploration_config_map = {(dec.space, dec.external_id): dec for dec in data_exploration_results}
+        result: list[InfieldLocationConfig] = []
+        for item in parsed_response.items[self.LOCATION_REF]:
+            properties = item.get_properties_for_source(InfieldLocationConfig.VIEW_ID, include_identifier=True)
+            data_exploration = properties.pop(self.DATA_EXPLORATION_PROP_ID, None)
+            if isinstance(data_exploration, dict):
+                space = data_exploration["space"]
+                external_id = data_exploration["externalId"]
+                if (space, external_id) not in data_exploration_config_map:
+                    HighSeverityWarning(
+                        f"{self.DATA_EXPLORATION_PROP_ID} with space '{space}' and externalId '{external_id}' referenced in InfieldLocationConfig '{properties['externalId']}' was not found in the retrieved results."
+                    ).print_warning(console=self._console)
+                else:
+                    # Pydantic allow already validated models to be assigned to fields
+                    properties[self.DATA_EXPLORATION_PROP_ID] = data_exploration_config_map[(space, external_id)]  # type: ignore[assignment,index]
+            else:
+                HighSeverityWarning(
+                    f"InfieldLocationConfig '{properties['externalId']}' is missing a valid {self.DATA_EXPLORATION_PROP_ID} reference."
+                ).print_warning(console=self._console)
+            result.append(InfieldLocationConfig.model_validate(properties))
+        return result
+
+
+class InFieldCDMConfigAPI:
+    ENDPOINT = "/models/instances"
+    LOCATION_REF = "cdmLocationConfig"
+
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self._console = console
+        self._config = http_client.config
+
+    def apply(self, items: Sequence[InFieldCDMLocationConfig]) -> list[InstanceResult]:
+        if len(items) > 500:
+            raise ValueError("Cannot apply more than 500 InFieldCDMLocationConfig items at once.")
+
+        request_items = [item.as_request_item() for item in items]
+        results = self._http_client.request_items_retries(
+            ItemsRequest2(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=request_items,
+            )
+        )
+        results.raise_for_status()
+        return TypeAdapter(list[InstanceResult]).validate_python(results.get_items())
+
+    def retrieve(self, items: Sequence[NodeIdentifier]) -> list[InFieldCDMLocationConfig]:
+        if len(items) > 100:
+            raise ValueError("Cannot retrieve more than 100 InFieldCDMLocationConfig items at once.")
+        if not items:
+            return []
+        result = self._http_client.request_single_retries(
+            RequestMessage2(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
+                method="POST",
+                body_content=self._retrieve_query(items),
+            )
+        )
+        success = result.get_success_or_raise()
+        parsed_response = QueryResponse[InstanceResponseItem].model_validate(success.body_json)
+        return self._parse_retrieve_response(parsed_response)
+
+    def delete(self, items: Sequence[InFieldCDMLocationConfig]) -> list[NodeIdentifier]:
+        if len(items) > 500:
+            raise ValueError("Cannot delete more than 500 InFieldCDMLocationConfig items at once.")
+
+        identifiers: Sequence = [item.as_id() for item in items]
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/delete"),
+                method="POST",
+                items=identifiers,  # type: ignore[arg-type]
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[NodeIdentifier].model_validate(responses.get_first_body()).items
+
+    @classmethod
+    def _retrieve_query(cls, items: Sequence[NodeIdentifier]) -> dict[str, Any]:
+        return {
+            "with": {
+                cls.LOCATION_REF: {
+                    "limit": len(items),
+                    "nodes": {
+                        "filter": {
+                            "instanceReferences": [
+                                {"space": item.space, "externalId": item.external_id} for item in items
+                            ]
+                        },
+                    },
+                },
+            },
+            "select": {
+                cls.LOCATION_REF: {
+                    "sources": [{"source": InFieldCDMLocationConfig.VIEW_ID.dump(), "properties": ["*"]}],
+                },
+            },
+        }
+
+    def _parse_retrieve_response(
+        self, parsed_response: QueryResponse[InstanceResponseItem]
+    ) -> list[InFieldCDMLocationConfig]:
+        result: list[InFieldCDMLocationConfig] = []
+        for item in parsed_response.items[self.LOCATION_REF]:
+            properties = item.get_properties_for_source(InFieldCDMLocationConfig.VIEW_ID, include_identifier=True)
+            result.append(InFieldCDMLocationConfig.model_validate(properties))
+        return result
+
+
+class InfieldAPI:
+    def __init__(self, http_client: HTTPClient, console: Console) -> None:
+        self._http_client = http_client
+        self.config = InfieldConfigAPI(http_client, console)
+        self.cdm_config = InFieldCDMConfigAPI(http_client, console)

cognite_toolkit/_cdf_tk/client/api/location_filters.py

@@ -1,9 +1,10 @@
-from collections.abc import Iterator
+from collections.abc import Iterator, Sequence
 from typing import overload
 
 from cognite.client import CogniteClient
 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 (
     LocationFilter,
@@ -92,3 +93,20 @@ class LocationFiltersAPI(APIClient):
     def list(self) -> LocationFilterList:
         res = self._post(url_path=self._RESOURCE_PATH + "/list", json={"flat": True})
         return LocationFilterList._load(res.json()["items"], cognite_client=self._cognite_client)
+
+    def retrieve_multiple(self, ids: Sequence[int]) -> LocationFilterList:
+        """Retrieve multiple LocationFilters using their IDs.
+
+        Args:
+            ids: The IDs of the LocationFilters
+
+        Returns:
+            LocationFilterList
+        """
+        identifiers = IdentifierSequence.load(ids=ids)
+        return self._retrieve_multiple(
+            identifiers=identifiers,
+            resource_cls=LocationFilter,
+            list_cls=LocationFilterList,
+            resource_path=self._RESOURCE_PATH,
+        )