quasarr 2.4.11__py3-none-any.whl → 2.5.0__py3-none-any.whl

quasarr/api/__init__.py

@@ -367,15 +367,15 @@ def get_api(shared_state_dict, shared_state_lock):
             /* Dark mode */
             @media (prefers-color-scheme: dark) {{
                 :root {{
-                    --status-success-bg: #1b5e20;
-                    --status-success-color: #a5d6a7;
-                    --status-success-border: #2e7d32;
+                    --status-success-bg: #1c4532;
+                    --status-success-color: #68d391;
+                    --status-success-border: #276749;
                     --status-warning-bg: #3d3520;
                     --status-warning-color: #ffb74d;
                     --status-warning-border: #d69e2e;
-                    --status-error-bg: #b71c1c;
-                    --status-error-color: #ef9a9a;
-                    --status-error-border: #c62828;
+                    --status-error-bg: #3d2d2d;
+                    --status-error-color: #fc8181;
+                    --status-error-border: #c53030;
                     --alert-warning-bg: #3d3520;
                     --alert-warning-border: #d69e2e;
                     --card-bg: #2d3748;

quasarr/api/config/__init__.py

@@ -3,27 +3,24 @@
 # Project by https://github.com/rix1337
 
 import os
-import re
 import signal
 import threading
 import time
-from urllib.parse import urlparse
 
-import requests
-from bottle import request, response
+from bottle import response
 
-from quasarr.providers.html_templates import render_button, render_fail, render_form
+from quasarr.providers.html_templates import render_button, render_form
 from quasarr.providers.log import info
-from quasarr.providers.shared_state import extract_valid_hostname
-from quasarr.providers.utils import (
-    check_flaresolverr,
-    extract_allowed_keys,
-    extract_kv_pairs,
-)
 from quasarr.storage.config import Config
 from quasarr.storage.setup import (
+    check_credentials,
+    clear_skip_login,
+    delete_skip_flaresolverr_preference,
+    get_flaresolverr_status_data,
+    get_skip_login,
     hostname_form_html,
-    render_reconnect_success,
+    import_hostnames_from_url,
+    save_flaresolverr_url,
     save_hostnames,
 )
 from quasarr.storage.sqlite_database import DataBase
@@ -50,7 +47,6 @@ def setup_config(app, shared_state):
             hostname_form_html(
                 shared_state,
                 message,
-                show_restart_button=True,
                 show_skip_management=True,
             )
             + back_button,
@@ -60,97 +56,21 @@ def setup_config(app, shared_state):
     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"}
-
-            # Fetch content
-            try:
-                resp = requests.get(url, timeout=15)
-                resp.raise_for_status()
-                content = resp.text
-            except requests.RequestException as e:
-                info(f"Failed to fetch hostnames URL: {e}")
-                return {
-                    "success": False,
-                    "error": "Failed to fetch URL. Check the console log for details.",
-                }
-
-            # 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",
-                }
+    @app.post("/api/hostnames/check-credentials/<shorthand>")
+    def check_credentials_api(shorthand):
+        return check_credentials(shared_state, shorthand)
 
-            # 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.post("/api/hostnames/import-url")
+    def import_hostnames_route():
+        return import_hostnames_from_url()
 
     @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}
+    def get_skip_login_route():
+        return get_skip_login()
 
     @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}
+    def clear_skip_login_route(shorthand):
+        return clear_skip_login(shorthand)
 
     @app.get("/flaresolverr")
     def flaresolverr_ui():
@@ -183,12 +103,6 @@ def setup_config(app, shared_state):
             {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;
@@ -278,78 +192,17 @@ def setup_config(app, shared_state):
     @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:
-            return render_fail("Could not reach FlareSolverr!")
-
-        return render_fail(
-            "Could not reach FlareSolverr at that URL (expected HTTP 200)."
-        )
+        return save_flaresolverr_url(shared_state)
 
     @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}
+        return get_flaresolverr_status_data(shared_state)
 
     @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}
+        return delete_skip_flaresolverr_preference()
 
     @app.post("/api/restart")
     def restart_quasarr():

quasarr/providers/version.py

@@ -5,7 +5,7 @@
 import re
 import sys
 
-__version__ = "2.4.11"
+__version__ = "2.5.0"
 
 
 def get_version():

quasarr/search/__init__.py

@@ -35,8 +35,6 @@ def get_search_results(
     season="",
     episode="",
 ):
-    results = []
-
     if imdb_id and not imdb_id.startswith("tt"):
         imdb_id = f"tt{imdb_id}"
 
@@ -66,7 +64,7 @@ def get_search_results(
 
     start_time = time.time()
 
-    functions = []
+    search_executor = SearchExecutor()
 
     # Radarr/Sonarr use imdb_id for searches
     imdb_map = [
@@ -127,7 +125,7 @@ def get_search_results(
         )
         for flag, func in imdb_map:
             if flag:
-                functions.append(lambda f=func, a=args, kw=kwargs: f(*a, **kw))
+                search_executor.add(func, args, kwargs, True)
 
     elif (
         search_phrase and docs_search
@@ -138,7 +136,7 @@ def get_search_results(
         )
         for flag, func in phrase_map:
             if flag:
-                functions.append(lambda f=func, a=args, kw=kwargs: f(*a, **kw))
+                search_executor.add(func, args, kwargs)
 
     elif search_phrase:
         debug(
@@ -149,7 +147,7 @@ def get_search_results(
         args, kwargs = ((shared_state, start_time, request_from), {"mirror": mirror})
         for flag, func in feed_map:
             if flag:
-                functions.append(lambda f=func, a=args, kw=kwargs: f(*a, **kw))
+                search_executor.add(func, args, kwargs)
 
     if imdb_id:
         stype = f'IMDb-ID "{imdb_id}"'
@@ -159,21 +157,94 @@ def get_search_results(
         stype = "feed search"
 
     info(
-        f"Starting {len(functions)} search functions for {stype}... This may take some time."
+        f"Starting {len(search_executor.searches)} searches for {stype}... This may take some time."
+    )
+    results = search_executor.run_all()
+    elapsed_time = time.time() - start_time
+    info(
+        f"Providing {len(results)} releases to {request_from} for {stype}. Time taken: {elapsed_time:.2f} seconds"
     )
 
-    with ThreadPoolExecutor() as executor:
-        futures = [executor.submit(func) for func in functions]
-        for future in as_completed(futures):
+    return results
+
+
+class SearchExecutor:
+    def __init__(self):
+        self.searches = []
+
+    def add(self, func, args, kwargs, use_cache=False):
+        # create cache key
+        key_args = list(args)
+        key_args[1] = None  # ignore start_time in cache key
+        key_args = tuple(key_args)
+        key = hash((func.__name__, key_args, frozenset(kwargs.items())))
+
+        self.searches.append((key, lambda: func(*args, **kwargs), use_cache))
+
+    def run_all(self):
+        results = []
+        futures = []
+        cache_keys = []
+        cache_used = False
+
+        with ThreadPoolExecutor() as executor:
+            for key, func, use_cache in self.searches:
+                if use_cache:
+                    cached_result = search_cache.get(key)
+                    if cached_result is not None:
+                        debug(f"Using cached result for {key}")
+                        cache_used = True
+                        results.extend(cached_result)
+                        continue
+
+                futures.append(executor.submit(func))
+                cache_keys.append(key if use_cache else None)
+
+        for index, future in enumerate(as_completed(futures)):
             try:
                 result = future.result()
                 results.extend(result)
+
+                if cache_keys[index]:  # only cache if flag is set
+                    search_cache.set(cache_keys[index], result)
             except Exception as e:
                 info(f"An error occurred: {e}")
 
-    elapsed_time = time.time() - start_time
-    info(
-        f"Providing {len(results)} releases to {request_from} for {stype}. Time taken: {elapsed_time:.2f} seconds"
-    )
+        if cache_used:
+            info("Presenting cached results instead of searching online.")
 
-    return results
+        return results
+
+
+class SearchCache:
+    def __init__(self):
+        self.last_cleaned = time.time()
+        self.cache = {}
+
+    def clean(self, now):
+        if now - self.last_cleaned < 60:
+            return
+
+        keys_to_delete = [
+            key for key, (_, expiry) in self.cache.items() if now >= expiry
+        ]
+
+        for key in keys_to_delete:
+            del self.cache[key]
+
+        self.last_cleaned = now
+
+    def get(self, key):
+        value, expiry = self.cache.get(key, (None, 0))
+        if time.time() < expiry:
+            return value
+
+        return None
+
+    def set(self, key, value, ttl=300):
+        now = time.time()
+        self.cache[key] = (value, now + ttl)
+        self.clean(now)
+
+
+search_cache = SearchCache()