qBitrr2 5.4.3__py3-none-any.whl → 5.4.4__py3-none-any.whl

qBitrr/auto_update.py

@@ -1,17 +1,149 @@
 from __future__ import annotations
 
 import logging
+import platform
 import subprocess
 import sys
 import threading
 from datetime import datetime
 from pathlib import Path
-from typing import Callable
+from typing import Any, Callable
 
+import requests
 from croniter import croniter
 from croniter.croniter import CroniterBadCronError
 
 
+def get_installation_type() -> str:
+    """Detect how qBitrr is installed.
+
+    Returns:
+        "binary" - PyInstaller frozen executable
+        "git" - Git repository installation
+        "pip" - PyPI package installation
+    """
+    # Check if running as PyInstaller binary
+    if getattr(sys, "frozen", False) and hasattr(sys, "_MEIPASS"):
+        return "binary"
+
+    # Check for git repository
+    repo_root = Path(__file__).resolve().parent.parent
+    git_dir = repo_root / ".git"
+    if git_dir.exists():
+        return "git"
+
+    # Default to pip installation
+    return "pip"
+
+
+def get_binary_asset_pattern() -> str:
+    """Get the asset filename pattern for the current platform.
+
+    Returns:
+        Partial filename to match against release assets
+        Examples: "ubuntu-latest-x64", "windows-latest-x64", "macOS-latest-arm64"
+
+    Note: The release workflow only builds these platforms:
+        - ubuntu-latest-x64
+        - macOS-latest-arm64
+        - windows-latest-x64
+    Other platforms (Linux ARM, macOS Intel, Windows ARM) are not built.
+    """
+    system = platform.system()
+    machine = platform.machine()
+
+    # Map platform to GitHub runner names (matching build workflow)
+    if system == "Linux":
+        os_part = "ubuntu-latest"
+        # Note: Only x64 is built for Linux (arm64 excluded from workflow)
+        arch_part = "x64" if machine in ("x86_64", "AMD64") else "arm64"
+    elif system == "Darwin":  # macOS
+        os_part = "macOS-latest"
+        # Note: Only arm64 is built for macOS (x64/Intel excluded from workflow)
+        arch_part = "arm64" if machine == "arm64" else "x64"
+    elif system == "Windows":
+        os_part = "windows-latest"
+        # Note: Only x64 is built for Windows (arm64 excluded from workflow)
+        arch_part = "x64" if machine in ("x86_64", "AMD64") else "arm64"
+    else:
+        raise RuntimeError(f"Unsupported platform: {system} {machine}")
+
+    return f"{os_part}-{arch_part}"
+
+
+def get_binary_download_url(release_tag: str, logger: logging.Logger) -> dict[str, Any]:
+    """Get the download URL for the binary asset matching current platform.
+
+    Args:
+        release_tag: GitHub release tag (e.g., "v5.4.3")
+        logger: Logger instance
+
+    Returns:
+        Dict with 'url', 'name', 'size' if found, or 'error' if not found
+    """
+    try:
+        # Get asset pattern for current platform
+        asset_pattern = get_binary_asset_pattern()
+        logger.debug("Looking for binary asset matching: %s", asset_pattern)
+
+        # Fetch release details with assets
+        repo = "Feramance/qBitrr"
+        url = f"https://api.github.com/repos/{repo}/releases/tags/{release_tag}"
+        response = requests.get(url, timeout=30)
+        response.raise_for_status()
+        release_data = response.json()
+
+        # Find matching asset
+        assets = release_data.get("assets", [])
+        for asset in assets:
+            name = asset.get("name", "")
+            if asset_pattern in name:
+                return {
+                    "url": asset["browser_download_url"],
+                    "name": name,
+                    "size": asset.get("size", 0),
+                    "error": None,
+                }
+
+        # No matching asset found
+        available = [a.get("name") for a in assets]
+        logger.error(
+            "No binary asset found for platform %s in release %s",
+            asset_pattern,
+            release_tag,
+        )
+        logger.debug("Available assets: %s", available)
+
+        # Provide helpful error message
+        system = platform.system()
+        machine = platform.machine()
+        unsupported_platforms = [
+            "ubuntu-latest-arm64",
+            "macOS-latest-x64",
+            "windows-latest-arm64",
+        ]
+
+        error_msg = f"No binary available for {system} {machine}"
+        if asset_pattern in unsupported_platforms:
+            error_msg += f" (platform {asset_pattern} is not built by release workflow)"
+
+        return {
+            "url": None,
+            "name": None,
+            "size": None,
+            "error": error_msg,
+        }
+
+    except Exception as exc:
+        logger.error("Failed to fetch binary asset info: %s", exc)
+        return {
+            "url": None,
+            "name": None,
+            "size": None,
+            "error": str(exc),
+        }
+
+
 class AutoUpdater:
     """Background worker that executes a callback on a cron schedule."""
 
@@ -82,16 +214,126 @@ class AutoUpdater:
             self._logger.info("Auto update completed")
 
 
-def perform_self_update(logger: logging.Logger) -> bool:
-    """Attempt to update qBitrr in-place using git or pip.
+def verify_update_success(expected_version: str, logger: logging.Logger) -> bool:
+    """Verify that the installed version matches the expected version.
+
+    Args:
+        expected_version: Expected version string (e.g., "5.4.3")
+        logger: Logger instance for output
 
-    Returns True when the update command completed successfully, False otherwise.
+    Returns:
+        True if version matches, False otherwise
     """
+    try:
+        # Re-import bundled_data to get fresh version
+        pass
 
-    repo_root = Path(__file__).resolve().parent.parent
-    git_dir = repo_root / ".git"
-    if git_dir.exists():
-        logger.debug("Detected git repository at %s", repo_root)
+        # Remove cached module
+        if "qBitrr.bundled_data" in sys.modules:
+            del sys.modules["qBitrr.bundled_data"]
+
+        # Re-import
+        from qBitrr import bundled_data
+        from qBitrr.versioning import normalize_version
+
+        current = normalize_version(bundled_data.version)
+        expected = normalize_version(expected_version)
+
+        if current == expected:
+            logger.info("Update verified: version %s installed successfully", current)
+            return True
+        logger.warning(
+            "Version mismatch after update: expected %s, got %s",
+            expected,
+            current,
+        )
+        return False
+
+    except Exception as exc:
+        logger.error("Failed to verify update: %s", exc)
+        return False
+
+
+def perform_self_update(logger: logging.Logger, target_version: str | None = None) -> bool:
+    """Attempt to update qBitrr in-place using appropriate method for installation type.
+
+    Args:
+        logger: Logger instance for output
+        target_version: Optional specific version to update to (e.g., "5.4.3")
+
+    Returns:
+        True when the update command completed successfully, False otherwise.
+    """
+
+    # Detect installation type
+    install_type = get_installation_type()
+    logger.debug("Installation type detected: %s", install_type)
+
+    # BINARY INSTALLATION - Cannot auto-update
+    if install_type == "binary":
+        logger.info("Binary installation detected - manual update required")
+        if target_version:
+            logger.info(
+                "Update available: v%s",
+                target_version if target_version.startswith("v") else f"v{target_version}",
+            )
+            logger.info("Download from: https://github.com/Feramance/qBitrr/releases/latest")
+            logger.info("Instructions:")
+            logger.info("  1. Download the binary for your platform")
+            logger.info("  2. Extract the archive")
+            logger.info("  3. Replace current executable with new binary")
+            logger.info("  4. Restart qBitrr")
+        return False  # Binary updates require manual intervention
+
+    # GIT INSTALLATION
+    elif install_type == "git":
+        repo_root = Path(__file__).resolve().parent.parent
+        repo_root / ".git"
+        logger.debug("Git repository detected at %s", repo_root)
+
+        if target_version:
+            # Strict version: checkout specific tag
+            tag = target_version if target_version.startswith("v") else f"v{target_version}"
+
+            try:
+                logger.debug("Fetching tags from remote")
+                subprocess.run(
+                    ["git", "fetch", "--tags", "--force"],
+                    cwd=str(repo_root),
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+
+                result = subprocess.run(
+                    ["git", "rev-parse", tag],
+                    cwd=str(repo_root),
+                    capture_output=True,
+                    text=True,
+                )
+                if result.returncode != 0:
+                    logger.error("Tag %s not found in repository", tag)
+                    logger.warning("Falling back to git pull")
+                else:
+                    result = subprocess.run(
+                        ["git", "checkout", tag],
+                        cwd=str(repo_root),
+                        capture_output=True,
+                        text=True,
+                        check=True,
+                    )
+                    stdout = (result.stdout or "").strip()
+                    if stdout:
+                        logger.info("git checkout output:\n%s", stdout)
+                    logger.info("Checked out tag %s", tag)
+                    return True
+
+            except subprocess.CalledProcessError as exc:
+                stderr = (exc.stderr or "").strip()
+                logger.error("Failed to checkout tag %s: %s", tag, stderr or exc)
+                logger.warning("Falling back to git pull")
+
+        # Default: git pull
         try:
             result = subprocess.run(
                 ["git", "pull", "--ff-only"],
@@ -109,20 +351,32 @@ def perform_self_update(logger: logging.Logger) -> bool:
             logger.error("Failed to update repository via git: %s", stderr or exc)
             return False
 
-    package = "qBitrr2"
-    logger.debug("Fallback to pip upgrade for package %s", package)
-    try:
-        result = subprocess.run(
-            [sys.executable, "-m", "pip", "install", "--upgrade", package],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        stdout = (result.stdout or "").strip()
-        if stdout:
-            logger.info("pip upgrade output:\n%s", stdout)
-        return True
-    except subprocess.CalledProcessError as exc:
-        stderr = (exc.stderr or "").strip()
-        logger.error("Failed to upgrade package via pip: %s", stderr or exc)
-        return False
+    # PIP INSTALLATION
+    elif install_type == "pip":
+        logger.debug("PyPI installation detected")
+
+        package = "qBitrr2"
+        if target_version:
+            # Strict version: install exact version
+            version = target_version[1:] if target_version.startswith("v") else target_version
+            package = f"{package}=={version}"
+
+        logger.debug("Upgrading package: %s", package)
+        try:
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "--upgrade", package],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            stdout = (result.stdout or "").strip()
+            if stdout:
+                logger.info("pip upgrade output:\n%s", stdout)
+            return True
+        except subprocess.CalledProcessError as exc:
+            stderr = (exc.stderr or "").strip()
+            logger.error("Failed to upgrade package via pip: %s", stderr or exc)
+            return False
+
+    logger.error("Unknown installation type: %s", install_type)
+    return False

qBitrr/bundled_data.py

@@ -1,5 +1,5 @@
-version = "5.4.3"
-git_hash = "eb7a9ae5"
+version = "5.4.4"
+git_hash = "478d48fd"
 license_text = (
     "Licence can be found on:\n\nhttps://github.com/Feramance/qBitrr/blob/master/LICENSE"
 )

qBitrr/main.py

@@ -180,27 +180,66 @@ class qBitManager:
             self.logger.error("Auto update could not be scheduled; leaving it disabled")
 
     def _perform_auto_update(self) -> None:
+        """Check for updates and apply if available."""
         self.logger.notice("Checking for updates...")
+
+        # Fetch latest release info from GitHub
         release_info = fetch_latest_release()
+
         if release_info.get("error"):
             self.logger.error("Auto update skipped: %s", release_info["error"])
             return
-        target_version = release_info.get("raw_tag") or release_info.get("normalized")
+
+        # Use normalized version for comparison, raw tag for display
+        target_version = release_info.get("normalized")
+        raw_tag = release_info.get("raw_tag")
+
         if not release_info.get("update_available"):
             if target_version:
                 self.logger.info(
                     "Auto update skipped: already running the latest release (%s).",
-                    target_version,
+                    raw_tag or target_version,
                 )
             else:
                 self.logger.info("Auto update skipped: no new release detected.")
             return
 
-        self.logger.notice("Updating from %s to %s", patched_version, target_version or "latest")
-        updated = perform_self_update(self.logger)
+        # Detect installation type
+        from qBitrr.auto_update import get_installation_type
+
+        install_type = get_installation_type()
+
+        self.logger.notice(
+            "Update available: %s -> %s (installation: %s)",
+            patched_version,
+            raw_tag or target_version,
+            install_type,
+        )
+
+        # Perform the update with specific version
+        updated = perform_self_update(self.logger, target_version=target_version)
+
         if not updated:
-            self.logger.error("Auto update failed; manual intervention may be required.")
+            if install_type == "binary":
+                # Binary installations require manual update, this is expected
+                self.logger.info("Manual update required for binary installation")
+            else:
+                self.logger.error("Auto update failed; manual intervention may be required.")
             return
+
+        # Verify update success (git/pip only)
+        if target_version and install_type != "binary":
+            from qBitrr.auto_update import verify_update_success
+
+            if verify_update_success(target_version, self.logger):
+                self.logger.notice("Update verified successfully")
+            else:
+                self.logger.warning(
+                    "Update completed but version verification failed. "
+                    "The system may not be running the expected version."
+                )
+                # Continue with restart anyway (Phase 1 approach)
+
         self.logger.notice("Update applied successfully; restarting to load the new version.")
         self.request_restart()