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

quasarr/downloads/linkcrypters/filecrypt.py

@@ -395,42 +395,8 @@ def get_filecrypt_links(shared_state, token, title, url, password=None, mirror=N
                     links.extend(DLC(shared_state, dlc_file).decrypt())
                 except:
                     debug("DLC fallback failed, trying button fallback.")
-                    info("DLC not found! Falling back to first available download Button...")
-
-                    base_url = urlparse(url).netloc
-                    phpsessid = session.cookies.get('PHPSESSID')
-                    if not phpsessid:
-                        info("PHPSESSID cookie not found! Cannot proceed with download links extraction.")
-                        debug("Missing PHPSESSID cookie.")
-                        return False
-
-                    results = []
-                    debug("Parsing fallback buttons for download links.")
-
-                    for button in soup.find_all('button'):
-                        data_attrs = [v for k, v in button.attrs.items() if k.startswith('data-') and k != 'data-i18n']
-                        if not data_attrs:
-                            continue
-
-                        link_id = data_attrs[0]
-                        row = button.find_parent('tr')
-                        mirror_tag = row.find('a', class_='external_link') if row else None
-                        mirror_name = mirror_tag.get_text(strip=True) if mirror_tag else 'unknown'
-                        full_url = f"http://{base_url}/Link/{link_id}.html"
-                        results.append((full_url, mirror_name))
-
-                    sorted_results = sorted(results, key=lambda x: 0 if 'rapidgator' in x[1].lower() else 1)
-                    debug(f"Found {len(sorted_results)} fallback link candidates.")
-
-                    for result_url, mirror in sorted_results:
-                        info("You must solve circlecaptcha separately!")
-                        debug(f'Session "{phpsessid}" for {result_url} will not live long. Submit new CAPTCHA quickly!')
-                        return {
-                            "status": "replaced",
-                            "replace_url": result_url,
-                            "mirror": mirror,
-                            "session": phpsessid
-                        }
+                    info("Click'n'Load and DLC not found. Please use the fallback userscript instead!")
+                    return False
 
     if not links:
         info("No links found in Filecrypt response!")

quasarr/downloads/packages/__init__.py

@@ -6,6 +6,7 @@ import json
 from collections import defaultdict
 from urllib.parse import urlparse
 
+from quasarr.providers.jd_cache import JDPackageCache
 from quasarr.providers.log import info, debug
 from quasarr.providers.myjd_api import TokenExpiredException, RequestTimeoutException, MYJDException
 
@@ -102,9 +103,23 @@ def format_eta(seconds):
         return f"{hours:02}:{minutes:02}:{seconds:02}"
 
 
-def get_packages(shared_state):
+def get_packages(shared_state, _cache=None):
+    """
+    Get all packages from protected DB, failed DB, linkgrabber, and downloader.
+
+    Args:
+        shared_state: The shared state object
+        _cache: INTERNAL USE ONLY. Used by delete_package() to share cached data
+                within a single request. External callers should never pass this.
+    """
     packages = []
 
+    # Create cache for this request - only valid for duration of this call
+    if _cache is None:
+        _cache = JDPackageCache(shared_state.get_device())
+
+    cache = _cache  # Use shorter name internally
+
     protected_packages = shared_state.get_db("protected").retrieve_all_titles()
     if protected_packages:
         for package in protected_packages:
@@ -152,16 +167,15 @@ def get_packages(shared_state):
                 "comment": package_id,
                 "uuid": package_id
             })
-    try:
-        linkgrabber_packages = shared_state.get_device().linkgrabber.query_packages()
-        linkgrabber_links = shared_state.get_device().linkgrabber.query_links()
-    except (TokenExpiredException, RequestTimeoutException, MYJDException):
-        linkgrabber_packages = []
-        linkgrabber_links = []
+
+    # Use cached queries instead of direct API calls
+    linkgrabber_packages = cache.linkgrabber_packages
+    linkgrabber_links = cache.linkgrabber_links
 
     if linkgrabber_packages:
         for package in linkgrabber_packages:
-            comment = get_links_comment(package, shared_state.get_device().linkgrabber.query_links())
+            # Use cached linkgrabber_links instead of re-querying
+            comment = get_links_comment(package, linkgrabber_links)
             link_details = get_links_status(package, linkgrabber_links, is_archive=False)
 
             error = link_details["error"]
@@ -184,25 +198,21 @@ def get_packages(shared_state):
                 "uuid": package.get("uuid"),
                 "error": error
             })
-    try:
-        downloader_packages = shared_state.get_device().downloads.query_packages()
-        downloader_links = shared_state.get_device().downloads.query_links()
-    except (TokenExpiredException, RequestTimeoutException, MYJDException):
-        downloader_packages = []
-        downloader_links = []
+
+    # Use cached queries instead of direct API calls
+    downloader_packages = cache.downloader_packages
+    downloader_links = cache.downloader_links
 
     if downloader_packages and downloader_links:
+        # Get all package UUIDs that contain archives (uses link data, fallback to single API call)
+        archive_package_uuids = cache.get_archive_package_uuids(downloader_packages, downloader_links)
+
         for package in downloader_packages:
             comment = get_links_comment(package, downloader_links)
 
-            # Check if package is actually archived/extracted using archive info
-            is_archive = False
-            try:
-                archive_info = shared_state.get_device().extraction.get_archive_info([], [package.get("uuid")])
-                is_archive = True if archive_info and archive_info[0] else False
-            except:
-                # On error, don't assume it's an archive - check bytes instead
-                pass
+            # Check if this package contains any archive files
+            package_uuid = package.get("uuid")
+            is_archive = package_uuid in archive_package_uuids if package_uuid else False
 
             link_details = get_links_status(package, downloader_links, is_archive)
 
@@ -250,7 +260,7 @@ def get_packages(shared_state):
             time_left = "23:59:59"
             if package["type"] == "linkgrabber":
                 details = package["details"]
-                name = f"[Linkgrabber] {details["name"]}"
+                name = f"[Linkgrabber] {details['name']}"
                 try:
                     mb = mb_left = int(details["bytesTotal"]) / (1024 * 1024)
                 except KeyError:
@@ -302,7 +312,7 @@ def get_packages(shared_state):
                 package_uuid = package["uuid"]
             else:
                 details = package["details"]
-                name = f"[CAPTCHA not solved!] {details["title"]}"
+                name = f"[CAPTCHA not solved!] {details['title']}"
                 mb = mb_left = details["size_mb"]
                 try:
                     package_id = package["package_id"]
@@ -386,23 +396,23 @@ def get_packages(shared_state):
         else:
             info(f"Invalid package location {package['location']}")
 
-    if not shared_state.get_device().linkgrabber.is_collecting():
-        linkgrabber_packages = shared_state.get_device().linkgrabber.query_packages()
-        linkgrabber_links = shared_state.get_device().linkgrabber.query_links()
-
+    # Use cached is_collecting check
+    if not cache.is_collecting:
+        # Reuse cached data instead of re-querying
         packages_to_start = []
         links_to_start = []
 
         for package in linkgrabber_packages:
-            comment = get_links_comment(package, shared_state.get_device().linkgrabber.query_links())
+            # Use cached linkgrabber_links instead of re-querying
+            comment = get_links_comment(package, linkgrabber_links)
             if comment and comment.startswith("Quasarr_"):
                 package_uuid = package.get("uuid")
                 if package_uuid:
-                    linkgrabber_links = [link.get("uuid") for link in linkgrabber_links if
-                                         link.get("packageUUID") == package_uuid]
-                    if linkgrabber_links:
+                    package_link_ids = [link.get("uuid") for link in linkgrabber_links if
+                                        link.get("packageUUID") == package_uuid]
+                    if package_link_ids:
                         packages_to_start.append(package_uuid)
-                        links_to_start.extend(linkgrabber_links)
+                        links_to_start.extend(package_link_ids)
                     else:
                         info(f"Package {package_uuid} has no links in linkgrabber - skipping start")
 
@@ -420,13 +430,17 @@ def delete_package(shared_state, package_id):
     try:
         deleted_title = ""
 
-        packages = get_packages(shared_state)
+        # Create cache for this single delete operation
+        # Safe to reuse within this request since we fetch->find->delete atomically
+        cache = JDPackageCache(shared_state.get_device())
+
+        packages = get_packages(shared_state, _cache=cache)
         for package_location in packages:
             for package in packages[package_location]:
                 if package["nzo_id"] == package_id:
                     if package["type"] == "linkgrabber":
-                        ids = get_links_matching_package_uuid(package,
-                                                              shared_state.get_device().linkgrabber.query_links())
+                        # Use cached linkgrabber_links instead of re-querying
+                        ids = get_links_matching_package_uuid(package, cache.linkgrabber_links)
                         if ids:
                             shared_state.get_device().linkgrabber.cleanup(
                                 "DELETE_ALL",
@@ -437,8 +451,8 @@ def delete_package(shared_state, package_id):
                             )
                             break
                     elif package["type"] == "downloader":
-                        ids = get_links_matching_package_uuid(package,
-                                                              shared_state.get_device().downloads.query_links())
+                        # Use cached downloader_links instead of re-querying
+                        ids = get_links_matching_package_uuid(package, cache.downloader_links)
                         if ids:
                             shared_state.get_device().downloads.cleanup(
                                 "DELETE_ALL",

quasarr/providers/jd_cache.py

@@ -0,0 +1,131 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+from quasarr.providers.myjd_api import TokenExpiredException, RequestTimeoutException, MYJDException
+
+
+class JDPackageCache:
+    """
+    Caches JDownloader package/link queries within a single request.
+
+    IMPORTANT: This cache is ONLY valid for the duration of ONE get_packages()
+    or delete_package() call. JDownloader state can be modified at any time by
+    the user or third-party tools, so cached data must NEVER persist across
+    separate requests.
+
+    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):
+        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._is_collecting = None
+
+    @property
+    def linkgrabber_packages(self):
+        if self._linkgrabber_packages is None:
+            try:
+                self._linkgrabber_packages = self._device.linkgrabber.query_packages()
+            except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                self._linkgrabber_packages = []
+        return self._linkgrabber_packages
+
+    @property
+    def linkgrabber_links(self):
+        if self._linkgrabber_links is None:
+            try:
+                self._linkgrabber_links = self._device.linkgrabber.query_links()
+            except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                self._linkgrabber_links = []
+        return self._linkgrabber_links
+
+    @property
+    def downloader_packages(self):
+        if self._downloader_packages is None:
+            try:
+                self._downloader_packages = self._device.downloads.query_packages()
+            except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                self._downloader_packages = []
+        return self._downloader_packages
+
+    @property
+    def downloader_links(self):
+        if self._downloader_links is None:
+            try:
+                self._downloader_links = self._device.downloads.query_links()
+            except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                self._downloader_links = []
+        return self._downloader_links
+
+    @property
+    def is_collecting(self):
+        if self._is_collecting is None:
+            try:
+                self._is_collecting = self._device.linkgrabber.is_collecting()
+            except (TokenExpiredException, RequestTimeoutException, MYJDException):
+                self._is_collecting = False
+        return self._is_collecting
+
+    def get_archive_package_uuids(self, downloader_packages, downloader_links):
+        """
+        Get set of package UUIDs that contain at least one archive file.
+
+        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)
+
+        This correctly handles:
+        - Mixed packages (archive + non-archive files)
+        - Archives before extraction starts
+        - Archives during/after extraction
+        """
+        if self._archive_package_uuids is not None:
+            return self._archive_package_uuids
+
+        self._archive_package_uuids = set()
+
+        if not downloader_packages:
+            return self._archive_package_uuids
+
+        all_package_uuids = {p.get("uuid") for p in downloader_packages if p.get("uuid")}
+
+        # 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)
+
+        # Phase 2: Single API call for all unchecked packages
+        unchecked_package_uuids = list(all_package_uuids - self._archive_package_uuids)
+
+        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