cognite-toolkit 0.6.90__py3-none-any.whl → 0.6.92__py3-none-any.whl

cognite_toolkit/_cdf_tk/commands/deploy.py

@@ -3,7 +3,6 @@ from graphlib import TopologicalSorter
 from pathlib import Path
 from typing import overload
 
-from cognite.client.data_classes._base import T_CogniteResourceList, T_WritableCogniteResource, T_WriteClass
 from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError
 from cognite.client.utils._identifier import T_ID
 from rich import print
@@ -26,7 +25,6 @@ from cognite_toolkit._cdf_tk.cruds import (
     ResourceCRUD,
     ResourceWorker,
 )
-from cognite_toolkit._cdf_tk.cruds._base_cruds import T_WritableCogniteResourceList
 from cognite_toolkit._cdf_tk.cruds._worker import CategorizedResources
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildEnvironment,
@@ -45,6 +43,12 @@ from cognite_toolkit._cdf_tk.exceptions import (
     ToolkitFileNotFoundError,
     ToolkitNotADirectoryError,
 )
+from cognite_toolkit._cdf_tk.protocols import (
+    T_ResourceRequest,
+    T_ResourceRequestList,
+    T_ResourceResponse,
+    T_ResourceResponseList,
+)
 from cognite_toolkit._cdf_tk.tk_warnings import EnvironmentVariableMissingWarning
 from cognite_toolkit._cdf_tk.tk_warnings.base import WarningList, catch_warnings
 from cognite_toolkit._cdf_tk.tk_warnings.other import (
@@ -324,7 +328,7 @@ class DeployCommand(ToolkitCommand):
     def deploy_resource_type(
         self,
         loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
+            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
         ],
         env_vars: EnvironmentVariables,
         read_modules: list[ReadModule] | None = None,
@@ -387,9 +391,9 @@ class DeployCommand(ToolkitCommand):
 
     def actual_deploy(
         self,
-        resources: CategorizedResources[T_ID, T_CogniteResourceList],
+        resources: CategorizedResources[T_ID, T_ResourceResponseList],
         loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
+            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
         ],
         env_var_warnings: WarningList | None = None,
     ) -> ResourceDeployResult:
@@ -421,9 +425,9 @@ class DeployCommand(ToolkitCommand):
 
     @staticmethod
     def dry_run_deploy(
-        resources: CategorizedResources[T_ID, T_CogniteResourceList],
+        resources: CategorizedResources[T_ID, T_ResourceResponseList],
         loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
+            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
         ],
         has_done_drop: bool,
         has_dropped_data: bool,
@@ -455,7 +459,7 @@ class DeployCommand(ToolkitCommand):
 
     @staticmethod
     def _verbose_print(
-        resources: CategorizedResources[T_ID, T_CogniteResourceList],
+        resources: CategorizedResources[T_ID, T_ResourceResponseList],
         loader: ResourceCRUD,
         dry_run: bool,
     ) -> None:
@@ -479,7 +483,7 @@ class DeployCommand(ToolkitCommand):
 
     def _create_resources(
         self,
-        resources: T_CogniteResourceList,
+        resources: T_ResourceResponseList,
         loader: ResourceCRUD,
         environment_variable_warning_by_id: dict[Hashable, EnvironmentVariableMissingWarning],
     ) -> int:
@@ -502,7 +506,7 @@ class DeployCommand(ToolkitCommand):
 
     def _update_resources(
         self,
-        resources: T_CogniteResourceList,
+        resources: T_ResourceResponseList,
         loader: ResourceCRUD,
         environment_variable_warning_by_id: dict[Hashable, EnvironmentVariableMissingWarning],
     ) -> int:

cognite_toolkit/_cdf_tk/commands/pull.py

@@ -11,7 +11,6 @@ from typing import Any, Union
 
 import questionary
 import yaml
-from cognite.client.data_classes._base import T_CogniteResourceList, T_WritableCogniteResource, T_WriteClass
 from questionary import Choice
 from rich import print
 from rich.markdown import Markdown
@@ -30,7 +29,13 @@ from cognite_toolkit._cdf_tk.cruds import (
     ResourceCRUD,
     StreamlitCRUD,
 )
-from cognite_toolkit._cdf_tk.cruds._base_cruds import T_ID, T_WritableCogniteResourceList
+from cognite_toolkit._cdf_tk.cruds._base_cruds import (
+    T_ID,
+    T_ResourceRequest,
+    T_ResourceRequestList,
+    T_ResourceResponse,
+    T_ResourceResponseList,
+)
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildEnvironment,
     BuildVariable,
@@ -543,14 +548,14 @@ class PullCommand(ToolkitCommand):
     def _pull_resources(
         self,
         loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
+            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
         ],
         resources: BuiltFullResourceList[T_ID],
         dry_run: bool,
         environment_variables: dict[str, str | None],
     ) -> ResourceDeployResult:
         cdf_resources = loader.retrieve(resources.identifiers)
-        cdf_resource_by_id: dict[T_ID, T_WritableCogniteResource] = {loader.get_id(r): r for r in cdf_resources}
+        cdf_resource_by_id: dict[T_ID, T_ResourceResponse] = {loader.get_id(r): r for r in cdf_resources}
 
         resources_by_file = resources.by_file()
         file_results = ResourceDeployResult(loader.display_name)
@@ -574,10 +579,10 @@ class PullCommand(ToolkitCommand):
     def _get_to_write(
         self,
         local_resource_by_id: dict[T_ID, dict[str, Any]],
-        cdf_resource_by_id: dict[T_ID, T_WritableCogniteResource],
+        cdf_resource_by_id: dict[T_ID, T_ResourceResponse],
         file_results: ResourceDeployResult,
         loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
+            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
         ],
     ) -> tuple[bool, dict[T_ID, dict[str, Any]]]:
         to_write: dict[T_ID, dict[str, Any]] = {}
@@ -608,7 +613,7 @@ class PullCommand(ToolkitCommand):
     def _get_local_resource_dict_by_id(
         resources: BuiltFullResourceList[T_ID],
         loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
+            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
         ],
         environment_variables: dict[str, str | None],
     ) -> dict[T_ID, dict[str, Any]]:
@@ -647,7 +652,7 @@ class PullCommand(ToolkitCommand):
         resources: BuiltFullResourceList[T_ID],
         environment_variables: dict[str, str | None],
         loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
+            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
         ],
         source_file: Path,
     ) -> tuple[str, dict[Path, str]]:

cognite_toolkit/_cdf_tk/cruds/__init__.py

@@ -41,6 +41,7 @@ from ._resource_cruds import (
     HostedExtractorJobCRUD,
     HostedExtractorMappingCRUD,
     HostedExtractorSourceCRUD,
+    InFieldLocationConfigCRUD,
     InfieldV1CRUD,
     LabelCRUD,
     LocationFilterCRUD,
@@ -79,6 +80,7 @@ if not FeatureFlag.is_enabled(Flags.AGENTS):
     _EXCLUDED_CRUDS.add(AgentCRUD)
 if not FeatureFlag.is_enabled(Flags.INFIELD):
     _EXCLUDED_CRUDS.add(InfieldV1CRUD)
+    _EXCLUDED_CRUDS.add(InFieldLocationConfigCRUD)
 if not FeatureFlag.is_enabled(Flags.MIGRATE):
     _EXCLUDED_CRUDS.add(ResourceViewMappingCRUD)
 if not FeatureFlag.is_enabled(Flags.SEARCH_CONFIG):
@@ -172,6 +174,7 @@ __all__ = [
     "HostedExtractorJobCRUD",
     "HostedExtractorMappingCRUD",
     "HostedExtractorSourceCRUD",
+    "InFieldLocationConfigCRUD",
     "LabelCRUD",
     "LocationFilterCRUD",
     "NodeCRUD",

cognite_toolkit/_cdf_tk/cruds/_base_cruds.py

@@ -5,21 +5,22 @@ from collections.abc import Hashable, Iterable, Sequence, Set, Sized
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Generic, TypeVar
 
-from cognite.client.data_classes._base import (
-    T_CogniteResourceList,
-    T_WritableCogniteResource,
-    T_WriteClass,
-)
 from cognite.client.data_classes.capabilities import 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.constants import BUILD_FOLDER_ENCODING, EXCL_FILES
+from cognite_toolkit._cdf_tk.protocols import (
+    T_ResourceRequest,
+    T_ResourceRequestList,
+    T_ResourceResponse,
+    T_ResourceResponseList,
+)
 from cognite_toolkit._cdf_tk.resource_classes import ToolkitResource
 from cognite_toolkit._cdf_tk.tk_warnings import ToolkitWarning
 from cognite_toolkit._cdf_tk.utils import load_yaml_inject_variables, safe_read, sanitize_filename
-from cognite_toolkit._cdf_tk.utils.useful_types import T_ID, T_WritableCogniteResourceList
+from cognite_toolkit._cdf_tk.utils.useful_types import T_ID
 
 if TYPE_CHECKING:
     from cognite_toolkit._cdf_tk.data_classes import BuildEnvironment
@@ -151,7 +152,7 @@ T_Loader = TypeVar("T_Loader", bound=Loader)
 class ResourceCRUD(
     Loader,
     ABC,
-    Generic[T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList],
+    Generic[T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList],
 ):
     """This is the base class for all resource CRUD.
 
@@ -178,10 +179,10 @@ class ResourceCRUD(
     """
 
     # Must be set in the subclass
-    resource_write_cls: type[T_WriteClass]
-    resource_cls: type[T_WritableCogniteResource]
-    list_cls: type[T_WritableCogniteResourceList]
-    list_write_cls: type[T_CogniteResourceList]
+    resource_write_cls: type[T_ResourceRequest]
+    resource_cls: type[T_ResourceResponse]
+    list_cls: type[T_ResourceResponseList]
+    list_write_cls: type[T_ResourceRequestList]
     yaml_cls: type[ToolkitResource]
     # Optional to set in the subclass
     support_drop = True
@@ -196,7 +197,7 @@ class ResourceCRUD(
     # The methods that must be implemented in the subclass
     @classmethod
     @abstractmethod
-    def get_id(cls, item: T_WriteClass | T_WritableCogniteResource | dict) -> T_ID:
+    def get_id(cls, item: T_ResourceRequest | T_ResourceResponse | dict) -> T_ID:
         raise NotImplementedError
 
     @classmethod
@@ -207,19 +208,19 @@ class ResourceCRUD(
     @classmethod
     @abstractmethod
     def get_required_capability(
-        cls, items: Sequence[T_WriteClass] | None, read_only: bool
+        cls, items: Sequence[T_ResourceRequest] | None, read_only: bool
     ) -> Capability | list[Capability]:
         raise NotImplementedError(f"get_required_capability must be implemented for {cls.__name__}.")
 
     @abstractmethod
-    def create(self, items: T_CogniteResourceList) -> Sized:
+    def create(self, items: T_ResourceRequestList) -> Sized:
         raise NotImplementedError
 
     @abstractmethod
-    def retrieve(self, ids: SequenceNotStr[T_ID]) -> T_WritableCogniteResourceList:
+    def retrieve(self, ids: SequenceNotStr[T_ID]) -> T_ResourceResponseList:
         raise NotImplementedError
 
-    def update(self, items: T_CogniteResourceList) -> Sized:
+    def update(self, items: T_ResourceRequestList) -> Sized:
         raise NotImplementedError(f"Update is not supported for {type(self).__name__}.")
 
     @abstractmethod
@@ -231,7 +232,7 @@ class ResourceCRUD(
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[T_WritableCogniteResource]:
+    ) -> Iterable[T_ResourceResponse]:
         if sum([1 for x in [data_set_external_id, space, parent_ids] if x is not None]) > 1:
             raise ValueError("At most one of data_set_external_id, space, or parent_ids must be set.")
         if parent_ids is not None and not self.parent_resource:
@@ -254,7 +255,7 @@ class ResourceCRUD(
         data_set_external_id: str | None = None,
         space: str | None = None,
         parent_ids: list[Hashable] | None = None,
-    ) -> Iterable[T_WritableCogniteResource]:
+    ) -> Iterable[T_ResourceResponse]:
         raise NotImplementedError
 
     ### These methods can be optionally overwritten in the subclass ###
@@ -297,7 +298,7 @@ class ResourceCRUD(
         return []
 
     @classmethod
-    def get_internal_id(cls, item: T_WritableCogniteResource | dict) -> int:
+    def get_internal_id(cls, item: T_ResourceResponse | dict) -> int:
         raise NotImplementedError(f"{cls.__name__} does not have an internal id.")
 
     @classmethod
@@ -334,18 +335,18 @@ class ResourceCRUD(
         )
         return raw_yaml if isinstance(raw_yaml, list) else [raw_yaml]
 
-    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> T_WriteClass:
+    def load_resource(self, resource: dict[str, Any], is_dry_run: bool = False) -> T_ResourceRequest:
         """Loads the resource from a dictionary. Can be overwritten in subclasses."""
         return self.resource_write_cls._load(resource)
 
-    def dump_resource(self, resource: T_WritableCogniteResource, local: dict[str, Any] | None = None) -> dict[str, Any]:
+    def dump_resource(self, resource: T_ResourceResponse, local: dict[str, Any] | None = None) -> dict[str, Any]:
         """Dumps the resource to a dictionary that matches the write format.
 
         This is intended to be overwritten in subclasses that require special dumping logic, for example,
         replacing dataSetId with dataSetExternalId.
 
         Args:
-            resource (T_WritableCogniteResource): The resource to dump (typically comes from CDF).
+            resource (T_ResourceResponse): The resource to dump (typically comes from CDF).
             local (dict[str, Any] | None): The local resource. When used in a dump/import command, there is no local
                 resource.
         """
@@ -394,7 +395,7 @@ class ResourceCRUD(
             f"Missing implementation for {type(self).__name__} for {'.'.join(map(str, json_path))}."
         )
 
-    def sensitive_strings(self, item: T_WriteClass) -> Iterable[str]:
+    def sensitive_strings(self, item: T_ResourceRequest) -> Iterable[str]:
         """Returns a list of strings that should be masked when printing.
 
         This is used by the loaders with credentials to mask the credentials secrets. For example, the
@@ -405,7 +406,9 @@ class ResourceCRUD(
 
     # Helper methods
     @classmethod
-    def get_ids(cls, items: Sequence[T_WriteClass | T_WritableCogniteResource | dict]) -> list[T_ID]:
+    def get_ids(
+        cls, items: Sequence[T_ResourceRequest | T_ResourceResponse | dict] | T_ResourceResponseList
+    ) -> list[T_ID]:
         return [cls.get_id(item) for item in items]
 
     @classmethod
@@ -418,7 +421,7 @@ class ResourceCRUD(
 
 
 class ResourceContainerCRUD(
-    ResourceCRUD[T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList],
+    ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList],
     ABC,
 ):
     """This is the base class for all resource CRUD' containers.

cognite_toolkit/_cdf_tk/cruds/_data_cruds.py

@@ -5,15 +5,20 @@ from typing import TYPE_CHECKING, cast, final
 
 import pandas as pd
 from cognite.client.data_classes import FileMetadataWrite
-from cognite.client.data_classes._base import T_CogniteResourceList, T_WritableCogniteResource, T_WriteClass
 
 from cognite_toolkit._cdf_tk.client.data_classes.extendable_cognite_file import ExtendableCogniteFileApply
 from cognite_toolkit._cdf_tk.client.data_classes.raw import RawTable
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
+from cognite_toolkit._cdf_tk.protocols import (
+    T_ResourceRequest,
+    T_ResourceRequestList,
+    T_ResourceResponse,
+    T_ResourceResponseList,
+)
 from cognite_toolkit._cdf_tk.utils import read_yaml_content, safe_read
 from cognite_toolkit._cdf_tk.utils.file import read_csv
 
-from ._base_cruds import T_ID, DataCRUD, ResourceCRUD, T_WritableCogniteResourceList
+from ._base_cruds import T_ID, DataCRUD, ResourceCRUD
 from ._resource_cruds import CogniteFileCRUD, FileMetadataCRUD, RawTableCRUD, TimeSeriesCRUD
 
 if TYPE_CHECKING:
@@ -131,15 +136,13 @@ class FileCRUD(DataCRUD):
     def _read_metadata(
         destination: Path,
         loader: type[
-            ResourceCRUD[
-                T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
-            ]
+            ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList]
         ],
         identifier: T_ID,
-    ) -> T_WriteClass:
+    ) -> T_ResourceRequest:
         built_content = read_yaml_content(safe_read(destination, encoding=BUILD_FOLDER_ENCODING))
         if isinstance(built_content, dict):
-            return loader.resource_write_cls.load(built_content)
+            return loader.resource_write_cls._load(built_content)
         elif isinstance(built_content, list):
             try:
                 return next(m for m in loader.list_write_cls.load(built_content) if loader.get_id(m) == identifier)

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/__init__.py

@@ -13,7 +13,7 @@ from .datamodel import (
     ViewCRUD,
 )
 from .extraction_pipeline import ExtractionPipelineConfigCRUD, ExtractionPipelineCRUD
-from .fieldops import InfieldV1CRUD
+from .fieldops import InFieldLocationConfigCRUD, InfieldV1CRUD
 from .file import CogniteFileCRUD, FileMetadataCRUD
 from .function import FunctionCRUD, FunctionScheduleCRUD
 from .group_scoped import GroupResourceScopedCRUD
@@ -63,6 +63,7 @@ __all__ = [
     "HostedExtractorJobCRUD",
     "HostedExtractorMappingCRUD",
     "HostedExtractorSourceCRUD",
+    "InFieldLocationConfigCRUD",
     "InfieldV1CRUD",
     "LabelCRUD",
     "LocationFilterCRUD",

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/classic.py

@@ -6,6 +6,7 @@ from typing import Any, final
 
 import pandas as pd
 from cognite.client.data_classes import (
+    AggregateResultItem,
     Asset,
     AssetList,
     AssetWrite,
@@ -213,6 +214,20 @@ class AssetCRUD(ResourceCRUD[str, AssetWrite, Asset, AssetWriteList, AssetList])
             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
 
 

cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py

@@ -1,5 +1,5 @@
 import collections.abc
-from collections.abc import Hashable, Iterable
+from collections.abc import Hashable, Iterable, Sequence, Sized
 from pathlib import Path
 from typing import Any, final
 
@@ -14,9 +14,11 @@ from cognite_toolkit._cdf_tk.client.data_classes.apm_config_v1 import (
     APMConfigWrite,
     APMConfigWriteList,
 )
+from cognite_toolkit._cdf_tk.client.data_classes.infield import InfieldLocationConfig, InfieldLocationConfigList
+from cognite_toolkit._cdf_tk.client.data_classes.instance_api import InstanceResult, NodeIdentifier
 from cognite_toolkit._cdf_tk.constants import BUILD_FOLDER_ENCODING
 from cognite_toolkit._cdf_tk.cruds._base_cruds import ResourceCRUD
-from cognite_toolkit._cdf_tk.resource_classes import InfieldV1YAML
+from cognite_toolkit._cdf_tk.resource_classes import InfieldLocationConfigYAML, InfieldV1YAML
 from cognite_toolkit._cdf_tk.utils import quote_int_value_by_key_in_yaml, safe_read
 from cognite_toolkit._cdf_tk.utils.cdf import iterate_instances
 from cognite_toolkit._cdf_tk.utils.diff_list import diff_list_hashable, diff_list_identifiable, hash_dict
@@ -238,3 +240,110 @@ class InfieldV1CRUD(ResourceCRUD[str, APMConfigWrite, APMConfig, APMConfigWriteL
         if not isinstance(feature_configuration, dict):
             return None
         return feature_configuration.get("rootLocationConfigurations")
+
+
+@final
+class InFieldLocationConfigCRUD(
+    ResourceCRUD[
+        NodeIdentifier,
+        InfieldLocationConfig,
+        InfieldLocationConfig,
+        InfieldLocationConfigList,
+        InfieldLocationConfigList,
+    ]
+):
+    folder_name = "cdf_applications"
+    filename_pattern = r"^.*\.InFieldLocationConfig$"
+    filetypes = frozenset({"yaml", "yml"})
+    resource_cls = InfieldLocationConfig
+    resource_write_cls = InfieldLocationConfig
+    list_cls = InfieldLocationConfigList
+    list_write_cls = InfieldLocationConfigList
+    kind = "InFieldLocationConfig"
+    yaml_cls = InfieldLocationConfigYAML
+    dependencies = frozenset({SpaceCRUD, GroupAllScopedCRUD, GroupResourceScopedCRUD})
+    _doc_url = "Instances/operation/applyNodeAndEdges"
+
+    @classmethod
+    def get_id(cls, item: InfieldLocationConfig | dict) -> NodeIdentifier:
+        if isinstance(item, dict):
+            return NodeIdentifier(space=item["space"], external_id=item["externalId"])
+        return NodeIdentifier(space=item.space, external_id=item.external_id)
+
+    @classmethod
+    def dump_id(cls, id: NodeIdentifier) -> dict[str, Any]:
+        return id.dump(include_type=False)
+
+    @classmethod
+    def get_required_capability(
+        cls, items: Sequence[InfieldLocationConfig] | None, read_only: bool
+    ) -> Capability | list[Capability]:
+        if not items or items is None:
+            return []
+
+        actions = (
+            [DataModelInstancesAcl.Action.Read]
+            if read_only
+            else [DataModelInstancesAcl.Action.Read, DataModelInstancesAcl.Action.Write]
+        )
+        instance_spaces = sorted({item.space for item in items})
+
+        return DataModelInstancesAcl(actions, DataModelInstancesAcl.Scope.SpaceID(instance_spaces))
+
+    def dump_resource(self, resource: InfieldLocationConfig, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.dump()
+        local = local or {}
+        dumped.pop("instanceType", None)
+        if isinstance(cdf_dec := dumped.get("dataExplorationConfig"), dict):
+            cdf_dec.pop("instanceType", None)
+            if isinstance(local_dec := local.get("dataExplorationConfig"), dict):
+                if "space" in cdf_dec and "space" not in local_dec:
+                    # Default space is used for the data exploration config if not specified locally.
+                    cdf_dec.pop("space")
+                if "externalId" in cdf_dec and "externalId" not in local_dec:
+                    # Default externalId is used for the data exploration config if not specified locally.
+                    cdf_dec.pop("externalId")
+
+        return dumped
+
+    def create(self, items: InfieldLocationConfigList) -> list[InstanceResult]:
+        created = self.client.infield.config.apply(items)
+        config_ids = {config.as_id() for config in items}
+        # We filter out all the data exploration configs that were created along with the infield location configs
+        # as we only want to count the infield location configs here.
+        return [res for res in created if res.as_id() in config_ids]
+
+    def retrieve(self, ids: SequenceNotStr[NodeIdentifier]) -> InfieldLocationConfigList:
+        return InfieldLocationConfigList(self.client.infield.config.retrieve(list(ids)))
+
+    def update(self, items: InfieldLocationConfigList) -> Sized:
+        return self.create(items)
+
+    def delete(self, ids: SequenceNotStr[NodeIdentifier]) -> int:
+        # We must retrieve the full resource to get hte DataExplorationConfig linked resource deleted as well.
+        retrieved = self.retrieve(list(ids))
+        # Then, we pass the entire resource to the delete method, which will delete both the InfieldLocationConfig
+        # and the linked DataExplorationConfig.
+        _ = self.client.infield.config.delete(retrieved)
+        return len(retrieved)
+
+    def _iterate(
+        self,
+        data_set_external_id: str | None = None,
+        space: str | None = None,
+        parent_ids: list[Hashable] | None = None,
+    ) -> Iterable[InfieldLocationConfig]:
+        raise NotImplementedError(f"Iteration over {self.display_name} is not supported.")
+
+    def diff_list(
+        self, local: list[Any], cdf: list[Any], json_path: tuple[str | int, ...]
+    ) -> tuple[dict[int, int], list[int]]:
+        if json_path == ("accessManagement", "templateAdmins"):
+            return diff_list_hashable(local, cdf)
+        elif json_path == ("accessManagement", "checklistAdmins"):
+            return diff_list_hashable(local, cdf)
+        elif json_path == ("dataFilters", "general", "spaces"):
+            return diff_list_hashable(local, cdf)
+        elif json_path == ("dataExplorationConfig", "documents", "supportedFormats"):
+            return diff_list_hashable(local, cdf)
+        return super().diff_list(local, cdf, json_path)

cognite_toolkit/_cdf_tk/cruds/_worker.py

@@ -7,11 +7,6 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any, Generic, cast
 
 from cognite.client.data_classes import FunctionWrite
-from cognite.client.data_classes._base import (
-    T_CogniteResourceList,
-    T_WritableCogniteResource,
-    T_WriteClass,
-)
 from cognite.client.data_classes.capabilities import Capability
 from rich import print
 from rich.panel import Panel
@@ -23,27 +18,34 @@ from cognite_toolkit._cdf_tk.tk_warnings import EnvironmentVariableMissingWarnin
 from cognite_toolkit._cdf_tk.utils import to_diff
 
 from . import FunctionCRUD
-from ._base_cruds import T_ID, ResourceCRUD, T_WritableCogniteResourceList
+from ._base_cruds import (
+    T_ID,
+    ResourceCRUD,
+    T_ResourceRequest,
+    T_ResourceRequestList,
+    T_ResourceResponse,
+    T_ResourceResponseList,
+)
 
 if TYPE_CHECKING:
     from cognite_toolkit._cdf_tk.data_classes._module_directories import ReadModule
 
 
 @dataclass
-class CategorizedResources(Generic[T_ID, T_CogniteResourceList]):
-    to_create: T_CogniteResourceList
-    to_update: T_CogniteResourceList
+class CategorizedResources(Generic[T_ID, T_ResourceRequestList]):
+    to_create: T_ResourceRequestList
+    to_update: T_ResourceRequestList
     to_delete: list[T_ID]
-    unchanged: T_CogniteResourceList
+    unchanged: T_ResourceRequestList
 
 
 class ResourceWorker(
-    Generic[T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList]
+    Generic[T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList]
 ):
     def __init__(
         self,
         loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
+            T_ID, T_ResourceRequest, T_ResourceResponse, T_ResourceRequestList, T_ResourceResponseList
         ],
         action: str,
     ):
@@ -102,14 +104,14 @@ class ResourceWorker(
         self.validate_access(local_by_id, is_dry_run)
 
         # Lookup the existing resources in CDF
-        cdf_resources: T_WritableCogniteResourceList
+        cdf_resources: T_ResourceResponseList
         cdf_resources = self.loader.retrieve(list(local_by_id.keys()))
         return self.categorize_resources(local_by_id, cdf_resources, force_update, verbose)
 
     def load_resources(
         self, filepaths: list[Path], environment_variables: dict[str, str | None] | None, is_dry_run: bool
-    ) -> dict[T_ID, tuple[dict[str, Any], T_WriteClass]]:
-        local_by_id: dict[T_ID, tuple[dict[str, Any], T_WriteClass]] = {}
+    ) -> dict[T_ID, tuple[dict[str, Any], T_ResourceRequest]]:
+        local_by_id: dict[T_ID, tuple[dict[str, Any], T_ResourceRequest]] = {}
         # Load all resources from files, get ids, and remove duplicates.
         environment_variables = environment_variables or {}
         for filepath in filepaths:
@@ -145,7 +147,9 @@ class ResourceWorker(
                     warning.print_warning()
         return local_by_id
 
-    def validate_access(self, local_by_id: dict[T_ID, tuple[dict[str, Any], T_WriteClass]], is_dry_run: bool) -> None:
+    def validate_access(
+        self, local_by_id: dict[T_ID, tuple[dict[str, Any], T_ResourceRequest]], is_dry_run: bool
+    ) -> None:
         capabilities: Capability | list[Capability]
         if isinstance(self.loader, FunctionCRUD):
             function_loader: FunctionCRUD = self.loader
@@ -160,12 +164,12 @@ class ResourceWorker(
 
     def categorize_resources(
         self,
-        local_by_id: dict[T_ID, tuple[dict[str, Any], T_WriteClass]],
-        cdf_resources: T_WritableCogniteResourceList,
+        local_by_id: dict[T_ID, tuple[dict[str, Any], T_ResourceRequest]],
+        cdf_resources: T_ResourceResponseList,
         force_update: bool,
         verbose: bool,
-    ) -> CategorizedResources:
-        resources: CategorizedResources[T_ID, T_CogniteResourceList] = CategorizedResources(
+    ) -> CategorizedResources[T_ID, T_ResourceRequestList]:
+        resources: CategorizedResources[T_ID, T_ResourceRequestList] = CategorizedResources(
             to_create=self.loader.list_write_cls([]),
             to_update=self.loader.list_write_cls([]),
             to_delete=[],