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

qBitrr/bundled_data.py

@@ -1,5 +1,5 @@
-version = "5.7.0"
-git_hash = "f7e3e092"
+version = "5.7.1"
+git_hash = "a8446ba3"
 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/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

@@ -86,6 +86,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 +152,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 +699,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 +715,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 +904,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