cognite-toolkit 0.5.44__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/commands/dump_resource.py

@@ -1,5 +1,9 @@
+import io
+import json
+import zipfile
 from abc import ABC, abstractmethod
-from collections.abc import Hashable, Iterable, Iterator
+from collections import defaultdict
+from collections.abc import Hashable, Iterable, Iterator, Sequence
 from functools import cached_property
 from pathlib import Path
 from typing import Generic, cast
@@ -8,16 +12,30 @@ import questionary
 import typer
 from cognite.client import data_modeling as dm
 from cognite.client.data_classes import (
+    DataSetList,
+    ExtractionPipelineList,
     Group,
     GroupList,
     TransformationList,
     TransformationNotificationList,
     TransformationScheduleList,
+    filters,
 )
 from cognite.client.data_classes._base import (
+    CogniteResource,
     CogniteResourceList,
 )
+from cognite.client.data_classes.agents import (
+    AgentList,
+)
 from cognite.client.data_classes.data_modeling import DataModelId
+from cognite.client.data_classes.documents import SourceFileProperty
+from cognite.client.data_classes.extractionpipelines import ExtractionPipelineConfigList
+from cognite.client.data_classes.functions import (
+    Function,
+    FunctionList,
+    FunctionSchedulesList,
+)
 from cognite.client.data_classes.workflows import (
     Workflow,
     WorkflowList,
@@ -27,41 +45,57 @@ from cognite.client.data_classes.workflows import (
     WorkflowVersionList,
 )
 from cognite.client.exceptions import CogniteAPIError
+from cognite.client.utils import ms_to_datetime
 from questionary import Choice
 from rich import print
+from rich.console import Console
 from rich.panel import Panel
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.location_filters import LocationFilterList
+from cognite_toolkit._cdf_tk.client.data_classes.search_config import SearchConfigList
+from cognite_toolkit._cdf_tk.client.data_classes.search_config import ViewId as SearchConfigViewId
+from cognite_toolkit._cdf_tk.client.data_classes.streamlit_ import Streamlit, StreamlitList
+from cognite_toolkit._cdf_tk.cruds import (
+    AgentCRUD,
+    ContainerCRUD,
+    DataModelCRUD,
+    DataSetsCRUD,
+    ExtractionPipelineConfigCRUD,
+    ExtractionPipelineCRUD,
+    FunctionCRUD,
+    FunctionScheduleCRUD,
+    GroupCRUD,
+    LocationFilterCRUD,
+    NodeCRUD,
+    ResourceCRUD,
+    SearchConfigCRUD,
+    SpaceCRUD,
+    StreamlitCRUD,
+    TransformationCRUD,
+    TransformationNotificationCRUD,
+    TransformationScheduleCRUD,
+    ViewCRUD,
+    WorkflowCRUD,
+    WorkflowTriggerCRUD,
+    WorkflowVersionCRUD,
+)
+from cognite_toolkit._cdf_tk.cruds._base_cruds import T_ID
 from cognite_toolkit._cdf_tk.exceptions import (
     ResourceRetrievalError,
     ToolkitMissingResourceError,
     ToolkitResourceMissingError,
     ToolkitValueError,
 )
-from cognite_toolkit._cdf_tk.loaders import (
-    ContainerLoader,
-    DataModelLoader,
-    GroupLoader,
-    LocationFilterLoader,
-    NodeLoader,
-    ResourceLoader,
-    SpaceLoader,
-    TransformationLoader,
-    TransformationNotificationLoader,
-    TransformationScheduleLoader,
-    ViewLoader,
-    WorkflowLoader,
-    WorkflowTriggerLoader,
-    WorkflowVersionLoader,
-)
-from cognite_toolkit._cdf_tk.loaders._base_loaders import T_ID
-from cognite_toolkit._cdf_tk.tk_warnings import FileExistsWarning, MediumSeverityWarning
+from cognite_toolkit._cdf_tk.tk_warnings import FileExistsWarning, HighSeverityWarning, MediumSeverityWarning
 from cognite_toolkit._cdf_tk.utils import humanize_collection
-from cognite_toolkit._cdf_tk.utils.file import safe_rmtree, safe_write, yaml_safe_dump
+from cognite_toolkit._cdf_tk.utils.file import safe_rmtree, safe_write, sanitize_filename, yaml_safe_dump
+from cognite_toolkit._cdf_tk.utils.interactive_select import DataModelingSelect
 
 from ._base import ToolkitCommand
 
+_INTERACTIVE_SELECT_HELPER_TEXT = " Use arrow keys to navigate and space key to select. Press enter to confirm."
+
 
 class ResourceFinder(Iterable, ABC, Generic[T_ID]):
     def __init__(self, client: ToolkitClient, identifier: T_ID | None = None):
@@ -72,7 +106,7 @@ class ResourceFinder(Iterable, ABC, Generic[T_ID]):
         return self.identifier or self._interactive_select()
 
     @abstractmethod
-    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceLoader, None | str]]:
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
         raise NotImplementedError
 
     @abstractmethod
@@ -80,7 +114,7 @@ class ResourceFinder(Iterable, ABC, Generic[T_ID]):
         raise NotImplementedError
 
     # Can be implemented in subclasses
-    def update(self, resources: CogniteResourceList) -> None: ...
+    def update(self, resources: Sequence[CogniteResource]) -> None: ...
 
 
 class DataModelFinder(ResourceFinder[DataModelId]):
@@ -137,12 +171,15 @@ class DataModelFinder(ResourceFinder[DataModelId]):
 
         selected_model = questionary.select(
             "Which version would you like to dump?",
-            [Choice(f"{version}", value=model) for version, model in models_by_version.items()],
+            [
+                Choice(f"{version} ({len(model.views)} views)", value=version)
+                for version, model in models_by_version.items()
+            ],
         ).ask()
         self.data_model = models_by_version[selected_model]
         return self.data_model.as_id()
 
-    def update(self, resources: CogniteResourceList) -> None:
+    def update(self, resources: Sequence[CogniteResource]) -> None:
         if isinstance(resources, dm.DataModelList):
             self.view_ids |= {
                 view.as_id() if isinstance(view, dm.View) else view for item in resources for view in item.views
@@ -151,11 +188,11 @@ class DataModelFinder(ResourceFinder[DataModelId]):
             self.container_ids |= resources.referenced_containers()
         elif isinstance(resources, dm.SpaceList):
             return
-        self.space_ids |= {item.space for item in resources}
+        self.space_ids |= {item.space for item in resources if hasattr(item, "space")}
 
-    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceLoader, None | str]]:
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
         self.identifier = self._selected()
-        model_loader = DataModelLoader.create_loader(self.client)
+        model_loader = DataModelCRUD.create_loader(self.client)
         if self.data_model:
             is_global_model = self.data_model.is_global
             yield [], dm.DataModelList([self.data_model]), model_loader, None
@@ -166,14 +203,14 @@ class DataModelFinder(ResourceFinder[DataModelId]):
             is_global_model = model_list[0].is_global
             yield [], model_list, model_loader, None
         if self._include_global or is_global_model:
-            yield list(self.view_ids), None, ViewLoader.create_loader(self.client), "views"
-            yield list(self.container_ids), None, ContainerLoader.create_loader(self.client), "containers"
-            yield list(self.space_ids), None, SpaceLoader.create_loader(self.client), None
+            yield list(self.view_ids), None, ViewCRUD.create_loader(self.client), "views"
+            yield list(self.container_ids), None, ContainerCRUD.create_loader(self.client), "containers"
+            yield list(self.space_ids), None, SpaceCRUD.create_loader(self.client), None
         else:
-            view_loader = ViewLoader(self.client, None, None, topological_sort_implements=True)
+            view_loader = ViewCRUD(self.client, None, None, topological_sort_implements=True)
             views = dm.ViewList([view for view in view_loader.retrieve(list(self.view_ids)) if not view.is_global])
             yield [], views, view_loader, "views"
-            container_loader = ContainerLoader.create_loader(self.client)
+            container_loader = ContainerCRUD.create_loader(self.client)
             containers = dm.ContainerList(
                 [
                     container
@@ -183,7 +220,7 @@ class DataModelFinder(ResourceFinder[DataModelId]):
             )
             yield [], containers, container_loader, "containers"
 
-            space_loader = SpaceLoader.create_loader(self.client)
+            space_loader = SpaceCRUD.create_loader(self.client)
             spaces = dm.SpaceList(
                 [space for space in space_loader.retrieve(list(self.space_ids)) if not space.is_global]
             )
@@ -226,22 +263,22 @@ class WorkflowFinder(ResourceFinder[WorkflowVersionId]):
                 break
         return selected_version
 
-    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceLoader, None | str]]:
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
         self.identifier = self._selected()
         if self._workflow:
-            yield [], WorkflowList([self._workflow]), WorkflowLoader.create_loader(self.client), None
+            yield [], WorkflowList([self._workflow]), WorkflowCRUD.create_loader(self.client), None
         else:
-            yield [self.identifier.workflow_external_id], None, WorkflowLoader.create_loader(self.client), None
+            yield [self.identifier.workflow_external_id], None, WorkflowCRUD.create_loader(self.client), None
         if self._workflow_version:
             yield (
                 [],
                 WorkflowVersionList([self._workflow_version]),
-                WorkflowVersionLoader.create_loader(self.client),
+                WorkflowVersionCRUD.create_loader(self.client),
                 None,
             )
         else:
-            yield [self.identifier], None, WorkflowVersionLoader.create_loader(self.client), None
-        trigger_loader = WorkflowTriggerLoader.create_loader(self.client)
+            yield [self.identifier], None, WorkflowVersionCRUD.create_loader(self.client), None
+        trigger_loader = WorkflowTriggerCRUD.create_loader(self.client)
         trigger_list = WorkflowTriggerList(
             list(trigger_loader.iterate(parent_ids=[self.identifier.workflow_external_id]))
         )
@@ -273,58 +310,100 @@ class TransformationFinder(ResourceFinder[tuple[str, ...]]):
             "Which transformation(s) would you like to dump?",
             choices=choices,
         ).ask()
-        if selected_transformation_ids is None:
-            raise ToolkitValueError("No transformations selected for dumping.")
+        if not selected_transformation_ids:
+            raise ToolkitValueError(f"No transformations selected for dumping.{_INTERACTIVE_SELECT_HELPER_TEXT}")
         return tuple(selected_transformation_ids)
 
-    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceLoader, None | str]]:
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
         self.identifier = self._selected()
         if self.transformations:
             yield (
                 [],
                 TransformationList([t for t in self.transformations if t.external_id in self.identifier]),
-                TransformationLoader.create_loader(self.client),
+                TransformationCRUD.create_loader(self.client),
                 None,
             )
         else:
-            yield list(self.identifier), None, TransformationLoader.create_loader(self.client), None
+            yield list(self.identifier), None, TransformationCRUD.create_loader(self.client), None
 
-        schedule_loader = TransformationScheduleLoader.create_loader(self.client)
-        schedule_list = TransformationScheduleList(schedule_loader.iterate(parent_ids=list(self.identifier)))
+        schedule_loader = TransformationScheduleCRUD.create_loader(self.client)
+        schedule_list = TransformationScheduleList(list(schedule_loader.iterate(parent_ids=list(self.identifier))))
         yield [], schedule_list, schedule_loader, None
-        notification_loader = TransformationNotificationLoader.create_loader(self.client)
+        notification_loader = TransformationNotificationCRUD.create_loader(self.client)
         notification_list = TransformationNotificationList(
-            notification_loader.iterate(parent_ids=list(self.identifier))
+            list(notification_loader.iterate(parent_ids=list(self.identifier)))
         )
         yield [], notification_list, notification_loader, None
 
 
-class GroupFinder(ResourceFinder[str]):
-    def __init__(self, client: ToolkitClient, identifier: str | None = None):
+class GroupFinder(ResourceFinder[tuple[str, ...]]):
+    def __init__(self, client: ToolkitClient, identifier: tuple[str, ...] | None = None):
         super().__init__(client, identifier)
-        self.group: Group | None = None
+        self.groups: list[Group] | None = None
 
-    def _interactive_select(self) -> str:
+    def _interactive_select(self) -> tuple[str, ...]:
         groups = self.client.iam.groups.list(all=True)
         if not groups:
             raise ToolkitMissingResourceError("No groups found")
-        group_names = [group.name for group in groups]
-        selected_group_name: str = questionary.select(
-            "Which group would you like to dump?",
-            [Choice(group, value=group) for group in group_names],
-        ).ask()
+        groups_by_name: dict[str, list[Group]] = defaultdict(list)
         for group in groups:
-            if group.name == selected_group_name:
-                self.group = group
-                break
-        return selected_group_name
+            groups_by_name[group.name].append(group)
+        selected_groups: list[list[Group]] | None = questionary.checkbox(
+            "Which group(s) would you like to dump?",
+            choices=[
+                Choice(f"{group_name} ({len(group_list)} group{'s' if len(group_list) > 1 else ''})", value=group_list)
+                for group_name, group_list in sorted(groups_by_name.items())
+            ],
+        ).ask()
+        if not selected_groups:
+            raise ToolkitValueError(f"No group selected for dumping.{_INTERACTIVE_SELECT_HELPER_TEXT}")
+        self.groups = [group for group_list in selected_groups for group in group_list]
+        return tuple(group_list[0].name for group_list in selected_groups)
 
-    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceLoader, None | str]]:
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
         self.identifier = self._selected()
-        if self.group:
-            yield [], GroupList([self.group]), GroupLoader.create_loader(self.client), None
+        if self.groups:
+            yield [], GroupList(self.groups), GroupCRUD.create_loader(self.client), None
+        else:
+            yield list(self.identifier), None, GroupCRUD.create_loader(self.client), None
+
+
+class AgentFinder(ResourceFinder[tuple[str, ...]]):
+    def __init__(self, client: ToolkitClient, identifier: tuple[str, ...] | None = None):
+        super().__init__(client, identifier)
+        self.agents: AgentList | None = None
+
+    def _interactive_select(self) -> tuple[str, ...]:
+        self.agents = self.client.agents.list()
+        if not self.agents:
+            raise ToolkitMissingResourceError("No agents found")
+
+        choices = [
+            Choice(f"{agent.name} ({agent.external_id}) with {len(agent.tools)} tools", value=agent.external_id)
+            for agent in sorted(self.agents, key=lambda a: a.name or a.external_id)
+            if agent.external_id
+        ]
+
+        selected_agent_ids: list[str] | None = questionary.checkbox(
+            "Which agent(s) would you like to dump?",
+            choices=choices,
+        ).ask()
+        if not selected_agent_ids:
+            raise ToolkitValueError(f"No agents selected for dumping.{_INTERACTIVE_SELECT_HELPER_TEXT}")
+        return tuple(selected_agent_ids)
+
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
+        self.identifier = self._selected()
+        loader = AgentCRUD.create_loader(self.client)
+        if self.agents:
+            yield (
+                [],
+                AgentList([agent for agent in self.agents if agent.external_id in self.identifier]),
+                loader,
+                None,
+            )
         else:
-            yield [self.identifier], None, GroupLoader.create_loader(self.client), None
+            yield list(self.identifier), None, loader, None
 
 
 class NodeFinder(ResourceFinder[dm.ViewId]):
@@ -352,9 +431,9 @@ class NodeFinder(ResourceFinder[dm.ViewId]):
         ).ask()
         return selected_view_id
 
-    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceLoader, None | str]]:
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
         self.identifier = self._selected()
-        loader = NodeLoader(self.client, None, None, self.identifier)
+        loader = NodeCRUD(self.client, None, None, self.identifier)
         if self.is_interactive:
             count = self.client.data_modeling.instances.aggregate(
                 self.identifier, dm.aggregations.Count("externalId"), instance_type="node"
@@ -374,19 +453,20 @@ class NodeFinder(ResourceFinder[dm.ViewId]):
 class LocationFilterFinder(ResourceFinder[tuple[str, ...]]):
     @cached_property
     def all_filters(self) -> LocationFilterList:
-        return self.client.location_filters.list()
+        return self.client.search.locations.list()
 
     def _interactive_select(self) -> tuple[str, ...]:
         filters = self.all_filters
         if not filters:
             raise ToolkitMissingResourceError("No filters found")
         id_by_display_name = {f"{filter.name} ({filter.external_id})": filter.external_id for filter in filters}
-        return tuple(
-            questionary.checkbox(
-                "Which filters would you like to dump?",
-                choices=[Choice(name, value=id_) for name, id_ in id_by_display_name.items()],
-            ).ask()
-        )
+        selected_filter_ids: tuple[str, ...] | None = questionary.checkbox(
+            "Which filters would you like to dump?",
+            choices=[Choice(name, value=id_) for name, id_ in id_by_display_name.items()],
+        ).ask()
+        if not selected_filter_ids:
+            raise ToolkitValueError(f"No filters selected for dumping.{_INTERACTIVE_SELECT_HELPER_TEXT}")
+        return tuple(selected_filter_ids)
 
     def _get_filters(self, identifiers: tuple[str, ...]) -> LocationFilterList:
         if not identifiers:
@@ -396,10 +476,314 @@ class LocationFilterFinder(ResourceFinder[tuple[str, ...]]):
             raise ToolkitResourceMissingError(f"Location filters {identifiers} not found", str(identifiers))
         return LocationFilterList(filters)
 
-    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceLoader, None | str]]:
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
         self.identifier = self.identifier or self._interactive_select()
         filters = self._get_filters(self.identifier)
-        yield [], filters, LocationFilterLoader.create_loader(self.client), None
+        yield [], filters, LocationFilterCRUD.create_loader(self.client), None
+
+
+class ExtractionPipelineFinder(ResourceFinder[tuple[str, ...]]):
+    def __init__(self, client: ToolkitClient, identifier: tuple[str, ...] | None = None):
+        super().__init__(client, identifier)
+        self.extraction_pipelines: ExtractionPipelineList | None = None
+
+    def _interactive_select(self) -> tuple[str, ...]:
+        self.extraction_pipelines = self.client.extraction_pipelines.list(limit=-1)
+        if not self.extraction_pipelines:
+            raise ToolkitMissingResourceError("No extraction pipelines found")
+        choices = [
+            Choice(f"{pipeline.name} ({pipeline.external_id})", value=pipeline.external_id)
+            for pipeline in sorted(self.extraction_pipelines, key=lambda p: p.name or "")
+            if pipeline.external_id
+        ]
+        selected_pipeline_ids: tuple[str, ...] | None = questionary.checkbox(
+            "Which extraction pipeline(s) would you like to dump?",
+            choices=choices,
+        ).ask()
+        if not selected_pipeline_ids:
+            raise ToolkitValueError(f"No extraction pipelines selected for dumping.{_INTERACTIVE_SELECT_HELPER_TEXT}")
+        return tuple(selected_pipeline_ids)
+
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
+        self.identifier = self._selected()
+        pipeline_loader = ExtractionPipelineCRUD.create_loader(self.client)
+        if self.extraction_pipelines:
+            selected_pipelines = ExtractionPipelineList(
+                [p for p in self.extraction_pipelines if p.external_id in self.identifier]
+            )
+            yield [], selected_pipelines, pipeline_loader, None
+        else:
+            yield list(self.identifier), None, pipeline_loader, None
+        config_loader = ExtractionPipelineConfigCRUD.create_loader(self.client)
+        configs = ExtractionPipelineConfigList(list(config_loader.iterate(parent_ids=list(self.identifier))))
+        yield [], configs, config_loader, None
+
+
+class DataSetFinder(ResourceFinder[tuple[str, ...]]):
+    """Finds data sets to dump."""
+
+    def __init__(self, client: ToolkitClient, identifier: tuple[str, ...] | None = None):
+        super().__init__(client, identifier)
+        self.datasets: DataSetList | None = None
+
+    def _interactive_select(self) -> tuple[str, ...]:
+        self.datasets = self.client.data_sets.list(limit=-1)
+        if not self.datasets:
+            raise ToolkitMissingResourceError("No datasets found")
+        choices = [
+            Choice(f"{dataset.name} ({dataset.external_id})", value=dataset.external_id)
+            for dataset in sorted(self.datasets, key=lambda d: d.name or "")
+            if dataset.external_id
+        ]
+        selected_dataset_ids: tuple[str, ...] | None = questionary.checkbox(
+            "Which dataset(s) would you like to dump?",
+            choices=choices,
+        ).ask()
+        if not selected_dataset_ids:
+            raise ToolkitValueError(f"No datasets selected for dumping.{_INTERACTIVE_SELECT_HELPER_TEXT}")
+        return tuple(selected_dataset_ids)
+
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
+        self.identifier = self._selected()
+        loader = DataSetsCRUD.create_loader(self.client)
+        if self.datasets:
+            yield (
+                [],
+                DataSetList([d for d in self.datasets if d.external_id in set(self.identifier)]),
+                loader,
+                None,
+            )
+        else:
+            yield list(self.identifier), None, loader, None
+
+
+class FunctionFinder(ResourceFinder[tuple[str, ...]]):
+    def __init__(self, client: ToolkitClient, identifier: tuple[str, ...] | None = None):
+        super().__init__(client, identifier)
+        self.functions: FunctionList | None = None
+
+    def _interactive_select(self) -> tuple[str, ...]:
+        self.functions = self.client.functions.list(limit=-1)
+        if not self.functions:
+            raise ToolkitMissingResourceError("No functions found")
+        choices = [
+            Choice(f"{function.name} ({function.external_id})", value=function.external_id)
+            for function in sorted(self.functions, key=lambda f: f.name or "")
+            if function.name and function.external_id
+        ]
+        selected_function_ids: tuple[str, ...] | None = questionary.checkbox(
+            "Which function(s) would you like to dump?",
+            choices=choices,
+        ).ask()
+        if not selected_function_ids:
+            raise ToolkitValueError(f"No functions selected for dumping.{_INTERACTIVE_SELECT_HELPER_TEXT}")
+        return tuple(selected_function_ids)
+
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
+        self.identifier = self._selected()
+        loader = FunctionCRUD.create_loader(self.client)
+        if self.functions:
+            selected_functions = FunctionList([f for f in self.functions if f.external_id in self.identifier])
+            yield [], selected_functions, loader, None
+        else:
+            yield list(self.identifier), None, loader, None
+
+        schedule_loader = FunctionScheduleCRUD.create_loader(self.client)
+        schedules = schedule_loader.iterate(parent_ids=list(self.identifier))
+        yield [], FunctionSchedulesList(list(schedules)), schedule_loader, None
+
+    def dump_function_code(self, function: Function, folder: Path) -> None:
+        try:
+            zip_bytes = self.client.files.download_bytes(id=function.file_id)
+        except CogniteAPIError as e:
+            if e.code == 400 and "File ids not found" in e.message:
+                HighSeverityWarning(
+                    f"The function {function.external_id!r} does not have code to dump. It is not available in CDF."
+                ).print_warning()
+                return
+            raise
+        try:
+            top_level = f"{sanitize_filename(function.external_id or 'unknown_external_id')}/"
+            with zipfile.ZipFile(io.BytesIO(zip_bytes)) as zf:
+                if all(name.startswith(top_level) for name in zf.namelist()):
+                    zf.extractall(folder)
+                else:
+                    zf.extractall(folder / top_level)
+        except zipfile.BadZipFile as e:
+            HighSeverityWarning(
+                f"The function {function.external_id!r} has a corrupted code zip file. Unable to extract code: {e!s}"
+            ).print_warning()
+
+
+class StreamlitFinder(ResourceFinder[tuple[str, ...]]):
+    def __init__(self, client: ToolkitClient, identifier: tuple[str, ...] | None = None):
+        super().__init__(client, identifier)
+        self.apps: StreamlitList | None = None
+
+    def _interactive_select(self) -> tuple[str, ...]:
+        """Interactively select one or more Streamlit apps to dump."""
+        result = self.client.documents.aggregate_unique_values(
+            SourceFileProperty.metadata_key("creator"),
+            filter=filters.Equals(SourceFileProperty.directory, "/streamlit-apps/"),
+        )
+        if not result:
+            raise ToolkitMissingResourceError("No Streamlit apps found")
+
+        selected_creator = questionary.select(
+            "Who is the creator of the Streamlit app you would like to dump? [name (app count)]",
+            choices=[
+                Choice(f"{item.value} ({item.count})", value=item.value)
+                for item in sorted(result, key=lambda r: (r.count, str(r.value) or ""))
+            ],
+        ).ask()
+        files = self.client.files.list(
+            limit=-1, directory_prefix="/streamlit-apps/", metadata={"creator": str(selected_creator)}
+        )
+        self.apps = StreamlitList([Streamlit.from_file(file) for file in files if file.name and file.external_id])
+        if missing := [file for file in files if not file.external_id or file.name]:
+            MediumSeverityWarning(
+                f"{len(missing)} file(s) in /streamlit-apps/ are missing "
+                f"either name or external ID and will be skipped. File IDs: {humanize_collection([file.id for file in missing])}",
+            ).print_warning()
+        selected_ids: list[str] | None = questionary.checkbox(
+            message="Which Streamlit app(s) would you like to dump?",
+            choices=[
+                Choice(
+                    title=f"{app.name} ({app.creator} - {ms_to_datetime(app.last_updated_time)})", value=app.external_id
+                )
+                for app in sorted(self.apps, key=lambda a: a.name)
+            ],
+        ).ask()
+        if not selected_ids:
+            raise ToolkitValueError(f"No Streamlit app selected for dumping.{_INTERACTIVE_SELECT_HELPER_TEXT}")
+        return tuple(selected_ids)
+
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
+        identifier = self.identifier or self._interactive_select()
+        loader = StreamlitCRUD.create_loader(self.client)
+        # If the user used interactive select, we have already downloaded the streamlit apps,
+        # Thus, we do not need to download them again. If not pass the identifier and let the main logic
+        # take care of the download.
+        if self.apps:
+            yield [], StreamlitList([app for app in self.apps if app.external_id in identifier]), loader, None
+        else:
+            yield list(identifier), None, loader, None
+
+    def dump_code(self, app: Streamlit, folder: Path, console: Console | None = None) -> None:
+        """Dump the code of a Streamlit app to the specified folder.
+
+        The code is extracted from the JSON content of the app file in CDF.
+
+        Args:
+            app (Streamlit): The Streamlit app whose code is to be dumped.
+            folder (Path): The directory where the app code will be saved.
+            console (Console | None): Optional Rich console for printing warnings.
+        """
+        try:
+            content = self.client.files.download_bytes(external_id=app.external_id)
+        except CogniteAPIError as e:
+            if e.code == 400 and e.missing:
+                HighSeverityWarning(
+                    f"The source code for {app.external_id!r} could not be retrieved from CDF."
+                ).print_warning(console=console)
+                return
+            raise
+
+        try:
+            json_content = json.loads(content)
+        except json.JSONDecodeError as e:
+            HighSeverityWarning(
+                f"The JSON content for the Streamlit app {app.external_id!r} is corrupt and could not be extracted. "
+                f"Download file with the same external id manually to remediate. {e!s}"
+            ).print_warning(console=console)
+            return
+
+        app_folder = sanitize_filename(app.external_id)
+        app_path = folder / app_folder
+        app_path.mkdir(exist_ok=True)
+        if isinstance(json_content.get("requirements"), list):
+            requirements_txt = app_path / "requirements.txt"
+            requirements = json_content["requirements"]
+            if not requirements:
+                HighSeverityWarning(
+                    f"The Streamlit app {app.external_id!r} has a requirements.txt file with no content. Skipping..."
+                ).print_warning()
+            else:
+                requirements_txt.write_text("\n".join(requirements), encoding="utf-8")
+        files = json_content.get("files", {})
+        if not isinstance(files, dict) or (not files):
+            HighSeverityWarning(
+                f"The Streamlit app {app.external_id!r} does not have any files to dump. It is likely corrupted."
+            ).print_warning(console=console)
+            return
+        created_files: set[str] = set()
+        for relative_filepath, content in files.items():
+            filepath = app_path / relative_filepath
+            filepath.parent.mkdir(parents=True, exist_ok=True)
+            file_content = content.get("content", {}).get("text", "")
+            if not isinstance(file_content, str):
+                HighSeverityWarning(
+                    f"The Streamlit app {app.external_id!r} has a file {relative_filepath} with invalid content. Skipping..."
+                ).print_warning(console=console)
+                continue
+            safe_write(filepath, file_content, encoding="utf-8")
+            created_files.add(relative_filepath)
+
+        entry_point = json_content.get("entrypoint")
+        if entry_point and entry_point not in created_files:
+            HighSeverityWarning(
+                f"The Streamlit app {app.external_id!r} has an entry point {entry_point} that was not found in the files. "
+                "The app may be corrupted."
+            ).print_warning(console=console)
+
+
+class SpaceFinder(ResourceFinder[tuple[str, ...]]):
+    def __init__(self, client: ToolkitClient, identifier: tuple[str, ...] | None = None):
+        super().__init__(client, identifier)
+
+    def _interactive_select(self) -> tuple[str, ...]:
+        # Using new interactive select component for selecting instance spaces
+        # This will raise a ToolkitValueError if no instance spaces are selected and this is handled in the caller.
+        data_modeling_select = DataModelingSelect(self.client, "dump")
+        selected_spaces = data_modeling_select.select_instance_space(
+            multiselect=True, message="Which instance space(s) would you like to dump?"
+        )
+        return tuple(selected_spaces)
+
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
+        self.identifier = self._selected()
+        loader = SpaceCRUD.create_loader(self.client)
+        yield list(self.identifier), None, loader, None
+
+
+class SearchConfigFinder(ResourceFinder[tuple[SearchConfigViewId, ...]]):
+    def __init__(self, client: ToolkitClient, identifier: tuple[SearchConfigViewId, ...] | None = None):
+        super().__init__(client, identifier)
+        self.search_configs: SearchConfigList | None = None
+
+    def _interactive_select(self) -> tuple[SearchConfigViewId, ...]:
+        self.search_configs = self.client.search.configurations.list()
+        if not self.search_configs:
+            raise ToolkitMissingResourceError("No search configurations found!")
+        choices = [
+            Choice(f"{config.view.external_id} {config.view.space}", value=config.view)
+            for config in self.search_configs
+        ]
+        selected_view_ids: list[SearchConfigViewId] | None = questionary.checkbox(
+            "For which view would you like to dump the search configuration?",
+            choices=choices,
+        ).ask()
+        if not selected_view_ids:
+            raise ToolkitValueError("No view selected for dumping the search configuration.")
+        return tuple(selected_view_ids)
+
+    def __iter__(self) -> Iterator[tuple[list[Hashable], CogniteResourceList | None, ResourceCRUD, None | str]]:
+        self.identifier = self._selected()
+        loader = SearchConfigCRUD.create_loader(self.client)
+        if self.search_configs:
+            yield [], SearchConfigList([sc for sc in self.search_configs if sc.view in self.identifier]), loader, None
+        else:
+            yield list(self.identifier), None, loader, None
 
 
 class DumpResourceCommand(ToolkitCommand):
@@ -420,6 +804,8 @@ class DumpResourceCommand(ToolkitCommand):
         elif not output_dir.exists():
             output_dir.mkdir(exist_ok=True)
 
+        dumped_ids: list[Hashable] = []
+        resources: Sequence[CogniteResource] | None = None
         for identifiers, resources, loader, subfolder in finder:
             if not identifiers and not resources:
                 # No resources to dump
@@ -440,7 +826,8 @@ class DumpResourceCommand(ToolkitCommand):
                 resource_folder = resource_folder / subfolder
             resource_folder.mkdir(exist_ok=True, parents=True)
             for resource in resources:
-                name = loader.as_str(loader.get_id(resource))
+                resource_id = loader.get_id(resource)
+                name = loader.as_str(resource_id)
                 base_filepath = resource_folder / f"{name}.{loader.kind}.yaml"
                 if base_filepath.exists():
                     self.warn(FileExistsWarning(base_filepath, "Skipping... Use --clean to remove existing files."))
@@ -451,5 +838,9 @@ class DumpResourceCommand(ToolkitCommand):
                     safe_write(filepath, content, encoding="utf-8")
                     if verbose:
                         self.console(f"Dumped {loader.kind} {name} to {filepath!s}")
-
-        print(Panel(f"Dumped {finder.identifier}", title="Success", style="green", expand=False))
+                if isinstance(finder, FunctionFinder) and isinstance(resource, Function):
+                    finder.dump_function_code(resource, resource_folder)
+                if isinstance(finder, StreamlitFinder) and isinstance(resource, Streamlit):
+                    finder.dump_code(resource, resource_folder)
+                dumped_ids.append(resource_id)
+        print(Panel(f"Dumped {humanize_collection(dumped_ids)}", title="Success", style="green", expand=False))