qBitrr2 5.5.5__py3-none-any.whl

qBitrr/static/manifest.json

@@ -0,0 +1,23 @@
+{
+  "background_color": "#101114",
+  "categories": [
+    "utilities",
+    "productivity"
+  ],
+  "description": "A Radarr and Sonarr companion app for managing torrents",
+  "display": "standalone",
+  "icons": [
+    {
+      "purpose": "any maskable",
+      "sizes": "any",
+      "src": "/logov2-clean.svg",
+      "type": "image/svg+xml"
+    }
+  ],
+  "name": "qBitrr",
+  "orientation": "any",
+  "screenshots": [],
+  "short_name": "qBitrr",
+  "start_url": "/",
+  "theme_color": "#7aa2f7"
+}

qBitrr/static/sw.js

@@ -0,0 +1,87 @@
+// qBitrr Service Worker
+// Update cache version on every deployment to force refresh
+const CACHE_VERSION = Date.now();
+const CACHE_NAME = `qbitrr-v${CACHE_VERSION}`;
+const RUNTIME_CACHE = `qbitrr-runtime-v${CACHE_VERSION}`;
+
+// Assets to cache on install
+const PRECACHE_URLS = [
+  '/',
+  '/index.html',
+];
+
+// Install event - precache essential assets
+self.addEventListener('install', (event) => {
+  event.waitUntil(
+    caches.open(CACHE_NAME)
+      .then((cache) => cache.addAll(PRECACHE_URLS))
+      .then(() => self.skipWaiting())
+  );
+});
+
+// Activate event - clean up old caches
+self.addEventListener('activate', (event) => {
+  event.waitUntil(
+    caches.keys().then((cacheNames) => {
+      return Promise.all(
+        cacheNames
+          .filter((cacheName) => cacheName !== CACHE_NAME && cacheName !== RUNTIME_CACHE)
+          .map((cacheName) => caches.delete(cacheName))
+      );
+    }).then(() => self.clients.claim())
+  );
+});
+
+// Fetch event - network-first strategy for API calls, cache-first for assets
+self.addEventListener('fetch', (event) => {
+  const { request } = event;
+  const url = new URL(request.url);
+
+  // Skip non-GET requests
+  if (request.method !== 'GET') {
+    return;
+  }
+
+  // Network-first for API calls
+  if (url.pathname.startsWith('/api/')) {
+    event.respondWith(
+      fetch(request)
+        .then((response) => {
+          // Clone the response before caching
+          const responseToCache = response.clone();
+          caches.open(RUNTIME_CACHE).then((cache) => {
+            cache.put(request, responseToCache);
+          });
+          return response;
+        })
+        .catch(() => {
+          // Return cached response if network fails
+          return caches.match(request);
+        })
+    );
+    return;
+  }
+
+  // Cache-first for static assets
+  event.respondWith(
+    caches.match(request).then((cachedResponse) => {
+      if (cachedResponse) {
+        return cachedResponse;
+      }
+
+      return fetch(request).then((response) => {
+        // Don't cache non-successful responses
+        if (!response || response.status !== 200 || response.type === 'error') {
+          return response;
+        }
+
+        const responseToCache = response.clone();
+        caches.open(RUNTIME_CACHE).then((cache) => {
+          cache.put(request, responseToCache);
+        });
+
+        return response;
+      });
+    })
+  );
+});

qBitrr/static/vite.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

qBitrr/tables.py

@@ -0,0 +1,143 @@
+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)
+    # Quality profile from Arr API
+    QualityProfileId = IntegerField(null=True)
+    QualityProfileName = TextField(null=True)
+    # Profile switching state tracking
+    LastProfileSwitchTime = DateTimeField(formats=["%Y-%m-%d %H:%M:%S.%f"], null=True)
+    CurrentProfileId = IntegerField(null=True)
+    OriginalProfileId = IntegerField(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)
+    # Quality profile from Arr API (inherited from series)
+    QualityProfileId = IntegerField(null=True)
+    QualityProfileName = TextField(null=True)
+    # Profile switching state tracking
+    LastProfileSwitchTime = DateTimeField(formats=["%Y-%m-%d %H:%M:%S.%f"], null=True)
+    CurrentProfileId = IntegerField(null=True)
+    OriginalProfileId = IntegerField(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)
+    # Quality profile from Arr API
+    QualityProfileId = IntegerField(null=True)
+    QualityProfileName = TextField(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 AlbumFilesModel(Model):
+    Title = CharField()
+    Monitored = BooleanField()
+    ForeignAlbumId = CharField()
+    ReleaseDate = DateTimeField(formats=["%Y-%m-%d %H:%M:%S.%f"], null=True)
+    EntryId = IntegerField(unique=True)
+    Searched = BooleanField(default=False)
+    AlbumFileId = 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)
+    ArtistId = IntegerField(null=False)
+    ArtistTitle = TextField(null=True)
+    # Quality profile from Arr API
+    QualityProfileId = IntegerField(null=True)
+    QualityProfileName = TextField(null=True)
+    # Profile switching state tracking
+    LastProfileSwitchTime = DateTimeField(formats=["%Y-%m-%d %H:%M:%S.%f"], null=True)
+    CurrentProfileId = IntegerField(null=True)
+    OriginalProfileId = IntegerField(null=True)
+
+
+class TrackFilesModel(Model):
+    EntryId = IntegerField(primary_key=True)
+    AlbumId = IntegerField(null=False)
+    TrackNumber = IntegerField(null=True)
+    Title = TextField(null=True)
+    Duration = IntegerField(null=True)  # Duration in seconds
+    HasFile = BooleanField(default=False)
+    TrackFileId = IntegerField(null=True)
+    Monitored = BooleanField(default=False)
+
+
+class ArtistFilesModel(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)
+    # Quality profile from Arr API
+    QualityProfileId = IntegerField(null=True)
+    QualityProfileName = TextField(null=True)
+
+
+class AlbumQueueModel(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)

qBitrr/utils.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import logging
+import pathlib
+import random
+import re
+import socket
+import time
+from typing import Iterator
+
+import ping3
+import qbittorrentapi
+from cachetools import TTLCache
+
+ping3.EXCEPTIONS = True
+
+logger = logging.getLogger("qBitrr.Utils")
+
+CACHE = TTLCache(maxsize=50, ttl=60)
+
+UNITS = {"k": 1024, "m": 1048576, "g": 1073741824, "t": 1099511627776}
+
+
+def with_retry(
+    func, *, retries=3, backoff=0.5, max_backoff=5.0, jitter=0.25, exceptions=(Exception,)
+):
+    """Run `func()` with exponential backoff and jitter for transient failures.
+
+    - retries: total attempts (including first). Set to 1 for no retry.
+    - backoff: initial backoff seconds, doubles each attempt up to max_backoff.
+    - jitter: random jitter in seconds added to each delay.
+    - exceptions: tuple of exception types to catch and retry on.
+    """
+    attempt = 0
+    while True:
+        try:
+            return func()
+        except exceptions as e:
+            attempt += 1
+            if attempt >= retries:
+                raise
+            delay = min(max_backoff, backoff * (2 ** (attempt - 1))) + random.random() * jitter
+            logger.debug(
+                "Retryable error: %s. Retrying in %.2fs (attempt %s/%s)",
+                e,
+                delay,
+                attempt + 1,
+                retries,
+            )
+            time.sleep(delay)
+
+
+def absolute_file_paths(directory: pathlib.Path | str) -> Iterator[pathlib.Path]:
+    file_counter = 0
+    error = True
+    while error:
+        try:
+            if file_counter == 50:
+                error = False
+            yield from pathlib.Path(directory).glob("**/*")
+            error = False
+            file_counter = 0
+        except FileNotFoundError as e:
+            file_counter += 1
+            if file_counter == 1:
+                logger.warning("%s - %s", e.strerror, e.filename)
+
+
+def validate_and_return_torrent_file(file: str) -> pathlib.Path:
+    path = pathlib.Path(file)
+    if path.is_file():
+        path = path.parent.absolute()
+    count = 9
+    while not path.exists():
+        logger.debug(
+            "Attempt %s/10: File does not yet exist! (Possibly being moved?) | "
+            "%s | Sleeping for 0.1s",
+            10 - count,
+            path,
+        )
+        time.sleep(0.1)
+        if count == 0:
+            break
+        count -= 1
+    else:
+        count = 0
+    while str(path) == ".":
+        path = pathlib.Path(file)
+        if path.is_file():
+            path = path.parent.absolute()
+        while not path.exists():
+            logger.debug(
+                "Attempt %s/10: File does not yet exist! (Possibly being moved?) | "
+                "%s | Sleeping for 0.1s",
+                10 - count,
+                path,
+            )
+            time.sleep(0.1)
+            if count == 0:
+                break
+            count -= 1
+        else:
+            count = 0
+        if count == 0:
+            break
+        count -= 1
+    return path
+
+
+def has_internet(client: qbittorrentapi.Client):
+    from qBitrr.config import PING_URLS
+
+    # Prefer qBit's connection status to avoid frequent pings
+    try:
+        status = client.transfer_info().get("connection_status")
+        if status and status != "disconnected":
+            return True
+    except Exception as e:
+        logger.debug("transfer_info unavailable: %s", e)
+    # Fallback to a single ping
+    url = random.choice(PING_URLS)
+    try:
+        if is_connected(url):
+            logger.debug("Successfully connected to %s", url)
+            return True
+    except Exception as e:
+        logger.debug("Ping to %s failed: %s", url, e)
+    return False
+
+
+def _basic_ping(hostname):
+    host = "N/A"
+    try:
+        # if this hostname was called within the last 10 seconds skip it
+        # if it was previous successful
+        # Reducing the number of call to it and the likelihood of rate-limits.
+        if hostname in CACHE:
+            return CACHE[hostname]
+        # see if we can resolve the host name -- tells us if there is
+        # a DNS listening
+        host = socket.gethostbyname(hostname)
+        # connect to the host -- tells us if the host is actually
+        # reachable
+        s = socket.create_connection((host, 80), 5)
+        s.close()
+        CACHE[hostname] = True
+        return True
+    except Exception as e:
+        logger.debug("Error when connecting to host: %s %s %s", hostname, host, e)
+        return False
+
+
+def is_connected(hostname):
+    try:
+        # if this hostname was called within the last 10 seconds skip it
+        # if it was previous successful
+        # Reducing the number of call to it and the likelihood of rate-limits.
+        if hostname in CACHE:
+            return CACHE[hostname]
+        ping3.ping(hostname, timeout=5)
+        CACHE[hostname] = True
+        return True
+    except ping3.errors.PingError as e:  # All ping3 errors are subclasses of `PingError`.
+        logger.debug("Error when connecting to host: %s %s", hostname, e)
+    except (
+        Exception
+    ):  # Ping3 is far more robust but may requite root access, if root access is not available then run the basic mode
+        return _basic_ping(hostname)
+
+
+def parse_size(size):
+    m = re.match(r"^([0-9]+(?:\.[0-9]+)?)([kmgt]?)$", size, re.IGNORECASE)
+    if not m:
+        raise ValueError("Unsupported value for leave_free_space")
+    val = float(m.group(1))
+    unit = m.group(2)
+    if unit:
+        val *= UNITS[unit.lower()]
+    return val
+
+
+def format_bytes(bytes_value: int | float) -> str:
+    """Format bytes into human-readable format (e.g., '1.5 GB', '256 MB').
+
+    Args:
+        bytes_value: Number of bytes to format
+
+    Returns:
+        Human-readable string representation of the byte value
+    """
+    if bytes_value < 0:
+        return f"-{format_bytes(-bytes_value)}"
+
+    if bytes_value == 0:
+        return "0 B"
+
+    units = [("B", 1), ("KB", 1024), ("MB", 1048576), ("GB", 1073741824), ("TB", 1099511627776)]
+
+    for unit_name, unit_value in reversed(units):
+        if bytes_value >= unit_value:
+            value = bytes_value / unit_value
+            # Show 2 decimal places for values < 10, 1 decimal place for values >= 10
+            if value < 10:
+                return f"{value:.2f} {unit_name}"
+            else:
+                return f"{value:.1f} {unit_name}"
+
+    return f"{bytes_value} B"
+
+
+class ExpiringSet:
+    def __init__(self, *args: list, **kwargs):
+        max_age_seconds = kwargs.get("max_age_seconds", 0)
+        assert max_age_seconds > 0
+        self.age = max_age_seconds
+        self.container = {}
+        for arg in args:
+            self.add(arg)
+
+    def __repr__(self):
+        self.__update__()
+        return f"{self.__class__.__name__}({', '.join(map(str, self.container.keys()))})"
+
+    def extend(self, args):
+        """Add several items at once."""
+        for arg in args:
+            self.add(arg)
+
+    def add(self, value):
+        self.container[value] = time.time()
+
+    def remove(self, item):
+        del self.container[item]
+
+    def contains(self, value):
+        if value not in self.container:
+            return False
+        if time.time() - self.container[value] > self.age:
+            del self.container[value]
+            return False
+        return True
+
+    __contains__ = contains
+
+    def __getitem__(self, index):
+        self.__update__()
+        return list(self.container.keys())[index]
+
+    def __iter__(self):
+        self.__update__()
+        return iter(self.container.copy())
+
+    def __len__(self):
+        self.__update__()
+        return len(self.container)
+
+    def __copy__(self):
+        self.__update__()
+        temp = ExpiringSet(max_age_seconds=self.age)
+        temp.container = self.container.copy()
+        return temp
+
+    def __update__(self):
+        for k, b in self.container.copy().items():
+            if time.time() - b > self.age:
+                del self.container[k]
+                return False
+
+    def __eq__(self, other):
+        if not isinstance(other, ExpiringSet):
+            return False
+        self.__update__()
+        other.__update__()
+        return set(self.container.keys()) == set(other.container.keys())

qBitrr/versioning.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from typing import Any
+
+import requests
+from packaging import version as version_parser
+
+from qBitrr.bundled_data import patched_version
+
+DEFAULT_REPOSITORY = "Feramance/qBitrr"
+
+
+def normalize_version(raw: str | None) -> str | None:
+    if not raw:
+        return None
+    cleaned = raw.strip()
+    if cleaned.startswith(("v", "V")):
+        cleaned = cleaned[1:]
+    if "-" in cleaned:
+        cleaned = cleaned.split("-", 1)[0]
+    return cleaned or None
+
+
+def is_newer_version(candidate: str | None, current: str | None = None) -> bool:
+    if not candidate:
+        return False
+    normalized_candidate = normalize_version(candidate)
+    normalized_current = normalize_version(current or patched_version)
+    if not normalized_current:
+        return True
+    if not normalized_candidate:
+        return False
+    try:
+        latest_version = version_parser.parse(normalized_candidate)
+        current_version = version_parser.parse(normalized_current)
+        return latest_version > current_version
+    except Exception:
+        return normalized_candidate != normalized_current
+
+
+def fetch_latest_release(repo: str = DEFAULT_REPOSITORY, *, timeout: int = 10) -> dict[str, Any]:
+    """Fetch latest non-draft, non-prerelease from GitHub.
+
+    Note: The /releases/latest endpoint excludes drafts by default, but we
+    explicitly check to be defensive and provide clear error messages.
+    """
+    url = f"https://api.github.com/repos/{repo}/releases/latest"
+    headers = {"Accept": "application/vnd.github+json"}
+    try:
+        response = requests.get(url, headers=headers, timeout=timeout)
+        response.raise_for_status()
+        payload = response.json()
+    except Exception as exc:
+        message = str(exc)
+        if len(message) > 200:
+            message = f"{message[:197]}..."
+        return {
+            "raw_tag": None,
+            "normalized": None,
+            "changelog": "",
+            "changelog_url": f"https://github.com/{repo}/releases",
+            "update_available": False,
+            "error": message,
+        }
+
+    # Validate release is not draft/prerelease
+    is_draft = payload.get("draft", False)
+    is_prerelease = payload.get("prerelease", False)
+
+    if is_draft:
+        return {
+            "raw_tag": None,
+            "normalized": None,
+            "changelog": "",
+            "changelog_url": f"https://github.com/{repo}/releases",
+            "update_available": False,
+            "error": "Latest release is a draft (not yet published)",
+        }
+
+    if is_prerelease:
+        # Could make this configurable via settings in the future
+        return {
+            "raw_tag": None,
+            "normalized": None,
+            "changelog": "",
+            "changelog_url": f"https://github.com/{repo}/releases",
+            "update_available": False,
+            "error": "Latest release is a prerelease (beta/rc)",
+        }
+
+    raw_tag = (payload.get("tag_name") or payload.get("name") or "").strip()
+    normalized = normalize_version(raw_tag)
+    changelog = payload.get("body") or ""
+    changelog_url = payload.get("html_url") or f"https://github.com/{repo}/releases"
+    update_available = is_newer_version(normalized)
+    return {
+        "raw_tag": raw_tag or None,
+        "normalized": normalized,
+        "changelog": changelog,
+        "changelog_url": changelog_url,
+        "update_available": update_available,
+        "error": None,
+    }
+
+
+def fetch_release_by_tag(
+    tag: str, repo: str = DEFAULT_REPOSITORY, *, timeout: int = 10
+) -> dict[str, Any]:
+    """Fetch a specific release by tag name."""
+    # Ensure tag starts with 'v'
+    if not tag.startswith(("v", "V")):
+        tag = f"v{tag}"
+
+    url = f"https://api.github.com/repos/{repo}/releases/tags/{tag}"
+    headers = {"Accept": "application/vnd.github+json"}
+    try:
+        response = requests.get(url, headers=headers, timeout=timeout)
+        response.raise_for_status()
+        payload = response.json()
+    except Exception as exc:
+        message = str(exc)
+        if len(message) > 200:
+            message = f"{message[:197]}..."
+        return {
+            "changelog": "",
+            "changelog_url": f"https://github.com/{repo}/releases/tag/{tag}",
+            "error": message,
+        }
+
+    changelog = payload.get("body") or ""
+    changelog_url = payload.get("html_url") or f"https://github.com/{repo}/releases/tag/{tag}"
+    return {
+        "changelog": changelog,
+        "changelog_url": changelog_url,
+        "error": None,
+    }