Photo-Composition-Designer 0.0.7__py3-none-any.whl

Photo_Composition_Designer/common/logging.py

@@ -0,0 +1,216 @@
+"""Centralized logging configuration for Photo_Composition_Designer.
+
+This module provides a unified logging setup that supports:
+- File logging with rotation
+- GUI integration via custom handler
+- Configurable log levels from config
+- Structured logging with consistent formatting
+"""
+
+import logging
+import logging.handlers
+import sys
+from pathlib import Path
+
+from Photo_Composition_Designer.config.config import ConfigParameterManager
+
+
+class GuiLogHandler(logging.Handler):
+    """Custom logging handler that can write to GUI text widgets."""
+
+    def __init__(self, gui_writer=None):
+        super().__init__()
+        self.gui_writer = gui_writer
+        self.setFormatter(
+            logging.Formatter("%(asctime)s - %(levelname)s - %(message)s", datefmt="%H:%M:%S")
+        )
+
+    def emit(self, record):
+        """Emit a log record to the GUI if writer is available."""
+        if self.gui_writer:
+            try:
+                msg = self.format(record) + "\n"
+                self.gui_writer.write(msg)
+            except Exception:
+                # Fail silently to avoid recursive logging errors
+                pass
+
+
+class LoggerManager:
+    """Manages all logging configuration and handlers."""
+
+    def __init__(self, config: ConfigParameterManager):
+        self.config = config
+        self.logger = logging.getLogger("Photo_Composition_Designer")
+        self.gui_handler = None
+        self.file_handler = None
+        self.console_handler = None
+        self._setup_logging()
+
+    def _setup_logging(self):
+        """Configure all logging handlers and formatters."""
+        # Clear any existing handlers
+        self.logger.handlers.clear()
+
+        # Set log level from config
+        log_level = getattr(logging, self.config.app.log_level.value.upper())
+        self.logger.setLevel(log_level)
+
+        # Create formatters
+        detailed_formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s"
+        )
+        simple_formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+
+        # Setup file handler with rotation
+        self._setup_file_handler(detailed_formatter)
+
+        # Setup console handler
+        self._setup_console_handler(simple_formatter)
+
+        # Setup GUI handler (will be connected later if needed)
+        self._setup_gui_handler()
+
+    def _setup_file_handler(self, formatter):
+        """Setup rotating file handler."""
+        log_dir = Path("logs")
+        log_dir.mkdir(exist_ok=True)
+
+        log_file = log_dir / "Photo_Composition_Designer.log"
+
+        # Use RotatingFileHandler to prevent huge log files
+        self.file_handler = logging.handlers.RotatingFileHandler(
+            log_file,
+            maxBytes=10 * 1024 * 1024,  # 10MB
+            backupCount=5,
+            encoding="utf-8",
+        )
+        self.file_handler.setFormatter(formatter)
+        self.logger.addHandler(self.file_handler)
+
+    def _setup_console_handler(self, formatter):
+        """Setup console handler for CLI output."""
+        self.console_handler = logging.StreamHandler(sys.stdout)
+        self.console_handler.setFormatter(formatter)
+        self.logger.addHandler(self.console_handler)
+
+    def _setup_gui_handler(self):
+        """Setup GUI handler (initially without writer)."""
+        self.gui_handler = GuiLogHandler()
+        # Don't add to logger yet - will be done when GUI connects
+
+    def connect_gui_writer(self, gui_writer):
+        """Connect a GUI writer to the logging system.
+
+        Args:
+            gui_writer: Object with write() method (like the LogHandler from gui.py)
+        """
+        if self.gui_handler:
+            # Remove old handler if it exists
+            if self.gui_handler in self.logger.handlers:
+                self.logger.removeHandler(self.gui_handler)
+
+        # Create new handler with GUI writer
+        self.gui_handler = GuiLogHandler(gui_writer)
+        self.logger.addHandler(self.gui_handler)
+
+    def disconnect_gui_writer(self):
+        """Disconnect GUI writer (useful when GUI closes)."""
+        if self.gui_handler and self.gui_handler in self.logger.handlers:
+            self.logger.removeHandler(self.gui_handler)
+
+    def get_logger(self, name: str = None) -> logging.Logger:
+        """Get a logger instance.
+
+        Args:
+            name: Logger name (defaults to main project logger)
+
+        Returns:
+            Logger instance
+        """
+        if name:
+            return logging.getLogger(f"Photo_Composition_Designer.{name}")
+        return self.logger
+
+    def set_log_level(self, level: str):
+        """Change log level dynamically.
+
+        Args:
+            level: New log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        """
+        log_level = getattr(logging, level.upper())
+        self.logger.setLevel(log_level)
+
+        # Update config
+        self.config.app.log_level.value = level.upper()
+
+    def log_config_summary(self):
+        """Log current configuration summary."""
+        self.logger.info("=== Configuration Summary ===")
+        self.logger.info(f"Log level: {self.config.app.log_level.value}")
+        self.logger.info("==============================")
+
+
+# Global logger manager instance
+_logger_manager = None
+
+
+def initialize_logging(config: ConfigParameterManager) -> LoggerManager:
+    """Initialize the global logging system.
+
+    Args:
+        config: Configuration manager instance
+
+    Returns:
+        LoggerManager instance
+    """
+    global _logger_manager
+    _logger_manager = LoggerManager(config)
+    return _logger_manager
+
+
+def get_logger(name: str = None) -> logging.Logger:
+    """Get a logger instance.
+
+    Args:
+        name: Logger name (optional)
+
+    Returns:
+        Logger instance
+
+    Raises:
+        RuntimeError: If logging not initialized
+    """
+    if _logger_manager is None:
+        raise RuntimeError("Logging not initialized. Call initialize_logging() first.")
+    return _logger_manager.get_logger(name)
+
+
+def get_logger_manager() -> LoggerManager:
+    """Get the global logger manager.
+
+    Returns:
+        LoggerManager instance
+
+    Raises:
+        RuntimeError: If logging not initialized
+    """
+    if _logger_manager is None:
+        raise RuntimeError("Logging not initialized. Call initialize_logging() first.")
+    return _logger_manager
+
+
+def connect_gui_logging(gui_writer):
+    """Connect GUI writer to logging system.
+
+    Args:
+        gui_writer: GUI writer object with write() method
+    """
+    if _logger_manager:
+        _logger_manager.connect_gui_writer(gui_writer)
+
+
+def disconnect_gui_logging():
+    """Disconnect GUI from logging system."""
+    if _logger_manager:
+        _logger_manager.disconnect_gui_writer()

Photo_Composition_Designer/config/config.py

@@ -0,0 +1,321 @@
+"""
+Central configuration management for the new project.
+
+This module provides a single source of truth for all configuration parameters
+organized in categories (GENERAL, CALENDAR, COLORS, GEO, SIZE, LAYOUT).
+It can generate config files, CLI modules, and documentation from the parameter definitions.
+"""
+
+from datetime import datetime
+from pathlib import Path
+
+from config_cli_gui.config import Color, ConfigCategory, ConfigManager, ConfigParameter
+from config_cli_gui.docs import DocumentationGenerator
+
+
+class AppConfig(ConfigCategory):
+    """Application-specific configuration parameters."""
+
+    def get_category_name(self) -> str:
+        return "app"
+
+    log_level: ConfigParameter = ConfigParameter(
+        name="log_level",
+        value="INFO",
+        choices=["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"],
+        help="Logging level for the application",
+    )
+
+
+class GeneralConfig(ConfigCategory):
+    """GENERAL configuration parameters."""
+
+    def get_category_name(self) -> str:
+        return "general"
+
+    photoDirectory: ConfigParameter = ConfigParameter(
+        name="photoDirectory",
+        value=Path("images"),
+        help="Path to the directory containing photos "
+        "(absolute, or relative to this config.ini file)",
+        is_cli=True,
+        required=True,
+    )
+
+    anniversariesConfig: ConfigParameter = ConfigParameter(
+        name="anniversariesConfig",
+        value=Path("anniversaries.ini"),
+        help="Path to anniversaries.ini file (absolute, or relative to this config.ini file)",
+    )
+
+    locationsConfig: ConfigParameter = ConfigParameter(
+        name="locationsConfig",
+        value=Path("locations_en.ini"),
+        help="Path to locations.ini file (absolute, or relative to this config.ini file)",
+    )
+
+    compositionTitle: ConfigParameter = ConfigParameter(
+        name="compositionTitle",
+        value="This is the title of the composition",
+        help="This is the title of the composition on the first page. Leave empty if not required.",
+    )
+
+
+class CalendarConfig(ConfigCategory):
+    """CALENDAR configuration parameters."""
+
+    def get_category_name(self) -> str:
+        return "calendar"
+
+    useCalendar: ConfigParameter = ConfigParameter(
+        name="useCalendar",
+        value=True,
+        help="True: Calendar elements are generated",
+    )
+
+    language: ConfigParameter = ConfigParameter(
+        name="language",
+        value="de_DE",
+        help="Language for the calendar (e.g., de_DE, en_US)",
+    )
+
+    holidayCountries: ConfigParameter = ConfigParameter(
+        name="holidayCountries",
+        value="SN",
+        help="Country/state codes for public holidays, e.g., NY,CA",
+    )
+
+    startDate: ConfigParameter = ConfigParameter(
+        name="startDate",
+        value=datetime.fromisoformat("2025-12-31"),
+        help="Start date of the calendar",
+        is_cli=True,
+    )
+
+    collagesToGenerate: ConfigParameter = ConfigParameter(
+        name="collagesToGenerate",
+        value=5,
+        help="Number of collages to be generated (e.g. number of weeks)",
+    )
+
+
+class ColorsConfig(ConfigCategory):
+    """COLORS configuration parameters."""
+
+    def get_category_name(self) -> str:
+        return "colors"
+
+    backgroundColor: ConfigParameter = ConfigParameter(
+        name="backgroundColor",
+        value=Color(20, 20, 20),
+        help="Background color (RGB)",
+    )
+
+    textColor1: ConfigParameter = ConfigParameter(
+        name="textColor1",
+        value=Color(255, 255, 255),
+        help="Primary text color",
+    )
+
+    textColor2: ConfigParameter = ConfigParameter(
+        name="textColor2",
+        value=Color(150, 150, 150),
+        help="Secondary text color",
+    )
+
+    holidayColor: ConfigParameter = ConfigParameter(
+        name="holidayColor",
+        value=Color(255, 0, 0),
+        help="Color for holidays",
+    )
+
+
+class GeoConfig(ConfigCategory):
+    """GEO configuration parameters."""
+
+    def get_category_name(self) -> str:
+        return "geo"
+
+    usePhotoLocationMaps: ConfigParameter = ConfigParameter(
+        name="usePhotoLocationMaps",
+        value=True,
+        help="Use GPS data to generate maps",
+    )
+
+    minimalExtension: ConfigParameter = ConfigParameter(
+        name="minimalExtension",
+        value=7,
+        help="Minimum range for map display (degrees)",
+    )
+
+
+class SizeConfig(ConfigCategory):
+    """SIZE configuration parameters."""
+
+    def get_category_name(self) -> str:
+        return "size"
+
+    width: ConfigParameter = ConfigParameter(
+        name="width",
+        value=216,
+        help="Width of the collage in mm",
+        is_cli=True,
+    )
+
+    height: ConfigParameter = ConfigParameter(
+        name="height",
+        value=154,
+        help="Height of the collage in mm",
+        is_cli=True,
+    )
+
+    calendarHeight: ConfigParameter = ConfigParameter(
+        name="calendarHeight",
+        value=18,
+        help="Height of the calendar area in mm",
+    )
+
+    mapWidth: ConfigParameter = ConfigParameter(
+        name="mapWidth",
+        value=20,
+        help="Width of the locations map in mm",
+    )
+
+    mapHeight: ConfigParameter = ConfigParameter(
+        name="mapHeight",
+        value=20,
+        help="Height of the locations map in mm",
+    )
+
+    dpi: ConfigParameter = ConfigParameter(
+        name="dpi",
+        value=150,
+        help="Resolution of the image in dpi",
+        is_cli=True,
+    )
+
+    jpgQuality: ConfigParameter = ConfigParameter(
+        name="jpgQuality",
+        value=90,
+        help="JPG compression quality (1-100)",
+    )
+
+
+class LayoutConfig(ConfigCategory):
+    """LAYOUT configuration parameters."""
+
+    def get_category_name(self) -> str:
+        return "layout"
+
+    fontSizeLarge: ConfigParameter = ConfigParameter(
+        name="fontSizeLarge",
+        value=0.5,
+        help="Font size for large text",
+    )
+
+    fontSizeSmall: ConfigParameter = ConfigParameter(
+        name="fontSizeSmall",
+        value=0.14,
+        help="Font size for small text",
+    )
+
+    fontSizeAnniversaries: ConfigParameter = ConfigParameter(
+        name="fontSizeAnniversaries",
+        value=0.115,
+        help="Font size for anniversaries",
+    )
+
+    marginTop: ConfigParameter = ConfigParameter(
+        name="marginTop",
+        value=6,
+        help="Top margin in mm",
+    )
+
+    marginBottom: ConfigParameter = ConfigParameter(
+        name="marginBottom",
+        value=3,
+        help="Bottom margin in mm",
+    )
+
+    marginSides: ConfigParameter = ConfigParameter(
+        name="marginSides",
+        value=3,
+        help="Side margins in mm",
+    )
+
+    spacing: ConfigParameter = ConfigParameter(
+        name="spacing",
+        value=2,
+        help="Spacing between elements in mm",
+    )
+
+    useShortDayNames: ConfigParameter = ConfigParameter(
+        name="useShortDayNames",
+        value=False,
+        help="Use short weekday names (e.g., Mon, Tue)",
+    )
+
+    useShortMonthNames: ConfigParameter = ConfigParameter(
+        name="useShortMonthNames",
+        value=True,
+        help="Use short month names (e.g., Jan, Feb)",
+    )
+
+    usePhotoDescription: ConfigParameter = ConfigParameter(
+        name="usePhotoDescription",
+        value=True,
+        help="Include photo descriptions in the collage",
+    )
+
+    generatePdf: ConfigParameter = ConfigParameter(
+        name="generatePdf",
+        value=True,
+        help="Combine all generated collages into one pdf",
+    )
+
+
+class ConfigParameterManager(ConfigManager):
+    """Main configuration manager that handles all parameter categories."""
+
+    app: AppConfig
+    general: GeneralConfig
+    calendar: CalendarConfig
+    colors: ColorsConfig
+    geo: GeoConfig
+    size: SizeConfig
+    layout: LayoutConfig
+
+    def __init__(self, config_file: str | None = None, **kwargs):
+        categories = (
+            AppConfig(),
+            GeneralConfig(),
+            CalendarConfig(),
+            ColorsConfig(),
+            GeoConfig(),
+            SizeConfig(),
+            LayoutConfig(),
+        )
+        super().__init__(categories, config_file, **kwargs)
+
+
+def main():
+    """Main function to generate config file and documentation."""
+    default_config: str = "config.yaml"
+    default_cli_doc: str = "docs/usage/cli.md"
+    default_config_doc: str = "docs/usage/config.md"
+
+    config_manager = ConfigParameterManager()
+    docGen = DocumentationGenerator(config_manager)
+
+    docGen.generate_default_config_file(output_file=default_config)
+    print(f"Generated: {default_config}")
+
+    docGen.generate_config_markdown_doc(output_file=default_config_doc)
+    print(f"Generated: {default_config_doc}")
+
+    docGen.generate_cli_markdown_doc(output_file=default_cli_doc)
+    print(f"Generated: {default_cli_doc}")
+
+
+if __name__ == "__main__":
+    main()