quasarr 1.30.0__py3-none-any.whl → 1.32.0__py3-none-any.whl

quasarr/providers/jd_cache.py

@@ -2,8 +2,18 @@
 # Quasarr
 # Project by https://github.com/rix1337
 
+from quasarr.providers.log import debug
 from quasarr.providers.myjd_api import TokenExpiredException, RequestTimeoutException, MYJDException
 
+# Known archive extensions for fallback detection
+ARCHIVE_EXTENSIONS = frozenset([
+    '.rar', '.zip', '.7z', '.tar', '.gz', '.bz2', '.xz',
+    '.001', '.002', '.003', '.004', '.005', '.006', '.007', '.008', '.009',
+    '.r00', '.r01', '.r02', '.r03', '.r04', '.r05', '.r06', '.r07', '.r08', '.r09',
+    '.part1.rar', '.part01.rar', '.part001.rar',
+    '.part2.rar', '.part02.rar', '.part002.rar',
+])
+
 
 class JDPackageCache:
     """
@@ -16,116 +26,264 @@ class JDPackageCache:
 
     This reduces redundant API calls within a single operation where the same
     data (e.g., linkgrabber_links) is needed multiple times.
-
-    Usage:
-        # Cache is created and discarded within a single function call
-        cache = JDPackageCache(device)
-        packages = cache.linkgrabber_packages  # Fetches from API
-        packages = cache.linkgrabber_packages  # Returns cached (same request)
-        # Cache goes out of scope and is garbage collected
     """
 
     def __init__(self, device):
+        debug("JDPackageCache: Initializing new cache instance")
         self._device = device
         self._linkgrabber_packages = None
         self._linkgrabber_links = None
         self._downloader_packages = None
         self._downloader_links = None
-        self._archive_package_uuids = None  # Set of package UUIDs containing archives
+        self._archive_cache = {}  # package_uuid -> bool (is_archive)
         self._is_collecting = None
+        # Stats tracking
+        self._api_calls = 0
+        self._cache_hits = 0
+
+    def get_stats(self):
+        """Return cache statistics string."""
+        pkg_count = len(self._downloader_packages or []) + len(self._linkgrabber_packages or [])
+        link_count = len(self._downloader_links or []) + len(self._linkgrabber_links or [])
+        return f"{self._api_calls} API calls | {pkg_count} packages, {link_count} links cached"
 
     @property
     def linkgrabber_packages(self):
         if self._linkgrabber_packages is None:
+            debug("JDPackageCache: Fetching linkgrabber_packages from API")
+            self._api_calls += 1
             try:
                 self._linkgrabber_packages = self._device.linkgrabber.query_packages()
-            except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                debug(f"JDPackageCache: Retrieved {len(self._linkgrabber_packages)} linkgrabber packages")
+            except (TokenExpiredException, RequestTimeoutException, MYJDException) as e:
+                debug(f"JDPackageCache: Failed to fetch linkgrabber_packages: {e}")
                 self._linkgrabber_packages = []
+        else:
+            self._cache_hits += 1
+            debug(f"JDPackageCache: Using cached linkgrabber_packages ({len(self._linkgrabber_packages)} packages)")
         return self._linkgrabber_packages
 
     @property
     def linkgrabber_links(self):
         if self._linkgrabber_links is None:
+            debug("JDPackageCache: Fetching linkgrabber_links from API")
+            self._api_calls += 1
             try:
                 self._linkgrabber_links = self._device.linkgrabber.query_links()
-            except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                debug(f"JDPackageCache: Retrieved {len(self._linkgrabber_links)} linkgrabber links")
+            except (TokenExpiredException, RequestTimeoutException, MYJDException) as e:
+                debug(f"JDPackageCache: Failed to fetch linkgrabber_links: {e}")
                 self._linkgrabber_links = []
+        else:
+            self._cache_hits += 1
+            debug(f"JDPackageCache: Using cached linkgrabber_links ({len(self._linkgrabber_links)} links)")
         return self._linkgrabber_links
 
     @property
     def downloader_packages(self):
         if self._downloader_packages is None:
+            debug("JDPackageCache: Fetching downloader_packages from API")
+            self._api_calls += 1
             try:
                 self._downloader_packages = self._device.downloads.query_packages()
-            except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                debug(f"JDPackageCache: Retrieved {len(self._downloader_packages)} downloader packages")
+            except (TokenExpiredException, RequestTimeoutException, MYJDException) as e:
+                debug(f"JDPackageCache: Failed to fetch downloader_packages: {e}")
                 self._downloader_packages = []
+        else:
+            self._cache_hits += 1
+            debug(f"JDPackageCache: Using cached downloader_packages ({len(self._downloader_packages)} packages)")
         return self._downloader_packages
 
     @property
     def downloader_links(self):
         if self._downloader_links is None:
+            debug("JDPackageCache: Fetching downloader_links from API")
+            self._api_calls += 1
             try:
                 self._downloader_links = self._device.downloads.query_links()
-            except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                debug(f"JDPackageCache: Retrieved {len(self._downloader_links)} downloader links")
+            except (TokenExpiredException, RequestTimeoutException, MYJDException) as e:
+                debug(f"JDPackageCache: Failed to fetch downloader_links: {e}")
                 self._downloader_links = []
+        else:
+            self._cache_hits += 1
+            debug(f"JDPackageCache: Using cached downloader_links ({len(self._downloader_links)} links)")
         return self._downloader_links
 
     @property
     def is_collecting(self):
         if self._is_collecting is None:
+            debug("JDPackageCache: Checking is_collecting from API")
+            self._api_calls += 1
             try:
                 self._is_collecting = self._device.linkgrabber.is_collecting()
-            except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                debug(f"JDPackageCache: is_collecting = {self._is_collecting}")
+            except (TokenExpiredException, RequestTimeoutException, MYJDException) as e:
+                debug(f"JDPackageCache: Failed to check is_collecting: {e}")
                 self._is_collecting = False
+        else:
+            self._cache_hits += 1
+            debug(f"JDPackageCache: Using cached is_collecting = {self._is_collecting}")
         return self._is_collecting
 
-    def get_archive_package_uuids(self, downloader_packages, downloader_links):
+    def _has_archive_extension(self, package_uuid, links):
+        """Check if any link in the package has an archive file extension."""
+        for link in links:
+            if link.get("packageUUID") != package_uuid:
+                continue
+            name = link.get("name", "")
+            name_lower = name.lower()
+            for ext in ARCHIVE_EXTENSIONS:
+                if name_lower.endswith(ext):
+                    debug(
+                        f"JDPackageCache: Found archive extension '{ext}' in file '{name}' for package {package_uuid}")
+                    return True
+        return False
+
+    def _bulk_detect_archives(self, package_uuids):
         """
-        Get set of package UUIDs that contain at least one archive file.
+        Detect archives for multiple packages in ONE API call.
+
+        Returns:
+            tuple: (confirmed_archives: set, api_succeeded: bool)
+            - confirmed_archives: Package UUIDs confirmed as archives
+            - api_succeeded: Whether the API call worked (for fallback decisions)
+        """
+        confirmed_archives = set()
+
+        if not package_uuids:
+            debug("JDPackageCache: _bulk_detect_archives called with empty package_uuids")
+            return confirmed_archives, True
 
-        Two-phase detection:
-        1. Check extractionStatus in link data (free - catches in-progress/completed extractions)
-        2. Single API call for all remaining packages (catches pre-extraction archives)
+        package_list = list(package_uuids)
+        debug(f"JDPackageCache: Bulk archive detection for {len(package_list)} packages")
 
-        This correctly handles:
-        - Mixed packages (archive + non-archive files)
-        - Archives before extraction starts
-        - Archives during/after extraction
+        try:
+            self._api_calls += 1
+            archive_infos = self._device.extraction.get_archive_info([], package_list)
+            debug(f"JDPackageCache: get_archive_info returned {len(archive_infos) if archive_infos else 0} results")
+
+            if archive_infos:
+                for i, archive_info in enumerate(archive_infos):
+                    if archive_info:
+                        debug(f"JDPackageCache: archive_info[{i}] = {archive_info}")
+                        # Try to get packageUUID from response
+                        pkg_uuid = archive_info.get("packageUUID")
+                        if pkg_uuid:
+                            debug(f"JDPackageCache: Confirmed archive via packageUUID: {pkg_uuid}")
+                            confirmed_archives.add(pkg_uuid)
+                        else:
+                            # Log what fields ARE available for debugging
+                            debug(
+                                f"JDPackageCache: archive_info has no packageUUID, available keys: {list(archive_info.keys())}")
+                    else:
+                        debug(f"JDPackageCache: archive_info[{i}] is empty/None")
+
+            debug(f"JDPackageCache: Bulk detection confirmed {len(confirmed_archives)} archives: {confirmed_archives}")
+            return confirmed_archives, True
+
+        except Exception as e:
+            debug(f"JDPackageCache: Bulk archive detection API FAILED: {type(e).__name__}: {e}")
+            return confirmed_archives, False
+
+    def detect_all_archives(self, packages, links):
         """
-        if self._archive_package_uuids is not None:
-            return self._archive_package_uuids
+        Detect archives for all packages efficiently.
 
-        self._archive_package_uuids = set()
+        Uses ONE bulk API call, then applies safety fallbacks for packages
+        where detection was uncertain.
 
-        if not downloader_packages:
-            return self._archive_package_uuids
+        Args:
+            packages: List of downloader packages
+            links: List of downloader links (for extension fallback)
 
-        all_package_uuids = {p.get("uuid") for p in downloader_packages if p.get("uuid")}
+        Returns:
+            Set of package UUIDs that should be treated as archives
+        """
+        if not packages:
+            debug("JDPackageCache: detect_all_archives called with no packages")
+            return set()
 
-        # Phase 1: Check extractionStatus in already-fetched link data (free - no API call)
-        # This catches packages where extraction is in progress or completed
-        for link in downloader_links:
-            extraction_status = link.get("extractionStatus")
-            if extraction_status:  # Any non-empty extraction status means it's an archive
-                pkg_uuid = link.get("packageUUID")
-                if pkg_uuid:
-                    self._archive_package_uuids.add(pkg_uuid)
+        all_package_uuids = {p.get("uuid") for p in packages if p.get("uuid")}
+        debug(f"JDPackageCache: detect_all_archives for {len(all_package_uuids)} packages")
 
-        # Phase 2: Single API call for all unchecked packages
-        unchecked_package_uuids = list(all_package_uuids - self._archive_package_uuids)
+        # ONE bulk API call for all packages
+        confirmed_archives, api_succeeded = self._bulk_detect_archives(all_package_uuids)
+        debug(f"JDPackageCache: Bulk API succeeded={api_succeeded}, confirmed={len(confirmed_archives)} archives")
 
-        if unchecked_package_uuids:
-            try:
-                # One API call for ALL unchecked packages
-                archive_infos = self._device.extraction.get_archive_info([], unchecked_package_uuids)
-                if archive_infos:
-                    for archive_info in archive_infos:
-                        if archive_info:
-                            # Extract package UUID from response
-                            pkg_uuid = archive_info.get("packageUUID")
-                            if pkg_uuid:
-                                self._archive_package_uuids.add(pkg_uuid)
-            except:
-                pass
-
-        return self._archive_package_uuids
+        # For packages NOT confirmed as archives, apply safety fallbacks
+        unconfirmed = all_package_uuids - confirmed_archives
+        debug(f"JDPackageCache: {len(unconfirmed)} packages need fallback checking")
+
+        for pkg_uuid in unconfirmed:
+            # Fallback 1: Check file extensions
+            if self._has_archive_extension(pkg_uuid, links):
+                debug(f"JDPackageCache: Package {pkg_uuid} confirmed as archive via extension fallback")
+                confirmed_archives.add(pkg_uuid)
+            # Fallback 2: If bulk API failed completely, assume archive (safe)
+            elif not api_succeeded:
+                debug(f"JDPackageCache: SAFETY - Bulk API failed, assuming package {pkg_uuid} is archive")
+                confirmed_archives.add(pkg_uuid)
+            else:
+                debug(f"JDPackageCache: Package {pkg_uuid} confirmed as NON-archive (API worked, no extension match)")
+
+        # Cache results for is_package_archive() lookups
+        for pkg_uuid in all_package_uuids:
+            self._archive_cache[pkg_uuid] = pkg_uuid in confirmed_archives
+
+        debug(
+            f"JDPackageCache: Final archive detection: {len(confirmed_archives)}/{len(all_package_uuids)} packages are archives")
+        return confirmed_archives
+
+    def is_package_archive(self, package_uuid, links=None):
+        """
+        Check if a package contains archive files.
+
+        Prefer calling detect_all_archives() first for efficiency.
+        This method is for single lookups or cache hits.
+
+        SAFETY: On API error, defaults to True (assume archive) to prevent
+        premature "finished" status.
+        """
+        if package_uuid is None:
+            debug("JDPackageCache: is_package_archive called with None UUID")
+            return False
+
+        if package_uuid in self._archive_cache:
+            self._cache_hits += 1
+            cached = self._archive_cache[package_uuid]
+            debug(f"JDPackageCache: is_package_archive({package_uuid}) = {cached} (cached)")
+            return cached
+
+        debug(f"JDPackageCache: is_package_archive({package_uuid}) - cache miss, querying API")
+
+        # Single package lookup (fallback if detect_all_archives wasn't called)
+        is_archive = None
+        api_failed = False
+
+        try:
+            self._api_calls += 1
+            archive_info = self._device.extraction.get_archive_info([], [package_uuid])
+            debug(f"JDPackageCache: Single get_archive_info returned: {archive_info}")
+            # Original logic: is_archive = True if archive_info and archive_info[0] else False
+            is_archive = True if archive_info and archive_info[0] else False
+            debug(f"JDPackageCache: API says is_archive = {is_archive}")
+        except Exception as e:
+            api_failed = True
+            debug(f"JDPackageCache: Single archive detection API FAILED for {package_uuid}: {type(e).__name__}: {e}")
+
+        # Fallback: check file extensions if API failed or returned False
+        if (api_failed or not is_archive) and links:
+            if self._has_archive_extension(package_uuid, links):
+                debug(f"JDPackageCache: Package {package_uuid} confirmed as archive via extension fallback")
+                is_archive = True
+
+        # SAFETY: If API failed and no extension detected, assume archive (conservative)
+        if is_archive is None:
+            debug(f"JDPackageCache: SAFETY - Detection uncertain for {package_uuid}, assuming archive")
+            is_archive = True
+
+        self._archive_cache[package_uuid] = is_archive
+        debug(f"JDPackageCache: is_package_archive({package_uuid}) = {is_archive} (final)")
+        return is_archive

quasarr/providers/utils.py

@@ -6,9 +6,12 @@ import os
 import re
 import socket
 import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from io import BytesIO
 from urllib.parse import urlparse
 
 import requests
+from PIL import Image
 
 # Fallback user agent when FlareSolverr is not available
 FALLBACK_USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
@@ -187,3 +190,177 @@ def is_site_usable(shared_state, shorthand):
     password = config.get('password')
 
     return bool(user and password)
+
+
+# =============================================================================
+# LINK STATUS CHECKING
+# =============================================================================
+
+def generate_status_url(href, crypter_type):
+    """
+    Generate a status URL for crypters that support it.
+    Returns None if status URL cannot be generated.
+    """
+    if crypter_type == "hide":
+        # hide.cx links: https://hide.cx/folder/{UUID} or /container/{UUID} → https://hide.cx/state/{UUID}
+        match = re.search(r'hide\.cx/(?:folder/|container/)?([a-f0-9-]{36})', href, re.IGNORECASE)
+        if match:
+            uuid = match.group(1)
+            return f"https://hide.cx/state/{uuid}"
+
+    elif crypter_type == "tolink":
+        # tolink links: https://tolink.to/f/{ID} → https://tolink.to/f/{ID}/s/status.png
+        match = re.search(r'tolink\.to/f/([a-zA-Z0-9]+)', href, re.IGNORECASE)
+        if match:
+            link_id = match.group(1)
+            return f"https://tolink.to/f/{link_id}/s/status.png"
+
+    return None
+
+
+def detect_crypter_type(url):
+    """Detect crypter type from URL for status checking."""
+    url_lower = url.lower()
+    if 'hide.' in url_lower:
+        return "hide"
+    elif 'tolink.' in url_lower:
+        return "tolink"
+    elif 'filecrypt.' in url_lower:
+        return "filecrypt"
+    elif 'keeplinks.' in url_lower:
+        return "keeplinks"
+    return None
+
+
+def image_has_green(image_data):
+    """
+    Analyze image data to check if it contains green pixels.
+    Returns True if any significant green is detected (indicating online status).
+    """
+    try:
+        img = Image.open(BytesIO(image_data))
+        # Convert palette images with transparency to RGBA first to avoid warning
+        if img.mode == 'P' and 'transparency' in img.info:
+            img = img.convert('RGBA')
+        img = img.convert('RGB')
+
+        pixels = list(img.getdata())
+
+        for r, g, b in pixels:
+            # Check if pixel is greenish: green channel is dominant
+            # and has a reasonable absolute value
+            if g > 100 and g > r * 1.3 and g > b * 1.3:
+                return True
+
+        return False
+    except Exception:
+        # If we can't analyze, assume online to not skip valid links
+        return True
+
+
+def fetch_status_image(status_url, shared_state=None):
+    """
+    Fetch a status image and return (status_url, image_data).
+    Returns (status_url, None) on failure.
+    """
+    try:
+        headers = {}
+        if shared_state:
+            user_agent = shared_state.values.get("user_agent")
+            if user_agent:
+                headers["User-Agent"] = user_agent
+        response = requests.get(status_url, headers=headers, timeout=10)
+        if response.status_code == 200:
+            return (status_url, response.content)
+    except Exception:
+        pass
+    return (status_url, None)
+
+
+def check_links_online_status(links_with_status, shared_state=None):
+    """
+    Check online status for links that have status URLs.
+    Returns list of links that are online (or have no status URL to check).
+
+    links_with_status: list of [href, identifier, status_url] where status_url can be None
+    shared_state: optional shared state for user agent
+    """
+    links_to_check = [(i, link) for i, link in enumerate(links_with_status) if link[2]]
+
+    if not links_to_check:
+        # No status URLs to check, return all links as potentially online
+        return [[link[0], link[1]] for link in links_with_status]
+
+    # Batch fetch status images
+    status_results = {}  # status_url -> has_green
+    status_urls = list(set(link[2] for _, link in links_to_check))
+
+    batch_size = 10
+    for i in range(0, len(status_urls), batch_size):
+        batch = status_urls[i:i + batch_size]
+        with ThreadPoolExecutor(max_workers=batch_size) as executor:
+            futures = [executor.submit(fetch_status_image, url, shared_state) for url in batch]
+            for future in as_completed(futures):
+                try:
+                    status_url, image_data = future.result()
+                    if image_data:
+                        status_results[status_url] = image_has_green(image_data)
+                    else:
+                        # Could not fetch, assume online
+                        status_results[status_url] = True
+                except Exception:
+                    pass
+
+    # Filter to online links
+    online_links = []
+
+    for link in links_with_status:
+        href, identifier, status_url = link
+        if not status_url:
+            # No status URL, include link
+            online_links.append([href, identifier])
+        elif status_url in status_results:
+            if status_results[status_url]:
+                online_links.append([href, identifier])
+        else:
+            # Status check failed, include link
+            online_links.append([href, identifier])
+
+    return online_links
+
+
+def filter_offline_links(links, shared_state=None, log_func=None):
+    """
+    Filter out offline links from a list of [url, identifier] pairs.
+    Only checks links where status can be verified (hide.cx, tolink).
+    Returns filtered list of [url, identifier] pairs.
+    """
+    if not links:
+        return links
+
+    # Build list with status URLs
+    links_with_status = []
+    for link in links:
+        url = link[0]
+        identifier = link[1] if len(link) > 1 else "unknown"
+        crypter_type = detect_crypter_type(url)
+        status_url = generate_status_url(url, crypter_type) if crypter_type else None
+        links_with_status.append([url, identifier, status_url])
+
+    # Check if any links can be verified
+    verifiable_count = sum(1 for l in links_with_status if l[2])
+    if verifiable_count == 0:
+        # Nothing to verify, return original links
+        return links
+
+    if log_func:
+        log_func(f"Checking online status for {verifiable_count} verifiable link(s)...")
+
+    # Check status and filter
+    online_links = check_links_online_status(links_with_status, shared_state)
+
+    if log_func and len(online_links) < len(links):
+        offline_count = len(links) - len(online_links)
+        log_func(f"Filtered out {offline_count} offline link(s)")
+
+    return online_links

quasarr/providers/version.py

@@ -8,7 +8,7 @@ import requests
 
 
 def get_version():
-    return "1.30.0"
+    return "1.32.0"
 
 
 def get_latest_version():

quasarr/search/sources/wx.py

@@ -131,6 +131,7 @@ def wx_feed(shared_state, start_time, request_from, mirror=None):
 def wx_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
     """
     Search using internal API.
+    Deduplicates results by fulltitle - each unique release appears only once.
     """
     releases = []
     host = shared_state.values["config"]("Hostnames").get(hostname)
@@ -201,6 +202,9 @@ def wx_search(shared_state, start_time, request_from, search_string, mirror=None
 
         debug(f"{hostname.upper()}: Found {len(items)} items in search results")
 
+        # Track seen titles to deduplicate (mirrors have same fulltitle)
+        seen_titles = set()
+
         for item in items:
             try:
                 uid = item.get('uid')
@@ -238,29 +242,34 @@ def wx_search(shared_state, start_time, request_from, search_string, mirror=None
                     title = title.replace(' ', '.')
 
                     if shared_state.is_valid_release(title, request_from, search_string, season, episode):
-                        published = detail_item.get('updated_at') or detail_item.get('created_at')
-                        if not published:
-                            published = datetime.now().strftime("%a, %d %b %Y %H:%M:%S +0000")
-                        password = f"www.{host}"
-
-                        payload = urlsafe_b64encode(
-                            f"{title}|{source}|{mirror}|0|{password}|{item_imdb_id or ''}".encode("utf-8")
-                        ).decode("utf-8")
-                        link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
-
-                        releases.append({
-                            "details": {
-                                "title": title,
-                                "hostname": hostname,
-                                "imdb_id": item_imdb_id,
-                                "link": link,
-                                "mirror": mirror,
-                                "size": 0,
-                                "date": published,
-                                "source": source
-                            },
-                            "type": "protected"
-                        })
+                        # Skip if we've already seen this exact title
+                        if title in seen_titles:
+                            debug(f"{hostname.upper()}: Skipping duplicate main title: {title}")
+                        else:
+                            seen_titles.add(title)
+                            published = detail_item.get('updated_at') or detail_item.get('created_at')
+                            if not published:
+                                published = datetime.now().strftime("%a, %d %b %Y %H:%M:%S +0000")
+                            password = f"www.{host}"
+
+                            payload = urlsafe_b64encode(
+                                f"{title}|{source}|{mirror}|0|{password}|{item_imdb_id or ''}".encode("utf-8")
+                            ).decode("utf-8")
+                            link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+                            releases.append({
+                                "details": {
+                                    "title": title,
+                                    "hostname": hostname,
+                                    "imdb_id": item_imdb_id,
+                                    "link": link,
+                                    "mirror": mirror,
+                                    "size": 0,
+                                    "date": published,
+                                    "source": source
+                                },
+                                "type": "protected"
+                            })
 
                 if 'releases' in detail_item and isinstance(detail_item['releases'], list):
                     debug(f"{hostname.upper()}: Found {len(detail_item['releases'])} releases for {uid}")
@@ -279,6 +288,13 @@ def wx_search(shared_state, start_time, request_from, search_string, mirror=None
                                 debug(f"{hostname.upper()}: ✗ Release filtered out: {release_title}")
                                 continue
 
+                            # Skip if we've already seen this exact title (deduplication)
+                            if release_title in seen_titles:
+                                debug(f"{hostname.upper()}: Skipping duplicate release: {release_title}")
+                                continue
+
+                            seen_titles.add(release_title)
+
                             release_uid = release.get('uid')
                             if release_uid:
                                 release_source = f"https://{host}/detail/{uid}?release={release_uid}"
@@ -323,7 +339,7 @@ def wx_search(shared_state, start_time, request_from, search_string, mirror=None
                 debug(f"{hostname.upper()}: {traceback.format_exc()}")
                 continue
 
-        debug(f"{hostname.upper()}: Returning {len(releases)} total releases")
+        debug(f"{hostname.upper()}: Returning {len(releases)} total releases (deduplicated)")
 
     except Exception as e:
         info(f"Error in {hostname.upper()} search: {e}")

quasarr/storage/setup.py

@@ -239,7 +239,9 @@ def hostname_form_html(shared_state, message, show_restart_button=False, show_sk
     .import-status {{
         margin-top: 0.5rem;
         font-size: 0.875rem;
-        min-height: 1.25rem;
+    }}
+    .import-status:empty {{
+        display: none;
     }}
     .import-status.success {{ color: #198754; }}
     .import-status.error {{ color: #dc3545; }}

{quasarr-1.30.0.dist-info → quasarr-1.32.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quasarr
-Version: 1.30.0
+Version: 1.32.0
 Summary: Quasarr connects JDownloader with Radarr, Sonarr and LazyLibrarian. It also decrypts links protected by CAPTCHAs.
 Home-page: https://github.com/rix1337/Quasarr
 Author: rix1337