pysfi 0.1.11__py3-none-any.whl → 0.1.13__py3-none-any.whl

sfi/pyloadergen/pyloadergen.py

@@ -6,58 +6,28 @@ import platform
 import shutil
 import subprocess
 import time
-from dataclasses import dataclass
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from dataclasses import dataclass, field
+from functools import cached_property
 from pathlib import Path
+from typing import Final
 
-from sfi.pyprojectparse.pyprojectparse import Project
+from sfi.pyprojectparse.pyprojectparse import Project, Solution
 
 is_windows = platform.system() == "Windows"
 is_linux = platform.system() == "Linux"
 is_macos = platform.system() == "Darwin"
 ext = ".exe" if is_windows else ""
 
-logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
+logging.basicConfig(level=logging.INFO, format="%(message)s")
 logger = logging.getLogger(__name__)
 cwd = Path.cwd()
 
+# Default cache directory
+_DEFAULT_BUILD_DIR = Path(".cbuild")
+_DEFAULT_OUTPUT_DIR = Path("dist")
 
-@dataclass(frozen=True)
-class CompilerConfig:
-    """Compiler configuration dataclass.
-
-    Attributes:
-        name: Compiler name
-        args: List of compiler arguments
-    """
-
-    name: str
-    args: tuple[str, ...]
-
-    def to_list(self) -> list[str]:
-        """Convert arguments to list.
-
-        Returns:
-            List of compiler arguments
-        """
-        return list(self.args)
-
-
-@dataclass(frozen=True)
-class EntryFile:
-    """Entry file dataclass."""
-
-    project_name: str
-    source_file: Path
-
-    @property
-    def entry_name(self) -> str:
-        """Get entry file name."""
-        return self.source_file.stem
-
-    def __repr__(self) -> str:
-        return f"<EntryFile project_name={self.project_name} source_file={self.source_file}>"
-
-
+# Platform templates
 _WINDOWS_GUI_TEMPLATE: str = r"""#include <windows.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -84,17 +54,31 @@ static void build_python_command(
     char script_path[MAX_PATH_LEN];
 
     // Build Python interpreter path
-    snprintf(python_runtime, MAX_PATH_LEN, "%s\\runtime\\%s", exe_dir, is_debug ? "python.exe" : "pythonw.exe");
+    // Debug mode: use python.exe to show console output
+    // Production GUI mode: use pythonw.exe to hide console window
+    if (is_debug) {
+        snprintf(python_runtime, MAX_PATH_LEN, "%s\\runtime\\python.exe", exe_dir);
+    } else {
+        snprintf(python_runtime, MAX_PATH_LEN, "%s\\runtime\\pythonw.exe", exe_dir);
+    }
 
     // Build startup script path
     snprintf(script_path, MAX_PATH_LEN, "%s\\%s", exe_dir, entry_file);
 
-    // Build command line: python runtime -u script [args] [2>&1 for production]
-    snprintf(cmd, MAX_PATH_LEN * 2, "\"%s\" -u \"%s\"%s%s%s",
-        python_runtime, script_path,
-        lpCmdLine && strlen(lpCmdLine) > 0 ? " " : "",
-        lpCmdLine && strlen(lpCmdLine) > 0 ? lpCmdLine : "",
-        is_debug ? "" : " 2>&1");
+    // Build command line
+    if (is_debug) {
+        // Debug mode: don't redirect output, let output show in console
+        snprintf(cmd, MAX_PATH_LEN * 2, "\"%s\" -u \"%s\"%s%s",
+            python_runtime, script_path,
+            lpCmdLine && strlen(lpCmdLine) > 0 ? " " : "",
+            lpCmdLine && strlen(lpCmdLine) > 0 ? lpCmdLine : "");
+    } else {
+        // Production mode: redirect all output to pipe
+        snprintf(cmd, MAX_PATH_LEN * 2, "\"%s\" -u \"%s\"%s%s 2>&1",
+            python_runtime, script_path,
+            lpCmdLine && strlen(lpCmdLine) > 0 ? " " : "",
+            lpCmdLine && strlen(lpCmdLine) > 0 ? lpCmdLine : "");
+    }
 }
 
 // Read process output
@@ -166,6 +150,12 @@ int APIENTRY WinMain(
         return 1;
     }
 
+    // Build Python command
+    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", ${DEBUG_MODE}, lpCmdLine);
+
+    // Setup startup info
+    si.cb = sizeof(si);
+
     // Create pipe for capturing output (only in production mode)
     if (!${DEBUG_MODE}) {
         sa.nLength = sizeof(SECURITY_ATTRIBUTES);
@@ -177,23 +167,17 @@ int APIENTRY WinMain(
             return 1;
         }
 
-        si.cb = sizeof(si);
         si.dwFlags = STARTF_USESTDHANDLES;
         si.hStdError = hWritePipe;
         si.hStdOutput = hWritePipe;
-    } else {
-        si.cb = sizeof(si);
     }
 
-    // Build and execute Python command
-    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", ${DEBUG_MODE}, lpCmdLine);
-
     // Create Python process
     // Debug mode: do not use CREATE_NO_WINDOW, let python.exe create console
     // Production GUI mode: use CREATE_NO_WINDOW to ensure no console is created
     DWORD createFlags = ${DEBUG_MODE} ? 0 : CREATE_NO_WINDOW;
     success = CreateProcessA(
-        NULL, cmd, NULL, NULL, FALSE,
+        NULL, cmd, NULL, NULL, ${DEBUG_MODE} ? TRUE : FALSE,
         createFlags,
         NULL, exe_dir, &si, &pi
     );
@@ -331,7 +315,7 @@ int main(int argc, char* argv[]) {
     // Get executable directory
     GetModuleFileNameA(NULL, exe_dir, MAX_PATH_LEN);
     if ((last_slash = strrchr(exe_dir, '\\'))) *last_slash = '\0';
-`
+
     // Check Python runtime
     if (!check_python_runtime(exe_dir)) {
         fprintf(stderr, "Error: Python runtime not found at %s\\runtime\\\n", exe_dir);
@@ -418,12 +402,17 @@ _UNIX_GUI_TEMPLATE: str = r"""#define _GNU_SOURCE
 static void build_python_command(
     char* cmd,
     const char* exe_dir,
-    const char* entry_file
+    const char* entry_file,
+    int argc,
+    char* argv[]
 ) {
     char script_path[MAX_PATH_LEN];
+    char* p = cmd;
+    size_t remaining = MAX_PATH_LEN * 3;
+    int len;
 
     // Build startup script path
-    snprintf(script_path, MAX_PATH_LEN * 2, "%s/%s", exe_dir, entry_file);
+    snprintf(script_path, MAX_PATH_LEN, "%s/%s", exe_dir, entry_file);
 
     // Build log file path (record error information)
     char log_file[MAX_PATH_LEN];
@@ -431,15 +420,28 @@ static void build_python_command(
 
     // Build command line - use system python3 instead of bundled runtime
     // GUI mode uses nohup and background execution, error output to log
-    snprintf(cmd, MAX_PATH_LEN * 2,
-        "cd \"%s\" && nohup python3 -u \"%s\" >\"%s\" 2>&1 &",
-        exe_dir, script_path, log_file
-    );
+    len = snprintf(p, remaining,
+        "cd \"%s\" && nohup python3 -u \"%s\"",
+        exe_dir, script_path);
+    p += len;
+    remaining -= len;
+
+    // Append command line arguments
+    for (int i = 1; i < argc && remaining > 0; i++) {
+        len = snprintf(p, remaining, " \"%s\"", argv[i]);
+        if (len < 0 || (size_t)len >= remaining) break;
+        p += len;
+        remaining -= len;
+    }
+
+    // Append log redirection
+    if (remaining > 0) {
+        snprintf(p, remaining, " >\"%s\" 2>&1 &", log_file);
+    }
 }
 
 // Unix GUI entry point
 int main(int argc, char* argv[]) {
-    (void)argc;
     char exe_dir[MAX_PATH_LEN];
     char cmd[MAX_PATH_LEN * 3];
     char log_file[MAX_PATH_LEN];
@@ -458,7 +460,7 @@ int main(int argc, char* argv[]) {
     if ((last_slash = strrchr(exe_dir, '/'))) *last_slash = '\0';
 
     // Build and execute Python command
-    build_python_command(cmd, exe_dir, "${ENTRY_FILE}");
+    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", argc, argv);
     snprintf(log_file, MAX_PATH_LEN, "%s/.error_log", exe_dir);
 
     // Execute Python process in background
@@ -508,25 +510,37 @@ _UNIX_CONSOLE_TEMPLATE: str = r"""#define _GNU_SOURCE
 static void build_python_command(
     char* cmd,
     const char* exe_dir,
-    const char* entry_file
+    const char* entry_file,
+    int argc,
+    char* argv[]
 ) {
     char script_path[MAX_PATH_LEN];
+    char* p = cmd;
+    size_t remaining = MAX_PATH_LEN * 2;
+    int len;
 
     // Build startup script path
     snprintf(script_path, MAX_PATH_LEN, "%s/%s", exe_dir, entry_file);
 
     // Build command line - use system python3 instead of bundled runtime
     // add -u parameter for real-time output capture
-    snprintf(cmd, MAX_PATH_LEN * 2,
+    len = snprintf(p, remaining,
         "cd \"%s\" && python3 -u \"%s\"",
-        exe_dir, script_path
-    );
+        exe_dir, script_path);
+    p += len;
+    remaining -= len;
+
+    // Append command line arguments
+    for (int i = 1; i < argc && remaining > 0; i++) {
+        len = snprintf(p, remaining, " \"%s\"", argv[i]);
+        if (len < 0 || (size_t)len >= remaining) break;
+        p += len;
+        remaining -= len;
+    }
 }
 
 // Unix Console entry point
 int main(int argc, char* argv[]) {
-    (void)argc;
-    (void)argv;
     char exe_dir[MAX_PATH_LEN];
     char cmd[MAX_PATH_LEN * 3];
     pid_t pid;
@@ -543,7 +557,7 @@ int main(int argc, char* argv[]) {
     if ((last_slash = strrchr(exe_dir, '/'))) *last_slash = '\0';
 
     // Build and execute Python command
-    build_python_command(cmd, exe_dir, "${ENTRY_FILE}");
+    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", argc, argv);
 
     // Fork and execute Python process
     pid = fork();
@@ -637,11 +651,16 @@ static void show_error_dialog(const char* message) {
 static void build_python_command(
     char* cmd,
     const char* exe_dir,
-    const char* entry_file
+    const char* entry_file,
+    int argc,
+    char* argv[]
 ) {
     char python_runtime[MAX_PATH_LEN];
     char script_path[MAX_PATH_LEN];
     char log_file[MAX_PATH_LEN];
+    char* p = cmd;
+    size_t remaining = MAX_PATH_LEN * 2;
+    int len;
 
     // macOS Python path
     snprintf(python_runtime, MAX_PATH_LEN, "%s/runtime/bin/python3", exe_dir);
@@ -651,16 +670,28 @@ static void build_python_command(
     snprintf(log_file, MAX_PATH_LEN, "%s/.error_log", exe_dir);
 
     // Build command line (GUI mode uses nohup and background execution, error output to log)
-    snprintf(cmd, MAX_PATH_LEN * 2,
-        "cd \"%s\" && nohup \"%s\" -u \"%s\" >\"%s\" 2>&1 &",
-        exe_dir, python_runtime, script_path, log_file
-    );
+    len = snprintf(p, remaining,
+        "cd \"%s\" && nohup \"%s\" -u \"%s\"",
+        exe_dir, python_runtime, script_path);
+    p += len;
+    remaining -= len;
+
+    // Append command line arguments
+    for (int i = 1; i < argc && remaining > 0; i++) {
+        len = snprintf(p, remaining, " \"%s\"", argv[i]);
+        if (len < 0 || (size_t)len >= remaining) break;
+        p += len;
+        remaining -= len;
+    }
+
+    // Append log redirection
+    if (remaining > 0) {
+        snprintf(p, remaining, " >\"%s\" 2>&1 &", log_file);
+    }
 }
 
 // macOS GUI entry point
 int main(int argc, char* argv[]) {
-    (void)argc;
-    (void)argv;
     char exe_dir[MAX_PATH_LEN];
     char cmd[MAX_PATH_LEN * 3];
     char log_file[MAX_PATH_LEN];
@@ -684,7 +715,7 @@ int main(int argc, char* argv[]) {
     }
 
     // Build and execute Python command
-    build_python_command(cmd, exe_dir, "${ENTRY_FILE}");
+    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", argc, argv);
     snprintf(log_file, MAX_PATH_LEN, "%s/.error_log", exe_dir);
 
     // Execute Python process in background
@@ -738,6 +769,8 @@ _MACOS_CONSOLE_TEMPLATE: str = r"""#define _GNU_SOURCE
 #include <unistd.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
+#include <errno.h>
+#include <CoreFoundation/CoreFoundation.h>
 
 #define MAX_PATH_LEN 4096
 
@@ -772,25 +805,37 @@ static void get_exe_dir_macos(char* exe_dir, size_t size) {
 static void build_python_command(
     char* cmd,
     const char* exe_dir,
-    const char* entry_file
+    const char* entry_file,
+    int argc,
+    char* argv[]
 ) {
     char python_runtime[MAX_PATH_LEN];
     char script_path[MAX_PATH_LEN];
+    char* p = cmd;
+    size_t remaining = MAX_PATH_LEN;
+    int len;
 
     snprintf(python_runtime, MAX_PATH_LEN, "%s/runtime/bin/python3", exe_dir);
     snprintf(script_path, MAX_PATH_LEN, "%s/%s", exe_dir, entry_file);
 
     // Build command line (add -u parameter for real-time output capture)
-    snprintf(cmd, MAX_PATH_LEN,
+    len = snprintf(p, remaining,
         "cd \"%s\" && \"%s\" -u \"%s\"",
-        exe_dir, python_runtime, script_path
-    );
+        exe_dir, python_runtime, script_path);
+    p += len;
+    remaining -= len;
+
+    // Append command line arguments
+    for (int i = 1; i < argc && remaining > 0; i++) {
+        len = snprintf(p, remaining, " \"%s\"", argv[i]);
+        if (len < 0 || (size_t)len >= remaining) break;
+        p += len;
+        remaining -= len;
+    }
 }
 
 // macOS Console entry point
 int main(int argc, char* argv[]) {
-    (void)argc;
-    (void)argv;
     char exe_dir[MAX_PATH_LEN];
     char cmd[MAX_PATH_LEN * 3];
     char python_runtime[MAX_PATH_LEN];
@@ -809,7 +854,7 @@ int main(int argc, char* argv[]) {
     }
 
     // Build and execute Python command
-    build_python_command(cmd, exe_dir, "${ENTRY_FILE}");
+    build_python_command(cmd, exe_dir, "${ENTRY_FILE}", argc, argv);
 
     // Fork and execute Python process
     pid = fork();
@@ -867,12 +912,76 @@ from src.$PROJECT_NAME.$ENTRY_NAME import main
 main()
 """
 
-# Compiler configurations using frozenset for better performance
-_COMPILER_CONFIGS: frozenset[CompilerConfig] = frozenset([
+
+@dataclass(frozen=True)
+class CompilerConfig:
+    """Compiler configuration dataclass.
+
+    Attributes:
+        name: Compiler name
+        args: Tuple of compiler arguments
+    """
+
+    name: str
+    args: tuple[str, ...]
+
+    def to_list(self) -> list[str]:
+        """Convert arguments to list.
+
+        Returns:
+            List of compiler arguments
+        """
+        return list(self.args)
+
+
+@dataclass(frozen=True)
+class EntryFile:
+    """Entry file dataclass with enhanced functionality."""
+
+    project_name: str
+    source_file: Path
+
+    @cached_property
+    def entry_name(self) -> str:
+        """Get entry file name."""
+        return self.source_file.stem
+
+    @cached_property
+    def module_name(self) -> str:
+        """Get module name from source file stem."""
+        return self.source_file.stem.replace("-", "_")
+
+    @cached_property
+    def is_gui(self) -> bool:
+        """Determine if this entry file is a GUI application.
+
+        Entry file is considered GUI if:
+        1. File name contains 'gui' (e.g., docscan_gui.py, myapp-gui.py)
+        2. File imports GUI frameworks (PySide2, PyQt5, PyQt6, tkinter)
+        """
+        # Check file name for 'gui' keyword
+        if "gui" in self.source_file.stem.lower():
+            return True
+
+        # Check file content for GUI framework imports
+        try:
+            content = self.source_file.read_text(encoding="utf-8")
+            gui_keywords = ["pyside2", "pyqt5", "pyqt6", "tkinter", "tkinter.ttk"]
+            return any(f"from {kw}" in content.lower() or f"import {kw}" in content.lower()
+                      for kw in gui_keywords)
+        except Exception:
+            return False
+
+    def __repr__(self) -> str:
+        return f"<EntryFile project_name={self.project_name} source_file={self.source_file} entry_name={self.entry_name} is_gui={self.is_gui}>"
+
+
+# Compiler configurations
+_COMPILER_CONFIGS: Final = [
     CompilerConfig(name="gcc", args=("-std=c99", "-Wall", "-O2")),
     CompilerConfig(name="clang", args=("-std=c99", "-Wall", "-O2")),
     CompilerConfig(name="cl", args=("/std:c99", "/O2")),
-])
+]
 
 
 def find_compiler() -> str | None:
@@ -1090,156 +1199,199 @@ def _detect_entry_files(
     return entry_files
 
 
-def _generate_single_loader(
-    project: Project,
-    project_dir: Path,
-    entry_file: EntryFile,
-    is_debug: bool,
-) -> bool:
-    """Generate a single loader executable and entry file.
+@dataclass
+class PyLoaderBuilder:
+    """Helper class to build individual loaders."""
 
-    Args:
-        project_dir: Project directory
-        entry_name: Entry file name (e.g., "docscan", "docscan-gui")
-        entry_module: Python module name (e.g., "docscan", "docscan_gui")
-        loader_type: Loader type ("console" or "gui")
-        use_qt: Whether this is a Qt application
-        is_debug: Whether to generate debug version
-        compiler: Optional compiler to use
+    parent: PyLoaderGenerator
+    project: Project
+    entry_file: EntryFile
+    is_debug: bool = False
 
-    Returns:
-        True if successful, False otherwise
-    """
-    entry_name = entry_file.entry_name
-
-    # Prepare directories
-    build_dir = project_dir / ".cbuild"
-    output_dir = project_dir / "dist"
-    build_dir.mkdir(parents=True, exist_ok=True)
-    output_dir.mkdir(parents=True, exist_ok=True)
-
-    # Output paths
-    output_exe = output_dir / f"{entry_name}{ext}"
-    c_source_filename = (
-        f"{entry_name}_debug_console.c"
-        if is_debug
-        else f"{entry_name}_{project.is_gui}.c"
-    )
-    entry_filepath = output_dir / f"{entry_name}.ent"
-    c_source_path = build_dir / c_source_filename
-
-    t0 = time.perf_counter()
-
-    # Generate entry file
-    # Extract project name from entry_name (remove -gui suffix if present)
-    entry_file_code = prepare_entry_file(project=project, entry_stem=entry_name)
-    entry_filepath.write_text(entry_file_code, encoding="utf-8")
-    logger.debug(f"Generated entry file: {entry_filepath}")
-
-    # Generate and compile C source
-    c_template = select_c_template(project.loader_type, is_debug)
-    c_code = prepare_c_source(c_template, entry_filepath.name, is_debug)
-    c_source_path.write_text(c_code, encoding="utf-8")
-    logger.debug(f"Generated C source code: {c_source_path}")
-
-    compiler = find_compiler()
-    if not compiler:
-        logger.error(f"Failed to find compiler: {compiler}")
-        return False
+    @cached_property
+    def build_dir(self) -> Path:
+        """Build directory path."""
+        return self.parent.root_dir / _DEFAULT_BUILD_DIR
 
-    success = compile_c_source(c_source_path, output_exe, compiler)
-    if success:
-        logger.info(f"Loader executable generated successfully: {output_exe}")
-        logger.debug(f"Entry: {entry_file}")
-        logger.debug(f"Type: {project.loader_type}")
-        logger.debug(f"Qt: {project.has_qt}")
-        logger.debug(f"Debug mode: {is_debug}")
-        logger.debug(f"Compilation time: {time.perf_counter() - t0:.4f} seconds")
-    else:
-        logger.error(f"Failed to compile loader for {entry_name}")
+    @cached_property
+    def output_dir(self) -> Path:
+        """Output directory path."""
+        return self.parent.root_dir / _DEFAULT_OUTPUT_DIR
 
-    return success
+    @cached_property
+    def output_exe(self) -> Path:
+        """Output executable path."""
+        return self.output_dir / f"{self.entry_file.entry_name}{ext}"
 
+    @cached_property
+    def loader_type(self) -> str:
+        """Determine loader type based on entry file.
 
-def generate_loader_for_project(
-    project: Project,
-    project_dir: Path,
-    debug: bool = False,
-):
-    """Generate loader executables and entry files for a single project.
+        Entry file is GUI if:
+        - The entry file itself is detected as GUI (contains 'gui' in name or imports GUI libs)
+        - Otherwise, fall back to project-level loader_type
+        """
+        return "gui" if self.entry_file.is_gui else self.project.loader_type
+
+    @cached_property
+    def c_source_path(self) -> Path:
+        """C source file path."""
+        filename = (
+            f"{self.entry_file.entry_name}_debug_console.c"
+            if self.is_debug
+            else f"{self.entry_file.entry_name}_{self.loader_type}.c"
+        )
+        return self.build_dir / filename
 
-    This function detects all entry files (main and GUI versions) and generates
-    a loader for each one.
+    @cached_property
+    def entry_filepath(self) -> Path:
+        """Entry file path."""
+        return self.output_dir / f"{self.entry_file.entry_name}.ent"
 
-    Args:
-        project: Project information dataclass
-        project_dir: Directory containing the project (pyproject.toml location)
-        debug: Whether to generate debug version
-    """
-    # Determine base loader type and Qt usage from project info
-    # Detect all entry files in project directory
-    entry_files = _detect_entry_files(project_dir, project.name)
-    if not entry_files:
-        logger.error(f"No entry files found in {project_dir}")
-        return False
+    def generate(self) -> bool:
+        """Generate loader for a single entry file."""
+        t0 = time.perf_counter()
+
+        # Prepare directories
+        self.build_dir.mkdir(parents=True, exist_ok=True)
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+        # Generate entry file
+        entry_file_code = prepare_entry_file(
+            project=self.project, entry_stem=self.entry_file.entry_name
+        )
+        self.entry_filepath.write_text(entry_file_code, encoding="utf-8")
+        logger.debug(f"Generated entry file: {self.entry_filepath}")
+
+        # Generate and compile C source
+        c_template = select_c_template(self.loader_type, self.is_debug)
+        c_code = prepare_c_source(c_template, self.entry_filepath.name, self.is_debug)
+        self.c_source_path.write_text(c_code, encoding="utf-8")
+        logger.debug(f"Generated C source code: {self.c_source_path}")
 
-    # Generate loaders for all entry files
-    for entry_file in entry_files:
-        logger.debug(f"Generating loader for: {entry_file.project_name}")
-        if not _generate_single_loader(
-            project=project,
-            project_dir=project_dir,
-            entry_file=entry_file,
-            is_debug=debug,
-        ):
+        compiler = find_compiler()
+        if not compiler:
+            logger.error(f"Failed to find compiler: {compiler}")
             return False
 
-    return True
+        success = compile_c_source(self.c_source_path, self.output_exe, compiler)
+        if success:
+            logger.info(f"Loader executable generated successfully: {self.output_exe}")
+            logger.debug(f"Entry: {self.entry_file}")
+            logger.debug(f"Type: {self.loader_type}")
+            logger.debug(f"Qt: {self.project.has_qt}")
+            logger.debug(f"Debug mode: {self.is_debug}")
+            logger.debug(f"Compilation time: {time.perf_counter() - t0:.4f} seconds")
+        else:
+            logger.error(f"Failed to compile loader for {self.entry_file.entry_name}")
 
+        return success
 
-def generate_loader(base_dir: Path, debug: bool) -> None:
-    """Generate loader executables for all projects in the given directory."""
-    from sfi.pyprojectparse.pyprojectparse import Solution
 
-    projects = Solution.projects
-    if not projects:
-        logger.error("Failed to load project information")
+@dataclass
+class PyLoaderGenerator:
+    """Main class for generating Python loader executables."""
 
-    success_count = 0
-    failed_projects: list[str] = []
+    root_dir: Path
+    build_dir: Path = field(default_factory=lambda: _DEFAULT_BUILD_DIR)
+    output_dir: Path = field(default_factory=lambda: _DEFAULT_OUTPUT_DIR)
+    compiler: str | None = None
 
-    if len(projects) == 1:
-        logger.debug("Only one project found, using current directory")
-        project_dir = base_dir
-        if generate_loader_for_project(
-            project=next(iter(projects.values())),
-            project_dir=project_dir,
-            debug=debug,
-        ):
-            success_count += 1
-        else:
-            failed_projects.append(next(iter(projects)))
-    else:
-        for project_name, project in projects.items():
-            project_dir = base_dir / project_name
-            if not project_dir.is_dir():
-                logger.error(f"Project directory not found: {project_dir}, skipping...")
-                failed_projects.append(project_name)
-                continue
-
-            if generate_loader_for_project(
-                project=project,
+    @cached_property
+    def solution(self) -> Solution:
+        """Get the solution from the target directory."""
+        return Solution.from_directory(self.root_dir)
+
+    def generate_for_project(
+        self, project: Project, project_dir: Path, debug: bool = False
+    ) -> bool:
+        """Generate loader executables and entry files for a single project.
+
+        This function detects all entry files (main and GUI versions) and generates
+        a loader for each one.
+
+        Args:
+            project: Project information dataclass
+            project_dir: Directory containing the project (pyproject.toml location)
+            debug: Whether to generate debug version
+        """
+        # Detect all entry files in project directory
+        entry_files = _detect_entry_files(project_dir, project.name)
+        if not entry_files:
+            logger.error(f"No entry files found in {project_dir}")
+            return False
+
+        # Generate loaders for all entry files
+        for entry_file in entry_files:
+            logger.debug(f"Generating loader for: {entry_file.project_name}")
+            builder = PyLoaderBuilder(
+                parent=self, project=project, entry_file=entry_file, is_debug=debug
+            )
+
+            if not builder.generate():
+                return False
+
+        return True
+
+    def run(self, debug: bool = False) -> None:
+        """Generate loader executables for all projects concurrently."""
+        projects = self.solution.projects
+        if not projects:
+            logger.error("Failed to load project information")
+            return
+
+        success_count = 0
+        failed_projects: list[str] = []
+
+        if len(projects) == 1:
+            logger.debug("Only one project found, using current directory")
+            project_dir = self.root_dir
+            if self.generate_for_project(
+                project=next(iter(projects.values())),
                 project_dir=project_dir,
                 debug=debug,
             ):
                 success_count += 1
             else:
-                failed_projects.append(project_name)
-
-    logger.info(f"Pack {success_count}/{len(projects)} projects successfully")
-
-    if failed_projects:
-        logger.error(f"Failed: {failed_projects}")
+                failed_projects.append(next(iter(projects)))
+        else:
+            # Prepare project tasks
+            project_tasks = []
+            for project_name, project in projects.items():
+                project_dir = self.root_dir / project_name
+                if not project_dir.is_dir():
+                    logger.error(
+                        f"Project directory not found: {project_dir}, skipping..."
+                    )
+                    failed_projects.append(project_name)
+                    continue
+                project_tasks.append((project_name, project, project_dir))
+
+            # Execute compilation tasks concurrently
+            logger.info(f"Compiling {len(project_tasks)} projects concurrently...")
+            with ThreadPoolExecutor(max_workers=None) as executor:
+                future_to_project = {
+                    executor.submit(
+                        self.generate_for_project, project, project_dir, debug
+                    ): project_name
+                    for project_name, project, project_dir in project_tasks
+                }
+
+                for future in as_completed(future_to_project):
+                    project_name = future_to_project[future]
+                    try:
+                        if future.result():
+                            success_count += 1
+                        else:
+                            failed_projects.append(project_name)
+                    except Exception as e:
+                        logger.error(f"Project {project_name} compilation failed: {e}")
+                        failed_projects.append(project_name)
+
+        logger.info(f"Pack {success_count}/{len(projects)} projects successfully")
+
+        if failed_projects:
+            logger.error(f"Failed: {failed_projects}")
 
 
 def parse_args() -> argparse.Namespace:
@@ -1273,7 +1425,9 @@ def main():
         return
 
     logger.info(f"Working directory: {working_dir}")
-    generate_loader(working_dir, args.debug)
+
+    generator = PyLoaderGenerator(root_dir=working_dir, compiler=args.compiler)
+    generator.run(debug=args.debug)
 
 
 if __name__ == "__main__":