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

cognite_toolkit/_cdf_tk/utils/interactive_select.py

@@ -3,23 +3,29 @@ from collections import defaultdict
 from collections.abc import Sequence
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
-from functools import lru_cache, partial
+from functools import cached_property, lru_cache, partial
 from typing import ClassVar, Literal, TypeVar, get_args, overload
 
 import questionary
 from cognite.client.data_classes import (
     Asset,
     DataSet,
+    UserProfileList,
     filters,
 )
 from cognite.client.data_classes.aggregations import Count
-from cognite.client.data_classes.data_modeling import NodeList, Space, SpaceList, View, ViewId
-from cognite.client.exceptions import CogniteException
+from cognite.client.data_classes.data_modeling import ContainerId, NodeList, Space, SpaceList, View, ViewId, ViewList
+from cognite.client.data_classes.data_modeling.statistics import SpaceStatistics
+from cognite.client.utils import ms_to_datetime
 from questionary import Choice
 from rich.console import Console
 
 from cognite_toolkit._cdf_tk.client import ToolkitClient
 from cognite_toolkit._cdf_tk.client.data_classes.canvas import Canvas
+from cognite_toolkit._cdf_tk.client.data_classes.charts import Chart, ChartList, Visibility
+from cognite_toolkit._cdf_tk.client.data_classes.migration import ResourceViewMapping
+from cognite_toolkit._cdf_tk.client.data_classes.raw import RawTable
+from cognite_toolkit._cdf_tk.client.data_classes.three_d import ThreeDModelResponse
 from cognite_toolkit._cdf_tk.exceptions import ToolkitMissingResourceError, ToolkitValueError
 
 from . import humanize_collection
@@ -115,11 +121,7 @@ class AssetCentricInteractiveSelect(ABC):
         return self._select("data sets", options, False, "multiple")
 
     def select_hierarchies_and_data_sets(self) -> tuple[list[str], list[str]]:
-        what = questionary.select(
-            f"Do you want to {self.operation} a hierarchy or a data set?", choices=["Hierarchy", "Data Set"]
-        ).ask()
-        if what is None:
-            raise ToolkitValueError("No selection made. Aborting.")
+        what = self.select_hierarchies_or_data_sets()
         if what == "Hierarchy":
             hierarchy = self._select("hierarchy", self._get_available_hierarchies(), False, "single")
             data_sets = self._get_available_data_sets(hierarchy=hierarchy)
@@ -134,8 +136,16 @@ class AssetCentricInteractiveSelect(ABC):
                 return [], [data_set]
             selected_hierarchies = self._select(f"hierarchies in data set {data_set!r} ", hierarchies, True, "multiple")
             return selected_hierarchies or [], [data_set]
-        else:
+
+    def select_hierarchies_or_data_sets(self) -> Literal["Hierarchy", "Data Set"]:
+        what = questionary.select(
+            f"Do you want to {self.operation} a hierarchy or a data set?", choices=["Hierarchy", "Data Set"]
+        ).ask()
+        if what is None:
+            raise ToolkitValueError("No selection made. Aborting.")
+        if what not in ["Hierarchy", "Data Set"]:
             raise ToolkitValueError(f"Unexpected selection: {what}. Aborting.")
+        return what
 
     @overload
     def _select(
@@ -229,6 +239,51 @@ class EventInteractiveSelect(AssetCentricInteractiveSelect):
         return EventAggregator(self.client)
 
 
+class RawTableInteractiveSelect:
+    def __init__(self, client: ToolkitClient, operation: str) -> None:
+        self.client = client
+        self.operation = operation
+
+    def _available_databases(self) -> list[str]:
+        databases = self.client.raw.databases.list(limit=-1)
+        return [db.name for db in databases if db.name is not None]
+
+    def _available_tables(self, database: str) -> list[RawTable]:
+        tables = self.client.raw.tables.list(db_name=database, limit=-1)
+        return [RawTable(database, table.name) for table in tables if table.name is not None]
+
+    def select_tables(self, database: str | None = None) -> list[RawTable]:
+        """Interactively select raw tables."""
+        databases = self._available_databases()
+        if not databases:
+            raise ToolkitValueError("No raw databases available. Aborting.")
+        if database and database not in databases:
+            raise ToolkitValueError(
+                f"Database '{database}' not found in available raw databases: {databases}. Aborting."
+            )
+        elif database:
+            selected_database = database
+        else:
+            selected_database = questionary.select(
+                f"Select a Raw Database to {self.operation}",
+                choices=[questionary.Choice(title=db, value=db) for db in databases],
+            ).ask()
+        if selected_database is None:
+            raise ToolkitValueError("No database selected. Aborting.")
+        available_tables = self._available_tables(selected_database)
+        if not available_tables:
+            raise ToolkitValueError(f"No raw tables available in database '{selected_database}'. Aborting.")
+
+        selected_tables = questionary.checkbox(
+            f"Select Raw Tables in {selected_database} to {self.operation}",
+            choices=[questionary.Choice(title=f"{table.table_name}", value=table) for table in available_tables],
+        ).ask()
+
+        if selected_tables is None:
+            raise ToolkitValueError("No tables selected. Aborting.")
+        return selected_tables
+
+
 @dataclass
 class CanvasFilter:
     visibility: Literal["public", "private"] | None = None
@@ -252,9 +307,14 @@ class InteractiveCanvasSelect:
     opening_choices: ClassVar[list[questionary.Choice]] = [
         questionary.Choice(title="All public Canvases", value=CanvasFilter(visibility="public", select_all=True)),
         questionary.Choice(title="Selected public Canvases", value=CanvasFilter(visibility="public", select_all=False)),
-        questionary.Choice(title="All by given user", value=CanvasFilter(created_by="user", select_all=True)),
-        questionary.Choice(title="Selected by given user", value=CanvasFilter(created_by="user", select_all=False)),
-        questionary.Choice(title="All Canvases", value=CanvasFilter(visibility=None, select_all=True)),
+        questionary.Choice(
+            title="All public Canvases by given user",
+            value=CanvasFilter(created_by="user", select_all=True, visibility="public"),
+        ),
+        questionary.Choice(
+            title="Selected public Canvases by given user",
+            value=CanvasFilter(created_by="user", select_all=False, visibility="public"),
+        ),
     ]
 
     def __init__(self, client: ToolkitClient) -> None:
@@ -316,6 +376,85 @@ class InteractiveCanvasSelect:
         return selected_canvases or []
 
 
+@dataclass
+class ChartFilter:
+    visibility: Visibility | None = None
+    owned_by: Literal["user"] | None = None
+    select_all: bool = False
+
+
+class InteractiveChartSelect:
+    opening_choices: ClassVar[list[questionary.Choice]] = [
+        questionary.Choice(title="All public Charts", value=ChartFilter(visibility="PUBLIC", select_all=True)),
+        questionary.Choice(title="Selected public Charts", value=ChartFilter(visibility="PUBLIC", select_all=False)),
+        questionary.Choice(title="All owned by given user", value=ChartFilter(owned_by="user", select_all=True)),
+        questionary.Choice(title="Selected owned by given user", value=ChartFilter(owned_by="user", select_all=False)),
+    ]
+
+    def __init__(self, client: ToolkitClient) -> None:
+        self.client = client
+
+    def select_external_ids(self) -> list[str]:
+        select_filter = self._select_filter()
+        return self._select_external_ids(select_filter)
+
+    @classmethod
+    def _select_filter(cls) -> ChartFilter:
+        user_response = questionary.select(
+            "Which Charts do you want to select?",
+            choices=cls.opening_choices,
+        ).ask()
+        if user_response is None:
+            raise ToolkitValueError("No Chart selection made. Aborting.")
+        return user_response
+
+    def _select_external_ids(self, select_filter: ChartFilter) -> list[str]:
+        available_charts = self.client.charts.list(visibility=(select_filter.visibility or "PUBLIC"))
+        if select_filter.select_all and select_filter.owned_by is None:
+            return [chart.external_id for chart in available_charts]
+
+        users = self.client.iam.user_profiles.list(limit=-1)
+        display_name_by_user_identifier = {
+            user.user_identifier: user.display_name for user in users if user.display_name
+        }
+        if select_filter.owned_by == "user":
+            available_charts = self._select_charts_by_user(available_charts, users)
+        if select_filter.select_all:
+            return [chart.external_id for chart in available_charts]
+        selected_charts = questionary.checkbox(
+            "Select Charts",
+            choices=[
+                questionary.Choice(
+                    title=f"{chart.data.name} (Created by "
+                    f"{display_name_by_user_identifier.get(chart.owner_id, 'missing')!r} "
+                    f"- {ms_to_datetime(chart.last_updated_time)})",
+                    value=chart.external_id,
+                )
+                for chart in available_charts
+            ],
+        ).ask()
+        return selected_charts or []
+
+    @classmethod
+    def _select_charts_by_user(cls, available_charts: ChartList, users: UserProfileList) -> ChartList:
+        chart_by_user: dict[str, list[Chart]] = defaultdict(list)
+        for chart in available_charts:
+            chart_by_user[chart.owner_id].append(chart)
+        user_response = questionary.select(
+            "Which user do you want to select Charts for?",
+            choices=[
+                questionary.Choice(
+                    title=f"{user.display_name} ({user.user_identifier})",
+                    value=chart_by_user[user.user_identifier],
+                )
+                for user in users
+                if user.user_identifier in chart_by_user
+            ],
+        ).ask()
+        available_charts = ChartList(user_response)
+        return available_charts
+
+
 class AssetCentricDestinationSelect:
     valid_destinations: tuple[str, ...] = get_args(AssetCentricDestinationType)
 
@@ -338,7 +477,7 @@ class AssetCentricDestinationSelect:
         if destination_type is None:
             raise ToolkitValueError("No destination type selected. Aborting.")
         # We only input valid destination types, so we can safely skip MyPy's type checking here
-        return destination_type  # type: ignore[return-value]
+        return destination_type
 
     @classmethod
     def get(cls, destination_type: str | None = None) -> AssetCentricDestinationType:
@@ -357,32 +496,114 @@ class DataModelingSelect:
         self.console = console or Console()
         self._available_spaces: SpaceList | None = None
 
-    def select_view(self, include_global: bool = False) -> View:
-        selected_space = self.select_space(
-            include_global, message=f"In which Spaces is the view you will use to select instances to {self.operation}?"
+    @cached_property
+    def stats_by_space(self) -> dict[str, SpaceStatistics]:
+        result = self.client.data_modeling.statistics.spaces.list()
+        return {stat.space: stat for stat in result}
+
+    @overload
+    def select_view(
+        self,
+        multiselect: Literal[False] = False,
+        include_global: bool = False,
+        space: str | None = None,
+        message: str | None = None,
+        instance_type: Literal["node", "edge", "all"] | None = None,
+        mapped_container: ContainerId | None = None,
+    ) -> View: ...
+
+    @overload
+    def select_view(
+        self,
+        multiselect: Literal[True],
+        include_global: bool = False,
+        space: str | None = None,
+        message: str | None = None,
+        instance_type: Literal["node", "edge", "all"] | None = None,
+        mapped_container: ContainerId | None = None,
+    ) -> ViewList: ...
+
+    def select_view(
+        self,
+        multiselect: bool = False,
+        include_global: bool = False,
+        space: str | None = None,
+        message: str | None = None,
+        instance_type: Literal["node", "edge", "all"] | None = None,
+        mapped_container: ContainerId | None = None,
+    ) -> View | ViewList:
+        """Select one or more views interactively.
+
+        Args:
+            multiselect: Whether to allow selecting multiple views.
+            include_global: Whether to include global views in the selection.
+            space: The space to select views from. If None, the user will be prompted to
+                select a space.
+            message: The message to display when prompting for a view. If None, a default message
+                will be used.
+            instance_type: If 'node' or 'edge', only views of that type will be shown.
+            mapped_container: Only selects view(s) that are mapping the given container.
+
+        Returns:
+            The selected view(s).
+
+        Raises:
+            ToolkitValueError: If no view(s) are selected or if the selected view(s) are not valid.
+            ToolkitMissingResourceError: If no views are found in the selected space.
+
+        """
+        selected_space = (
+            space
+            or self.select_schema_space(
+                include_global,
+                message=f"In which Spaces is the view you will use to select instances to {self.operation}?",
+            ).space
         )
+
         views = self.client.data_modeling.views.list(
-            space=selected_space.space,
+            space=selected_space,
             include_inherited_properties=True,
             limit=-1,
             include_global=include_global,
         )
+        views = ViewList(
+            [
+                view
+                for view in views
+                if instance_type in (None, "all", view.used_for)
+                and (mapped_container is None or mapped_container in view.referenced_containers())
+            ]
+        )
         if not views:
-            raise ToolkitMissingResourceError(f"No views found in space {selected_space.space!r}.")
-
-        selected_view = questionary.select(
-            f"Which view do you want to use to select instances to {self.operation}?",
-            [Choice(title=f"{view.external_id} (version={view.version})", value=view) for view in views],
-        ).ask()
-        if selected_view is None:
-            raise ToolkitValueError("No view selected")
-        if not isinstance(selected_view, View):
-            raise ToolkitValueError(f"Selected view is not a valid View object: {selected_view!r}")
-        return selected_view
+            raise ToolkitMissingResourceError(f"No views found in space {selected_space!r}.")
+        question = message or f"Which view do you want to use to select instances to {self.operation}?"
+        choices = [Choice(title=f"{view.external_id} (version={view.version})", value=view) for view in views]
+        if multiselect:
+            selected_views = questionary.checkbox(question, choices=choices).ask()
+        else:
+            selected_views = questionary.select(question, choices=choices).ask()
+        if selected_views is None:
+            raise ToolkitValueError("No view(s) selected")
+        if multiselect:
+            if not isinstance(selected_views, list) or not all(isinstance(v, View) for v in selected_views):
+                raise ToolkitValueError(f"Selected views is not a valid list of View objects: {selected_views!r}")
+            return ViewList(selected_views)
+        else:
+            if not isinstance(selected_views, View):
+                raise ToolkitValueError(f"Selected view is not a valid View object: {selected_views!r}")
+            return selected_views
 
-    def select_space(self, include_global: bool, message: str | None = None) -> Space:
+    def select_schema_space(self, include_global: bool, message: str | None = None) -> Space:
         message = message or f"Select the space to {self.operation}:"
         spaces = self._get_available_spaces(include_global)
+        schema_spaces = {
+            space
+            for space, stats in self.stats_by_space.items()
+            if (stats.containers + stats.views + stats.data_models) > 0
+        }
+        spaces = SpaceList([space for space in spaces if space.space in schema_spaces or space.is_global])
+        if not spaces:
+            raise ToolkitMissingResourceError("No spaces with schema (containers, views, or data models) found.")
         selected_space = questionary.select(
             message,
             [Choice(title=space.space, value=space) for space in sorted(spaces, key=lambda s: s.space)],
@@ -393,8 +614,19 @@ class DataModelingSelect:
             raise ToolkitValueError(f"Selected space is not a valid Space object: {selected_space!r}")
         return selected_space
 
-    def select_instance_type(self, view_used_for: Literal["node", "edge", "all"]) -> Literal["node", "edge"]:
-        if view_used_for != "all":
+    def select_instance_type(
+        self, view_used_for: Literal["node", "edge", "all"] | None = None
+    ) -> Literal["node", "edge"]:
+        """Selects an instance type (node or edge) interactively.
+
+        Args:
+            view_used_for: If 'node' or 'edge', that type is returned directly.
+                           If 'all' or None, the user is prompted to select.
+
+        Returns:
+            The selected instance type, either 'node' or 'edge'.
+        """
+        if view_used_for is not None and view_used_for != "all":
             return view_used_for
         selected_instance_type = questionary.select(
             f"What type of instances do you want to {self.operation}?",
@@ -405,15 +637,70 @@ class DataModelingSelect:
         ).ask()
         if selected_instance_type is None:
             raise ToolkitValueError("No instance type selected")
-        if selected_instance_type not in ["node", "edge"]:
+        if selected_instance_type not in ("node", "edge"):
             raise ToolkitValueError(f"Selected instance type is not valid: {selected_instance_type!r}")
         return selected_instance_type
 
-    def select_instance_spaces(
-        self, selected_view: ViewId, instance_type: Literal["node", "edge"] = "node"
-    ) -> list[str] | None:
-        all_spaces = self._get_available_spaces(include_global=False)
-        count_by_space = self._get_instance_count_by_space(all_spaces, selected_view, instance_type)
+    def select_space_type(self) -> Literal["instance", "schema", "empty"]:
+        selected_space_type = questionary.select(
+            f"What type of spaces do you want to {self.operation}?",
+            choices=[
+                Choice(title="Instance spaces with instances", value="instance"),
+                Choice(title="Schema spaces with schema", value="schema"),
+                Choice(title="Empty spaces without schema or instances", value="empty"),
+            ],
+        ).ask()
+        if selected_space_type is None:
+            raise ToolkitValueError("No space type selected")
+        if selected_space_type not in ["instance", "schema", "empty"]:
+            raise ToolkitValueError(f"Selected space type is not valid: {selected_space_type!r}")
+        return selected_space_type
+
+    @overload
+    def select_instance_space(
+        self,
+        multiselect: Literal[False],
+        selected_view: ViewId | None = None,
+        instance_type: Literal["node", "edge"] | None = None,
+        message: str | None = None,
+        include_empty: bool = False,
+    ) -> str: ...
+
+    @overload
+    def select_instance_space(
+        self,
+        multiselect: Literal[True] = True,
+        selected_view: ViewId | None = None,
+        instance_type: Literal["node", "edge"] | None = None,
+        message: str | None = None,
+        include_empty: bool = False,
+    ) -> list[str]: ...
+
+    def select_instance_space(
+        self,
+        multiselect: bool = True,
+        selected_view: ViewId | None = None,
+        instance_type: Literal["node", "edge"] | None = None,
+        message: str | None = None,
+        include_empty: bool = False,
+    ) -> str | list[str]:
+        if (selected_view is not None and instance_type is None) or (
+            selected_view is None and instance_type is not None
+        ):
+            raise ToolkitValueError("Both selected_view and instance_type must be provided or both must be None.")
+        if selected_view is not None and instance_type is not None:
+            all_spaces = self._get_available_spaces(include_global=False)
+            count_by_space = self._get_instance_count_in_view_by_space(all_spaces, selected_view, instance_type)
+        else:
+            count_by_space = {
+                space: stats.nodes + stats.edges
+                for space, stats in self.stats_by_space.items()
+                if (stats.nodes + stats.edges) > 0
+                or (
+                    include_empty
+                    and (stats.nodes + stats.edges + stats.containers + stats.views + stats.data_models) == 0
+                )
+            }
 
         if not count_by_space:
             raise ToolkitMissingResourceError(
@@ -422,32 +709,58 @@ class DataModelingSelect:
         if len(count_by_space) == 1:
             selected_spaces = next(iter(count_by_space.keys()))
             self.console.print(f"Only one space with instances found: {selected_spaces!r}. Using this space.")
-            return [selected_spaces]
+            return [selected_spaces] if multiselect else selected_spaces
 
-        selected_spaces = questionary.select(
-            f"In which Space(s) do you want to {self.operation} instances?",
-            choices=[
-                Choice(title=f"{space} ({count:,} instances)", value=space)
-                for space, count in sorted(count_by_space.items(), key=lambda item: item[1], reverse=True)
-            ],
-            multiselect=True,
-        ).ask()
-        if selected_spaces is None or len(selected_spaces) == 0:
-            return None
-        if not isinstance(selected_spaces, list):
-            raise ToolkitValueError(f"Selected space is not a valid list: {selected_spaces!r}")
+        if not message:
+            message = f"In which Space{'(s)' if multiselect else ''} do you want to {self.operation} instances?"
+        choices = [
+            Choice(title=f"{space} ({count:,} instances)", value=space)
+            for space, count in sorted(count_by_space.items(), key=lambda item: item[1], reverse=True)
+        ]
+        if multiselect:
+            selected_spaces = questionary.checkbox(message, choices=choices).ask()
+        else:
+            selected_spaces = questionary.select(message, choices=choices).ask()
+        if selected_spaces is None or (isinstance(selected_spaces, list) and len(selected_spaces) == 0):
+            raise ToolkitValueError(
+                f"No instance space selected to {self.operation}. Use arrow keys to navigate and space key to select. Press enter to confirm."
+            )
+        return selected_spaces
+
+    @overload
+    def select_empty_spaces(self, multiselect: Literal[False]) -> str: ...
+    @overload
+    def select_empty_spaces(self, multiselect: Literal[True]) -> list[str]: ...
+
+    def select_empty_spaces(self, multiselect: bool = True) -> str | list[str]:
+        empty_spaces = [
+            space
+            for space, stats in self.stats_by_space.items()
+            if (stats.nodes + stats.edges + stats.containers + stats.views + stats.data_models) == 0
+        ]
+        if not empty_spaces:
+            raise ToolkitMissingResourceError("No empty spaces found.")
+        if len(empty_spaces) == 1:
+            selected_space = empty_spaces[0]
+            self.console.print(f"Only one empty space found: {selected_space!r}. Using this space.")
+            return [selected_space] if multiselect else selected_space
+
+        message = f"In which empty Space{'(s)' if multiselect else ''} do you want to {self.operation}?"
+        choices = [Choice(title=f"{space}", value=space) for space in sorted(empty_spaces)]
+        if multiselect:
+            selected_spaces = questionary.checkbox(message, choices=choices).ask()
+        else:
+            selected_spaces = questionary.select(message, choices=choices).ask()
+        if selected_spaces is None or (isinstance(selected_spaces, list) and len(selected_spaces) == 0):
+            raise ToolkitValueError(f"No empty space selected to {self.operation}. Aborting.")
         return selected_spaces
 
-    def _get_instance_count_by_space(
+    def _get_instance_count_in_view_by_space(
         self, all_spaces: SpaceList, view_id: ViewId, instance_type: Literal["node", "edge"]
     ) -> dict[str, float]:
         count_by_space: dict[str, float] = {}
-        try:
-            read_limit = self.client.data_modeling.statistics.project().concurrent_read_limit
-        except CogniteException:
-            # Fetching a broad exception as the statistics endpoint is in pre-alpha and may suddenly no longer be
-            # available.
-            read_limit = 2
+        result = self.client.data_modeling.statistics.project()
+        read_limit = result.concurrent_read_limit
 
         with ThreadPoolExecutor(max_workers=read_limit // 2) as executor:
             results = executor.map(
@@ -475,3 +788,85 @@ class DataModelingSelect:
         if include_global:
             return self._available_spaces
         return SpaceList([space for space in self._available_spaces if not space.is_global])
+
+
+class ResourceViewMappingInteractiveSelect:
+    def __init__(self, client: ToolkitClient, operation: str) -> None:
+        self.client = client
+        self.operation = operation
+
+    def select_resource_view_mapping(self, resource_type: str) -> ResourceViewMapping:
+        """Select a Resource View Mapping interactively.
+
+        Args:
+            resource_type: The resource type to filter Resource View Mappings by.
+        Returns:
+            The selected Resource View Mapping.
+        """
+        mappings = self.client.migration.resource_view_mapping.list(resource_type=resource_type, limit=-1)
+        if not mappings:
+            raise ToolkitMissingResourceError(f"No Resource View Mappings found for resource type {resource_type!r}.")
+        choices = [
+            Choice(
+                title=f"{mapping.external_id} ({mapping.view_id!r})",
+                value=mapping,
+            )
+            for mapping in mappings
+        ]
+        selected_mapping = questionary.select(
+            f"Which Resource View Mapping do you want to use to {self.operation}? [identifier] (ingestion view)",
+            choices=choices,
+        ).ask()
+        if selected_mapping is None:
+            raise ToolkitValueError("No Resource View Mapping selected.")
+        if not isinstance(selected_mapping, ResourceViewMapping):
+            raise ToolkitValueError(
+                f"Selected Resource View Mapping is not a valid ResourceViewMapping object: {selected_mapping!r}"
+            )
+        return selected_mapping
+
+
+class ThreeDInteractiveSelect:
+    def __init__(self, client: ToolkitClient, operation: str) -> None:
+        self.client = client
+        self.operation = operation
+
+    def select_three_d_models(self, model_type: Literal["classic", "dm"] | None = None) -> list[ThreeDModelResponse]:
+        """Select multiple 3D models interactively."""
+        if model_type is None:
+            model_type = questionary.select(
+                f"What type of 3D models do you want to {self.operation}?",
+                choices=[
+                    Choice(title="Classic models", value="classic"),
+                    Choice(title="Data modeling 3D", value="dm"),
+                ],
+            ).ask()
+        if model_type is None:
+            raise ToolkitValueError("No 3D model type selected.")
+        published = questionary.select(
+            f"Do you want to {self.operation} published or unpublished 3D models?",
+            choices=[
+                Choice(title="Published models", value=True),
+                Choice(title="Unpublished models", value=False),
+                Choice(title="Both published and unpublished models", value=None),
+            ],
+        ).ask()
+
+        models = self.client.tool.three_d.models.list(published=published, include_revision_info=True, limit=None)
+        if model_type == "classic":
+            models = [model for model in models if model.space is None]
+        else:
+            models = [model for model in models if model.space is not None]
+        if not models:
+            raise ToolkitMissingResourceError(
+                f"No 3D models found for type {model_type!r} with published={published!r}."
+            )
+
+        choices = [Choice(title=f"{model.name} ({model.id})", value=model) for model in models]
+        selected_models = questionary.checkbox(
+            f"Select 3D models to {self.operation}:",
+            choices=choices,
+        ).ask()
+        if selected_models is None or len(selected_models) == 0:
+            raise ToolkitValueError("No 3D models selected.")
+        return selected_models