cognite-toolkit 0.7.13__tar.gz → 0.7.15__tar.gz

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.13
+Version: 0.7.15
 Summary: Official Cognite Data Fusion tool for project templates and configuration deployment
 Project-URL: Homepage, https://docs.cognite.com/cdf/deploy/cdf_toolkit/
 Project-URL: Changelog, https://github.com/cognitedata/toolkit/releases

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/cdf.toml

@@ -12,6 +12,7 @@ infield = true
 migrate = true
 streams = true
 create = true
+extend-download = true
 
 [plugins]
 run = true
@@ -22,7 +23,7 @@ data = true
 [modules]
 # This is the version of the modules. It should not be changed manually.
 # It will be updated by the 'cdf modules upgrade' command.
-version = "0.7.13"
+version = "0.7.15"
 
 
 [library.toolkit-data]

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/cognite_toolkit/_cdf_tk/apps/_download_app.py

@@ -10,15 +10,19 @@ from rich import print
 from cognite_toolkit._cdf_tk.client.data_classes.raw import RawTable
 from cognite_toolkit._cdf_tk.commands import DownloadCommand
 from cognite_toolkit._cdf_tk.constants import DATA_DEFAULT_DIR
+from cognite_toolkit._cdf_tk.feature_flags import Flags
 from cognite_toolkit._cdf_tk.storageio import (
     AssetIO,
     CanvasIO,
     ChartIO,
+    DataSelector,
     EventIO,
+    FileContentIO,
     FileMetadataIO,
     HierarchyIO,
     InstanceIO,
     RawIO,
+    StorageIO,
     TimeSeriesIO,
 )
 from cognite_toolkit._cdf_tk.storageio.selectors import (
@@ -28,11 +32,14 @@ from cognite_toolkit._cdf_tk.storageio.selectors import (
     ChartExternalIdSelector,
     ChartSelector,
     DataSetSelector,
+    FileIdentifierSelector,
     InstanceSpaceSelector,
     RawTableSelector,
     SelectedTable,
     SelectedView,
 )
+from cognite_toolkit._cdf_tk.storageio.selectors._file_content import FileInternalID
+from cognite_toolkit._cdf_tk.utils import sanitize_filename
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 from cognite_toolkit._cdf_tk.utils.interactive_select import (
     AssetCentricInteractiveSelect,
@@ -45,7 +52,6 @@ from cognite_toolkit._cdf_tk.utils.interactive_select import (
     RawTableInteractiveSelect,
     TimeSeriesInteractiveSelect,
 )
-from cognite_toolkit._cdf_tk.utils.useful_types import AssetCentricKind
 
 
 class RawFormats(str, Enum):
@@ -59,6 +65,10 @@ class AssetCentricFormats(str, Enum):
     ndjson = "ndjson"
 
 
+class FileContentFormats(str, Enum):
+    ndjson = "ndjson"
+
+
 class HierarchyFormats(str, Enum):
     ndjson = "ndjson"
 
@@ -261,7 +271,7 @@ class DownloadApp(typer.Typer):
                 compression,
                 output_dir,
                 limit,
-                "Assets",
+                "assets",
             )
 
         selectors = [DataSetSelector(kind="Assets", data_set_external_id=data_set) for data_set in data_sets]
@@ -286,13 +296,14 @@ class DownloadApp(typer.Typer):
         compression: CompressionFormat,
         output_dir: Path,
         limit: int,
-        kind: AssetCentricKind,
+        display_name: str,
+        max_limit: int | None = None,
+        available_formats: type[Enum] = AssetCentricFormats,
     ) -> tuple[list[str], AssetCentricFormats, CompressionFormat, Path, int]:
         data_sets = selector.select_data_sets()
-        display_name = kind.casefold() + "s"
         file_format = questionary.select(
             f"Select format to download the {display_name} in:",
-            choices=[Choice(title=format_.value, value=format_) for format_ in AssetCentricFormats],
+            choices=[Choice(title=format_.value, value=format_) for format_ in available_formats],
             default=file_format,
         ).ask()
         compression = questionary.select(
@@ -302,7 +313,7 @@ class DownloadApp(typer.Typer):
         ).ask()
         output_dir = Path(
             questionary.path(
-                "Where to download the assets:",
+                f"Where to download the {display_name}:",
                 default=str(output_dir),
                 only_directories=True,
             ).ask()
@@ -316,9 +327,15 @@ class DownloadApp(typer.Typer):
                 raise typer.Abort()
             try:
                 limit = int(limit_str)
-                break
             except ValueError:
                 print("[red]Please enter a valid integer for the limit.[/]")
+            else:
+                if max_limit is not None and limit > max_limit:
+                    print(
+                        f"[red]The maximum limit for downloading {display_name} is {max_limit}. Please enter a lower value.[/]"
+                    )
+                else:
+                    break
         return data_sets, file_format, compression, output_dir, limit
 
     def download_timeseries_cmd(
@@ -383,7 +400,7 @@ class DownloadApp(typer.Typer):
                 compression,
                 output_dir,
                 limit,
-                "TimeSeries",
+                "time series",
             )
 
         selectors = [DataSetSelector(kind="TimeSeries", data_set_external_id=data_set) for data_set in data_sets]
@@ -462,7 +479,7 @@ class DownloadApp(typer.Typer):
                 compression,
                 output_dir,
                 limit,
-                "Events",
+                "events",
             )
 
         selectors = [DataSetSelector(kind="Events", data_set_external_id=data_set) for data_set in data_sets]
@@ -491,6 +508,16 @@ class DownloadApp(typer.Typer):
                 help="List of data sets to download file metadata from. If this is not provided, an interactive selection will be made.",
             ),
         ] = None,
+        include_file_contents: Annotated[
+            bool,
+            typer.Option(
+                "--include-file-contents",
+                "-c",
+                help="Whether to include file contents when downloading assets. Note if you enable this option, you can"
+                "only download 1000 files at a time.",
+                hidden=not Flags.EXTEND_DOWNLOAD.is_enabled(),
+            ),
+        ] = False,
         file_format: Annotated[
             AssetCentricFormats,
             typer.Option(
@@ -536,21 +563,58 @@ class DownloadApp(typer.Typer):
         """This command will download file metadata from CDF into a temporary directory."""
         client = EnvironmentVariables.create_from_environment().get_client()
         if data_sets is None:
+            if Flags.EXTEND_DOWNLOAD.is_enabled():
+                include_file_contents = questionary.select(
+                    "Do you want to include file contents when downloading file metadata?",
+                    choices=[
+                        Choice(title="Yes", value=True),
+                        Choice(title="No", value=False),
+                    ],
+                ).ask()
+            else:
+                include_file_contents = False
+
+            available_formats = FileContentFormats if include_file_contents else AssetCentricFormats
+            file_format = FileContentFormats.ndjson if include_file_contents else file_format  # type: ignore[assignment]
             data_sets, file_format, compression, output_dir, limit = self._asset_centric_interactive(
                 FileMetadataInteractiveSelect(client, "download"),
                 file_format,
                 compression,
                 output_dir,
-                limit,
-                "FileMetadata",
+                limit if not include_file_contents else 1000,
+                "file metadata",
+                max_limit=1000 if include_file_contents else None,
+                available_formats=available_formats,
             )
 
-        selectors = [DataSetSelector(kind="FileMetadata", data_set_external_id=data_set) for data_set in data_sets]
+        io: StorageIO
+        selectors: list[DataSelector]
+        if include_file_contents:
+            if limit == -1 or limit > 1000:
+                limit = 1000
+                print(
+                    "[yellow]When including file contents, the maximum number of files that can be downloaded at a time is 1000. "
+                )
+            if file_format == AssetCentricFormats.csv or file_format == AssetCentricFormats.parquet:
+                print(
+                    "[red]When including file contents, the only supported format is ndjson. Overriding the format to ndjson.[/]"
+                )
+                file_format = AssetCentricFormats.ndjson
+            files = client.files.list(data_set_external_ids=data_sets, limit=limit)
+            selector = FileIdentifierSelector(
+                identifiers=tuple([FileInternalID(internal_id=file.id) for file in files])  # type: ignore[call-arg]
+            )
+            selectors = [selector]
+            io = FileContentIO(client, output_dir / sanitize_filename(selector.group))
+        else:
+            selectors = [DataSetSelector(kind="FileMetadata", data_set_external_id=data_set) for data_set in data_sets]
+            io = FileMetadataIO(client)
+
         cmd = DownloadCommand()
         cmd.run(
             lambda: cmd.download(
-                selectors=selectors,
-                io=FileMetadataIO(client),
+                selectors=selectors,  # type: ignore[misc]
+                io=io,
                 output_dir=output_dir,
                 file_format=f".{file_format.value}",
                 compression=compression.value,

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/cognite_toolkit/_cdf_tk/client/_toolkit_client.py

@@ -38,6 +38,7 @@ class ToolkitClient(CogniteClient):
     def __init__(self, config: ToolkitClientConfig | None = None, enable_set_pending_ids: bool = False) -> None:
         super().__init__(config=config)
         http_client = HTTPClient(self.config)
+        self.http_client = http_client
         toolkit_config = ToolkitClientConfig.from_client_config(self.config)
         self.console = Console()
         self.tool = ToolAPI(http_client, self.console)

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/cognite_toolkit/_cdf_tk/client/api/infield.py

@@ -4,7 +4,11 @@ from typing import Any, cast
 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, InfieldLocationConfig
+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,
@@ -150,7 +154,95 @@ class InfieldConfigAPI:
         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]
+        responses = self._http_client.request_with_retries(
+            ItemsRequest(
+                endpoint_url=self._config.create_api_url(self.ENDPOINT),
+                method="POST",
+                items=request_items,  # type: ignore[arg-type]
+            )
+        )
+        responses.raise_for_status()
+        return PagedResponse[InstanceResult].model_validate(responses.get_first_body()).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 []
+        responses = self._http_client.request_with_retries(
+            SimpleBodyRequest(
+                endpoint_url=self._config.create_api_url(f"{self.ENDPOINT}/query"),
+                method="POST",
+                body_content=self._retrieve_query(items),
+            )
+        )
+        responses.raise_for_status()
+        parsed_response = QueryResponse[InstanceResponseItem].model_validate(responses.get_first_body())
+        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-0.7.13 → cognite_toolkit-0.7.15}/cognite_toolkit/_cdf_tk/client/data_classes/infield.py

@@ -19,6 +19,9 @@ else:
     from typing_extensions import Self
 
 INFIELD_LOCATION_CONFIG_VIEW_ID = ViewReference(space="cdf_infield", external_id="InFieldLocationConfig", version="v1")
+INFIELD_CDM_LOCATION_CONFIG_VIEW_ID = ViewReference(
+    space="infield_cdm_source_desc_sche_asset_file_ts", external_id="InFieldCDMLocationConfig", version="v1"
+)
 DATA_EXPLORATION_CONFIG_VIEW_ID = ViewReference(space="cdf_infield", external_id="DataExplorationConfig", version="v1")
 
 
@@ -85,3 +88,29 @@ class InfieldLocationConfigList(
 
     def as_write(self) -> Self:
         return self
+
+
+class InFieldCDMLocationConfig(ResponseResource["InFieldCDMLocationConfig"], InstanceRequestResource):
+    """InField CDM Location Configuration resource class.
+
+    This class is used for both the response and request resource for InField CDM Location Configuration nodes.
+    """
+
+    VIEW_ID: ClassVar[ViewReference] = INFIELD_CDM_LOCATION_CONFIG_VIEW_ID
+    instance_type: Literal["node"] = "node"
+
+    name: str | None = None
+    description: str | None = None
+    feature_toggles: dict[str, JsonValue] | None = None
+    access_management: dict[str, JsonValue] | None = None
+    data_filters: dict[str, JsonValue] | None = None
+    data_storage: dict[str, JsonValue] | None = None
+    view_mappings: dict[str, JsonValue] | None = None
+    disciplines: list[dict[str, JsonValue]] | None = None
+    data_exploration_config: dict[str, JsonValue] | None = None
+
+    def as_request_resource(self) -> "InFieldCDMLocationConfig":
+        return self
+
+    def as_write(self) -> Self:
+        return self

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/cognite_toolkit/_cdf_tk/client/testing.py

@@ -21,7 +21,7 @@ from .api.extended_files import ExtendedFileMetadataAPI
 from .api.extended_functions import ExtendedFunctionsAPI
 from .api.extended_raw import ExtendedRawAPI
 from .api.extended_timeseries import ExtendedTimeSeriesAPI
-from .api.infield import InfieldAPI, InfieldConfigAPI
+from .api.infield import InfieldAPI, InFieldCDMConfigAPI, InfieldConfigAPI
 from .api.location_filters import LocationFiltersAPI
 from .api.lookup import (
     AssetLookUpAPI,
@@ -84,6 +84,7 @@ class ToolkitClientMock(CogniteClientMock):
         self.functions.schedules = MagicMock(spec_set=FunctionSchedulesAPI)
         self.infield = MagicMock(spec=InfieldAPI)
         self.infield.config = MagicMock(spec_set=InfieldConfigAPI)
+        self.infield.cdm_config = MagicMock(spec_set=InFieldCDMConfigAPI)
 
         self.project = MagicMock(spec_set=ProjectAPI)
 

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/cognite_toolkit/_cdf_tk/cruds/__init__.py

@@ -41,6 +41,7 @@ from ._resource_cruds import (
     HostedExtractorJobCRUD,
     HostedExtractorMappingCRUD,
     HostedExtractorSourceCRUD,
+    InFieldCDMLocationConfigCRUD,
     InFieldLocationConfigCRUD,
     InfieldV1CRUD,
     LabelCRUD,
@@ -80,6 +81,7 @@ if not FeatureFlag.is_enabled(Flags.GRAPHQL):
 if not FeatureFlag.is_enabled(Flags.INFIELD):
     _EXCLUDED_CRUDS.add(InfieldV1CRUD)
     _EXCLUDED_CRUDS.add(InFieldLocationConfigCRUD)
+    _EXCLUDED_CRUDS.add(InFieldCDMLocationConfigCRUD)
 if not FeatureFlag.is_enabled(Flags.MIGRATE):
     _EXCLUDED_CRUDS.add(ResourceViewMappingCRUD)
 if not FeatureFlag.is_enabled(Flags.STREAMS):
@@ -185,6 +187,7 @@ __all__ = [
     "HostedExtractorJobCRUD",
     "HostedExtractorMappingCRUD",
     "HostedExtractorSourceCRUD",
+    "InFieldCDMLocationConfigCRUD",
     "InFieldLocationConfigCRUD",
     "LabelCRUD",
     "LocationFilterCRUD",

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/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 InFieldLocationConfigCRUD, InfieldV1CRUD
+from .fieldops import InFieldCDMLocationConfigCRUD, InFieldLocationConfigCRUD, InfieldV1CRUD
 from .file import CogniteFileCRUD, FileMetadataCRUD
 from .function import FunctionCRUD, FunctionScheduleCRUD
 from .group_scoped import GroupResourceScopedCRUD
@@ -64,6 +64,7 @@ __all__ = [
     "HostedExtractorJobCRUD",
     "HostedExtractorMappingCRUD",
     "HostedExtractorSourceCRUD",
+    "InFieldCDMLocationConfigCRUD",
     "InFieldLocationConfigCRUD",
     "InfieldV1CRUD",
     "LabelCRUD",

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/cognite_toolkit/_cdf_tk/cruds/_resource_cruds/fieldops.py

@@ -13,11 +13,19 @@ from cognite_toolkit._cdf_tk.client.data_classes.apm_config_v1 import (
     APMConfigList,
     APMConfigWrite,
 )
-from cognite_toolkit._cdf_tk.client.data_classes.infield import InfieldLocationConfig, InfieldLocationConfigList
+from cognite_toolkit._cdf_tk.client.data_classes.infield import (
+    InFieldCDMLocationConfig,
+    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 InfieldLocationConfigYAML, InfieldV1YAML
+from cognite_toolkit._cdf_tk.resource_classes import (
+    InFieldCDMLocationConfigYAML,
+    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
@@ -249,6 +257,10 @@ class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConf
     dependencies = frozenset({SpaceCRUD, GroupAllScopedCRUD, GroupResourceScopedCRUD})
     _doc_url = "Instances/operation/applyNodeAndEdges"
 
+    @property
+    def display_name(self) -> str:
+        return "infield location configs"
+
     @classmethod
     def get_id(cls, item: InfieldLocationConfig | dict) -> NodeIdentifier:
         if isinstance(item, dict):
@@ -332,3 +344,97 @@ class InFieldLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InfieldLocationConf
         elif json_path == ("dataExplorationConfig", "documents", "supportedFormats"):
             return diff_list_hashable(local, cdf)
         return super().diff_list(local, cdf, json_path)
+
+
+@final
+class InFieldCDMLocationConfigCRUD(ResourceCRUD[NodeIdentifier, InFieldCDMLocationConfig, InFieldCDMLocationConfig]):
+    folder_name = "cdf_applications"
+    filetypes = frozenset({"yaml", "yml"})
+    resource_cls = InFieldCDMLocationConfig
+    resource_write_cls = InFieldCDMLocationConfig
+    kind = "InFieldCDMLocationConfig"
+    yaml_cls = InFieldCDMLocationConfigYAML
+    dependencies = frozenset({SpaceCRUD, GroupAllScopedCRUD, GroupResourceScopedCRUD})
+    _doc_url = "Instances/operation/applyNodeAndEdges"
+
+    @property
+    def display_name(self) -> str:
+        return "infield CDM location configs"
+
+    @classmethod
+    def get_id(cls, item: InFieldCDMLocationConfig | 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[InFieldCDMLocationConfig] | 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: InFieldCDMLocationConfig, local: dict[str, Any] | None = None) -> dict[str, Any]:
+        dumped = resource.as_write().dump()
+        local = local or {}
+        if "existingVersion" not in local:
+            # Existing version is typically not set when creating nodes, but we get it back
+            # when we retrieve the node from the server.
+            dumped.pop("existingVersion", None)
+        dumped.pop("instanceType", None)
+        return dumped
+
+    def create(self, items: Sequence[InFieldCDMLocationConfig]) -> list[InstanceResult]:
+        return self.client.infield.cdm_config.apply(items)
+
+    def retrieve(self, ids: SequenceNotStr[NodeIdentifier]) -> list[InFieldCDMLocationConfig]:
+        return self.client.infield.cdm_config.retrieve(list(ids))
+
+    def update(self, items: Sequence[InFieldCDMLocationConfig]) -> Sized:
+        return self.create(items)
+
+    def delete(self, ids: SequenceNotStr[NodeIdentifier]) -> int:
+        # We must retrieve the full resource to delete it.
+        retrieved = self.retrieve(list(ids))
+        _ = self.client.infield.cdm_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[InFieldCDMLocationConfig]:
+        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 == ("disciplines",):
+            return diff_list_identifiable(local, cdf, get_identifier=hash_dict)
+        elif len(json_path) == 3 and json_path[0] == "dataFilters" and json_path[2] == "instanceSpaces":
+            # Handles dataFilters.<entity>.instanceSpaces (e.g., files, assets, operations, timeSeries, etc.)
+            return diff_list_hashable(local, cdf)
+        elif json_path == ("dataExplorationConfig", "filters"):
+            return diff_list_identifiable(local, cdf, get_identifier=hash_dict)
+        elif len(json_path) == 4 and json_path[:2] == ("dataExplorationConfig", "filters") and json_path[3] == "values":
+            # Handles dataExplorationConfig.filters[i].values
+            return diff_list_hashable(local, cdf)
+        return super().diff_list(local, cdf, json_path)

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/cognite_toolkit/_cdf_tk/feature_flags.py

@@ -53,6 +53,10 @@ class Flags(Enum):
         visible=True,
         description="Enables the support for the resources create command under dev plugin",
     )
+    EXTEND_DOWNLOAD = FlagMetadata(
+        visible=True,
+        description="Enables extended download to support downloading file content",
+    )
 
     def is_enabled(self) -> bool:
         return FeatureFlag.is_enabled(self)

{cognite_toolkit-0.7.13 → cognite_toolkit-0.7.15}/cognite_toolkit/_cdf_tk/resource_classes/__init__.py

@@ -27,6 +27,7 @@ from .hosted_extractor_destination import HostedExtractorDestinationYAML
 from .hosted_extractor_job import HostedExtractorJobYAML
 from .hosted_extractor_mapping import HostedExtractorMappingYAML
 from .hosted_extractor_source import HostedExtractorSourceYAML
+from .infield_cdm_location_config import InFieldCDMLocationConfigYAML
 from .infield_location_config import InfieldLocationConfigYAML
 from .infield_v1 import InfieldV1YAML
 from .instance import EdgeYAML, NodeYAML
@@ -76,6 +77,7 @@ __all__ = [
     "HostedExtractorJobYAML",
     "HostedExtractorMappingYAML",
     "HostedExtractorSourceYAML",
+    "InFieldCDMLocationConfigYAML",
     "InfieldLocationConfigYAML",
     "InfieldV1YAML",
     "LabelsYAML",