quasarr 1.20.6__py3-none-any.whl

quasarr/api/config/__init__.py

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+from quasarr.providers.html_templates import render_form
+from quasarr.providers.html_templates import render_button
+from quasarr.storage.setup import hostname_form_html, save_hostnames
+
+
+def setup_config(app, shared_state):
+    @app.get('/hostnames')
+    def hostnames_ui():
+        message = """<p>
+            At least one hostname must be kept.
+        </p>"""
+        back_button = f'''<p>
+                        {render_button("Back", "secondary", {"onclick": "location.href='/'"})}
+                    </p>'''
+        return render_form("Hostnames", hostname_form_html(shared_state, message) + back_button)
+
+    @app.post("/api/hostnames")
+    def hostnames_api():
+        return save_hostnames(shared_state, timeout=1, first_run=False)

quasarr/api/sponsors_helper/__init__.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import json
+
+from bottle import request, abort
+
+from quasarr.downloads import fail
+from quasarr.providers import shared_state
+from quasarr.providers.log import info
+from quasarr.providers.notifications import send_discord_message
+from quasarr.providers.statistics import StatsHelper
+
+
+def setup_sponsors_helper_routes(app):
+    @app.get("/sponsors_helper/api/to_decrypt/")
+    def to_decrypt_api():
+        try:
+            if not shared_state.values["helper_active"]:
+                shared_state.update("helper_active", True)
+                info(f"Sponsor status activated successfully")
+
+            protected = shared_state.get_db("protected").retrieve_all_titles()
+            if not protected:
+                return abort(404, "No encrypted packages found")
+
+            # Find the first package without a "session" key
+            selected_package = None
+            for package in protected:
+                data = json.loads(package[1])
+                if "session" not in data:
+                    selected_package = (package[0], data)
+                    break
+
+            if not selected_package:
+                return abort(404, "No valid packages without session found")
+
+            package_id, data = selected_package
+            title = data["title"]
+            links = data["links"]
+            mirror = None if (mirror := data.get('mirror')) == "None" else mirror
+            password = data["password"]
+
+            rapid = [ln for ln in links if "rapidgator" in ln[1].lower()]
+            others = [ln for ln in links if "rapidgator" not in ln[1].lower()]
+            prioritized_links = rapid + others
+
+            return {
+                "to_decrypt": {
+                    "name": title,
+                    "id": package_id,
+                    "url": prioritized_links,
+                    "mirror": mirror,
+                    "password": password,
+                    "max_attempts": 3
+                }
+            }
+        except Exception as e:
+            return abort(500, str(e))
+
+    @app.post("/sponsors_helper/api/to_download/")
+    def to_download_api():
+        try:
+            data = request.json
+            title = data.get('name')
+            package_id = data.get('package_id')
+            download_links = data.get('urls')
+            password = data.get('password')
+
+            info(f"Received {len(download_links)} download links for {title}")
+
+            if download_links:
+                downloaded = shared_state.download_package(download_links, title, password, package_id)
+                if downloaded:
+                    StatsHelper(shared_state).increment_package_with_links(download_links)
+                    StatsHelper(shared_state).increment_captcha_decryptions_automatic()
+                    shared_state.get_db("protected").delete(package_id)
+                    send_discord_message(shared_state, title=title, case="solved")
+                    info(f"Download successfully started for {title}")
+                    return f"Downloaded {len(download_links)} download links for {title}"
+                else:
+                    info(f"Download failed for {title}")
+
+        except Exception as e:
+            info(f"Error decrypting: {e}")
+
+        StatsHelper(shared_state).increment_failed_decryptions_automatic()
+        return abort(500, "Failed")  #
+
+    @app.post("/sponsors_helper/api/to_replace/")
+    def to_replace_api():
+        try:
+            data = request.json
+            name = data.get('name')
+            package_id = data.get('package_id')
+            password = data.get('password')
+            replace_url = data.get('replace_url')
+            mirror = data.get('mirror')
+            session = data.get('session')
+
+            if not all([name, package_id, replace_url, mirror, session]):
+                info("Missing required replacement data")
+                return {"error": "Missing required replacement data"}, 400
+
+            if password is None:
+                password = ""
+
+            blob = json.dumps(
+                {
+                    "title": name,
+                    "links": [replace_url, mirror],
+                    "size_mb": 0,
+                    "password": password,
+                    "mirror": mirror,
+                    "session": session
+                })
+
+            shared_state.get_db("protected").update_store(package_id, blob)
+
+            info(f"Another CAPTCHA solution is required for {mirror} link: {replace_url}")
+
+            StatsHelper(shared_state).increment_captcha_decryptions_automatic()
+
+            return f"Replacement link stored for {name}"
+
+        except Exception as e:
+            StatsHelper(shared_state).increment_failed_decryptions_automatic()
+            info(f"Error handling replacement: {e}")
+            return {"error": str(e)}, 500
+
+    @app.delete("/sponsors_helper/api/to_failed/")
+    def move_to_failed_api():
+        try:
+            StatsHelper(shared_state).increment_failed_decryptions_automatic()
+
+            data = request.json
+            package_id = data.get('package_id')
+
+            data = json.loads(shared_state.get_db("protected").retrieve(package_id))
+            title = data.get('title')
+
+            if package_id:
+                info(f'Marking package "{title}" with ID "{package_id}" as failed')
+                failed = fail(title, package_id, shared_state, reason="Too many failed attempts by SponsorsHelper")
+                if failed:
+                    shared_state.get_db("protected").delete(package_id)
+                    send_discord_message(shared_state, title=title, case="failed")
+                    return f'Package "{title}" with ID "{package_id} marked as failed!"'
+        except Exception as e:
+            info(f"Error moving to failed: {e}")
+
+        return abort(500, "Failed")
+
+    @app.put("/sponsors_helper/api/set_sponsor_status/")
+    def activate_sponsor_status():
+        try:
+            data = request.body.read().decode("utf-8")
+            payload = json.loads(data)
+            if payload["activate"]:
+                shared_state.update("helper_active", True)
+                info(f"Sponsor status activated successfully")
+                return "Sponsor status activated successfully!"
+        except:
+            pass
+        return abort(500, "Failed")

quasarr/api/statistics/__init__.py

@@ -0,0 +1,196 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import quasarr.providers.html_images as images
+from quasarr.providers.html_templates import render_button, render_centered_html
+from quasarr.providers.statistics import StatsHelper
+
+
+def setup_statistics(app, shared_state):
+    @app.get('/statistics')
+    def statistics():
+        stats_helper = StatsHelper(shared_state)
+        stats = stats_helper.get_stats()
+
+        stats_html = f"""
+        <h1><img src="{images.logo}" type="image/png" alt="Quasarr logo" class="logo"/>Quasarr</h1>
+        <h2>Statistics</h2>
+        <div class="stats-container">
+            <h3>📊 Overview</h3>
+            <div class="stats-grid compact">
+                <div class="stat-card highlight">
+                    <h3>📦 Total Download Attempts</h3>
+                    <div class="stat-value">{stats['total_download_attempts']}</div>
+                    <div class="stat-subtitle">Success Rate: {stats['download_success_rate']:.1f}%</div>
+                </div>
+                <div class="stat-card highlight">
+                    <h3>🔐 Total CAPTCHA Decryptions</h3>
+                    <div class="stat-value">{stats['total_captcha_decryptions']}</div>
+                    <div class="stat-subtitle">Success Rate: {stats['decryption_success_rate']:.1f}%</div>
+                </div>
+            </div>
+
+            <h3>📥 Downloads</h3>
+            <div class="stats-grid compact">
+                <div class="stat-card">
+                    <h3>✅ Packages Downloaded</h3>
+                    <div class="stat-value">{stats['packages_downloaded']}</div>
+                </div>
+                <div class="stat-card">
+                    <h3>⚙️ Links Processed</h3>
+                    <div class="stat-value">{stats['links_processed']}</div>
+                </div>
+                <div class="stat-card">
+                    <h3>❌ Failed Downloads</h3>
+                    <div class="stat-value">{stats['failed_downloads']}</div>
+                </div>
+                <div class="stat-card">
+                    <h3>🔗 Average Links per Package</h3>
+                    <div class="stat-value">{stats['average_links_per_package']:.1f}</div>
+                </div>
+            </div>
+
+            <h3>🧩 CAPTCHAs</h3>
+            <div class="stats-grid compact">
+                <div class="stat-card">
+                    <h3>🤖 Automatic Decryptions</h3>
+                    <div class="stat-value">{stats['captcha_decryptions_automatic']}</div>
+                    <div class="stat-subtitle">Success Rate: {stats['automatic_decryption_success_rate']:.1f}%</div>
+                </div>
+                <div class="stat-card">
+                    <h3>👤 Manual Decryptions</h3>
+                    <div class="stat-value">{stats['captcha_decryptions_manual']}</div>
+                    <div class="stat-subtitle">Success Rate: {stats['manual_decryption_success_rate']:.1f}%</div>
+                </div>
+                <div class="stat-card">
+                    <h3>⛔ Failed Auto Decryptions</h3>
+                    <div class="stat-value">{stats['failed_decryptions_automatic']}</div>
+                </div>
+                <div class="stat-card">
+                    <h3>🚫 Failed Manual Decryptions</h3>
+                    <div class="stat-value">{stats['failed_decryptions_manual']}</div>
+                </div>
+            </div>
+        </div>
+
+        <p>
+            {render_button("Back", "secondary", {"onclick": "location.href='/'"})}
+        </p>
+
+        <style>
+            .stats-container {{
+                max-width: 1000px;
+                margin: 0 auto;
+            }}
+
+            .stats-grid {{
+                display: grid;
+                grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+                gap: 15px;
+                margin: 15px 0;
+            }}
+
+            .stats-grid.compact {{
+                gap: 12px;
+                margin: 12px 0;
+            }}
+
+            .stat-card {{
+                background: var(--card-bg, #f8f9fa);
+                border: 1px solid var(--card-border, #dee2e6);
+                border-radius: 8px;
+                padding: 15px;
+                text-align: center;
+                transition: transform 0.2s, box-shadow 0.2s;
+            }}
+
+            .stat-card:hover {{
+                transform: translateY(-2px);
+                box-shadow: 0 4px 12px var(--card-shadow, rgba(0,0,0,0.1));
+            }}
+
+            .stat-card.highlight {{
+                background: var(--highlight-bg, #e3f2fd);
+                border-color: var(--highlight-border, #2196f3);
+            }}
+
+            .stat-card h3 {{
+                margin: 0 0 8px 0;
+                font-size: 13px;
+                color: var(--text-muted, #666);
+                text-transform: uppercase;
+                letter-spacing: 0.5px;
+            }}
+
+            .stat-value {{
+                font-size: 24px;
+                font-weight: bold;
+                color: var(--text-primary, #333);
+                margin: 8px 0;
+            }}
+
+            .stat-subtitle {{
+                font-size: 11px;
+                color: var(--text-secondary, #888);
+                margin-top: 4px;
+            }}
+
+            h3 {{
+                color: var(--heading-color, #444);
+                padding-bottom: 8px;
+                margin-top: 25px;
+                margin-bottom: 15px;
+            }}
+
+            /* Dark mode styles */
+            @media (prefers-color-scheme: dark) {{
+                :root {{
+                    --card-border: #4a5568;
+                    --card-shadow: rgba(0,0,0,0.3);
+                    --highlight-bg: #1a365d;
+                    --highlight-border: #3182ce;
+                    --text-muted: #a0aec0;
+                    --text-primary: #f7fafc;
+                    --text-secondary: #cbd5e0;
+                    --heading-color: #e2e8f0;
+                    --border-color: #4a5568;
+                }}
+            }}
+
+            /* Force dark mode styles for applications that don't support prefers-color-scheme */
+            body.dark-mode .stat-card {{
+                background: #2d3748;
+                border-color: #4a5568;
+                color: #f7fafc;
+            }}
+
+            body.dark-mode .stat-card:hover {{
+                box-shadow: 0 4px 12px rgba(0,0,0,0.3);
+            }}
+
+            body.dark-mode .stat-card.highlight {{
+                background: #1a365d;
+                border-color: #3182ce;
+            }}
+
+            body.dark-mode .stat-card h3 {{
+                color: #a0aec0;
+            }}
+
+            body.dark-mode .stat-value {{
+                color: #f7fafc;
+            }}
+
+            body.dark-mode .stat-subtitle {{
+                color: #cbd5e0;
+            }}
+
+            body.dark-mode h2 {{
+                color: #e2e8f0;
+                border-bottom-color: #4a5568;
+            }}
+        </style>
+        """
+
+        return render_centered_html(stats_html)

quasarr/downloads/__init__.py

@@ -0,0 +1,267 @@
+# -*- 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.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.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.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_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}
+
+    decrypted = decrypt_links_if_hide(shared_state, links)
+    if decrypted and decrypted.get("status") != "none":
+        status = decrypted.get("status", "error")
+        links = decrypted.get("results", [])
+        if status == "success":
+            return handle_unprotected(
+                shared_state, title, password, package_id, imdb_id, url,
+                links=links, label='BY'
+            )
+        else:
+            fail(title, package_id, shared_state,
+                 reason=f'Error decrypting hide.cx links for "{title}" on BY - "{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: links,
+        label='BY'
+    )
+
+
+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}
+
+    decrypted = decrypt_links_if_hide(shared_state, links)
+    if decrypted and decrypted.get("status") != "none":
+        status = decrypted.get("status", "error")
+        links = decrypted.get("results", [])
+        if status == "success":
+            return handle_unprotected(
+                shared_state, title, password, package_id, imdb_id, url,
+                links=links, label='WD'
+            )
+        else:
+            fail(title, package_id, shared_state,
+                 reason=f'Error decrypting hide.cx links for "{title}" on WD - "{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: links,
+        label='WD'
+    )
+
+
+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"
+
+    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"),
+        '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")
+    }
+
+    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['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),
+    ]
+
+    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