qBitrr2 5.0.2__py3-none-any.whl → 5.1.1__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 SqliteDatabase
+from peewee import Model, SqliteDatabase
 from pyarr import RadarrAPI, SonarrAPI
 from pyarr.exceptions import PyarrResourceNotFound, PyarrServerError
 from pyarr.types import JsonObject
@@ -302,6 +302,7 @@ class Arr:
             self._delta = 1
         else:
             self._delta = -1
+
         self._app_data_folder = APPDATA_FOLDER
         self.search_db_file = self._app_data_folder.joinpath(f"{self._name}.db")
 
@@ -566,15 +567,16 @@ class Arr:
         elif not QBIT_DISABLED and TAGLESS:
             self.manager.qbit_manager.client.torrents_create_tags(["qBitrr-ignored"])
         self.search_setup_completed = False
-        self.model_file: EpisodeFilesModel | MoviesFilesModel = None
-        self.series_file_model: SeriesFilesModel = None
-        self.model_queue: EpisodeQueueModel | MovieQueueModel = None
-        self.persistent_queue: FilesQueued = None
+        self.model_file: Model | None = None
+        self.series_file_model: Model | None = None
+        self.model_queue: Model | None = None
+        self.persistent_queue: Model | None = None
         self.torrents: TorrentLibrary | None = None
+        self.torrent_db: SqliteDatabase | None = None
+        self.db: SqliteDatabase | None = None
         # Initialize search mode (and torrent tag-emulation DB in TAGLESS)
         # early and fail fast if it cannot be set up.
         self.register_search_mode()
-        # Ensure DBs are closed on process exit
         atexit.register(
             lambda: (
                 hasattr(self, "db") and self.db and not self.db.is_closed() and self.db.close()
@@ -848,28 +850,6 @@ class Arr:
                     ),
                 )
 
-    def _get_models(
-        self,
-    ) -> tuple[
-        type[EpisodeFilesModel] | type[MoviesFilesModel],
-        type[EpisodeQueueModel] | type[MovieQueueModel],
-        type[SeriesFilesModel] | None,
-        type[TorrentLibrary] | None,
-    ]:
-        if self.type == "sonarr":
-            if self.series_search:
-                return (
-                    EpisodeFilesModel,
-                    EpisodeQueueModel,
-                    SeriesFilesModel,
-                    TorrentLibrary if TAGLESS else None,
-                )
-            return EpisodeFilesModel, EpisodeQueueModel, None, TorrentLibrary if TAGLESS else None
-        elif self.type == "radarr":
-            return MoviesFilesModel, MovieQueueModel, None, TorrentLibrary if TAGLESS else None
-        else:
-            raise UnhandledError(f"Well you shouldn't have reached here, Arr.type={self.type}")
-
     def _get_oversee_requests_all(self) -> dict[str, set]:
         try:
             data = defaultdict(set)
@@ -4843,11 +4823,8 @@ class Arr:
         if self.search_setup_completed:
             return
 
-        # Determine which models we need in this mode (including TorrentLibrary when TAGLESS)
         db1, db2, db3, db4 = self._get_models()
 
-        # If searches are disabled, we still want the torrent tag-emulation DB in TAGLESS mode,
-        # but can skip the per-entry search database setup.
         if not (
             self.search_missing
             or self.do_upgrade_search
@@ -4862,7 +4839,7 @@ class Arr:
                     str(self._app_data_folder.joinpath("Torrents.db")),
                     pragmas={
                         "journal_mode": "wal",
-                        "cache_size": -1 * 64000,  # 64MB
+                        "cache_size": -64_000,
                         "foreign_keys": 1,
                         "ignore_check_constraints": 0,
                         "synchronous": 0,
@@ -4880,12 +4857,13 @@ class Arr:
             self.search_setup_completed = True
             return
 
+        self.search_db_file.parent.mkdir(parents=True, exist_ok=True)
         self.db = SqliteDatabase(None)
         self.db.init(
             str(self.search_db_file),
             pragmas={
                 "journal_mode": "wal",
-                "cache_size": -1 * 64000,  # 64MB
+                "cache_size": -64_000,
                 "foreign_keys": 1,
                 "ignore_check_constraints": 0,
                 "synchronous": 0,
@@ -4916,6 +4894,7 @@ class Arr:
             self.series_file_model = Series
         else:
             self.db.create_tables([Files, Queue, PersistingQueue])
+            self.series_file_model = None
 
         if db4:
             self.torrent_db = SqliteDatabase(None)
@@ -4923,7 +4902,7 @@ class Arr:
                 str(self._app_data_folder.joinpath("Torrents.db")),
                 pragmas={
                     "journal_mode": "wal",
-                    "cache_size": -1 * 64000,  # 64MB
+                    "cache_size": -64_000,
                     "foreign_keys": 1,
                     "ignore_check_constraints": 0,
                     "synchronous": 0,
@@ -4939,13 +4918,44 @@ class Arr:
             self.torrent_db.create_tables([Torrents])
             self.torrents = Torrents
         else:
-            self.torrents: TorrentLibrary = None
+            self.torrents = None
 
         self.model_file = Files
         self.model_queue = Queue
         self.persistent_queue = PersistingQueue
         self.search_setup_completed = True
 
+    def _get_models(
+        self,
+    ) -> tuple[
+        type[EpisodeFilesModel] | type[MoviesFilesModel],
+        type[EpisodeQueueModel] | type[MovieQueueModel],
+        type[SeriesFilesModel] | None,
+        type[TorrentLibrary] | None,
+    ]:
+        if self.type == "sonarr":
+            if self.series_search:
+                return (
+                    EpisodeFilesModel,
+                    EpisodeQueueModel,
+                    SeriesFilesModel,
+                    TorrentLibrary if TAGLESS else None,
+                )
+            return (
+                EpisodeFilesModel,
+                EpisodeQueueModel,
+                None,
+                TorrentLibrary if TAGLESS else None,
+            )
+        if self.type == "radarr":
+            return (
+                MoviesFilesModel,
+                MovieQueueModel,
+                None,
+                TorrentLibrary if TAGLESS else None,
+            )
+        raise UnhandledError(f"Well you shouldn't have reached here, Arr.type={self.type}")
+
     def run_request_search(self):
         if (
             (
@@ -5567,6 +5577,7 @@ class PlaceHolderArr(Arr):
 class FreeSpaceManager(Arr):
     def __init__(self, categories: set[str], manager: ArrManager):
         self._name = "FreeSpaceManager"
+        self.type = "FreeSpaceManager"
         self.manager = manager
         self.logger = logging.getLogger(f"qBitrr.{self._name}")
         self._LOG_LEVEL = self.manager.qbit_manager.logger.level
@@ -5581,7 +5592,6 @@ class FreeSpaceManager(Arr):
         )
         self.timed_ignore_cache = ExpiringSet(max_age_seconds=self.ignore_torrents_younger_than)
         self.needs_cleanup = False
-        # Needed by register_search_mode for torrent DB pathing
         self._app_data_folder = APPDATA_FOLDER
         # Track search setup state to cooperate with Arr.register_search_mode
         self.search_setup_completed = False
@@ -5608,9 +5618,9 @@ class FreeSpaceManager(Arr):
         self.ombi_search_requests = False
         self.overseerr_requests = False
         self.session = None
-        # Reuse Arr's search-mode initializer to set up the torrent tag-emulation DB
-        # without needing Arr type, by overriding _get_models below.
+        # Ensure torrent tag-emulation tables exist when needed.
         self.torrents = None
+        self.torrent_db: SqliteDatabase | None = None
         self.last_search_description: str | None = None
         self.last_search_timestamp: str | None = None
         self.queue_active_count: int = 0
@@ -5618,7 +5628,6 @@ class FreeSpaceManager(Arr):
         self.free_space_tagged_count: int = 0
         self.register_search_mode()
         self.logger.hnotice("Starting %s monitor", self._name)
-        # Ensure DB is closed when process exits (guard attribute existence)
         atexit.register(
             lambda: (
                 hasattr(self, "torrent_db")
@@ -5636,9 +5645,6 @@ class FreeSpaceManager(Arr):
         None,
         type[TorrentLibrary] | None,
     ]:
-        # FreeSpaceManager should never create the per-entry search database.
-        # Return None for file and queue models so only the torrent DB (TAGLESS)
-        # can be initialized by register_search_mode.
         return None, None, None, (TorrentLibrary if TAGLESS else None)
 
     def _process_single_torrent_pause_disk_space(self, torrent: qbittorrentapi.TorrentDictionary):

qBitrr/auto_update.py

@@ -82,8 +82,11 @@ class AutoUpdater:
             self._logger.info("Auto update completed")
 
 
-def perform_self_update(logger: logging.Logger) -> None:
-    """Attempt to update qBitrr in-place using git or pip."""
+def perform_self_update(logger: logging.Logger) -> bool:
+    """Attempt to update qBitrr in-place using git or pip.
+
+    Returns True when the update command completed successfully, False otherwise.
+    """
 
     repo_root = Path(__file__).resolve().parent.parent
     git_dir = repo_root / ".git"
@@ -100,10 +103,11 @@ def perform_self_update(logger: logging.Logger) -> None:
             stdout = (result.stdout or "").strip()
             if stdout:
                 logger.info("git pull output:\n%s", stdout)
+            return True
         except subprocess.CalledProcessError as exc:
             stderr = (exc.stderr or "").strip()
             logger.error("Failed to update repository via git: %s", stderr or exc)
-        return
+            return False
 
     package = "qBitrr2"
     logger.debug("Fallback to pip upgrade for package %s", package)
@@ -117,6 +121,8 @@ def perform_self_update(logger: logging.Logger) -> None:
         stdout = (result.stdout or "").strip()
         if stdout:
             logger.info("pip upgrade output:\n%s", stdout)
+        return True
     except subprocess.CalledProcessError as exc:
         stderr = (exc.stderr or "").strip()
         logger.error("Failed to upgrade package via pip: %s", stderr or exc)
+        return False

qBitrr/bundled_data.py

@@ -1,5 +1,5 @@
-version = "5.0.2"
-git_hash = "34ae835"
+version = "5.1.1"
+git_hash = "203e3ef"
 license_text = (
     "Licence can be found on:\n\nhttps://github.com/Feramance/qBitrr/blob/master/LICENSE"
 )

qBitrr/db_lock.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import os
+import threading
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Iterator
+
+from qBitrr.home_path import APPDATA_FOLDER
+
+if os.name == "nt":  # pragma: no cover - platform specific
+    import msvcrt
+else:  # pragma: no cover
+    import fcntl
+
+_LOCK_FILE = APPDATA_FOLDER.joinpath("qbitrr.db.lock")
+
+
+class _InterProcessFileLock:
+    """Cross-process, re-entrant file lock to guard SQLite access."""
+
+    def __init__(self, path: Path):
+        self._path = path
+        self._thread_gate = threading.RLock()
+        self._local = threading.local()
+
+    def acquire(self) -> None:
+        depth = getattr(self._local, "depth", 0)
+        if depth == 0:
+            self._thread_gate.acquire()
+            self._path.parent.mkdir(parents=True, exist_ok=True)
+            handle = open(self._path, "a+b")
+            try:
+                if os.name == "nt":  # pragma: no cover - Windows specific branch
+                    msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)
+                else:  # pragma: no cover - POSIX branch
+                    fcntl.flock(handle, fcntl.LOCK_EX)
+            except Exception:
+                handle.close()
+                self._thread_gate.release()
+                raise
+            self._local.handle = handle
+        self._local.depth = depth + 1
+
+    def release(self) -> None:
+        depth = getattr(self._local, "depth", 0)
+        if depth <= 0:
+            raise RuntimeError("Attempted to release an unacquired database lock")
+        depth -= 1
+        if depth == 0:
+            handle = getattr(self._local, "handle")
+            try:
+                if os.name == "nt":  # pragma: no cover
+                    msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+                else:  # pragma: no cover
+                    fcntl.flock(handle, fcntl.LOCK_UN)
+            finally:
+                handle.close()
+                del self._local.handle
+                self._thread_gate.release()
+        self._local.depth = depth
+
+    @contextmanager
+    def context(self) -> Iterator[None]:
+        self.acquire()
+        try:
+            yield
+        finally:
+            self.release()
+
+
+_DB_LOCK = _InterProcessFileLock(_LOCK_FILE)
+
+
+@contextmanager
+def database_lock() -> Iterator[None]:
+    """Provide a shared lock used to serialize SQLite access across processes."""
+    with _DB_LOCK.context():
+        yield

qBitrr/gen_config.py

@@ -159,9 +159,9 @@ def _add_settings_section(config: TOMLDocument):
     )
     _gen_default_line(
         settings,
-        "WebUI listen host (default 127.0.0.1)",
+        "WebUI listen host (default 0.0.0.0)",
         "WebUIHost",
-        "127.0.0.1",
+        "0.0.0.0",
     )
     _gen_default_line(
         settings,

qBitrr/logger.py

@@ -119,6 +119,7 @@ def run_logs(logger: Logger, _name: str = None) -> None:
         },
         reconfigure=True,
     )
+    logger.propagate = False
     if ENABLE_LOGS and _name:
         logs_folder = HOME_PATH.joinpath("logs")
         logs_folder.mkdir(parents=True, exist_ok=True)

qBitrr/main.py

@@ -2,9 +2,10 @@ from __future__ import annotations
 
 import atexit
 import contextlib
-import itertools
 import logging
+import os
 import sys
+import time
 from multiprocessing import Event, freeze_support
 from queue import SimpleQueue
 from threading import Event as ThreadEvent
@@ -21,7 +22,6 @@ from qbittorrentapi import APINames
 from qBitrr.auto_update import AutoUpdater, perform_self_update
 from qBitrr.bundled_data import patched_version
 from qBitrr.config import (
-    APPDATA_FOLDER,
     CONFIG,
     CONFIG_EXISTS,
     QBIT_DISABLED,
@@ -32,7 +32,8 @@ from qBitrr.config import (
 from qBitrr.env_config import ENVIRO_CONFIG
 from qBitrr.ffprobe import FFprobeDownloader
 from qBitrr.logger import run_logs
-from qBitrr.utils import ExpiringSet, absolute_file_paths
+from qBitrr.utils import ExpiringSet
+from qBitrr.versioning import fetch_latest_release
 from qBitrr.webui import WebUI
 
 if CONFIG_EXISTS:
@@ -101,6 +102,8 @@ class qBitManager:
         self.arr_manager = None
         self._bootstrap_ready = ThreadEvent()
         self._startup_thread: Thread | None = None
+        self._restart_requested = False
+        self._restart_thread: Thread | None = None
         self.ffprobe_downloader = FFprobeDownloader()
         try:
             if not (QBIT_DISABLED or SEARCH_ONLY):
@@ -115,6 +118,11 @@ class qBitManager:
         except Exception:
             web_port = 6969
         web_host = CONFIG.get("Settings.WebUIHost", fallback="127.0.0.1") or "127.0.0.1"
+        if os.environ.get("QBITRR_DOCKER_RUNNING") == "69420" and web_host in {
+            "127.0.0.1",
+            "localhost",
+        }:
+            web_host = "0.0.0.0"
         if web_host in {"0.0.0.0", "::"}:
             self.logger.warning(
                 "WebUI host configured for %s; ensure exposure is intentional and protected.",
@@ -144,11 +152,55 @@ class qBitManager:
             self.logger.error("Auto update could not be scheduled; leaving it disabled")
 
     def _perform_auto_update(self) -> None:
-        self.logger.notice("Performing auto update...")
-        perform_self_update(self.logger)
-        self.logger.notice(
-            "Auto update cycle complete. A restart may be required if files were updated."
-        )
+        self.logger.notice("Checking for updates...")
+        release_info = fetch_latest_release()
+        if release_info.get("error"):
+            self.logger.error("Auto update skipped: %s", release_info["error"])
+            return
+        target_version = release_info.get("raw_tag") or release_info.get("normalized")
+        if not release_info.get("update_available"):
+            if target_version:
+                self.logger.info(
+                    "Auto update skipped: already running the latest release (%s).",
+                    target_version,
+                )
+            else:
+                self.logger.info("Auto update skipped: no new release detected.")
+            return
+
+        self.logger.notice("Updating from %s to %s", patched_version, target_version or "latest")
+        updated = perform_self_update(self.logger)
+        if not updated:
+            self.logger.error("Auto update failed; manual intervention may be required.")
+            return
+        self.logger.notice("Update applied successfully; restarting to load the new version.")
+        self.request_restart()
+
+    def request_restart(self, delay: float = 3.0) -> None:
+        if self._restart_requested:
+            return
+        self._restart_requested = True
+
+        def _restart():
+            if delay > 0:
+                time.sleep(delay)
+            self.logger.notice("Exiting to complete restart.")
+            try:
+                self.shutdown_event.set()
+            except Exception:
+                pass
+            for proc in list(self.child_processes):
+                with contextlib.suppress(Exception):
+                    proc.join(timeout=5)
+            for proc in list(self.child_processes):
+                with contextlib.suppress(Exception):
+                    proc.kill()
+                with contextlib.suppress(Exception):
+                    proc.terminate()
+            os._exit(0)
+
+        self._restart_thread = Thread(target=_restart, name="qBitrr-Restart", daemon=True)
+        self._restart_thread.start()
 
     def _prepare_arr_processes(self, arr, timeout_seconds: int = 30) -> None:
         timeout = max(
@@ -437,15 +489,6 @@ def run():
             child.kill()
 
 
-def file_cleanup():
-    extensions = [".db", ".db-shm", ".db-wal"]
-    all_files_in_folder = list(absolute_file_paths(APPDATA_FOLDER))
-    for file, ext in itertools.product(all_files_in_folder, extensions):
-        if file.name.endswith(ext):
-            file.unlink(missing_ok=True)
-
-
 if __name__ == "__main__":
     freeze_support()
-    file_cleanup()
     run()

qBitrr/versioning.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+from packaging import version as version_parser
+
+from qBitrr.bundled_data import patched_version
+
+DEFAULT_REPOSITORY = "Feramance/qBitrr"
+
+
+def normalize_version(raw: str | None) -> str | None:
+    if not raw:
+        return None
+    cleaned = raw.strip()
+    if cleaned.startswith(("v", "V")):
+        cleaned = cleaned[1:]
+    if "-" in cleaned:
+        cleaned = cleaned.split("-", 1)[0]
+    return cleaned or None
+
+
+def is_newer_version(candidate: str | None, current: str | None = None) -> bool:
+    if not candidate:
+        return False
+    normalized_current = normalize_version(current or patched_version)
+    if not normalized_current:
+        return True
+    try:
+        latest_version = version_parser.parse(candidate)
+        current_version = version_parser.parse(normalized_current)
+        return latest_version > current_version
+    except Exception:
+        return candidate != normalized_current
+
+
+def fetch_latest_release(repo: str = DEFAULT_REPOSITORY, *, timeout: int = 10) -> dict[str, Any]:
+    url = f"https://api.github.com/repos/{repo}/releases/latest"
+    headers = {"Accept": "application/vnd.github+json"}
+    try:
+        response = requests.get(url, headers=headers, timeout=timeout)
+        response.raise_for_status()
+        payload = response.json()
+    except Exception as exc:
+        message = str(exc)
+        if len(message) > 200:
+            message = f"{message[:197]}..."
+        return {
+            "raw_tag": None,
+            "normalized": None,
+            "changelog": "",
+            "changelog_url": f"https://github.com/{repo}/releases",
+            "update_available": False,
+            "error": message,
+        }
+
+    raw_tag = (payload.get("tag_name") or payload.get("name") or "").strip()
+    normalized = normalize_version(raw_tag)
+    changelog = payload.get("body") or ""
+    changelog_url = payload.get("html_url") or f"https://github.com/{repo}/releases"
+    update_available = is_newer_version(normalized)
+    return {
+        "raw_tag": raw_tag or None,
+        "normalized": normalized,
+        "changelog": changelog,
+        "changelog_url": changelog_url,
+        "update_available": update_available,
+        "error": None,
+    }

qBitrr/webui.py

@@ -11,9 +11,7 @@ from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Any
 
-import requests
 from flask import Flask, jsonify, redirect, request, send_file
-from packaging import version as version_parser
 from peewee import fn
 
 from qBitrr.arss import FreeSpaceManager, PlaceHolderArr
@@ -24,6 +22,7 @@ from qBitrr.search_activity_store import (
     clear_search_activity,
     fetch_search_activities,
 )
+from qBitrr.versioning import fetch_latest_release
 
 
 def _toml_set(doc, dotted_key: str, value: Any):
@@ -69,7 +68,7 @@ def _toml_to_jsonable(obj: Any) -> Any:
 
 
 class WebUI:
-    def __init__(self, manager, host: str = "127.0.0.1", port: int = 6969):
+    def __init__(self, manager, host: str = "0.0.0.0", port: int = 6969):
         self.manager = manager
         self.host = host
         self.port = port
@@ -131,58 +130,17 @@ class WebUI:
         self._thread: threading.Thread | None = None
         self._use_dev_server: bool | None = None
 
-    @staticmethod
-    def _normalize_version(value: str | None) -> str | None:
-        if not value:
-            return None
-        cleaned = value.strip()
-        if not cleaned:
-            return None
-        if cleaned[0] in {"v", "V"}:
-            cleaned = cleaned[1:]
-        if "-" in cleaned:
-            cleaned = cleaned.split("-", 1)[0]
-        return cleaned or None
-
-    def _is_newer_version(self, candidate: str | None) -> bool:
-        if not candidate:
-            return False
-        current_norm = self._normalize_version(patched_version)
-        if not current_norm:
-            return True
-        try:
-            latest_version = version_parser.parse(candidate)
-            current_version = version_parser.parse(current_norm)
-            return latest_version > current_version
-        except Exception:
-            return candidate != current_norm
-
     def _fetch_version_info(self) -> dict[str, Any]:
-        repo = self._github_repo
-        url = f"https://api.github.com/repos/{repo}/releases/latest"
-        headers = {"Accept": "application/vnd.github+json"}
-        try:
-            response = requests.get(url, headers=headers, timeout=10)
-            response.raise_for_status()
-            payload = response.json()
-        except Exception as exc:
-            message = str(exc)
-            if len(message) > 200:
-                message = f"{message[:197]}..."
-            self.logger.debug("Failed to fetch latest release information: %s", exc)
-            return {"error": message}
-
-        raw_tag = (payload.get("tag_name") or payload.get("name") or "").strip()
-        normalized_latest = self._normalize_version(raw_tag)
-        latest_display = raw_tag or normalized_latest
-        changelog = payload.get("body") or ""
-        changelog_url = payload.get("html_url") or f"https://github.com/{repo}/releases"
-        update_available = self._is_newer_version(normalized_latest)
+        info = fetch_latest_release(self._github_repo)
+        if info.get("error"):
+            self.logger.debug("Failed to fetch latest release information: %s", info["error"])
+            return {"error": info["error"]}
+        latest_display = info.get("raw_tag") or info.get("normalized")
         return {
             "latest_version": latest_display,
-            "update_available": update_available,
-            "changelog": changelog,
-            "changelog_url": changelog_url,
+            "update_available": bool(info.get("update_available")),
+            "changelog": info.get("changelog") or "",
+            "changelog_url": info.get("changelog_url"),
             "error": None,
         }
 
@@ -251,7 +209,14 @@ class WebUI:
             except AttributeError:
                 from qBitrr.auto_update import perform_self_update
 
-                perform_self_update(self.manager.logger)
+                if not perform_self_update(self.manager.logger):
+                    raise RuntimeError("pip upgrade did not complete successfully")
+                try:
+                    self.manager.request_restart()
+                except Exception:
+                    self.logger.warning(
+                        "Update applied but restart request failed; exiting manually."
+                    )
         except Exception as exc:
             result = "error"
             error_message = str(exc)

{qbitrr2-5.0.2.dist-info → qbitrr2-5.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qBitrr2
-Version: 5.0.2
+Version: 5.1.1
 Summary: "A simple Python script to talk to qBittorrent and Arr's"
 Home-page: https://github.com/Feramance/qBitrr
 Author: Feramance
@@ -138,13 +138,16 @@ Minimal setup:
 docker run -d \
   --name qbitrr \
   -e TZ=Europe/London \
+  -p 6969:6969 \
   -v /etc/localtime:/etc/localtime:ro \
   -v /path/to/appdata/qbitrr:/config \
   -v /path/to/completed/downloads:/completed_downloads:rw \
   --restart unless-stopped \
-  feramance/qbitrr:latest
+feramance/qbitrr:latest
 ```
 
+The container automatically binds its WebUI to `0.0.0.0`; exposing `6969` makes the dashboard reachable at `http://<host>:6969/ui`.
+
 Compose example with a little more structure:
 ```yaml
 services:

qbitrr2-5.1.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+qBitrr/__init__.py,sha256=smiPIV7d2lMJ_KTtFdAVlxLEBobFTheILdgry1iqpjQ,405
+qBitrr/arss.py,sha256=WwDobdQcGcHSvQdh9tiDaza0S8wnPgOMtiRLpmd3Ans,263064
+qBitrr/auto_update.py,sha256=hVAvAlKEdOHm6AJLlKvtkklbQhjotVcFOCH-MTigHQM,4419
+qBitrr/bundled_data.py,sha256=qkprw9cE-4KVdWUx1-7xn2heRUSPOIMW9LZd04dOzuo,190
+qBitrr/config.py,sha256=brGy1PQJY6D0HG1V6gpuTi1gPbMH3zIvfozASkvPZR8,6177
+qBitrr/db_lock.py,sha256=SRCDIoqg-AFLU-VDChAmGdfx8nhgLGETn6XKF3RdJT4,2449
+qBitrr/env_config.py,sha256=299u_uEoyxlM_ceTD0Z_i41JdYjSHmqO6FKe7qGFgTM,2866
+qBitrr/errors.py,sha256=5_n1x0XX4UvMlieC_J1Hc5pq5JD17orfjJy9KfxDXA4,1107
+qBitrr/ffprobe.py,sha256=2IM0iuPPTEb0xHmN1OetQoBd80-Nmv5Oq7P6o-mjBd0,4019
+qBitrr/gen_config.py,sha256=lDRbCzjWoJuUyOZNnOmNjChuZoR5K6fuwKCJ2qxzu78,29862
+qBitrr/home_path.py,sha256=zvBheAR2xvr8LBZRk1FyqfnALE-eFzsY9CyqyZDjxiE,626
+qBitrr/logger.py,sha256=os7cHbJ3sbkxDh6Nno9o_41aCwsLp-Y963nZe-rglKA,5505
+qBitrr/main.py,sha256=x1jzrOBX3PziARnRY5UaSgrRmbCGwG6s2AnoUI6M-Zk,19003
+qBitrr/search_activity_store.py,sha256=_7MD7fFna4uTSo_pRT7DqoytSVz7tPoU9D2AV2mn-oc,2474
+qBitrr/tables.py,sha256=si_EpQXj6OOF78rgJGDMeTEnT2zpvfnR3NGPaVZHUXc,2479
+qBitrr/utils.py,sha256=DEnkQrbXFPWunhzId0OE6_oWuUTd5V4aDCZ2yHdrvo0,7306
+qBitrr/versioning.py,sha256=k3n8cOh1E5mevN8OkYWOA3110PuOajMOpGyCKy3rFEc,2279
+qBitrr/webui.py,sha256=HaM3w-rzuvVyGtphRCROY2GDXZtRmny3blkC5WoTOSk,68298
+qbitrr2-5.1.1.dist-info/licenses/LICENSE,sha256=P978aVGi7dPbKz8lfvdiryOS5IjTAU7AA47XhBhVBlI,1066
+qbitrr2-5.1.1.dist-info/METADATA,sha256=DFS1E6dKhTG132BhkflK2scrC_kGR5XeonsNOsX0Nk4,10122
+qbitrr2-5.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qbitrr2-5.1.1.dist-info/entry_points.txt,sha256=MIR-l5s31VBs9qlv3HiAaMdpOOyy0MNGfM7Ib1-fKeQ,43
+qbitrr2-5.1.1.dist-info/top_level.txt,sha256=jIINodarzsPcQeTf-vvK8-_g7cQ8CvxEg41ms14K97g,7
+qbitrr2-5.1.1.dist-info/RECORD,,

qbitrr2-5.0.2.dist-info/RECORD

@@ -1,22 +0,0 @@
-qBitrr/__init__.py,sha256=smiPIV7d2lMJ_KTtFdAVlxLEBobFTheILdgry1iqpjQ,405
-qBitrr/arss.py,sha256=jJgCKobZT_y5HnakpR5uj3ul-0CUhiL4uLhB8HkaGSo,263449
-qBitrr/auto_update.py,sha256=faHYeJ9GsSmz5XfOt6Uq3fZOeEmqZ20MMUotKtq9M7s,4256
-qBitrr/bundled_data.py,sha256=Y0Qq5-HofqPBmU3sL9_Ihp7t0k-Yl-RiwYYUz4tQJdc,190
-qBitrr/config.py,sha256=brGy1PQJY6D0HG1V6gpuTi1gPbMH3zIvfozASkvPZR8,6177
-qBitrr/env_config.py,sha256=299u_uEoyxlM_ceTD0Z_i41JdYjSHmqO6FKe7qGFgTM,2866
-qBitrr/errors.py,sha256=5_n1x0XX4UvMlieC_J1Hc5pq5JD17orfjJy9KfxDXA4,1107
-qBitrr/ffprobe.py,sha256=2IM0iuPPTEb0xHmN1OetQoBd80-Nmv5Oq7P6o-mjBd0,4019
-qBitrr/gen_config.py,sha256=ub5sZAPj7uh4yxR-RIV-LhqrWS66uH9kitybXLAk1e4,29866
-qBitrr/home_path.py,sha256=zvBheAR2xvr8LBZRk1FyqfnALE-eFzsY9CyqyZDjxiE,626
-qBitrr/logger.py,sha256=lp9aPXtdcSVrSv7SQX_Nokq1nzQdHHkmZJ23RofWnos,5476
-qBitrr/main.py,sha256=mz5c-m7ZlnTkSrIS_eTJdWUh2ANioH4LJ4AkAHoB_FA,17208
-qBitrr/search_activity_store.py,sha256=_7MD7fFna4uTSo_pRT7DqoytSVz7tPoU9D2AV2mn-oc,2474
-qBitrr/tables.py,sha256=si_EpQXj6OOF78rgJGDMeTEnT2zpvfnR3NGPaVZHUXc,2479
-qBitrr/utils.py,sha256=DEnkQrbXFPWunhzId0OE6_oWuUTd5V4aDCZ2yHdrvo0,7306
-qBitrr/webui.py,sha256=YhEhEm0os1UE-kVHxtEZN4ZV06hSeE5D0HPMIV4pPjs,69493
-qbitrr2-5.0.2.dist-info/licenses/LICENSE,sha256=P978aVGi7dPbKz8lfvdiryOS5IjTAU7AA47XhBhVBlI,1066
-qbitrr2-5.0.2.dist-info/METADATA,sha256=lQTz_WgcB9k4ifTv9Vi5rIwL57fESc0HpzyR3isNjV4,9974
-qbitrr2-5.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-qbitrr2-5.0.2.dist-info/entry_points.txt,sha256=MIR-l5s31VBs9qlv3HiAaMdpOOyy0MNGfM7Ib1-fKeQ,43
-qbitrr2-5.0.2.dist-info/top_level.txt,sha256=jIINodarzsPcQeTf-vvK8-_g7cQ8CvxEg41ms14K97g,7
-qbitrr2-5.0.2.dist-info/RECORD,,