qBitrr2 5.1.0__tar.gz → 5.1.1__tar.gz

{qbitrr2-5.1.0/qBitrr2.egg-info → qbitrr2-5.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qBitrr2
-Version: 5.1.0
+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

{qbitrr2-5.1.0 → qbitrr2-5.1.1}/pyproject.toml

@@ -28,7 +28,7 @@ target-version = ['py312']
 
 [tool.poetry]
 name = "pypi-public"
-version = "5.1.0"
+version = "5.1.1"
 description = "A simple script to monitor qBit and communicate with Radarr and Sonarr"
 authors = ["Drapersniper", "Feramance"]
 readme = "README.md"

{qbitrr2-5.1.0 → qbitrr2-5.1.1}/qBitrr/arss.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import atexit
 import contextlib
 import itertools
 import logging
@@ -19,7 +20,7 @@ import qbittorrentapi
 import qbittorrentapi.exceptions
 import requests
 from packaging import version as version_parser
-from peewee import Model
+from peewee import Model, SqliteDatabase
 from pyarr import RadarrAPI, SonarrAPI
 from pyarr.exceptions import PyarrResourceNotFound, PyarrServerError
 from pyarr.types import JsonObject
@@ -27,6 +28,7 @@ from qbittorrentapi import TorrentDictionary, TorrentStates
 from ujson import JSONDecodeError
 
 from qBitrr.config import (
+    APPDATA_FOLDER,
     AUTO_PAUSE_RESUME,
     COMPLETED_DOWNLOAD_FOLDER,
     CONFIG,
@@ -55,7 +57,15 @@ from qBitrr.search_activity_store import (
     fetch_search_activities,
     record_search_activity,
 )
-from qBitrr.tables import TorrentLibrary, create_arr_tables, ensure_table_schema, get_database
+from qBitrr.tables import (
+    EpisodeFilesModel,
+    EpisodeQueueModel,
+    FilesQueued,
+    MovieQueueModel,
+    MoviesFilesModel,
+    SeriesFilesModel,
+    TorrentLibrary,
+)
 from qBitrr.utils import (
     ExpiringSet,
     absolute_file_paths,
@@ -293,6 +303,9 @@ class Arr:
         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
         )
@@ -559,9 +572,24 @@ class Arr:
         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()
+        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
@@ -4795,46 +4823,139 @@ class Arr:
         if self.search_setup_completed:
             return
 
-        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,
-            )
+        db1, db2, db3, db4 = self._get_models()
+
+        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": -64_000,
+                        "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.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": -64_000,
+                "foreign_keys": 1,
+                "ignore_check_constraints": 0,
+                "synchronous": 0,
+            },
+            timeout=15,
         )
-        include_series = self.type == "sonarr" and self.series_search
-        include_torrents = TAGLESS
 
-        self.db = get_database()
+        class Files(db1):
+            class Meta:
+                database = self.db
 
-        if include_search_tables:
-            tables = create_arr_tables(
-                self._name,
-                self.type,
-                include_series=include_series,
-                include_torrents=include_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
+        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.create_tables([Files, Queue, PersistingQueue, Series])
+            self.series_file_model = Series
         else:
-            self.model_file = None
-            self.model_queue = None
-            self.persistent_queue = None
+            self.db.create_tables([Files, Queue, PersistingQueue])
             self.series_file_model = None
-            if include_torrents:
-                ensure_table_schema(TorrentLibrary)
-                self.torrents = TorrentLibrary
-            else:
-                self.torrents = None
 
+        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": -64_000,
+                    "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
+        else:
+            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 (
             (
@@ -5471,6 +5592,7 @@ class FreeSpaceManager(Arr):
         )
         self.timed_ignore_cache = ExpiringSet(max_age_seconds=self.ignore_torrents_younger_than)
         self.needs_cleanup = False
+        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":
@@ -5498,6 +5620,7 @@ class FreeSpaceManager(Arr):
         self.session = None
         # 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
@@ -5505,6 +5628,24 @@ class FreeSpaceManager(Arr):
         self.free_space_tagged_count: int = 0
         self.register_search_mode()
         self.logger.hnotice("Starting %s monitor", self._name)
+        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,
+    ]:
+        return None, None, None, (TorrentLibrary if TAGLESS else None)
 
     def _process_single_torrent_pause_disk_space(self, torrent: qbittorrentapi.TorrentDictionary):
         self.logger.info(

{qbitrr2-5.1.0 → qbitrr2-5.1.1}/qBitrr/bundled_data.py

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

{qbitrr2-5.1.0 → qbitrr2-5.1.1}/qBitrr/main.py

@@ -32,7 +32,6 @@ from qBitrr.config import (
 from qBitrr.env_config import ENVIRO_CONFIG
 from qBitrr.ffprobe import FFprobeDownloader
 from qBitrr.logger import run_logs
-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
@@ -490,17 +489,6 @@ def run():
             child.kill()
 
 
-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()
-    initialize_database()
     run()

qbitrr2-5.1.1/qBitrr/search_activity_store.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from threading import RLock
+from typing import Any
+
+from peewee import Model, SqliteDatabase, TextField
+
+from qBitrr.home_path import APPDATA_FOLDER
+
+_DB_LOCK = RLock()
+_DB_INSTANCE: SqliteDatabase | None = None
+
+
+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()
+    with _DB_LOCK:
+        db.connect(reuse_if_open=True)
+        db.create_tables([SearchActivity], safe=True)
+
+
+def record_search_activity(category: str, summary: str | None, timestamp: str | None) -> None:
+    if not category:
+        return
+    _ensure_tables()
+    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():
+        SearchActivity.insert(category=category, **data).on_conflict(
+            conflict_target=[SearchActivity.category],
+            update=data,
+        ).execute()
+
+
+def fetch_search_activities() -> dict[str, dict[str, str | None]]:
+    _ensure_tables()
+    activities: dict[str, dict[str, str | None]] = {}
+    db = _get_database()
+    db.connect(reuse_if_open=True)
+    try:
+        query = SearchActivity.select()
+    except Exception:
+        return activities
+    for row in query:
+        activities[str(row.category)] = {
+            "summary": row.summary,
+            "timestamp": row.timestamp,
+        }
+    return activities
+
+
+def clear_search_activity(category: str) -> None:
+    if not category:
+        return
+    _ensure_tables()
+    with _get_database().atomic():
+        SearchActivity.delete().where(SearchActivity.category == category).execute()

qbitrr2-5.1.1/qBitrr/tables.py

@@ -0,0 +1,72 @@
+from peewee import BooleanField, CharField, DateTimeField, IntegerField, Model, TextField
+
+
+class FilesQueued(Model):
+    EntryId = IntegerField(primary_key=True, null=False, unique=True)
+
+
+class MoviesFilesModel(Model):
+    Title = CharField()
+    Monitored = BooleanField()
+    TmdbId = IntegerField()
+    Year = IntegerField()
+    EntryId = IntegerField(unique=True)
+    Searched = BooleanField(default=False)
+    MovieFileId = IntegerField()
+    IsRequest = BooleanField(default=False)
+    QualityMet = BooleanField(default=False)
+    Upgrade = BooleanField(default=False)
+    CustomFormatScore = IntegerField(null=True)
+    MinCustomFormatScore = IntegerField(null=True)
+    CustomFormatMet = BooleanField(default=False)
+    Reason = TextField(null=True)
+
+
+class EpisodeFilesModel(Model):
+    EntryId = IntegerField(primary_key=True)
+    SeriesTitle = TextField(null=True)
+    Title = TextField(null=True)
+    SeriesId = IntegerField(null=False)
+    EpisodeFileId = IntegerField(null=True)
+    EpisodeNumber = IntegerField(null=False)
+    SeasonNumber = IntegerField(null=False)
+    AbsoluteEpisodeNumber = IntegerField(null=True)
+    SceneAbsoluteEpisodeNumber = IntegerField(null=True)
+    AirDateUtc = DateTimeField(formats=["%Y-%m-%d %H:%M:%S.%f"], null=True)
+    Monitored = BooleanField(null=True)
+    Searched = BooleanField(default=False)
+    IsRequest = BooleanField(default=False)
+    QualityMet = BooleanField(default=False)
+    Upgrade = BooleanField(default=False)
+    CustomFormatScore = IntegerField(null=True)
+    MinCustomFormatScore = IntegerField(null=True)
+    CustomFormatMet = BooleanField(default=False)
+    Reason = TextField(null=True)
+
+
+class SeriesFilesModel(Model):
+    EntryId = IntegerField(primary_key=True)
+    Title = TextField(null=True)
+    Monitored = BooleanField(null=True)
+    Searched = BooleanField(default=False)
+    Upgrade = BooleanField(default=False)
+    MinCustomFormatScore = IntegerField(null=True)
+
+
+class MovieQueueModel(Model):
+    EntryId = IntegerField(unique=True)
+    Completed = BooleanField(default=False)
+
+
+class EpisodeQueueModel(Model):
+    EntryId = IntegerField(unique=True)
+    Completed = BooleanField(default=False)
+
+
+class TorrentLibrary(Model):
+    Hash = TextField(null=False)
+    Category = TextField(null=False)
+    AllowedSeeding = BooleanField(default=False)
+    Imported = BooleanField(default=False)
+    AllowedStalled = BooleanField(default=False)
+    FreeSpacePaused = BooleanField(default=False)

{qbitrr2-5.1.0 → qbitrr2-5.1.1/qBitrr2.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qBitrr2
-Version: 5.1.0
+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

{qbitrr2-5.1.0 → qbitrr2-5.1.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = qBitrr2
-version = 5.1.0
+version = 5.1.1
 description = "A simple Python script to talk to qBittorrent and Arr's"
 long_description = file: README.md
 long_description_content_type = text/markdown

qbitrr2-5.1.0/qBitrr/search_activity_store.py

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-from threading import RLock
-from typing import Any
-
-from peewee import SqliteDatabase
-
-from qBitrr.tables import SearchActivity, ensure_table_schema, get_database
-
-_DB_LOCK = RLock()
-_TABLE_READY = False
-
-
-def _ensure_ready() -> SqliteDatabase:
-    global _TABLE_READY
-    db = get_database()
-    if _TABLE_READY:
-        return db
-    with _DB_LOCK:
-        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
-    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 db.atomic():
-        SearchActivity.insert(category=category, **data).on_conflict(
-            conflict_target=[SearchActivity.category],
-            update=data,
-        ).execute()
-
-
-def fetch_search_activities() -> dict[str, dict[str, str | None]]:
-    db = _ensure_ready()
-    activities: dict[str, dict[str, str | None]] = {}
-    db.connect(reuse_if_open=True)
-    try:
-        query = SearchActivity.select()
-    except Exception:
-        return activities
-    for row in query:
-        activities[str(row.category)] = {
-            "summary": row.summary,
-            "timestamp": row.timestamp,
-        }
-    return activities
-
-
-def clear_search_activity(category: str) -> None:
-    if not category:
-        return
-    db = _ensure_ready()
-    with db.atomic():
-        SearchActivity.delete().where(SearchActivity.category == category).execute()

qbitrr2-5.1.0/qBitrr/tables.py

@@ -1,389 +0,0 @@
-from __future__ import annotations
-
-import logging
-import re
-from functools import lru_cache
-from pathlib import Path
-from typing import NamedTuple
-
-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(BaseModel):
-    Title = CharField()
-    Monitored = BooleanField()
-    TmdbId = IntegerField()
-    Year = IntegerField()
-    EntryId = IntegerField(unique=True)
-    Searched = BooleanField(default=False)
-    MovieFileId = IntegerField()
-    IsRequest = BooleanField(default=False)
-    QualityMet = BooleanField(default=False)
-    Upgrade = BooleanField(default=False)
-    CustomFormatScore = IntegerField(null=True)
-    MinCustomFormatScore = IntegerField(null=True)
-    CustomFormatMet = BooleanField(default=False)
-    Reason = TextField(null=True)
-
-
-class EpisodeFilesModel(BaseModel):
-    EntryId = IntegerField(primary_key=True)
-    SeriesTitle = TextField(null=True)
-    Title = TextField(null=True)
-    SeriesId = IntegerField(null=False)
-    EpisodeFileId = IntegerField(null=True)
-    EpisodeNumber = IntegerField(null=False)
-    SeasonNumber = IntegerField(null=False)
-    AbsoluteEpisodeNumber = IntegerField(null=True)
-    SceneAbsoluteEpisodeNumber = IntegerField(null=True)
-    AirDateUtc = DateTimeField(formats=["%Y-%m-%d %H:%M:%S.%f"], null=True)
-    Monitored = BooleanField(null=True)
-    Searched = BooleanField(default=False)
-    IsRequest = BooleanField(default=False)
-    QualityMet = BooleanField(default=False)
-    Upgrade = BooleanField(default=False)
-    CustomFormatScore = IntegerField(null=True)
-    MinCustomFormatScore = IntegerField(null=True)
-    CustomFormatMet = BooleanField(default=False)
-    Reason = TextField(null=True)
-
-
-class SeriesFilesModel(BaseModel):
-    EntryId = IntegerField(primary_key=True)
-    Title = TextField(null=True)
-    Monitored = BooleanField(null=True)
-    Searched = BooleanField(default=False)
-    Upgrade = BooleanField(default=False)
-    MinCustomFormatScore = IntegerField(null=True)
-
-
-class MovieQueueModel(BaseModel):
-    EntryId = IntegerField(unique=True)
-    Completed = BooleanField(default=False)
-
-
-class EpisodeQueueModel(BaseModel):
-    EntryId = IntegerField(unique=True)
-    Completed = BooleanField(default=False)
-
-
-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)