qBitrr2 5.0.1__py3-none-any.whl → 5.1.0__py3-none-any.whl

qBitrr/arss.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import atexit
 import contextlib
 import itertools
 import logging
@@ -20,7 +19,7 @@ import qbittorrentapi
 import qbittorrentapi.exceptions
 import requests
 from packaging import version as version_parser
-from peewee import SqliteDatabase
+from peewee import Model
 from pyarr import RadarrAPI, SonarrAPI
 from pyarr.exceptions import PyarrResourceNotFound, PyarrServerError
 from pyarr.types import JsonObject
@@ -28,7 +27,6 @@ from qbittorrentapi import TorrentDictionary, TorrentStates
 from ujson import JSONDecodeError
 
 from qBitrr.config import (
-    APPDATA_FOLDER,
     AUTO_PAUSE_RESUME,
     COMPLETED_DOWNLOAD_FOLDER,
     CONFIG,
@@ -57,15 +55,7 @@ from qBitrr.search_activity_store import (
     fetch_search_activities,
     record_search_activity,
 )
-from qBitrr.tables import (
-    EpisodeFilesModel,
-    EpisodeQueueModel,
-    FilesQueued,
-    MovieQueueModel,
-    MoviesFilesModel,
-    SeriesFilesModel,
-    TorrentLibrary,
-)
+from qBitrr.tables import TorrentLibrary, create_arr_tables, ensure_table_schema, get_database
 from qBitrr.utils import (
     ExpiringSet,
     absolute_file_paths,
@@ -302,8 +292,6 @@ 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")
 
         self.ombi_search_requests = CONFIG.get(
             f"{name}.EntrySearch.Ombi.SearchOmbiRequests", fallback=False
@@ -566,28 +554,14 @@ 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
         # 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()
-            )
-        )
-        atexit.register(
-            lambda: (
-                hasattr(self, "torrent_db")
-                and self.torrent_db
-                and not self.torrent_db.is_closed()
-                and self.torrent_db.close()
-            )
-        )
         self.logger.hnotice("Starting %s monitor", self._name)
 
     @staticmethod
@@ -848,28 +822,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,107 +4795,44 @@ 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
-            or self.quality_unmet_search
-            or self.custom_format_unmet_search
-            or self.ombi_search_requests
-            or self.overseerr_requests
-        ):
-            if db4 and getattr(self, "torrents", None) is None:
-                self.torrent_db = SqliteDatabase(None)
-                self.torrent_db.init(
-                    str(self._app_data_folder.joinpath("Torrents.db")),
-                    pragmas={
-                        "journal_mode": "wal",
-                        "cache_size": -1 * 64000,  # 64MB
-                        "foreign_keys": 1,
-                        "ignore_check_constraints": 0,
-                        "synchronous": 0,
-                    },
-                    timeout=15,
-                )
-
-                class Torrents(db4):
-                    class Meta:
-                        database = self.torrent_db
-
-                self.torrent_db.connect()
-                self.torrent_db.create_tables([Torrents])
-                self.torrents = Torrents
-            self.search_setup_completed = True
-            return
-
-        self.db = SqliteDatabase(None)
-        self.db.init(
-            str(self.search_db_file),
-            pragmas={
-                "journal_mode": "wal",
-                "cache_size": -1 * 64000,  # 64MB
-                "foreign_keys": 1,
-                "ignore_check_constraints": 0,
-                "synchronous": 0,
-            },
-            timeout=15,
+        include_search_tables = any(
+            (
+                self.search_missing,
+                self.do_upgrade_search,
+                self.quality_unmet_search,
+                self.custom_format_unmet_search,
+                self.ombi_search_requests,
+                self.overseerr_requests,
+            )
         )
+        include_series = self.type == "sonarr" and self.series_search
+        include_torrents = TAGLESS
 
-        class Files(db1):
-            class Meta:
-                database = self.db
-
-        class Queue(db2):
-            class Meta:
-                database = self.db
-
-        class PersistingQueue(FilesQueued):
-            class Meta:
-                database = self.db
-
-        self.db.connect()
-        if db3:
-
-            class Series(db3):
-                class Meta:
-                    database = self.db
+        self.db = get_database()
 
-            self.db.create_tables([Files, Queue, PersistingQueue, Series])
-            self.series_file_model = Series
-        else:
-            self.db.create_tables([Files, Queue, PersistingQueue])
-
-        if db4:
-            self.torrent_db = SqliteDatabase(None)
-            self.torrent_db.init(
-                str(self._app_data_folder.joinpath("Torrents.db")),
-                pragmas={
-                    "journal_mode": "wal",
-                    "cache_size": -1 * 64000,  # 64MB
-                    "foreign_keys": 1,
-                    "ignore_check_constraints": 0,
-                    "synchronous": 0,
-                },
-                timeout=15,
+        if include_search_tables:
+            tables = create_arr_tables(
+                self._name,
+                self.type,
+                include_series=include_series,
+                include_torrents=include_torrents,
             )
-
-            class Torrents(db4):
-                class Meta:
-                    database = self.torrent_db
-
-            self.torrent_db.connect()
-            self.torrent_db.create_tables([Torrents])
-            self.torrents = Torrents
+            self.model_file = tables.files
+            self.model_queue = tables.queue
+            self.persistent_queue = tables.persisting_queue
+            self.series_file_model = tables.series
+            self.torrents = tables.torrents
         else:
-            self.torrents: TorrentLibrary = None
+            self.model_file = None
+            self.model_queue = None
+            self.persistent_queue = None
+            self.series_file_model = None
+            if include_torrents:
+                ensure_table_schema(TorrentLibrary)
+                self.torrents = TorrentLibrary
+            else:
+                self.torrents = None
 
-        self.model_file = Files
-        self.model_queue = Queue
-        self.persistent_queue = PersistingQueue
         self.search_setup_completed = True
 
     def run_request_search(self):
@@ -5567,6 +5456,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,8 +5471,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
         if FREE_SPACE_FOLDER == "CHANGE_ME":
@@ -5602,9 +5490,13 @@ class FreeSpaceManager(Arr):
         self.logger.trace("Current free space: %s", self.current_free_space)
         self.manager.qbit_manager.client.torrents_create_tags(["qBitrr-free_space_paused"])
         self.search_missing = False
+        self.do_upgrade_search = False
+        self.quality_unmet_search = False
+        self.custom_format_unmet_search = False
+        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.last_search_description: str | None = None
         self.last_search_timestamp: str | None = None
@@ -5613,28 +5505,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")
-                and self.torrent_db
-                and not self.torrent_db.is_closed()
-                and self.torrent_db.close()
-            )
-        )
-
-    def _get_models(
-        self,
-    ) -> tuple[
-        None,
-        None,
-        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):
         self.logger.info(

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.1"
-git_hash = "9c461f7"
+version = "5.1.0"
+git_hash = "048cc3f"
 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,9 @@ 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.tables import ensure_core_tables, get_database, purge_database_files
+from qBitrr.utils import ExpiringSet
+from qBitrr.versioning import fetch_latest_release
 from qBitrr.webui import WebUI
 
 if CONFIG_EXISTS:
@@ -101,6 +103,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 +119,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 +153,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 +490,17 @@ 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)
+def initialize_database() -> None:
+    try:
+        purge_database_files()
+        get_database()
+        ensure_core_tables()
+    except Exception:
+        logger.exception("Failed to initialize database schema")
+        raise
 
 
 if __name__ == "__main__":
     freeze_support()
-    file_cleanup()
+    initialize_database()
     run()

qBitrr/search_activity_store.py

@@ -3,60 +3,34 @@ from __future__ import annotations
 from threading import RLock
 from typing import Any
 
-from peewee import Model, SqliteDatabase, TextField
+from peewee import SqliteDatabase
 
-from qBitrr.home_path import APPDATA_FOLDER
+from qBitrr.tables import SearchActivity, ensure_table_schema, get_database
 
 _DB_LOCK = RLock()
-_DB_INSTANCE: SqliteDatabase | None = None
+_TABLE_READY = False
 
 
-def _get_database() -> SqliteDatabase:
-    global _DB_INSTANCE
-    if _DB_INSTANCE is None:
-        path = APPDATA_FOLDER.joinpath("webui_activity.db")
-        path.parent.mkdir(parents=True, exist_ok=True)
-        _DB_INSTANCE = SqliteDatabase(
-            str(path),
-            pragmas={
-                "journal_mode": "wal",
-                "cache_size": -64_000,
-                "foreign_keys": 1,
-                "ignore_check_constraints": 0,
-                "synchronous": 0,
-            },
-            timeout=15,
-            check_same_thread=False,
-        )
-    return _DB_INSTANCE
-
-
-class BaseModel(Model):
-    class Meta:
-        database = _get_database()
-
-
-class SearchActivity(BaseModel):
-    category = TextField(primary_key=True)
-    summary = TextField(null=True)
-    timestamp = TextField(null=True)
-
-
-def _ensure_tables() -> None:
-    db = _get_database()
+def _ensure_ready() -> SqliteDatabase:
+    global _TABLE_READY
+    db = get_database()
+    if _TABLE_READY:
+        return db
     with _DB_LOCK:
-        db.connect(reuse_if_open=True)
-        db.create_tables([SearchActivity], safe=True)
+        if not _TABLE_READY:
+            ensure_table_schema(SearchActivity)
+            _TABLE_READY = True
+    return db
 
 
 def record_search_activity(category: str, summary: str | None, timestamp: str | None) -> None:
     if not category:
         return
-    _ensure_tables()
+    db = _ensure_ready()
     if timestamp is not None and not isinstance(timestamp, str):
         timestamp = str(timestamp)
     data: dict[str, Any] = {"summary": summary, "timestamp": timestamp}
-    with _get_database().atomic():
+    with db.atomic():
         SearchActivity.insert(category=category, **data).on_conflict(
             conflict_target=[SearchActivity.category],
             update=data,
@@ -64,9 +38,8 @@ def record_search_activity(category: str, summary: str | None, timestamp: str |
 
 
 def fetch_search_activities() -> dict[str, dict[str, str | None]]:
-    _ensure_tables()
+    db = _ensure_ready()
     activities: dict[str, dict[str, str | None]] = {}
-    db = _get_database()
     db.connect(reuse_if_open=True)
     try:
         query = SearchActivity.select()
@@ -83,6 +56,6 @@ def fetch_search_activities() -> dict[str, dict[str, str | None]]:
 def clear_search_activity(category: str) -> None:
     if not category:
         return
-    _ensure_tables()
-    with _get_database().atomic():
+    db = _ensure_ready()
+    with db.atomic():
         SearchActivity.delete().where(SearchActivity.category == category).execute()

qBitrr/tables.py

@@ -1,11 +1,229 @@
-from peewee import BooleanField, CharField, DateTimeField, IntegerField, Model, TextField
+from __future__ import annotations
 
+import logging
+import re
+from functools import lru_cache
+from pathlib import Path
+from typing import NamedTuple
 
-class FilesQueued(Model):
+from peewee import (
+    BooleanField,
+    CharField,
+    DatabaseError,
+    DatabaseProxy,
+    DateTimeField,
+    IntegerField,
+    Model,
+    OperationalError,
+    SqliteDatabase,
+    TextField,
+)
+
+from qBitrr.db_lock import database_lock
+from qBitrr.home_path import APPDATA_FOLDER
+
+logger = logging.getLogger("qBitrr.Database")
+
+DATABASE_FILE = APPDATA_FOLDER.joinpath("qbitrr.db")
+_database_proxy: DatabaseProxy = DatabaseProxy()
+_DATABASE: SqliteDatabase | None = None
+_DB_ARTIFACT_SUFFIXES: tuple[str, ...] = ("", "-wal", "-shm")
+
+
+class LockedSqliteDatabase(SqliteDatabase):
+    def connect(self, **kwargs):
+        with database_lock():
+            return super().connect(**kwargs)
+
+    def close(self):
+        with database_lock():
+            return super().close()
+
+    def execute_sql(self, *args, **kwargs):
+        with database_lock():
+            return super().execute_sql(*args, **kwargs)
+
+
+def _database_artifact_paths() -> tuple[Path, ...]:
+    return tuple(
+        DATABASE_FILE if suffix == "" else DATABASE_FILE.with_name(f"{DATABASE_FILE.name}{suffix}")
+        for suffix in _DB_ARTIFACT_SUFFIXES
+    )
+
+
+def purge_database_files() -> list[Path]:
+    removed: list[Path] = []
+    with database_lock():
+        for candidate in _database_artifact_paths():
+            try:
+                candidate.unlink()
+                removed.append(candidate)
+            except FileNotFoundError:
+                continue
+            except OSError as exc:
+                logger.warning("Unable to remove database artifact '%s': %s", candidate, exc)
+    if removed:
+        logger.info(
+            "Removed database artifacts: %s",
+            ", ".join(str(path) for path in removed),
+        )
+    return removed
+
+
+def _reset_database(exc: BaseException) -> None:
+    global _DATABASE
+    logger.warning("Database reset triggered after failure: %s", exc)
+    with database_lock():
+        try:
+            if _DATABASE is not None and not _DATABASE.is_closed():
+                _DATABASE.close()
+        except Exception as close_error:  # pragma: no cover - best effort cleanup
+            logger.debug("Error closing database while resetting: %s", close_error)
+        _DATABASE = None
+        purge_database_files()
+
+
+class BaseModel(Model):
+    class Meta:
+        database = _database_proxy
+
+
+def get_database(*, _retry: bool = True) -> SqliteDatabase:
+    global _DATABASE
+    if _DATABASE is None:
+        DATABASE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        _DATABASE = LockedSqliteDatabase(
+            str(DATABASE_FILE),
+            pragmas={
+                "journal_mode": "wal",
+                "cache_size": -64_000,
+                "foreign_keys": 1,
+                "ignore_check_constraints": 0,
+                "synchronous": "NORMAL",
+                "busy_timeout": 60_000,
+            },
+            timeout=15,
+            check_same_thread=False,
+            autocommit=True,
+        )
+        _database_proxy.initialize(_DATABASE)
+    try:
+        _DATABASE.connect(reuse_if_open=True)
+    except DatabaseError as exc:
+        if not _retry:
+            raise
+        _reset_database(exc)
+        return get_database(_retry=False)
+    return _DATABASE
+
+
+def ensure_table_schema(model: type[BaseModel]) -> None:
+    database = get_database()
+    table_name = model._meta.table_name
+    with database:
+        database.create_tables([model], safe=True)
+        existing_columns = {column.name for column in database.get_columns(table_name)}
+        try:
+            primary_keys = {column.lower() for column in database.get_primary_keys(table_name)}
+        except OperationalError:
+            primary_keys = set()
+        try:
+            index_metadata = database.get_indexes(table_name)
+        except OperationalError:
+            index_metadata = []
+
+        def _refresh_indexes() -> None:
+            nonlocal index_metadata
+            try:
+                index_metadata = database.get_indexes(table_name)
+            except OperationalError:
+                index_metadata = []
+
+        def _has_unique(column: str) -> bool:
+            lower_column = column.lower()
+            for index in index_metadata:
+                if not index.unique:
+                    continue
+                normalized = tuple(col.lower() for col in index.columns or ())
+                if normalized == (lower_column,):
+                    return True
+            return False
+
+        def _deduplicate(column: str) -> None:
+            try:
+                duplicates = database.execute_sql(
+                    f"""
+                    SELECT {column}, MIN(rowid) AS keep_rowid
+                    FROM {table_name}
+                    WHERE {column} IS NOT NULL
+                    GROUP BY {column}
+                    HAVING COUNT(*) > 1
+                    """
+                ).fetchall()
+            except OperationalError:
+                return
+            if not duplicates:
+                return
+            for value, keep_rowid in duplicates:
+                try:
+                    database.execute_sql(
+                        f"""
+                        DELETE FROM {table_name}
+                        WHERE {column} = ?
+                        AND rowid != ?
+                        """,
+                        (value, keep_rowid),
+                    )
+                except OperationalError:
+                    logger.warning(
+                        "Failed to deduplicate rows on %s.%s for value %s",
+                        table_name,
+                        column,
+                        value,
+                    )
+            if duplicates:
+                logger.info(
+                    "Deduplicated %s entries on %s.%s to restore unique constraint",
+                    len(duplicates),
+                    table_name,
+                    column,
+                )
+
+        def _ensure_unique(column: str) -> None:
+            if _has_unique(column):
+                return
+            _deduplicate(column)
+            try:
+                index_name = f"{table_name}_{column}_uniq".replace(".", "_")
+                database.execute_sql(
+                    f'CREATE UNIQUE INDEX IF NOT EXISTS "{index_name}" '
+                    f'ON "{table_name}" ("{column}")'
+                )
+                _refresh_indexes()
+            except OperationalError:
+                logger.warning(
+                    "Unable to create unique index on %s.%s; uniqueness guarantees may be missing",
+                    table_name,
+                    column,
+                )
+                return
+            _refresh_indexes()
+
+        for field in model._meta.sorted_fields:
+            column_name = field.column_name
+            if column_name not in existing_columns:
+                database.add_column(table_name, column_name, field)
+            if field.primary_key and column_name.lower() not in primary_keys:
+                _ensure_unique(column_name)
+            elif field.unique:
+                _ensure_unique(column_name)
+
+
+class FilesQueued(BaseModel):
     EntryId = IntegerField(primary_key=True, null=False, unique=True)
 
 
-class MoviesFilesModel(Model):
+class MoviesFilesModel(BaseModel):
     Title = CharField()
     Monitored = BooleanField()
     TmdbId = IntegerField()
@@ -22,7 +240,7 @@ class MoviesFilesModel(Model):
     Reason = TextField(null=True)
 
 
-class EpisodeFilesModel(Model):
+class EpisodeFilesModel(BaseModel):
     EntryId = IntegerField(primary_key=True)
     SeriesTitle = TextField(null=True)
     Title = TextField(null=True)
@@ -44,7 +262,7 @@ class EpisodeFilesModel(Model):
     Reason = TextField(null=True)
 
 
-class SeriesFilesModel(Model):
+class SeriesFilesModel(BaseModel):
     EntryId = IntegerField(primary_key=True)
     Title = TextField(null=True)
     Monitored = BooleanField(null=True)
@@ -53,20 +271,119 @@ class SeriesFilesModel(Model):
     MinCustomFormatScore = IntegerField(null=True)
 
 
-class MovieQueueModel(Model):
+class MovieQueueModel(BaseModel):
     EntryId = IntegerField(unique=True)
     Completed = BooleanField(default=False)
 
 
-class EpisodeQueueModel(Model):
+class EpisodeQueueModel(BaseModel):
     EntryId = IntegerField(unique=True)
     Completed = BooleanField(default=False)
 
 
-class TorrentLibrary(Model):
+class TorrentLibrary(BaseModel):
     Hash = TextField(null=False)
     Category = TextField(null=False)
     AllowedSeeding = BooleanField(default=False)
     Imported = BooleanField(default=False)
     AllowedStalled = BooleanField(default=False)
     FreeSpacePaused = BooleanField(default=False)
+
+    class Meta:
+        table_name = "torrent_library"
+
+
+class SearchActivity(BaseModel):
+    category = TextField(primary_key=True)
+    summary = TextField(null=True)
+    timestamp = TextField(null=True)
+
+    class Meta:
+        table_name = "search_activity"
+
+
+class ArrTables(NamedTuple):
+    files: type[BaseModel]
+    queue: type[BaseModel]
+    series: type[BaseModel] | None
+    persisting_queue: type[BaseModel]
+    torrents: type[BaseModel] | None
+
+
+_SAFE_IDENTIFIER = re.compile(r"[^0-9A-Za-z_]+")
+
+
+def _sanitize_identifier(name: str) -> str:
+    token = name.strip().replace(" ", "_")
+    token = _SAFE_IDENTIFIER.sub("_", token)
+    token = token.strip("_")
+    if not token:
+        token = "Arr"
+    if token[0].isdigit():
+        token = f"Arr_{token}"
+    return token
+
+
+@lru_cache(maxsize=None)
+def create_arr_tables(
+    arr_name: str,
+    arr_type: str,
+    *,
+    include_series: bool,
+    include_torrents: bool,
+) -> ArrTables:
+    table_prefix = _sanitize_identifier(arr_name)
+    files_base: type[BaseModel]
+    queue_base: type[BaseModel]
+    if arr_type.lower() == "sonarr":
+        files_base = EpisodeFilesModel
+        queue_base = EpisodeQueueModel
+    elif arr_type.lower() == "radarr":
+        files_base = MoviesFilesModel
+        queue_base = MovieQueueModel
+    else:
+        raise ValueError(f"Unknown arr_type '{arr_type}'")
+
+    class Files(files_base):
+        class Meta:
+            table_name = f"{table_prefix}_files"
+
+    class Queue(queue_base):
+        class Meta:
+            table_name = f"{table_prefix}_queue"
+
+    class PersistingQueue(FilesQueued):
+        class Meta:
+            table_name = f"{table_prefix}_persisting_queue"
+
+    series_model: type[BaseModel] | None = None
+    if include_series:
+
+        class Series(SeriesFilesModel):
+            class Meta:
+                table_name = f"{table_prefix}_series"
+
+        series_model = Series
+
+    torrents_model: type[BaseModel] | None = TorrentLibrary if include_torrents else None
+
+    ensure_table_schema(Files)
+    ensure_table_schema(Queue)
+    ensure_table_schema(PersistingQueue)
+    if series_model is not None:
+        ensure_table_schema(series_model)
+    if torrents_model is not None:
+        ensure_table_schema(torrents_model)
+
+    return ArrTables(
+        files=Files,
+        queue=Queue,
+        series=series_model,
+        persisting_queue=PersistingQueue,
+        torrents=torrents_model,
+    )
+
+
+def ensure_core_tables() -> None:
+    ensure_table_schema(TorrentLibrary)
+    ensure_table_schema(SearchActivity)

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.1.dist-info → qbitrr2-5.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qBitrr2
-Version: 5.0.1
+Version: 5.1.0
 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:
@@ -154,6 +157,8 @@ services:
     restart: unless-stopped
     environment:
       TZ: Europe/London
+    ports:
+      - "6969:6969"
     volumes:
       - /etc/localtime:/etc/localtime:ro
       - /path/to/appdata/qbitrr:/config

qbitrr2-5.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+qBitrr/__init__.py,sha256=smiPIV7d2lMJ_KTtFdAVlxLEBobFTheILdgry1iqpjQ,405
+qBitrr/arss.py,sha256=sxxO19PyD5bR1-K8k87pgQWtgXghzSggVJXkbuExU3c,258843
+qBitrr/auto_update.py,sha256=hVAvAlKEdOHm6AJLlKvtkklbQhjotVcFOCH-MTigHQM,4419
+qBitrr/bundled_data.py,sha256=oP177OBkkhh_wXSpvQnW-oH46iGPEACBHC2myahMkGE,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=FdW3sNLUR2WAeOCMB_1XCg1E9az_qg_5SqXORNilXgg,19340
+qBitrr/search_activity_store.py,sha256=NZFLIhnHYst9-vIWVN9on2yRRd0eYyTDd5Uye6slbsw,1704
+qBitrr/tables.py,sha256=0i7oTSUaPk3qbmBAGzawxbQo4bL04YpLDGQ0G3-fBeo,12133
+qBitrr/utils.py,sha256=DEnkQrbXFPWunhzId0OE6_oWuUTd5V4aDCZ2yHdrvo0,7306
+qBitrr/versioning.py,sha256=k3n8cOh1E5mevN8OkYWOA3110PuOajMOpGyCKy3rFEc,2279
+qBitrr/webui.py,sha256=HaM3w-rzuvVyGtphRCROY2GDXZtRmny3blkC5WoTOSk,68298
+qbitrr2-5.1.0.dist-info/licenses/LICENSE,sha256=P978aVGi7dPbKz8lfvdiryOS5IjTAU7AA47XhBhVBlI,1066
+qbitrr2-5.1.0.dist-info/METADATA,sha256=HZW0rN-GBfN2nVhoBTELsSJAHG6szM9M9QWlByr3-SI,10122
+qbitrr2-5.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qbitrr2-5.1.0.dist-info/entry_points.txt,sha256=MIR-l5s31VBs9qlv3HiAaMdpOOyy0MNGfM7Ib1-fKeQ,43
+qbitrr2-5.1.0.dist-info/top_level.txt,sha256=jIINodarzsPcQeTf-vvK8-_g7cQ8CvxEg41ms14K97g,7
+qbitrr2-5.1.0.dist-info/RECORD,,

qbitrr2-5.0.1.dist-info/RECORD

@@ -1,22 +0,0 @@
-qBitrr/__init__.py,sha256=smiPIV7d2lMJ_KTtFdAVlxLEBobFTheILdgry1iqpjQ,405
-qBitrr/arss.py,sha256=83YtsaUoOp5ICyRopvjT4wUHUPWWPMbNg6t2CC5ZxFc,263238
-qBitrr/auto_update.py,sha256=faHYeJ9GsSmz5XfOt6Uq3fZOeEmqZ20MMUotKtq9M7s,4256
-qBitrr/bundled_data.py,sha256=jQbC0u8PvjasHFnKzjvDz_oMRBrzaI6YCb4SJIUJcFU,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.1.dist-info/licenses/LICENSE,sha256=P978aVGi7dPbKz8lfvdiryOS5IjTAU7AA47XhBhVBlI,1066
-qbitrr2-5.0.1.dist-info/METADATA,sha256=si636Z-gpFrpBtMcwYx5zB3D2XqIGX3sfEWtDEHHmWQ,9943
-qbitrr2-5.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-qbitrr2-5.0.1.dist-info/entry_points.txt,sha256=MIR-l5s31VBs9qlv3HiAaMdpOOyy0MNGfM7Ib1-fKeQ,43
-qbitrr2-5.0.1.dist-info/top_level.txt,sha256=jIINodarzsPcQeTf-vvK8-_g7cQ8CvxEg41ms14K97g,7
-qbitrr2-5.0.1.dist-info/RECORD,,