qBitrr2 5.7.0__py3-none-any.whl → 5.8.0__py3-none-any.whl

qBitrr/bundled_data.py

@@ -1,5 +1,5 @@
-version = "5.7.0"
-git_hash = "f7e3e092"
+version = "5.8.0"
+git_hash = "ae0807b0"
 license_text = (
     "Licence can be found on:\n\nhttps://github.com/Feramance/qBitrr/blob/master/LICENSE"
 )

qBitrr/config.py

@@ -151,7 +151,7 @@ PING_URLS = ENVIRO_CONFIG.settings.ping_urls or CONFIG.get(
     "Settings.PingURLS", fallback=["one.one.one.one", "dns.google.com"]
 )
 IGNORE_TORRENTS_YOUNGER_THAN = ENVIRO_CONFIG.settings.ignore_torrents_younger_than or CONFIG.get(
-    "Settings.IgnoreTorrentsYoungerThan", fallback=600
+    "Settings.IgnoreTorrentsYoungerThan", fallback=180
 )
 QBIT_DISABLED = (
     CONFIG.get("qBit.Disabled", fallback=False)

qBitrr/database.py

@@ -0,0 +1,79 @@
+"""Single consolidated database for all Arr instances."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+from peewee import SqliteDatabase
+
+from qBitrr.config import APPDATA_FOLDER
+from qBitrr.db_lock import with_database_retry
+from qBitrr.tables import (
+    AlbumFilesModel,
+    AlbumQueueModel,
+    ArtistFilesModel,
+    EpisodeFilesModel,
+    EpisodeQueueModel,
+    FilesQueued,
+    MovieQueueModel,
+    MoviesFilesModel,
+    SeriesFilesModel,
+    TorrentLibrary,
+    TrackFilesModel,
+)
+
+logger = logging.getLogger("qBitrr.database")
+
+# Global database instance
+_db: SqliteDatabase | None = None
+
+
+def get_database() -> SqliteDatabase:
+    """Get or create the global database instance."""
+    global _db
+    if _db is None:
+        db_path = Path(APPDATA_FOLDER) / "qbitrr.db"
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+
+        _db = SqliteDatabase(
+            str(db_path),
+            pragmas={
+                "journal_mode": "wal",
+                "cache_size": -64_000,
+                "foreign_keys": 1,
+                "ignore_check_constraints": 0,
+                "synchronous": 0,
+                "read_uncommitted": 1,
+            },
+            timeout=15,
+        )
+
+        # Connect with retry logic
+        with_database_retry(
+            lambda: _db.connect(reuse_if_open=True),
+            logger=logger,
+        )
+
+        # Bind models to database
+        models = [
+            MoviesFilesModel,
+            EpisodeFilesModel,
+            AlbumFilesModel,
+            SeriesFilesModel,
+            ArtistFilesModel,
+            TrackFilesModel,
+            MovieQueueModel,
+            EpisodeQueueModel,
+            AlbumQueueModel,
+            FilesQueued,
+            TorrentLibrary,
+        ]
+        _db.bind(models)
+
+        # Create all tables
+        _db.create_tables(models, safe=True)
+
+        logger.info("Initialized single database: %s", db_path)
+
+    return _db

qBitrr/gen_config.py

@@ -385,48 +385,56 @@ def _gen_default_torrent_table(category: str, cat_default: Table):
         "CaseSensitiveMatches",
         False,
     )
-    if "anime" not in category.lower():
-        _gen_default_line(
-            torrent_table,
-            [
-                "These regex values will match any folder where the full name matches the specified values here, comma separated strings.",
-                "These regex need to be escaped, that's why you see so many backslashes.",
-            ],
-            "FolderExclusionRegex",
-            [
-                r"\bextras?\b",
-                r"\bfeaturettes?\b",
-                r"\bsamples?\b",
-                r"\bscreens?\b",
-                r"\bnc(ed|op)?(\\d+)?\b",
-            ],
-        )
+    # Set folder exclusions based on category type
+    if "anime" in category.lower():
+        # Anime-specific exclusions (includes OVA, specials, NCOP/NCED)
+        folder_exclusions = [
+            r"\bextras?\b",
+            r"\bfeaturettes?\b",
+            r"\bsamples?\b",
+            r"\bscreens?\b",
+            r"\bspecials?\b",
+            r"\bova\b",
+            r"\bnc(ed|op)?(\\d+)?\b",
+        ]
+    elif "lidarr" in category.lower():
+        # Music-specific exclusions (no NCOP/NCED, no featurettes)
+        folder_exclusions = [
+            r"\bextras?\b",
+            r"\bsamples?\b",
+            r"\bscreens?\b",
+        ]
     else:
-        _gen_default_line(
-            torrent_table,
-            [
-                "These regex values will match any folder where the full name matches the specified values here, comma separated strings.",
-                "These regex need to be escaped, that's why you see so many backslashes.",
-            ],
-            "FolderExclusionRegex",
-            [
-                r"\bextras?\b",
-                r"\bfeaturettes?\b",
-                r"\bsamples?\b",
-                r"\bscreens?\b",
-                r"\bspecials?\b",
-                r"\bova\b",
-                r"\bnc(ed|op)?(\\d+)?\b",
-            ],
-        )
+        # Standard video exclusions (movies/TV shows)
+        folder_exclusions = [
+            r"\bextras?\b",
+            r"\bfeaturettes?\b",
+            r"\bsamples?\b",
+            r"\bscreens?\b",
+            r"\bnc(ed|op)?(\\d+)?\b",
+        ]
+
     _gen_default_line(
         torrent_table,
         [
             "These regex values will match any folder where the full name matches the specified values here, comma separated strings.",
             "These regex need to be escaped, that's why you see so many backslashes.",
         ],
-        "FileNameExclusionRegex",
-        [
+        "FolderExclusionRegex",
+        folder_exclusions,
+    )
+    # Set filename exclusions based on category type
+    if "lidarr" in category.lower():
+        # Music-specific exclusions (no NCOP/NCED, no "music video" since that's actual music content)
+        filename_exclusions = [
+            r"\bsample\b",
+            r"brarbg.com\b",
+            r"\btrailer\b",
+            r"comandotorrents.com",
+        ]
+    else:
+        # Video exclusions (movies/TV/anime)
+        filename_exclusions = [
             r"\bncop\\d+?\b",
             r"\bnced\\d+?\b",
             r"\bsample\b",
@@ -434,13 +442,40 @@ def _gen_default_torrent_table(category: str, cat_default: Table):
             r"\btrailer\b",
             r"music video",
             r"comandotorrents.com",
+        ]
+
+    _gen_default_line(
+        torrent_table,
+        [
+            "These regex values will match any folder where the full name matches the specified values here, comma separated strings.",
+            "These regex need to be escaped, that's why you see so many backslashes.",
         ],
-    )
+        "FileNameExclusionRegex",
+        filename_exclusions,
+    )
+    # Set appropriate file extensions based on category type
+    if "lidarr" in category.lower():
+        file_extensions = [
+            ".mp3",
+            ".flac",
+            ".m4a",
+            ".aac",
+            ".ogg",
+            ".opus",
+            ".wav",
+            ".ape",
+            ".wma",
+            ".!qB",
+            ".parts",
+        ]
+    else:
+        file_extensions = [".mp4", ".mkv", ".sub", ".ass", ".srt", ".!qB", ".parts"]
+
     _gen_default_line(
         torrent_table,
         "Only files with these extensions will be allowed to be downloaded, comma separated strings or regex, leave it empty to allow all extensions",
         "FileExtensionAllowlist",
-        [".mp4", ".mkv", ".sub", ".ass", ".srt", ".!qB", ".parts"],
+        file_extensions,
     )
     _gen_default_line(
         torrent_table,
@@ -698,9 +733,15 @@ def _gen_default_search_table(category: str, cat_default: Table):
         )
     # SearchByYear doesn't apply to Lidarr (music albums)
     if "lidarr" not in category.lower():
+        if "sonarr" in category.lower():
+            search_by_year_comment = (
+                "It will order searches by the year the episode was first aired"
+            )
+        else:
+            search_by_year_comment = "It will order searches by the year the movie was released"
         _gen_default_line(
             search_table,
-            "It will order searches by the year the EPISODE was first aired",
+            search_by_year_comment,
             "SearchByYear",
             True,
         )
@@ -711,12 +752,14 @@ def _gen_default_search_table(category: str, cat_default: Table):
         False,
     )
     _gen_default_line(
-        search_table, "Delay between request searches in seconds", "SearchRequestsEvery", 300
+        search_table,
+        "Delay (in seconds) between checking for new Overseerr/Ombi requests. Does NOT affect delay between individual search commands (use Settings.SearchLoopDelay for that).",
+        "SearchRequestsEvery",
+        300,
     )
     _gen_default_line(
         search_table,
-        "Search movies which already have a file in the database in hopes of finding a "
-        "better quality version.",
+        "Search media which already have a file in hopes of finding a better quality version.",
         "DoUpgradeSearch",
         False,
     )

qBitrr/main.py

@@ -53,28 +53,34 @@ def _mask_secret(value: str | None) -> str:
 
 def _delete_all_databases() -> None:
     """
-    Delete all database files from the APPDATA_FOLDER on startup.
+    Delete old per-instance database files from the APPDATA_FOLDER on startup.
 
-    This includes:
-    - All .db files (SQLite databases)
-    - All .db-wal files (Write-Ahead Log files)
-    - All .db-shm files (Shared Memory files)
+    Preserves the consolidated database (qbitrr.db) and Torrents.db.
+    Deletes old per-instance databases and their WAL/SHM files.
     """
     db_patterns = ["*.db", "*.db-wal", "*.db-shm"]
     deleted_files = []
+    # Files to preserve (consolidated database)
+    preserve_files = {"qbitrr.db", "Torrents.db"}
 
     for pattern in db_patterns:
         for db_file in glob.glob(str(APPDATA_FOLDER.joinpath(pattern))):
+            base_name = os.path.basename(db_file)
+            # Preserve consolidated database and its WAL/SHM files
+            should_preserve = any(base_name.startswith(f) for f in preserve_files)
+            if should_preserve:
+                continue
+
             try:
                 os.remove(db_file)
-                deleted_files.append(os.path.basename(db_file))
+                deleted_files.append(base_name)
             except Exception as e:
                 logger.error("Failed to delete database file %s: %s", db_file, e)
 
     if deleted_files:
-        logger.info("Deleted database files on startup: %s", ", ".join(deleted_files))
+        logger.info("Deleted old database files on startup: %s", ", ".join(deleted_files))
     else:
-        logger.debug("No database files found to delete on startup")
+        logger.debug("No old database files found to delete on startup")
 
 
 class qBitManager:
@@ -86,6 +92,7 @@ class qBitManager:
     def __init__(self):
         self._name = "Manager"
         self.shutdown_event = Event()
+        self.database_restart_event = Event()  # Signal for coordinated database recovery restart
         self.qBit_Host = CONFIG.get("qBit.Host", fallback="localhost")
         self.qBit_Port = CONFIG.get("qBit.Port", fallback=8105)
         self.qBit_UserName = CONFIG.get("qBit.UserName", fallback=None)
@@ -151,6 +158,8 @@ class qBitManager:
         self._process_restart_counts: dict[tuple[str, str], list[float]] = (
             {}
         )  # (category, role) -> [timestamps]
+        self._failed_spawn_attempts: dict[tuple[str, str], int] = {}  # Track failed spawn attempts
+        self._pending_spawns: list[tuple] = []  # (arr_instance, meta) tuples to retry
         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)
@@ -696,6 +705,8 @@ class qBitManager:
                 self.logger.warning(
                     "Startup thread still running after 60s; managing available workers."
                 )
+            started_processes = []
+            failed_processes = []
             for proc in list(self.child_processes):
                 try:
                     # Check if process has already been started
@@ -710,20 +721,153 @@ class qBitManager:
                         )
                         continue
 
-                    proc.start()
                     meta = self._process_registry.get(proc, {})
-                    self.logger.debug(
-                        "Started %s worker for category '%s'",
+                    self.logger.info(
+                        "Starting %s worker for category '%s'...",
                         meta.get("role", "worker"),
                         meta.get("category", "unknown"),
                     )
+                    proc.start()
+
+                    # Verify process actually started (give it a moment)
+                    time.sleep(0.1)
+                    if proc.is_alive():
+                        self.logger.info(
+                            "Successfully started %s worker for category '%s' (PID: %s)",
+                            meta.get("role", "worker"),
+                            meta.get("category", "unknown"),
+                            proc.pid,
+                        )
+                        started_processes.append((meta.get("role"), meta.get("category")))
+                    else:
+                        self.logger.error(
+                            "Process %s worker for category '%s' started but immediately died (exitcode: %s)",
+                            meta.get("role", "worker"),
+                            meta.get("category", "unknown"),
+                            proc.exitcode,
+                        )
+                        failed_processes.append((meta.get("role"), meta.get("category")))
                 except Exception as exc:
-                    self.logger.exception(
-                        "Failed to start worker process %s",
-                        getattr(proc, "name", repr(proc)),
+                    meta = self._process_registry.get(proc, {})
+                    self.logger.critical(
+                        "FAILED to start %s worker for category '%s': %s",
+                        meta.get("role", "worker"),
+                        meta.get("category", "unknown"),
+                        exc,
                         exc_info=exc,
                     )
+                    failed_processes.append((meta.get("role"), meta.get("category")))
+
+            # Log summary
+            if started_processes:
+                self.logger.info(
+                    "Started %d worker process(es): %s",
+                    len(started_processes),
+                    ", ".join(f"{role}({cat})" for role, cat in started_processes),
+                )
+            if failed_processes:
+                self.logger.critical(
+                    "FAILED to start %d worker process(es): %s - Will retry periodically",
+                    len(failed_processes),
+                    ", ".join(f"{role}({cat})" for role, cat in failed_processes),
+                )
+                # Track failed processes for retry
+                for role, category in failed_processes:
+                    key = (category, role)
+                    self._failed_spawn_attempts[key] = self._failed_spawn_attempts.get(key, 0) + 1
+                    # Add to retry queue if not already there
+                    if hasattr(self, "arr_manager") and self.arr_manager:
+                        for arr in self.arr_manager.managed_objects.values():
+                            if arr.category == category:
+                                # Check if already in pending spawns (avoid duplicates)
+                                meta = {"category": category, "role": role, "name": arr._name}
+                                already_pending = any(
+                                    m.get("category") == category and m.get("role") == role
+                                    for _, m in self._pending_spawns
+                                )
+                                if not already_pending:
+                                    self._pending_spawns.append((arr, meta))
+                                break
             while not self.shutdown_event.is_set():
+                # Check for database restart signal
+                if self.database_restart_event.is_set():
+                    self.logger.critical(
+                        "Database restart signal detected - terminating ALL processes for coordinated restart..."
+                    )
+                    # Terminate all child processes
+                    for proc in list(self.child_processes):
+                        if proc.is_alive():
+                            self.logger.warning(
+                                "Terminating %s process for database recovery",
+                                self._process_registry.get(proc, {}).get("role", "worker"),
+                            )
+                            proc.terminate()
+                    # Wait for processes to terminate
+                    time.sleep(2)
+                    # Force kill any that didn't terminate
+                    for proc in list(self.child_processes):
+                        if proc.is_alive():
+                            self.logger.error(
+                                "Force killing %s process",
+                                self._process_registry.get(proc, {}).get("role", "worker"),
+                            )
+                            proc.kill()
+                    # Clear all processes
+                    self.child_processes.clear()
+                    self._process_registry.clear()
+                    # Clear the event
+                    self.database_restart_event.clear()
+                    # Restart all Arr instances
+                    self.logger.critical("Restarting all Arr instances after database recovery...")
+                    if hasattr(self, "arr_manager") and self.arr_manager:
+                        for arr in self.arr_manager.managed_objects.values():
+                            try:
+                                worker_count, procs = arr.spawn_child_processes()
+                                for proc in procs:
+                                    role = (
+                                        "search"
+                                        if getattr(arr, "process_search_loop", None) is proc
+                                        else "torrent"
+                                    )
+                                    self._process_registry[proc] = {
+                                        "category": getattr(arr, "category", ""),
+                                        "name": getattr(arr, "_name", ""),
+                                        "role": role,
+                                    }
+                                    # CRITICAL: Actually start the process!
+                                    try:
+                                        proc.start()
+                                        time.sleep(0.1)  # Brief pause to let process initialize
+                                        if proc.is_alive():
+                                            self.logger.info(
+                                                "Started %s worker for %s (PID: %s)",
+                                                role,
+                                                arr._name,
+                                                proc.pid,
+                                            )
+                                        else:
+                                            self.logger.error(
+                                                "Respawned %s worker for %s died immediately (exitcode: %s)",
+                                                role,
+                                                arr._name,
+                                                proc.exitcode,
+                                            )
+                                    except Exception as start_exc:
+                                        self.logger.error(
+                                            "Failed to start respawned %s worker for %s: %s",
+                                            role,
+                                            arr._name,
+                                            start_exc,
+                                        )
+                                self.logger.info(
+                                    "Respawned %d process(es) for %s", worker_count, arr._name
+                                )
+                            except Exception as e:
+                                self.logger.exception(
+                                    "Failed to respawn processes for %s: %s", arr._name, e
+                                )
+                    continue
+
                 any_alive = False
                 for proc in list(self.child_processes):
                     if proc.is_alive():
@@ -766,6 +910,78 @@ class qBitManager:
                     with contextlib.suppress(ValueError):
                         self.child_processes.remove(proc)
 
+                # Retry failed process spawns
+                if self._pending_spawns and self.auto_restart_enabled:
+                    retry_spawns = []
+                    for arr, meta in self._pending_spawns:
+                        category = meta.get("category", "")
+                        role = meta.get("role", "")
+                        key = (category, role)
+                        attempts = self._failed_spawn_attempts.get(key, 0)
+
+                        # Exponential backoff: 30s, 60s, 120s, 240s, 480s (max 8min)
+                        # Retry indefinitely but with increasing delays
+                        self.logger.info(
+                            "Retrying spawn of %s worker for '%s' (attempt #%d)...",
+                            role,
+                            category,
+                            attempts + 1,
+                        )
+
+                        try:
+                            worker_count, procs = arr.spawn_child_processes()
+                            if worker_count > 0:
+                                for proc in procs:
+                                    proc_role = (
+                                        "search"
+                                        if getattr(arr, "process_search_loop", None) is proc
+                                        else "torrent"
+                                    )
+                                    if proc_role == role:  # Only start the one we're retrying
+                                        try:
+                                            proc.start()
+                                            time.sleep(0.1)
+                                            if proc.is_alive():
+                                                self.logger.info(
+                                                    "Successfully spawned %s worker for '%s' on retry (PID: %s)",
+                                                    role,
+                                                    category,
+                                                    proc.pid,
+                                                )
+                                                self._process_registry[proc] = meta
+                                                # CRITICAL: Add to child_processes so it's monitored
+                                                if proc not in self.child_processes:
+                                                    self.child_processes.append(proc)
+                                                # Clear failed attempts on success
+                                                self._failed_spawn_attempts.pop(key, None)
+                                            else:
+                                                self.logger.error(
+                                                    "Retry spawn failed: %s worker for '%s' died immediately",
+                                                    role,
+                                                    category,
+                                                )
+                                                retry_spawns.append((arr, meta))
+                                                self._failed_spawn_attempts[key] = attempts + 1
+                                        except Exception as exc:
+                                            self.logger.error(
+                                                "Retry spawn failed for %s worker '%s': %s",
+                                                role,
+                                                category,
+                                                exc,
+                                            )
+                                            retry_spawns.append((arr, meta))
+                                            self._failed_spawn_attempts[key] = attempts + 1
+                        except Exception as exc:
+                            self.logger.error(
+                                "Failed to respawn processes for retry: %s",
+                                exc,
+                            )
+                            retry_spawns.append((arr, meta))
+                            self._failed_spawn_attempts[key] = attempts + 1
+
+                    # Update pending spawns list
+                    self._pending_spawns = retry_spawns
+
                 if not self.child_processes:
                     if not any_alive:
                         break

qBitrr/search_activity_store.py

@@ -3,52 +3,25 @@ from __future__ import annotations
 from threading import RLock
 from typing import Any
 
-from peewee import Model, SqliteDatabase, TextField
+from peewee import Model, TextField
 
-from qBitrr.db_lock import with_database_retry
-from qBitrr.home_path import APPDATA_FOLDER
+from qBitrr.database import get_database
 
 _DB_LOCK = RLock()
-_DB_INSTANCE: SqliteDatabase | None = None
 
 
-def _get_database() -> SqliteDatabase:
-    global _DB_INSTANCE
-    if _DB_INSTANCE is None:
-        path = APPDATA_FOLDER.joinpath("webui_activity.db")
-        path.parent.mkdir(parents=True, exist_ok=True)
-        _DB_INSTANCE = SqliteDatabase(
-            str(path),
-            pragmas={
-                "journal_mode": "wal",
-                "cache_size": -64_000,
-                "foreign_keys": 1,
-                "ignore_check_constraints": 0,
-                "synchronous": 0,
-                "read_uncommitted": 1,
-            },
-            timeout=15,
-            check_same_thread=False,
-        )
-    return _DB_INSTANCE
-
-
-class BaseModel(Model):
-    class Meta:
-        database = _get_database()
-
-
-class SearchActivity(BaseModel):
+class SearchActivity(Model):
     category = TextField(primary_key=True)
     summary = TextField(null=True)
     timestamp = TextField(null=True)
 
 
 def _ensure_tables() -> None:
-    db = _get_database()
+    db = get_database()
     with _DB_LOCK:
-        # Connect with retry logic for transient I/O errors
-        with_database_retry(lambda: db.connect(reuse_if_open=True))
+        # Bind model to database if not already bound
+        if not SearchActivity._meta.database:
+            db.bind([SearchActivity])
         db.create_tables([SearchActivity], safe=True)
 
 
@@ -59,7 +32,7 @@ def record_search_activity(category: str, summary: str | None, timestamp: str |
     if timestamp is not None and not isinstance(timestamp, str):
         timestamp = str(timestamp)
     data: dict[str, Any] = {"summary": summary, "timestamp": timestamp}
-    with _get_database().atomic():
+    with get_database().atomic():
         SearchActivity.insert(category=category, **data).on_conflict(
             conflict_target=[SearchActivity.category],
             update=data,
@@ -69,9 +42,6 @@ def record_search_activity(category: str, summary: str | None, timestamp: str |
 def fetch_search_activities() -> dict[str, dict[str, str | None]]:
     _ensure_tables()
     activities: dict[str, dict[str, str | None]] = {}
-    db = _get_database()
-    # 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:
@@ -88,5 +58,5 @@ def clear_search_activity(category: str) -> None:
     if not category:
         return
     _ensure_tables()
-    with _get_database().atomic():
+    with get_database().atomic():
         SearchActivity.delete().where(SearchActivity.category == category).execute()