qBitrr2 5.8.6__py3-none-any.whl → 5.8.8__py3-none-any.whl

qBitrr/arss.py

@@ -7649,6 +7649,7 @@ class ArrManager:
         self.uris: set[str] = set()
         self.special_categories: set[str] = {FAILED_CATEGORY, RECHECK_CATEGORY}
         self.arr_categories: set[str] = set()
+        self.qbit_managed_categories: set[str] = set()
         self.category_allowlist: set[str] = self.special_categories.copy()
         self.completed_folders: set[pathlib.Path] = set()
         self.managed_objects: dict[str, Arr] = {}
@@ -7663,6 +7664,62 @@ class ArrManager:
                 self.qbit_manager.ffprobe_downloader.probe_path,
             )
 
+    def _validate_category_assignments(self):
+        """
+        Validate that no category is managed by both Arr and qBit instances.
+
+        Collects all qBit-managed categories from all qBit instances and checks
+        for conflicts with Arr-managed categories. Allows same category on
+        multiple qBit instances (acceptable).
+
+        Raises:
+            ValueError: If any category is managed by both Arr and qBit
+        """
+        # Collect qBit-managed categories from all instances
+        for section in CONFIG.sections():
+            # Check default qBit section
+            if section == "qBit":
+                managed_cats = CONFIG.get("qBit.ManagedCategories", fallback=[])
+                if managed_cats:
+                    self.qbit_managed_categories.update(managed_cats)
+                    self.logger.debug(
+                        "qBit instance 'default' manages categories: %s",
+                        ", ".join(managed_cats),
+                    )
+            # Check additional qBit-XXX sections
+            elif section.startswith("qBit-"):
+                instance_name = section.replace("qBit-", "", 1)
+                managed_cats = CONFIG.get(f"{section}.ManagedCategories", fallback=[])
+                if managed_cats:
+                    self.qbit_managed_categories.update(managed_cats)
+                    self.logger.debug(
+                        "qBit instance '%s' manages categories: %s",
+                        instance_name,
+                        ", ".join(managed_cats),
+                    )
+
+        # Check for conflicts between Arr and qBit categories
+        conflicts = self.arr_categories & self.qbit_managed_categories
+        if conflicts:
+            conflict_list = ", ".join(sorted(conflicts))
+            error_msg = (
+                f"Category conflict detected: {conflict_list} "
+                f"cannot be managed by both Arr instances and qBit instances. "
+                f"Please assign each category to either Arr OR qBit management, not both."
+            )
+            self.logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        # Update category allowlist to include qBit-managed categories
+        self.category_allowlist.update(self.qbit_managed_categories)
+
+        if self.qbit_managed_categories:
+            self.logger.info(
+                "qBit-managed categories registered: %s",
+                ", ".join(sorted(self.qbit_managed_categories)),
+            )
+        self.logger.debug("Category validation passed - no conflicts detected")
+
     def build_arr_instances(self):
         for key in CONFIG.sections():
             if search := re.match("(rad|son|anim|lid)arr.*", key, re.IGNORECASE):
@@ -7690,6 +7747,10 @@ class ArrManager:
                     continue
                 except (OSError, TypeError) as e:
                     self.logger.exception(e)
+
+        # Validate category assignments after all Arr instances are initialized
+        self._validate_category_assignments()
+
         if (
             FREE_SPACE != "-1"
             and AUTO_PAUSE_RESUME

qBitrr/bundled_data.py

@@ -1,5 +1,5 @@
-version = "5.8.6"
-git_hash = "236b1bf2"
+version = "5.8.8"
+git_hash = "7569d1c7"
 license_text = (
     "Licence can be found on:\n\nhttps://github.com/Feramance/qBitrr/blob/master/LICENSE"
 )

qBitrr/config_version.py

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
     from qBitrr.gen_config import MyConfig
 
 # Current expected config version - increment when schema changes require migration
-EXPECTED_CONFIG_VERSION = 3
+EXPECTED_CONFIG_VERSION = 4
 
 logger = logging.getLogger(__name__)
 

qBitrr/database.py

@@ -43,8 +43,10 @@ def get_database() -> SqliteDatabase:
                 "cache_size": -64_000,
                 "foreign_keys": 1,
                 "ignore_check_constraints": 0,
-                "synchronous": 0,
+                "synchronous": 2,  # FULL mode - maximum safety, prevents corruption on power loss
                 "read_uncommitted": 1,
+                "wal_autocheckpoint": 100,  # Checkpoint every 100 pages (more frequent = safer)
+                "journal_size_limit": 67108864,  # 64MB max WAL size
             },
             timeout=15,
         )
@@ -148,3 +150,29 @@ def _create_arrinstance_indexes(db: SqliteDatabase, models: list) -> None:
         db.commit()
     except Exception as e:
         logger.error("Error creating ArrInstance indexes: %s", e)
+
+
+def get_database_path() -> Path:
+    """Get the path to the database file."""
+    return Path(APPDATA_FOLDER) / "qbitrr.db"
+
+
+def checkpoint_database() -> bool:
+    """
+    Checkpoint the database WAL to prevent corruption on shutdown.
+
+    This is called automatically on graceful shutdown to ensure all
+    WAL entries are flushed to the main database file.
+
+    Returns:
+        True if checkpoint successful, False otherwise
+    """
+    from qBitrr.db_recovery import checkpoint_wal
+
+    db_path = get_database_path()
+    if not db_path.exists():
+        logger.debug("Database file does not exist, skipping checkpoint")
+        return True
+
+    logger.info("Checkpointing database WAL before shutdown...")
+    return checkpoint_wal(db_path, logger_override=logger)

qBitrr/gen_config.py

@@ -61,6 +61,12 @@ def _add_web_settings_section(config: TOMLDocument):
         "Theme",
         "Dark",
     )
+    _gen_default_line(
+        web_settings,
+        "WebUI view density (Comfortable or Compact)",
+        "ViewDensity",
+        "Comfortable",
+    )
     config.add("WebUI", web_settings)
 
 
@@ -283,6 +289,58 @@ def _add_qbit_section(config: TOMLDocument):
         "Password",
         ENVIRO_CONFIG.qbit.password or "CHANGE_ME",
     )
+    _gen_default_line(
+        qbit,
+        [
+            "Categories managed directly by this qBit instance (not managed by Arr instances).",
+            "These categories will have seeding settings applied according to CategorySeeding configuration.",
+            "Example: ['downloads', 'private-tracker', 'long-term-seed']",
+        ],
+        "ManagedCategories",
+        [],
+    )
+
+    # Add CategorySeeding subsection
+    category_seeding = table()
+    _gen_default_line(
+        category_seeding,
+        "Download rate limit per torrent in KB/s (-1 = disabled)",
+        "DownloadRateLimitPerTorrent",
+        -1,
+    )
+    _gen_default_line(
+        category_seeding,
+        "Upload rate limit per torrent in KB/s (-1 = disabled)",
+        "UploadRateLimitPerTorrent",
+        -1,
+    )
+    _gen_default_line(
+        category_seeding,
+        "Maximum upload ratio (-1 = disabled, e.g. 2.0 for 200%)",
+        "MaxUploadRatio",
+        -1,
+    )
+    _gen_default_line(
+        category_seeding,
+        "Maximum seeding time in seconds (-1 = disabled, e.g. 604800 for 7 days)",
+        "MaxSeedingTime",
+        -1,
+    )
+    _gen_default_line(
+        category_seeding,
+        [
+            "When to remove torrents from qBittorrent:",
+            "  -1 = Never remove",
+            "   1 = Remove when MaxUploadRatio is reached",
+            "   2 = Remove when MaxSeedingTime is reached",
+            "   3 = Remove when either condition is met (OR)",
+            "   4 = Remove when both conditions are met (AND)",
+        ],
+        "RemoveTorrent",
+        -1,
+    )
+    qbit.add("CategorySeeding", category_seeding)
+
     config.add("qBit", qbit)
 
 
@@ -1152,6 +1210,79 @@ def _migrate_quality_profile_mappings(config: MyConfig) -> bool:
     return changes_made
 
 
+def _migrate_qbit_category_settings(config: MyConfig) -> bool:
+    """
+    Add qBit category management settings to existing configs.
+
+    Migration runs if:
+    - ConfigVersion < 4
+
+    Adds ManagedCategories and CategorySeeding configuration to all qBit sections.
+
+    After migration, ConfigVersion will be set to 4 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 >= 4:
+        return False  # Already migrated
+
+    changes_made = False
+
+    # Migrate default qBit section
+    if "qBit" in config.config:
+        qbit_section = config.config["qBit"]
+        if "ManagedCategories" not in qbit_section:
+            qbit_section["ManagedCategories"] = []
+            changes_made = True
+            logger.info("Added ManagedCategories = [] to [qBit]")
+
+        # Add CategorySeeding subsection
+        if "CategorySeeding" not in qbit_section:
+            seeding = table()
+            seeding["DownloadRateLimitPerTorrent"] = -1
+            seeding["UploadRateLimitPerTorrent"] = -1
+            seeding["MaxUploadRatio"] = -1
+            seeding["MaxSeedingTime"] = -1
+            seeding["RemoveTorrent"] = -1
+            qbit_section["CategorySeeding"] = seeding
+            changes_made = True
+            logger.info("Added CategorySeeding configuration to [qBit]")
+
+    # Migrate additional qBit instances (qBit-XXX)
+    for section in config.config.keys():
+        if str(section).startswith("qBit-"):
+            qbit_section = config.config[str(section)]
+            if "ManagedCategories" not in qbit_section:
+                qbit_section["ManagedCategories"] = []
+                changes_made = True
+                logger.info(f"Added ManagedCategories = [] to [{section}]")
+
+            if "CategorySeeding" not in qbit_section:
+                seeding = table()
+                seeding["DownloadRateLimitPerTorrent"] = -1
+                seeding["UploadRateLimitPerTorrent"] = -1
+                seeding["MaxUploadRatio"] = -1
+                seeding["MaxSeedingTime"] = -1
+                seeding["RemoveTorrent"] = -1
+                qbit_section["CategorySeeding"] = seeding
+                changes_made = True
+                logger.info(f"Added CategorySeeding configuration to [{section}]")
+
+    if changes_made:
+        print("Migration v3→v4: Added qBit category management settings")
+
+    return changes_made
+
+
 def _normalize_theme_value(value: Any) -> str:
     """
     Normalize theme value to always be 'Light' or 'Dark' (case insensitive input).
@@ -1168,6 +1299,22 @@ def _normalize_theme_value(value: Any) -> str:
         return "Dark"
 
 
+def _normalize_view_density_value(value: Any) -> str:
+    """
+    Normalize view density value to always be 'Comfortable' or 'Compact' (case insensitive input).
+    """
+    if value is None:
+        return "Comfortable"
+    value_str = str(value).strip().lower()
+    if value_str == "comfortable":
+        return "Comfortable"
+    elif value_str == "compact":
+        return "Compact"
+    else:
+        # Default to Comfortable if invalid value
+        return "Comfortable"
+
+
 def _validate_and_fill_config(config: MyConfig) -> bool:
     """
     Validate configuration and fill in missing values with defaults.
@@ -1234,6 +1381,7 @@ def _validate_and_fill_config(config: MyConfig) -> bool:
         ("GroupSonarr", True),
         ("GroupLidarr", True),
         ("Theme", "Dark"),
+        ("ViewDensity", "Comfortable"),
     ]
 
     for key, default in webui_defaults:
@@ -1250,6 +1398,14 @@ def _validate_and_fill_config(config: MyConfig) -> bool:
             webui_section["Theme"] = normalized_theme
             changed = True
 
+    # Normalize ViewDensity value to always be capitalized (Comfortable or Compact)
+    if "ViewDensity" in webui_section:
+        current_density = webui_section["ViewDensity"]
+        normalized_density = _normalize_view_density_value(current_density)
+        if current_density != normalized_density:
+            webui_section["ViewDensity"] = normalized_density
+            changed = True
+
     # Validate qBit section
     qbit_defaults = [
         ("Disabled", False),
@@ -1343,6 +1499,10 @@ def apply_config_migrations(config: MyConfig) -> None:
     if _migrate_process_restart_settings(config):
         changes_made = True
 
+    # NEW: Add qBit category management settings (v3 → v4)
+    if _migrate_qbit_category_settings(config):
+        changes_made = True
+
     # Validate and fill config (this also ensures ConfigVersion field exists)
     if _validate_and_fill_config(config):
         changes_made = True

qBitrr/main.py

@@ -5,6 +5,7 @@ import contextlib
 import glob
 import logging
 import os
+import signal
 import sys
 import time
 from multiprocessing import Event, freeze_support
@@ -34,6 +35,7 @@ from qBitrr.env_config import ENVIRO_CONFIG
 from qBitrr.ffprobe import FFprobeDownloader
 from qBitrr.home_path import APPDATA_FOLDER
 from qBitrr.logger import run_logs
+from qBitrr.qbit_category_manager import qBitCategoryManager
 from qBitrr.utils import ExpiringSet
 from qBitrr.versioning import fetch_latest_release
 from qBitrr.webui import WebUI
@@ -114,6 +116,9 @@ class qBitManager:
         self.qbit_versions: dict[str, VersionClass] = {}
         self.instance_metadata: dict[str, dict] = {}
         self.instance_health: dict[str, bool] = {}
+        # qBit category management
+        self.qbit_category_configs: dict[str, dict] = {}
+        self.qbit_category_managers: dict[str, qBitCategoryManager] = {}
         if not (QBIT_DISABLED or SEARCH_ONLY):
             self.client = qbittorrentapi.Client(
                 host=self.qBit_Host,
@@ -158,6 +163,9 @@ class qBitManager:
         self._process_restart_counts: dict[tuple[str, str], list[float]] = (
             {}
         )  # (category, role) -> [timestamps]
+        # Database checkpoint thread
+        self._db_checkpoint_thread: Thread | None = None
+        self._db_checkpoint_event = ThreadEvent()
         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)
@@ -411,9 +419,20 @@ class qBitManager:
             arr_manager = ArrManager(self)
             self.arr_manager = arr_manager
             arr_manager.build_arr_instances()
+
+            # Initialize qBit category managers after Arr instances (for category validation)
+            self._initialize_qbit_category_managers()
+
             run_logs(self.logger)
             for arr in arr_manager.managed_objects.values():
                 self._prepare_arr_processes(arr)
+
+            # Spawn qBit category workers after Arr workers
+            self._spawn_qbit_category_workers()
+
+            # Start periodic database checkpoint thread
+            self._start_db_checkpoint_thread()
+
             self.configure_auto_update()
             elapsed = monotonic() - started_at
             self.logger.info("Background startup completed in %.1fs", elapsed)
@@ -467,6 +486,41 @@ class qBitManager:
         # Default instance already initialized in __init__
         self.logger.info("Initialized qBit instance: default")
 
+        # Load qBit category config for default instance
+        managed_categories = CONFIG.get("qBit.ManagedCategories", fallback=[])
+        if managed_categories:
+            # Load default seeding settings
+            default_seeding = {}
+            seeding_keys = [
+                "DownloadRateLimitPerTorrent",
+                "UploadRateLimitPerTorrent",
+                "MaxUploadRatio",
+                "MaxSeedingTime",
+                "RemoveTorrent",
+            ]
+            for key in seeding_keys:
+                value = CONFIG.get(f"qBit.CategorySeeding.{key}", fallback=-1)
+                default_seeding[key] = value
+
+            # Load per-category overrides
+            category_overrides = {}
+            categories_list = CONFIG.get("qBit.CategorySeeding.Categories", fallback=[])
+            for cat_config in categories_list:
+                if isinstance(cat_config, dict) and "Name" in cat_config:
+                    cat_name = cat_config["Name"]
+                    category_overrides[cat_name] = cat_config
+
+            # Store config for later initialization
+            self.qbit_category_configs["default"] = {
+                "managed_categories": managed_categories,
+                "default_seeding": default_seeding,
+                "category_overrides": category_overrides,
+            }
+            self.logger.debug(
+                "Loaded qBit category config for 'default': %d managed categories",
+                len(managed_categories),
+            )
+
         # Scan for additional instances (qBit-XXX sections)
         for section in CONFIG.sections():
             if section.startswith("qBit-") and section != "qBit":
@@ -550,6 +604,42 @@ class qBitManager:
         }
         self.instance_health[instance_name] = True
 
+        # Load qBit category management config for this instance
+        managed_categories = CONFIG.get(f"{section_name}.ManagedCategories", fallback=[])
+        if managed_categories:
+            # Load default seeding settings
+            default_seeding = {}
+            seeding_keys = [
+                "DownloadRateLimitPerTorrent",
+                "UploadRateLimitPerTorrent",
+                "MaxUploadRatio",
+                "MaxSeedingTime",
+                "RemoveTorrent",
+            ]
+            for key in seeding_keys:
+                value = CONFIG.get(f"{section_name}.CategorySeeding.{key}", fallback=-1)
+                default_seeding[key] = value
+
+            # Load per-category overrides
+            category_overrides = {}
+            categories_list = CONFIG.get(f"{section_name}.CategorySeeding.Categories", fallback=[])
+            for cat_config in categories_list:
+                if isinstance(cat_config, dict) and "Name" in cat_config:
+                    cat_name = cat_config["Name"]
+                    category_overrides[cat_name] = cat_config
+
+            # Store config for later initialization
+            self.qbit_category_configs[instance_name] = {
+                "managed_categories": managed_categories,
+                "default_seeding": default_seeding,
+                "category_overrides": category_overrides,
+            }
+            self.logger.debug(
+                "Loaded qBit category config for '%s': %d managed categories",
+                instance_name,
+                len(managed_categories),
+            )
+
     def is_instance_alive(self, instance_name: str = "default") -> bool:
         """
         Check if a specific qBittorrent instance is alive and responding.
@@ -633,6 +723,117 @@ class qBitManager:
             return None
         return self.clients[instance_name]
 
+    def _initialize_qbit_category_managers(self) -> None:
+        """
+        Initialize qBit category managers for instances with managed categories.
+
+        Creates qBitCategoryManager instances for each qBit instance that has
+        ManagedCategories configured. Managers handle seeding settings and
+        removal logic for qBit-managed torrents.
+        """
+        if not self.qbit_category_configs:
+            self.logger.debug("No qBit category managers to initialize")
+            return
+
+        for instance_name, config in self.qbit_category_configs.items():
+            try:
+                manager = qBitCategoryManager(instance_name, self, config)
+                self.qbit_category_managers[instance_name] = manager
+                self.logger.info(
+                    "Initialized qBit category manager for instance '%s'", instance_name
+                )
+            except Exception as e:
+                self.logger.error(
+                    "Failed to initialize qBit category manager for '%s': %s",
+                    instance_name,
+                    e,
+                    exc_info=True,
+                )
+
+        self.logger.info(
+            "Total qBit category managers initialized: %d", len(self.qbit_category_managers)
+        )
+
+    def _spawn_qbit_category_workers(self) -> None:
+        """
+        Spawn worker processes for qBit category managers.
+
+        Creates a worker process for each qBit category manager to handle
+        continuous processing of managed torrents (applying seeding settings,
+        checking removal conditions).
+        """
+        if not self.qbit_category_managers:
+            self.logger.debug("No qBit category workers to spawn")
+            return
+
+        for instance_name, manager in self.qbit_category_managers.items():
+            try:
+                process = pathos.helpers.mp.Process(
+                    target=manager.run_processing_loop,
+                    name=f"qBitCategory-{instance_name}",
+                )
+                process.start()
+                self.child_processes.append(process)
+                self._process_registry[process] = {
+                    "category": f"qbit-{instance_name}",
+                    "role": "category_manager",
+                    "instance": instance_name,
+                }
+                self.logger.info(
+                    "Spawned qBit category worker for instance '%s' (PID: %d)",
+                    instance_name,
+                    process.pid,
+                )
+            except Exception as e:
+                self.logger.error(
+                    "Failed to spawn qBit category worker for '%s': %s",
+                    instance_name,
+                    e,
+                    exc_info=True,
+                )
+
+        self.logger.info(
+            "Total qBit category workers spawned: %d", len(self.qbit_category_managers)
+        )
+
+    def _periodic_db_checkpoint(self) -> None:
+        """
+        Background thread that periodically checkpoints the database WAL.
+
+        This runs every 5 minutes during normal operation to ensure WAL entries
+        are regularly flushed to the main database file, minimizing data loss
+        risk in case of sudden crashes or power loss.
+        """
+        from qBitrr.database import checkpoint_database
+
+        self.logger.info("Starting periodic database checkpoint thread (interval: 5 minutes)")
+
+        while not self.shutdown_event.is_set():
+            # Wait 5 minutes or until shutdown
+            if self._db_checkpoint_event.wait(timeout=300):  # 300 seconds = 5 minutes
+                break  # Shutdown requested
+
+            if self.shutdown_event.is_set():
+                break
+
+            try:
+                checkpoint_database()
+            except Exception as e:
+                self.logger.error("Periodic database checkpoint failed: %s", e)
+
+        self.logger.info("Periodic database checkpoint thread stopped")
+
+    def _start_db_checkpoint_thread(self) -> None:
+        """Start the periodic database checkpoint background thread."""
+        if self._db_checkpoint_thread is None or not self._db_checkpoint_thread.is_alive():
+            self._db_checkpoint_thread = Thread(
+                target=self._periodic_db_checkpoint,
+                name="DBCheckpoint",
+                daemon=True,
+            )
+            self._db_checkpoint_thread.start()
+            self.logger.info("Started periodic database checkpoint thread")
+
     # @response_text(str)
     # @login_required
     def app_version(self, instance_name: str = "default", **kwargs):
@@ -1187,11 +1388,28 @@ def run():
     # Early consolidated config validation feedback
     _report_config_issues()
     logger.debug("Environment variables: %r", ENVIRO_CONFIG)
+
+    # Flag to track if shutdown has been initiated
+    shutdown_initiated = False
+
     try:
         manager.get_child_processes()
 
         # Register cleanup for child processes when the main process exits
         def _cleanup():
+            nonlocal shutdown_initiated
+            if shutdown_initiated:
+                return  # Already cleaned up
+            shutdown_initiated = True
+
+            # Checkpoint database WAL before shutdown
+            try:
+                from qBitrr.database import checkpoint_database
+
+                checkpoint_database()
+            except Exception as e:
+                logger.error("Failed to checkpoint database on shutdown: %s", e)
+
             # Signal loops to shutdown gracefully
             try:
                 manager.shutdown_event.set()
@@ -1207,6 +1425,15 @@ def run():
                 with contextlib.suppress(Exception):
                     p.terminate()
 
+        # Register signal handlers for graceful shutdown
+        def _signal_handler(signum, frame):
+            logger.info("Received signal %s - initiating graceful shutdown", signum)
+            _cleanup()
+            sys.exit(0)
+
+        signal.signal(signal.SIGTERM, _signal_handler)
+        signal.signal(signal.SIGINT, _signal_handler)
+
         atexit.register(_cleanup)
         if manager.child_processes:
             manager.run()
@@ -1216,9 +1443,11 @@ def run():
             )
     except KeyboardInterrupt:
         logger.info("Detected Ctrl+C - Terminating process")
+        _cleanup()
         sys.exit(0)
     except Exception:
         logger.info("Attempting to terminate child processes, please wait a moment.")
+        _cleanup()
         for child in manager.child_processes:
             child.kill()