qBitrr2 5.1.1__py3-none-any.whl → 5.2.0__py3-none-any.whl

qBitrr/arss.py

@@ -312,7 +312,14 @@ class Arr:
         self.overseerr_requests = CONFIG.get(
             f"{name}.EntrySearch.Overseerr.SearchOverseerrRequests", fallback=False
         )
-        self.series_search = CONFIG.get(f"{name}.EntrySearch.SearchBySeries", fallback=False)
+        # SearchBySeries can be: True (always series), False (always episode), or "smart" (automatic)
+        series_search_config = CONFIG.get(f"{name}.EntrySearch.SearchBySeries", fallback=False)
+        if isinstance(series_search_config, str) and series_search_config.lower() == "smart":
+            self.series_search = "smart"
+        elif series_search_config in (True, "true", "True", "TRUE", 1):
+            self.series_search = True
+        else:
+            self.series_search = False
         if self.ombi_search_requests:
             self.ombi_uri = CONFIG.get_or_raise(f"{name}.EntrySearch.Ombi.OmbiURI")
             self.ombi_api_key = CONFIG.get_or_raise(f"{name}.EntrySearch.Ombi.OmbiAPIKey")
@@ -549,9 +556,12 @@ class Arr:
                 self.quality_unmet_search
                 or self.do_upgrade_search
                 or self.custom_format_unmet_search
-                or self.series_search
+                or self.series_search == True
             ):
                 self.search_api_command = "SeriesSearch"
+            elif self.series_search == "smart":
+                # In smart mode, the command will be determined dynamically
+                self.search_api_command = "SeriesSearch"  # Default, will be overridden per search
             else:
                 self.search_api_command = "MissingEpisodeSearch"
 
@@ -1499,11 +1509,55 @@ class Arr:
     ) -> Iterable[
         tuple[MoviesFilesModel | EpisodeFilesModel | SeriesFilesModel, bool, bool, bool, int]
     ]:
-        if self.type == "sonarr" and self.series_search:
+        if self.type == "sonarr" and self.series_search == True:
             serieslist = self.db_get_files_series()
             for series in serieslist:
                 yield series[0], series[1], series[2], series[2] is not True, len(serieslist)
-        elif self.type == "sonarr" and not self.series_search:
+        elif self.type == "sonarr" and self.series_search == "smart":
+            # Smart mode: decide dynamically based on what needs to be searched
+            episodelist = self.db_get_files_episodes()
+            if episodelist:
+                # Group episodes by series to determine if we should search by series or episode
+                series_episodes_map = {}
+                for episode_entry in episodelist:
+                    episode = episode_entry[0]
+                    series_id = episode.SeriesId
+                    if series_id not in series_episodes_map:
+                        series_episodes_map[series_id] = []
+                    series_episodes_map[series_id].append(episode_entry)
+
+                # Process each series
+                for series_id, episodes in series_episodes_map.items():
+                    if len(episodes) > 1:
+                        # Multiple episodes from same series - use series search (smart decision)
+                        self.logger.info(
+                            "[SMART MODE] Using series search for %s episodes from series ID %s",
+                            len(episodes),
+                            series_id,
+                        )
+                        # Create a series entry for searching
+                        series_model = (
+                            self.series_file_model.select()
+                            .where(self.series_file_model.EntryId == series_id)
+                            .first()
+                        )
+                        if series_model:
+                            yield series_model, episodes[0][1], episodes[0][2], True, len(
+                                episodelist
+                            )
+                    else:
+                        # Single episode - use episode search (smart decision)
+                        episode = episodes[0][0]
+                        self.logger.info(
+                            "[SMART MODE] Using episode search for single episode: %s S%02dE%03d",
+                            episode.SeriesTitle,
+                            episode.SeasonNumber,
+                            episode.EpisodeNumber,
+                        )
+                        yield episodes[0][0], episodes[0][1], episodes[0][2], False, len(
+                            episodelist
+                        )
+        elif self.type == "sonarr" and self.series_search == False:
             episodelist = self.db_get_files_episodes()
             for episodes in episodelist:
                 yield episodes[0], episodes[1], episodes[2], False, len(episodelist)
@@ -2842,7 +2896,7 @@ class Arr:
                             self.logger.debug(
                                 "Updating quality profile for %s to %s",
                                 db_entry["title"],
-                                self.temp_quality_profile_ids[db_entry["qualityProfileId"]],
+                                db_entry["qualityProfileId"],
                             )
                         while True:
                             try:

qBitrr/bundled_data.py

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

qBitrr/config.py

@@ -8,7 +8,7 @@ import sys
 
 from qBitrr.bundled_data import license_text, patched_version
 from qBitrr.env_config import ENVIRO_CONFIG
-from qBitrr.gen_config import MyConfig, _write_config_file, generate_doc
+from qBitrr.gen_config import MyConfig, _write_config_file, apply_config_migrations, generate_doc
 from qBitrr.home_path import APPDATA_FOLDER, HOME_PATH
 
 
@@ -105,6 +105,10 @@ if COPIED_TO_NEW_DIR is not None:
 else:
     print(f"STARTING QBITRR |  CONFIG_FILE={CONFIG_FILE} | CONFIG_PATH={CONFIG_PATH}")
 
+# Apply configuration migrations and validations
+if CONFIG_EXISTS:
+    apply_config_migrations(CONFIG)
+
 FFPROBE_AUTO_UPDATE = (
     CONFIG.get("Settings.FFprobeAutoUpdate", fallback=True)
     if ENVIRO_CONFIG.settings.ffprobe_auto_update is None

qBitrr/gen_config.py

@@ -14,6 +14,50 @@ from qBitrr.home_path import APPDATA_FOLDER, HOME_PATH
 T = TypeVar("T")
 
 
+def _add_web_settings_section(config: TOMLDocument):
+    web_settings = table()
+    _gen_default_line(
+        web_settings,
+        "WebUI listen host (default 0.0.0.0)",
+        "Host",
+        "0.0.0.0",
+    )
+    _gen_default_line(
+        web_settings,
+        "WebUI listen port (default 6969)",
+        "Port",
+        6969,
+    )
+    _gen_default_line(
+        web_settings,
+        [
+            "Optional bearer token to secure WebUI/API.",
+            "Set a non-empty value to require Authorization: Bearer <token>.",
+        ],
+        "Token",
+        "",
+    )
+    _gen_default_line(
+        web_settings,
+        "Enable live updates for Arr views",
+        "LiveArr",
+        True,
+    )
+    _gen_default_line(
+        web_settings,
+        "Group Sonarr episodes by series in views",
+        "GroupSonarr",
+        True,
+    )
+    _gen_default_line(
+        web_settings,
+        "WebUI theme (light or dark)",
+        "Theme",
+        "dark",
+    )
+    config.add("WebUI", web_settings)
+
+
 def generate_doc() -> TOMLDocument:
     config = document()
     config.add(
@@ -25,6 +69,7 @@ def generate_doc() -> TOMLDocument:
     config.add(comment('This is a config file should be moved to "' f'{HOME_PATH}".'))
     config.add(nl())
     _add_settings_section(config)
+    _add_web_settings_section(config)
     _add_qbit_section(config)
     _add_category_sections(config)
     return config
@@ -151,27 +196,6 @@ def _add_settings_section(config: TOMLDocument):
         "AutoUpdateCron",
         ENVIRO_CONFIG.settings.auto_update_cron or "0 3 * * 0",
     )
-    _gen_default_line(
-        settings,
-        "WebUI listen port (default 6969)",
-        "WebUIPort",
-        6969,
-    )
-    _gen_default_line(
-        settings,
-        "WebUI listen host (default 0.0.0.0)",
-        "WebUIHost",
-        "0.0.0.0",
-    )
-    _gen_default_line(
-        settings,
-        [
-            "Optional bearer token to secure WebUI/API.",
-            "Set a non-empty value to require Authorization: Bearer <token>.",
-        ],
-        "WebUIToken",
-        "",
-    )
     config.add("Settings", settings)
 
 
@@ -680,9 +704,13 @@ def _gen_default_search_table(category: str, cat_default: Table):
     if "sonarr" in category.lower():
         _gen_default_line(
             search_table,
-            "Search by series instead of by episode (This ignored the QualityUnmetSearch and CustomFormatUnmetSearch setting)",
+            [
+                "Search mode: true (always series search), false (always episode search), or 'smart' (automatic)",
+                "Smart mode: uses series search for entire seasons/series, episode search for single episodes",
+                "(Series search ignores QualityUnmetSearch and CustomFormatUnmetSearch settings)",
+            ],
             "SearchBySeries",
-            True,
+            "smart",
         )
         _gen_default_line(
             search_table,
@@ -813,6 +841,153 @@ class MyConfig:
         return values if values is not ... else default
 
 
+def _migrate_webui_config(config: MyConfig) -> bool:
+    """
+    Migrate WebUI configuration from old location (Settings section) to new location (WebUI section).
+    Returns True if any migration was performed, False otherwise.
+    """
+    migrated = False
+
+    # Check if WebUI section exists, if not create it
+    if "WebUI" not in config.config:
+        config.config["WebUI"] = table()
+
+    webui_section = config.config.get("WebUI", {})
+
+    # Migrate Host from Settings to WebUI
+    if "Host" not in webui_section:
+        old_host = config.get("Settings.Host", fallback=None)
+        if old_host is not None:
+            webui_section["Host"] = old_host
+            migrated = True
+            print(f"Migrated WebUI Host from Settings to WebUI section: {old_host}")
+
+    # Migrate Port from Settings to WebUI
+    if "Port" not in webui_section:
+        old_port = config.get("Settings.Port", fallback=None)
+        if old_port is not None:
+            webui_section["Port"] = old_port
+            migrated = True
+            print(f"Migrated WebUI Port from Settings to WebUI section: {old_port}")
+
+    # Migrate Token from Settings to WebUI
+    if "Token" not in webui_section:
+        old_token = config.get("Settings.Token", fallback=None)
+        if old_token is not None:
+            webui_section["Token"] = old_token
+            migrated = True
+            print(f"Migrated WebUI Token from Settings to WebUI section")
+
+    return migrated
+
+
+def _validate_and_fill_config(config: MyConfig) -> bool:
+    """
+    Validate configuration and fill in missing values with defaults.
+    Returns True if any changes were made, False otherwise.
+    """
+    changed = False
+    defaults = config.defaults_config
+
+    # Helper function to ensure a config section exists
+    def ensure_section(section_name: str) -> None:
+        """Ensure a config section exists."""
+        if section_name not in config.config:
+            config.config[section_name] = table()
+
+    # Helper function to check and fill config values
+    def ensure_value(config_section: str, key: str, default_value: Any) -> bool:
+        """Ensure a config value exists, setting to default if missing."""
+        ensure_section(config_section)
+        section = config.config[config_section]
+
+        if key not in section or section[key] is None:
+            # Get the value from defaults if available
+            default_section = defaults.get(config_section, {})
+            if default_section and key in default_section:
+                default = default_section[key]
+            else:
+                default = default_value
+            section[key] = default
+            return True
+        return False
+
+    # Validate Settings section
+    settings_defaults = [
+        ("ConsoleLevel", "INFO"),
+        ("Logging", True),
+        ("CompletedDownloadFolder", "CHANGE_ME"),
+        ("FreeSpace", "-1"),
+        ("FreeSpaceFolder", "CHANGE_ME"),
+        ("AutoPauseResume", True),
+        ("NoInternetSleepTimer", 15),
+        ("LoopSleepTimer", 5),
+        ("SearchLoopDelay", -1),
+        ("FailedCategory", "failed"),
+        ("RecheckCategory", "recheck"),
+        ("Tagless", False),
+        ("IgnoreTorrentsYoungerThan", 600),
+        ("PingURLS", ["one.one.one.one", "dns.google.com"]),
+        ("FFprobeAutoUpdate", True),
+        ("AutoUpdateEnabled", False),
+        ("AutoUpdateCron", "0 3 * * 0"),
+    ]
+
+    for key, default in settings_defaults:
+        if ensure_value("Settings", key, default):
+            changed = True
+
+    # Validate WebUI section
+    webui_defaults = [
+        ("Host", "0.0.0.0"),
+        ("Port", 6969),
+        ("Token", ""),
+        ("LiveArr", True),
+        ("GroupSonarr", True),
+        ("Theme", "dark"),
+    ]
+
+    for key, default in webui_defaults:
+        if ensure_value("WebUI", key, default):
+            changed = True
+
+    # Validate qBit section
+    qbit_defaults = [
+        ("Disabled", False),
+        ("Host", "localhost"),
+        ("Port", 8105),
+        ("UserName", ""),
+        ("Password", ""),
+    ]
+
+    for key, default in qbit_defaults:
+        if ensure_value("qBit", key, default):
+            changed = True
+
+    return changed
+
+
+def apply_config_migrations(config: MyConfig) -> None:
+    """
+    Apply all configuration migrations and validations.
+    Saves the config if any changes were made.
+    """
+    changes_made = False
+
+    # Apply migrations
+    if _migrate_webui_config(config):
+        changes_made = True
+
+    # Validate and fill config
+    if _validate_and_fill_config(config):
+        changes_made = True
+
+    # Save if changes were made
+    if changes_made:
+        config.save()
+        print("Configuration has been updated with migrations and defaults.")
+
+
 def _write_config_file(docker: bool = False) -> pathlib.Path:
     doc = generate_doc()
     config_file = HOME_PATH.joinpath("config.toml")

qBitrr/logger.py

@@ -131,9 +131,29 @@ def run_logs(logger: Logger, _name: str = None) -> None:
                 logold.unlink()
             logfile.rename(logold)
         fh = logging.FileHandler(logfile)
+        # Use ColoredFormatter for file output to include ANSI colors in log files
         fh.setFormatter(
-            logging.Formatter(
-                fmt="[%(asctime)-15s] " f"%(levelname)-8s: %(name)-{key_length}s: %(message)s"
+            coloredlogs.ColoredFormatter(
+                fmt="[%(asctime)-15s] " f"%(levelname)-8s: %(name)-{key_length}s: %(message)s",
+                level_styles={
+                    "trace": {"color": "black", "bold": True},
+                    "debug": {"color": "magenta", "bold": True},
+                    "verbose": {"color": "blue", "bold": True},
+                    "info": {"color": "white"},
+                    "notice": {"color": "cyan"},
+                    "hnotice": {"color": "cyan", "bold": True},
+                    "warning": {"color": "yellow", "bold": True},
+                    "success": {"color": "green", "bold": True},
+                    "error": {"color": "red"},
+                    "critical": {"color": "red", "bold": True},
+                },
+                field_styles={
+                    "asctime": {"color": "green"},
+                    "process": {"color": "magenta"},
+                    "levelname": {"color": "red", "bold": True},
+                    "name": {"color": "blue", "bold": True},
+                    "thread": {"color": "cyan"},
+                },
             )
         )
         logger.addHandler(fh)

qBitrr/main.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import atexit
 import contextlib
+import glob
 import logging
 import os
 import sys
@@ -31,6 +32,7 @@ from qBitrr.config import (
 )
 from qBitrr.env_config import ENVIRO_CONFIG
 from qBitrr.ffprobe import FFprobeDownloader
+from qBitrr.home_path import APPDATA_FOLDER
 from qBitrr.logger import run_logs
 from qBitrr.utils import ExpiringSet
 from qBitrr.versioning import fetch_latest_release
@@ -49,6 +51,32 @@ def _mask_secret(value: str | None) -> str:
     return "[redacted]" if value else ""
 
 
+def _delete_all_databases() -> None:
+    """
+    Delete all database files from the APPDATA_FOLDER on startup.
+
+    This includes:
+    - All .db files (SQLite databases)
+    - All .db-wal files (Write-Ahead Log files)
+    - All .db-shm files (Shared Memory files)
+    """
+    db_patterns = ["*.db", "*.db-wal", "*.db-shm"]
+    deleted_files = []
+
+    for pattern in db_patterns:
+        for db_file in glob.glob(str(APPDATA_FOLDER.joinpath(pattern))):
+            try:
+                os.remove(db_file)
+                deleted_files.append(os.path.basename(db_file))
+            except Exception as e:
+                logger.error("Failed to delete database file %s: %s", db_file, e)
+
+    if deleted_files:
+        logger.info("Deleted database files on startup: %s", ", ".join(deleted_files))
+    else:
+        logger.debug("No database files found to delete on startup")
+
+
 class qBitManager:
     min_supported_version = VersionClass("4.3.9")
     soft_not_supported_supported_version = VersionClass("4.4.4")
@@ -114,10 +142,10 @@ class qBitManager:
             )
         # Start WebUI as early as possible
         try:
-            web_port = int(CONFIG.get("Settings.WebUIPort", fallback=6969) or 6969)
+            web_port = int(CONFIG.get("WebUI.Port", fallback=6969) or 6969)
         except Exception:
             web_port = 6969
-        web_host = CONFIG.get("Settings.WebUIHost", fallback="127.0.0.1") or "127.0.0.1"
+        web_host = CONFIG.get("WebUI.Host", 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",
@@ -420,7 +448,7 @@ def _report_config_issues():
         for key in CONFIG.sections():
             import re
 
-            m = re.match(r"(rad|son|anim)arr.*", key, re.IGNORECASE)
+            m = re.match(r"radarr.*", key, re.IGNORECASE)
             if not m:
                 continue
             managed = CONFIG.get(f"{key}.Managed", fallback=False)
@@ -445,6 +473,10 @@ def run():
     if early_exit is True:
         sys.exit(0)
     logger.info("Starting qBitrr: Version: %s.", patched_version)
+
+    # Delete all databases on startup
+    _delete_all_databases()
+
     try:
         manager = qBitManager()
     except NameError:

qBitrr/webui.py

@@ -89,11 +89,11 @@ class WebUI:
         werkzeug_logger.propagate = True
         werkzeug_logger.setLevel(self.logger.level)
         # Security token (optional) - auto-generate and persist if empty
-        self.token = CONFIG.get("Settings.WebUIToken", fallback=None)
+        self.token = CONFIG.get("WebUI.Token", fallback=None)
         if not self.token:
             self.token = secrets.token_hex(32)
             try:
-                _toml_set(CONFIG.config, "Settings.WebUIToken", self.token)
+                _toml_set(CONFIG.config, "WebUI.Token", self.token)
                 CONFIG.save()
             except Exception:
                 pass
@@ -270,11 +270,27 @@ class WebUI:
         return bool(value) and str(value).lower() not in {"0", "false", "none"}
 
     def _radarr_movies_from_db(
-        self, arr, search: str | None, page: int, page_size: int
+        self,
+        arr,
+        search: str | None,
+        page: int,
+        page_size: int,
+        year_min: int | None = None,
+        year_max: int | None = None,
+        monitored: bool | None = None,
+        has_file: bool | None = None,
+        quality_met: bool | None = None,
+        is_request: bool | None = None,
     ) -> dict[str, Any]:
         if not self._ensure_arr_db(arr):
             return {
-                "counts": {"available": 0, "monitored": 0},
+                "counts": {
+                    "available": 0,
+                    "monitored": 0,
+                    "missing": 0,
+                    "quality_met": 0,
+                    "requests": 0,
+                },
                 "total": 0,
                 "page": max(page, 0),
                 "page_size": max(page_size, 1),
@@ -284,7 +300,13 @@ class WebUI:
         db = getattr(arr, "db", None)
         if model is None or db is None:
             return {
-                "counts": {"available": 0, "monitored": 0},
+                "counts": {
+                    "available": 0,
+                    "monitored": 0,
+                    "missing": 0,
+                    "quality_met": 0,
+                    "requests": 0,
+                },
                 "total": 0,
                 "page": max(page, 0),
                 "page_size": max(page_size, 1),
@@ -294,6 +316,8 @@ class WebUI:
         page_size = max(page_size, 1)
         with db.connection_context():
             base_query = model.select()
+
+            # Calculate counts
             monitored_count = (
                 model.select(fn.COUNT(model.EntryId))
                 .where(model.Monitored == True)  # noqa: E712
@@ -310,9 +334,44 @@ class WebUI:
                 .scalar()
                 or 0
             )
+            missing_count = max(monitored_count - available_count, 0)
+            quality_met_count = (
+                model.select(fn.COUNT(model.EntryId))
+                .where(model.QualityMet == True)  # noqa: E712
+                .scalar()
+                or 0
+            )
+            request_count = (
+                model.select(fn.COUNT(model.EntryId))
+                .where(model.IsRequest == True)  # noqa: E712
+                .scalar()
+                or 0
+            )
+
+            # Build filtered query
             query = base_query
             if search:
                 query = query.where(model.Title.contains(search))
+            if year_min is not None:
+                query = query.where(model.Year >= year_min)
+            if year_max is not None:
+                query = query.where(model.Year <= year_max)
+            if monitored is not None:
+                query = query.where(model.Monitored == monitored)
+            if has_file is not None:
+                if has_file:
+                    query = query.where(
+                        (model.MovieFileId.is_null(False)) & (model.MovieFileId != 0)
+                    )
+                else:
+                    query = query.where(
+                        (model.MovieFileId.is_null(True)) | (model.MovieFileId == 0)
+                    )
+            if quality_met is not None:
+                query = query.where(model.QualityMet == quality_met)
+            if is_request is not None:
+                query = query.where(model.IsRequest == is_request)
+
             total = query.count()
             page_items = query.order_by(model.Title.asc()).paginate(page + 1, page_size).iterator()
             movies = []
@@ -324,10 +383,23 @@ class WebUI:
                         "year": movie.Year,
                         "monitored": self._safe_bool(movie.Monitored),
                         "hasFile": self._safe_bool(movie.MovieFileId),
+                        "qualityMet": self._safe_bool(movie.QualityMet),
+                        "isRequest": self._safe_bool(movie.IsRequest),
+                        "upgrade": self._safe_bool(movie.Upgrade),
+                        "customFormatScore": movie.CustomFormatScore,
+                        "minCustomFormatScore": movie.MinCustomFormatScore,
+                        "customFormatMet": self._safe_bool(movie.CustomFormatMet),
+                        "reason": movie.Reason,
                     }
                 )
         return {
-            "counts": {"available": available_count, "monitored": monitored_count},
+            "counts": {
+                "available": available_count,
+                "monitored": monitored_count,
+                "missing": missing_count,
+                "quality_met": quality_met_count,
+                "requests": request_count,
+            },
             "total": total,
             "page": page,
             "page_size": page_size,
@@ -1177,7 +1249,40 @@ class WebUI:
             q = request.args.get("q", default=None, type=str)
             page = request.args.get("page", default=0, type=int)
             page_size = request.args.get("page_size", default=50, type=int)
-            payload = self._radarr_movies_from_db(arr, q, page, page_size)
+            year_min = request.args.get("year_min", default=None, type=int)
+            year_max = request.args.get("year_max", default=None, type=int)
+            monitored = (
+                self._safe_bool(request.args.get("monitored"))
+                if "monitored" in request.args
+                else None
+            )
+            has_file = (
+                self._safe_bool(request.args.get("has_file"))
+                if "has_file" in request.args
+                else None
+            )
+            quality_met = (
+                self._safe_bool(request.args.get("quality_met"))
+                if "quality_met" in request.args
+                else None
+            )
+            is_request = (
+                self._safe_bool(request.args.get("is_request"))
+                if "is_request" in request.args
+                else None
+            )
+            payload = self._radarr_movies_from_db(
+                arr,
+                q,
+                page,
+                page_size,
+                year_min=year_min,
+                year_max=year_max,
+                monitored=monitored,
+                has_file=has_file,
+                quality_met=quality_met,
+                is_request=is_request,
+            )
             payload["category"] = category
             return jsonify(payload)
 
@@ -1193,7 +1298,40 @@ class WebUI:
             q = request.args.get("q", default=None, type=str)
             page = request.args.get("page", default=0, type=int)
             page_size = request.args.get("page_size", default=50, type=int)
-            payload = self._radarr_movies_from_db(arr, q, page, page_size)
+            year_min = request.args.get("year_min", default=None, type=int)
+            year_max = request.args.get("year_max", default=None, type=int)
+            monitored = (
+                self._safe_bool(request.args.get("monitored"))
+                if "monitored" in request.args
+                else None
+            )
+            has_file = (
+                self._safe_bool(request.args.get("has_file"))
+                if "has_file" in request.args
+                else None
+            )
+            quality_met = (
+                self._safe_bool(request.args.get("quality_met"))
+                if "quality_met" in request.args
+                else None
+            )
+            is_request = (
+                self._safe_bool(request.args.get("is_request"))
+                if "is_request" in request.args
+                else None
+            )
+            payload = self._radarr_movies_from_db(
+                arr,
+                q,
+                page,
+                page_size,
+                year_min=year_min,
+                year_max=year_max,
+                monitored=monitored,
+                has_file=has_file,
+                quality_met=quality_met,
+                is_request=is_request,
+            )
             payload["category"] = category
             return jsonify(payload)
 
@@ -1457,11 +1595,11 @@ class WebUI:
             for key, val in changes.items():
                 if val is None:
                     _toml_delete(CONFIG.config, key)
-                    if key == "Settings.WebUIToken":
+                    if key == "WebUI.Token":
                         self.token = ""
                     continue
                 _toml_set(CONFIG.config, key, val)
-                if key == "Settings.WebUIToken":
+                if key == "WebUI.Token":
                     # Update in-memory token immediately
                     self.token = str(val) if val is not None else ""
             # Persist
@@ -1483,11 +1621,11 @@ class WebUI:
             for key, val in changes.items():
                 if val is None:
                     _toml_delete(CONFIG.config, key)
-                    if key == "Settings.WebUIToken":
+                    if key == "WebUI.Token":
                         self.token = ""
                     continue
                 _toml_set(CONFIG.config, key, val)
-                if key == "Settings.WebUIToken":
+                if key == "WebUI.Token":
                     self.token = str(val) if val is not None else ""
             CONFIG.save()
             try:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qBitrr2
-Version: 5.1.1
+Version: 5.2.0
 Summary: "A simple Python script to talk to qBittorrent and Arr's"
 Home-page: https://github.com/Feramance/qBitrr
 Author: Feramance
@@ -137,13 +137,14 @@ Minimal setup:
 ```bash
 docker run -d \
   --name qbitrr \
+  --tty \
   -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`.
@@ -155,6 +156,7 @@ services:
     image: feramance/qbitrr:latest
     user: 1000:1000
     restart: unless-stopped
+    tty: true
     environment:
       TZ: Europe/London
     ports:

{qbitrr2-5.1.1.dist-info → qbitrr2-5.2.0.dist-info}/RECORD

@@ -1,24 +1,24 @@
 qBitrr/__init__.py,sha256=smiPIV7d2lMJ_KTtFdAVlxLEBobFTheILdgry1iqpjQ,405
-qBitrr/arss.py,sha256=WwDobdQcGcHSvQdh9tiDaza0S8wnPgOMtiRLpmd3Ans,263064
+qBitrr/arss.py,sha256=UeDAyZyl6GO2VcUT1wKLHug2QuNSV9TdTg4oWOwV3X8,266028
 qBitrr/auto_update.py,sha256=hVAvAlKEdOHm6AJLlKvtkklbQhjotVcFOCH-MTigHQM,4419
-qBitrr/bundled_data.py,sha256=qkprw9cE-4KVdWUx1-7xn2heRUSPOIMW9LZd04dOzuo,190
-qBitrr/config.py,sha256=brGy1PQJY6D0HG1V6gpuTi1gPbMH3zIvfozASkvPZR8,6177
+qBitrr/bundled_data.py,sha256=EtewAQLDIoOSHMqzKq2dvgjYRYNJ4GazbwLqlWcqS9I,190
+qBitrr/config.py,sha256=e_UL8Jjz2hWAhT53Du8XZpvyY4ULC5mpyus_7i2An18,6306
 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/gen_config.py,sha256=oIsGIRDF0zHOQXS8Y8yiHiqPL4R0ckw9xw2uQQ2M14s,35368
 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/logger.py,sha256=jEmtSqmsxdvjuYSbgsu9u4jLY5xEfV0nhuW3NHD6zKg,6574
+qBitrr/main.py,sha256=lv4y7Ew5xOCFt37koFGdoqQcv6xULZwojt2ne0LmkD4,19976
 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,,
+qBitrr/webui.py,sha256=qwKkB3fgJy0tXpaoGx1jomNRZ8qUKT4A1hWuZL2sxms,73299
+qbitrr2-5.2.0.dist-info/licenses/LICENSE,sha256=P978aVGi7dPbKz8lfvdiryOS5IjTAU7AA47XhBhVBlI,1066
+qbitrr2-5.2.0.dist-info/METADATA,sha256=tILNoBxyNwCRBRHmAFvfWhetFFyw27AVYDDx6KX3uYo,10148
+qbitrr2-5.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qbitrr2-5.2.0.dist-info/entry_points.txt,sha256=MIR-l5s31VBs9qlv3HiAaMdpOOyy0MNGfM7Ib1-fKeQ,43
+qbitrr2-5.2.0.dist-info/top_level.txt,sha256=jIINodarzsPcQeTf-vvK8-_g7cQ8CvxEg41ms14K97g,7
+qbitrr2-5.2.0.dist-info/RECORD,,