quasarr 1.26.6__py3-none-any.whl → 1.27.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
 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
@@ -120,19 +119,15 @@ def run():
             if arguments.hostnames:
                 hostnames_link = arguments.hostnames
                 if is_valid_url(hostnames_link):
-                    if "pastebin.com" in hostnames_link:
-                        hostnames_link = make_raw_pastebin_link(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)
                     shorthand_list = ', '.join(
                         [f'"{key}"' for key in allowed_keys[:-1]]) + ' and ' + f'"{allowed_keys[-1]}"'
                     print(f'There are up to {max_keys} hostnames currently supported: {shorthand_list}')
-                    if "/ini.html" in hostnames_link:
-                        data = build_ini_from_ini_html(hostnames_link)
-                    else:
-                        data = requests.get(hostnames_link).text
+                    data = requests.get(hostnames_link).text
                     results = extract_kv_pairs(data, allowed_keys)
 
                     extracted_hostnames = 0
@@ -166,33 +161,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')
@@ -240,21 +223,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)
 
 
@@ -333,170 +316,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 make_raw_pastebin_link(url):
-    """
-    Takes a Pastebin URL and ensures it is a raw link.
-    If it's not a Pastebin URL, it returns the URL unchanged.
-    """
-    # Check if the URL is already a raw Pastebin link
-    if re.match(r"https?://(?:www\.)?pastebin\.com/raw/\w+", url):
-        return url  # Already raw, return as is
-
-    # Check if the URL is a standard Pastebin link
-    pastebin_pattern = r"https?://(?:www\.)?pastebin\.com/(\w+)"
-    match = re.match(pastebin_pattern, url)
-
-    if match:
-        paste_id = match.group(1)
-        print(f"The link you provided is not a raw Pastebin link. Attempting to convert it to a raw link from {url}...")
-        return f"https://pastebin.com/raw/{paste_id}"
-
-    return url  # Not a Pastebin link, return unchanged
-
-
-def build_ini_from_ini_html(url: str) -> str:
-    def get(u: str) -> str:
-        r = requests.get(u, timeout=10)
-        r.raise_for_status()
-        return r.text
-
-    parsed = urlparse(url)
-    params = parse_qs(parsed.query)
-
-    data_js = get(urljoin(f"{parsed.scheme}://{parsed.netloc}", "data.js"))
-
-    hostnames = dukpy.evaljs("""
-        var window = {};
-        %s
-        window.HOSTNAMES;
-    """ % data_js)
-
-    excluded = set()
-    if "exclude" in params:
-        excluded = set(params["exclude"][0].split(","))
-
-    lines = []
-    for h in hostnames:
-        if h["key"] not in excluded:
-            lines.append(f"{h['key']} = {h['name']}")
-
-    return "\n".join(lines) + "\n"
-
-
-def is_valid_url(url):
-    if "https://pastebin.com/raw/eX4Mpl3" in url:
-        print("Example URL detected. Please provide a valid URL found on pastebin or another 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
-        else:
-            print(f"Skipping line because it does not contain any supported hostname: {line}")
-
-    return kv_pairs

quasarr/api/config/__init__.py

@@ -2,9 +2,22 @@
 # Quasarr
 # Project by https://github.com/rix1337
 
-from quasarr.providers.html_templates import render_form
-from quasarr.providers.html_templates import render_button
+import os
+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
+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
+from quasarr.storage.config import Config
 from quasarr.storage.setup import hostname_form_html, save_hostnames
+from quasarr.storage.sqlite_database import DataBase
 
 
 def setup_config(app, shared_state):
@@ -16,8 +29,107 @@ 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.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/providers/sessions/al.py

@@ -13,6 +13,12 @@ from bs4 import BeautifulSoup
 from requests.exceptions import Timeout, RequestException
 
 from quasarr.providers.log import info, debug
+from quasarr.providers.utils import is_site_usable
+
+
+class SkippedSiteError(Exception):
+    """Raised when a site is skipped due to missing credentials or login being skipped."""
+    pass
 
 hostname = "al"
 
@@ -106,6 +112,9 @@ def create_and_persist_session(shared_state):
 
 
 def retrieve_and_validate_session(shared_state):
+    if not is_site_usable(shared_state, hostname):
+        return None
+
     db = shared_state.values["database"]("sessions")
     stored = db.retrieve(hostname)
     if not stored:
@@ -216,6 +225,16 @@ def fetch_via_flaresolverr(shared_state,
     flaresolverr_url = shared_state.values["config"]('FlareSolverr').get('url')
 
     sess = retrieve_and_validate_session(shared_state)
+    if not sess:
+        debug(f"Skipping {hostname}: site not usable (login skipped or no credentials)")
+        return {
+            "status_code": None,
+            "headers": {},
+            "json": None,
+            "text": "",
+            "cookies": [],
+            "error": f"Site '{hostname}' is not usable (login skipped or no credentials)"
+        }
 
     cmd = "request.get" if method.upper() == "GET" else "request.post"
     fs_payload = {
@@ -301,6 +320,8 @@ def fetch_via_requests_session(shared_state, method: str, target_url: str, post_
     – timeout: seconds
     """
     sess = retrieve_and_validate_session(shared_state)
+    if not sess:
+        raise SkippedSiteError(f"{hostname}: site not usable (login skipped or no credentials)")
 
     # Execute request
     if method.upper() == "GET":

quasarr/providers/sessions/dd.py

@@ -7,7 +7,10 @@ import pickle
 
 import requests
 
-from quasarr.providers.log import info
+from quasarr.providers.log import info, debug
+from quasarr.providers.utils import is_site_usable
+
+hostname = "dd"
 
 
 def create_and_persist_session(shared_state):
@@ -62,6 +65,10 @@ def create_and_persist_session(shared_state):
 
 
 def retrieve_and_validate_session(shared_state):
+    if not is_site_usable(shared_state, hostname):
+        debug(f"Skipping {hostname}: site not usable (login skipped or no credentials)")
+        return None
+
     session_string = shared_state.values["database"]("sessions").retrieve("dd")
     if not session_string:
         dd_session = create_and_persist_session(shared_state)

quasarr/providers/sessions/dl.py

@@ -9,6 +9,13 @@ import requests
 from bs4 import BeautifulSoup
 
 from quasarr.providers.log import info, debug
+from quasarr.providers.utils import is_site_usable
+
+
+class SkippedSiteError(Exception):
+    """Raised when a site is skipped due to missing credentials or login being skipped."""
+    pass
+
 
 hostname = "dl"
 
@@ -16,17 +23,17 @@ hostname = "dl"
 def create_and_persist_session(shared_state):
     """
     Create and persist a session using user and password.
-    
+
     Args:
         shared_state: Shared state object
-    
+
     Returns:
         requests.Session or None
     """
     cfg = shared_state.values["config"]("Hostnames")
     host = cfg.get(hostname)
     credentials_cfg = shared_state.values["config"](hostname.upper())
-    
+
     user = credentials_cfg.get("user")
     password = credentials_cfg.get("password")
 
@@ -35,30 +42,30 @@ def create_and_persist_session(shared_state):
         return None
 
     sess = requests.Session()
-    
+
     # Set user agent
     ua = shared_state.values["user_agent"]
     sess.headers.update({'User-Agent': ua})
-    
+
     try:
         # Step 1: Get login page to retrieve CSRF token
         login_page_url = f'https://www.{host}/login/'
         login_page = sess.get(login_page_url, timeout=30)
-        
+
         if login_page.status_code != 200:
             info(f'Failed to load login page for: "{hostname}" - Status {login_page.status_code}')
             return None
-        
+
         # Extract CSRF token from login form
         soup = BeautifulSoup(login_page.text, 'html.parser')
         csrf_input = soup.find('input', {'name': '_xfToken'})
-        
+
         if not csrf_input or not csrf_input.get('value'):
             info(f'Could not find CSRF token on login page for: "{hostname}"')
             return None
-        
+
         csrf_token = csrf_input['value']
-        
+
         # Step 2: Submit login form
         login_data = {
             'login': user,
@@ -67,18 +74,18 @@ def create_and_persist_session(shared_state):
             'remember': '1',
             '_xfRedirect': f'https://www.{host}/'
         }
-        
+
         login_url = f'https://www.{host}/login/login'
         login_response = sess.post(login_url, data=login_data, timeout=30)
-        
+
         # Step 3: Verify login success
         # Check if we're logged in by accessing the main page
         verify_response = sess.get(f'https://www.{host}/', timeout=30)
-        
+
         if 'data-logged-in="true"' not in verify_response.text:
             info(f'Login verification failed for: "{hostname}" - invalid credentials or login failed')
             return None
-        
+
         info(f'Session successfully created for: "{hostname}" using user/password')
     except Exception as e:
         info(f'Failed to create session for: "{hostname}" - {e}')
@@ -88,20 +95,23 @@ def create_and_persist_session(shared_state):
     blob = pickle.dumps(sess)
     token = base64.b64encode(blob).decode("utf-8")
     shared_state.values["database"]("sessions").update_store(hostname, token)
-    
+
     return sess
 
 
 def retrieve_and_validate_session(shared_state):
     """
     Retrieve session from database or create a new one.
-    
+
     Args:
         shared_state: Shared state object
-    
+
     Returns:
         requests.Session or None
     """
+    if not is_site_usable(shared_state, hostname):
+        return None
+
     db = shared_state.values["database"]("sessions")
     token = db.retrieve(hostname)
     if not token:
@@ -122,7 +132,7 @@ def retrieve_and_validate_session(shared_state):
 def invalidate_session(shared_state):
     """
     Invalidate the current session.
-    
+
     Args:
         shared_state: Shared state object
     """
@@ -134,7 +144,7 @@ def invalidate_session(shared_state):
 def _persist_session_to_db(shared_state, sess):
     """
     Serialize & store the given requests.Session into the database under `hostname`.
-    
+
     Args:
         shared_state: Shared state object
         sess: requests.Session to persist
@@ -144,10 +154,11 @@ def _persist_session_to_db(shared_state, sess):
     shared_state.values["database"]("sessions").update_store(hostname, token)
 
 
-def fetch_via_requests_session(shared_state, method: str, target_url: str, post_data: dict = None, get_params: dict = None, timeout: int = 30):
+def fetch_via_requests_session(shared_state, method: str, target_url: str, post_data: dict = None,
+                               get_params: dict = None, timeout: int = 30):
     """
     Execute request using the session.
-    
+
     Args:
         shared_state: Shared state object
         method: "GET" or "POST"
@@ -155,13 +166,13 @@ def fetch_via_requests_session(shared_state, method: str, target_url: str, post_
         post_data: POST data (for POST requests)
         get_params: URL parameters (for GET requests)
         timeout: Request timeout in seconds
-    
+
     Returns:
         Response object
     """
     sess = retrieve_and_validate_session(shared_state)
     if not sess:
-        raise Exception(f"Could not retrieve valid session for {hostname}")
+        raise SkippedSiteError(f"{hostname}: site not usable (login skipped or no credentials)")
 
     # Execute request
     if method.upper() == "GET":

quasarr/providers/sessions/nx.py

@@ -7,7 +7,10 @@ import pickle
 
 import requests
 
-from quasarr.providers.log import info
+from quasarr.providers.log import info, debug
+from quasarr.providers.utils import is_site_usable
+
+hostname = "nx"
 
 
 def create_and_persist_session(shared_state):
@@ -60,6 +63,10 @@ def create_and_persist_session(shared_state):
 
 
 def retrieve_and_validate_session(shared_state):
+    if not is_site_usable(shared_state, hostname):
+        debug(f"Skipping {hostname}: site not usable (login skipped or no credentials)")
+        return None
+
     session_string = shared_state.values["database"]("sessions").retrieve("nx")
     if not session_string:
         nx_session = create_and_persist_session(shared_state)