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

qBitrr/arss.py

@@ -20,7 +20,7 @@ import qbittorrentapi
 import qbittorrentapi.exceptions
 import requests
 from packaging import version as version_parser
-from peewee import Model, SqliteDatabase
+from peewee import DatabaseError, Model, OperationalError, SqliteDatabase
 from pyarr import LidarrAPI, RadarrAPI, SonarrAPI
 from pyarr.exceptions import PyarrResourceNotFound, PyarrServerError
 from pyarr.types import JsonObject
@@ -147,36 +147,36 @@ class Arr:
         self.logger = logging.getLogger(f"qBitrr.{self._name}")
         run_logs(self.logger, self._name)
 
+        # Set completed_folder path (used for category creation and file monitoring)
         if not QBIT_DISABLED:
             try:
+                # Check default instance for existing category configuration
                 categories = self.manager.qbit_manager.client.torrent_categories.categories
-                try:
-                    categ = categories[self.category]
-                    path = categ["savePath"]
-                    if path:
-                        self.logger.trace("Category exists with save path [%s]", path)
-                        self.completed_folder = pathlib.Path(path)
-                    else:
-                        self.logger.trace("Category exists without save path")
-                        self.completed_folder = pathlib.Path(COMPLETED_DOWNLOAD_FOLDER).joinpath(
-                            self.category
-                        )
-                except KeyError:
+                categ = categories.get(self.category)
+                if categ and categ.get("savePath"):
+                    self.logger.trace("Category exists with save path [%s]", categ["savePath"])
+                    self.completed_folder = pathlib.Path(categ["savePath"])
+                else:
+                    self.logger.trace("Category does not exist or lacks save path")
                     self.completed_folder = pathlib.Path(COMPLETED_DOWNLOAD_FOLDER).joinpath(
                         self.category
                     )
-                    self.manager.qbit_manager.client.torrent_categories.create_category(
-                        self.category, save_path=self.completed_folder
-                    )
             except Exception as e:
                 self.logger.warning(
-                    "Could not connect to qBittorrent during initialization for %s: %s. Will retry when process starts.",
+                    "Could not connect to qBittorrent during initialization for %s: %s. Using default path.",
                     self._name,
-                    str(e).split("\n")[0] if "\n" in str(e) else str(e),  # First line only
+                    str(e).split("\n")[0] if "\n" in str(e) else str(e),
                 )
                 self.completed_folder = pathlib.Path(COMPLETED_DOWNLOAD_FOLDER).joinpath(
                     self.category
                 )
+            # Ensure category exists on ALL instances (deferred to avoid __init__ failures)
+            try:
+                self._ensure_category_on_all_instances()
+            except Exception as e:
+                self.logger.warning(
+                    "Could not ensure category on all instances during init: %s", e
+                )
         else:
             self.completed_folder = pathlib.Path(COMPLETED_DOWNLOAD_FOLDER).joinpath(self.category)
 
@@ -673,6 +673,57 @@ class Arr:
         )
         self.logger.hnotice("Starting %s monitor", self._name)
 
+    def _ensure_category_on_all_instances(self) -> None:
+        """
+        Ensure the Arr category exists on ALL qBittorrent instances.
+
+        Creates the category with the completed_folder save path on each instance.
+        Logs errors but continues if individual instances fail.
+        """
+        if QBIT_DISABLED:
+            return
+
+        qbit_manager = self.manager.qbit_manager
+        all_instances = qbit_manager.get_all_instances()
+
+        self.logger.debug(
+            "Ensuring category '%s' exists on %d qBit instance(s)",
+            self.category,
+            len(all_instances),
+        )
+
+        for instance_name in all_instances:
+            try:
+                client = qbit_manager.get_client(instance_name)
+                if client is None:
+                    self.logger.warning(
+                        "Skipping category creation on instance '%s' (client unavailable)",
+                        instance_name,
+                    )
+                    continue
+
+                categories = client.torrent_categories.categories
+                if self.category not in categories:
+                    client.torrent_categories.create_category(
+                        self.category, save_path=str(self.completed_folder)
+                    )
+                    self.logger.info(
+                        "Created category '%s' on instance '%s'", self.category, instance_name
+                    )
+                else:
+                    self.logger.debug(
+                        "Category '%s' already exists on instance '%s'",
+                        self.category,
+                        instance_name,
+                    )
+            except Exception as e:
+                self.logger.error(
+                    "Failed to ensure category '%s' on instance '%s': %s",
+                    self.category,
+                    instance_name,
+                    str(e).split("\n")[0] if "\n" in str(e) else str(e),
+                )
+
     @staticmethod
     def _humanize_request_tag(tag: str) -> str | None:
         if not tag:
@@ -785,7 +836,9 @@ class Arr:
         """Returns True if the State is categorized as Downloading."""
         return torrent.state_enum in (TorrentStates.DOWNLOADING, TorrentStates.PAUSED_DOWNLOAD)
 
-    def in_tags(self, torrent: TorrentDictionary, tag: str) -> bool:
+    def in_tags(
+        self, torrent: TorrentDictionary, tag: str, instance_name: str = "default"
+    ) -> bool:
         return_value = False
         if TAGLESS:
             if tag == "qBitrr-ignored":
@@ -796,15 +849,20 @@ class Arr:
                     .where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     )
                     .execute()
                 )
                 if not query:
                     self.torrents.insert(
-                        Hash=torrent.hash, Category=torrent.category
+                        Hash=torrent.hash,
+                        Category=torrent.category,
+                        QbitInstance=instance_name,
                     ).on_conflict_ignore().execute()
-                condition = (self.torrents.Hash == torrent.hash) & (
-                    self.torrents.Category == torrent.category
+                condition = (
+                    (self.torrents.Hash == torrent.hash)
+                    & (self.torrents.Category == torrent.category)
+                    & (self.torrents.QbitInstance == instance_name)
                 )
                 if tag == "qBitrr-allowed_seeding":
                     condition &= self.torrents.AllowedSeeding == True
@@ -832,7 +890,9 @@ class Arr:
             self.logger.trace("Tag %s not in %s", tag, torrent.name)
             return False
 
-    def remove_tags(self, torrent: TorrentDictionary, tags: list) -> None:
+    def remove_tags(
+        self, torrent: TorrentDictionary, tags: list, instance_name: str = "default"
+    ) -> None:
         for tag in tags:
             self.logger.trace("Removing tag %s from %s", tag, torrent.name)
         if TAGLESS:
@@ -842,32 +902,39 @@ class Arr:
                     .where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     )
                     .execute()
                 )
                 if not query:
                     self.torrents.insert(
-                        Hash=torrent.hash, Category=torrent.category
+                        Hash=torrent.hash,
+                        Category=torrent.category,
+                        QbitInstance=instance_name,
                     ).on_conflict_ignore().execute()
                 if tag == "qBitrr-allowed_seeding":
                     self.torrents.update(AllowedSeeding=False).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-imported":
                     self.torrents.update(Imported=False).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-allowed_stalled":
                     self.torrents.update(AllowedStalled=False).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-free_space_paused":
                     self.torrents.update(FreeSpacePaused=False).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
         else:
             with contextlib.suppress(Exception):
@@ -883,7 +950,9 @@ class Arr:
                     ),
                 )
 
-    def add_tags(self, torrent: TorrentDictionary, tags: list) -> None:
+    def add_tags(
+        self, torrent: TorrentDictionary, tags: list, instance_name: str = "default"
+    ) -> None:
         for tag in tags:
             self.logger.trace("Adding tag %s from %s", tag, torrent.name)
         if TAGLESS:
@@ -893,32 +962,39 @@ class Arr:
                     .where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     )
                     .execute()
                 )
                 if not query:
                     self.torrents.insert(
-                        Hash=torrent.hash, Category=torrent.category
+                        Hash=torrent.hash,
+                        Category=torrent.category,
+                        QbitInstance=instance_name,
                     ).on_conflict_ignore().execute()
                 if tag == "qBitrr-allowed_seeding":
                     self.torrents.update(AllowedSeeding=True).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-imported":
                     self.torrents.update(Imported=True).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-allowed_stalled":
                     self.torrents.update(AllowedStalled=True).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
                 elif tag == "qBitrr-free_space_paused":
                     self.torrents.update(FreeSpacePaused=True).where(
                         (self.torrents.Hash == torrent.hash)
                         & (self.torrents.Category == torrent.category)
+                        & (self.torrents.QbitInstance == instance_name)
                     ).execute()
         else:
             with contextlib.suppress(Exception):
@@ -1159,7 +1235,7 @@ class Arr:
     def _process_imports(self) -> None:
         if self.import_torrents:
             self.needs_cleanup = True
-            for torrent in self.import_torrents:
+            for torrent, instance_name in self.import_torrents:
                 if torrent.hash in self.sent_to_scan:
                     continue
                 path = validate_and_return_torrent_file(torrent.content_path)
@@ -1245,7 +1321,7 @@ class Arr:
                         self.import_mode,
                         ex,
                     )
-                self.add_tags(torrent, ["qBitrr-imported"])
+                self.add_tags(torrent, ["qBitrr-imported"], instance_name)
                 self.sent_to_scan.add(path)
             self.import_torrents.clear()
 
@@ -4448,33 +4524,96 @@ class Arr:
 
         return payload
 
+    def _get_torrents_from_all_instances(
+        self,
+    ) -> list[tuple[str, qbittorrentapi.TorrentDictionary]]:
+        """
+        Get torrents from ALL qBittorrent instances for this Arr's category.
+
+        Returns:
+            list[tuple[str, TorrentDictionary]]: List of (instance_name, torrent) tuples
+        """
+        all_torrents = []
+        qbit_manager = self.manager.qbit_manager
+
+        for instance_name in qbit_manager.get_all_instances():
+            if not qbit_manager.is_instance_alive(instance_name):
+                self.logger.debug(
+                    "Skipping unhealthy instance '%s' during torrent scan", instance_name
+                )
+                continue
+
+            client = qbit_manager.get_client(instance_name)
+            if client is None:
+                continue
+
+            try:
+                torrents = client.torrents.info(
+                    status_filter="all",
+                    category=self.category,
+                    sort="added_on",
+                    reverse=False,
+                )
+                # Tag each torrent with its instance name
+                for torrent in torrents:
+                    if hasattr(torrent, "category"):
+                        all_torrents.append((instance_name, torrent))
+
+                self.logger.trace(
+                    "Retrieved %d torrents from instance '%s' for category '%s'",
+                    len(torrents),
+                    instance_name,
+                    self.category,
+                )
+            except (qbittorrentapi.exceptions.APIError, JSONDecodeError) as e:
+                self.logger.warning(
+                    "Failed to get torrents from instance '%s': %s", instance_name, e
+                )
+                continue
+
+        self.logger.debug(
+            "Total torrents across %d instances: %d",
+            len(qbit_manager.get_all_instances()),
+            len(all_torrents),
+        )
+        return all_torrents
+
     def process_torrents(self):
         try:
             try:
                 while True:
                     try:
-                        torrents = self.manager.qbit_manager.client.torrents.info(
-                            status_filter="all",
-                            category=self.category,
-                            sort="added_on",
-                            reverse=False,
-                        )
+                        # Multi-instance: Scan all qBit instances for category-matching torrents
+                        torrents_with_instances = self._get_torrents_from_all_instances()
                         break
                     except (qbittorrentapi.exceptions.APIError, JSONDecodeError) as e:
                         if "JSONDecodeError" in str(e):
                             continue
                         else:
                             raise qbittorrentapi.exceptions.APIError
-                torrents = [t for t in torrents if hasattr(t, "category")]
-                self.category_torrent_count = len(torrents)
-                if not len(torrents):
+
+                # Filter torrents that have category attribute
+                torrents_with_instances = [
+                    (instance, t)
+                    for instance, t in torrents_with_instances
+                    if hasattr(t, "category")
+                ]
+                self.category_torrent_count = len(torrents_with_instances)
+                if not len(torrents_with_instances):
                     raise DelayLoopException(length=LOOP_SLEEP_TIMER, type="no_downloads")
+
+                # Internet check: Use default instance for backward compatibility
                 if not has_internet(self.manager.qbit_manager.client):
                     self.manager.qbit_manager.should_delay_torrent_scan = True
                     raise DelayLoopException(length=NO_INTERNET_SLEEP_TIMER, type="internet")
                 if self.manager.qbit_manager.should_delay_torrent_scan:
                     raise DelayLoopException(length=NO_INTERNET_SLEEP_TIMER, type="delay")
 
+                # Initialize database error tracking for exponential backoff
+                if not hasattr(self, "_db_error_count"):
+                    self._db_error_count = 0
+                    self._db_last_error_time = 0
+
                 # Periodic database health check (every 10th iteration)
                 if not hasattr(self, "_health_check_counter"):
                     self._health_check_counter = 0
@@ -4502,9 +4641,10 @@ class Arr:
 
                 self.api_calls()
                 self.refresh_download_queue()
-                for torrent in torrents:
+                # Multi-instance: Process torrents from all instances
+                for instance_name, torrent in torrents_with_instances:
                     with contextlib.suppress(qbittorrentapi.NotFound404Error):
-                        self._process_single_torrent(torrent)
+                        self._process_single_torrent(torrent, instance_name=instance_name)
                 self.process()
             except NoConnectionrException as e:
                 self.logger.error(e.message)
@@ -4516,6 +4656,76 @@ class Arr:
                 self.logger.error("The qBittorrent API returned an unexpected error")
                 self.logger.debug("Unexpected APIError from qBitTorrent")  # , exc_info=e)
                 raise DelayLoopException(length=300, type="qbit")
+            except (OperationalError, DatabaseError) as e:
+                # Database errors after retry exhaustion - implement automatic recovery with backoff
+                error_msg = str(e).lower()
+                current_time = time.time()
+
+                # Track consecutive database errors for exponential backoff
+                if (
+                    current_time - self._db_last_error_time > 300
+                ):  # Reset if >5min since last error
+                    self._db_error_count = 0
+                self._db_error_count += 1
+                self._db_last_error_time = current_time
+
+                # Calculate exponential backoff: 2min, 5min, 10min, 20min, 30min (max)
+                delay_seconds = min(120 * (2 ** (self._db_error_count - 1)), 1800)
+
+                # Log detailed error information based on error type
+                if "disk i/o error" in error_msg:
+                    self.logger.critical(
+                        "Persistent database I/O error detected (consecutive error #%d). "
+                        "This indicates disk issues, filesystem corruption, or resource exhaustion. "
+                        "Attempting automatic recovery and retrying in %d seconds...",
+                        self._db_error_count,
+                        delay_seconds,
+                    )
+                elif "database is locked" in error_msg:
+                    self.logger.error(
+                        "Database locked error (consecutive error #%d). "
+                        "Retrying in %d seconds...",
+                        self._db_error_count,
+                        delay_seconds,
+                    )
+                elif "disk image is malformed" in error_msg:
+                    self.logger.critical(
+                        "Database corruption detected (consecutive error #%d). "
+                        "Attempting automatic recovery and retrying in %d seconds...",
+                        self._db_error_count,
+                        delay_seconds,
+                    )
+                else:
+                    self.logger.error(
+                        "Database error (consecutive error #%d): %s. " "Retrying in %d seconds...",
+                        self._db_error_count,
+                        error_msg,
+                        delay_seconds,
+                    )
+
+                # Attempt automatic recovery for critical errors
+                if "disk i/o error" in error_msg or "disk image is malformed" in error_msg:
+                    try:
+                        self.logger.warning(
+                            "Attempting enhanced database recovery (WAL checkpoint, repair, and verification)..."
+                        )
+                        self._enhanced_database_recovery()
+                        self.logger.info(
+                            "Database recovery completed successfully - will retry operation after delay"
+                        )
+                        # Reduce error count on successful recovery (but don't reset completely)
+                        self._db_error_count = max(0, self._db_error_count - 1)
+                    except Exception as recovery_error:
+                        self.logger.critical(
+                            "Automatic database recovery failed: %s. "
+                            "MANUAL INTERVENTION REQUIRED: Check disk health (smartctl), "
+                            "filesystem integrity (fsck), available space (df -h), "
+                            "Docker volume mounts, permissions, and system logs (dmesg).",
+                            recovery_error,
+                        )
+
+                # Delay processing to avoid hammering failing database
+                raise DelayLoopException(length=delay_seconds, type="database")
             except DelayLoopException:
                 raise
             except KeyboardInterrupt:
@@ -4566,6 +4776,83 @@ class Arr:
             "Manual intervention may be required. Continuing with caution..."
         )
 
+    def _enhanced_database_recovery(self):
+        """
+        Enhanced automatic database recovery with additional filesystem checks.
+
+        This method is called when disk I/O errors persist after retry logic has been exhausted.
+        It implements a comprehensive recovery strategy:
+        1. Try WAL checkpoint (least invasive)
+        2. Try VACUUM to reclaim space and fix minor corruption
+        3. Try full database repair (dump/restore) if needed
+        4. Verify database integrity after recovery
+        """
+        from qBitrr.db_recovery import (
+            DatabaseRecoveryError,
+            checkpoint_wal,
+            repair_database,
+            vacuum_database,
+        )
+        from qBitrr.home_path import APPDATA_FOLDER
+
+        db_path = APPDATA_FOLDER / "qbitrr.db"
+
+        self.logger.info("Starting enhanced database recovery procedure...")
+
+        # Step 1: Try WAL checkpoint
+        self.logger.info("Step 1/3: Attempting WAL checkpoint...")
+        if checkpoint_wal(db_path, self.logger):
+            self.logger.info("WAL checkpoint successful")
+            # Try a quick health check
+            from qBitrr.db_lock import check_database_health
+
+            healthy, msg = check_database_health(db_path, self.logger)
+            if healthy:
+                self.logger.info("Database health verified - recovery complete")
+                return
+            else:
+                self.logger.warning(
+                    "WAL checkpoint completed but database still unhealthy: %s", msg
+                )
+
+        # Step 2: Try VACUUM (only if WAL didn't fully fix it)
+        self.logger.info("Step 2/3: Attempting VACUUM to reclaim space and fix minor issues...")
+        if vacuum_database(db_path, self.logger):
+            self.logger.info("VACUUM completed successfully")
+            from qBitrr.db_lock import check_database_health
+
+            healthy, msg = check_database_health(db_path, self.logger)
+            if healthy:
+                self.logger.info("Database health verified after VACUUM - recovery complete")
+                return
+            else:
+                self.logger.warning("VACUUM completed but database still unhealthy: %s", msg)
+
+        # Step 3: Try full repair (most invasive)
+        self.logger.warning("Step 3/3: Attempting full database repair (dump/restore)...")
+        try:
+            if repair_database(db_path, backup=True, logger_override=self.logger):
+                self.logger.info("Database repair successful")
+                # Final health check
+                from qBitrr.db_lock import check_database_health
+
+                healthy, msg = check_database_health(db_path, self.logger)
+                if healthy:
+                    self.logger.info("Database health verified after repair - recovery complete")
+                    return
+                else:
+                    self.logger.error("Repair completed but database still unhealthy: %s", msg)
+                    raise DatabaseRecoveryError(f"Database unhealthy after repair: {msg}")
+        except DatabaseRecoveryError as e:
+            self.logger.error("Database repair failed: %s", e)
+            raise
+        except Exception as e:
+            self.logger.error("Unexpected error during database repair: %s", e)
+            raise
+
+        # If we reach here, all recovery methods failed
+        raise DatabaseRecoveryError("All automatic recovery methods failed")
+
     def _process_single_torrent_failed_cat(self, torrent: qbittorrentapi.TorrentDictionary):
         self.logger.notice(
             "Deleting manually failed torrent: "
@@ -4825,7 +5112,10 @@ class Arr:
         self.recheck.add(torrent.hash)
 
     def _process_single_torrent_fully_completed_torrent(
-        self, torrent: qbittorrentapi.TorrentDictionary, leave_alone: bool
+        self,
+        torrent: qbittorrentapi.TorrentDictionary,
+        leave_alone: bool,
+        instance_name: str = "default",
     ):
         if leave_alone or torrent.state_enum == TorrentStates.FORCED_UPLOAD:
             self.logger.trace(
@@ -4843,7 +5133,7 @@ class Arr:
                 torrent.name,
                 torrent.hash,
             )
-        elif not self.in_tags(torrent, "qBitrr-imported"):
+        elif not self.in_tags(torrent, "qBitrr-imported", instance_name):
             self.logger.info(
                 "Importing Completed torrent: "
                 "[Progress: %s%%][Added On: %s]"
@@ -4868,7 +5158,7 @@ class Arr:
                 else:
                     torrent_folder = content_path
             self.files_to_cleanup.add((torrent.hash, torrent_folder))
-            self.import_torrents.append(torrent)
+            self.import_torrents.append((torrent, instance_name))
 
     def _process_single_torrent_missing_files(self, torrent: qbittorrentapi.TorrentDictionary):
         # Sometimes Sonarr/Radarr does not automatically remove the
@@ -5236,7 +5526,7 @@ class Arr:
         return data_settings, data_torrent
 
     def _should_leave_alone(
-        self, torrent: qbittorrentapi.TorrentDictionary
+        self, torrent: qbittorrentapi.TorrentDictionary, instance_name: str = "default"
     ) -> tuple[bool, int, bool]:
         return_value = True
         remove_torrent = False
@@ -5262,18 +5552,18 @@ class Arr:
         return_value = not self.torrent_limit_check(torrent, seeding_time_limit, ratio_limit)
         if data_settings.get("super_seeding", False) or data_torrent.get("super_seeding", False):
             return_value = True
-        if self.in_tags(torrent, "qBitrr-free_space_paused"):
+        if self.in_tags(torrent, "qBitrr-free_space_paused", instance_name):
             return_value = True
         if (
             return_value
-            and not self.in_tags(torrent, "qBitrr-allowed_seeding")
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
+            and not self.in_tags(torrent, "qBitrr-allowed_seeding", instance_name)
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
         ):
-            self.add_tags(torrent, ["qBitrr-allowed_seeding"])
+            self.add_tags(torrent, ["qBitrr-allowed_seeding"], instance_name)
         elif (
-            not return_value and self.in_tags(torrent, "qBitrr-allowed_seeding")
-        ) or self.in_tags(torrent, "qBitrr-free_space_paused"):
-            self.remove_tags(torrent, ["qBitrr-allowed_seeding"])
+            not return_value and self.in_tags(torrent, "qBitrr-allowed_seeding", instance_name)
+        ) or self.in_tags(torrent, "qBitrr-free_space_paused", instance_name):
+            self.remove_tags(torrent, ["qBitrr-allowed_seeding"], instance_name)
 
         self.logger.trace("Config Settings returned [%s]: %r", torrent.name, data_settings)
         return (
@@ -5439,9 +5729,14 @@ class Arr:
             current_tags = set(torrent.tags.split(", "))
             add_tags = unique_tags.difference(current_tags)
             if add_tags:
-                self.add_tags(torrent, add_tags)
+                self.add_tags(torrent, add_tags, instance_name)
 
-    def _stalled_check(self, torrent: qbittorrentapi.TorrentDictionary, time_now: float) -> bool:
+    def _stalled_check(
+        self,
+        torrent: qbittorrentapi.TorrentDictionary,
+        time_now: float,
+        instance_name: str = "default",
+    ) -> bool:
         stalled_ignore = True
         if not self.allowed_stalled:
             self.logger.trace("Stalled check: Stalled delay disabled")
@@ -5478,15 +5773,15 @@ class Arr:
             (
                 torrent.state_enum
                 in (TorrentStates.METADATA_DOWNLOAD, TorrentStates.STALLED_DOWNLOAD)
-                and not self.in_tags(torrent, "qBitrr-ignored")
-                and not self.in_tags(torrent, "qBitrr-free_space_paused")
+                and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+                and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
             )
             or (
                 torrent.availability < 1
                 and torrent.hash in self.cleaned_torrents
                 and torrent.state_enum in (TorrentStates.DOWNLOADING)
-                and not self.in_tags(torrent, "qBitrr-ignored")
-                and not self.in_tags(torrent, "qBitrr-free_space_paused")
+                and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+                and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
             )
         ) and self.allowed_stalled:
             if (
@@ -5496,8 +5791,8 @@ class Arr:
             ):
                 stalled_ignore = False
                 self.logger.trace("Process stalled, delay expired: %s", torrent.name)
-            elif not self.in_tags(torrent, "qBitrr-allowed_stalled"):
-                self.add_tags(torrent, ["qBitrr-allowed_stalled"])
+            elif not self.in_tags(torrent, "qBitrr-allowed_stalled", instance_name):
+                self.add_tags(torrent, ["qBitrr-allowed_stalled"], instance_name)
                 if self.re_search_stalled:
                     self.logger.trace(
                         "Stalled, adding tag, blocklosting and re-searching: %s", torrent.name
@@ -5514,7 +5809,7 @@ class Arr:
                             )
                 else:
                     self.logger.trace("Stalled, adding tag: %s", torrent.name)
-            elif self.in_tags(torrent, "qBitrr-allowed_stalled"):
+            elif self.in_tags(torrent, "qBitrr-allowed_stalled", instance_name):
                 self.logger.trace(
                     "Stalled: %s [Current:%s][Last Activity:%s][Limit:%s]",
                     torrent.name,
@@ -5525,8 +5820,8 @@ class Arr:
                     ),
                 )
 
-        elif self.in_tags(torrent, "qBitrr-allowed_stalled"):
-            self.remove_tags(torrent, ["qBitrr-allowed_stalled"])
+        elif self.in_tags(torrent, "qBitrr-allowed_stalled", instance_name):
+            self.remove_tags(torrent, ["qBitrr-allowed_stalled"], instance_name)
             stalled_ignore = False
             self.logger.trace("Not stalled, removing tag: %s", torrent.name)
         else:
@@ -5534,13 +5829,17 @@ class Arr:
             self.logger.trace("Not stalled: %s", torrent.name)
         return stalled_ignore
 
-    def _process_single_torrent(self, torrent: qbittorrentapi.TorrentDictionary):
+    def _process_single_torrent(
+        self, torrent: qbittorrentapi.TorrentDictionary, instance_name: str = "default"
+    ):
         if torrent.category != RECHECK_CATEGORY:
             self.manager.qbit_manager.cache[torrent.hash] = torrent.category
         self._process_single_torrent_trackers(torrent)
         self.manager.qbit_manager.name_cache[torrent.hash] = torrent.name
         time_now = time.time()
-        leave_alone, _tracker_max_eta, remove_torrent = self._should_leave_alone(torrent)
+        leave_alone, _tracker_max_eta, remove_torrent = self._should_leave_alone(
+            torrent, instance_name
+        )
         self.logger.trace(
             "Torrent [%s]: Leave Alone (allow seeding): %s, Max ETA: %s, State[%s]",
             torrent.name,
@@ -5555,20 +5854,22 @@ class Arr:
             TorrentStates.STALLED_DOWNLOAD,
             TorrentStates.DOWNLOADING,
         ):
-            stalled_ignore = self._stalled_check(torrent, time_now)
+            stalled_ignore = self._stalled_check(torrent, time_now, instance_name)
         else:
             stalled_ignore = False
 
-        if self.in_tags(torrent, "qBitrr-ignored"):
-            self.remove_tags(torrent, ["qBitrr-allowed_seeding", "qBitrr-free_space_paused"])
+        if self.in_tags(torrent, "qBitrr-ignored", instance_name):
+            self.remove_tags(
+                torrent, ["qBitrr-allowed_seeding", "qBitrr-free_space_paused"], instance_name
+            )
 
         if (
             self.custom_format_unmet_search
             and self.custom_format_unmet_check(torrent)
-            and not self.in_tags(torrent, "qBitrr-ignored")
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
+            and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
         ):
-            self._process_single_torrent_delete_cfunmet(torrent)
+            self._process_single_torrent_delete_cfunmet(torrent, instance_name)
         elif remove_torrent and not leave_alone and torrent.amount_left == 0:
             self._process_single_torrent_delete_ratio_seed(torrent)
         elif torrent.category == FAILED_CATEGORY:
@@ -5581,8 +5882,8 @@ class Arr:
             self._process_single_torrent_ignored(torrent)
         elif (
             torrent.state_enum in (TorrentStates.METADATA_DOWNLOAD, TorrentStates.STALLED_DOWNLOAD)
-            and not self.in_tags(torrent, "qBitrr-ignored")
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
+            and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
             and not stalled_ignore
         ):
             self._process_single_torrent_stalled_torrent(torrent, "Stalled State")
@@ -5603,15 +5904,15 @@ class Arr:
         elif (
             torrent.state_enum == TorrentStates.PAUSED_DOWNLOAD
             and torrent.amount_left != 0
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
-            and not self.in_tags(torrent, "qBitrr-ignored")
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
+            and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
         ):
             self._process_single_torrent_paused(torrent)
         elif (
             torrent.progress <= self.maximum_deletable_percentage
             and not self.is_complete_state(torrent)
-            and not self.in_tags(torrent, "qBitrr-ignored")
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
+            and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
             and not stalled_ignore
         ) and torrent.hash in self.cleaned_torrents:
             self._process_single_torrent_percentage_threshold(torrent, maximum_eta)
@@ -5658,8 +5959,8 @@ class Arr:
             and time_now > torrent.added_on + self.ignore_torrents_younger_than
             and 0 < maximum_eta < torrent.eta
             and not self.do_not_remove_slow
-            and not self.in_tags(torrent, "qBitrr-ignored")
-            and not self.in_tags(torrent, "qBitrr-free_space_paused")
+            and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+            and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
             and not stalled_ignore
         ):
             self._process_single_torrent_delete_slow(torrent)
@@ -5674,8 +5975,8 @@ class Arr:
                 )
                 and torrent.hash in self.cleaned_torrents
                 and self.is_downloading_state(torrent)
-                and not self.in_tags(torrent, "qBitrr-ignored")
-                and not self.in_tags(torrent, "qBitrr-free_space_paused")
+                and not self.in_tags(torrent, "qBitrr-ignored", instance_name)
+                and not self.in_tags(torrent, "qBitrr-free_space_paused", instance_name)
                 and not stalled_ignore
             ):
                 self._process_single_torrent_stalled_torrent(torrent, "Unavailable")
@@ -6898,7 +7199,7 @@ class FreeSpaceManager(Arr):
         )
         self.pause.add(torrent.hash)
 
-    def _process_single_torrent(self, torrent):
+    def _process_single_torrent(self, torrent, instance_name: str = "default"):
         if self.is_downloading_state(torrent):
             free_space_test = self.current_free_space
             free_space_test -= torrent["amount_left"]
@@ -6917,8 +7218,8 @@ class FreeSpaceManager(Arr):
                     format_bytes(torrent.amount_left),
                     format_bytes(-free_space_test),
                 )
-                self.add_tags(torrent, ["qBitrr-free_space_paused"])
-                self.remove_tags(torrent, ["qBitrr-allowed_seeding"])
+                self.add_tags(torrent, ["qBitrr-free_space_paused"], instance_name)
+                self.remove_tags(torrent, ["qBitrr-allowed_seeding"], instance_name)
                 self._process_single_torrent_pause_disk_space(torrent)
             elif torrent.state_enum == TorrentStates.PAUSED_DOWNLOAD and free_space_test < 0:
                 self.logger.info(
@@ -6928,8 +7229,8 @@ class FreeSpaceManager(Arr):
                     format_bytes(torrent.amount_left),
                     format_bytes(-free_space_test),
                 )
-                self.add_tags(torrent, ["qBitrr-free_space_paused"])
-                self.remove_tags(torrent, ["qBitrr-allowed_seeding"])
+                self.add_tags(torrent, ["qBitrr-free_space_paused"], instance_name)
+                self.remove_tags(torrent, ["qBitrr-allowed_seeding"], instance_name)
             elif torrent.state_enum != TorrentStates.PAUSED_DOWNLOAD and free_space_test > 0:
                 self.logger.info(
                     "Continuing download (sufficient space) | Torrent: %s | Available: %s | Space after: %s",
@@ -6938,7 +7239,7 @@ class FreeSpaceManager(Arr):
                     format_bytes(free_space_test + self._min_free_space_bytes),
                 )
                 self.current_free_space = free_space_test
-                self.remove_tags(torrent, ["qBitrr-free_space_paused"])
+                self.remove_tags(torrent, ["qBitrr-free_space_paused"], instance_name)
             elif torrent.state_enum == TorrentStates.PAUSED_DOWNLOAD and free_space_test > 0:
                 self.logger.info(
                     "Resuming download (space available) | Torrent: %s | Available: %s | Space after: %s",
@@ -6947,16 +7248,16 @@ class FreeSpaceManager(Arr):
                     format_bytes(free_space_test + self._min_free_space_bytes),
                 )
                 self.current_free_space = free_space_test
-                self.remove_tags(torrent, ["qBitrr-free_space_paused"])
+                self.remove_tags(torrent, ["qBitrr-free_space_paused"], instance_name)
         elif not self.is_downloading_state(torrent) and self.in_tags(
-            torrent, "qBitrr-free_space_paused"
+            torrent, "qBitrr-free_space_paused", instance_name
         ):
             self.logger.info(
                 "Torrent completed, removing free space tag | Torrent: %s | Available: %s",
                 torrent.name,
                 format_bytes(self.current_free_space + self._min_free_space_bytes),
             )
-            self.remove_tags(torrent, ["qBitrr-free_space_paused"])
+            self.remove_tags(torrent, ["qBitrr-free_space_paused"], instance_name)
 
     def process(self):
         self._process_paused()
@@ -6986,7 +7287,7 @@ class FreeSpaceManager(Arr):
                 torrents = [t for t in torrents if "qBitrr-ignored" not in t.tags]
                 self.category_torrent_count = len(torrents)
                 self.free_space_tagged_count = sum(
-                    1 for t in torrents if self.in_tags(t, "qBitrr-free_space_paused")
+                    1 for t in torrents if self.in_tags(t, "qBitrr-free_space_paused", "default")
                 )
                 if not len(torrents):
                     raise DelayLoopException(length=LOOP_SLEEP_TIMER, type="no_downloads")