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

cognite_toolkit/_cdf_tk/{loaders/_resource_loaders/classic_loaders.py → cruds/_resource_cruds/classic.py}

@@ -1,63 +1,78 @@
 import collections.abc
 import io
-from collections.abc import Hashable, Iterable
-from functools import lru_cache
+from collections.abc import Hashable, Iterable, Sequence
 from pathlib import Path
 from typing import Any, final
 
 import pandas as pd
 from cognite.client.data_classes import (
+    AggregateResultItem,
     Asset,
     AssetList,
     AssetWrite,
-    AssetWriteList,
     Event,
     EventList,
     EventWrite,
-    EventWriteList,
-    Sequence,
     SequenceList,
     SequenceWrite,
-    SequenceWriteList,
     capabilities,
 )
+from cognite.client.data_classes import Sequence as CDFSequence
 from cognite.client.data_classes.capabilities import Capability
 from cognite.client.exceptions import CogniteAPIError, CogniteNotFoundError
 from cognite.client.utils.useful_types import SequenceNotStr
 from rich.console import Console
 
-from cognite_toolkit._cdf_tk._parameters import ANY_INT, ParameterSpec, ParameterSpecSet
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.sequences import (
     ToolkitSequenceRows,
     ToolkitSequenceRowsList,
     ToolkitSequenceRowsWrite,
-    ToolkitSequenceRowsWriteList,
 )
-from cognite_toolkit._cdf_tk.loaders._base_loaders import ResourceLoader
-from cognite_toolkit._cdf_tk.resource_classes import AssetYAML, EventYAML
-from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning
+from cognite_toolkit._cdf_tk.constants import TABLE_FORMATS, YAML_SUFFIX
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
+from cognite_toolkit._cdf_tk.feature_flags import Flags
+from cognite_toolkit._cdf_tk.resource_classes import AssetYAML, EventYAML, SequenceRowYAML, SequenceYAML
+from cognite_toolkit._cdf_tk.tk_warnings import LowSeverityWarning, ToolkitDeprecationWarning
 from cognite_toolkit._cdf_tk.utils import load_yaml_inject_variables
 from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_hashable, diff_list_identifiable
 from cognite_toolkit._cdf_tk.utils.file import read_csv
 
-from .data_organization_loaders import DataSetsLoader, LabelLoader
+from .data_organization import DataSetsCRUD, LabelCRUD
+
+_DEPRECATION_WARNING_ISSUED = False
 
 
 @final
-class AssetLoader(ResourceLoader[str, AssetWrite, Asset, AssetWriteList, AssetList]):
+class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset]):
     folder_name = "classic"
-    filename_pattern = r"^.*\.Asset$"  # Matches all yaml files whose stem ends with '.Asset'.
-    filetypes = frozenset({"yaml", "yml", "csv", "parquet"})
     resource_cls = Asset
     resource_write_cls = AssetWrite
-    list_cls = AssetList
-    list_write_cls = AssetWriteList
     yaml_cls = AssetYAML
     kind = "Asset"
-    dependencies = frozenset({DataSetsLoader, LabelLoader})
+    dependencies = frozenset({DataSetsCRUD, LabelCRUD})
     _doc_url = "Assets/operation/createAssets"
 
+    @classmethod
+    def is_supported_file(cls, file: Path) -> bool:
+        if Flags.v08.is_enabled():
+            return super().is_supported_file(file)
+        global _DEPRECATION_WARNING_ISSUED
+        if not file.stem.casefold().endswith(cls.kind.casefold()):
+            return False
+        if file.suffix in YAML_SUFFIX:
+            return True
+        if file.suffix in TABLE_FORMATS:
+            if not _DEPRECATION_WARNING_ISSUED:
+                ToolkitDeprecationWarning(
+                    feature="deployment of asset from CSV or Parquet files",
+                    alternative="data plugin and cdf data upload commands",
+                    removal_version="0.8",
+                ).print_warning()
+                _DEPRECATION_WARNING_ISSUED = True
+            return True
+        return False
+
     @property
     def display_name(self) -> str:
         return "assets"
@@ -102,18 +117,15 @@ class AssetLoader(ResourceLoader[str, AssetWrite, Asset, AssetWriteList, AssetLi
             if data_set_ids := {item.data_set_id for item in items if item.data_set_id}:
                 scope = capabilities.AssetsAcl.Scope.DataSet(list(data_set_ids))
 
-        return capabilities.AssetsAcl(
-            actions,
-            scope,  # type: ignore[arg-type]
-        )
+        return capabilities.AssetsAcl(actions, scope)
 
-    def create(self, items: AssetWriteList) -> AssetList:
+    def create(self, items: Sequence[AssetWrite]) -> AssetList:
         return self.client.assets.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> AssetList:
         return self.client.assets.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: AssetWriteList) -> AssetList:
+    def update(self, items: Sequence[AssetWrite]) -> AssetList:
         return self.client.assets.update(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str | int]) -> int:
@@ -148,36 +160,19 @@ class AssetLoader(ResourceLoader[str, AssetWrite, Asset, AssetWriteList, AssetLi
         )
 
     @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.discard(ParameterSpec(("dataSetId",), frozenset({"int"}), is_required=False, _is_nullable=False))
-
-        # Failed to be inferred from the AssetWrite.__init__ method.
-        spec.add(
-            ParameterSpec(("labels", ANY_INT, "externalId"), frozenset({"str"}), is_required=True, _is_nullable=True)
-        )
-
-        # Should not be used, used for parentExternalId instead
-        spec.discard(ParameterSpec(("parentId",), 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"]
         for label in item.get("labels", []):
             if isinstance(label, dict):
-                yield LabelLoader, label["externalId"]
+                yield LabelCRUD, label["externalId"]
             elif isinstance(label, str):
-                yield LabelLoader, label
+                yield LabelCRUD, label
         if "parentExternalId" in item:
             yield cls, item["parentExternalId"]
 
@@ -235,19 +230,31 @@ class AssetLoader(ResourceLoader[str, AssetWrite, Asset, AssetWriteList, AssetLi
             dumped.pop("metadata", None)
         if "parentId" in dumped and "parentId" not in local:
             dumped.pop("parentId")
+        if resource.aggregates:
+            # This is only included when the asset is downloaded/migrated with aggregated properties
+            aggregates = (
+                resource.aggregates.dump()
+                if isinstance(resource.aggregates, AggregateResultItem)
+                else resource.aggregates
+            )
+            if "path" in aggregates:
+                path = aggregates.pop("path", [])
+                if path:
+                    aggregates["path"] = self.client.lookup.assets.external_id(
+                        [segment["id"] for segment in path if "id" in segment]
+                    )
+            dumped.update(aggregates)
         return dumped
 
 
 @final
-class SequenceLoader(ResourceLoader[str, SequenceWrite, Sequence, SequenceWriteList, SequenceList]):
+class SequenceCRUD(ResourceCRUD[str, SequenceWrite, CDFSequence]):
     folder_name = "classic"
-    filename_pattern = r"^.*\.Sequence$"
-    resource_cls = Sequence
+    resource_cls = CDFSequence
     resource_write_cls = SequenceWrite
-    list_cls = SequenceList
-    list_write_cls = SequenceWriteList
     kind = "Sequence"
-    dependencies = frozenset({DataSetsLoader, AssetLoader})
+    dependencies = frozenset({DataSetsCRUD, AssetCRUD})
+    yaml_cls = SequenceYAML
     _doc_url = "Sequences/operation/createSequence"
 
     @property
@@ -255,7 +262,7 @@ class SequenceLoader(ResourceLoader[str, SequenceWrite, Sequence, SequenceWriteL
         return "sequences"
 
     @classmethod
-    def get_id(cls, item: Sequence | SequenceWrite | dict) -> str:
+    def get_id(cls, item: CDFSequence | SequenceWrite | dict) -> str:
         if isinstance(item, dict):
             return item["externalId"]
         if not item.external_id:
@@ -263,7 +270,7 @@ class SequenceLoader(ResourceLoader[str, SequenceWrite, Sequence, SequenceWriteL
         return item.external_id
 
     @classmethod
-    def get_internal_id(cls, item: Sequence | dict) -> int:
+    def get_internal_id(cls, item: CDFSequence | dict) -> int:
         if isinstance(item, dict):
             return item["id"]
         if not item.id:
@@ -276,7 +283,7 @@ class SequenceLoader(ResourceLoader[str, SequenceWrite, Sequence, SequenceWriteL
 
     @classmethod
     def get_required_capability(
-        cls, items: collections.abc.Sequence[SequenceWrite] | None, read_only: bool
+        cls, items: Sequence[SequenceWrite] | None, read_only: bool
     ) -> Capability | list[Capability]:
         if not items and items is not None:
             return []
@@ -291,10 +298,7 @@ class SequenceLoader(ResourceLoader[str, SequenceWrite, Sequence, SequenceWriteL
             else [capabilities.SequencesAcl.Action.Read, capabilities.SequencesAcl.Action.Write]
         )
 
-        return capabilities.SequencesAcl(
-            actions,
-            scope,  # type: ignore[arg-type]
-        )
+        return capabilities.SequencesAcl(actions, scope)
 
     def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> SequenceWrite:
         if ds_external_id := resource.pop("dataSetExternalId", None):
@@ -303,7 +307,7 @@ class SequenceLoader(ResourceLoader[str, SequenceWrite, Sequence, SequenceWriteL
             resource["assetId"] = self.client.lookup.assets.id(asset_external_id, is_dry_run)
         return SequenceWrite._load(resource)
 
-    def dump_resource(self, resource: Sequence, local: dict[str, Any] | None = None) -> dict[str, Any]:
+    def dump_resource(self, resource: CDFSequence, local: dict[str, Any] | None = None) -> dict[str, Any]:
         dumped = resource.as_write().dump()
         local = local or {}
         if data_set_id := dumped.pop("dataSetId", None):
@@ -331,13 +335,13 @@ class SequenceLoader(ResourceLoader[str, SequenceWrite, Sequence, SequenceWriteL
             return super().diff_list(local, cdf, json_path)
         return diff_list_identifiable(local, cdf, get_identifier=lambda col: col["externalId"])
 
-    def create(self, items: SequenceWriteList) -> SequenceList:
+    def create(self, items: Sequence[SequenceWrite]) -> SequenceList:
         return self.client.sequences.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> SequenceList:
         return self.client.sequences.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: SequenceWriteList) -> SequenceList:
+    def update(self, items: Sequence[SequenceWrite]) -> SequenceList:
         return self.client.sequences.upsert(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str | int]) -> int:
@@ -358,46 +362,29 @@ class SequenceLoader(ResourceLoader[str, SequenceWrite, Sequence, SequenceWriteL
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[Sequence]:
+    ) -> Iterable[CDFSequence]:
         return iter(
             self.client.sequences(data_set_external_ids=[data_set_external_id] if data_set_external_id else None)
         )
 
     @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.discard(ParameterSpec(("dataSetId",), frozenset({"int"}), is_required=False, _is_nullable=False))
-        spec.add(ParameterSpec(("assetExternalId",), frozenset({"int"}), is_required=False, _is_nullable=False))
-        spec.discard(ParameterSpec(("assetId",), 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]]:
         if "dataSetExternalId" in item:
-            yield DataSetsLoader, item["dataSetExternalId"]
+            yield DataSetsCRUD, item["dataSetExternalId"]
         if "assetExternalId" in item:
-            yield AssetLoader, item["assetExternalId"]
+            yield AssetCRUD, item["assetExternalId"]
 
 
 @final
-class SequenceRowLoader(
-    ResourceLoader[
-        str, ToolkitSequenceRowsWrite, ToolkitSequenceRows, ToolkitSequenceRowsWriteList, ToolkitSequenceRowsList
-    ]
-):
+class SequenceRowCRUD(ResourceCRUD[str, ToolkitSequenceRowsWrite, ToolkitSequenceRows]):
     folder_name = "classic"
-    filename_pattern = r"^.*\.SequenceRow$"
     resource_cls = ToolkitSequenceRows
     resource_write_cls = ToolkitSequenceRowsWrite
-    list_cls = ToolkitSequenceRowsList
-    list_write_cls = ToolkitSequenceRowsWriteList
     kind = "SequenceRow"
-    dependencies = frozenset({SequenceLoader})
-    parent_resource = frozenset({SequenceLoader})
+    dependencies = frozenset({SequenceCRUD})
+    parent_resource = frozenset({SequenceCRUD})
     _doc_url = "Sequences/operation/postSequenceData"
+    yaml_cls = SequenceRowYAML
     support_update = False
 
     def __init__(self, client: ToolkitClient, build_dir: Path | None, console: Console | None):
@@ -437,8 +424,7 @@ class SequenceRowLoader(
         # We don't have any capabilities for SequenceRows, that is already handled by the Sequence
         return []
 
-    def create(self, items: ToolkitSequenceRowsWriteList) -> ToolkitSequenceRowsWriteList:
-        item: ToolkitSequenceRowsWrite
+    def create(self, items: Sequence[ToolkitSequenceRowsWrite]) -> Sequence[ToolkitSequenceRowsWrite]:
         for item in items:
             self.client.sequences.rows.insert(item.as_sequence_rows(), external_id=item.external_id)
         return items
@@ -474,13 +460,13 @@ class SequenceRowLoader(
                     yield ToolkitSequenceRows._load(res.dump(camel_case=True))
 
     @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.
         """
-        yield SequenceLoader, item["externalId"]
+        yield SequenceCRUD, item["externalId"]
 
     def dump_resource(self, resource: ToolkitSequenceRows, local: dict[str, Any] | None = None) -> dict[str, Any]:
         dumped = resource.as_write().dump()
@@ -514,17 +500,13 @@ class SequenceRowLoader(
 
 
 @final
-class EventLoader(ResourceLoader[str, EventWrite, Event, EventWriteList, EventList]):
+class EventCRUD(ResourceCRUD[str, EventWrite, Event]):
     folder_name = "classic"
-    filename_pattern = r"^.*\.Event$"  # Matches all yaml files whose stem ends with '.Event'.
-    filetypes = frozenset({"yaml", "yml"})
     resource_cls = Event
     resource_write_cls = EventWrite
-    list_cls = EventList
-    list_write_cls = EventWriteList
     yaml_cls = EventYAML
     kind = "Event"
-    dependencies = frozenset({DataSetsLoader, AssetLoader})
+    dependencies = frozenset({DataSetsCRUD, AssetCRUD})
     _doc_url = "Events/operation/createEvents"
 
     @property
@@ -571,18 +553,15 @@ class EventLoader(ResourceLoader[str, EventWrite, Event, EventWriteList, EventLi
             if data_set_ids := {item.data_set_id for item in items if item.data_set_id}:
                 scope = capabilities.EventsAcl.Scope.DataSet(list(data_set_ids))
 
-        return capabilities.EventsAcl(
-            actions,
-            scope,  # type: ignore[arg-type]
-        )
+        return capabilities.EventsAcl(actions, scope)
 
-    def create(self, items: EventWriteList) -> EventList:
+    def create(self, items: Sequence[EventWrite]) -> EventList:
         return self.client.events.create(items)
 
     def retrieve(self, ids: SequenceNotStr[str]) -> EventList:
         return self.client.events.retrieve_multiple(external_ids=ids, ignore_unknown_ids=True)
 
-    def update(self, items: EventWriteList) -> EventList:
+    def update(self, items: Sequence[EventWrite]) -> EventList:
         return self.client.events.update(items, mode="replace")
 
     def delete(self, ids: SequenceNotStr[str | int]) -> int:
@@ -607,33 +586,17 @@ class EventLoader(ResourceLoader[str, EventWrite, Event, EventWriteList, EventLi
         return iter(self.client.events(data_set_external_ids=[data_set_external_id] if data_set_external_id else None))
 
     @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.discard(ParameterSpec(("dataSetId",), frozenset({"int"}), is_required=False, _is_nullable=False))
-
-        spec.add(ParameterSpec(("assetExternalIds",), frozenset({"list"}), is_required=False, _is_nullable=False))
-        spec.add(
-            ParameterSpec(("assetExternalIds", ANY_INT), frozenset({"str"}), is_required=False, _is_nullable=False)
-        )
-        spec.discard(ParameterSpec(("assetIds",), frozenset({"int"}), is_required=False, _is_nullable=False))
-        spec.discard(ParameterSpec(("assetIds", ANY_INT), 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"]
         for asset_id in item.get("assetExternalIds", []):
             if isinstance(asset_id, str):
-                yield AssetLoader, asset_id
+                yield AssetCRUD, asset_id
 
     def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> EventWrite:
         if ds_external_id := resource.get("dataSetExternalId", None):

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/configuration.py

@@ -0,0 +1,149 @@
+from collections.abc import Hashable, Iterable, Sequence
+from pathlib import Path
+from typing import Any, final
+
+from cognite.client.data_classes.capabilities import AppConfigAcl, Capability
+from cognite.client.utils.useful_types import SequenceNotStr
+from rich.console import Console
+
+from cognite_toolkit._cdf_tk.client import ToolkitClient
+from cognite_toolkit._cdf_tk.client.data_classes.search_config import (
+    SearchConfig,
+    SearchConfigList,
+    SearchConfigWrite,
+    ViewId,
+)
+from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
+from cognite_toolkit._cdf_tk.resource_classes import SearchConfigYAML
+from cognite_toolkit._cdf_tk.utils import sanitize_filename
+from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_identifiable, dm_identifier
+
+from .datamodel import ViewCRUD
+
+
+@final
+class SearchConfigCRUD(ResourceCRUD[ViewId, SearchConfigWrite, SearchConfig]):
+    support_drop = False
+    folder_name = "cdf_applications"
+    resource_cls = SearchConfig
+    resource_write_cls = SearchConfigWrite
+    yaml_cls = SearchConfigYAML
+    dependencies = frozenset({ViewCRUD})
+    kind = "SearchConfig"
+    _doc_base_url = "https://api-docs.cogheim.net/redoc/#tag/"
+    _doc_url = "Search-Config/operation/upsertSearchConfigViews"
+
+    def __init__(self, client: ToolkitClient, build_path: Path | None, console: Console | None):
+        super().__init__(client, build_path, console)
+        self._existing_configs_cache: dict[ViewId, int] | None = None
+
+    @property
+    def display_name(self) -> str:
+        return "search config"
+
+    @classmethod
+    def get_required_capability(
+        cls, items: Sequence[SearchConfigWrite] | None, read_only: bool
+    ) -> Capability | list[Capability]:
+        if not items and items is not None:
+            return []
+
+        actions = [AppConfigAcl.Action.Read] if read_only else [AppConfigAcl.Action.Read, AppConfigAcl.Action.Write]
+
+        return AppConfigAcl(
+            actions=actions,
+            scope=AppConfigAcl.Scope.AppConfig(apps=["SEARCH"]),
+            allow_unknown=True,
+        )
+
+    @classmethod
+    def get_id(cls, item: SearchConfig | SearchConfigWrite | dict) -> ViewId:
+        if isinstance(item, dict):
+            return ViewId.load(item.get("view", {}))
+        return item.view
+
+    @classmethod
+    def dump_id(cls, id: ViewId) -> dict[str, Any]:
+        return {"view": id.dump()}
+
+    @classmethod
+    def as_str(cls, id: ViewId) -> str:
+        return sanitize_filename(f"{id.external_id}_{id.space}")
+
+    def dump_resource(self, resource: SearchConfig, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.as_write().dump()
+        local = local or {}
+        dumped.pop("id", None)
+        for key in ["columnsLayout", "filterLayout", "propertiesLayout"]:
+            if not dumped.get(key) and key not in local:
+                dumped.pop(key, None)
+        return dumped
+
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> SearchConfigWrite:
+        loaded = SearchConfigWrite._load(resource)
+
+        if self._existing_configs_cache is None:
+            all_configs = self.client.search.configurations.list()
+            self._existing_configs_cache = {config.view: config.id for config in all_configs if config.id is not None}
+
+        if loaded.view in self._existing_configs_cache:
+            loaded.id = self._existing_configs_cache[loaded.view]
+
+        return loaded
+
+    def diff_list(
+        self, local: list[Any], cdf: list[Any], json_path: tuple[str | int, ...]
+    ) -> tuple[dict[int, int], list[int]]:
+        if json_path in [("columnsLayout",), ("filterLayout",), ("propertiesLayout",)]:
+            return diff_list_identifiable(local, cdf, get_identifier=lambda x: x.get("property"))
+        elif json_path == ("view",):
+            return diff_list_identifiable(local, cdf, get_identifier=dm_identifier)
+        return super().diff_list(local, cdf, json_path)
+
+    def _upsert(self, items: Sequence[SearchConfigWrite]) -> SearchConfigList:
+        """
+        Upsert search configurations using the upsert method
+        """
+        result = SearchConfigList([])
+        for item in items:
+            created = self.client.search.configurations.upsert(item)
+            result.append(created)
+        return result
+
+    def create(self, items: Sequence[SearchConfigWrite]) -> SearchConfigList:
+        """
+        Create new search configurations using the upsert method
+        """
+        return self._upsert(items)
+
+    def retrieve(self, ids: SequenceNotStr[ViewId]) -> SearchConfigList:
+        """Retrieve search configurations by their IDs"""
+        all_configs = self.client.search.configurations.list()
+        # The API does not support server-side filtering, so we filter in memory.
+        return SearchConfigList([config for config in all_configs if config.view in ids])
+
+    def update(self, items: Sequence[SearchConfigWrite]) -> SearchConfigList:
+        """
+        Update search configurations using the upsert method
+        """
+        return self._upsert(items)
+
+    def delete(self, ids: SequenceNotStr[ViewId]) -> int:
+        """
+        Delete is not implemented in the API client
+        """
+        raise NotImplementedError("Delete operation is not supported for search config")
+
+    def _iterate(
+        self,
+        data_set_external_id: str | None = None,
+        space: str | None = None,
+        parent_ids: list[Hashable] | None = None,
+    ) -> Iterable[SearchConfig]:
+        """Iterate through all search configurations"""
+        if space or data_set_external_id or parent_ids:
+            # These filters are not supported for SearchConfig
+            return iter([])
+
+        all_configs = self.client.search.configurations.list()
+        return iter(all_configs)