qBitrr2 4.10.9__py3-none-any.whl → 5.4.5__py3-none-any.whl

qBitrr/gen_config.py

@@ -14,6 +14,56 @@ 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,
+        "Group Lidarr albums by artist in views",
+        "GroupLidarr",
+        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 +75,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
@@ -129,6 +180,28 @@ def _add_settings_section(config: TOMLDocument):
         "FFprobeAutoUpdate",
         True if ENVIRO_CONFIG.settings.ping_urls is None else ENVIRO_CONFIG.settings.ping_urls,
     )
+    _gen_default_line(
+        settings,
+        [
+            "Automatically attempt to update qBitrr on a schedule",
+            "Set to true to enable the auto-update worker.",
+        ],
+        "AutoUpdateEnabled",
+        (
+            ENVIRO_CONFIG.settings.auto_update_enabled
+            if ENVIRO_CONFIG.settings.auto_update_enabled is not None
+            else False
+        ),
+    )
+    _gen_default_line(
+        settings,
+        [
+            "Cron expression describing when to check for updates",
+            "Default is weekly Sunday at 03:00 (0 3 * * 0).",
+        ],
+        "AutoUpdateCron",
+        ENVIRO_CONFIG.settings.auto_update_cron or "0 3 * * 0",
+    )
     config.add("Settings", settings)
 
 
@@ -146,19 +219,19 @@ def _add_qbit_section(config: TOMLDocument):
     )
     _gen_default_line(
         qbit,
-        'qBit WebUI URL/IP - Can be found in Options > Web UI (called "IP Address")',
+        'qbittorrent WebUI URL/IP - Can be found in Options > Web UI (called "IP Address")',
         "Host",
         ENVIRO_CONFIG.qbit.host or "CHANGE_ME",
     )
     _gen_default_line(
         qbit,
-        'qBit WebUI Port - Can be found in Options > Web UI (called "Port" on top right corner of the window)',
+        'qbittorrent WebUI Port - Can be found in Options > Web UI (called "Port" on top right corner of the window)',
         "Port",
         ENVIRO_CONFIG.qbit.port or 8080,
     )
     _gen_default_line(
         qbit,
-        "qBit WebUI Authentication - Can be found in Options > Web UI > Authentication",
+        "qbittorrent WebUI Authentication - Can be found in Options > Web UI > Authentication",
         "UserName",
         ENVIRO_CONFIG.qbit.username or "CHANGE_ME",
     )
@@ -168,17 +241,11 @@ def _add_qbit_section(config: TOMLDocument):
         "Password",
         ENVIRO_CONFIG.qbit.password or "CHANGE_ME",
     )
-    _gen_default_line(
-        qbit,
-        "Set to true to allow abittorrent v5 (Some API calls will not work as expected due to qbittorrent API issues not qBitrr)",
-        "v5",
-        ENVIRO_CONFIG.qbit.v5 or False,
-    )
     config.add("qBit", qbit)
 
 
 def _add_category_sections(config: TOMLDocument):
-    for c in ["Sonarr-TV", "Sonarr-Anime", "Radarr-1080", "Radarr-4K"]:
+    for c in ["Sonarr-TV", "Sonarr-Anime", "Radarr-1080", "Radarr-4K", "Lidarr-Music"]:
         _gen_default_cat(c, config)
 
 
@@ -245,6 +312,14 @@ def _gen_default_cat(category: str, config: TOMLDocument):
                 "Unable to determine if file is a sample",
             ]
         )
+    elif "lidarr" in category.lower():
+        messages.extend(
+            [
+                "Not a preferred word upgrade for existing track file(s)",
+                "Not an upgrade for existing track file(s)",
+                "Unable to determine if file is a sample",
+            ]
+        )
     _gen_default_line(
         cat_default,
         [
@@ -357,11 +432,11 @@ def _gen_default_torrent_table(category: str, cat_default: Table):
         torrent_table,
         "Maximum allowed time for allowed stalled torrents in minutes (-1 = Disabled, 0 = Infinite)",
         "StalledDelay",
-        -1,
+        15,
     )
     _gen_default_line(
         torrent_table,
-        "Re-search stalled torrents when StalledDelay is enabled and you want to re-search before removing the stalled torrent",
+        "Re-search stalled torrents when StalledDelay is enabled and you want to re-search before removing the stalled torrent, or only after the torrent is removed.",
         "ReSearchStalled",
         False,
     )
@@ -579,12 +654,14 @@ def _gen_default_search_table(category: str, cat_default: Table):
             "SearchLimit",
             5,
         )
-    _gen_default_line(
-        search_table,
-        "It will order searches by the year the EPISODE was first aired",
-        "SearchByYear",
-        True,
-    )
+    # SearchByYear doesn't apply to Lidarr (music albums)
+    if "lidarr" not in category.lower():
+        _gen_default_line(
+            search_table,
+            "It will order searches by the year the EPISODE was first aired",
+            "SearchByYear",
+            True,
+        )
     _gen_default_line(
         search_table,
         "Reverse search order (Start searching oldest to newest)",
@@ -627,6 +704,7 @@ def _gen_default_search_table(category: str, cat_default: Table):
         True,
     )
     _gen_default_line(search_table, "Use Temp profile for missing", "UseTempForMissing", False)
+    _gen_default_line(search_table, "Don't change back to main profile", "KeepTempProfile", False)
     _gen_default_line(
         search_table,
         "Main quality profile (To pair quality profiles, ensure they are in the same order as in the temp profiles)",
@@ -642,9 +720,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,
@@ -653,8 +735,10 @@ def _gen_default_search_table(category: str, cat_default: Table):
             "PrioritizeTodaysReleases",
             True,
         )
-    _gen_default_ombi_table(category, search_table)
-    _gen_default_overseerr_table(category, search_table)
+    # Ombi and Overseerr don't support music requests
+    if "lidarr" not in category.lower():
+        _gen_default_ombi_table(category, search_table)
+        _gen_default_overseerr_table(category, search_table)
     cat_default.add("EntrySearch", search_table)
 
 
@@ -775,11 +859,188 @@ class MyConfig:
         return values if values is not ... else default
 
 
-def _write_config_file(docker=False) -> pathlib.Path:
+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 _normalize_theme_value(value: Any) -> str:
+    """
+    Normalize theme value to always be 'Light' or 'Dark' (case insensitive input).
+    """
+    if value is None:
+        return "Dark"
+    value_str = str(value).strip().lower()
+    if value_str == "light":
+        return "Light"
+    elif value_str == "dark":
+        return "Dark"
+    else:
+        # Default to Dark if invalid value
+        return "Dark"
+
+
+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),
+        ("GroupLidarr", True),
+        ("Theme", "Dark"),
+    ]
+
+    for key, default in webui_defaults:
+        if ensure_value("WebUI", key, default):
+            changed = True
+
+    # Normalize Theme value to always be capitalized (Light or Dark)
+    ensure_section("WebUI")
+    webui_section = config.config["WebUI"]
+    if "Theme" in webui_section:
+        current_theme = webui_section["Theme"]
+        normalized_theme = _normalize_theme_value(current_theme)
+        if current_theme != normalized_theme:
+            webui_section["Theme"] = normalized_theme
+            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()
-    file_name = "config.rename_me.toml" if docker else "config.toml"
-    config_file = HOME_PATH.joinpath(file_name)
-    if config_file.exists() and not docker:
+    config_file = HOME_PATH.joinpath("config.toml")
+    if docker:
+        if config_file.exists():
+            print(f"{config_file} already exists, keeping current configuration.")
+            return config_file
+    elif config_file.exists():
         print(f"{config_file} already exists, File is not being replaced.")
         config_file = pathlib.Path.cwd().joinpath("config_new.toml")
     config = MyConfig(config_file, config=doc)

qBitrr/logger.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import logging
+import pathlib
 import time
 from logging import Logger
 
@@ -35,7 +36,7 @@ SUCCESS = 25
 
 
 class VerboseLogger(Logger):
-    def _init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         if self.name.startswith("qBitrr"):
             self.set_config_level()
@@ -83,10 +84,11 @@ logger = logging.getLogger("qBitrr.Misc")
 
 
 HAS_RUN = False
+ALL_LOGS_HANDLER = None  # Global handler for unified All.log file
 
 
-def run_logs(logger: Logger) -> None:
-    global HAS_RUN
+def run_logs(logger: Logger, _name: str = None) -> None:
+    global HAS_RUN, ALL_LOGS_HANDLER
     try:
         configkeys = {f"qBitrr.{i}" for i in CONFIG.sections()}
         key_length = max(len(max(configkeys, key=len)), 10)
@@ -118,6 +120,88 @@ def run_logs(logger: Logger) -> None:
         },
         reconfigure=True,
     )
+    logger.propagate = False
+    if ENABLE_LOGS:
+        # Initialize unified All.log handler once (first time run_logs is called)
+        if ALL_LOGS_HANDLER is None:
+            logs_folder = HOME_PATH.joinpath("logs")
+            logs_folder.mkdir(parents=True, exist_ok=True)
+            logs_folder.chmod(mode=0o777)
+            all_logfile = logs_folder.joinpath("All.log")
+            # Rotate old All.log if it exists
+            if all_logfile.exists():
+                all_logold = logs_folder.joinpath("All.log.old")
+                if all_logold.exists():
+                    all_logold.unlink()
+                all_logfile.rename(all_logold)
+            # Create handler for All.log that all loggers will use
+            ALL_LOGS_HANDLER = logging.FileHandler(all_logfile)
+            ALL_LOGS_HANDLER.setFormatter(
+                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"},
+                    },
+                )
+            )
+
+        # Add All.log handler to this logger (since propagate=False, we can't use root)
+        logger.addHandler(ALL_LOGS_HANDLER)
+
+        # Add individual component log file handler
+        if _name:
+            logs_folder = HOME_PATH.joinpath("logs")
+            logs_folder.mkdir(parents=True, exist_ok=True)
+            logs_folder.chmod(mode=0o777)
+            logfile = logs_folder.joinpath(_name + ".log")
+            if pathlib.Path(logfile).is_file():
+                logold = logs_folder.joinpath(_name + ".log.old")
+                if pathlib.Path(logold).exists():
+                    logold.unlink()
+                logfile.rename(logold)
+            fh = logging.FileHandler(logfile)
+            # Use ColoredFormatter for file output to include ANSI colors in log files
+            fh.setFormatter(
+                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)
     if HAS_RUN is False:
         HAS_RUN = True
         log_debugs(logger)