cognite-toolkit 0.6.84__py3-none-any.whl → 0.6.86__py3-none-any.whl

cognite_toolkit/_cdf_tk/apps/_purge.py

@@ -17,7 +17,7 @@ from cognite_toolkit._cdf_tk.storageio.selectors import (
 )
 from cognite_toolkit._cdf_tk.utils.auth import EnvironmentVariables
 from cognite_toolkit._cdf_tk.utils.cli_args import parse_view_str
-from cognite_toolkit._cdf_tk.utils.interactive_select import DataModelingSelect
+from cognite_toolkit._cdf_tk.utils.interactive_select import AssetInteractiveSelect, DataModelingSelect
 
 
 class InstanceTypeEnum(str, Enum):
@@ -39,8 +39,8 @@ class PurgeApp(typer.Typer):
         if ctx.invoked_subcommand is None:
             print("Use [bold yellow]cdf purge --help[/] for more information.")
 
+    @staticmethod
     def purge_dataset(
-        self,
         ctx: typer.Context,
         external_id: Annotated[
             str | None,
@@ -53,7 +53,46 @@ class PurgeApp(typer.Typer):
             typer.Option(
                 "--include-dataset",
                 "-i",
-                help="Include dataset in the purge. This will also archive the dataset.",
+                help="Whether to archive the dataset itself after purging its contents.",
+                hidden=Flags.v07.is_enabled(),
+            ),
+        ] = False,
+        archive_dataset: Annotated[
+            bool,
+            typer.Option(
+                "--archive-dataset",
+                help="Whether to archive the dataset itself after purging its contents.",
+                hidden=not Flags.v07.is_enabled(),
+            ),
+        ] = False,
+        skip_data: Annotated[
+            bool,
+            typer.Option(
+                "--skip-data",
+                "-s",
+                help="Skip deleting the data in the dataset, only delete configurations. The resources that are "
+                "considered data are: time series, event, files, assets, sequences, relationships, "
+                "labels, and 3D Models",
+                hidden=not Flags.v07.is_enabled(),
+            ),
+        ] = False,
+        include_configurations: Annotated[
+            bool,
+            typer.Option(
+                "--include-configurations",
+                "-c",
+                help="Include configurations, workflows, extraction pipelines and transformations in the purge.",
+                hidden=not Flags.v07.is_enabled(),
+            ),
+        ] = False,
+        asset_recursive: Annotated[
+            bool,
+            typer.Option(
+                "--asset-recursive",
+                "-a",
+                help="When deleting assets, delete all child assets recursively. CAVEAT: This can lead to assets"
+                " not in the selected dataset being deleted if they are children of assets in the dataset.",
+                hidden=not Flags.v07.is_enabled(),
             ),
         ] = False,
         dry_run: Annotated[
@@ -84,11 +123,52 @@ class PurgeApp(typer.Typer):
         """This command will delete the contents of the specified dataset"""
         cmd = PurgeCommand()
         client = EnvironmentVariables.create_from_environment().get_client()
+
+        if external_id is None:
+            # Is Interactive
+            interactive = AssetInteractiveSelect(client, operation="purge")
+            external_id = interactive.select_data_set(allow_empty=False)
+            if Flags.v07.is_enabled():
+                skip_data = not questionary.confirm(
+                    "Delete data in the dataset (time series, events, files, assets, sequences, relationships, labels, 3D models)?",
+                    default=True,
+                ).ask()
+                include_configurations = questionary.confirm(
+                    "Delete configurations (workflows, extraction pipelines and transformations) in the dataset?",
+                    default=False,
+                ).ask()
+                asset_recursive = questionary.confirm(
+                    "When deleting assets, delete all child assets recursively? (WARNING: This can lead "
+                    "to assets not in the selected dataset being deleted if they are children of assets in the dataset.)",
+                    default=False,
+                ).ask()
+            archive_dataset = questionary.confirm("Archive the dataset itself after purging?", default=False).ask()
+            dry_run = questionary.confirm("Dry run?", default=True).ask()
+            verbose = questionary.confirm("Verbose?", default=True).ask()
+
+            user_options = [archive_dataset, dry_run, verbose]
+            if Flags.v07.is_enabled():
+                user_options.extend([skip_data, include_configurations, asset_recursive])
+
+            if any(selected is None for selected in user_options):
+                raise typer.Abort("Aborted by user.")
+
+        else:
+            archive_dataset = archive_dataset if Flags.v07.is_enabled() else include_dataset
+
+        if not Flags.v07.is_enabled():
+            skip_data = False
+            include_configurations = True
+            asset_recursive = False
+
         cmd.run(
             lambda: cmd.dataset(
                 client,
                 external_id,
-                include_dataset,
+                archive_dataset,
+                not skip_data,
+                include_configurations,
+                asset_recursive,
                 dry_run,
                 auto_yes,
                 verbose,

cognite_toolkit/_cdf_tk/commands/_download.py

@@ -1,4 +1,4 @@
-from collections.abc import Iterable
+from collections.abc import Callable, Iterable
 from functools import partial
 from pathlib import Path
 
@@ -42,7 +42,7 @@ class DownloadCommand(ToolkitCommand):
 
         console = io.client.console
         for selector in selectors:
-            target_dir = output_dir / selector.group
+            target_dir = output_dir / sanitize_filename(selector.group)
             if verbose:
                 console.print(f"Downloading {selector.display_name} '{selector!s}' to {target_dir.as_posix()!r}")
 
@@ -57,9 +57,10 @@ class DownloadCommand(ToolkitCommand):
 
             selector.dump_to_file(target_dir)
             columns: list[SchemaColumn] | None = None
-            if file_format in TABLE_WRITE_CLS_BY_FORMAT and isinstance(io, TableStorageIO):
+            is_table = file_format in TABLE_WRITE_CLS_BY_FORMAT
+            if is_table and isinstance(io, TableStorageIO):
                 columns = io.get_schema(selector)
-            elif file_format in TABLE_WRITE_CLS_BY_FORMAT:
+            elif is_table:
                 raise ToolkitValueError(
                     f"Cannot download {selector.kind} in {file_format!r} format. The {selector.kind!r} storage type does not support table schemas."
                 )
@@ -69,7 +70,7 @@ class DownloadCommand(ToolkitCommand):
             ) as writer:
                 executor = ProducerWorkerExecutor[Page[T_CogniteResource], list[dict[str, JsonVal]]](
                     download_iterable=io.stream_data(selector, limit),
-                    process=partial(self.process_data_chunk, io=io, selector=selector),
+                    process=self.create_data_process(io=io, selector=selector, is_table=is_table),
                     write=partial(writer.write_chunks, filestem=filestem),
                     iteration_count=iteration_count,
                     # Limit queue size to avoid filling up memory before the workers can write to disk.
@@ -124,19 +125,20 @@ class DownloadCommand(ToolkitCommand):
         return False
 
     @staticmethod
-    def process_data_chunk(
-        data_page: Page[T_CogniteResource],
+    def create_data_process(
         io: StorageIO[T_Selector, T_CogniteResource],
         selector: T_Selector,
-    ) -> list[dict[str, JsonVal]]:
-        """Processes a chunk of data by converting it to a JSON-compatible format.
+        is_table: bool,
+    ) -> Callable[[Page[T_CogniteResource]], list[dict[str, JsonVal]]]:
+        """Creates a data processing function based on the IO type and whether the output is a table."""
+        if is_table and isinstance(io, TableStorageIO):
 
-        Args:
-            data_page: The page of data to process.
-            io: The StorageIO instance that defines how to process the data.
-            selector: The selection criteria used to identify the data.
+            def row_data_process(chunk: Page[T_CogniteResource]) -> list[dict[str, JsonVal]]:
+                return io.data_to_row(chunk.items, selector)
 
-        Returns:
-            A list of dictionaries representing the processed data in a JSON-compatible format.
-        """
-        return io.data_to_json_chunk(data_page.items, selector)
+            return row_data_process
+
+        def chunk_data_process(data_page: Page[T_CogniteResource]) -> list[dict[str, JsonVal]]:
+            return io.data_to_json_chunk(data_page.items, selector)
+
+        return chunk_data_process