fbuild 1.1.0__py3-none-any.whl

fbuild/assets/example.txt

@@ -0,0 +1 @@
+Example assets that will be deployed with python code.

fbuild/build/__init__.py

@@ -0,0 +1,117 @@
+"""
+Build system components for Fbuild.
+
+This module provides the build system implementation including:
+- Source file discovery and preprocessing
+- Compilation (avr-gcc/avr-g++)
+- Linking (avr-gcc linker, avr-objcopy)
+- Build orchestration
+"""
+
+from .source_scanner import SourceScanner, SourceCollection
+
+__all__ = [
+    'SourceScanner',
+    'SourceCollection',
+]
+
+# Import base classes
+try:
+    from .orchestrator import (  # noqa: F401
+        IBuildOrchestrator,
+        BuildResult,
+        BuildOrchestratorError
+    )
+    __all__.extend(['IBuildOrchestrator', 'BuildResult', 'BuildOrchestratorError'])
+except ImportError:
+    pass
+
+try:
+    from .compiler import ICompiler, CompilerError, ILinker, LinkerError  # noqa: F401
+    __all__.extend(['ICompiler', 'CompilerError', 'ILinker', 'LinkerError'])
+except ImportError:
+    pass
+
+# Import platform-specific implementations
+try:
+    from .compiler_avr import CompilerAVR  # noqa: F401
+    __all__.append('CompilerAVR')
+except ImportError:
+    pass
+
+try:
+    from .linker import LinkerAVR  # noqa: F401
+    __all__.append('LinkerAVR')
+except ImportError:
+    pass
+
+try:
+    from .orchestrator_avr import BuildOrchestratorAVR  # noqa: F401
+    __all__.append('BuildOrchestratorAVR')
+except ImportError:
+    pass
+
+try:
+    from .orchestrator_esp32 import OrchestratorESP32  # noqa: F401
+    __all__.append('OrchestratorESP32')
+except ImportError:
+    pass
+
+try:
+    from .binary_generator import BinaryGenerator  # noqa: F401
+    __all__.append('BinaryGenerator')
+except ImportError:
+    pass
+
+try:
+    from .build_utils import SizeInfoPrinter  # noqa: F401
+    __all__.append('SizeInfoPrinter')
+except ImportError:
+    pass
+
+try:
+    from .flag_builder import FlagBuilder  # noqa: F401
+    __all__.append('FlagBuilder')
+except ImportError:
+    pass
+
+try:
+    from .compilation_executor import CompilationExecutor  # noqa: F401
+    __all__.append('CompilationExecutor')
+except ImportError:
+    pass
+
+try:
+    from .archive_creator import ArchiveCreator  # noqa: F401
+    __all__.append('ArchiveCreator')
+except ImportError:
+    pass
+
+try:
+    from .library_dependency_processor import (  # noqa: F401
+        LibraryDependencyProcessor,
+        LibraryProcessingResult
+    )
+    __all__.extend(['LibraryDependencyProcessor', 'LibraryProcessingResult'])
+except ImportError:
+    pass
+
+try:
+    from .source_compilation_orchestrator import (  # noqa: F401
+        SourceCompilationOrchestrator,
+        SourceCompilationOrchestratorError,
+        MultiGroupCompilationResult
+    )
+    __all__.extend([
+        'SourceCompilationOrchestrator',
+        'SourceCompilationOrchestratorError',
+        'MultiGroupCompilationResult'
+    ])
+except ImportError:
+    pass
+
+try:
+    from .build_component_factory import BuildComponentFactory  # noqa: F401
+    __all__.append('BuildComponentFactory')
+except ImportError:
+    pass

fbuild/build/archive_creator.py

@@ -0,0 +1,186 @@
+"""Archive Creator.
+
+This module handles creating static library archives (.a files) from compiled
+object files using the archiver tool (ar).
+
+Design:
+    - Wraps ar command execution
+    - Creates .a archives from object files
+    - Provides clear error messages
+    - Shows archive size information
+"""
+
+import gc
+import platform
+import subprocess
+import time
+from pathlib import Path
+from typing import List
+
+
+class ArchiveError(Exception):
+    """Raised when archive creation operations fail."""
+    pass
+
+
+class ArchiveCreator:
+    """Creates static library archives from object files.
+
+    This class handles:
+    - Running archiver (ar) commands
+    - Creating .a archives from object files
+    - Validating archive creation
+    - Showing size information
+    """
+
+    def __init__(self, show_progress: bool = True):
+        """Initialize archive creator.
+
+        Args:
+            show_progress: Whether to show archive creation progress
+        """
+        self.show_progress = show_progress
+
+    def create_archive(
+        self,
+        ar_path: Path,
+        archive_path: Path,
+        object_files: List[Path]
+    ) -> Path:
+        """Create static library archive from object files.
+
+        Args:
+            ar_path: Path to archiver tool (ar)
+            archive_path: Path for output .a file
+            object_files: List of object file paths to archive
+
+        Returns:
+            Path to generated archive file
+
+        Raises:
+            ArchiveError: If archive creation fails
+        """
+        if not object_files:
+            raise ArchiveError("No object files provided for archive")
+
+        if not ar_path.exists():
+            raise ArchiveError(
+                f"Archiver not found: {ar_path}. Ensure toolchain is installed."
+            )
+
+        # Ensure archive directory exists
+        archive_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Build archiver command
+        # 'rcs' flags: r=insert/replace, c=create, s=index (ranlib)
+        cmd = [str(ar_path), "rcs", str(archive_path)]
+        cmd.extend([str(obj) for obj in object_files])
+
+        # Execute archiver
+        if self.show_progress:
+            print(f"Creating {archive_path.name} archive from {len(object_files)} object files...")
+
+        # On Windows, add retry logic to handle file locking issues
+        # Object files may still have open handles from compiler/antivirus
+        is_windows = platform.system() == "Windows"
+        max_retries = 5 if is_windows else 1
+        delay = 0.1
+        last_error = None
+
+        for attempt in range(max_retries):
+            try:
+                # On Windows, force garbage collection and add delay before retry
+                if is_windows and attempt > 0:
+                    gc.collect()
+                    time.sleep(delay)
+                    if self.show_progress:
+                        print(f"  Retrying archive creation (attempt {attempt + 1}/{max_retries})...")
+
+                result = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    timeout=60
+                )
+
+                if result.returncode != 0:
+                    # Check if error is due to file truncation/locking (Windows-specific)
+                    # Windows file locking manifests as: "file truncated", "error reading", or "No such file"
+                    stderr_lower = result.stderr.lower()
+                    is_file_locking_error = (
+                        "file truncated" in stderr_lower or
+                        "error reading" in stderr_lower or
+                        "no such file" in stderr_lower
+                    )
+                    if is_windows and is_file_locking_error:
+                        last_error = result.stderr
+                        if attempt < max_retries - 1:
+                            if self.show_progress:
+                                print("  [Windows] Detected file locking error, retrying...")
+                            delay = min(delay * 2, 1.0)  # Exponential backoff, max 1s
+                            continue
+                        else:
+                            # Last attempt failed
+                            error_msg = f"Archive creation failed after {max_retries} attempts (file locking)\n"
+                            error_msg += f"stderr: {result.stderr}\n"
+                            error_msg += f"stdout: {result.stdout}"
+                            raise ArchiveError(error_msg)
+
+                    error_msg = f"Archive creation failed for {archive_path.name}\n"
+                    error_msg += f"stderr: {result.stderr}\n"
+                    error_msg += f"stdout: {result.stdout}"
+                    raise ArchiveError(error_msg)
+
+                if not archive_path.exists():
+                    raise ArchiveError(f"Archive was not created: {archive_path}")
+
+                if self.show_progress:
+                    size = archive_path.stat().st_size
+                    print(f"✓ Created {archive_path.name}: {size:,} bytes ({size / 1024 / 1024:.2f} MB)")
+
+                return archive_path
+
+            except subprocess.TimeoutExpired as e:
+                raise ArchiveError(f"Archive creation timeout for {archive_path.name}") from e
+            except KeyboardInterrupt as ke:
+                from fbuild.interrupt_utils import handle_keyboard_interrupt_properly
+                handle_keyboard_interrupt_properly(ke)
+                raise  # Never reached, but satisfies type checker
+            except Exception as e:
+                if isinstance(e, ArchiveError):
+                    raise
+                # If Windows file locking error, retry
+                if is_windows and attempt < max_retries - 1:
+                    last_error = str(e)
+                    delay = min(delay * 2, 1.0)
+                    continue
+                raise ArchiveError(f"Failed to create archive {archive_path.name}: {e}") from e
+
+        # If we exhausted retries, raise the last error
+        if last_error:
+            raise ArchiveError(f"Archive creation failed after {max_retries} attempts: {last_error}")
+        raise ArchiveError(f"Archive creation failed after {max_retries} attempts")
+
+    def create_core_archive(
+        self,
+        ar_path: Path,
+        build_dir: Path,
+        object_files: List[Path]
+    ) -> Path:
+        """Create core.a archive from core object files.
+
+        Convenience method for creating the standard core.a archive.
+
+        Args:
+            ar_path: Path to archiver tool (ar)
+            build_dir: Build directory
+            object_files: List of core object file paths
+
+        Returns:
+            Path to generated core.a file
+
+        Raises:
+            ArchiveError: If archive creation fails
+        """
+        archive_path = build_dir / "core.a"
+        return self.create_archive(ar_path, archive_path, object_files)