fbuild 1.2.8__py3-none-any.whl → 1.2.15__py3-none-any.whl

fbuild/output.py

@@ -32,12 +32,13 @@ import sys
 import time
 from pathlib import Path
 from types import TracebackType
-from typing import Optional, TextIO
+from typing import Optional, Protocol, TextIO, runtime_checkable
 
 # Global state for the timer
 _start_time: Optional[float] = None
 _output_stream: TextIO = sys.stdout
 _verbose: bool = True
+_output_file: Optional[TextIO] = None
 
 
 def init_timer(output_stream: Optional[TextIO] = None) -> None:
@@ -77,6 +78,27 @@ def set_verbose(verbose: bool) -> None:
     _verbose = verbose
 
 
+def set_output_file(output_file: Optional[TextIO]) -> None:
+    """
+    Set a file to receive all log output (in addition to stdout).
+
+    Args:
+        output_file: File object to receive output, or None to disable file output
+    """
+    global _output_file
+    _output_file = output_file
+
+
+def get_output_file() -> Optional[TextIO]:
+    """
+    Get the current output file.
+
+    Returns:
+        The current output file, or None if not set
+    """
+    return _output_file
+
+
 def get_elapsed() -> float:
     """
     Get elapsed time since timer initialization.
@@ -112,9 +134,15 @@ def _print(message: str, end: str = "\n") -> None:
         end: End character (default newline)
     """
     timestamp = format_timestamp()
-    _output_stream.write(f"{timestamp} {message}{end}")
+    line = f"{timestamp} {message}{end}"
+    _output_stream.write(line)
     _output_stream.flush()
 
+    # Also write to output file if set
+    if _output_file is not None:
+        _output_file.write(line)
+        _output_file.flush()
+
 
 def log(message: str, verbose_only: bool = False) -> None:
     """
@@ -350,3 +378,211 @@ class TimedLogger:
     def log(self, message: str) -> None:
         """Log a message within this operation."""
         log(message, self.verbose_only)
+
+
+# =============================================================================
+# Progress Callback Protocol and Helpers
+# =============================================================================
+
+
+def format_size(size_bytes: int) -> str:
+    """
+    Format a byte count as a human-readable size.
+
+    Args:
+        size_bytes: Size in bytes
+
+    Returns:
+        Human-readable size string (e.g., "1.2 MB", "340 KB", "12 B")
+    """
+    if size_bytes < 0:
+        return "0 B"
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    elif size_bytes < 1024 * 1024 * 1024:
+        return f"{size_bytes / (1024 * 1024):.1f} MB"
+    else:
+        return f"{size_bytes / (1024 * 1024 * 1024):.1f} GB"
+
+
+def format_progress_bar(current: int, total: int, width: int = 28) -> str:
+    """
+    Generate an ASCII progress bar.
+
+    Args:
+        current: Current progress value
+        total: Total progress value
+        width: Width of the progress bar in characters (default 28)
+
+    Returns:
+        ASCII progress bar string like "████████░░░░░░░░░░░░░░░░░░░░"
+
+    Examples:
+        >>> format_progress_bar(5, 10, 20)
+        '██████████░░░░░░░░░░'
+        >>> format_progress_bar(0, 10, 10)
+        '░░░░░░░░░░'
+        >>> format_progress_bar(10, 10, 10)
+        '██████████'
+    """
+    if total <= 0:
+        return "░" * width
+    ratio = min(1.0, max(0.0, current / total))
+    filled = int(width * ratio)
+    empty = width - filled
+    return "█" * filled + "░" * empty
+
+
+@runtime_checkable
+class ProgressCallback(Protocol):
+    """
+    Protocol for progress callback implementations.
+
+    This protocol defines the interface for tracking build progress events.
+    Implementations can log to terminal, update TUI elements, or report to daemons.
+    """
+
+    def on_file_start(self, file: str, index: int, total: int) -> None:
+        """
+        Called when compilation of a file starts.
+
+        Args:
+            file: Name or path of the file being compiled
+            index: Current file index (1-based)
+            total: Total number of files to compile
+        """
+        ...
+
+    def on_file_complete(self, file: str, index: int, total: int, cached: bool = False) -> None:
+        """
+        Called when compilation of a file completes.
+
+        Args:
+            file: Name or path of the file that was compiled
+            index: Current file index (1-based)
+            total: Total number of files to compile
+            cached: If True, the file was served from cache (not recompiled)
+        """
+        ...
+
+    def on_download_progress(self, url: str, downloaded: int, total: int) -> None:
+        """
+        Called during file download to report progress.
+
+        Args:
+            url: URL being downloaded
+            downloaded: Bytes downloaded so far
+            total: Total bytes to download (0 if unknown)
+        """
+        ...
+
+    def on_extract_progress(self, archive: str, extracted: int, total: int) -> None:
+        """
+        Called during archive extraction to report progress.
+
+        Args:
+            archive: Archive file being extracted
+            extracted: Number of files/items extracted so far
+            total: Total number of files/items to extract
+        """
+        ...
+
+    def on_phase_start(self, phase: int, total: int, message: str) -> None:
+        """
+        Called when a build phase starts.
+
+        Args:
+            phase: Current phase number (1-based)
+            total: Total number of phases
+            message: Phase description
+        """
+        ...
+
+    def on_phase_complete(self, phase: int, total: int, elapsed: float) -> None:
+        """
+        Called when a build phase completes.
+
+        Args:
+            phase: Completed phase number (1-based)
+            total: Total number of phases
+            elapsed: Time spent in this phase (seconds)
+        """
+        ...
+
+
+class DefaultProgressCallback:
+    """
+    Default implementation of ProgressCallback that logs to the existing output system.
+
+    This implementation uses log_detail() and log_phase() to display progress
+    in a format consistent with the rest of fbuild's output.
+    """
+
+    def __init__(self, verbose_only: bool = False, show_progress_bar: bool = True):
+        """
+        Initialize the default progress callback.
+
+        Args:
+            verbose_only: If True, only log when verbose mode is enabled
+            show_progress_bar: If True, show ASCII progress bars for downloads/extractions
+        """
+        self.verbose_only = verbose_only
+        self.show_progress_bar = show_progress_bar
+        self._last_download_percent: int = -1
+        self._last_extract_percent: int = -1
+
+    def on_file_start(self, file: str, index: int, total: int) -> None:
+        """Log file compilation start."""
+        log_detail(f"[{index}/{total}] Compiling {file}...", verbose_only=self.verbose_only)
+
+    def on_file_complete(self, file: str, index: int, total: int, cached: bool = False) -> None:
+        """Log file compilation completion."""
+        suffix = " (cached)" if cached else ""
+        log_detail(f"[{index}/{total}] {file}{suffix}", verbose_only=True)
+
+    def on_download_progress(self, url: str, downloaded: int, total: int) -> None:
+        """Log download progress (rate-limited to avoid excessive output)."""
+        if total <= 0:
+            return
+
+        percent = int(100 * downloaded / total)
+        # Only log at 10% intervals to avoid spam
+        if percent // 10 == self._last_download_percent // 10 and percent != 100:
+            return
+        self._last_download_percent = percent
+
+        filename = url.split("/")[-1][:30]
+        if self.show_progress_bar:
+            bar = format_progress_bar(downloaded, total, 20)
+            log_detail(f"{bar} {percent:3d}% {filename} ({format_size(downloaded)}/{format_size(total)})", verbose_only=self.verbose_only)
+        else:
+            log_detail(f"Downloading {filename}: {percent}% ({format_size(downloaded)}/{format_size(total)})", verbose_only=self.verbose_only)
+
+    def on_extract_progress(self, archive: str, extracted: int, total: int) -> None:
+        """Log extraction progress (rate-limited to avoid excessive output)."""
+        if total <= 0:
+            return
+
+        percent = int(100 * extracted / total)
+        # Only log at 25% intervals to avoid spam
+        if percent // 25 == self._last_extract_percent // 25 and percent != 100:
+            return
+        self._last_extract_percent = percent
+
+        archive_name = Path(archive).name[:30]
+        if self.show_progress_bar:
+            bar = format_progress_bar(extracted, total, 20)
+            log_detail(f"{bar} {percent:3d}% Extracting {archive_name} ({extracted}/{total} files)", verbose_only=self.verbose_only)
+        else:
+            log_detail(f"Extracting {archive_name}: {percent}% ({extracted}/{total} files)", verbose_only=self.verbose_only)
+
+    def on_phase_start(self, phase: int, total: int, message: str) -> None:
+        """Log phase start using log_phase."""
+        log_phase(phase, total, f"{message}...", verbose_only=self.verbose_only)
+
+    def on_phase_complete(self, phase: int, total: int, elapsed: float) -> None:
+        """Log phase completion with elapsed time."""
+        del phase, total  # Unused in default implementation
+        log_detail(f"Done ({elapsed:.2f}s)", verbose_only=self.verbose_only)

fbuild/packages/library_compiler.py

@@ -8,6 +8,8 @@ import subprocess
 from pathlib import Path
 from typing import TYPE_CHECKING, Callable, List, Optional, Tuple
 
+from fbuild.output import ProgressCallback, log_detail
+
 if TYPE_CHECKING:
     from .library_manager import LibraryInfo
 
@@ -70,6 +72,7 @@ class LibraryCompiler:
         defines: List[str],
         extra_flags: List[str],
         show_progress: bool = True,
+        progress_callback: ProgressCallback | None = None,
     ) -> Tuple[Path, List[Path], List[str]]:
         """Compile a library into a static archive (.a file).
 
@@ -97,7 +100,7 @@ class LibraryCompiler:
         """
         try:
             if show_progress:
-                print(f"Compiling library: {library_name}")
+                log_detail(f"Compiling library: {library_name}")
 
             if not source_files:
                 raise LibraryCompilationError(f"No source files found in library '{library_name}'")
@@ -155,14 +158,21 @@ class LibraryCompiler:
                 compile_commands.append(" ".join(cmd))
 
                 # Compile
-                if show_progress:
-                    print(f"  Compiling {source.name}...")
+                file_index = source_files.index(source) + 1  # 1-based indexing
+                total_files = len(source_files)
+                if progress_callback:
+                    progress_callback.on_file_start(source.name, file_index, total_files)
+                elif show_progress:
+                    log_detail(f"Compiling {source.name}...")
 
                 result = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8")
 
                 if result.returncode != 0:
                     raise LibraryCompilationError(f"Failed to compile {source}:\n{result.stderr}")
 
+                if progress_callback:
+                    progress_callback.on_file_complete(source.name, file_index, total_files)
+
                 object_files.append(obj_file)
 
             # Create static archive using avr-ar
@@ -170,7 +180,7 @@ class LibraryCompiler:
             archive_file = lib_dir / f"lib{library_name}.a"
 
             if show_progress:
-                print(f"  Creating archive: {archive_file.name}")
+                log_detail(f"Creating archive: {archive_file.name}")
 
             # Remove old archive if exists
             if archive_file.exists():
@@ -188,7 +198,7 @@ class LibraryCompiler:
             # Object files are needed for proper LTO symbol resolution
 
             if show_progress:
-                print(f"Library '{library_name}' compiled successfully")
+                log_detail(f"Library '{library_name}' compiled successfully")
 
             return archive_file, object_files, compile_commands
 

fbuild/packages/library_manager.py

@@ -10,6 +10,7 @@ from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 from urllib.parse import urlparse
 
+from fbuild.output import log_detail
 from fbuild.packages.downloader import PackageDownloader
 from fbuild.packages.github_utils import GitHubURLOptimizer
 from fbuild.packages.library_compiler import LibraryCompilationError, LibraryCompiler
@@ -269,7 +270,7 @@ class LibraryManager:
             if GitHubURLOptimizer.is_github_url(url):
                 url = GitHubURLOptimizer.optimize_url(url)
                 if show_progress:
-                    print(f"Optimized GitHub URL: {url}")
+                    log_detail(f"Optimized GitHub URL: {url}")
 
             # Extract library name
             lib_name = self._extract_library_name(original_url)
@@ -278,7 +279,7 @@ class LibraryManager:
             # Skip if already downloaded
             if library.exists:
                 if show_progress:
-                    print(f"Library '{lib_name}' already downloaded")
+                    log_detail(f"Library '{lib_name}' already downloaded")
                 return library
 
             # Create library directory
@@ -289,13 +290,13 @@ class LibraryManager:
             temp_archive = library.lib_dir / filename
 
             if show_progress:
-                print(f"Downloading library: {lib_name}")
+                log_detail(f"Downloading library: {lib_name}")
 
             self.downloader.download(url, temp_archive, show_progress=show_progress)
 
             # Extract to src directory
             if show_progress:
-                print(f"Extracting library: {lib_name}")
+                log_detail(f"Extracting library: {lib_name}")
 
             temp_extract = library.lib_dir / "_extract"
             temp_extract.mkdir(exist_ok=True)
@@ -475,8 +476,13 @@ class LibraryManager:
             List of compiled Library instances
         """
         libraries = []
+        total = len(lib_deps)
+
+        for index, url in enumerate(lib_deps, 1):
+            # Extract library name for logging
+            library_name = self._extract_library_name(url)
+            log_detail(f"[{index}/{total}] {library_name}")
 
-        for url in lib_deps:
             # Download library
             library = self.download_library(url, show_progress)
 
@@ -485,7 +491,7 @@ class LibraryManager:
 
             if needs_rebuild:
                 if show_progress and reason:
-                    print(f"Rebuilding library '{library.name}': {reason}")
+                    log_detail(f"Rebuilding library '{library.name}': {reason}")
 
                 self.compile_library(
                     library,