qBitrr2 5.7.1__tar.gz → 5.8.0__tar.gz

{qbitrr2-5.7.1/qBitrr2.egg-info → qbitrr2-5.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qBitrr2
-Version: 5.7.1
+Version: 5.8.0
 Summary: Intelligent automation for qBittorrent and *Arr apps (Radarr/Sonarr/Lidarr) - health monitoring, instant imports, quality upgrades, request integration
 Home-page: https://github.com/Feramance/qBitrr
 Author: Feramance
@@ -169,6 +169,24 @@ services:
 
 Access the WebUI at `http://<host>:6969/ui` after startup.
 
+## 🆕 What's New in v5.8.0
+
+### Single Consolidated Database
+qBitrr now uses a **single `qbitrr.db` file** for all Arr instances, replacing the previous per-instance database approach.
+
+**Benefits:**
+- ✅ Single file to backup instead of 9+ separate databases
+- ✅ 78% code reduction in database initialization
+- ✅ Better performance with shared connection pool
+- ✅ Simplified database management
+
+**Migration:**
+- Automatic on first upgrade (5-30 minutes re-sync from Arr APIs)
+- Old databases deleted automatically
+- No manual intervention required
+
+[Full Migration Guide →](https://feramance.github.io/qBitrr/getting-started/migration/)
+
 ## ✨ Key Features
 
 - **🚀 Multi-qBittorrent Support (v3.0+)** – Manage torrents across multiple qBittorrent instances for load balancing, redundancy, and VPN isolation

{qbitrr2-5.7.1 → qbitrr2-5.8.0}/README.md

@@ -65,6 +65,24 @@ services:
 
 Access the WebUI at `http://<host>:6969/ui` after startup.
 
+## 🆕 What's New in v5.8.0
+
+### Single Consolidated Database
+qBitrr now uses a **single `qbitrr.db` file** for all Arr instances, replacing the previous per-instance database approach.
+
+**Benefits:**
+- ✅ Single file to backup instead of 9+ separate databases
+- ✅ 78% code reduction in database initialization
+- ✅ Better performance with shared connection pool
+- ✅ Simplified database management
+
+**Migration:**
+- Automatic on first upgrade (5-30 minutes re-sync from Arr APIs)
+- Old databases deleted automatically
+- No manual intervention required
+
+[Full Migration Guide →](https://feramance.github.io/qBitrr/getting-started/migration/)
+
 ## ✨ Key Features
 
 - **🚀 Multi-qBittorrent Support (v3.0+)** – Manage torrents across multiple qBittorrent instances for load balancing, redundancy, and VPN isolation

{qbitrr2-5.7.1 → qbitrr2-5.8.0}/pyproject.toml

@@ -28,7 +28,7 @@ target-version = ['py311']
 
 [tool.poetry]
 name = "pypi-public"
-version = "5.7.1"
+version = "5.8.0"
 description = "Intelligent automation for qBittorrent and *Arr apps (Radarr/Sonarr/Lidarr) - health monitoring, instant imports, quality upgrades, request integration"
 authors = ["Drapersniper", "Feramance"]
 readme = "README.md"

{qbitrr2-5.7.1 → qbitrr2-5.8.0}/qBitrr/arss.py

@@ -6615,159 +6615,43 @@ class Arr:
             self.logger.error(f"Error checking temp profile timeouts: {e}", exc_info=True)
 
     def register_search_mode(self):
+        """Initialize database models using the single shared database."""
         if self.search_setup_completed:
             return
 
-        db1, db2, db3, db4, db5 = self._get_models()
+        # Import the shared database
+        from qBitrr.database import get_database
 
-        if not (
-            self.search_missing
-            or self.do_upgrade_search
-            or self.quality_unmet_search
-            or self.custom_format_unmet_search
-            or self.ombi_search_requests
-            or self.overseerr_requests
-        ):
-            if db5 and getattr(self, "torrents", None) is None:
-                self.torrent_db = SqliteDatabase(None)
-                self.torrent_db.init(
-                    str(self._app_data_folder.joinpath("Torrents.db")),
-                    pragmas={
-                        "journal_mode": "wal",
-                        "cache_size": -64_000,
-                        "foreign_keys": 1,
-                        "ignore_check_constraints": 0,
-                        "synchronous": 0,
-                        "read_uncommitted": 1,
-                    },
-                    timeout=15,
-                )
-
-                class Torrents(db5):
-                    class Meta:
-                        database = self.torrent_db
-
-                # Connect with retry logic for transient I/O errors
-                with_database_retry(
-                    lambda: self.torrent_db.connect(),
-                    logger=self.logger,
-                )
-                self.torrent_db.create_tables([Torrents])
-                self.torrents = Torrents
-            self.search_setup_completed = True
-            return
-
-        self.search_db_file.parent.mkdir(parents=True, exist_ok=True)
-        self.db = SqliteDatabase(None)
-        self.db.init(
-            str(self.search_db_file),
-            pragmas={
-                "journal_mode": "wal",
-                "cache_size": -64_000,
-                "foreign_keys": 1,
-                "ignore_check_constraints": 0,
-                "synchronous": 0,
-                "read_uncommitted": 1,
-            },
-            timeout=15,
-        )
-
-        class Files(db1):
-            class Meta:
-                database = self.db
-
-        class Queue(db2):
-            class Meta:
-                database = self.db
-
-        class PersistingQueue(FilesQueued):
-            class Meta:
-                database = self.db
+        self.db = get_database()
 
-        # Connect with retry logic for transient I/O errors
-        with_database_retry(
-            lambda: self.db.connect(),
-            logger=self.logger,
+        # Get the appropriate model classes for this Arr type
+        file_model, queue_model, series_or_artist_model, track_model, torrent_model = (
+            self._get_models()
         )
 
-        if db4:
-
-            class Tracks(db4):
-                class Meta:
-                    database = self.db
-
-            self.track_file_model = Tracks
-        else:
-            self.track_file_model = None
-
-        if db3 and self.type == "sonarr":
-
-            class Series(db3):
-                class Meta:
-                    database = self.db
+        # Set model references for this instance
+        self.model_file = file_model
+        self.model_queue = queue_model
+        self.persistent_queue = FilesQueued
 
-            try:
-                self.db.create_tables([Files, Queue, PersistingQueue, Series], safe=True)
-            except Exception as e:
-                self.logger.error("Failed to create database tables for Sonarr: %s", e)
-                raise
-            self.series_file_model = Series
-            self.artists_file_model = None
-        elif db3 and self.type == "lidarr":
-
-            class Artists(db3):
-                class Meta:
-                    database = self.db
-
-            try:
-                self.db.create_tables([Files, Queue, PersistingQueue, Artists, Tracks], safe=True)
-            except Exception as e:
-                self.logger.error("Failed to create database tables for Lidarr: %s", e)
-                raise
-            self.artists_file_model = Artists
-            self.series_file_model = None  # Lidarr uses artists, not series
-        else:
-            # Radarr or any type without db3/db4 (series/artists/tracks models)
-            try:
-                self.db.create_tables([Files, Queue, PersistingQueue], safe=True)
-            except Exception as e:
-                self.logger.error("Failed to create database tables for Radarr: %s", e)
-                raise
+        # Set type-specific models
+        if self.type == "sonarr":
+            self.series_file_model = series_or_artist_model
             self.artists_file_model = None
+            self.track_file_model = None
+        elif self.type == "lidarr":
             self.series_file_model = None
+            self.artists_file_model = series_or_artist_model
+            self.track_file_model = track_model
+        else:  # radarr
+            self.series_file_model = None
+            self.artists_file_model = None
+            self.track_file_model = None
 
-        if db5:
-            self.torrent_db = SqliteDatabase(None)
-            self.torrent_db.init(
-                str(self._app_data_folder.joinpath("Torrents.db")),
-                pragmas={
-                    "journal_mode": "wal",
-                    "cache_size": -64_000,
-                    "foreign_keys": 1,
-                    "ignore_check_constraints": 0,
-                    "synchronous": 0,
-                    "read_uncommitted": 1,
-                },
-                timeout=15,
-            )
-
-            class Torrents(db5):
-                class Meta:
-                    database = self.torrent_db
-
-            # Connect with retry logic for transient I/O errors
-            with_database_retry(
-                lambda: self.torrent_db.connect(),
-                logger=self.logger,
-            )
-            self.torrent_db.create_tables([Torrents])
-            self.torrents = Torrents
-        else:
-            self.torrents = None
+        # Set torrents model if TAGLESS is enabled
+        self.torrents = torrent_model if TAGLESS else None
 
-        self.model_file = Files
-        self.model_queue = Queue
-        self.persistent_queue = PersistingQueue
+        self.logger.debug("Database initialization completed for %s", self._name)
         self.search_setup_completed = True
 
     def _get_models(

{qbitrr2-5.7.1 → qbitrr2-5.8.0}/qBitrr/bundled_data.py

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

qbitrr2-5.8.0/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

{qbitrr2-5.7.1 → qbitrr2-5.8.0}/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:

{qbitrr2-5.7.1 → qbitrr2-5.8.0}/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()