LiteBuild 0.5__tar.gz → 0.7__tar.gz

{litebuild-0.5 → litebuild-0.7}/LiteBuild/build_engine.py

@@ -1,7 +1,7 @@
 from concurrent.futures import ProcessPoolExecutor
 import datetime
 import difflib
-from enum import IntEnum
+from enum import IntEnum, StrEnum
 import json
 import os
 from pathlib import Path
@@ -13,10 +13,13 @@ from typing import List, Dict, Tuple, NamedTuple, Optional
 import networkx as nx
 from YMLEditor.yaml_reader import ConfigLoader
 
+
+# build_engine.py
+
 from LiteBuild.build_logger import BuildLogger, setup_logger, get_logger
 from LiteBuild.command_generator import CommandGenerator
 from LiteBuild.dependency_graph import DependencyGraph
-from LiteBuild.schema import BUILD_SCHEMA, LiteBuildValidator
+from LiteBuild.schema import BUILD_SCHEMA, LiteBuildValidator, YAMLSection
 
 
 class UpdateCode(IntEnum):
@@ -58,14 +61,15 @@ class BuildEngine:
     ):
         """Initializes the BuildEngine, merging command-line variables into the config."""
         if cli_vars:
-            if "GENERAL" not in config_data:
-                config_data["GENERAL"] = {}
-            config_data["GENERAL"].update(cli_vars)
+            if YAMLSection.GENERAL not in config_data:
+                config_data[YAMLSection.GENERAL] = {}
+            config_data[YAMLSection.GENERAL].update(cli_vars)
 
         self.config = config_data
         self.state_file = state_file
+
         # Validate Input Directory
-        input_dir = config_data.get("GENERAL", {}).get("INPUT_DIRECTORY")
+        input_dir = config_data.get(YAMLSection.GENERAL, {}).get("INPUT_DIRECTORY")
         if input_dir:
             path = Path(input_dir)
             if not path.exists():
@@ -93,7 +97,7 @@ class BuildEngine:
             return cls(config_data, cli_vars=cli_vars, state_file=state_file)
         except (FileNotFoundError, ValueError) as e:
             # Re-raise to be handled by the calling script (CLI or GUI)
-            raise e
+            raise
 
     def execute(self, final_step_name: str, profile_name: str = "", logger: BuildLogger = None, status_callback=None, force_rebuild=False):
         """
@@ -103,59 +107,106 @@ class BuildEngine:
             logger = get_logger()
         setup_logger(logger)
 
-        # --- Extract Context info ---
-        general_cfg = self.config.get("GENERAL", {})
-        profile_cfg = self.config.get("PROFILES", {}).get(profile_name, {})
-
-        # Get (optional) segment/category from General  or Profile
-        segment = general_cfg.get("SEGMENT") or profile_cfg.get("SEGMENT") or ""
-        category = general_cfg.get("CATEGORY") or profile_cfg.get("CATEGORY") or ""
-
-        context_str = f"Segment: {segment}    Category: {category}  "
+        context_str = ""
         if profile_name:
             context_str += f" Profile: {profile_name}"
 
-        # Get the current date and time
-        #now = datetime.now()
-
         # Format the time as a string (HH:MM:SS) using strftime()
         current_time = "" #now.strftime("%H:%M:%S")
 
-        logger.log(f"🔵 Executing build for step {final_step_name} - {current_time}")
-        logger.log(f"ℹ️   {context_str}\n")
+        logger.log(f"\n🔵 Executing build for target step: {final_step_name} - {current_time}")
+        profile_display = profile_name or "none"
+        logger.log(f"ℹ️   Profile: {profile_display}\n")
 
         try:
             state_manager = BuildStateManager(self.state_file)
             planner = BuildPlanner(self.config, state_manager.load_state())
             plan = planner.plan_build(profile_name, final_step_name, force_rebuild=force_rebuild)
-
             executor = BuildExecutor(state_manager, self.config)
             success = executor.execute_plan(plan, logger, status_callback=status_callback)
         except Exception as e:
             success = False
             # ---  ERROR REPORTING ---
-            #logger.log(f"\n❌ ERROR")
-            logger.log(f"{e}")
-            #logger.log("\n--- Traceback ---")
-            #logger.log(traceback.format_exc())
+            logger.log(f"🔴{e}")
 
             # Update status callback if present
             if status_callback:
                 status_callback("step", 0, 0, "error")
-        # Get the current date and time
-        #now = datetime.now()
 
         # Format the time as a string (HH:MM:SS) using strftime()
         current_time = "" #now.strftime("%H:%M:%S")
 
         if success:
             logger.log(f"\n✅ Build finished successfully. {current_time}")
+            return True
         else:
             logger.log(f"🔴Build failed for {final_step_name}.  {current_time}")
+            return False
+        
+    def get_group_list(self) -> dict:
+        """Returns the PROFILE_GROUPS in the YAML config."""
+        return self.config.get(YAMLSection.PROFILE_GROUPS, {})
+
+    def get_profile_list(self) -> dict:
+        """Returns the PROFILES in the YAML config."""
+        return self.config.get(YAMLSection.PROFILES, {})
 
     def has_profile(self, profile_name: str) -> bool:
         """Checks if a specific profile key exists in the YAML config."""
-        return profile_name in self.config.get('PROFILES', {})
+        return profile_name in self.get_profile_list()
+
+    def resolve_profile_group(self, group_name: str) -> List[str]:
+        """Resolve a profile group into its ordered list of profile names.
+
+        Args:
+            group_name: Name of the PROFILE_GROUPS entry to resolve.
+
+        Returns:
+            Profile names in the order defined by the configuration.
+
+        Raises:
+            ValueError: If the group does not exist, is empty, or references
+                profiles that are not defined in PROFILES.
+        """
+        profile_groups = self.get_group_list()
+
+        if group_name not in profile_groups:
+            available = list(profile_groups.keys())
+            matches = difflib.get_close_matches(group_name, available, n=1, cutoff=0.6)
+            hint = f"\n   Did you mean '{matches[0]}'?" if matches else ""
+
+            if available:
+                available_text = "\n - ".join(available)
+                available_message = f"\nAvailable profile groups:\n - {available_text}"
+            else:
+                available_message = "\nNo profile groups are configured."
+
+            raise ValueError(
+                f"\nProfile Group '{group_name}' not found.{hint}"
+                f"{available_message}\n"
+            )
+
+        profiles = list(profile_groups[group_name])
+        if not profiles:
+            raise ValueError(
+                f"Profile Group '{group_name}' does not contain any profiles."
+            )
+
+        configured_profiles = self.get_profile_list()
+        missing_profiles = [
+            profile_name
+            for profile_name in profiles
+            if profile_name not in configured_profiles
+        ]
+
+        if missing_profiles:
+            missing_text = "\n - ".join(missing_profiles)
+            raise ValueError(
+                f"Profile Group '{group_name}' references undefined profiles:"
+                f"\n - {missing_text}\n"
+            )
+
+        return profiles
 
     def describe(self, profile_name: str) -> str:
         """Generates a Markdown description of the workflow for a given profile."""
@@ -172,7 +223,14 @@ class BuildPlanner:
         self.build_state = build_state
         self.logger = get_logger()
 
-    def _is_step_outdated(self, command: Dict, force_rebuild: bool = False) -> Tuple[UpdateCode, str]:
+    @staticmethod
+    def _normalize_path(path: str) -> str:
+        """Return a stable absolute path for DAG input/output comparison."""
+        return os.path.normcase(os.path.abspath(os.path.normpath(os.fspath(path))))
+
+    def _is_step_outdated(
+            self, command: Dict, produced_outputs: set[str], force_rebuild: bool = False
+    ) -> Tuple[UpdateCode, str]:
         # 1. Force Check (Short Circuit)
         if force_rebuild:
             self.logger.debug(f"  - RESULT: Rebuild forced by user. (COMMAND_CHANGED)")
@@ -228,7 +286,18 @@ class BuildPlanner:
             for input_file in command['input_files']:
                 self.logger.debug(f"    - Checking input: '{input_file}'")
                 if not os.path.exists(input_file):
-                    self.logger.debug(f"    - RESULT: Input file does not exist. (MISSING_INPUT)")
+                    normalized_input = self._normalize_path(input_file)
+                    if normalized_input in produced_outputs:
+                        self.logger.debug(
+                            "    - RESULT: Input does not exist yet, but is produced by "
+                            "another step in this DAG."
+                        )
+                        continue
+
+                    self.logger.debug(
+                        "    - RESULT: Input file does not exist and is not produced by "
+                        "this DAG. (MISSING_INPUT)"
+                    )
                     raise FileNotFoundError(input_file)
 
                 input_mtime = os.path.getmtime(input_file)
@@ -255,11 +324,25 @@ class BuildPlanner:
         for node, cmd in command_map.items():
             cmd['node_name'] = node
 
+        produced_outputs = {
+            self._normalize_path(command["output"])
+            for command in command_map.values()
+        }
+
         initially_outdated = {}
         build_order = list(nx.topological_sort(execution_graph))
         for node_name in build_order:
             command = command_map[node_name]
-            update_code, context = self._is_step_outdated(command, force_rebuild=force_rebuild)
+            update_code, context = self._is_step_outdated(
+                command, produced_outputs, force_rebuild=force_rebuild
+            )
+
+            if update_code == UpdateCode.MISSING_INPUT:
+                raise FileNotFoundError(
+                    f"Cannot build step '{node_name}': required input '{context}' is missing "
+                    "and no step in the current build DAG creates it."
+                )
+
             if update_code != UpdateCode.UP_TO_DATE:
                 initially_outdated[node_name] = (update_code, context)
 
@@ -305,13 +388,14 @@ class BuildPlanner:
 
         graph_manager = DependencyGraph(self.config.get("WORKFLOW", {}))
         execution_graph = graph_manager.get_execution_subgraph(final_step_name)
-        general_config = self.config.get("GENERAL", {})
-        command_gen = CommandGenerator(general_config, profile_config)
+        general_config = self.config.get(YAMLSection.GENERAL, {})
+        parameters_config = self.config.get(YAMLSection.PARAMETERS, {})
+        command_gen = CommandGenerator(parameters_config, profile_config)
         context = {"profile_name": profile_name, **general_config, **profile_config}
 
         # Pre-process input files to create full paths automatically.
-        input_dir = context.get("INPUT_DIRECTORY")
         input_basenames = context.get("INPUT_FILES")
+        input_dir = context.get("INPUT_DIRECTORY", {})
 
         if input_dir and input_basenames:
             full_paths = [os.path.join(input_dir, f) for f in input_basenames]
@@ -321,7 +405,6 @@ class BuildPlanner:
         for node_name in nx.topological_sort(execution_graph):
             node_data = execution_graph.nodes[node_name]
 
-            # --- IMPROVED ERROR HANDLING ---
             try:
                 command_map[node_name] = command_gen.generate_for_node(
                     node_name, node_data, context, resolved_outputs
@@ -365,8 +448,11 @@ class BuildExecutor:
         if status_callback:
             status_callback("step", 0, total_to_run, "started")
 
-        for step in plan.steps_to_skip:
-            logger.log(f"Skipping '{step.node_name}' (up-to-date)")
+        if plan.steps_to_skip:
+            skipped = ", ".join(
+                step.node_name for step in plan.steps_to_skip
+            )
+            logger.log(f"⏭️  Skipping up-to-date steps:\n   {skipped}\n")
 
         if not plan.steps_to_run:
             if status_callback:
@@ -391,7 +477,7 @@ class BuildExecutor:
             if not tasks_this_generation:
                 continue
 
-            max_workers = self.config.get("GENERAL", {}).get("MAX_WORKERS")
+            max_workers = self.config.get(YAMLSection.GENERAL, {}).get("MAX_WORKERS")
             with ProcessPoolExecutor(
                     max_workers=max_workers, initializer=initializer, initargs=initargs
             ) as executor:
@@ -407,7 +493,7 @@ class BuildExecutor:
 
                 if status == 'EXECUTED':
                     finished_count += 1
-                    logger.log(f"✅ Finished step '{step_name}' [{finished_count}/{total_to_run}]")
+                    logger.log(f"✅ Finished step '{step_name}' [{finished_count}/{total_to_run}]\n")
                     if status_callback:
                         status_callback("step", finished_count, total_to_run, "done")
                     self.build_state[result_data['output_path']] = {
@@ -453,7 +539,7 @@ class BuildExecutor:
 
         # Log the command (Truncated)
         cmd_display = _truncate(command['cmd_string'])
-        logger.log(f"\n▶️  Running step '{step_name}': {update_text}")
+        logger.log(f"\n\n▶️  Running step '{step_name}': {update_text}")
         logger.log(f"  [{step_name}]       {cmd_display}")
 
         start_time = time.perf_counter()
@@ -559,7 +645,8 @@ class BuildReporter:
         """Generates a full Markdown report for the workflow."""
         import datetime
         timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
-        project_name = self.config.get("GENERAL", {}).get("PROJECT_NAME", "LiteBuild Project")
+        project_cfg = self.config.get(YAMLSection.PROJECT)
+        project_name = project_cfg.get("PROJECT_NAME", "LiteBuild Project")
 
         # 1. Generate the Plan to resolve all variables
         planner = BuildPlanner(self.config, {})
@@ -588,8 +675,9 @@ class BuildReporter:
         ]
 
         # --- OVERVIEW SECTION ---
-        # Checks for the global OVERVIEW key in the config
-        overview_text = self.config.get("OVERVIEW")
+        # Checks for the  OVERVIEW key in the config
+
+        overview_text = project_cfg.get("OVERVIEW")
         if overview_text:
             lines.append("## Overview")
             lines.append(overview_text.strip())

{litebuild-0.5 → litebuild-0.7}/LiteBuild/build_logger.py

@@ -47,7 +47,6 @@ class BuildLogger:
             self.log_file_handle = open(log_file, 'a', encoding='utf-8')
             self.lock = FileLock(log_file.with_suffix(".lock"))
 
-        # --- FIX: Duck typing check instead of strict isinstance(TextIO) ---
         elif hasattr(output, 'write') and hasattr(output, 'flush'):
             self.log_file_handle = output
             self.lock = nullcontext()

litebuild-0.7/LiteBuild/build_util.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Final
+
+
+class StatusContext:
+    """Defined status-update context values."""
+    PROFILE: Final[str] = "profile"
+    STEP: Final[str] = "step"
+
+
+class StatusCode:
+    """Defined status-update state values."""
+    STARTED: Final[str] = "started"
+    DONE: Final[str] = "done"
+    SKIPPED: Final[str] = "skipped"
+    ERROR: Final[str] = "error"
+
+@dataclass(frozen=True)
+class StatusMessage:
+    context_type: str
+    current_task: int
+    total: int
+    status_code: str
+
+    @classmethod
+    def profile(cls, current_task: int, total: int, status_code: str) -> "StatusMessage":
+        return cls(
+            context_type=StatusContext.PROFILE,
+            current_task=current_task,
+            total=total,
+            status_code=status_code,
+        )
+
+    @classmethod
+    def step(cls, current_task: int, total: int, status_code: str) -> "StatusMessage":
+        return cls(
+            context_type=StatusContext.STEP,
+            current_task=current_task,
+            total=total,
+            status_code=status_code,
+        )

litebuild-0.7/LiteBuild/build_workers.py

@@ -0,0 +1,299 @@
+from __future__ import annotations
+
+import difflib
+import threading
+import time
+import traceback
+from pathlib import Path
+from typing import Dict, Optional
+
+from LiteBuild.build_engine import BuildEngine
+from LiteBuild.build_logger import BuildLogger, LogLevel
+from LiteBuild.schema import YAMLSection
+from PySide6.QtCore import QObject, Signal
+
+from LiteBuild.build_util import StatusCode, StatusMessage
+
+
+# build_workers.py
+
+class BuildWorker(QObject):
+    """
+    Worker for running a single build profile or step.
+    """
+
+    finished = Signal()
+    error = Signal(Exception)
+    log_message = Signal(str)
+    status_signal = Signal(object)
+
+    def __init__(
+        self,
+        config_path: str,
+        profile_name: str,
+        cli_vars: Optional[Dict] = None,
+        step_name: Optional[str] = None,
+    ) -> None:
+        """Initialize the worker.
+
+        Args:
+            config_path: Path to the LiteBuild config file.
+            profile_name: Profile to execute.
+            cli_vars: Optional CLI variable overrides.
+            step_name: Optional explicit workflow step to execute.
+        """
+        super().__init__()
+        self.config_path = config_path
+        self.profile_name = profile_name
+        self.cli_vars = cli_vars
+        self.step_name = step_name
+
+    def _emit_status(self, message: StatusMessage) -> None:
+        """Emit a structured status update.
+
+        Args:
+            message: Status payload to emit.
+        """
+        self.status_signal.emit(message)
+
+    def _relay_step_status(
+        self,
+        context_type: str,
+        current_task: int,
+        total: int,
+        status_code: str,
+    ) -> None:
+        """Relay engine status callback to the Qt signal.
+
+        Args:
+            context_type: Status context type.
+            current_task: Current step/profile index.
+            total: Total number of items in the context.
+            status_code: Status code such as started/done/error.
+        """
+        message = (
+            StatusMessage.profile(current_task, total, status_code)
+            if context_type == "profile"
+            else StatusMessage.step(current_task, total, status_code)
+        )
+        self._emit_status(message)
+
+    def run(self) -> None:
+        """Run the build and tail log output."""
+        log_dir = Path("build/logs")
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / f"litebuild_{self.profile_name}_{int(time.time())}.log"
+
+        log_level_enum = LogLevel["INFO"]
+        logger = BuildLogger(log_file, log_level=log_level_enum)
+
+        try:
+            engine = BuildEngine.from_file(self.config_path, cli_vars=self.cli_vars)
+            project_cfg = engine.config.get(YAMLSection.PROJECT)
+
+            final_step_name = self.step_name or project_cfg.get("DEFAULT_WORKFLOW_STEP")
+            if not final_step_name:
+                raise ValueError(
+                    "No workflow target step specified. Please  "
+                    "set a DEFAULT_WORKFLOW_STEP in PROJECT: section of your configuration file."
+                )
+
+            self._emit_status(StatusMessage.profile(1, 1, StatusCode.STARTED))
+
+            build_thread = threading.Thread(
+                target=engine.execute,
+                args=(final_step_name, self.profile_name, logger),
+                kwargs={"status_callback": self._relay_step_status},
+            )
+            build_thread.start()
+
+            last_pos = 0
+            time.sleep(0.2)
+
+            if log_file.exists():
+                with open(log_file, "r", encoding="utf-8") as file_obj:
+                    while build_thread.is_alive():
+                        lines = file_obj.readlines()
+                        if lines:
+                            for line in lines:
+                                self.log_message.emit(line.strip())
+                            last_pos = file_obj.tell()
+                        time.sleep(0.1)
+
+            build_thread.join()
+
+            if log_file.exists():
+                with open(log_file, "r", encoding="utf-8") as file_obj:
+                    file_obj.seek(last_pos)
+                    for line in file_obj.readlines():
+                        self.log_message.emit(line.strip())
+
+            self._emit_status(StatusMessage.profile(1, 1, StatusCode.DONE))
+            self.log_message.emit("DONE")
+            self.finished.emit()
+
+        except Exception as exc:
+            tb_str = traceback.format_exc()
+            self.log_message.emit("\n❌ A critical error occurred.")
+            self.log_message.emit(tb_str)
+            self.error.emit(exc)
+            self._emit_status(StatusMessage.profile(1, 1, StatusCode.ERROR))
+
+
+class BuildGroupWorker(QObject):
+    """
+    Worker for running a GROUP of profiles sequentially.
+    """
+
+    finished = Signal()
+    error = Signal(Exception)
+    log_message = Signal(str)
+    status_signal = Signal(object)
+
+    def __init__(
+        self,
+        config_path: str,
+        group_name: str,
+        cli_vars: Optional[Dict] = None,
+    ) -> None:
+        """Initialize the worker.
+
+        Args:
+            config_path: Path to the LiteBuild config file.
+            group_name: Profile group to execute.
+            cli_vars: Optional CLI variable overrides.
+        """
+        super().__init__()
+        self.config_path = config_path
+        self.group_name = group_name
+        self.cli_vars = cli_vars
+
+    def _emit_status(self, message: StatusMessage) -> None:
+        """Emit a structured status update.
+
+        Args:
+            message: Status payload to emit.
+        """
+        self.status_signal.emit(message)
+
+    def _relay_step_status(
+        self,
+        context_type: str,
+        current_task: int,
+        total: int,
+        status_code: str,
+    ) -> None:
+        """Relay engine status callback to the GUI.
+
+        Args:
+            context_type: Status context type.
+            current_task: Current step/profile index.
+            total: Total number of items in the context.
+            status_code: Status code such as started/done/error.
+        """
+        message = (
+            StatusMessage.profile(current_task, total, status_code)
+            if context_type == "profile"
+            else StatusMessage.step(current_task, total, status_code)
+        )
+        self._emit_status(message)
+
+    @staticmethod
+    def get_suggestion(invalid_key: str, valid_options: list[str]) -> str:
+        """Return a 'Did you mean X?' hint if a close match is found.
+
+        Args:
+            invalid_key: Invalid user-provided key.
+            valid_options: Valid available options.
+
+        Returns:
+            Suggestion text or an empty string.
+        """
+        matches = difflib.get_close_matches(invalid_key, valid_options, n=1, cutoff=0.6)
+        return f"\n   Did you mean '{matches[0]}'?" if matches else ""
+
+    def run(self) -> None:
+        """Iterate through profiles and execute them sequentially."""
+        try:
+            engine = BuildEngine.from_file(self.config_path, cli_vars=self.cli_vars)
+
+            profile_groups = engine.config.get(YAMLSection.PROFILE_GROUPS, {})
+            if self.group_name not in profile_groups:
+                available = list(profile_groups.keys())
+                hint = self.get_suggestion(self.group_name, available)
+                raise ValueError(
+                    f"Profile Group '{self.group_name}' not found. {hint}\n"
+                    f"Available: {available}"
+                )
+
+            profiles_to_run = profile_groups[self.group_name]
+            total_profiles = len(profiles_to_run)
+
+            self.log_message.emit(f"Starting Profile Group: {self.group_name} ")
+            self.log_message.emit(f"Profiles to run: {', '.join(profiles_to_run)} ")
+
+            for index, profile_name in enumerate(profiles_to_run, start=1):
+                self._emit_status(StatusMessage.profile(index, total_profiles, StatusCode.STARTED))
+
+                self.log_message.emit("\n" + "=" * 80)
+                self.log_message.emit(
+                    f" ({index}/{total_profiles}) Running Profile: {profile_name}\n "
+                )
+
+                log_dir = Path("build/logs")
+                log_dir.mkdir(parents=True, exist_ok=True)
+                log_file = (
+                    log_dir / f"litebuild_{self.group_name}_{profile_name}_{int(time.time())}.log"
+                )
+
+                logger = BuildLogger(log_file, log_level=LogLevel["INFO"])
+
+                profile_engine = BuildEngine.from_file(self.config_path, cli_vars=self.cli_vars)
+                step_name = profile_engine.config.get("DEFAULT_WORKFLOW_STEP")
+                if not step_name:
+                    raise ValueError(
+                        "No DEFAULT_WORKFLOW_STEP found in config for group execution."
+                    )
+
+                build_thread = threading.Thread(
+                    target=profile_engine.execute,
+                    args=(step_name, profile_name, logger),
+                    kwargs={"status_callback": self._relay_step_status},
+                )
+                build_thread.start()
+
+                last_pos = 0
+                time.sleep(0.2)
+
+                while build_thread.is_alive():
+                    if log_file.exists():
+                        with open(log_file, "r", encoding="utf-8") as file_obj:
+                            file_obj.seek(last_pos)
+                            for line in file_obj.readlines():
+                                self.log_message.emit(line.strip())
+                            last_pos = file_obj.tell()
+                    time.sleep(0.2)
+
+                build_thread.join()
+
+                if log_file.exists():
+                    with open(log_file, "r", encoding="utf-8") as file_obj:
+                        file_obj.seek(last_pos)
+                        for line in file_obj.readlines():
+                            self.log_message.emit(line.strip())
+
+                self.log_message.emit(f"✅ Profile '{profile_name}' finished.")
+                self._emit_status(StatusMessage.profile(index, total_profiles, StatusCode.DONE))
+
+            self.log_message.emit("\n" + "=" * 80)
+            self.log_message.emit(
+                f"✅ Profile Group '{self.group_name}' finished successfully. "
+            )
+            self.finished.emit()
+
+        except Exception as exc:
+            tb_str = traceback.format_exc()
+            self.log_message.emit("\n❌ A critical error occurred during the group build.")
+            self.log_message.emit(tb_str)
+            self.error.emit(exc)
+            self._emit_status(StatusMessage.profile(0, 0, StatusCode.ERROR))