quasarr 1.26.7__py3-none-any.whl → 1.28.0__py3-none-any.whl

quasarr/__init__.py

@@ -6,19 +6,18 @@ import argparse
 import multiprocessing
 import os
 import re
-import socket
 import sys
 import tempfile
 import time
-from urllib.parse import urlparse, urljoin, parse_qs
 
-import dukpy
 import requests
 
 from quasarr.api import get_api
 from quasarr.providers import shared_state, version
 from quasarr.providers.log import info, debug
 from quasarr.providers.notifications import send_discord_message
+from quasarr.providers.utils import extract_allowed_keys, extract_kv_pairs, is_valid_url, check_ip, check_flaresolverr, \
+    validate_address, Unbuffered, FALLBACK_USER_AGENT
 from quasarr.storage.config import Config, get_clean_hostnames
 from quasarr.storage.setup import path_config, hostnames_config, hostname_credentials_config, flaresolverr_config, \
     jdownloader_config
@@ -101,25 +100,45 @@ def run():
         shared_state.update("database", DataBase)
         supported_hostnames = extract_allowed_keys(Config._DEFAULT_CONFIG, 'Hostnames')
         shared_state.update("sites", [key.upper() for key in supported_hostnames])
-        shared_state.update("user_agent", "")  # will be set by FlareSolverr
+        shared_state.update("user_agent", "")  # will be set by FlareSolverr or fallback
         shared_state.update("helper_active", False)
 
         print(f'Config path: "{config_path}"')
 
+        # Check if FlareSolverr was previously skipped
+        skip_flaresolverr_db = DataBase("skip_flaresolverr")
+        flaresolverr_skipped = skip_flaresolverr_db.retrieve("skipped")
+
         flaresolverr_url = Config('FlareSolverr').get('url')
-        if not flaresolverr_url:
+        if not flaresolverr_url and not flaresolverr_skipped:
             flaresolverr_config(shared_state)
-        else:
+            # Re-check after config - user may have skipped
+            flaresolverr_skipped = skip_flaresolverr_db.retrieve("skipped")
+            flaresolverr_url = Config('FlareSolverr').get('url')
+
+        if flaresolverr_skipped:
+            info('FlareSolverr setup skipped by user preference')
+            info('Some sites (AL) will not work without FlareSolverr. Configure it later in the web UI.')
+            # Set fallback user agent
+            shared_state.update("user_agent", FALLBACK_USER_AGENT)
+            print(f'User Agent (fallback): "{FALLBACK_USER_AGENT}"')
+        elif flaresolverr_url:
             print(f'Flaresolverr URL: "{flaresolverr_url}"')
             flaresolverr_check = check_flaresolverr(shared_state, flaresolverr_url)
             if flaresolverr_check:
                 print(f'User Agent: "{shared_state.values["user_agent"]}"')
+            else:
+                info('FlareSolverr check failed - using fallback user agent')
+                shared_state.update("user_agent", FALLBACK_USER_AGENT)
+                print(f'User Agent (fallback): "{FALLBACK_USER_AGENT}"')
 
         print("\n===== Hostnames =====")
         try:
             if arguments.hostnames:
                 hostnames_link = arguments.hostnames
                 if is_valid_url(hostnames_link):
+                    # Store the hostnames URL for later use in web UI
+                    Config("Settings").save("hostnames_url", hostnames_link)
                     print(f"Extracting hostnames from {hostnames_link}...")
                     allowed_keys = supported_hostnames
                     max_keys = len(allowed_keys)
@@ -160,33 +179,21 @@ def run():
         print(f"You have [{len(hostnames)} of {len(Config._DEFAULT_CONFIG['Hostnames'])}] supported hostnames set up")
         print(f"For efficiency it is recommended to set up as few hostnames as needed.")
 
-        al = Config('Hostnames').get('al')
-        if al:
-            user = Config('AL').get('user')
-            password = Config('AL').get('password')
-            if not user or not password:
-                hostname_credentials_config(shared_state, "AL", al)
-
-        dd = Config('Hostnames').get('dd')
-        if dd:
-            user = Config('DD').get('user')
-            password = Config('DD').get('password')
-            if not user or not password:
-                hostname_credentials_config(shared_state, "DD", dd)
-
-        nx = Config('Hostnames').get('nx')
-        if nx:
-            user = Config('NX').get('user')
-            password = Config('NX').get('password')
-            if not user or not password:
-                hostname_credentials_config(shared_state, "NX", nx)
-
-        dl = Config('Hostnames').get('dl')
-        if dl:
-            user = Config('DL').get('user')
-            password = Config('DL').get('password')
-            if not user or not password:
-                hostname_credentials_config(shared_state, "DL", dl)
+        # Check credentials for login-required hostnames
+        skip_login_db = DataBase("skip_login")
+        login_required_sites = ['al', 'dd', 'nx', 'dl']
+
+        for site in login_required_sites:
+            hostname = Config('Hostnames').get(site)
+            if hostname:
+                site_config = Config(site.upper())
+                user = site_config.get('user')
+                password = site_config.get('password')
+                if not user or not password:
+                    if skip_login_db.retrieve(site):
+                        info(f'"{site.upper()}" login skipped by user preference')
+                    else:
+                        hostname_credentials_config(shared_state, site.upper(), hostname)
 
         config = Config('JDownloader')
         user = config.get('user')
@@ -234,21 +241,21 @@ def run():
 
         jdownloader = multiprocessing.Process(
             target=jdownloader_connection,
-            args=(shared_state_dict, shared_state_lock)
+            args=(shared_state_dict, shared_state_lock),
+            daemon=True
         )
         jdownloader.start()
 
         updater = multiprocessing.Process(
             target=update_checker,
-            args=(shared_state_dict, shared_state_lock)
+            args=(shared_state_dict, shared_state_lock),
+            daemon=True
         )
         updater.start()
 
         try:
             get_api(shared_state_dict, shared_state_lock)
         except KeyboardInterrupt:
-            jdownloader.kill()
-            updater.kill()
             sys.exit(0)
 
 
@@ -327,121 +334,3 @@ def jdownloader_connection(shared_state_dict, shared_state_lock):
 
     except KeyboardInterrupt:
         pass
-
-
-class Unbuffered(object):
-    def __init__(self, stream):
-        self.stream = stream
-
-    def write(self, data):
-        self.stream.write(data)
-        self.stream.flush()
-
-    def writelines(self, datas):
-        self.stream.writelines(datas)
-        self.stream.flush()
-
-    def __getattr__(self, attr):
-        return getattr(self.stream, attr)
-
-
-def check_ip():
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    try:
-        s.connect(('10.255.255.255', 0))
-        ip = s.getsockname()[0]
-    except:
-        ip = '127.0.0.1'
-    finally:
-        s.close()
-    return ip
-
-
-def check_flaresolverr(shared_state, flaresolverr_url):
-    # Ensure it ends with /v<digit+>
-    if not re.search(r"/v\d+$", flaresolverr_url):
-        print(f"FlareSolverr URL does not end with /v#: {flaresolverr_url}")
-        return False
-
-    # Try sending a simple test request
-    headers = {"Content-Type": "application/json"}
-    data = {
-        "cmd": "request.get",
-        "url": "http://www.google.com/",
-        "maxTimeout": 10000
-    }
-
-    try:
-        response = requests.post(flaresolverr_url, headers=headers, json=data, timeout=10)
-        response.raise_for_status()
-        json_data = response.json()
-
-        # Check if the structure looks like a valid FlareSolverr response
-        if "status" in json_data and json_data["status"] == "ok":
-            solution = json_data["solution"]
-            solution_ua = solution.get("userAgent", None)
-            if solution_ua:
-                shared_state.update("user_agent", solution_ua)
-            return True
-        else:
-            print(f"Unexpected FlareSolverr response: {json_data}")
-            return False
-
-    except Exception as e:
-        print(f"Failed to connect to FlareSolverr: {e}")
-        return False
-
-def is_valid_url(url):
-    if "/raw/eX4Mpl3" in url:
-        print("Example URL detected. Please provide a valid URL found on pastebin or any other public site!")
-        return False
-
-    parsed = urlparse(url)
-    return parsed.scheme in ("http", "https") and bool(parsed.netloc)
-
-
-def validate_address(address, name):
-    if not address.startswith("http"):
-        sys.exit(f"Error: {name} '{address}' is invalid. It must start with 'http'.")
-
-    colon_count = address.count(":")
-    if colon_count < 1 or colon_count > 2:
-        sys.exit(
-            f"Error: {name} '{address}' is invalid. It must contain 1 or 2 colons, but it has {colon_count}.")
-
-
-def extract_allowed_keys(config, section):
-    """
-    Extracts allowed keys from the specified section in the configuration.
-
-    :param config: The configuration dictionary.
-    :param section: The section from which to extract keys.
-    :return: A list of allowed keys.
-    """
-    if section not in config:
-        raise ValueError(f"Section '{section}' not found in configuration.")
-    return [key for key, *_ in config[section]]
-
-
-def extract_kv_pairs(input_text, allowed_keys):
-    """
-    Extracts key-value pairs from the given text where keys match allowed_keys.
-
-    :param input_text: The input text containing key-value pairs.
-    :param allowed_keys: A list of allowed two-letter shorthand keys.
-    :return: A dictionary of extracted key-value pairs.
-    """
-    kv_pattern = re.compile(rf"^({'|'.join(map(re.escape, allowed_keys))})\s*=\s*(.*)$")
-    kv_pairs = {}
-
-    for line in input_text.splitlines():
-        match = kv_pattern.match(line.strip())
-        if match:
-            key, value = match.groups()
-            kv_pairs[key] = value
-        elif "[Hostnames]" in line:
-            pass
-        else:
-            print(f"Skipping line because it does not contain any supported hostname: {line}")
-
-    return kv_pairs

quasarr/api/__init__.py

@@ -31,7 +31,6 @@ def get_api(shared_state_dict, shared_state_lock):
     def index():
         protected = shared_state.get_db("protected").retrieve_all_titles()
         api_key = Config('API').get('key')
-
         captcha_hint = ""
         if protected:
             plural = 's' if len(protected) > 1 else ''
@@ -103,6 +102,7 @@ def get_api(shared_state_dict, shared_state_lock):
         <div class="section">
             <h2>🔧 Quick Actions</h2>
             <p><button class="btn-primary" onclick="location.href='/hostnames'">Update Hostnames</button></p>
+            <p><button class="btn-primary" onclick="location.href='/flaresolverr'">Configure FlareSolverr</button></p>
             <p><button class="btn-primary" onclick="location.href='/statistics'">View Statistics</button></p>
         </div>
 

quasarr/api/config/__init__.py

@@ -2,9 +2,23 @@
 # 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
+import os
+import re
+import signal
+import threading
+import time
+from urllib.parse import urlparse
+
+import requests
+from bottle import request, response
+
+from quasarr.providers.html_templates import render_form, render_button, render_fail
+from quasarr.providers.log import info
+from quasarr.providers.shared_state import extract_valid_hostname
+from quasarr.providers.utils import extract_kv_pairs, extract_allowed_keys, check_flaresolverr
+from quasarr.storage.config import Config
+from quasarr.storage.setup import hostname_form_html, save_hostnames, render_reconnect_success
+from quasarr.storage.sqlite_database import DataBase
 
 
 def setup_config(app, shared_state):
@@ -16,8 +30,298 @@ def setup_config(app, shared_state):
         back_button = f'''<p>
                         {render_button("Back", "secondary", {"onclick": "location.href='/'"})}
                     </p>'''
-        return render_form("Hostnames", hostname_form_html(shared_state, message) + back_button)
+        return render_form("Hostnames",
+                           hostname_form_html(shared_state, message, show_restart_button=True,
+                                              show_skip_management=True) + back_button)
 
     @app.post("/api/hostnames")
     def hostnames_api():
         return save_hostnames(shared_state, timeout=1, first_run=False)
+
+    @app.post("/api/hostnames/import-url")
+    def import_hostnames_from_url():
+        """Fetch URL and parse hostnames, return JSON for JS to populate fields."""
+        response.content_type = 'application/json'
+        try:
+            data = request.json
+            url = data.get('url', '').strip()
+
+            if not url:
+                return {"success": False, "error": "No URL provided"}
+
+            # Validate URL
+            parsed = urlparse(url)
+            if parsed.scheme not in ("http", "https") or not parsed.netloc:
+                return {"success": False, "error": "Invalid URL format"}
+
+            if "/raw/eX4Mpl3" in url:
+                return {"success": False, "error": "Example URL detected. Please provide a real URL."}
+
+            # Fetch content
+            try:
+                resp = requests.get(url, timeout=15)
+                resp.raise_for_status()
+                content = resp.text
+            except requests.RequestException as e:
+                return {"success": False, "error": f"Failed to fetch URL: {str(e)}"}
+
+            # Parse hostnames
+            allowed_keys = extract_allowed_keys(Config._DEFAULT_CONFIG, 'Hostnames')
+            results = extract_kv_pairs(content, allowed_keys)
+
+            if not results:
+                return {"success": False, "error": "No hostnames found in the provided URL"}
+
+            # Validate each hostname
+            valid_hostnames = {}
+            invalid_hostnames = {}
+            for shorthand, hostname in results.items():
+                domain_check = extract_valid_hostname(hostname, shorthand)
+                domain = domain_check.get('domain')
+                if domain:
+                    valid_hostnames[shorthand] = domain
+                else:
+                    invalid_hostnames[shorthand] = domain_check.get('message', 'Invalid')
+
+            if not valid_hostnames:
+                return {"success": False, "error": "No valid hostnames found in the provided URL"}
+
+            return {
+                "success": True,
+                "hostnames": valid_hostnames,
+                "errors": invalid_hostnames
+            }
+
+        except Exception as e:
+            return {"success": False, "error": f"Error: {str(e)}"}
+
+    @app.get("/api/skip-login")
+    def get_skip_login():
+        """Return list of hostnames with skipped login."""
+        response.content_type = 'application/json'
+        skip_db = DataBase("skip_login")
+        login_required_sites = ['al', 'dd', 'dl', 'nx']
+        skipped = []
+        for site in login_required_sites:
+            if skip_db.retrieve(site):
+                skipped.append(site)
+        return {"skipped": skipped}
+
+    @app.delete("/api/skip-login/<shorthand>")
+    def clear_skip_login(shorthand):
+        """Clear skip login preference for a hostname."""
+        response.content_type = 'application/json'
+        shorthand = shorthand.lower()
+        login_required_sites = ['al', 'dd', 'dl', 'nx']
+        if shorthand not in login_required_sites:
+            return {"success": False, "error": f"Invalid shorthand: {shorthand}"}
+
+        skip_db = DataBase("skip_login")
+        skip_db.delete(shorthand)
+        info(f'Skip login preference cleared for "{shorthand.upper()}"')
+        return {"success": True}
+
+    @app.get('/flaresolverr')
+    def flaresolverr_ui():
+        """Web UI page for configuring FlareSolverr."""
+        skip_db = DataBase("skip_flaresolverr")
+        is_skipped = skip_db.retrieve("skipped")
+        current_url = Config('FlareSolverr').get('url') or ""
+
+        skip_indicator = ""
+        if is_skipped:
+            skip_indicator = '''
+            <div class="skip-indicator" style="margin-bottom:1rem; padding:0.75rem; background:var(--code-bg, #f8f9fa); border-radius:0.25rem; font-size:0.875rem;">
+                <span style="color:#dc3545;">⚠️ FlareSolverr setup was skipped</span>
+                <p style="margin:0.5rem 0 0 0; font-size:0.75rem; color:var(--secondary, #6c757d);">
+                    Some sites (like AL) won't work until FlareSolverr is configured.
+                </p>
+            </div>
+            '''
+
+        form_content = f'''
+        {skip_indicator}
+        <span><a href="https://github.com/FlareSolverr/FlareSolverr?tab=readme-ov-file#installation" target="_blank">FlareSolverr</a>
+        must be running and reachable to Quasarr for some sites to work.</span><br><br>
+        <label for="url">FlareSolverr URL</label>
+        <input type="text" id="url" name="url" placeholder="http://192.168.0.1:8191/v1" value="{current_url}"><br>
+        '''
+
+        form_html = f'''
+        <form action="/api/flaresolverr" method="post" onsubmit="return handleSubmit(this)">
+            {form_content}
+            {render_button("Save", "primary", {"type": "submit", "id": "submitBtn"})}
+        </form>
+        <p style="font-size:0.875rem; color:var(--secondary, #6c757d); margin-top:1rem;">
+            A restart is recommended after configuring FlareSolverr.
+        </p>
+        <div class="section-divider" style="margin-top:1.5rem; padding-top:1rem; border-top:1px solid var(--divider-color, #dee2e6);">
+            {render_button("Restart Quasarr", "secondary", {"type": "button", "onclick": "confirmRestart()"})}
+        </div>
+        <p>{render_button("Back", "secondary", {"onclick": "location.href='/';"})}</p>
+        <script>
+        var formSubmitted = false;
+        function handleSubmit(form) {{
+            if (formSubmitted) return false;
+            formSubmitted = true;
+            var btn = document.getElementById('submitBtn');
+            if (btn) {{ btn.disabled = true; btn.textContent = 'Saving...'; }}
+            return true;
+        }}
+        function confirmRestart() {{
+            if (confirm('Restart Quasarr now?')) {{
+                fetch('/api/restart', {{ method: 'POST' }})
+                .then(response => response.json())
+                .then(data => {{
+                    if (data.success) {{
+                        showRestartOverlay();
+                    }}
+                }})
+                .catch(error => {{
+                    showRestartOverlay();
+                }});
+            }}
+        }}
+        function showRestartOverlay() {{
+            document.body.innerHTML = `
+              <div style="text-align:center; padding:2rem; font-family:system-ui,-apple-system,sans-serif;">
+                <h2>Restarting Quasarr...</h2>
+                <p id="restartStatus">Waiting <span id="countdown">10</span> seconds...</p>
+                <div id="spinner" style="display:none; margin-top:1rem;">
+                  <div style="display:inline-block; width:24px; height:24px; border:3px solid #ccc; border-top-color:#333; border-radius:50%; animation:spin 1s linear infinite;"></div>
+                  <style>@keyframes spin {{ to {{ transform: rotate(360deg); }} }}</style>
+                </div>
+              </div>
+            `;
+            startCountdown(10);
+        }}
+        function startCountdown(seconds) {{
+            var countdownEl = document.getElementById('countdown');
+            var statusEl = document.getElementById('restartStatus');
+            var spinnerEl = document.getElementById('spinner');
+            var remaining = seconds;
+            var interval = setInterval(function() {{
+                remaining--;
+                if (countdownEl) countdownEl.textContent = remaining;
+                if (remaining <= 0) {{
+                    clearInterval(interval);
+                    statusEl.textContent = 'Reconnecting...';
+                    spinnerEl.style.display = 'block';
+                    tryReconnect();
+                }}
+            }}, 1000);
+        }}
+        function tryReconnect() {{
+            var statusEl = document.getElementById('restartStatus');
+            var attempts = 0;
+            function attempt() {{
+                attempts++;
+                fetch('/', {{ method: 'HEAD', cache: 'no-store' }})
+                .then(response => {{
+                    if (response.ok) {{
+                        statusEl.textContent = 'Connected! Reloading...';
+                        setTimeout(function() {{ window.location.href = '/'; }}, 500);
+                    }} else {{
+                        scheduleRetry();
+                    }}
+                }})
+                .catch(function() {{
+                    scheduleRetry();
+                }});
+            }}
+            function scheduleRetry() {{
+                statusEl.textContent = 'Reconnecting... (attempt ' + attempts + ')';
+                setTimeout(attempt, 1000);
+            }}
+            attempt();
+        }}
+        </script>
+        '''
+        return render_form("Configure FlareSolverr", form_html)
+
+    @app.post('/api/flaresolverr')
+    def set_flaresolverr_url():
+        """Save FlareSolverr URL from web UI."""
+        url = request.forms.get('url', '').strip()
+        config = Config("FlareSolverr")
+
+        if not url:
+            return render_fail("Please provide a FlareSolverr URL.")
+
+        if not url.startswith("http://") and not url.startswith("https://"):
+            url = "http://" + url
+
+        # Validate URL format
+        if not re.search(r"/v\d+$", url):
+            return render_fail("FlareSolverr URL must end with /v1 (or similar version path).")
+
+        try:
+            headers = {"Content-Type": "application/json"}
+            data = {
+                "cmd": "request.get",
+                "url": "http://www.google.com/",
+                "maxTimeout": 30000
+            }
+            resp = requests.post(url, headers=headers, json=data, timeout=30)
+            if resp.status_code == 200:
+                json_data = resp.json()
+                if json_data.get("status") == "ok":
+                    config.save("url", url)
+                    # Clear skip preference since we now have a working URL
+                    DataBase("skip_flaresolverr").delete("skipped")
+                    # Update user agent from FlareSolverr response
+                    solution = json_data.get("solution", {})
+                    solution_ua = solution.get("userAgent")
+                    if solution_ua:
+                        shared_state.update("user_agent", solution_ua)
+                    info(f'FlareSolverr URL configured: "{url}"')
+                    return render_reconnect_success(
+                        "FlareSolverr URL saved successfully! A restart is recommended.")
+                else:
+                    return render_fail(f"FlareSolverr returned unexpected status: {json_data.get('status')}")
+        except requests.RequestException as e:
+            return render_fail(f"Could not reach FlareSolverr: {str(e)}")
+
+        return render_fail("Could not reach FlareSolverr at that URL (expected HTTP 200).")
+
+    @app.get("/api/flaresolverr/status")
+    def get_flaresolverr_status():
+        """Return FlareSolverr configuration status."""
+        response.content_type = 'application/json'
+        skip_db = DataBase("skip_flaresolverr")
+        is_skipped = bool(skip_db.retrieve("skipped"))
+        current_url = Config('FlareSolverr').get('url') or ""
+
+        # Test connection if URL is set
+        is_working = False
+        if current_url and not is_skipped:
+            is_working = check_flaresolverr(shared_state, current_url)
+
+        return {
+            "skipped": is_skipped,
+            "url": current_url,
+            "working": is_working
+        }
+
+    @app.delete("/api/skip-flaresolverr")
+    def clear_skip_flaresolverr():
+        """Clear skip FlareSolverr preference."""
+        response.content_type = 'application/json'
+        skip_db = DataBase("skip_flaresolverr")
+        skip_db.delete("skipped")
+        info('Skip FlareSolverr preference cleared')
+        return {"success": True}
+
+    @app.post("/api/restart")
+    def restart_quasarr():
+        """Restart Quasarr. In Docker with the restart loop, exit(0) triggers restart."""
+        response.content_type = 'application/json'
+        info("Restart requested via web UI")
+
+        def delayed_exit():
+            time.sleep(0.5)
+            # Send SIGINT to main process - triggers KeyboardInterrupt handler
+            os.kill(os.getpid(), signal.SIGINT)
+
+        threading.Thread(target=delayed_exit, daemon=True).start()
+        return {"success": True, "message": "Restarting..."}

quasarr/downloads/linkcrypters/al.py

@@ -9,6 +9,7 @@ from Cryptodome.Cipher import AES
 from PIL import Image, ImageChops
 
 from quasarr.providers.log import info, debug
+from quasarr.providers.utils import is_flaresolverr_available
 
 
 class CNL:
@@ -137,7 +138,7 @@ def decrypt_content(content_items: list[dict], mirror: str | None) -> list[str]:
             decrypted_links.extend(urls)
             debug(f"[Item {idx} | hoster={hoster_name}] Decrypted {len(urls)} URLs")
         except Exception as e:
-            # Log and keep going; one bad item won’t stop the rest.
+            # Log and keep going; one bad item won't stop the rest.
             info(f"[Item {idx} | hoster={hoster_name}] Error during decryption: {e}")
 
     return decrypted_links
@@ -160,6 +161,11 @@ def calculate_pixel_based_difference(img1, img2):
 
 
 def solve_captcha(hostname, shared_state, fetch_via_flaresolverr, fetch_via_requests_session):
+    # Check if FlareSolverr is available
+    if not is_flaresolverr_available(shared_state):
+        raise RuntimeError("FlareSolverr is required for CAPTCHA solving but is not configured. "
+                           "Please configure FlareSolverr in the web UI.")
+
     al = shared_state.values["config"]("Hostnames").get(hostname)
     captcha_base = f"https://www.{al}/files/captcha"
 
@@ -195,7 +201,7 @@ def solve_captcha(hostname, shared_state, fetch_via_flaresolverr, fetch_via_requ
     for image_id, raw_bytes in images:
         img = Image.open(BytesIO(raw_bytes))
 
-        # if it’s a palette (P) image with an indexed transparency, go through RGBA
+        # if it's a palette (P) image with an indexed transparency, go through RGBA
         if img.mode == "P" and "transparency" in img.info:
             img = img.convert("RGBA")
 

quasarr/downloads/sources/al.py

@@ -17,6 +17,7 @@ from quasarr.providers.log import info, debug
 from quasarr.providers.sessions.al import retrieve_and_validate_session, invalidate_session, unwrap_flaresolverr_body, \
     fetch_via_flaresolverr, fetch_via_requests_session
 from quasarr.providers.statistics import StatsHelper
+from quasarr.providers.utils import is_flaresolverr_available
 
 hostname = "al"
 
@@ -552,6 +553,12 @@ def get_al_download_links(shared_state, url, mirror, title, password):
     This is set by the search module, not a user password.
     """
 
+    # Check if FlareSolverr is available - AL requires it
+    if not is_flaresolverr_available(shared_state):
+        info(f'"{hostname.upper()}" requires FlareSolverr which is not configured. '
+             f'Please configure FlareSolverr in the web UI to use this site.')
+        return {}
+
     release_id = password  # password field carries release_id for AL
 
     al = shared_state.values["config"]("Hostnames").get(hostname)