Kompletter Rewrite

serien_checker/utils/__init__.py

@@ -0,0 +1 @@
+"""Utility functions and helpers"""

serien_checker/utils/logger.py

@@ -0,0 +1,74 @@
+"""
+Logging configuration for Serien-Checker
+"""
+
+import logging
+import sys
+from pathlib import Path
+from datetime import datetime
+
+
+def get_executable_dir() -> Path:
+    """
+    Get the directory where the executable/script is located
+    Works for both .py and .exe
+    """
+    if getattr(sys, 'frozen', False):
+        # Running as compiled executable (PyInstaller)
+        return Path(sys.executable).parent
+    else:
+        # Running as script
+        return Path(__file__).parent.parent.parent
+
+
+def setup_logger(name: str = "serien_checker", log_to_file: bool = True, portable: bool = False) -> logging.Logger:
+    """
+    Setup application logger
+
+    Args:
+        name: Logger name
+        log_to_file: If True, also log to file
+        portable: If True, use portable mode (logs in program directory)
+
+    Returns:
+        Configured logger instance
+    """
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.DEBUG)
+
+    # Clear existing handlers
+    logger.handlers.clear()
+
+    # Console handler
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.INFO)
+    console_format = logging.Formatter(
+        '%(asctime)s - %(levelname)s - %(message)s',
+        datefmt='%H:%M:%S'
+    )
+    console_handler.setFormatter(console_format)
+    logger.addHandler(console_handler)
+
+    # File handler
+    if log_to_file:
+        # Check if running as EXE or if portable mode is enabled
+        if getattr(sys, 'frozen', False) or portable:
+            # Running as EXE or portable mode: logs in program directory (next to EXE)
+            log_dir = get_executable_dir() / "logs"
+        else:
+            # Running as script in development: logs in user's AppData
+            log_dir = Path.home() / ".serien_checker" / "logs"
+
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / f"serien_checker_{datetime.now().strftime('%Y%m%d')}.log"
+
+        file_handler = logging.FileHandler(log_file, encoding='utf-8')
+        file_handler.setLevel(logging.DEBUG)
+        file_format = logging.Formatter(
+            '%(asctime)s - %(name)s - %(levelname)s - %(funcName)s:%(lineno)d - %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+        file_handler.setFormatter(file_format)
+        logger.addHandler(file_handler)
+
+    return logger

serien_checker/utils/threading.py

@@ -0,0 +1,90 @@
+"""
+Threading utilities for PyQt5 asynchronous operations
+"""
+
+from PyQt5.QtCore import QThread, pyqtSignal, QObject
+from typing import Callable, Any, Optional
+import traceback
+
+from .logger import setup_logger
+
+logger = setup_logger()
+
+
+class WorkerSignals(QObject):
+    """Signals for worker threads"""
+    started = pyqtSignal()
+    finished = pyqtSignal(object)  # Result
+    error = pyqtSignal(str, str)  # Error message, traceback
+    progress = pyqtSignal(int, str)  # Progress percent, status message
+
+
+class Worker(QThread):
+    """
+    Generic worker thread for running tasks in background
+
+    Usage:
+        worker = Worker(my_function, arg1, arg2, kwarg1=value1)
+        worker.signals.finished.connect(on_finished)
+        worker.signals.error.connect(on_error)
+        worker.start()
+    """
+
+    def __init__(self, func: Callable, *args, **kwargs):
+        """
+        Initialize worker
+
+        Args:
+            func: Function to execute
+            *args: Positional arguments for func
+            **kwargs: Keyword arguments for func
+        """
+        super().__init__()
+        self.func = func
+        self.args = args
+        self.kwargs = kwargs
+        self.signals = WorkerSignals()
+        self.result = None
+
+    def run(self):
+        """Execute the function in background thread"""
+        try:
+            logger.debug(f"Worker started: {self.func.__name__}")
+            self.signals.started.emit()
+
+            # Execute function
+            self.result = self.func(*self.args, **self.kwargs)
+
+            # Emit success
+            self.signals.finished.emit(self.result)
+            logger.debug(f"Worker finished: {self.func.__name__}")
+
+        except Exception as e:
+            # Emit error
+            error_msg = str(e)
+            error_tb = traceback.format_exc()
+            logger.error(f"Worker error in {self.func.__name__}: {error_msg}\n{error_tb}")
+            self.signals.error.emit(error_msg, error_tb)
+
+
+class UpdateWorker(Worker):
+    """
+    Specialized worker for series updates with progress reporting
+
+    This worker extends the base Worker to provide progress updates
+    during long-running scraping operations.
+    """
+
+    def __init__(self, func: Callable, *args, **kwargs):
+        super().__init__(func, *args, **kwargs)
+
+    def report_progress(self, percent: int, message: str):
+        """
+        Report progress (can be called from within the worker function)
+
+        Args:
+            percent: Progress percentage (0-100)
+            message: Status message
+        """
+        self.signals.progress.emit(percent, message)
+        logger.debug(f"Progress: {percent}% - {message}")