quasarr 1.31.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/version.py

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

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.31.0.dist-info → quasarr-1.32.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quasarr
-Version: 1.31.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

{quasarr-1.31.0.dist-info → quasarr-1.32.0.dist-info}/RECORD

@@ -10,7 +10,7 @@ quasarr/downloads/linkcrypters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 quasarr/downloads/linkcrypters/al.py,sha256=mfUG5VclC_-FcGoZL9zHYD7dz7X_YpaNmoKkgiyl9-0,8812
 quasarr/downloads/linkcrypters/filecrypt.py,sha256=He8b7HjoPA-LmRwVwY0l_5JAVlJ3sYOXs5tcWXooqI4,17055
 quasarr/downloads/linkcrypters/hide.py,sha256=8YmNm49JmVa1zZdTHpjK9gnQrX435Cq5fo4JTNsIpds,4850
-quasarr/downloads/packages/__init__.py,sha256=6U4rk7hWoQCidIZy5O3-Pt5P7ZWEavHdbqZB0arxN1Y,18679
+quasarr/downloads/packages/__init__.py,sha256=zDMhLJz-16r4WSv2zzSlcBJEFrIUky2dRDkQaQLVSXY,32055
 quasarr/downloads/sources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 quasarr/downloads/sources/al.py,sha256=g587VESZRZHZ03uxHKpufEr5qAtzbyGLmoijksU35jk,27297
 quasarr/downloads/sources/by.py,sha256=kmUTn3izayRCV7W-t0E4kYE8qTbt3L3reCLozfvRGcU,3807
@@ -33,7 +33,7 @@ quasarr/providers/cloudflare.py,sha256=9iet8runc2VHVcA0_2z1qkrL6D5JKqz1ndktqCgsJ
 quasarr/providers/html_images.py,sha256=2n82gTJg7E7q2ytPFN4FWouYTIlmPYu_iHFtG7uktIA,28482
 quasarr/providers/html_templates.py,sha256=YMwdi7l_tHL0-qsUnwi4aPrE5Q6ZDxbjsPIfr-6uemY,10265
 quasarr/providers/imdb_metadata.py,sha256=10L4kZkt6Fg0HGdNcc6KCtIQHRYEqdarLyaMVN6mT8w,4843
-quasarr/providers/jd_cache.py,sha256=TfoQWetKZA7vO_qj2wFOGhgmVSXiMhwGpjl7HtLc_-c,5372
+quasarr/providers/jd_cache.py,sha256=mSvMrs3UwTn3sd9yGSJKGT-qwYeyYKC_l8whpXTVn7s,13530
 quasarr/providers/log.py,sha256=_g5RwtfuksARXnvryhsngzoJyFcNzj6suqd3ndqZM0Y,313
 quasarr/providers/myjd_api.py,sha256=Z3PEiO3c3UfDSr4Up5rgwTAnjloWHb-H1RkJ6BLKZv8,34140
 quasarr/providers/notifications.py,sha256=bohT-6yudmFnmZMc3BwCGX0n1HdzSVgQG_LDZm_38dI,4630
@@ -41,7 +41,7 @@ quasarr/providers/obfuscated.py,sha256=8FcmY9cjvjOoth-6LrPZ1CZZbpKplcaMMBE06FkdY
 quasarr/providers/shared_state.py,sha256=-TIiH2lkCfovq7bzUZicpUjXEjS87ZHCcevsFgySOqw,29944
 quasarr/providers/statistics.py,sha256=cEQixYnDMDqtm5wWe40E_2ucyo4mD0n3SrfelhQi1L8,6452
 quasarr/providers/utils.py,sha256=mcUPbcXMsLmrYv0CTZO5a9aOt2-JLyL3SZxu6N8OyjU,12075
-quasarr/providers/version.py,sha256=bjolkJyZ2IG4sc5GvrvZfwTeYTHWNvMAMp2vgnpPVZ0,4004
+quasarr/providers/version.py,sha256=qSQY_atV36RUnLVH8vYmVPbz_CX2LUB2abmOnivD8UQ,4004
 quasarr/providers/web_server.py,sha256=AYd0KRxdDWMBr87BP8wlSMuL4zZo0I_rY-vHBai6Pfg,1688
 quasarr/providers/sessions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 quasarr/providers/sessions/al.py,sha256=WXue9LaT4y0BzsbKtHbN6bb_72c4AZZWR9NP-vg9-cg,12462
@@ -69,11 +69,11 @@ quasarr/search/sources/wd.py,sha256=O02j3irSlVw2qES82g_qHuavAk-njjSRH1dHSCnOUas,
 quasarr/search/sources/wx.py,sha256=zlRvg7Ls-DFRo4sUBMRAXZRMfE2mnaXCkzP7pu53pIY,13842
 quasarr/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 quasarr/storage/config.py,sha256=SSTgIce2FVYoVTK_6OCU3msknhxuLA3EC4Kcrrf_dxQ,6378
-quasarr/storage/setup.py,sha256=0Gm6sHLmlcKvOGeli9eVuRVEP0Slz8-K5jZG0cNXaew,42041
+quasarr/storage/setup.py,sha256=0CmO4Z8GGHkn9YKgUYMxnPUfBIMZyafIrIg-K873Nrw,42070
 quasarr/storage/sqlite_database.py,sha256=yMqFQfKf0k7YS-6Z3_7pj4z1GwWSXJ8uvF4IydXsuTE,3554
-quasarr-1.31.0.dist-info/licenses/LICENSE,sha256=QQFCAfDgt7lSA8oSWDHIZ9aTjFbZaBJdjnGOHkuhK7k,1060
-quasarr-1.31.0.dist-info/METADATA,sha256=4jot6IFM_BIQwf8Ftx74l9W26M-2EaK8LXxC9XUn3qE,11009
-quasarr-1.31.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-quasarr-1.31.0.dist-info/entry_points.txt,sha256=gXi8mUKsIqKVvn-bOc8E5f04sK_KoMCC-ty6b2Hf-jc,40
-quasarr-1.31.0.dist-info/top_level.txt,sha256=dipJdaRda5ruTZkoGfZU60bY4l9dtPlmOWwxK_oGSF0,8
-quasarr-1.31.0.dist-info/RECORD,,
+quasarr-1.32.0.dist-info/licenses/LICENSE,sha256=QQFCAfDgt7lSA8oSWDHIZ9aTjFbZaBJdjnGOHkuhK7k,1060
+quasarr-1.32.0.dist-info/METADATA,sha256=Lz8rdtSm_dcHbamAQkeEOthTej3VCQs7d-HfZH5v3ng,11009
+quasarr-1.32.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+quasarr-1.32.0.dist-info/entry_points.txt,sha256=gXi8mUKsIqKVvn-bOc8E5f04sK_KoMCC-ty6b2Hf-jc,40
+quasarr-1.32.0.dist-info/top_level.txt,sha256=dipJdaRda5ruTZkoGfZU60bY4l9dtPlmOWwxK_oGSF0,8
+quasarr-1.32.0.dist-info/RECORD,,