cognite-toolkit 0.7.12__tar.gz → 0.7.14__tar.gz

{cognite_toolkit-0.7.12 → cognite_toolkit-0.7.14}/.pre-commit-config.yaml

@@ -18,7 +18,7 @@ repos:
           - --fixable=E,W,F,I,T,RUF,TID,UP
           - --target-version=py310
       - id: ruff-format
-    rev: v0.14.6
+    rev: v0.14.7
 
   - repo: https://github.com/igorshubovych/markdownlint-cli
     rev: v0.46.0

{cognite_toolkit-0.7.12 → cognite_toolkit-0.7.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cognite_toolkit
-Version: 0.7.12
+Version: 0.7.14
 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.12 → cognite_toolkit-0.7.14}/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.12"
+version = "0.7.14"
 
 
 [library.toolkit-data]

{cognite_toolkit-0.7.12 → cognite_toolkit-0.7.14}/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.12 → cognite_toolkit-0.7.14}/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.12 → cognite_toolkit-0.7.14}/cognite_toolkit/_cdf_tk/commands/auth.py

@@ -26,6 +26,7 @@ import questionary
 from cognite.client.data_classes.capabilities import (
     AssetsAcl,
     Capability,
+    ExtractionConfigsAcl,
     FunctionsAcl,
     GroupsAcl,
     ProjectsAcl,
@@ -46,6 +47,7 @@ from cognite_toolkit._cdf_tk.constants import (
     TOOLKIT_DEMO_GROUP_NAME,
     TOOLKIT_SERVICE_PRINCIPAL_GROUP_NAME,
 )
+from cognite_toolkit._cdf_tk.cruds import ExtractionPipelineConfigCRUD
 from cognite_toolkit._cdf_tk.exceptions import (
     AuthenticationError,
     AuthorizationError,
@@ -434,8 +436,23 @@ class AuthCommand(ToolkitCommand):
             crud = crud_cls.create_loader(client)
             if crud.prerequisite_warning() is not None:
                 continue
-            capability = crud_cls.get_required_capability(None, read_only=False)
-            capabilities = capability if isinstance(capability, list) else [capability]
+            if isinstance(crud, ExtractionPipelineConfigCRUD):
+                # The Extraction Pipeline Config CRUD requires special handling.
+                # The .get_required_capability is used in the DeployCommand as well. Since, there is no way to no
+                # the extraction pipeline ID or dataSetId from an ExtractionPipelineConfigWrite object, we do not
+                # check those there. If we returned the full capability, it would always have to be all scoped.
+                # That is too restrictive in the deploy command, so we return an empty list, essentially not checking
+                # anything there. Here, we want to add the all scoped capability, so that the Toolkit group gets the
+                # correct capability.
+                capabilities: list[Capability] = [
+                    ExtractionConfigsAcl(
+                        [ExtractionConfigsAcl.Action.Read, ExtractionConfigsAcl.Action.Write],
+                        ExtractionConfigsAcl.Scope.All(),
+                    )
+                ]
+            else:
+                capability = crud_cls.get_required_capability(None, read_only=False)
+                capabilities = capability if isinstance(capability, list) else [capability]
             for cap in capabilities:
                 if project_type == "DATA_MODELING_ONLY" and isinstance(cap, AssetsAcl | RelationshipsAcl):
                     continue

{cognite_toolkit-0.7.12 → cognite_toolkit-0.7.14}/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.12 → cognite_toolkit-0.7.14}/cognite_toolkit/_cdf_tk/storageio/_file_content.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import cast
 
+import httpx
 from cognite.client.data_classes import FileMetadata, FileMetadataWrite
 from cognite.client.data_classes.data_modeling import NodeId, ViewId
 
@@ -26,8 +27,16 @@ from cognite_toolkit._cdf_tk.utils.http_client import (
 from cognite_toolkit._cdf_tk.utils.useful_types import JsonVal
 
 from ._base import Page, UploadableStorageIO, UploadItem
-from .selectors import FileContentSelector, FileMetadataTemplateSelector
-from .selectors._file_content import FILEPATH, FileDataModelingTemplateSelector
+from .selectors import FileContentSelector, FileIdentifierSelector, FileMetadataTemplateSelector
+from .selectors._file_content import (
+    FILEPATH,
+    FileDataModelingTemplateSelector,
+    FileExternalID,
+    FileIdentifier,
+    FileInstanceID,
+    FileInternalID,
+)
+from .selectors._file_content import NodeId as SelectorNodeId
 
 COGNITE_FILE_VIEW = ViewId("cdf_cdm", "CogniteFile", "v1")
 
@@ -47,23 +56,150 @@ class FileContentIO(UploadableStorageIO[FileContentSelector, FileMetadata, FileM
     SUPPORTED_READ_FORMATS = frozenset({".ndjson"})
     UPLOAD_ENDPOINT = "/files"
 
-    def __init__(self, client: ToolkitClient) -> None:
+    def __init__(self, client: ToolkitClient, target_dir: Path = Path.cwd()) -> None:
         super().__init__(client)
         self._crud = FileMetadataCRUD(client, None, None)
+        self._target_dir = target_dir
 
     def as_id(self, item: FileMetadata) -> str:
         return item.external_id or str(item.id)
 
-    def stream_data(self, selector: FileContentSelector, limit: int | None = None) -> Iterable[Page]:
-        raise NotImplementedError("Download of FileContent is not yet supported")
+    def stream_data(self, selector: FileContentSelector, limit: int | None = None) -> Iterable[Page[FileMetadata]]:
+        if not isinstance(selector, FileIdentifierSelector):
+            raise ToolkitNotImplementedError(
+                f"Download with the manifest, {type(selector).__name__}, is not supported for FileContentIO"
+            )
+        selected_identifiers = selector.identifiers
+        if limit is not None and limit < len(selected_identifiers):
+            selected_identifiers = selected_identifiers[:limit]
+        for identifiers in chunker_sequence(selected_identifiers, self.CHUNK_SIZE):
+            metadata = self._retrieve_metadata(identifiers)
+            if metadata is None:
+                continue
+            identifiers_map = self._as_metadata_map(metadata)
+            downloaded_files: list[FileMetadata] = []
+            for identifier in identifiers:
+                if identifier not in identifiers_map:
+                    continue
+
+                meta = identifiers_map[identifier]
+                filepath = self._create_filepath(meta, selector)
+                download_url = self._retrieve_download_url(identifier)
+                if download_url is None:
+                    continue
+                filepath.parent.mkdir(parents=True, exist_ok=True)
+                with httpx.stream("GET", download_url) as response:
+                    if response.status_code != 200:
+                        continue
+                    with filepath.open(mode="wb") as file_stream:
+                        for chunk in response.iter_bytes(chunk_size=8192):
+                            file_stream.write(chunk)
+                downloaded_files.append(meta)
+            yield Page(items=downloaded_files, worker_id="Main")
+
+    def _retrieve_metadata(self, identifiers: Sequence[FileIdentifier]) -> Sequence[FileMetadata] | None:
+        config = self.client.config
+        responses = self.client.http_client.request_with_retries(
+            message=SimpleBodyRequest(
+                endpoint_url=config.create_api_url("/files/byids"),
+                method="POST",
+                body_content={
+                    "items": [
+                        identifier.model_dump(mode="json", by_alias=True, exclude={"id_type"})
+                        for identifier in identifiers
+                    ],
+                    "ignoreUnknownIds": True,
+                },
+            )
+        )
+        if responses.has_failed:
+            return None
+        body = responses.get_first_body()
+        items_data = body.get("items", [])
+        if not isinstance(items_data, list):
+            return None
+        # MyPy does not understand that JsonVal is valid dict[Any, Any]
+        return [FileMetadata._load(item) for item in items_data]  # type: ignore[arg-type]
+
+    @staticmethod
+    def _as_metadata_map(metadata: Sequence[FileMetadata]) -> dict[FileIdentifier, FileMetadata]:
+        identifiers_map: dict[FileIdentifier, FileMetadata] = {}
+        for item in metadata:
+            if item.id is not None:
+                # MyPy does cooperate well with Pydantic.
+                identifiers_map[FileInternalID(internal_id=item.id)] = item  # type: ignore[call-arg]
+            if item.external_id is not None:
+                identifiers_map[FileExternalID(external_id=item.external_id)] = item
+            if item.instance_id is not None:
+                identifiers_map[
+                    FileInstanceID(
+                        instance_id=SelectorNodeId(
+                            space=item.instance_id.space, external_id=item.instance_id.external_id
+                        )
+                    )
+                ] = item
+        return identifiers_map
+
+    def _create_filepath(self, meta: FileMetadata, selector: FileIdentifierSelector) -> Path:
+        # We now that metadata always have name set
+        filename = Path(cast(str, meta.name))
+        if len(filename.suffix) == 0 and meta.mime_type:
+            if mime_ext := mimetypes.guess_extension(meta.mime_type):
+                filename = filename.with_suffix(mime_ext)
+        directory = selector.file_directory
+        if isinstance(meta.directory, str) and meta.directory != "":
+            directory = Path(meta.directory.removeprefix("/"))
+
+        counter = 1
+        filepath = self._target_dir / directory / filename
+        while filepath.exists():
+            filepath = self._target_dir / directory / f"{filename} ({counter})"
+            counter += 1
+
+        return filepath
+
+    def _retrieve_download_url(self, identifier: FileIdentifier) -> str | None:
+        config = self.client.config
+        responses = self.client.http_client.request_with_retries(
+            message=SimpleBodyRequest(
+                endpoint_url=config.create_api_url("/files/downloadlink"),
+                method="POST",
+                body_content={"items": [identifier.model_dump(mode="json", by_alias=True, exclude={"id_type"})]},
+            )
+        )
+        try:
+            body = responses.get_first_body()
+        except ValueError:
+            return None
+        if "items" in body and isinstance(body["items"], list) and len(body["items"]) > 0:
+            # The API responses is not following the API docs, this is a workaround
+            body = body["items"][0]  # type: ignore[assignment]
+        try:
+            return cast(str, body["downloadUrl"])
+        except (KeyError, IndexError):
+            return None
 
     def count(self, selector: FileContentSelector) -> int | None:
+        if isinstance(selector, FileIdentifierSelector):
+            return len(selector.identifiers)
         return None
 
     def data_to_json_chunk(
         self, data_chunk: Sequence[FileMetadata], selector: FileContentSelector | None = None
     ) -> list[dict[str, JsonVal]]:
-        raise NotImplementedError("Download of FileContent is not yet supported")
+        """Convert a writable Cognite resource list to a JSON-compatible chunk of data.
+
+        Args:
+            data_chunk: A writable Cognite resource list representing the data.
+            selector: The selector used for the data. (Not used in this implementation)
+        Returns:
+            A list of dictionaries, each representing the data in a JSON-compatible format.
+        """
+        result: list[dict[str, JsonVal]] = []
+        for item in data_chunk:
+            item_json = self._crud.dump_resource(item)
+            result.append(item_json)
+        return result
 
     def json_chunk_to_data(self, data_chunk: list[tuple[str, dict[str, JsonVal]]]) -> Sequence[UploadFileContentItem]:
         """Convert a JSON-compatible chunk of data back to a writable Cognite resource list.

{cognite_toolkit-0.7.12 → cognite_toolkit-0.7.14}/cognite_toolkit/_cdf_tk/storageio/selectors/__init__.py

@@ -17,6 +17,7 @@ from ._file_content import (
     FileContentSelector,
     FileDataModelingTemplate,
     FileDataModelingTemplateSelector,
+    FileIdentifierSelector,
     FileMetadataTemplate,
     FileMetadataTemplateSelector,
 )
@@ -43,7 +44,8 @@ Selector = Annotated[
     | ChartExternalIdSelector
     | CanvasExternalIdSelector
     | FileMetadataTemplateSelector
-    | FileDataModelingTemplateSelector,
+    | FileDataModelingTemplateSelector
+    | FileIdentifierSelector,
     Field(discriminator="type"),
 ]
 
@@ -67,6 +69,7 @@ __all__ = [
     "FileContentSelector",
     "FileDataModelingTemplate",
     "FileDataModelingTemplateSelector",
+    "FileIdentifierSelector",
     "FileMetadataTemplate",
     "FileMetadataTemplateSelector",
     "InstanceColumn",

{cognite_toolkit-0.7.12 → cognite_toolkit-0.7.14}/cognite_toolkit/_cdf_tk/storageio/selectors/_file_content.py

@@ -1,9 +1,12 @@
+import hashlib
 import json
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any, Literal
+from typing import Annotated, Any, Literal
 
-from pydantic import ConfigDict, field_validator, model_validator
+from pydantic import ConfigDict, Field, field_validator, model_validator
+
+from cognite_toolkit._cdf_tk.exceptions import ToolkitNotImplementedError
 
 from ._base import DataSelector, SelectorObject
 from ._instances import SelectedView
@@ -107,3 +110,57 @@ class FileDataModelingTemplateSelector(FileContentSelector):
 
     def create_instance(self, filepath: Path) -> dict[str, Any]:
         return self.template.create_instance(filepath.name)
+
+
+class FileIdentifierDefinition(SelectorObject):
+    id_type: str
+
+
+class FileInternalID(FileIdentifierDefinition):
+    id_type: Literal["internalId"] = "internalId"
+    internal_id: int = Field(alias="id")
+
+    def __str__(self) -> str:
+        return f"internalId_{self.internal_id}"
+
+
+class FileExternalID(FileIdentifierDefinition):
+    id_type: Literal["externalId"] = "externalId"
+    external_id: str
+
+    def __str__(self) -> str:
+        return f"externalId_{self.external_id}"
+
+
+class NodeId(SelectorObject):
+    space: str
+    external_id: str
+
+
+class FileInstanceID(FileIdentifierDefinition):
+    id_type: Literal["instanceId"] = "instanceId"
+    instance_id: NodeId
+
+    def __str__(self) -> str:
+        return f"instanceId_{self.instance_id.space}_{self.instance_id.external_id}"
+
+
+FileIdentifier = Annotated[FileInstanceID | FileExternalID | FileInternalID, Field(discriminator="id_type")]
+
+
+class FileIdentifierSelector(FileContentSelector):
+    type: Literal["fileIdentifier"] = "fileIdentifier"
+    file_directory: Path = Path("file_content")
+    use_metadata_directory: bool = True
+    identifiers: tuple[FileIdentifier, ...]
+
+    @property
+    def group(self) -> str:
+        return "Files"
+
+    def __str__(self) -> str:
+        hash_ = hashlib.md5(",".join(sorted(str(self.identifiers))).encode()).hexdigest()[:8]
+        return f"file_{len(self.identifiers)}_identifiers_{hash_}"
+
+    def create_instance(self, filepath: Path) -> dict[str, Any]:
+        raise ToolkitNotImplementedError("FileIdentifierSelector does not support creating instances from file paths.")

{cognite_toolkit-0.7.12 → cognite_toolkit-0.7.14}/cognite_toolkit/_cdf_tk/utils/http_client/_data_classes.py

@@ -338,6 +338,18 @@ class ResponseList(UserList[ResponseMessage | FailedRequestMessage]):
             error_messages += "; ".join(f"Request error: {err.error}" for err in failed_requests)
         raise ToolkitAPIError(f"One or more requests failed: {error_messages}")
 
+    @property
+    def has_failed(self) -> bool:
+        """Indicates whether any response in the list indicates a failure.
+
+        Returns:
+            bool: True if there are any failed responses or requests, False otherwise.
+        """
+        for resp in self.data:
+            if isinstance(resp, FailedResponse | FailedRequestMessage):
+                return True
+        return False
+
     def get_first_body(self) -> dict[str, JsonVal]:
         """Returns the body of the first successful response in the list.
 

{cognite_toolkit-0.7.12 → cognite_toolkit-0.7.14}/cognite_toolkit/_repo_files/GitHub/.github/workflows/deploy.yaml

@@ -12,7 +12,7 @@ jobs:
     environment: dev
     name: Deploy
     container:
-      image: cognite/toolkit:0.7.12
+      image: cognite/toolkit:0.7.14
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

{cognite_toolkit-0.7.12 → cognite_toolkit-0.7.14}/cognite_toolkit/_repo_files/GitHub/.github/workflows/dry-run.yaml

@@ -10,7 +10,7 @@ jobs:
     environment: dev
     name: Deploy Dry Run
     container:
-      image: cognite/toolkit:0.7.12
+      image: cognite/toolkit:0.7.14
       env:
         CDF_CLUSTER: ${{ vars.CDF_CLUSTER }}
         CDF_PROJECT: ${{ vars.CDF_PROJECT }}

{cognite_toolkit-0.7.12 → cognite_toolkit-0.7.14}/cognite_toolkit/_resources/cdf.toml

@@ -4,7 +4,7 @@ default_env = "<DEFAULT_ENV_PLACEHOLDER>"
 [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.12"
+version = "0.7.14"
 
 
 [plugins]

cognite_toolkit-0.7.14/cognite_toolkit/_version.py

@@ -0,0 +1 @@
+__version__ = "0.7.14"

cognite_toolkit-0.7.14/last_changelog_entry.md

@@ -0,0 +1,6 @@
+## Changelog 
+
+### Added
+
+- [alpha] Support for downloading files with content `cdf data download
+files`.

cognite_toolkit-0.7.14/last_git_message.txt

@@ -0,0 +1,20 @@
+[CDF-25331] ⬇ Download file content (#2270)
+
+# Description
+
+<img width="1031" height="253" alt="image"
+src="https://github.com/user-attachments/assets/336391a1-103f-429f-9440-0c1bb66974cc"
+/>
+
+
+## Bump
+
+- [x] Patch
+- [ ] Skip
+
+## Changelog
+
+### Added
+
+- [alpha] Support for downloading files with content `cdf data download
+files`.

cognite_toolkit-0.7.14/last_version.txt

@@ -0,0 +1 @@
+0.7.13