cognite-toolkit 0.6.97__py3-none-any.whl → 0.7.39__py3-none-any.whl

cognite_toolkit/_cdf_tk/apps/_download_app.py

@@ -2,32 +2,57 @@ from enum import Enum
 from pathlib import Path
 from typing import Annotated, Any
 
+import questionary
 import typer
+from questionary import Choice
 from rich import print
 
-from cognite_toolkit._cdf_tk.client.data_classes.raw import RawTable
+from cognite_toolkit._cdf_tk.client.data_classes.legacy.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,
+    DatapointsIO,
+    DataSelector,
+    EventIO,
+    FileContentIO,
+    FileMetadataIO,
     HierarchyIO,
     InstanceIO,
     RawIO,
+    StorageIO,
+    TimeSeriesIO,
 )
 from cognite_toolkit._cdf_tk.storageio.selectors import (
-    AssetCentricSelector,
     AssetSubtreeSelector,
+    CanvasExternalIdSelector,
+    CanvasSelector,
+    ChartExternalIdSelector,
+    ChartSelector,
+    DataPointsDataSetSelector,
     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,
     AssetInteractiveSelect,
     DataModelingSelect,
+    EventInteractiveSelect,
+    FileMetadataInteractiveSelect,
+    InteractiveCanvasSelect,
+    InteractiveChartSelect,
     RawTableInteractiveSelect,
+    TimeSeriesInteractiveSelect,
 )
 
 
@@ -42,14 +67,36 @@ class AssetCentricFormats(str, Enum):
     ndjson = "ndjson"
 
 
+class FileContentFormats(str, Enum):
+    ndjson = "ndjson"
+
+
 class HierarchyFormats(str, Enum):
     ndjson = "ndjson"
 
 
+class DatapointFormats(str, Enum):
+    csv = "csv"
+    parquet = "parquet"
+
+
+class DatapointsDataTypes(str, Enum):
+    numeric = "numeric"
+    string = "string"
+
+
 class InstanceFormats(str, Enum):
     ndjson = "ndjson"
 
 
+class ChartFormats(str, Enum):
+    ndjson = "ndjson"
+
+
+class CanvasFormats(str, Enum):
+    ndjson = "ndjson"
+
+
 class InstanceTypes(str, Enum):
     node = "node"
     edge = "edge"
@@ -69,8 +116,15 @@ class DownloadApp(typer.Typer):
         self.callback(invoke_without_command=True)(self.download_main)
         self.command("raw")(self.download_raw_cmd)
         self.command("assets")(self.download_assets_cmd)
+        self.command("timeseries")(self.download_timeseries_cmd)
+        self.command("events")(self.download_events_cmd)
+        self.command("files")(self.download_files_cmd)
         self.command("hierarchy")(self.download_hierarchy_cmd)
+        if Flags.EXTEND_DOWNLOAD.is_enabled():
+            self.command("datapoints")(self.download_datapoints_cmd)
         self.command("instances")(self.download_instances_cmd)
+        self.command("charts")(self.download_charts_cmd)
+        self.command("canvas")(self.download_canvas_cmd)
 
     @staticmethod
     def download_main(ctx: typer.Context) -> None:
@@ -169,23 +223,15 @@ class DownloadApp(typer.Typer):
             )
         )
 
-    @staticmethod
     def download_assets_cmd(
+        self,
         ctx: typer.Context,
         data_sets: Annotated[
             list[str] | None,
             typer.Option(
                 "--data-set",
                 "-d",
-                help="List of data sets to download assets from. If this and hierarchy are not provided, an interactive selection will be made.",
-            ),
-        ] = None,
-        hierarchy: Annotated[
-            list[str] | None,
-            typer.Option(
-                "--hierarchy",
-                "-r",
-                help="List of asset hierarchies to download assets from. If this and data sets are not provided, an interactive selection will be made.",
+                help="List of data sets to download assets from. If this is not provided, an interactive selection will be made.",
             ),
         ] = None,
         file_format: Annotated[
@@ -232,20 +278,17 @@ class DownloadApp(typer.Typer):
     ) -> None:
         """This command will download assets from CDF into a temporary directory."""
         client = EnvironmentVariables.create_from_environment().get_client()
-        is_interactive = not data_sets and not hierarchy
-        if is_interactive:
-            interactive = AssetInteractiveSelect(client, "download assets")
-            selector_type = interactive.select_hierarchies_or_data_sets()
-            if selector_type == "Data Set":
-                data_sets = interactive.select_data_sets()
-            else:
-                hierarchy = interactive.select_hierarchies()
+        if data_sets is None:
+            data_sets, file_format, compression, output_dir, limit = self._asset_centric_interactive(
+                AssetInteractiveSelect(client, "download"),
+                file_format,
+                compression,
+                output_dir,
+                limit,
+                "assets",
+            )
 
-        selectors: list[AssetCentricSelector] = []
-        if data_sets:
-            selectors.extend([DataSetSelector(data_set_external_id=ds, kind="Assets") for ds in data_sets])
-        if hierarchy:
-            selectors.extend([AssetSubtreeSelector(hierarchy=h, kind="Assets") for h in hierarchy])
+        selectors = [DataSetSelector(kind="Assets", data_set_external_id=data_set) for data_set in data_sets]
         cmd = DownloadCommand()
         cmd.run(
             lambda: cmd.download(
@@ -259,6 +302,341 @@ class DownloadApp(typer.Typer):
             )
         )
 
+    @classmethod
+    def _asset_centric_interactive(
+        cls,
+        selector: AssetCentricInteractiveSelect,
+        file_format: AssetCentricFormats,
+        compression: CompressionFormat,
+        output_dir: Path,
+        limit: int,
+        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()
+        file_format = questionary.select(
+            f"Select format to download the {display_name} in:",
+            choices=[Choice(title=format_.value, value=format_) for format_ in available_formats],
+            default=file_format,
+        ).ask()
+        compression = questionary.select(
+            f"Select compression format to use when downloading the {display_name}:",
+            choices=[Choice(title=comp.value, value=comp) for comp in CompressionFormat],
+            default=compression,
+        ).ask()
+        output_dir = Path(
+            questionary.path(
+                f"Where to download the {display_name}:",
+                default=str(output_dir),
+                only_directories=True,
+            ).ask()
+        )
+        while True:
+            limit_str = questionary.text(
+                f"The maximum number of {display_name} to download from each dataset. Use -1 to download all {display_name}.",
+                default=str(limit),
+            ).ask()
+            if limit_str is None:
+                raise typer.Abort()
+            try:
+                limit = int(limit_str)
+            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(
+        self,
+        ctx: typer.Context,
+        data_sets: Annotated[
+            list[str] | None,
+            typer.Option(
+                "--data-set",
+                "-d",
+                help="List of data sets to download time series from. If this is not provided, an interactive selection will be made.",
+            ),
+        ] = None,
+        file_format: Annotated[
+            AssetCentricFormats,
+            typer.Option(
+                "--format",
+                "-f",
+                help="Format to download the time series in.",
+            ),
+        ] = AssetCentricFormats.csv,
+        compression: Annotated[
+            CompressionFormat,
+            typer.Option(
+                "--compression",
+                "-z",
+                help="Compression format to use when downloading the time series.",
+            ),
+        ] = CompressionFormat.none,
+        output_dir: Annotated[
+            Path,
+            typer.Option(
+                "--output-dir",
+                "-o",
+                help="Where to download the time series.",
+                allow_dash=True,
+            ),
+        ] = DEFAULT_DOWNLOAD_DIR,
+        limit: Annotated[
+            int,
+            typer.Option(
+                "--limit",
+                "-l",
+                help="The maximum number of time series to download from each dataset. Use -1 to download all time series.",
+            ),
+        ] = 100_000,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """This command will download time series from CDF into a temporary directory."""
+        client = EnvironmentVariables.create_from_environment().get_client()
+        if data_sets is None:
+            data_sets, file_format, compression, output_dir, limit = self._asset_centric_interactive(
+                TimeSeriesInteractiveSelect(client, "download"),
+                file_format,
+                compression,
+                output_dir,
+                limit,
+                "time series",
+            )
+
+        selectors = [DataSetSelector(kind="TimeSeries", data_set_external_id=data_set) for data_set in data_sets]
+        cmd = DownloadCommand()
+        cmd.run(
+            lambda: cmd.download(
+                selectors=selectors,
+                io=TimeSeriesIO(client),
+                output_dir=output_dir,
+                file_format=f".{file_format.value}",
+                compression=compression.value,
+                limit=limit if limit != -1 else None,
+                verbose=verbose,
+            )
+        )
+
+    def download_events_cmd(
+        self,
+        ctx: typer.Context,
+        data_sets: Annotated[
+            list[str] | None,
+            typer.Option(
+                "--data-set",
+                "-d",
+                help="List of data sets to download events from. If this is not provided, an interactive selection will be made.",
+            ),
+        ] = None,
+        file_format: Annotated[
+            AssetCentricFormats,
+            typer.Option(
+                "--format",
+                "-f",
+                help="Format to download the events in.",
+            ),
+        ] = AssetCentricFormats.csv,
+        compression: Annotated[
+            CompressionFormat,
+            typer.Option(
+                "--compression",
+                "-z",
+                help="Compression format to use when downloading the events.",
+            ),
+        ] = CompressionFormat.none,
+        output_dir: Annotated[
+            Path,
+            typer.Option(
+                "--output-dir",
+                "-o",
+                help="Where to download the events.",
+                allow_dash=True,
+            ),
+        ] = DEFAULT_DOWNLOAD_DIR,
+        limit: Annotated[
+            int,
+            typer.Option(
+                "--limit",
+                "-l",
+                help="The maximum number of events to download from each dataset. Use -1 to download all events.",
+            ),
+        ] = 100_000,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """This command will download events from CDF into a temporary directory."""
+        client = EnvironmentVariables.create_from_environment().get_client()
+        if data_sets is None:
+            data_sets, file_format, compression, output_dir, limit = self._asset_centric_interactive(
+                EventInteractiveSelect(client, "download"),
+                file_format,
+                compression,
+                output_dir,
+                limit,
+                "events",
+            )
+
+        selectors = [DataSetSelector(kind="Events", data_set_external_id=data_set) for data_set in data_sets]
+        cmd = DownloadCommand()
+
+        cmd.run(
+            lambda: cmd.download(
+                selectors=selectors,
+                io=EventIO(client),
+                output_dir=output_dir,
+                file_format=f".{file_format.value}",
+                compression=compression.value,
+                limit=limit if limit != -1 else None,
+                verbose=verbose,
+            )
+        )
+
+    def download_files_cmd(
+        self,
+        ctx: typer.Context,
+        data_sets: Annotated[
+            list[str] | None,
+            typer.Option(
+                "--data-set",
+                "-d",
+                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(
+                "--format",
+                "-f",
+                help="Format to download the file metadata in.",
+            ),
+        ] = AssetCentricFormats.csv,
+        compression: Annotated[
+            CompressionFormat,
+            typer.Option(
+                "--compression",
+                "-z",
+                help="Compression format to use when downloading the file metadata.",
+            ),
+        ] = CompressionFormat.none,
+        output_dir: Annotated[
+            Path,
+            typer.Option(
+                "--output-dir",
+                "-o",
+                help="Where to download the file metadata.",
+                allow_dash=True,
+            ),
+        ] = DEFAULT_DOWNLOAD_DIR,
+        limit: Annotated[
+            int,
+            typer.Option(
+                "--limit",
+                "-l",
+                help="The maximum number of file metadata to download from each dataset. Use -1 to download all file metadata.",
+            ),
+        ] = 100_000,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """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 if not include_file_contents else 1000,
+                "file metadata",
+                max_limit=1000 if include_file_contents else None,
+                available_formats=available_formats,
+            )
+
+        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])
+            )
+            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,  # type: ignore[misc]
+                io=io,
+                output_dir=output_dir,
+                file_format=f".{file_format.value}",
+                compression=compression.value,
+                limit=limit if limit != -1 else None,
+                verbose=verbose,
+            )
+        )
+
     @staticmethod
     def download_hierarchy_cmd(
         ctx: typer.Context,
@@ -476,3 +854,293 @@ class DownloadApp(typer.Typer):
                 verbose=verbose,
             )
         )
+
+    @staticmethod
+    def download_datapoints_cmd(
+        dataset: Annotated[
+            str | None,
+            typer.Argument(
+                help="The dataset to download timeseries from. If not provided, an interactive selection will be made.",
+            ),
+        ] = None,
+        start_time: Annotated[
+            str | None,
+            typer.Option(
+                "--start-time",
+                "-s",
+                help="The start time for the datapoints to download. Can be in RFC3339 format or as a relative time (e.g., '1d-ago'). If not provided, all datapoints from the beginning will be downloaded.",
+            ),
+        ] = None,
+        end_time: Annotated[
+            str | None,
+            typer.Option(
+                "--end-time",
+                "-e",
+                help="The end time for the datapoints to download. Can be in RFC3339 format or as a relative time (e.g., '1d-ago'). If not provided, all datapoints up to the latest will be downloaded.",
+            ),
+        ] = None,
+        datapoint_type: Annotated[
+            DatapointsDataTypes,
+            typer.Option(
+                "--data-type",
+                "-d",
+                help="The type of datapoints to download.",
+            ),
+        ] = DatapointsDataTypes.numeric,
+        file_format: Annotated[
+            DatapointFormats,
+            typer.Option(
+                "--format",
+                "-f",
+                help="Format for downloading the datapoints.",
+            ),
+        ] = DatapointFormats.csv,
+        output_dir: Annotated[
+            Path,
+            typer.Option(
+                "--output-dir",
+                "-o",
+                help="Where to download the datapoints.",
+                allow_dash=True,
+            ),
+        ] = DEFAULT_DOWNLOAD_DIR,
+        limit: Annotated[
+            int,
+            typer.Option(
+                "--limit",
+                "-l",
+                help="The maximum number of timeseries to download datapoints from. Use -1 to download all timeseries."
+                "The maximum number of datapoints in total is 10 million and 100 000 per timeseries.",
+                max=10_000_000,
+            ),
+        ] = 1000,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """This command will download Datapoints from CDF into a temporary ."""
+        client = EnvironmentVariables.create_from_environment().get_client()
+        if dataset is None:
+            interactive = TimeSeriesInteractiveSelect(client, "download datapoints")
+            dataset = interactive.select_data_set(allow_empty=False)
+
+            datapoint_type = questionary.select(
+                "Select the type of datapoints to download:",
+                choices=[Choice(title=dt.value, value=dt) for dt in DatapointsDataTypes],
+                default=datapoint_type,
+            ).ask()
+
+            start_time = (
+                questionary.text(
+                    "Enter the start time for the datapoints to download (RFC3339 format or relative time, e.g., '1d-ago'). Leave empty to download from the beginning.",
+                    default=start_time or "",
+                ).ask()
+                or None
+            )
+            end_time = (
+                questionary.text(
+                    "Enter the end time for the datapoints to download (RFC3339 format or relative time, e.g., '1d-ago'). Leave empty to download up to the latest.",
+                    default=end_time or "",
+                ).ask()
+                or None
+            )
+            file_format = questionary.select(
+                "Select format to download the datapoints in:",
+                choices=[Choice(title=format_.value, value=format_) for format_ in DatapointFormats],
+                default=file_format,
+            ).ask()
+            output_dir = Path(
+                questionary.path(
+                    "Where to download the datapoints:", default=str(output_dir), only_directories=True
+                ).ask()
+            )
+            while True:
+                limit_str = questionary.text(
+                    "The maximum number of timeseries to download datapoints from. Use -1 to download all timeseries."
+                    "The maximum number of datapoints in total is 10 million and 100 000 per timeseries.",
+                    default=str(limit),
+                ).ask()
+                if limit_str is None:
+                    raise typer.Abort()
+                try:
+                    limit = int(limit_str)
+                except ValueError:
+                    print("[red]Please enter a valid integer for the limit.[/]")
+                else:
+                    if limit != -1 and limit < 1:
+                        print("[red]Please enter a valid integer greater than 0 or -1 for unlimited.[/]")
+                    else:
+                        break
+                verbose = questionary.confirm(
+                    "Turn on to get more verbose output when running the command?", default=verbose
+                ).ask()
+
+        cmd = DownloadCommand()
+        selector = DataPointsDataSetSelector(
+            data_set_external_id=dataset,
+            start=start_time,
+            end=end_time,
+            data_type=datapoint_type.value,
+        )
+        cmd.run(
+            lambda: cmd.download(
+                selectors=[selector],
+                io=DatapointsIO(client),
+                output_dir=output_dir,
+                file_format=f".{file_format.value}",
+                compression="none",
+                limit=limit if limit != -1 else None,
+                verbose=verbose,
+            )
+        )
+
+    @staticmethod
+    def download_charts_cmd(
+        ctx: typer.Context,
+        external_ids: Annotated[
+            list[str] | None,
+            typer.Argument(
+                help="List of chart external IDs to download. If not provided, an interactive selection will be made.",
+            ),
+        ] = None,
+        file_format: Annotated[
+            ChartFormats,
+            typer.Option(
+                "--format",
+                "-f",
+                help="Format for downloading the charts.",
+            ),
+        ] = ChartFormats.ndjson,
+        compression: Annotated[
+            CompressionFormat,
+            typer.Option(
+                "--compression",
+                "-z",
+                help="Compression format to use when downloading the instances.",
+            ),
+        ] = CompressionFormat.none,
+        output_dir: Annotated[
+            Path,
+            typer.Option(
+                "--output-dir",
+                "-o",
+                help="Where to download the charts.",
+                allow_dash=True,
+            ),
+        ] = DEFAULT_DOWNLOAD_DIR,
+        limit: Annotated[
+            int,
+            typer.Option(
+                "--limit",
+                "-l",
+                help="The maximum number of charts to download. Use -1 to download all charts.",
+            ),
+        ] = 1000,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """This command will download Charts from CDF into a temporary directory."""
+        cmd = DownloadCommand()
+        client = EnvironmentVariables.create_from_environment().get_client()
+        selector: ChartSelector
+        if external_ids is None:
+            selected_external_ids = InteractiveChartSelect(client).select_external_ids()
+            selector = ChartExternalIdSelector(external_ids=tuple(selected_external_ids))
+        else:
+            selector = ChartExternalIdSelector(external_ids=tuple(external_ids))
+
+        cmd.run(
+            lambda: cmd.download(
+                selectors=[selector],
+                io=ChartIO(client),
+                output_dir=output_dir,
+                file_format=f".{file_format.value}",
+                compression=compression.value,
+                limit=limit if limit != -1 else None,
+                verbose=verbose,
+            )
+        )
+
+    @staticmethod
+    def download_canvas_cmd(
+        ctx: typer.Context,
+        external_ids: Annotated[
+            list[str] | None,
+            typer.Argument(
+                help="List of canvas external IDs to download. If not provided, an interactive selection will be made.",
+            ),
+        ] = None,
+        file_format: Annotated[
+            CanvasFormats,
+            typer.Option(
+                "--format",
+                "-f",
+                help="Format for downloading the canvas.",
+            ),
+        ] = CanvasFormats.ndjson,
+        compression: Annotated[
+            CompressionFormat,
+            typer.Option(
+                "--compression",
+                "-z",
+                help="Compression format to use when downloading the canvas.",
+            ),
+        ] = CompressionFormat.none,
+        output_dir: Annotated[
+            Path,
+            typer.Option(
+                "--output-dir",
+                "-o",
+                help="Where to download the canvas.",
+                allow_dash=True,
+            ),
+        ] = DEFAULT_DOWNLOAD_DIR,
+        limit: Annotated[
+            int,
+            typer.Option(
+                "--limit",
+                "-l",
+                help="The maximum number of canvas to download. Use -1 to download all canvas.",
+            ),
+        ] = 1000,
+        verbose: Annotated[
+            bool,
+            typer.Option(
+                "--verbose",
+                "-v",
+                help="Turn on to get more verbose output when running the command",
+            ),
+        ] = False,
+    ) -> None:
+        """This command will download Canvas from CDF into a temporary directory."""
+        cmd = DownloadCommand()
+        client = EnvironmentVariables.create_from_environment().get_client()
+        selector: CanvasSelector
+        if external_ids is None:
+            selected_external_ids = InteractiveCanvasSelect(client).select_external_ids()
+            selector = CanvasExternalIdSelector(external_ids=tuple(selected_external_ids))
+        else:
+            selector = CanvasExternalIdSelector(external_ids=tuple(external_ids))
+
+        cmd.run(
+            lambda: cmd.download(
+                selectors=[selector],
+                io=CanvasIO(client),
+                output_dir=output_dir,
+                file_format=f".{file_format.value}",
+                compression=compression.value,
+                limit=limit if limit != -1 else None,
+                verbose=verbose,
+            )
+        )