qBitrr2 5.5.5__py3-none-any.whl

qBitrr/db_recovery.py

@@ -0,0 +1,202 @@
+"""SQLite database recovery utilities."""
+
+from __future__ import annotations
+
+import logging
+import shutil
+import sqlite3
+from pathlib import Path
+
+logger = logging.getLogger("qBitrr.DBRecovery")
+
+
+class DatabaseRecoveryError(Exception):
+    """Raised when database recovery fails."""
+
+
+def checkpoint_wal(db_path: Path, logger_override=None) -> bool:
+    """
+    Force checkpoint of WAL file to main database.
+
+    This operation flushes all Write-Ahead Log entries to the main database
+    file, which can resolve certain types of corruption and reduce the risk
+    of data loss.
+
+    Args:
+        db_path: Path to SQLite database file
+        logger_override: Optional logger instance to use instead of module logger
+
+    Returns:
+        True if successful, False otherwise
+    """
+    log = logger_override or logger
+
+    try:
+        log.info("Starting WAL checkpoint for database: %s", db_path)
+        conn = sqlite3.connect(str(db_path), timeout=10.0)
+        cursor = conn.cursor()
+
+        # Force WAL checkpoint with TRUNCATE mode
+        # This checkpoints all frames and truncates the WAL file
+        cursor.execute("PRAGMA wal_checkpoint(TRUNCATE)")
+        result = cursor.fetchone()
+
+        conn.close()
+
+        # Result is (busy, log_pages, checkpointed_pages)
+        # If busy=0, checkpoint was fully successful
+        if result and result[0] == 0:
+            log.info(
+                "WAL checkpoint successful: %s frames checkpointed, %s pages in log",
+                result[2],
+                result[1],
+            )
+            return True
+        else:
+            log.warning(
+                "WAL checkpoint partially successful: result=%s (database may be busy)",
+                result,
+            )
+            return True  # Still consider partial success as success
+
+    except sqlite3.OperationalError as e:
+        log.error("WAL checkpoint failed (OperationalError): %s", e)
+        return False
+    except Exception as e:
+        log.error("WAL checkpoint failed (unexpected error): %s", e)
+        return False
+
+
+def repair_database(db_path: Path, backup: bool = True, logger_override=None) -> bool:
+    """
+    Attempt to repair corrupted SQLite database via dump/restore.
+
+    This operation:
+    1. Creates a backup of the corrupted database
+    2. Dumps all recoverable data to a temporary database
+    3. Replaces the original with the repaired copy
+    4. Verifies integrity of the repaired database
+
+    WARNING: Some data may be lost if corruption is severe.
+
+    Args:
+        db_path: Path to SQLite database file
+        backup: Whether to create backup before repair (default: True)
+        logger_override: Optional logger instance to use instead of module logger
+
+    Returns:
+        True if repair successful, False otherwise
+
+    Raises:
+        DatabaseRecoveryError: If repair fails critically
+    """
+    log = logger_override or logger
+
+    backup_path = db_path.with_suffix(".db.backup")
+    temp_path = db_path.with_suffix(".db.temp")
+
+    try:
+        # Step 1: Backup original
+        if backup:
+            log.info("Creating backup: %s", backup_path)
+            shutil.copy2(db_path, backup_path)
+
+        # Step 2: Dump recoverable data
+        log.info("Dumping recoverable data from corrupted database...")
+        source_conn = sqlite3.connect(str(db_path))
+
+        temp_conn = sqlite3.connect(str(temp_path))
+
+        # Dump schema and data
+        skipped_rows = 0
+        for line in source_conn.iterdump():
+            try:
+                temp_conn.execute(line)
+            except sqlite3.Error as e:
+                # Log but continue - recover what we can
+                skipped_rows += 1
+                log.debug("Skipping corrupted row during dump: %s", e)
+
+        if skipped_rows > 0:
+            log.warning("Skipped %s corrupted rows during dump", skipped_rows)
+
+        temp_conn.commit()
+        temp_conn.close()
+        source_conn.close()
+
+        # Step 3: Replace original with repaired copy
+        log.info("Replacing database with repaired version...")
+        db_path.unlink()
+        shutil.move(str(temp_path), str(db_path))
+
+        # Step 4: Verify integrity
+        log.info("Verifying integrity of repaired database...")
+        verify_conn = sqlite3.connect(str(db_path))
+        cursor = verify_conn.cursor()
+        cursor.execute("PRAGMA integrity_check")
+        result = cursor.fetchone()[0]
+        verify_conn.close()
+
+        if result != "ok":
+            raise DatabaseRecoveryError(f"Repair verification failed: {result}")
+
+        log.info("Database repair successful!")
+        return True
+
+    except Exception as e:
+        log.error("Database repair failed: %s", e)
+
+        # Attempt to restore backup
+        if backup and backup_path.exists():
+            log.warning("Restoring from backup...")
+            try:
+                shutil.copy2(backup_path, db_path)
+                log.info("Backup restored successfully")
+            except Exception as restore_error:
+                log.error("Failed to restore backup: %s", restore_error)
+
+        # Cleanup temp files
+        if temp_path.exists():
+            try:
+                temp_path.unlink()
+            except Exception:
+                pass  # Best effort cleanup
+
+        raise DatabaseRecoveryError(f"Repair failed: {e}") from e
+
+
+def vacuum_database(db_path: Path, logger_override=None) -> bool:
+    """
+    Run VACUUM to reclaim space and optimize database.
+
+    VACUUM rebuilds the database file, repacking it into a minimal amount of
+    disk space. This can help resolve some types of corruption and improve
+    performance.
+
+    Note: VACUUM requires free disk space approximately 2x the database size.
+
+    Args:
+        db_path: Path to SQLite database file
+        logger_override: Optional logger instance to use instead of module logger
+
+    Returns:
+        True if successful, False otherwise
+    """
+    log = logger_override or logger
+
+    try:
+        log.info("Running VACUUM on database: %s", db_path)
+        conn = sqlite3.connect(str(db_path), timeout=30.0)
+
+        conn.execute("VACUUM")
+        conn.close()
+
+        log.info("VACUUM completed successfully")
+        return True
+
+    except sqlite3.OperationalError as e:
+        log.error("VACUUM failed (OperationalError): %s", e)
+        return False
+    except Exception as e:
+        log.error("VACUUM failed (unexpected error): %s", e)
+        return False

qBitrr/env_config.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import environ
+
+
+def _strtobool(value: str) -> int:
+    """Return 1 for truthy strings and 0 for falsy strings, mirroring distutils.util.strtobool."""
+    if value is None:
+        raise ValueError("Boolean value must be a string")
+    normalized = value.strip().lower()
+    if normalized in {"y", "yes", "t", "true", "on", "1"}:
+        return 1
+    if normalized in {"n", "no", "f", "false", "off", "0"}:
+        return 0
+    raise ValueError(f"Invalid truth value {value!r}")
+
+
+class Converter:
+    @staticmethod
+    def int(value: str | None) -> int | None:
+        return None if value is None else int(value)
+
+    @staticmethod
+    def list(value: str | None, delimiter=",", converter=str) -> list | None:
+        return None if value is None else list(map(converter, value.split(delimiter)))
+
+    @staticmethod
+    def bool(value: str | None) -> bool | None:
+        return None if value is None else _strtobool(value) == 1
+
+
+@environ.config(prefix="QBITRR", frozen=True)
+class AppConfig:
+    @environ.config(prefix="OVERRIDES", frozen=True)
+    class Overrides:
+        search_only = environ.var(None, converter=Converter.bool)
+        processing_only = environ.var(None, converter=Converter.bool)
+        data_path = environ.var(None)
+
+    @environ.config(prefix="SETTINGS", frozen=True)
+    class Settings:
+        console_level = environ.var(None)
+        logging = environ.var(None, converter=Converter.bool)
+        completed_download_folder = environ.var(None)
+        free_space = environ.var(None)
+        free_space_folder = environ.var(None)
+        no_internet_sleep_timer = environ.var(None, converter=Converter.int)
+        loop_sleep_timer = environ.var(None, converter=Converter.int)
+        search_loop_delay = environ.var(None, converter=Converter.int)
+        auto_pause_resume = environ.var(None, converter=Converter.bool)
+        failed_category = environ.var(None)
+        recheck_category = environ.var(None)
+        tagless = environ.var(None, converter=Converter.bool)
+        ignore_torrents_younger_than = environ.var(None, converter=Converter.int)
+        ping_urls = environ.var(None, converter=Converter.list)
+        ffprobe_auto_update = environ.var(None, converter=Converter.bool)
+        auto_update_enabled = environ.var(None, converter=Converter.bool)
+        auto_update_cron = environ.var(None)
+
+    @environ.config(prefix="QBIT", frozen=True)
+    class qBit:
+        disabled = environ.var(None, converter=Converter.bool)
+        host = environ.var(None)
+        port = environ.var(None, converter=Converter.int)
+        username = environ.var(None)
+        password = environ.var(None)
+
+    overrides: Overrides = environ.group(Overrides)
+    settings: Settings = environ.group(Settings)
+    qbit: qBit = environ.group(qBit)
+
+
+ENVIRO_CONFIG: AppConfig = environ.to_config(AppConfig)

qBitrr/errors.py

@@ -0,0 +1,41 @@
+class qBitManagerError(Exception):
+    """Base Exception"""
+
+
+class UnhandledError(qBitManagerError):
+    """Use to raise when there an unhandled edge case"""
+
+
+class ConfigException(qBitManagerError):
+    """Base Exception for Config related exceptions"""
+
+
+class ArrManagerException(qBitManagerError):
+    """Base Exception for Arr related Exceptions"""
+
+
+class SkipException(qBitManagerError):
+    """Dummy error to skip actions"""
+
+
+class RequireConfigValue(qBitManagerError):
+    """Exception raised when a config value requires a value."""
+
+    def __init__(self, config_class: str, config_key: str):
+        self.message = f"Config key '{config_key}' in '{config_class}' requires a value."
+
+
+class NoConnectionrException(qBitManagerError):
+    def __init__(self, message: str, type: str = "delay"):
+        self.message = message
+        self.type = type
+
+
+class DelayLoopException(qBitManagerError):
+    def __init__(self, length: int, type: str):
+        self.type = type
+        self.length = length
+
+
+class RestartLoopException(ArrManagerException):
+    """Exception to trigger a loop restart"""

qBitrr/ffprobe.py

@@ -0,0 +1,105 @@
+import io
+import json
+import logging
+import os
+import platform
+import sys
+import zipfile
+
+import requests
+
+from qBitrr.config import FF_PROBE, FF_VERSION, FFPROBE_AUTO_UPDATE
+from qBitrr.logger import run_logs
+
+
+class FFprobeDownloader:
+    def __init__(self):
+        self.api = "https://ffbinaries.com/api/v1/version/latest"
+        self.version_file = FF_VERSION
+        self.logger = logging.getLogger("qBitrr.FFprobe")
+        run_logs(self.logger)
+        self.platform = platform.system()
+        if self.platform == "Windows":
+            self.probe_path = FF_PROBE.with_suffix(".exe")
+        else:
+            self.probe_path = FF_PROBE
+
+    def get_upstream_version(self) -> dict:
+        with requests.Session() as session:
+            with session.get(self.api) as response:
+                if response.status_code != 200:
+                    self.logger.warning("Failed to retrieve ffprobe version from API.")
+                    return {}
+                return response.json()
+
+    def get_current_version(self):
+        try:
+            with self.version_file.open(mode="r") as file:
+                data = json.load(file)
+            return data.get("version")
+        except Exception:  # If file can't be found or read or parsed
+            self.logger.warning("Failed to retrieve current ffprobe version.")
+            return ""
+
+    def update(self):
+        if not FFPROBE_AUTO_UPDATE:
+            return
+        current_version = self.get_current_version()
+        upstream_data = self.get_upstream_version()
+        upstream_version = upstream_data.get("version")
+        if upstream_version is None:
+            self.logger.debug(
+                "Failed to retrieve ffprobe version from API.'upstream_version' is None"
+            )
+            return
+        probe_file_exists = self.probe_path.exists()
+        if current_version == upstream_version and probe_file_exists:
+            self.logger.debug("Current FFprobe is up to date.")
+            return
+        arch_key = self.get_arch()
+        urls = upstream_data.get("bin", {}).get(arch_key)
+        if urls is None:
+            self.logger.debug("Failed to retrieve ffprobe version from API.'urls' is None")
+            return
+        ffprobe_url = urls.get("ffprobe")
+        self.logger.debug("Downloading newer FFprobe: %s", ffprobe_url)
+        self.download_and_extract(ffprobe_url)
+        self.logger.debug("Updating local version of FFprobe: %s", upstream_version)
+        self.version_file.write_text(json.dumps({"version": upstream_version}))
+        try:
+            os.chmod(self.probe_path, 0o777)
+            self.logger.debug("Successfully changed permissions for ffprobe")
+        except Exception as e:
+            self.logger.debug("Failed to change permissions for ffprobe, %s", e)
+
+    def download_and_extract(self, ffprobe_url):
+        r = requests.get(ffprobe_url)
+        z = zipfile.ZipFile(io.BytesIO(r.content))
+        self.logger.debug("Extracting downloaded FFprobe to: %s", FF_PROBE.parent)
+        z.extract(member=self.probe_path.name, path=FF_PROBE.parent)
+
+    def get_arch(self):
+        part1 = None
+        is_64bits = sys.maxsize > 2**32
+        part2 = "64" if is_64bits else "32"
+        if self.platform == "Windows":
+            part1 = "windows-"
+        elif self.platform == "Linux":
+            part1 = "linux-"
+            machine = platform.machine()
+            if machine == "armv6l":
+                part2 = "armhf"
+            elif ("arm" in machine and is_64bits) or machine == "aarch64":
+                part2 = "arm64"
+            # Else just 32/64, Not armel - because just no
+        elif self.platform == "Darwin":
+            part1 = "osx-"
+            part2 = "64"
+        if part1 is None:
+            raise RuntimeError(
+                "You are running in an unsupported platform, "
+                "if you expect this to be supported please open an issue on GitHub "
+                "https://github.com/Feramance/qBitrr."
+            )
+
+        return part1 + part2