initial

app/shared/logger.py

@@ -0,0 +1,217 @@
+"""Dynamic progress logger with formatting utilities"""
+import sys
+import logging
+from typing import Optional
+from datetime import datetime
+from pathlib import Path
+
+
+def format_size(bytes_size: int) -> str:
+    """Format bytes to human-readable size string
+
+    Args:
+        bytes_size: Size in bytes
+
+    Returns:
+        Human-readable size string (e.g., "1.5 GB", "234.5 MB")
+    """
+    for unit in ['B', 'KB', 'MB', 'GB', 'TB', 'PB']:
+        if bytes_size < 1024.0:
+            return f"{bytes_size:.1f} {unit}"
+        bytes_size /= 1024.0
+    return f"{bytes_size:.1f} EB"
+
+
+def format_rate(bytes_per_second: float) -> str:
+    """Format transfer rate to human-readable string
+
+    Args:
+        bytes_per_second: Transfer rate in bytes per second
+
+    Returns:
+        Human-readable rate string (e.g., "125.3 MB/s")
+    """
+    return f"{format_size(int(bytes_per_second))}/s"
+
+
+def format_time(seconds: float) -> str:
+    """Format seconds to human-readable time string
+
+    Args:
+        seconds: Time in seconds
+
+    Returns:
+        Human-readable time string (e.g., "2h 34m 12s", "45m 23s", "12s")
+    """
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        minutes = int(seconds // 60)
+        secs = int(seconds % 60)
+        return f"{minutes}m {secs}s"
+    else:
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        secs = int(seconds % 60)
+        return f"{hours}h {minutes}m {secs}s"
+
+
+class ProgressLogger:
+    """Dynamic progress logger with real-time statistics"""
+
+    def __init__(
+        self,
+        name: str = "defrag",
+        level: int = logging.INFO,
+        log_file: Optional[Path] = None,
+        console_output: bool = True
+    ):
+        """Initialize progress logger
+
+        Args:
+            name: Logger name
+            level: Logging level
+            log_file: Optional log file path
+            console_output: Whether to output to console
+        """
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(level)
+        self.logger.handlers.clear()
+
+        # Create formatter
+        formatter = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+
+        # Add console handler
+        if console_output:
+            console_handler = logging.StreamHandler(sys.stdout)
+            console_handler.setLevel(level)
+            console_handler.setFormatter(formatter)
+            self.logger.addHandler(console_handler)
+
+        # Add file handler
+        if log_file:
+            log_file.parent.mkdir(parents=True, exist_ok=True)
+            file_handler = logging.FileHandler(log_file)
+            file_handler.setLevel(level)
+            file_handler.setFormatter(formatter)
+            self.logger.addHandler(file_handler)
+
+        self._last_progress_line = ""
+
+    def info(self, message: str) -> None:
+        """Log info message"""
+        self.logger.info(message)
+
+    def warning(self, message: str) -> None:
+        """Log warning message"""
+        self.logger.warning(message)
+
+    def error(self, message: str) -> None:
+        """Log error message"""
+        self.logger.error(message)
+
+    def debug(self, message: str) -> None:
+        """Log debug message"""
+        self.logger.debug(message)
+
+    def critical(self, message: str) -> None:
+        """Log critical message"""
+        self.logger.critical(message)
+
+    def progress(
+        self,
+        current: int,
+        total: int,
+        prefix: str = "",
+        suffix: str = "",
+        bytes_processed: Optional[int] = None,
+        elapsed_seconds: Optional[float] = None
+    ) -> None:
+        """Log progress with dynamic statistics
+
+        Args:
+            current: Current progress count
+            total: Total count
+            prefix: Prefix message
+            suffix: Suffix message
+            bytes_processed: Optional bytes processed for rate calculation
+            elapsed_seconds: Optional elapsed time for rate calculation
+        """
+        if total == 0:
+            percent = 0.0
+        else:
+            percent = (current / total) * 100
+
+        progress_msg = f"{prefix} [{current}/{total}] {percent:.1f}%"
+
+        if bytes_processed is not None and elapsed_seconds is not None and elapsed_seconds > 0:
+            rate = bytes_per_second = bytes_processed / elapsed_seconds
+            progress_msg += f" | {format_size(bytes_processed)} @ {format_rate(rate)}"
+
+            # Estimate time remaining
+            if current > 0:
+                estimated_total_seconds = (elapsed_seconds / current) * total
+                remaining_seconds = estimated_total_seconds - elapsed_seconds
+                progress_msg += f" | ETA: {format_time(remaining_seconds)}"
+
+        if suffix:
+            progress_msg += f" | {suffix}"
+
+        self.info(progress_msg)
+
+    def section(self, title: str) -> None:
+        """Log section header
+
+        Args:
+            title: Section title
+        """
+        separator = "=" * 60
+        self.info(separator)
+        self.info(f"  {title}")
+        self.info(separator)
+
+    def subsection(self, title: str) -> None:
+        """Log subsection header
+
+        Args:
+            title: Subsection title
+        """
+        self.info(f"\n--- {title} ---")
+
+
+def create_logger(
+    name: str = "defrag",
+    level: str = "INFO",
+    log_file: Optional[Path] = None,
+    console_output: bool = True
+) -> ProgressLogger:
+    """Create and configure a progress logger
+
+    Args:
+        name: Logger name
+        level: Logging level as string
+        log_file: Optional log file path
+        console_output: Whether to output to console
+
+    Returns:
+        Configured ProgressLogger instance
+    """
+    level_map = {
+        'DEBUG': logging.DEBUG,
+        'INFO': logging.INFO,
+        'WARNING': logging.WARNING,
+        'ERROR': logging.ERROR,
+        'CRITICAL': logging.CRITICAL
+    }
+
+    log_level = level_map.get(level.upper(), logging.INFO)
+
+    return ProgressLogger(
+        name=name,
+        level=log_level,
+        log_file=log_file,
+        console_output=console_output
+    )