qBitrr2 5.4.4__py3-none-any.whl → 5.5.0__py3-none-any.whl

qBitrr/gen_config.py

@@ -4,7 +4,7 @@ import pathlib
 from functools import reduce
 from typing import Any, TypeVar
 
-from tomlkit import comment, document, nl, parse, table
+from tomlkit import comment, document, inline_table, nl, parse, table
 from tomlkit.items import Table
 from tomlkit.toml_document import TOMLDocument
 
@@ -83,6 +83,15 @@ def generate_doc() -> TOMLDocument:
 
 def _add_settings_section(config: TOMLDocument):
     settings = table()
+    _gen_default_line(
+        settings,
+        [
+            "Internal config schema version - DO NOT MODIFY",
+            "This is managed automatically by qBitrr for config migrations",
+        ],
+        "ConfigVersion",
+        3,
+    )
     _gen_default_line(
         settings,
         "Level of logging; One of CRITICAL, ERROR, WARNING, NOTICE, INFO, DEBUG, TRACE",
@@ -202,6 +211,39 @@ def _add_settings_section(config: TOMLDocument):
         "AutoUpdateCron",
         ENVIRO_CONFIG.settings.auto_update_cron or "0 3 * * 0",
     )
+    _gen_default_line(
+        settings,
+        [
+            "Automatically restart worker processes that fail or crash",
+            "Set to false to disable auto-restart (processes will only log failures)",
+        ],
+        "AutoRestartProcesses",
+        True,
+    )
+    _gen_default_line(
+        settings,
+        [
+            "Maximum number of restart attempts per process within the restart window",
+            "Prevents infinite restart loops for processes that crash immediately",
+        ],
+        "MaxProcessRestarts",
+        5,
+    )
+    _gen_default_line(
+        settings,
+        [
+            "Time window (seconds) for tracking restart attempts",
+            "If a process restarts MaxProcessRestarts times within this window, auto-restart is disabled for that process",
+        ],
+        "ProcessRestartWindow",
+        300,
+    )
+    _gen_default_line(
+        settings,
+        "Delay (seconds) before attempting to restart a failed process",
+        "ProcessRestartDelay",
+        5,
+    )
     config.add("Settings", settings)
 
 
@@ -705,6 +747,34 @@ def _gen_default_search_table(category: str, cat_default: Table):
     )
     _gen_default_line(search_table, "Use Temp profile for missing", "UseTempForMissing", False)
     _gen_default_line(search_table, "Don't change back to main profile", "KeepTempProfile", False)
+    _gen_default_line(
+        search_table,
+        [
+            "Quality profile mappings for temp profile switching (Main Profile Name -> Temp Profile Name)",
+            "Profile names must match exactly as they appear in your Arr instance",
+            'Example: QualityProfileMappings = {"HD-1080p" = "SD", "HD-720p" = "SD"}',
+        ],
+        "QualityProfileMappings",
+        inline_table(),
+    )
+    _gen_default_line(
+        search_table,
+        "Reset all items using temp profiles to their original main profile on qBitrr startup",
+        "ForceResetTempProfiles",
+        False,
+    )
+    _gen_default_line(
+        search_table,
+        "Timeout in minutes after which items with temp profiles are automatically reset to main profile (0 = disabled)",
+        "TempProfileResetTimeoutMinutes",
+        0,
+    )
+    _gen_default_line(
+        search_table,
+        "Number of retry attempts for profile switch API calls (default: 3)",
+        "ProfileSwitchRetryAttempts",
+        3,
+    )
     _gen_default_line(
         search_table,
         "Main quality profile (To pair quality profiles, ensure they are in the same order as in the temp profiles)",
@@ -899,6 +969,146 @@ def _migrate_webui_config(config: MyConfig) -> bool:
     return migrated
 
 
+def _migrate_process_restart_settings(config: MyConfig) -> bool:
+    """
+    Add process auto-restart settings to existing configs.
+
+    Migration runs if:
+    - ConfigVersion < 3 (versions 1 or 2)
+
+    After migration, ConfigVersion will be set to 3 by apply_config_migrations().
+
+    Returns:
+        True if changes were made, False otherwise
+    """
+    import logging
+
+    from qBitrr.config_version import get_config_version
+
+    logger = logging.getLogger(__name__)
+
+    # Check if migration already applied
+    current_version = get_config_version(config)
+    if current_version >= 3:
+        return False  # Already migrated
+
+    # Ensure Settings section exists
+    if "Settings" not in config.config:
+        config.config["Settings"] = table()
+
+    settings = config.config["Settings"]
+    changes_made = False
+
+    # Add AutoRestartProcesses if missing
+    if "AutoRestartProcesses" not in settings:
+        settings["AutoRestartProcesses"] = True
+        changes_made = True
+        logger.info("Added AutoRestartProcesses = true (default: enabled)")
+
+    # Add MaxProcessRestarts if missing
+    if "MaxProcessRestarts" not in settings:
+        settings["MaxProcessRestarts"] = 5
+        changes_made = True
+        logger.info("Added MaxProcessRestarts = 5 (default)")
+
+    # Add ProcessRestartWindow if missing
+    if "ProcessRestartWindow" not in settings:
+        settings["ProcessRestartWindow"] = 300
+        changes_made = True
+        logger.info("Added ProcessRestartWindow = 300 seconds (5 minutes)")
+
+    # Add ProcessRestartDelay if missing
+    if "ProcessRestartDelay" not in settings:
+        settings["ProcessRestartDelay"] = 5
+        changes_made = True
+        logger.info("Added ProcessRestartDelay = 5 seconds")
+
+    if changes_made:
+        print("Migration v2→v3: Added process auto-restart configuration settings")
+
+    return changes_made
+
+
+def _migrate_quality_profile_mappings(config: MyConfig) -> bool:
+    """
+    Migrate from list-based profile config to dict-based mappings.
+
+    Migration runs if:
+    - ConfigVersion is missing (old config), OR
+    - ConfigVersion == 1 (baseline version before this feature)
+
+    After migration, ConfigVersion will be set to 2 by apply_config_migrations().
+
+    Returns:
+        True if changes were made, False otherwise
+    """
+    import logging
+
+    from qBitrr.config_version import get_config_version
+
+    logger = logging.getLogger(__name__)
+
+    # Check if migration already applied
+    current_version = get_config_version(config)
+    if current_version >= 2:
+        return False  # Already migrated
+
+    # At this point, ConfigVersion is either missing (returns 1 as default) or explicitly 1
+    # Both cases need migration if old format exists
+
+    changes_made = False
+    arr_types = ["Radarr", "Sonarr", "Lidarr", "Animarr"]
+
+    for arr_type in arr_types:
+        # Find all Arr instances (e.g., "Radarr-Movies", "Sonarr-TV")
+        for key in list(config.config.keys()):
+            if not str(key).startswith(arr_type):
+                continue
+
+            entry_search_key = f"{key}.EntrySearch"
+            entry_search_section = config.get(entry_search_key, fallback=None)
+            if not entry_search_section:
+                continue
+
+            # Check for old format
+            main_profiles = config.get(f"{entry_search_key}.MainQualityProfile", fallback=None)
+            temp_profiles = config.get(f"{entry_search_key}.TempQualityProfile", fallback=None)
+
+            # Skip if no old format found
+            if not main_profiles or not temp_profiles:
+                continue
+
+            # Validate list lengths match
+            if len(main_profiles) != len(temp_profiles):
+                logger.error(
+                    f"Cannot migrate {key}: MainQualityProfile ({len(main_profiles)}) "
+                    f"and TempQualityProfile ({len(temp_profiles)}) have different lengths"
+                )
+                continue
+
+            # Create mappings dict, filtering out empty/None values
+            mappings = {
+                str(main).strip(): str(temp).strip()
+                for main, temp in zip(main_profiles, temp_profiles)
+                if main and temp and str(main).strip() and str(temp).strip()
+            }
+
+            if mappings:
+                # Set new format - use tomlkit's inline_table to ensure it's rendered as inline dict
+                inline_mappings = inline_table()
+                inline_mappings.update(mappings)
+                config.config[str(key)]["EntrySearch"]["QualityProfileMappings"] = inline_mappings
+                changes_made = True
+                logger.info(f"Migrated {key} to QualityProfileMappings: {mappings}")
+
+                # Remove old format
+                del config.config[str(key)]["EntrySearch"]["MainQualityProfile"]
+                del config.config[str(key)]["EntrySearch"]["TempQualityProfile"]
+                logger.debug(f"Removed legacy profile lists from {key}")
+
+    return changes_made
+
+
 def _normalize_theme_value(value: Any) -> str:
     """
     Normalize theme value to always be 'Light' or 'Dark' (case insensitive input).
@@ -948,6 +1158,7 @@ def _validate_and_fill_config(config: MyConfig) -> bool:
 
     # Validate Settings section
     settings_defaults = [
+        ("ConfigVersion", 1),  # Internal version, DO NOT expose to WebUI
         ("ConsoleLevel", "INFO"),
         ("Logging", True),
         ("CompletedDownloadFolder", "CHANGE_ME"),
@@ -1009,6 +1220,35 @@ def _validate_and_fill_config(config: MyConfig) -> bool:
         if ensure_value("qBit", key, default):
             changed = True
 
+    # Validate EntrySearch sections for all Arr instances
+    arr_types = ["Radarr", "Sonarr", "Lidarr", "Animarr"]
+    entry_search_defaults = {
+        "QualityProfileMappings": inline_table(),
+        "ForceResetTempProfiles": False,
+        "TempProfileResetTimeoutMinutes": 0,
+        "ProfileSwitchRetryAttempts": 3,
+    }
+
+    for arr_type in arr_types:
+        for key in list(config.config.keys()):
+            if not str(key).startswith(arr_type):
+                continue
+
+            # Check if this Arr instance has an EntrySearch section
+            if "EntrySearch" in config.config[str(key)]:
+                entry_search = config.config[str(key)]["EntrySearch"]
+
+                # Add missing fields directly to the existing section
+                for field, default in entry_search_defaults.items():
+                    if field not in entry_search:
+                        if field == "QualityProfileMappings":
+                            # Create as inline table (inline dict) not a section
+                            entry_search[field] = inline_table()
+                        else:
+                            # Add as a simple value
+                            entry_search[field] = default
+                        changed = True
+
     return changed
 
 
@@ -1017,16 +1257,58 @@ def apply_config_migrations(config: MyConfig) -> None:
     Apply all configuration migrations and validations.
     Saves the config if any changes were made.
     """
+    from qBitrr.config_version import (
+        EXPECTED_CONFIG_VERSION,
+        backup_config,
+        get_config_version,
+        set_config_version,
+        validate_config_version,
+    )
+
     changes_made = False
 
-    # Apply migrations
+    # Validate config version
+    is_valid, validation_result = validate_config_version(config)
+
+    if not is_valid:
+        # Config version is newer than expected - log error but continue
+        print(f"WARNING: {validation_result}")
+        print("Continuing with potentially incompatible config...")
+
+    # Check if migration is needed
+    current_version = get_config_version(config)
+    needs_migration = current_version < EXPECTED_CONFIG_VERSION
+
+    if needs_migration:
+        print(f"Config schema upgrade needed (v{current_version} -> v{EXPECTED_CONFIG_VERSION})")
+        # Create backup before migration
+        backup_path = backup_config(config.path)
+        if backup_path:
+            print(f"Config backup created: {backup_path}")
+        else:
+            print("WARNING: Could not create config backup, proceeding with migration anyway")
+
+    # Apply migrations in order
     if _migrate_webui_config(config):
         changes_made = True
 
-    # Validate and fill config
+    # NEW: Migrate quality profile mappings from list to dict format (v1 → v2)
+    if _migrate_quality_profile_mappings(config):
+        changes_made = True
+
+    # NEW: Add process auto-restart settings (v2 → v3)
+    if _migrate_process_restart_settings(config):
+        changes_made = True
+
+    # Validate and fill config (this also ensures ConfigVersion field exists)
     if _validate_and_fill_config(config):
         changes_made = True
 
+    # Update config version if migration was needed
+    if needs_migration and current_version < EXPECTED_CONFIG_VERSION:
+        set_config_version(config, EXPECTED_CONFIG_VERSION)
+        changes_made = True
+
     # Save if changes were made
     if changes_made:
         config.save()

qBitrr/main.py

@@ -133,6 +133,14 @@ class qBitManager:
         self._restart_requested = False
         self._restart_thread: Thread | None = None
         self.ffprobe_downloader = FFprobeDownloader()
+        # Process auto-restart tracking
+        self._process_restart_counts: dict[tuple[str, str], list[float]] = (
+            {}
+        )  # (category, role) -> [timestamps]
+        self.auto_restart_enabled = CONFIG.get("Settings.AutoRestartProcesses", fallback=True)
+        self.max_process_restarts = CONFIG.get("Settings.MaxProcessRestarts", fallback=5)
+        self.process_restart_window = CONFIG.get("Settings.ProcessRestartWindow", fallback=300)
+        self.process_restart_delay = CONFIG.get("Settings.ProcessRestartDelay", fallback=5)
         try:
             if not (QBIT_DISABLED or SEARCH_ONLY):
                 self.ffprobe_downloader.update()
@@ -490,15 +498,40 @@ class qBitManager:
                     exit_code = proc.exitcode
                     if exit_code is None:
                         continue
-                    meta = self._process_registry.pop(proc, {})
-                    with contextlib.suppress(ValueError):
-                        self.child_processes.remove(proc)
+
+                    meta = self._process_registry.get(proc, {})
+                    category = meta.get("category", "unknown")
+                    role = meta.get("role", "unknown")
+
                     self.logger.warning(
                         "Worker process exited (role=%s, category=%s, code=%s)",
-                        meta.get("role", "unknown"),
-                        meta.get("category", "unknown"),
+                        role,
+                        category,
                         exit_code,
                     )
+
+                    # Attempt auto-restart if enabled and process crashed (non-zero exit)
+                    if self.auto_restart_enabled and exit_code != 0:
+                        if self._should_restart_process(category, role):
+                            self.logger.info(
+                                "Attempting to restart %s worker for category '%s'",
+                                role,
+                                category,
+                            )
+                            if self._restart_process(proc, meta):
+                                continue  # Keep process in list, skip removal
+                            else:
+                                self.logger.error(
+                                    "Failed to restart %s worker for category '%s'",
+                                    role,
+                                    category,
+                                )
+
+                    # Remove process if not restarted
+                    self._process_registry.pop(proc, None)
+                    with contextlib.suppress(ValueError):
+                        self.child_processes.remove(proc)
+
                 if not self.child_processes:
                     if not any_alive:
                         break
@@ -518,6 +551,139 @@ class qBitManager:
                 if proc.is_alive():
                     proc.join(timeout=1)
 
+    def _should_restart_process(self, category: str, role: str) -> bool:
+        """
+        Determine if a process should be restarted based on restart count and window.
+
+        Tracks restart attempts per (category, role) combination and prevents
+        crash loops by enforcing maximum restart limits within a time window.
+
+        Args:
+            category: The Arr category (e.g., "radarr", "sonarr")
+            role: The process role ("search" or "torrent")
+
+        Returns:
+            bool: True if process should be restarted, False otherwise
+        """
+        key = (category, role)
+        now = time.time()
+
+        # Get restart history for this process type
+        if key not in self._process_restart_counts:
+            self._process_restart_counts[key] = []
+
+        restart_times = self._process_restart_counts[key]
+
+        # Remove timestamps outside the restart window
+        restart_times[:] = [t for t in restart_times if now - t < self.process_restart_window]
+
+        # Check if we've exceeded max restarts
+        if len(restart_times) >= self.max_process_restarts:
+            self.logger.error(
+                "Process %s/%s has failed %d times in %d seconds. Auto-restart disabled for this process.",
+                category,
+                role,
+                len(restart_times),
+                self.process_restart_window,
+            )
+            return False
+
+        return True
+
+    def _restart_process(
+        self, failed_proc: pathos.helpers.mp.Process, meta: dict[str, str]
+    ) -> bool:
+        """
+        Restart a failed worker process.
+
+        Creates a new process instance with the same target function, starts it,
+        and updates all tracking structures to reference the new process.
+
+        Args:
+            failed_proc: The failed process object
+            meta: Process metadata dict with keys: category, name, role
+
+        Returns:
+            bool: True if restart successful, False otherwise
+        """
+        category = meta.get("category", "")
+        role = meta.get("role", "worker")
+        meta.get("name", "")
+
+        try:
+            # Wait before restarting
+            if self.process_restart_delay > 0:
+                self.logger.debug(
+                    "Waiting %ds before restarting %s worker for '%s'",
+                    self.process_restart_delay,
+                    role,
+                    category,
+                )
+                time.sleep(self.process_restart_delay)
+
+            # Find the corresponding Arr instance
+            if not self.arr_manager:
+                self.logger.error("ArrManager not available for process restart")
+                return False
+
+            arr = self.arr_manager.managed_objects.get(category)
+            if not arr:
+                self.logger.error("Cannot find Arr instance for category '%s'", category)
+                return False
+
+            # Recreate the process based on role
+            new_proc = None
+            if role == "search" and hasattr(arr, "run_search_loop"):
+                new_proc = pathos.helpers.mp.Process(target=arr.run_search_loop, daemon=False)
+                if hasattr(arr, "process_search_loop"):
+                    arr.process_search_loop = new_proc
+            elif role == "torrent" and hasattr(arr, "run_torrent_loop"):
+                new_proc = pathos.helpers.mp.Process(target=arr.run_torrent_loop, daemon=False)
+                if hasattr(arr, "process_torrent_loop"):
+                    arr.process_torrent_loop = new_proc
+            else:
+                self.logger.error(
+                    "Unknown role '%s' for category '%s' or target method not found",
+                    role,
+                    category,
+                )
+                return False
+
+            if not new_proc:
+                return False
+
+            # Start the new process
+            new_proc.start()
+
+            # Update restart tracking
+            key = (category, role)
+            self._process_restart_counts.setdefault(key, []).append(time.time())
+
+            # Replace in child_processes list
+            with contextlib.suppress(ValueError):
+                self.child_processes.remove(failed_proc)
+            self.child_processes.append(new_proc)
+
+            # Update registry
+            self._process_registry.pop(failed_proc, None)
+            self._process_registry[new_proc] = meta
+
+            self.logger.notice(
+                "Successfully restarted %s worker for category '%s' (restarts in window: %d/%d)",
+                role,
+                category,
+                len(self._process_restart_counts[key]),
+                self.max_process_restarts,
+            )
+
+            return True
+
+        except Exception as e:
+            self.logger.exception(
+                "Failed to restart %s worker for category '%s': %s", role, category, e
+            )
+            return False
+
 
 def _report_config_issues():
     try:

qBitrr/search_activity_store.py

@@ -5,6 +5,7 @@ from typing import Any
 
 from peewee import Model, SqliteDatabase, TextField
 
+from qBitrr.db_lock import with_database_retry
 from qBitrr.home_path import APPDATA_FOLDER
 
 _DB_LOCK = RLock()
@@ -24,6 +25,7 @@ def _get_database() -> SqliteDatabase:
                 "foreign_keys": 1,
                 "ignore_check_constraints": 0,
                 "synchronous": 0,
+                "read_uncommitted": 1,
             },
             timeout=15,
             check_same_thread=False,
@@ -45,7 +47,8 @@ class SearchActivity(BaseModel):
 def _ensure_tables() -> None:
     db = _get_database()
     with _DB_LOCK:
-        db.connect(reuse_if_open=True)
+        # Connect with retry logic for transient I/O errors
+        with_database_retry(lambda: db.connect(reuse_if_open=True))
         db.create_tables([SearchActivity], safe=True)
 
 
@@ -67,7 +70,8 @@ def fetch_search_activities() -> dict[str, dict[str, str | None]]:
     _ensure_tables()
     activities: dict[str, dict[str, str | None]] = {}
     db = _get_database()
-    db.connect(reuse_if_open=True)
+    # Connect with retry logic for transient I/O errors
+    with_database_retry(lambda: db.connect(reuse_if_open=True))
     try:
         query = SearchActivity.select()
     except Exception: