quasarr 1.23.0__py3-none-any.whl → 1.24.0__py3-none-any.whl

quasarr/downloads/__init__.py

@@ -1,11 +1,9 @@
 # -*- coding: utf-8 -*-
 # Quasarr
 # Project by https://github.com/rix1337
-#
-# Special note: The signatures of all handlers must stay the same so we can neatly call them in download()
-# Same is true for every get_xx_download_links() function in sources/xx.py
 
 import json
+import re
 
 from quasarr.downloads.linkcrypters.hide import decrypt_links_if_hide
 from quasarr.downloads.sources.al import get_al_download_links
@@ -19,7 +17,7 @@ from quasarr.downloads.sources.he import get_he_download_links
 from quasarr.downloads.sources.mb import get_mb_download_links
 from quasarr.downloads.sources.nk import get_nk_download_links
 from quasarr.downloads.sources.nx import get_nx_download_links
-from quasarr.downloads.sources.sf import get_sf_download_links, resolve_sf_redirect
+from quasarr.downloads.sources.sf import get_sf_download_links
 from quasarr.downloads.sources.sj import get_sj_download_links
 from quasarr.downloads.sources.sl import get_sl_download_links
 from quasarr.downloads.sources.wd import get_wd_download_links
@@ -28,306 +26,247 @@ from quasarr.providers.log import info
 from quasarr.providers.notifications import send_discord_message
 from quasarr.providers.statistics import StatsHelper
 
-
-def handle_unprotected(shared_state, title, password, package_id, imdb_id, url,
-                       mirror=None, size_mb=None, links=None, func=None, label=""):
-    if func:
-        links = func(shared_state, url, mirror, title)
-
-    if links:
-        info(f"Decrypted {len(links)} download links for {title}")
-        send_discord_message(shared_state, title=title, case="unprotected", imdb_id=imdb_id, source=url)
-        added = shared_state.download_package(links, title, password, package_id)
-        if not added:
-            fail(title, package_id, shared_state,
-                 reason=f'Failed to add {len(links)} links for "{title}" to linkgrabber')
-            return {"success": False, "title": title}
-    else:
-        fail(title, package_id, shared_state,
-             reason=f'Offline / no links found for "{title}" on {label} - "{url}"')
-        return {"success": False, "title": title}
-
-    StatsHelper(shared_state).increment_package_with_links(links)
-    return {"success": True, "title": title}
-
-
-def handle_protected(shared_state, title, password, package_id, imdb_id, url,
-                     mirror=None, size_mb=None, func=None, label=""):
-    links = func(shared_state, url, mirror, title)
-    if links:
-        valid_links = [pair for pair in links if "/404.html" not in pair[0]]
-
-        # If none left, IP was banned
-        if not valid_links:
-            fail(
-                title,
-                package_id,
-                shared_state,
-                reason=f'IP was banned during download of "{title}" on {label} - "{url}"'
-            )
-            return {"success": False, "title": title}
-        links = valid_links
-
-        info(f'CAPTCHA-Solution required for "{title}" at: "{shared_state.values['external_address']}/captcha"')
-        send_discord_message(shared_state, title=title, case="captcha", imdb_id=imdb_id, source=url)
-        blob = json.dumps({"title": title, "links": links, "size_mb": size_mb, "password": password})
-        shared_state.values["database"]("protected").update_store(package_id, blob)
-    else:
-        fail(title, package_id, shared_state,
-             reason=f'No protected links found for "{title}" on {label} - "{url}"')
-        return {"success": False, "title": title}
-    return {"success": True, "title": title}
-
-
-def handle_hide(shared_state, title, password, package_id, imdb_id, url, links, label):
+# =============================================================================
+# CRYPTER CONFIGURATION
+# =============================================================================
+
+# Patterns match crypter name only - TLDs may change
+AUTO_DECRYPT_PATTERNS = {
+    'hide': re.compile(r'hide\.', re.IGNORECASE),
+}
+
+PROTECTED_PATTERNS = {
+    'filecrypt': re.compile(r'filecrypt\.', re.IGNORECASE),
+    'tolink': re.compile(r'tolink\.', re.IGNORECASE),
+    'keeplinks': re.compile(r'keeplinks\.', re.IGNORECASE),
+}
+
+# Source key -> getter function mapping
+# All getters have signature: (shared_state, url, mirror, title, password)
+# AL uses password as release_id, others ignore it
+SOURCE_GETTERS = {
+    'al': get_al_download_links,
+    'by': get_by_download_links,
+    'dd': get_dd_download_links,
+    'dj': get_dj_download_links,
+    'dl': get_dl_download_links,
+    'dt': get_dt_download_links,
+    'dw': get_dw_download_links,
+    'he': get_he_download_links,
+    'mb': get_mb_download_links,
+    'nk': get_nk_download_links,
+    'nx': get_nx_download_links,
+    'sf': get_sf_download_links,
+    'sj': get_sj_download_links,
+    'sl': get_sl_download_links,
+    'wd': get_wd_download_links,
+    'wx': get_wx_download_links,
+}
+
+
+# =============================================================================
+# LINK CLASSIFICATION
+# =============================================================================
+
+def detect_crypter(url):
+    """Returns (crypter_name, 'auto'|'protected') or (None, None)."""
+    for name, pattern in AUTO_DECRYPT_PATTERNS.items():
+        if pattern.search(url):
+            return name, 'auto'
+    for name, pattern in PROTECTED_PATTERNS.items():
+        if pattern.search(url):
+            return name, 'protected'
+    return None, None
+
+
+def is_junkies_link(url, shared_state):
+    """Check if URL is a junkies (sj/dj) link."""
+    sj = shared_state.values["config"]("Hostnames").get("sj")
+    dj = shared_state.values["config"]("Hostnames").get("dj")
+    url_lower = url.lower()
+    return (sj and sj.lower() in url_lower) or (dj and dj.lower() in url_lower)
+
+
+def classify_links(links, shared_state):
     """
-    Attempt to decrypt hide.cx links and handle the result.
-    Returns a dict with 'handled' (bool) and 'result' (response dict or None).
+    Classify links into direct/auto/protected categories.
+    Direct = anything that's not a known crypter or junkies link.
+    Mirror names from source are preserved.
     """
-    decrypted = decrypt_links_if_hide(shared_state, links)
-
-    if not decrypted or decrypted.get("status") == "none":
-        return {"handled": False, "result": None}
-
-    status = decrypted.get("status", "error")
-    decrypted_links = decrypted.get("results", [])
-
-    if status == "success":
-        result = handle_unprotected(
-            shared_state, title, password, package_id, imdb_id, url,
-            links=decrypted_links, label=label
-        )
-        return {"handled": True, "result": result}
-    else:
-        fail(title, package_id, shared_state,
-             reason=f'Error decrypting hide.cx links for "{title}" on {label} - "{url}"')
-        return {"handled": True, "result": {"success": False, "title": title}}
-
-
-def handle_al(shared_state, title, password, package_id, imdb_id, url, mirror, size_mb):
-    data = get_al_download_links(shared_state, url, mirror, title, password)
-    links = data.get("links", [])
-    title = data.get("title", title)
-    password = data.get("password", "")
-    return handle_unprotected(
-        shared_state, title, password, package_id, imdb_id, url,
-        links=links,
-        label='AL'
-    )
-
-
-def handle_by(shared_state, title, password, package_id, imdb_id, url, mirror, size_mb):
-    links = get_by_download_links(shared_state, url, mirror, title)
-    if not links:
-        fail(title, package_id, shared_state,
-             reason=f'Offline / no links found for "{title}" on BY - "{url}"')
-        return {"success": False, "title": title}
+    classified = {'direct': [], 'auto': [], 'protected': []}
 
-    decrypt_result = handle_hide(
-        shared_state, title, password, package_id, imdb_id, url, links, 'BY'
-    )
+    for link in links:
+        url = link[0]
 
-    if decrypt_result["handled"]:
-        return decrypt_result["result"]
+        if is_junkies_link(url, shared_state):
+            classified['protected'].append(link)
+            continue
 
-    return handle_protected(
-        shared_state, title, password, package_id, imdb_id, url,
-        mirror=mirror,
-        size_mb=size_mb,
-        func=lambda ss, u, m, t: links,
-        label='BY'
-    )
+        crypter, crypter_type = detect_crypter(url)
+        if crypter_type == 'auto':
+            classified['auto'].append(link)
+        elif crypter_type == 'protected':
+            classified['protected'].append(link)
+        else:
+            # Not a known crypter = direct hoster link
+            classified['direct'].append(link)
 
+    return classified
 
-def handle_dl(shared_state, title, password, package_id, imdb_id, url, mirror, size_mb):
-    links, extracted_password = get_dl_download_links(shared_state, url, mirror, title)
-    if not links:
-        fail(title, package_id, shared_state,
-             reason=f'Offline / no links found for "{title}" on DL - "{url}"')
-        return {"success": False, "title": title}
-
-    # Use extracted password if available, otherwise fall back to provided password
-    final_password = extracted_password if extracted_password else password
-
-    decrypt_result = handle_hide(
-        shared_state, title, final_password, package_id, imdb_id, url, links, 'DL'
-    )
-
-    if decrypt_result["handled"]:
-        return decrypt_result["result"]
-
-    return handle_protected(
-        shared_state, title, final_password, package_id, imdb_id, url,
-        mirror=mirror,
-        size_mb=size_mb,
-        func=lambda ss, u, m, t: links,
-        label='DL'
-    )
-
-
-def handle_sf(shared_state, title, password, package_id, imdb_id, url, mirror, size_mb):
-    if url.startswith(f"https://{shared_state.values['config']('Hostnames').get('sf')}/external"):
-        url = resolve_sf_redirect(url, shared_state.values["user_agent"])
-    elif url.startswith(f"https://{shared_state.values['config']('Hostnames').get('sf')}/"):
-        data = get_sf_download_links(shared_state, url, mirror, title)
-        url = data.get("real_url")
-        if not imdb_id:
-            imdb_id = data.get("imdb_id")
-
-    if not url:
-        fail(title, package_id, shared_state,
-             reason=f'Failed to get download link from SF for "{title}" - "{url}"')
-        return {"success": False, "title": title}
-
-    return handle_protected(
-        shared_state, title, password, package_id, imdb_id, url,
-        mirror=mirror,
-        size_mb=size_mb,
-        func=lambda ss, u, m, t: [[url, "filecrypt"]],
-        label='SF'
-    )
-
-
-def handle_sl(shared_state, title, password, package_id, imdb_id, url, mirror, size_mb):
-    data = get_sl_download_links(shared_state, url, mirror, title)
-    links = data.get("links")
-    if not imdb_id:
-        imdb_id = data.get("imdb_id")
-    return handle_unprotected(
-        shared_state, title, password, package_id, imdb_id, url,
-        links=links,
-        label='SL'
-    )
-
-
-def handle_wd(shared_state, title, password, package_id, imdb_id, url, mirror, size_mb):
-    data = get_wd_download_links(shared_state, url, mirror, title)
-    links = data.get("links", []) if data else []
-    if not links:
-        fail(title, package_id, shared_state,
-             reason=f'Offline / no links found for "{title}" on WD - "{url}"')
-        return {"success": False, "title": title}
 
-    decrypt_result = handle_hide(
-        shared_state, title, password, package_id, imdb_id, url, links, 'WD'
-    )
+# =============================================================================
+# LINK PROCESSING
+# =============================================================================
 
-    if decrypt_result["handled"]:
-        return decrypt_result["result"]
+def handle_direct_links(shared_state, links, title, password, package_id):
+    """Send direct hoster links to JDownloader."""
+    urls = [link[0] for link in links]
+    info(f"Sending {len(urls)} direct download links for {title}")
 
-    return handle_protected(
-        shared_state, title, password, package_id, imdb_id, url,
-        mirror=mirror,
-        size_mb=size_mb,
-        func=lambda ss, u, m, t: links,
-        label='WD'
-    )
+    if shared_state.download_package(urls, title, password, package_id):
+        StatsHelper(shared_state).increment_package_with_links(urls)
+        return {"success": True}
+    return {"success": False, "reason": f'Failed to add {len(urls)} links to linkgrabber'}
 
 
-def handle_wx(shared_state, title, password, package_id, imdb_id, url, mirror, size_mb):
-    links = get_wx_download_links(shared_state, url, mirror, title)
-    if not links:
-        fail(title, package_id, shared_state,
-             reason=f'Offline / no links found for "{title}" on WX - "{url}"')
-        return {"success": False, "title": title}
+def handle_auto_decrypt_links(shared_state, links, title, password, package_id):
+    """Decrypt hide.cx links and send to JDownloader."""
+    result = decrypt_links_if_hide(shared_state, links)
 
-    decrypt_result = handle_hide(
-        shared_state, title, password, package_id, imdb_id, url, links, 'WX'
-    )
+    if result.get("status") != "success":
+        return {"success": False, "reason": "Auto-decrypt failed"}
 
-    if decrypt_result["handled"]:
-        return decrypt_result["result"]
+    decrypted_urls = result.get("results", [])
+    if not decrypted_urls:
+        return {"success": False, "reason": "No links decrypted"}
 
-    return handle_protected(
-        shared_state, title, password, package_id, imdb_id, url,
-        mirror=mirror,
-        size_mb=size_mb,
-        func=lambda ss, u, m, t: links,
-        label='WX'
-    )
+    info(f"Decrypted {len(decrypted_urls)} download links for {title}")
 
+    if shared_state.download_package(decrypted_urls, title, password, package_id):
+        StatsHelper(shared_state).increment_package_with_links(decrypted_urls)
+        return {"success": True}
+    return {"success": False, "reason": "Failed to add decrypted links to linkgrabber"}
 
-def download(shared_state, request_from, title, url, mirror, size_mb, password, imdb_id=None):
-    if "lazylibrarian" in request_from.lower():
-        category = "docs"
-    elif "radarr" in request_from.lower():
-        category = "movies"
-    else:
-        category = "tv"
 
+def store_protected_links(shared_state, links, title, password, package_id, size_mb=None, original_url=None):
+    """Store protected links for CAPTCHA UI."""
+    blob_data = {"title": title, "links": links, "password": password, "size_mb": size_mb}
+    if original_url:
+        blob_data["original_url"] = original_url
+
+    shared_state.values["database"]("protected").update_store(package_id, json.dumps(blob_data))
+    info(f'CAPTCHA-Solution required for "{title}" at: "{shared_state.values["external_address"]}/captcha"')
+    return {"success": True}
+
+
+def process_links(shared_state, source_result, title, password, package_id, imdb_id, source_url, size_mb, label):
+    """
+    Central link processor with priority: direct → auto-decrypt → protected.
+    If ANY direct links exist, use them and ignore crypted fallbacks.
+    """
+    if not source_result:
+        return fail(title, package_id, shared_state,
+                    reason=f'Source returned no data for "{title}" on {label} - "{source_url}"')
+
+    links = source_result.get("links", [])
+    password = source_result.get("password") or password
+    imdb_id = imdb_id or source_result.get("imdb_id")
+    title = source_result.get("title") or title
+
+    if not links:
+        return fail(title, package_id, shared_state,
+                    reason=f'No links found for "{title}" on {label} - "{source_url}"')
+
+    # Filter out 404 links
+    valid_links = [link for link in links if "/404.html" not in link[0]]
+    if not valid_links:
+        return fail(title, package_id, shared_state,
+                    reason=f'All links are offline or IP is banned for "{title}" on {label} - "{source_url}"')
+    links = valid_links
+
+    classified = classify_links(links, shared_state)
+
+    # PRIORITY 1: Direct hoster links
+    if classified['direct']:
+        info(f"Found {len(classified['direct'])} direct hoster links for {title}")
+        send_discord_message(shared_state, title=title, case="unprotected", imdb_id=imdb_id, source=source_url)
+        result = handle_direct_links(shared_state, classified['direct'], title, password, package_id)
+        if result["success"]:
+            return {"success": True, "title": title}
+        return fail(title, package_id, shared_state, reason=result.get("reason"))
+
+    # PRIORITY 2: Auto-decryptable (hide.cx)
+    if classified['auto']:
+        info(f"Found {len(classified['auto'])} auto-decryptable links for {title}")
+        result = handle_auto_decrypt_links(shared_state, classified['auto'], title, password, package_id)
+        if result["success"]:
+            send_discord_message(shared_state, title=title, case="unprotected", imdb_id=imdb_id, source=source_url)
+            return {"success": True, "title": title}
+        info(f"Auto-decrypt failed for {title}, checking for protected fallback...")
+
+    # PRIORITY 3: Protected (filecrypt, tolink, keeplinks, junkies)
+    if classified['protected']:
+        info(f"Found {len(classified['protected'])} protected links for {title}")
+        send_discord_message(shared_state, title=title, case="captcha", imdb_id=imdb_id, source=source_url)
+        store_protected_links(shared_state, classified['protected'], title, password, package_id,
+                              size_mb=size_mb, original_url=source_url)
+        return {"success": True, "title": title}
+
+    return fail(title, package_id, shared_state,
+                reason=f'No usable links found for "{title}" on {label} - "{source_url}"')
+
+
+# =============================================================================
+# MAIN ENTRY POINT
+# =============================================================================
+
+def download(shared_state, request_from, title, url, mirror, size_mb, password, imdb_id=None):
+    """Main download entry point."""
+    category = "docs" if "lazylibrarian" in request_from.lower() else \
+        "movies" if "radarr" in request_from.lower() else "tv"
     package_id = f"Quasarr_{category}_{str(hash(title + url)).replace('-', '')}"
 
-    if imdb_id is not None and imdb_id.lower() == "none":
+    if imdb_id and imdb_id.lower() == "none":
         imdb_id = None
 
     config = shared_state.values["config"]("Hostnames")
-    flags = {
-        'AL': config.get("al"),
-        'BY': config.get("by"),
-        'DD': config.get("dd"),
-        'DJ': config.get("dj"),
-        'DL': config.get("dl"),
-        'DT': config.get("dt"),
-        'DW': config.get("dw"),
-        'HE': config.get("he"),
-        'MB': config.get("mb"),
-        'NK': config.get("nk"),
-        'NX': config.get("nx"),
-        'SF': config.get("sf"),
-        'SJ': config.get("sj"),
-        'SL': config.get("sl"),
-        'WD': config.get("wd"),
-        'WX': config.get("wx")
-    }
-
-    handlers = [
-        (flags['AL'], handle_al),
-        (flags['BY'], handle_by),
-        (flags['DD'], lambda *a: handle_unprotected(*a, func=get_dd_download_links, label='DD')),
-        (flags['DJ'], lambda *a: handle_protected(*a, func=get_dj_download_links, label='DJ')),
-        (flags['DL'], handle_dl),
-        (flags['DT'], lambda *a: handle_unprotected(*a, func=get_dt_download_links, label='DT')),
-        (flags['DW'], lambda *a: handle_protected(*a, func=get_dw_download_links, label='DW')),
-        (flags['HE'], lambda *a: handle_unprotected(*a, func=get_he_download_links, label='HE')),
-        (flags['MB'], lambda *a: handle_protected(*a, func=get_mb_download_links, label='MB')),
-        (flags['NK'], lambda *a: handle_protected(*a, func=get_nk_download_links, label='NK')),
-        (flags['NX'], lambda *a: handle_unprotected(*a, func=get_nx_download_links, label='NX')),
-        (flags['SF'], handle_sf),
-        (flags['SJ'], lambda *a: handle_protected(*a, func=get_sj_download_links, label='SJ')),
-        (flags['SL'], handle_sl),
-        (flags['WD'], handle_wd),
-        (flags['WX'], handle_wx),
-    ]
-
-    for flag, fn in handlers:
-        if flag and flag.lower() in url.lower():
-            return {"package_id": package_id,
-                    **fn(shared_state, title, password, package_id, imdb_id, url, mirror, size_mb)}
-
-    if "filecrypt" in url.lower():
-        return {"package_id": package_id, **handle_protected(
-            shared_state, title, password, package_id, imdb_id, url, mirror, size_mb,
-            func=lambda ss, u, m, t: [[u, "filecrypt"]],
-            label='filecrypt'
-        )}
-
-    info(f'Could not parse URL for "{title}" - "{url}"')
-    StatsHelper(shared_state).increment_failed_downloads()
-    return {"success": False, "package_id": package_id, "title": title}
-
-
-def fail(title, package_id, shared_state, reason="Offline / no links found"):
+
+    # Find matching source - all getters have unified signature
+    source_result = None
+    label = None
+
+    for key, getter in SOURCE_GETTERS.items():
+        hostname = config.get(key)
+        if hostname and hostname.lower() in url.lower():
+            source_result = getter(shared_state, url, mirror, title, password)
+            label = key.upper()
+            break
+
+    # No source matched - check if URL is a known crypter directly
+    if source_result is None:
+        crypter, crypter_type = detect_crypter(url)
+        if crypter_type:
+            # For direct crypter URLs, we only know the crypter type, not the hoster inside
+            source_result = {"links": [[url, crypter]]}
+            label = crypter.upper()
+
+    if source_result is None:
+        info(f'Could not find matching source for "{title}" - "{url}"')
+        StatsHelper(shared_state).increment_failed_downloads()
+        return {"success": False, "package_id": package_id, "title": title}
+
+    result = process_links(shared_state, source_result, title, password, package_id, imdb_id, url, size_mb, label)
+    return {"package_id": package_id, **result}
+
+
+def fail(title, package_id, shared_state, reason="Unknown error"):
+    """Mark download as failed."""
     try:
         info(f"Reason for failure: {reason}")
         StatsHelper(shared_state).increment_failed_downloads()
         blob = json.dumps({"title": title, "error": reason})
-        stored = shared_state.get_db("failed").store(package_id, json.dumps(blob))
-        if stored:
-            info(f'Package "{title}" marked as failed!"')
-            return True
-        else:
-            info(f'Failed to mark package "{title}" as failed!"')
-            return False
+        shared_state.get_db("failed").store(package_id, json.dumps(blob))
+        info(f'Package "{title}" marked as failed!')
     except Exception as e:
         info(f'Error marking package "{package_id}" as failed: {e}')
-        return False
+    return {"success": False, "title": title}

quasarr/downloads/sources/al.py

@@ -8,6 +8,7 @@ import re
 import time
 from dataclasses import dataclass
 from typing import Optional, List
+from urllib.parse import urlparse
 
 from bs4 import BeautifulSoup
 
@@ -50,6 +51,17 @@ def roman_to_int(r: str) -> int:
     return total
 
 
+def derive_mirror(url):
+    try:
+        hostname = urlparse(url).netloc.lower()
+        if hostname.startswith('www.'):
+            hostname = hostname[4:]
+        parts = hostname.split('.')
+        return parts[-2] if len(parts) >= 2 else hostname
+    except:
+        return "unknown"
+
+
 def extract_season_from_synonyms(soup):
     """
     Returns the first season found as "Season N" in the Synonym(s) <td>, or None.
@@ -529,8 +541,19 @@ def extract_episode(title: str) -> int | None:
     return None
 
 
-def get_al_download_links(shared_state, url, mirror, title,
-                          release_id):  # signature cant align with other download link functions!
+def get_al_download_links(shared_state, url, mirror, title, password):
+    """
+    KEEP THE SIGNATURE EVEN IF SOME PARAMETERS ARE UNUSED!
+
+    AL source handler. Returns plain download links automatically by solving CAPTCHA.
+
+    Note: The 'password' parameter is intentionally repurposed as release_id
+    to ensure we download the correct release from the search results.
+    This is set by the search module, not a user password.
+    """
+
+    release_id = password  # password field carries release_id for AL
+
     al = shared_state.values["config"]("Hostnames").get(hostname)
 
     sess = retrieve_and_validate_session(shared_state)
@@ -690,8 +713,10 @@ def get_al_download_links(shared_state, url, mirror, title,
     else:
         StatsHelper(shared_state).increment_failed_decryptions_automatic()
 
+    links_with_mirrors = [[url, derive_mirror(url)] for url in links]
+
     return {
-        "links": links,
+        "links": links_with_mirrors,
         "password": f"www.{al}",
         "title": title
     }

quasarr/downloads/sources/by.py

@@ -13,7 +13,13 @@ from bs4 import BeautifulSoup
 from quasarr.providers.log import info, debug
 
 
-def get_by_download_links(shared_state, url, mirror, title):  # signature must align with other download link functions!
+def get_by_download_links(shared_state, url, mirror, title, password):
+    """
+    KEEP THE SIGNATURE EVEN IF SOME PARAMETERS ARE UNUSED!
+
+    BY source handler - fetches protected download links from BY iframes.
+    """
+
     by = shared_state.values["config"]("Hostnames").get("by")
     headers = {
         'User-Agent': shared_state.values["user_agent"],
@@ -103,4 +109,4 @@ def get_by_download_links(shared_state, url, mirror, title):  # signature must a
     except Exception as e:
         info(f"Error loading BY download links: {e}")
 
-    return links
+    return {"links": links}