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

quasarr/downloads/__init__.py

@@ -1,270 +1,333 @@
 # -*- 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
 
+from quasarr.downloads.linkcrypters.hide import decrypt_links_if_hide
+from quasarr.downloads.sources.al import get_al_download_links
+from quasarr.downloads.sources.by import get_by_download_links
+from quasarr.downloads.sources.dd import get_dd_download_links
+from quasarr.downloads.sources.dj import get_dj_download_links
+from quasarr.downloads.sources.dl import get_dl_download_links
+from quasarr.downloads.sources.dt import get_dt_download_links
 from quasarr.downloads.sources.dw import get_dw_download_links
+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.providers.myjd_api import TokenExpiredException, RequestTimeoutException, MYJDException
-from quasarr.providers.notifications import send_discord_captcha_alert
-
-
-def get_first_matching_comment(package, package_links):
-    package_uuid = package.get("uuid")
-    if package_uuid:
-        for link in package_links:
-            if link.get("packageUUID") == package_uuid:
-                return link.get("comment")
-    return None
-
-
-def get_links_matching_package_uuid(package, package_links):
-    package_uuid = package.get("uuid")
-    link_ids = []
-    if package_uuid:
-        for link in package_links:
-            if link.get("packageUUID") == package_uuid:
-                link_ids.append(link.get("uuid"))
-    return link_ids
-
-
-def format_eta(seconds):
-    hours = seconds // 3600
-    minutes = (seconds % 3600) // 60
-    seconds = seconds % 60
-    return f"{hours:02}:{minutes:02}:{seconds:02}"
-
-
-def get_packages(shared_state):
-    packages = []
-
-    protected_packages = shared_state.get_db("protected").retrieve_all_titles()
-    if protected_packages:
-        for package in protected_packages:
-            package_id = package[0]
-
-            data = json.loads(package[1])
-            details = {
-                "title": data["title"],
-                "urls": data["links"],
-                "size_mb": data["size_mb"],
-                "password": data["password"]
-            }
-
-            packages.append({
-                "details": details,
-                "location": "queue",
-                "type": "protected",
-                "package_id": package_id
-            })
-    try:
-        linkgrabber_packages = shared_state.get_device().linkgrabber.query_packages()
-    except (TokenExpiredException, RequestTimeoutException, MYJDException):
-        linkgrabber_packages = []
-
-    if linkgrabber_packages:
-        for package in linkgrabber_packages:
-            comment = get_first_matching_comment(package, shared_state.get_device().linkgrabber.query_links())
-            packages.append({
-                "details": package,
-                "location": "queue",
-                "type": "linkgrabber",
-                "comment": comment,
-                "uuid": package.get("uuid")
-            })
-    try:
-        downloader_packages = shared_state.get_device().downloads.query_packages()
-    except (TokenExpiredException, RequestTimeoutException, MYJDException):
-        downloader_packages = []
-
-    if downloader_packages:
-        for package in downloader_packages:
-            comment = get_first_matching_comment(package, shared_state.get_device().downloads.query_links())
-            status = package.get("status", "")
-
-            if any(ex_str in status.lower() for ex_str in ["entpacken", "extracting"]) and "ok:" not in status.lower():
-                finished = False
-            else:
-                finished = package.get("finished", False)
-
-            packages.append({
-                "details": package,
-                "location": "history" if finished else "queue",
-                "type": "downloader",
-                "comment": comment,
-                "uuid": package.get("uuid")
-            })
-
-    downloads = {
-        "queue": [],
-        "history": []
-    }
-    for package in packages:
-        queue_index = 0
-        history_index = 0
-
-        if package["location"] == "queue":
-            time_left = "2376:00:00"  # yields "99d" to signify that its not running
-            if package["type"] == "linkgrabber":
-                details = package["details"]
-                name = f"[Linkgrabber] {details["name"]}"
-                try:
-                    mb = mb_left = int(details["bytesTotal"]) / (1024 * 1024)
-                except KeyError:
-                    mb = mb_left = 0
-                package_id = package["comment"]
-                if "movies" in package_id:
-                    category = "movies"
-                else:
-                    category = "tv"
-                package_type = "linkgrabber"
-                package_uuid = package["uuid"]
-            elif package["type"] == "downloader":
-                details = package["details"]
-                name = f"[Downloading] {details["name"]}"
-                try:
-                    if details["eta"]:
-                        time_left = format_eta(int(details["eta"]))
-                except KeyError:
-                    name = name.replace("[Downloading]", "[Paused]")
-                try:
-                    mb = int(details["bytesTotal"]) / (1024 * 1024)
-                    mb_left = (int(details["bytesTotal"]) - int(details["bytesLoaded"])) / (1024 * 1024)
-                except KeyError:
-                    mb = mb_left = 0
-                package_id = package["comment"]
-                if "movies" in package_id:
-                    category = "movies"
-                else:
-                    category = "tv"
-                package_type = "downloader"
-                package_uuid = package["uuid"]
-            else:
-                details = package["details"]
-                name = f"[CAPTCHA not solved!] {details["title"]}"
-                mb = mb_left = details["size_mb"]
-                package_id = package["package_id"]
-                if "movies" in package_id:
-                    category = "movies"
-                else:
-                    category = "tv"
-                package_type = "protected"
-                package_uuid = None
-
-            try:
-                downloads["queue"].append({
-                    "index": queue_index,
-                    "nzo_id": package_id,
-                    "priority": "Normal",
-                    "filename": name,
-                    "cat": category,
-                    "mbleft": int(mb_left),
-                    "mb": int(mb),
-                    "status": "Downloading",
-                    "timeleft": time_left,
-                    "type": package_type,
-                    "uuid": package_uuid
-                })
-            except:
-                print(f"Parameters missing for {package}")
-            queue_index += 1
-        elif package["location"] == "history":
-            details = package["details"]
-            name = details["name"]
-            size = int(details["bytesLoaded"])
-            storage = details["saveTo"]
-            package_id = package["comment"]
-            if "movies" in package_id:
-                category = "movies"
-            else:
-                category = "tv"
-
-            downloads["history"].append({
-                "fail_message": "",
-                "category": category,
-                "storage": storage,
-                "status": "Completed",
-                "nzo_id": package_id,
-                "name": name,
-                "bytes": int(size),
-                "type": "downloader",
-                "uuid": package["uuid"]
-            })
-            history_index += 1
-        else:
-            print(f"Invalid package location {package['location']}")
-
-    return downloads
-
-
-def delete_package(shared_state, package_id):
-    deleted = ""
-
-    packages = get_packages(shared_state)
-    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())
-                    shared_state.get_device().linkgrabber.remove_links(ids, [package["uuid"]])
-                elif package["type"] == "downloader":
-                    ids = get_links_matching_package_uuid(package, shared_state.get_device().downloads.query_links())
-                    shared_state.get_device().downloads.remove_links(ids, [package["uuid"]])
-                else:
-                    shared_state.get_db("protected").delete(package_id)
-                if package_location == "queue":
-                    package_name_field = "filename"
-                else:
-                    package_name_field = "name"
-
-                deleted = package[package_name_field]
-                break
-        if deleted:
-            break
-
-    if deleted:
-        print(f"Deleted package {deleted} with ID {package_id}")
-    else:
-        print(f"Failed to delete package {package_id}")
-    return deleted
-
-
-def download_package(shared_state, request_from, title, url, size_mb, password):
-    if "radarr".lower() in request_from.lower():
-        category = "movies"
-    else:
-        category = "tv"
-
-    package_id = ""
-
-    dw = shared_state.values["config"]("Hostnames").get("dw")
-    nx = shared_state.values["config"]("Hostnames").get("nx")
-
-    if nx.lower() in url.lower():
-        links = get_nx_download_links(shared_state, url, title)
-        print(f"Decrypted {len(links)} download links for {title}")
-        package_id = f"Quasarr_{category}_{str(hash(title + url)).replace('-', '')}"
-
+from quasarr.downloads.sources.sf import get_sf_download_links, resolve_sf_redirect
+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
+from quasarr.downloads.sources.wx import get_wx_download_links
+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:
-            print(f"Failed to add {title} to linkgrabber")
-            package_id = None
-
-    elif dw.lower() in url.lower():
-        links = get_dw_download_links(shared_state, url, title)
-        print(f"CAPTCHA-Solution required for {title} - {shared_state.values['external_address']}/captcha")
-        send_discord_captcha_alert(shared_state, title)
-        package_id = f"Quasarr_{category}_{str(hash(title + str(links))).replace('-', '')}"
+            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):
+    """
+    Attempt to decrypt hide.cx links and handle the result.
+    Returns a dict with 'handled' (bool) and 'result' (response dict or None).
+    """
+    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}
+
+    decrypt_result = handle_hide(
+        shared_state, title, password, package_id, imdb_id, url, links, 'BY'
+    )
+
+    if decrypt_result["handled"]:
+        return decrypt_result["result"]
+
+    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'
+    )
+
+
+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'
+    )
+
+    if decrypt_result["handled"]:
+        return decrypt_result["result"]
+
+    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'
+    )
+
+
+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}
+
+    decrypt_result = handle_hide(
+        shared_state, title, password, package_id, imdb_id, url, links, 'WX'
+    )
+
+    if decrypt_result["handled"]:
+        return decrypt_result["result"]
+
+    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'
+    )
+
+
+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"
 
-    elif "filecrypt".lower() in url.lower():
-        print(f"CAPTCHA-Solution required for {title} - {shared_state.values['external_address']}/captcha")
-        send_discord_captcha_alert(shared_state, title)
-        package_id = f"Quasarr_{category}_{str(hash(title + url)).replace('-', '')}"
-        blob = json.dumps({"title": title, "links": [[url, "filecrypt"]], "size_mb": size_mb, "password": password})
-        shared_state.values["database"]("protected").update_store(package_id, blob)
+    package_id = f"Quasarr_{category}_{str(hash(title + url)).replace('-', '')}"
+
+    if imdb_id is not None 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")
+    }
 
-    return package_id
+    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"):
+    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
+    except Exception as e:
+        info(f'Error marking package "{package_id}" as failed: {e}')
+        return False