qBitrr2 5.3.2__py3-none-any.whl → 5.4.0__py3-none-any.whl

qBitrr/arss.py

@@ -2705,10 +2705,8 @@ class Arr:
                         QualityMet = not QualityUnmet if db_entry["hasFile"] else False
                         customFormatMet = customFormat >= minCustomFormat
 
-                        if searched:
-                            # Episode is complete and not being searched
-                            reason = None
-                        elif not episode["hasFile"]:
+                        if not episode["hasFile"]:
+                            # Episode is missing a file - always mark as Missing
                             reason = "Missing"
                         elif self.quality_unmet_search and QualityUnmet:
                             reason = "Quality"
@@ -2716,8 +2714,11 @@ class Arr:
                             reason = "CustomFormat"
                         elif self.do_upgrade_search:
                             reason = "Upgrade"
+                        elif searched:
+                            # Episode has file and search is complete
+                            reason = "Not being searched"
                         else:
-                            reason = None
+                            reason = "Not being searched"
 
                         to_update = {
                             self.model_file.Monitored: Monitored,
@@ -3056,10 +3057,8 @@ class Arr:
                     qualityMet = not QualityUnmet if db_entry["hasFile"] else False
                     customFormatMet = customFormat >= minCustomFormat
 
-                    if searched:
-                        # Movie is complete and not being searched
-                        reason = None
-                    elif not db_entry["hasFile"]:
+                    if not db_entry["hasFile"]:
+                        # Movie is missing a file - always mark as Missing
                         reason = "Missing"
                     elif self.quality_unmet_search and QualityUnmet:
                         reason = "Quality"
@@ -3067,8 +3066,11 @@ class Arr:
                         reason = "CustomFormat"
                     elif self.do_upgrade_search:
                         reason = "Upgrade"
+                    elif searched:
+                        # Movie has file and search is complete
+                        reason = "Not being searched"
                     else:
-                        reason = None
+                        reason = "Not being searched"
 
                     to_update = {
                         self.model_file.MovieFileId: movieFileId,
@@ -3365,10 +3367,8 @@ class Arr:
                         qualityMet = not QualityUnmet if hasAllTracks else False
                         customFormatMet = customFormat >= minCustomFormat
 
-                        if searched:
-                            # Album is complete and not being searched
-                            reason = None
-                        elif not hasAllTracks:
+                        if not hasAllTracks:
+                            # Album is missing tracks - always mark as Missing
                             reason = "Missing"
                         elif self.quality_unmet_search and QualityUnmet:
                             reason = "Quality"
@@ -3376,8 +3376,11 @@ class Arr:
                             reason = "CustomFormat"
                         elif self.do_upgrade_search:
                             reason = "Upgrade"
+                        elif searched:
+                            # Album is complete and not being searched
+                            reason = "Not being searched"
                         else:
-                            reason = None
+                            reason = "Not being searched"
 
                         to_update = {
                             self.model_file.AlbumFileId: albumFileId,

qBitrr/bundled_data.py

@@ -1,5 +1,5 @@
-version = "5.3.2"
-git_hash = "4ee2e67"
+version = "5.4.0"
+git_hash = "5cfa06d7"
 license_text = (
     "Licence can be found on:\n\nhttps://github.com/Feramance/qBitrr/blob/master/LICENSE"
 )

qBitrr/main.py

@@ -212,20 +212,67 @@ class qBitManager:
         def _restart():
             if delay > 0:
                 time.sleep(delay)
-            self.logger.notice("Exiting to complete restart.")
+            self.logger.notice("Restarting qBitrr...")
+
+            # Set shutdown event to signal all loops to stop
             try:
                 self.shutdown_event.set()
             except Exception:
                 pass
+
+            # Wait for child processes to exit gracefully
             for proc in list(self.child_processes):
                 with contextlib.suppress(Exception):
                     proc.join(timeout=5)
+
+            # Force kill any remaining child processes
             for proc in list(self.child_processes):
                 with contextlib.suppress(Exception):
                     proc.kill()
                 with contextlib.suppress(Exception):
                     proc.terminate()
-            os._exit(0)
+
+            # Close database connections explicitly
+            try:
+                if hasattr(self, "arr_manager") and self.arr_manager:
+                    for arr in self.arr_manager.managed_objects.values():
+                        if hasattr(arr, "db") and arr.db:
+                            with contextlib.suppress(Exception):
+                                arr.db.close()
+            except Exception:
+                pass
+
+            # Flush all log handlers
+            try:
+                for handler in logging.root.handlers[:]:
+                    with contextlib.suppress(Exception):
+                        handler.flush()
+                        handler.close()
+            except Exception:
+                pass
+
+            # Prepare restart arguments
+            python = sys.executable
+            args = [python] + sys.argv
+
+            self.logger.notice("Executing restart: %s", " ".join(args))
+
+            # Flush logs one final time before exec
+            try:
+                for handler in self.logger.handlers[:]:
+                    with contextlib.suppress(Exception):
+                        handler.flush()
+            except Exception:
+                pass
+
+            # Replace current process with new instance
+            # This works in Docker, native installs, and systemd
+            try:
+                os.execv(python, args)
+            except Exception as e:
+                # If execv fails, fall back to exit and hope external supervisor restarts us
+                self.logger.critical("Failed to restart via execv: %s. Exiting instead.", e)
+                os._exit(1)
 
         self._restart_thread = Thread(target=_restart, name="qBitrr-Restart", daemon=True)
         self._restart_thread.start()

qBitrr/webui.py

@@ -6,6 +6,7 @@ import os
 import re
 import secrets
 import threading
+import time
 from collections.abc import Mapping
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
@@ -143,6 +144,11 @@ class WebUI:
         self._thread: threading.Thread | None = None
         self._use_dev_server: bool | None = None
 
+        # Shutdown control for graceful restart
+        self._shutdown_event = threading.Event()
+        self._restart_requested = False
+        self._server = None  # Will hold Waitress server reference
+
     def _fetch_version_info(self) -> dict[str, Any]:
         info = fetch_latest_release(self._github_repo)
         if info.get("error"):
@@ -916,6 +922,7 @@ class WebUI:
                                         "monitored": is_monitored,
                                         "hasFile": has_file,
                                         "airDateUtc": air_value,
+                                        "reason": getattr(ep, "Reason", None),
                                     }
                                 )
                         for bucket in seasons.values():
@@ -1065,6 +1072,7 @@ class WebUI:
                                 "monitored": is_monitored,
                                 "hasFile": has_file,
                                 "airDateUtc": air_value,
+                                "reason": getattr(ep, "Reason", None),
                             }
                         )
                     for bucket in seasons.values():
@@ -2039,29 +2047,51 @@ class WebUI:
             except Exception as e:
                 return jsonify({"error": str(e)}), 500
 
-        @app.post("/api/config")
-        def api_update_config():
+        def _handle_config_update():
+            """Common handler for config updates with intelligent reload detection."""
             body = request.get_json(silent=True) or {}
             changes: dict[str, Any] = body.get("changes", {})
             if not isinstance(changes, dict):
-                return jsonify({"error": "Invalid request"}), 400
+                return jsonify({"error": "changes must be an object"}), 400
 
-            # Frontend-only WebUI settings that don't require backend reload
+            # Define key categories
             frontend_only_keys = {
                 "WebUI.LiveArr",
                 "WebUI.GroupSonarr",
                 "WebUI.GroupLidarr",
                 "WebUI.Theme",
             }
+            webui_restart_keys = {
+                "WebUI.Host",
+                "WebUI.Port",
+                "WebUI.Token",
+            }
+
+            # Analyze changes to determine reload strategy
+            affected_arr_instances = set()
+            has_global_changes = False
+            has_webui_changes = False
+            has_frontend_only_changes = False
 
-            # Check if any changes require backend reload
-            requires_reload = False
             for key in changes.keys():
-                if key not in frontend_only_keys:
-                    requires_reload = True
-                    break
+                if key in frontend_only_keys:
+                    has_frontend_only_changes = True
+                elif key in webui_restart_keys:
+                    has_webui_changes = True
+                elif key.startswith("WebUI."):
+                    # Unknown WebUI key, treat as webui change for safety
+                    has_webui_changes = True
+                elif match := re.match(
+                    r"^(Radarr|Sonarr|Lidarr|Animarr)[^.]*\.(.+)$", key, re.IGNORECASE
+                ):
+                    # Arr instance specific change
+                    instance_name = key.split(".")[0]
+                    affected_arr_instances.add(instance_name)
+                else:
+                    # Settings.*, qBit.*, or unknown - requires full reload
+                    has_global_changes = True
 
-            # Apply changes
+            # Apply all changes to config
             for key, val in changes.items():
                 if val is None:
                     _toml_delete(CONFIG.config, key)
@@ -2072,75 +2102,88 @@ class WebUI:
                 if key == "WebUI.Token":
                     # Update in-memory token immediately
                     self.token = str(val) if val is not None else ""
-            # Persist
-            CONFIG.save()
 
-            # Only reload if changes affect backend behavior
-            if requires_reload:
+            # Persist config
+            try:
+                CONFIG.save()
+            except Exception as e:
+                return jsonify({"error": f"Failed to save config: {e}"}), 500
+
+            # Determine reload strategy
+            reload_type = "none"
+            affected_instances_list = []
+
+            if has_global_changes:
+                # Global settings changed - full reload required
+                # This affects ALL instances (qBit settings, loop timers, etc.)
+                reload_type = "full"
+                self.logger.notice("Global settings changed, performing full reload")
                 try:
                     self.manager.configure_auto_update()
                 except Exception:
                     self.logger.exception("Failed to refresh auto update configuration")
-                # Live-reload: rebuild Arr instances and restart processes
                 self._reload_all()
-            response = jsonify({"status": "ok"})
-            # Clear cache headers to force browser to reload
-            response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
-            response.headers["Pragma"] = "no-cache"
-            response.headers["Expires"] = "0"
-            # Add a custom header to signal the client to reload
-            response.headers["X-Config-Reloaded"] = "true"
-            return response
 
-        @app.post("/web/config")
-        def web_update_config():
-            body = request.get_json(silent=True) or {}
-            changes: dict[str, Any] = body.get("changes", {})
-            if not isinstance(changes, dict):
-                return jsonify({"error": "changes must be an object"}), 400
+            elif len(affected_arr_instances) >= 1:
+                # One or more Arr instances changed - reload each individually
+                # NEVER trigger global reload for Arr-only changes
+                reload_type = "multi_arr" if len(affected_arr_instances) > 1 else "single_arr"
+                affected_instances_list = sorted(affected_arr_instances)
 
-            # Frontend-only WebUI settings that don't require backend reload
-            frontend_only_keys = {
-                "WebUI.LiveArr",
-                "WebUI.GroupSonarr",
-                "WebUI.GroupLidarr",
-                "WebUI.Theme",
-            }
+                self.logger.notice(
+                    f"Reloading {len(affected_instances_list)} Arr instance(s): {', '.join(affected_instances_list)}"
+                )
 
-            # Check if any changes require backend reload
-            requires_reload = False
-            for key in changes.keys():
-                if key not in frontend_only_keys:
-                    requires_reload = True
-                    break
+                # Reload each affected instance in sequence
+                for instance_name in affected_instances_list:
+                    self._reload_arr_instance(instance_name)
+
+            elif has_webui_changes:
+                # Only WebUI settings changed - restart WebUI
+                reload_type = "webui"
+                self.logger.notice("WebUI settings changed, restarting WebUI server")
+                # Run restart in background thread to avoid blocking response
+                restart_thread = threading.Thread(
+                    target=self._restart_webui, name="WebUIRestart", daemon=True
+                )
+                restart_thread.start()
+
+            elif has_frontend_only_changes:
+                # Only frontend settings changed - no reload
+                reload_type = "frontend"
+                self.logger.debug("Frontend-only settings changed, no reload required")
+
+            # Build response
+            response_data = {
+                "status": "ok",
+                "configReloaded": reload_type not in ("none", "frontend"),
+                "reloadType": reload_type,
+                "affectedInstances": affected_instances_list,
+            }
 
-            for key, val in changes.items():
-                if val is None:
-                    _toml_delete(CONFIG.config, key)
-                    if key == "WebUI.Token":
-                        self.token = ""
-                    continue
-                _toml_set(CONFIG.config, key, val)
-                if key == "WebUI.Token":
-                    self.token = str(val) if val is not None else ""
-            CONFIG.save()
+            response = jsonify(response_data)
 
-            # Only reload if changes affect backend behavior
-            if requires_reload:
-                try:
-                    self.manager.configure_auto_update()
-                except Exception:
-                    self.logger.exception("Failed to refresh auto update configuration")
-                self._reload_all()
-            response = jsonify({"status": "ok"})
-            # Clear cache headers to force browser to reload
+            # Add headers for cache control
             response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate"
             response.headers["Pragma"] = "no-cache"
             response.headers["Expires"] = "0"
-            # Add a custom header to signal the client to reload
-            response.headers["X-Config-Reloaded"] = "true"
+
+            # Legacy header for compatibility
+            if reload_type in ("full", "single_arr", "multi_arr", "webui"):
+                response.headers["X-Config-Reloaded"] = "true"
+
             return response
 
+        @app.post("/api/config")
+        def api_update_config():
+            if (resp := require_token()) is not None:
+                return resp
+            return _handle_config_update()
+
+        @app.post("/web/config")
+        def web_update_config():
+            return _handle_config_update()
+
     def _reload_all(self):
         # Set rebuilding flag
         self._rebuilding_arrs = True
@@ -2199,6 +2242,202 @@ class WebUI:
             # Clear rebuilding flag
             self._rebuilding_arrs = False
 
+    def _restart_webui(self):
+        """
+        Gracefully restart the WebUI server without affecting Arr processes.
+        This is used when WebUI.Host, WebUI.Port, or WebUI.Token changes.
+        """
+        self.logger.notice("WebUI restart requested (config changed)")
+
+        # Reload config values
+        try:
+            CONFIG.load()
+        except Exception as e:
+            self.logger.warning(f"Failed to reload config: {e}")
+
+        # Update in-memory values
+        new_host = CONFIG.get("WebUI.Host", fallback="0.0.0.0")
+        new_port = CONFIG.get("WebUI.Port", fallback=6969)
+        new_token = CONFIG.get("WebUI.Token", fallback=None)
+
+        # Check if restart is actually needed
+        needs_restart = new_host != self.host or new_port != self.port
+
+        # Token can be updated without restart
+        if new_token != self.token:
+            self.token = new_token
+            self.logger.info("WebUI token updated")
+
+        if not needs_restart:
+            self.logger.info("WebUI Host/Port unchanged, restart not required")
+            return
+
+        # Update host/port
+        self.host = new_host
+        self.port = new_port
+
+        # Signal restart
+        self._restart_requested = True
+        self._shutdown_event.set()
+
+        self.logger.info(f"WebUI will restart on {self.host}:{self.port}")
+
+    def _stop_arr_instance(self, arr, category: str):
+        """Stop and cleanup a single Arr instance."""
+        self.logger.info(f"Stopping Arr instance: {category}")
+
+        # Stop processes
+        for loop_kind in ("search", "torrent"):
+            proc_attr = f"process_{loop_kind}_loop"
+            process = getattr(arr, proc_attr, None)
+            if process is not None:
+                try:
+                    process.kill()
+                except Exception:
+                    pass
+                try:
+                    process.terminate()
+                except Exception:
+                    pass
+                try:
+                    self.manager.child_processes.remove(process)
+                except Exception:
+                    pass
+                self.logger.debug(f"Stopped {loop_kind} process for {category}")
+
+        # Delete database files
+        try:
+            if hasattr(arr, "search_db_file") and arr.search_db_file:
+                if arr.search_db_file.exists():
+                    self.logger.info(f"Deleting database file: {arr.search_db_file}")
+                    arr.search_db_file.unlink()
+                    self.logger.success(
+                        f"Deleted database file for {getattr(arr, '_name', category)}"
+                    )
+                # Delete WAL and SHM files
+                for suffix in (".db-wal", ".db-shm"):
+                    aux_file = arr.search_db_file.with_suffix(suffix)
+                    if aux_file.exists():
+                        self.logger.debug(f"Deleting auxiliary file: {aux_file}")
+                        aux_file.unlink()
+        except Exception as e:
+            self.logger.warning(
+                f"Failed to delete database files for {getattr(arr, '_name', category)}: {e}"
+            )
+
+        # Remove from managed_objects
+        self.manager.arr_manager.managed_objects.pop(category, None)
+        self.manager.arr_manager.groups.discard(getattr(arr, "_name", ""))
+        self.manager.arr_manager.uris.discard(getattr(arr, "uri", ""))
+        self.manager.arr_manager.arr_categories.discard(category)
+
+        self.logger.success(f"Stopped and cleaned up Arr instance: {category}")
+
+    def _start_arr_instance(self, instance_name: str):
+        """Create and start a single Arr instance."""
+        self.logger.info(f"Starting Arr instance: {instance_name}")
+
+        # Check if instance is managed
+        if not CONFIG.get(f"{instance_name}.Managed", fallback=False):
+            self.logger.info(f"Instance {instance_name} is not managed, skipping")
+            return
+
+        # Determine client class based on name
+        client_cls = None
+        if re.match(r"^(Rad|rad)arr", instance_name):
+            from pyarr import RadarrAPI
+
+            client_cls = RadarrAPI
+        elif re.match(r"^(Son|son|Anim|anim)arr", instance_name):
+            from pyarr import SonarrAPI
+
+            client_cls = SonarrAPI
+        elif re.match(r"^(Lid|lid)arr", instance_name):
+            from pyarr import LidarrAPI
+
+            client_cls = LidarrAPI
+        else:
+            self.logger.error(f"Unknown Arr type for instance: {instance_name}")
+            return
+
+        try:
+            # Create new Arr instance
+            from qBitrr.arss import Arr
+            from qBitrr.errors import SkipException
+
+            new_arr = Arr(instance_name, self.manager.arr_manager, client_cls=client_cls)
+
+            # Register in manager
+            self.manager.arr_manager.groups.add(instance_name)
+            self.manager.arr_manager.uris.add(new_arr.uri)
+            self.manager.arr_manager.managed_objects[new_arr.category] = new_arr
+            self.manager.arr_manager.arr_categories.add(new_arr.category)
+
+            # Spawn and start processes
+            _, procs = new_arr.spawn_child_processes()
+            for p in procs:
+                try:
+                    p.start()
+                    self.logger.debug(f"Started process (PID: {p.pid}) for {instance_name}")
+                except Exception as e:
+                    self.logger.error(f"Failed to start process for {instance_name}: {e}")
+
+            self.logger.success(
+                f"Started Arr instance: {instance_name} (category: {new_arr.category})"
+            )
+
+        except SkipException:
+            self.logger.info(f"Instance {instance_name} skipped (not managed or disabled)")
+        except Exception as e:
+            self.logger.error(f"Failed to start Arr instance {instance_name}: {e}", exc_info=True)
+
+    def _reload_arr_instance(self, instance_name: str):
+        """Reload a single Arr instance without affecting others."""
+        self.logger.notice(f"Reloading Arr instance: {instance_name}")
+
+        if not hasattr(self.manager, "arr_manager") or not self.manager.arr_manager:
+            self.logger.warning("Cannot reload Arr instance: ArrManager not initialized")
+            return
+
+        managed_objects = self.manager.arr_manager.managed_objects
+
+        # Find the instance by name (key is category, so search by _name attribute)
+        old_arr = None
+        old_category = None
+        for category, arr in list(managed_objects.items()):
+            if getattr(arr, "_name", None) == instance_name:
+                old_arr = arr
+                old_category = category
+                break
+
+        # Check if instance exists in config
+        instance_exists_in_config = instance_name in CONFIG.sections()
+
+        # Handle deletion case
+        if not instance_exists_in_config:
+            if old_arr:
+                self.logger.info(f"Instance {instance_name} removed from config, stopping...")
+                self._stop_arr_instance(old_arr, old_category)
+            else:
+                self.logger.debug(f"Instance {instance_name} not found in config or memory")
+            return
+
+        # Handle update/addition
+        if old_arr:
+            # Update existing - stop old processes first
+            self.logger.info(f"Updating existing Arr instance: {instance_name}")
+            self._stop_arr_instance(old_arr, old_category)
+        else:
+            self.logger.info(f"Adding new Arr instance: {instance_name}")
+
+        # Small delay to ensure cleanup completes
+        time.sleep(0.5)
+
+        # Create new instance
+        self._start_arr_instance(instance_name)
+
+        self.logger.success(f"Successfully reloaded Arr instance: {instance_name}")
+
     def start(self):
         if self._thread and self._thread.is_alive():
             self.logger.debug("WebUI already running on %s:%s", self.host, self.port)
@@ -2210,10 +2449,24 @@ class WebUI:
 
     def _serve(self):
         try:
+            # Reset shutdown event at start
+            self._shutdown_event.clear()
+
             if self._should_use_dev_server():
                 self.logger.info("Using Flask development server for WebUI")
-                self.app.run(host=self.host, port=self.port, debug=False, use_reloader=False)
+                # Flask dev server - will exit on KeyboardInterrupt
+                try:
+                    self.app.run(
+                        host=self.host,
+                        port=self.port,
+                        debug=False,
+                        use_reloader=False,
+                        threaded=True,
+                    )
+                except (KeyboardInterrupt, SystemExit):
+                    pass
                 return
+
             try:
                 from waitress import serve as waitress_serve
             except Exception:
@@ -2223,15 +2476,32 @@ class WebUI:
                 )
                 self.app.run(host=self.host, port=self.port, debug=False, use_reloader=False)
                 return
+
             self.logger.info("Using Waitress WSGI server for WebUI")
+
+            # For graceful restart capability, we need to use waitress_serve with channels
+            # However, for now we'll use the simpler approach and just run the server
+            # Restart capability will require stopping the entire process
             waitress_serve(
                 self.app,
                 host=self.host,
                 port=self.port,
                 ident="qBitrr-WebUI",
             )
-        except Exception:  # pragma: no cover - defensive logging
+
+        except KeyboardInterrupt:
+            self.logger.info("WebUI interrupted")
+        except Exception:
             self.logger.exception("WebUI server terminated unexpectedly")
+        finally:
+            self._server = None
+
+            # If restart was requested, start a new server
+            if self._restart_requested:
+                self._restart_requested = False
+                self.logger.info("Restarting WebUI server...")
+                time.sleep(0.5)  # Brief pause
+                self.start()  # Restart
 
     def _should_use_dev_server(self) -> bool:
         if self._use_dev_server is not None: