cognite-toolkit 0.6.39__py3-none-any.whl → 0.7.30__py3-none-any.whl

cognite_toolkit/_cdf_tk/commands/deploy.py

@@ -1,8 +1,8 @@
-from collections.abc import Hashable
+from collections.abc import Hashable, Sequence
 from graphlib import TopologicalSorter
 from pathlib import Path
+from typing import overload
 
-from cognite.client.data_classes._base import T_CogniteResourceList, T_WritableCogniteResource, T_WriteClass
 from cognite.client.exceptions import CogniteAPIError, CogniteDuplicatedError
 from cognite.client.utils._identifier import T_ID
 from rich import print
@@ -15,6 +15,7 @@ from cognite_toolkit._cdf_tk.commands.clean import CleanCommand
 from cognite_toolkit._cdf_tk.constants import (
     _RUNNING_IN_BROWSER,
     BUILD_ENVIRONMENT_FILE,
+    DATA_UPLOAD_URL,
     HINT_LEAD_TEXT,
 )
 from cognite_toolkit._cdf_tk.cruds import (
@@ -25,7 +26,6 @@ from cognite_toolkit._cdf_tk.cruds import (
     ResourceCRUD,
     ResourceWorker,
 )
-from cognite_toolkit._cdf_tk.cruds._base_cruds import T_WritableCogniteResourceList
 from cognite_toolkit._cdf_tk.cruds._worker import CategorizedResources
 from cognite_toolkit._cdf_tk.data_classes import (
     BuildEnvironment,
@@ -44,9 +44,14 @@ from cognite_toolkit._cdf_tk.exceptions import (
     ToolkitFileNotFoundError,
     ToolkitNotADirectoryError,
 )
+from cognite_toolkit._cdf_tk.protocols import (
+    T_ResourceRequest,
+    T_ResourceResponse,
+)
 from cognite_toolkit._cdf_tk.tk_warnings import EnvironmentVariableMissingWarning
 from cognite_toolkit._cdf_tk.tk_warnings.base import WarningList, catch_warnings
 from cognite_toolkit._cdf_tk.tk_warnings.other import (
+    HighSeverityWarning,
     LowSeverityWarning,
     ToolkitDependenciesIncludedWarning,
 )
@@ -76,7 +81,19 @@ class DeployCommand(ToolkitCommand):
         include = self._clean_command.validate_include(include)
 
         build = self._load_build(build_dir, build_env_name)
+
         client = env_vars.get_client(build.is_strict_validation)
+
+        self._additional_tracking_info.project = client.config.project
+        self._additional_tracking_info.cluster = client.config.cdf_cluster
+
+        if not dry_run:
+            for module in build.read_modules:
+                if module.module_id:
+                    self._additional_tracking_info.module_ids.add(module.module_id)
+                if module.package_id:
+                    self._additional_tracking_info.package_ids.add(module.package_id)
+
         selected_loaders = self._clean_command.get_selected_loaders(build_dir, build.read_resource_folders, include)
         ordered_loaders = self._order_loaders(selected_loaders, build_dir)
         self._start_message(build_dir, dry_run, env_vars)
@@ -87,17 +104,17 @@ class DeployCommand(ToolkitCommand):
             )
 
         self.deploy_all_resources(
-            client,
-            results,
-            build,
-            build_dir,
-            drop,
-            drop_data,
-            dry_run,
-            env_vars,
-            force_update,
-            ordered_loaders,
-            verbose,
+            client=client,
+            build_dir=build_dir,
+            env_vars=env_vars,
+            results=results,
+            dry_run=dry_run,
+            has_dropped=drop,
+            has_dropped_data=drop_data,
+            force_update=force_update,
+            ordered_loaders=ordered_loaders,
+            build=build,
+            verbose=verbose,
         )
 
         if results.has_counts:
@@ -199,55 +216,129 @@ class DeployCommand(ToolkitCommand):
         print("[bold]...cleaning complete![/]")
         return None
 
+    @overload
     def deploy_all_resources(
         self,
         client: ToolkitClient,
+        build_dir: Path,
+        env_vars: EnvironmentVariables,
+        results: None = None,
+        dry_run: bool = False,
+        has_dropped: bool = False,
+        has_dropped_data: bool = False,
+        force_update: bool = False,
+        ordered_loaders: list[type[Loader]] | None = None,
+        build: BuildEnvironment | None = None,
+        verbose: bool = False,
+    ) -> DeployResults: ...
+
+    @overload
+    def deploy_all_resources(
+        self,
+        client: ToolkitClient,
+        build_dir: Path,
+        env_vars: EnvironmentVariables,
         results: DeployResults,
-        build: BuildEnvironment,
+        dry_run: bool = False,
+        has_dropped: bool = False,
+        has_dropped_data: bool = False,
+        force_update: bool = False,
+        ordered_loaders: list[type[Loader]] | None = None,
+        build: BuildEnvironment | None = None,
+        verbose: bool = False,
+    ) -> None: ...
+
+    def deploy_all_resources(
+        self,
+        client: ToolkitClient,
         build_dir: Path,
-        drop: bool,
-        drop_data: bool,
-        dry_run: bool,
         env_vars: EnvironmentVariables,
-        force_update: bool,
-        ordered_loaders: list[type[Loader]],
-        verbose: bool,
-    ) -> None:
+        results: DeployResults | None = None,
+        dry_run: bool = False,
+        has_dropped: bool = False,
+        has_dropped_data: bool = False,
+        force_update: bool = False,
+        ordered_loaders: list[type[Loader]] | None = None,
+        build: BuildEnvironment | None = None,
+        verbose: bool = False,
+    ) -> DeployResults | None:
+        """Deploy all resources in the build directory.
+
+        Args:
+            client: The Cognite client to use for deployment.
+            build_dir: The directory containing the built resource files.
+            env_vars: The environment variables to use for variable replacement in the resource files.
+            results: An optional DeployResults object to store the results of the deployment. If None, a new object will be created and returned.
+            dry_run: If True, performs a dry run without actually deploying the resources.
+            has_dropped: If True, indicates that resources have been dropped prior to deployment.
+            has_dropped_data: If True, indicates that data resources have been dropped prior to deployment.
+            force_update: If True, forces an update of resources even if they are unchanged.
+            ordered_loaders: An optional list of loader classes to use for deployment. If None, all loaders will be used in the order determined by dependencies.
+            build: An optional BuildEnvironment object containing information about the build. If None, data uploads will be skipped.
+            verbose: If True, prints detailed information about the deployment process.
+
+        Returns:
+            A DeployResults object containing the results of the deployment if results is None, otherwise None.
+
+        """
         if verbose:
             print(Panel("[bold]DEPLOYING resources...[/]"))
 
+        if ordered_loaders is None:
+            selected_loaders = self._clean_command.get_selected_loaders(build_dir, set(), None)
+            ordered_loaders = self._order_loaders(selected_loaders, build_dir)
+        read_modules: list[ReadModule] | None = None
+        if build is not None:
+            read_modules = build.read_modules
+        output_results = DeployResults([], "deploy", dry_run=dry_run) if results is None else results
         for loader_cls in ordered_loaders:
+            if issubclass(loader_cls, DataCRUD):
+                self.warn(
+                    HighSeverityWarning(
+                        f"Uploading {loader_cls.kind} data is deprecated and will be removed in v0.8. "
+                        f"Use the `cdf data upload dir` command instead. See [{DATA_UPLOAD_URL}]({DATA_UPLOAD_URL}) for more information about "
+                        "the upload command."
+                    )
+                )
+
             loader = loader_cls.create_loader(client, build_dir)
             resource_result: DeployResult | None
             if isinstance(loader, ResourceCRUD):
                 resource_result = self.deploy_resource_type(
                     loader,
                     env_vars,
-                    build.read_modules,
+                    read_modules,
                     dry_run,
-                    drop,
-                    drop_data,
+                    has_dropped,
+                    has_dropped_data,
                     force_update,
                     verbose,
                 )
-            elif isinstance(loader, DataCRUD):
+            elif isinstance(loader, DataCRUD) and build is not None:
                 resource_result = self.upload_data(loader, build, dry_run, verbose)
+            elif isinstance(loader, DataCRUD) and build is None:
+                self.warn(
+                    LowSeverityWarning(
+                        f"Skipping data upload for {loader.display_name} as it is not supported in this context."
+                    )
+                )
+                continue
             else:
                 raise ValueError(f"Unsupported loader type {type(loader)}.")
 
             if resource_result:
-                results[resource_result.name] = resource_result
+                output_results[resource_result.name] = resource_result
             if verbose:
                 print("")  # Extra newline
+        if results is None:
+            return output_results
         return None
 
     def deploy_resource_type(
         self,
-        loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
-        ],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         env_vars: EnvironmentVariables,
-        read_modules: list[ReadModule],
+        read_modules: list[ReadModule] | None = None,
         dry_run: bool = False,
         has_done_drop: bool = False,
         has_dropped_data: bool = False,
@@ -307,10 +398,8 @@ class DeployCommand(ToolkitCommand):
 
     def actual_deploy(
         self,
-        resources: CategorizedResources[T_ID, T_CogniteResourceList],
-        loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
-        ],
+        resources: CategorizedResources[T_ID, T_ResourceRequest],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         env_var_warnings: WarningList | None = None,
     ) -> ResourceDeployResult:
         environment_variable_warning_by_id = {
@@ -341,10 +430,8 @@ class DeployCommand(ToolkitCommand):
 
     @staticmethod
     def dry_run_deploy(
-        resources: CategorizedResources[T_ID, T_CogniteResourceList],
-        loader: ResourceCRUD[
-            T_ID, T_WriteClass, T_WritableCogniteResource, T_CogniteResourceList, T_WritableCogniteResourceList
-        ],
+        resources: CategorizedResources[T_ID, T_ResourceRequest],
+        loader: ResourceCRUD[T_ID, T_ResourceRequest, T_ResourceResponse],
         has_done_drop: bool,
         has_dropped_data: bool,
     ) -> ResourceDeployResult:
@@ -375,7 +462,7 @@ class DeployCommand(ToolkitCommand):
 
     @staticmethod
     def _verbose_print(
-        resources: CategorizedResources[T_ID, T_CogniteResourceList],
+        resources: CategorizedResources[T_ID, T_ResourceRequest],
         loader: ResourceCRUD,
         dry_run: bool,
     ) -> None:
@@ -399,7 +486,7 @@ class DeployCommand(ToolkitCommand):
 
     def _create_resources(
         self,
-        resources: T_CogniteResourceList,
+        resources: Sequence[T_ResourceRequest],
         loader: ResourceCRUD,
         environment_variable_warning_by_id: dict[Hashable, EnvironmentVariableMissingWarning],
     ) -> int:
@@ -422,7 +509,7 @@ class DeployCommand(ToolkitCommand):
 
     def _update_resources(
         self,
-        resources: T_CogniteResourceList,
+        resources: Sequence[T_ResourceRequest],
         loader: ResourceCRUD,
         environment_variable_warning_by_id: dict[Hashable, EnvironmentVariableMissingWarning],
     ) -> int:

cognite_toolkit/_cdf_tk/commands/dump_resource.py

@@ -3,7 +3,7 @@ import json
 import zipfile
 from abc import ABC, abstractmethod
 from collections import defaultdict
-from collections.abc import Hashable, Iterable, Iterator
+from collections.abc import Hashable, Iterable, Iterator, Sequence
 from functools import cached_property
 from pathlib import Path
 from typing import Generic, cast
@@ -22,6 +22,7 @@ from cognite.client.data_classes import (
     filters,
 )
 from cognite.client.data_classes._base import (
+    CogniteResource,
     CogniteResourceList,
 )
 from cognite.client.data_classes.agents import (
@@ -52,6 +53,8 @@ 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,
@@ -66,6 +69,7 @@ from cognite_toolkit._cdf_tk.cruds import (
     LocationFilterCRUD,
     NodeCRUD,
     ResourceCRUD,
+    SearchConfigCRUD,
     SpaceCRUD,
     StreamlitCRUD,
     TransformationCRUD,
@@ -85,7 +89,7 @@ from cognite_toolkit._cdf_tk.exceptions import (
 )
 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, to_directory_compatible, 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
@@ -110,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]):
@@ -167,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
@@ -181,7 +188,7 @@ 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, ResourceCRUD, None | str]]:
         self.identifier = self._selected()
@@ -596,7 +603,7 @@ class FunctionFinder(ResourceFinder[tuple[str, ...]]):
                 return
             raise
         try:
-            top_level = f"{to_directory_compatible(function.external_id or 'unknown_external_id')}/"
+            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)
@@ -691,7 +698,7 @@ class StreamlitFinder(ResourceFinder[tuple[str, ...]]):
             ).print_warning(console=console)
             return
 
-        app_folder = to_directory_compatible(app.external_id)
+        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):
@@ -749,6 +756,36 @@ class SpaceFinder(ResourceFinder[tuple[str, ...]]):
         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):
     def dump_to_yamls(
         self,
@@ -768,6 +805,7 @@ class DumpResourceCommand(ToolkitCommand):
             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

cognite_toolkit/_cdf_tk/commands/init.py

@@ -1,30 +1,231 @@
+import shutil
+import tempfile
+import traceback
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+
+import questionary
+import typer
+from questionary import Choice
 from rich import print
 from rich.panel import Panel
 
-from ._base import ToolkitCommand
+from cognite_toolkit._cdf_tk.cdf_toml import CDFToml
+from cognite_toolkit._cdf_tk.commands._base import ToolkitCommand
+from cognite_toolkit._cdf_tk.commands.auth import AuthCommand
+from cognite_toolkit._cdf_tk.commands.collect import CollectCommand
+from cognite_toolkit._cdf_tk.commands.modules import ModulesCommand
+from cognite_toolkit._cdf_tk.commands.repo import RepoCommand
+from cognite_toolkit._cdf_tk.exceptions import ToolkitError
+from cognite_toolkit._cdf_tk.feature_flags import FeatureFlag
+
+
+class InitItemStatus(Enum):
+    """Status of an init checklist item"""
+
+    NONE = "none"
+    SUCCESSFUL = "successful"
+    FAILED = "failed"
+
+
+@dataclass
+class InitChecklistItem:
+    name: str
+    description: str
+    function: Callable[[], None]
+    status: InitItemStatus | None = None
+    mandatory: bool = False
+
+    def get_status_display(self) -> str:
+        if self.status == InitItemStatus.SUCCESSFUL:
+            return "✓"
+        elif self.status == InitItemStatus.FAILED:
+            return "✗"
+        else:
+            return "○"
+
+    def get_choice_title(self) -> str:
+        status_icon = self.get_status_display()
+        return f"{status_icon} {self.description} (required)" if self.mandatory else f"{status_icon} {self.description}"
 
 
 class InitCommand(ToolkitCommand):
-    def execute(self) -> None:
+    organization_dir: Path | None
+
+    def __init__(self, print_warning: bool = True, skip_tracking: bool = False, silent: bool = False) -> None:
+        super().__init__(print_warning, skip_tracking, silent)
+        self.organization_dir = None
+
+    def execute(self, dry_run: bool = False) -> None:
+        print("\n")
         print(
             Panel(
-                "\n".join(
-                    [
-                        "[bold]Follow these steps to get started with the Cognite Data Fusion Toolkit:[/b]",
-                        "",
-                        "1. Run [bold]cdf-tk repo init (folder_name)[/] to prepare the working folder.",  # todo: connect the folder name with the modules command
-                        "2. Run [bold]cd (folder_name)[/] to enter the newly created folder.",
-                        "3. Run [bold]cdf-tk modules init[/] to select the configuration modules you would like to start with.",
-                        "4. Run [bold]cdf-tk auth verify --interactive[/] to check that you have access to the relevant CDF project. ",
-                        "   [italic](if you already have a .env file, you can copy it into the folder and run [bold]cdf-tk auth verify[/] directly)[/]",
-                        "5. Run [bold]cdf-tk build modules[/] to build the configuration and look for variables that need your attention. Repeat for as many times as needed.",
-                        "6. Run [bold]cdf-tk deploy --dry-run[/] to simulate the deployment of the configuration to the CDF project. Review the report provided",
-                        "7. Run [bold]cdf-tk deploy[/] to deploy the configuration to the CDF project.",
-                        "8. Commit the changes to your version control system.",
-                    ]
-                ),
-                title="Getting started",
+                "Go through the following steps to set up the Cognite Toolkit. You can re-run steps if you need to change something.",
+                title="Cognite Toolkit Setup",
                 style="green",
                 padding=(1, 2),
             )
         )
+
+        # Initialize checklist items
+        checklist_items = [
+            InitChecklistItem(
+                name="initToml",
+                description="Create toml file",
+                function=lambda: self._init_toml(dry_run=dry_run),
+                mandatory=True,
+            ),
+            InitChecklistItem(
+                name="initAuth",
+                description="Authentication",
+                function=lambda: self._init_auth(dry_run=dry_run),
+            ),
+            InitChecklistItem(
+                name="initModules",
+                description="Modules",
+                function=lambda: self._init_modules(dry_run=dry_run),
+            ),
+            InitChecklistItem(
+                name="initRepo",
+                description="Git repository",
+                function=lambda: self._init_repo(dry_run=dry_run),
+            ),
+            InitChecklistItem(
+                name="initDataCollection",
+                description="Usage statistics",
+                function=lambda: self._init_data_collection(dry_run=dry_run),
+            ),
+        ]
+
+        if CDFToml.load().is_loaded_from_file:
+            checklist_items[0].status = InitItemStatus.SUCCESSFUL
+            print("cdf.toml configuration file already exists. Skipping creation.")
+
+        # Main loop: keep showing checklist until user is done
+        while True:
+            # Build choices for questionary
+            choices = []
+            for item in checklist_items:
+                choices.append(
+                    Choice(
+                        title=item.get_choice_title(),
+                        value=item.name,
+                    )
+                )
+            # Check if all mandatory items are completed
+            mandatory_items = [item for item in checklist_items if item.mandatory]
+            all_mandatory_complete = all(item.status == InitItemStatus.SUCCESSFUL for item in mandatory_items)
+
+            choices.append(Choice(title="> Quit", value="__exit__"))
+
+            # Find the first item with status None to use as default
+            default_item = next((item for item in checklist_items if item.status is None), None)
+            default_value = default_item.name if default_item else "__exit__"
+
+            # Show checklist and get user selection
+            selected = questionary.select(
+                "Select a task:",
+                choices=choices,
+                default=default_value,
+            ).ask()
+
+            # User cancelled (Ctrl+C or similar)
+            if selected is None:
+                return
+
+            if selected == "__exit__":
+                if all_mandatory_complete:
+                    print("Setup complete!")
+                    break
+                else:
+                    incomplete_mandatory = [
+                        item.description for item in mandatory_items if item.status != InitItemStatus.SUCCESSFUL
+                    ]
+                    print(f"Warning: recommended item not completed: {', '.join(incomplete_mandatory)}")
+                    break
+
+            # Find the selected item
+            selected_item = next((item for item in checklist_items if item.name == selected), None)
+            if selected_item is None:
+                continue
+
+            # If item was already run, ask for confirmation to re-run
+            if selected_item.status is not None:
+                status_text = (
+                    "successfully. Re-run it?"
+                    if selected_item.status == InitItemStatus.SUCCESSFUL
+                    else "with failure. Retry?"
+                )
+                confirm = questionary.confirm(
+                    f"'{selected_item.description}' was already run {status_text}",
+                    default=False,
+                ).ask()
+                if not confirm:
+                    continue
+
+            try:
+                selected_item.function()
+                selected_item.status = InitItemStatus.SUCCESSFUL
+                print(f"✓ {selected_item.description} completed successfully")
+            except typer.Exit:
+                # typer.Exit is used for normal exits, treat as success
+                selected_item.status = InitItemStatus.SUCCESSFUL
+                print(f"✓ {selected_item.description} completed successfully")
+            except ToolkitError as e:
+                # Catch expected toolkit errors
+                selected_item.status = InitItemStatus.FAILED
+                print(f"✗ {selected_item.description} failed: {e}")
+            except Exception as e:
+                # Catch unexpected errors and log full traceback for debugging
+                selected_item.status = InitItemStatus.FAILED
+                print(f"✗ {selected_item.description} failed: {e}")
+                print(f"Unexpected error occurred. Full traceback:\n{traceback.format_exc()}")
+
+    def _init_toml(self, dry_run: bool = False) -> None:
+        if self.organization_dir is None:
+            self.organization_dir = ModulesCommand._prompt_organization_dir()
+        if dry_run:
+            print("Would initialize cdf.toml configuration file")
+            return
+        CDFToml.write(self.organization_dir, "dev")
+        FeatureFlag.flush()
+        print(f"cdf.toml configuration file initialized in {self.organization_dir}")
+
+    def _init_auth(self, dry_run: bool = False) -> None:
+        auth_command = AuthCommand()
+        auth_command.run(lambda: auth_command.init(no_verify=True, dry_run=dry_run))
+
+    def _init_modules(self, dry_run: bool = False) -> None:
+        with ModulesCommand() as modules_command:
+            if self.organization_dir is None:
+                self.organization_dir = ModulesCommand._prompt_organization_dir()
+            if dry_run:
+                organization_dir = Path(tempfile.mkdtemp(prefix="init_modules_", suffix=".tmp", dir=Path.cwd()))
+                modules_command.run(lambda: modules_command.init(organization_dir=organization_dir))
+                shutil.rmtree(organization_dir)
+            else:
+                modules_command.run(lambda: modules_command.init(organization_dir=self.organization_dir))
+
+    def _init_repo(self, dry_run: bool = False) -> None:
+        repo_command = RepoCommand()
+        repo_command.run(lambda: repo_command.init(cwd=Path.cwd(), host=None, verbose=False))
+
+    def _init_data_collection(self, dry_run: bool = False) -> None:
+        """Opt in to collect usage statistics"""
+
+        opt_in = questionary.confirm(
+            "Do you want to opt in to collect usage statistics? This will help us improve the Toolkit.",
+            default=True,
+        ).ask()
+        if dry_run:
+            print("Would opt in to collect data" if opt_in else "Would not opt in to collect data")
+            return
+
+        if opt_in:
+            collect_command = CollectCommand()
+            collect_command.run(lambda: collect_command.execute("opt-in"))
+        else:
+            collect_command = CollectCommand()
+            collect_command.run(lambda: collect_command.execute("opt-out"))