quasarr 2.6.1__py3-none-any.whl → 2.7.0__py3-none-any.whl

quasarr/__init__.py

@@ -15,7 +15,14 @@ import requests
 import quasarr.providers.web_server
 from quasarr.api import get_api
 from quasarr.providers import shared_state, version
-from quasarr.providers.log import info
+from quasarr.providers.log import (
+    crit,
+    debug,
+    error,
+    get_log_level,
+    info,
+    log_level_names,
+)
 from quasarr.providers.notifications import send_discord_message
 from quasarr.providers.utils import (
     FALLBACK_USER_AGENT,
@@ -67,26 +74,21 @@ def run():
 └────────────────────────────────────┘""")
 
         print("\n===== Recommended Services =====")
+        print('👉 Fast premium downloads: "https://linksnappy.com/?ref=397097" 👈')
         print(
-            'For convenient universal premium downloads use: "https://linksnappy.com/?ref=397097"'
-        )
-        print(
-            'Sponsors get automated CAPTCHA solutions: "https://github.com/rix1337/Quasarr?tab=readme-ov-file#sponsorshelper"'
+            '👉 Automated CAPTCHA solutions: "https://github.com/rix1337/Quasarr?tab=readme-ov-file#sponsorshelper" 👈'
         )
 
-        print("\n===== Startup Info =====")
         port = int("8080")
         config_path = ""
         if os.environ.get("DOCKER"):
             config_path = "/config"
             if not arguments.internal_address:
-                print(
+                error(
                     "You must set the INTERNAL_ADDRESS variable to a locally reachable URL, e.g. http://192.168.1.1:8080"
+                    + " The local URL will be used by Radarr/Sonarr to connect to Quasarr"
+                    + " Stopping Quasarr..."
                 )
-                print(
-                    "The local URL will be used by Radarr/Sonarr to connect to Quasarr"
-                )
-                print("Stopping Quasarr...")
                 sys.exit(1)
         else:
             if arguments.port:
@@ -118,7 +120,7 @@ def run():
             temp_file = tempfile.TemporaryFile(dir=config_path)
             temp_file.close()
         except Exception as e:
-            print(f'Could not access "{config_path}": {e}"Stopping Quasarr...')
+            error(f'Could not access "{config_path}": {e}"Stopping Quasarr...')
             sys.exit(1)
 
         shared_state.set_files(config_path)
@@ -130,16 +132,13 @@ def run():
         shared_state.update("user_agent", FALLBACK_USER_AGENT)
         shared_state.update("helper_active", False)
 
-        print(f'Config path: "{config_path}"')
-
-        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}...")
+                    info(f"Extracting hostnames from {hostnames_link}...")
                     allowed_keys = supported_hostnames
                     max_keys = len(allowed_keys)
                     shorthand_list = (
@@ -147,7 +146,7 @@ def run():
                         + " and "
                         + f'"{allowed_keys[-1]}"'
                     )
-                    print(
+                    info(
                         f"There are up to {max_keys} hostnames currently supported: {shorthand_list}"
                     )
                     data = requests.get(hostnames_link).text
@@ -165,36 +164,32 @@ def run():
                             if valid_domain:
                                 hostnames.save(shorthand, hostname)
                                 extracted_hostnames += 1
-                                print(
+                                info(
                                     f'Hostname for "{shorthand}" successfully set to "{hostname}"'
                                 )
                             else:
-                                print(
+                                info(
                                     f'Skipping invalid hostname for "{shorthand}" ("{hostname}")'
                                 )
                         if extracted_hostnames == max_keys:
-                            print(f"All {max_keys} hostnames successfully extracted!")
-                            print(
+                            info(f"All {max_keys} hostnames successfully extracted!")
+                            info(
                                 "You can now remove the hostnames link from the command line / environment variable."
                             )
                     else:
-                        print(
+                        info(
                             f'No Hostnames found at "{hostnames_link}". '
                             "Ensure to pass a plain hostnames list, not html or json!"
                         )
                 else:
-                    print(f'Invalid hostnames URL: "{hostnames_link}"')
+                    error(f'Invalid hostnames URL: "{hostnames_link}"')
         except Exception as e:
-            print(f'Error parsing hostnames link: "{e}"')
+            error(f'Error parsing hostnames link: "{e}"')
 
         hostnames = get_clean_hostnames(shared_state)
         if not hostnames:
             hostnames_config(shared_state)
             hostnames = get_clean_hostnames(shared_state)
-        print(
-            f"You have [{len(hostnames)} of {len(Config._DEFAULT_CONFIG['Hostnames'])}] supported hostnames set up"
-        )
-        print("For efficiency it is recommended to set up as few hostnames as needed.")
 
         # Check credentials for login-required hostnames
         skip_login_db = DataBase("skip_login")
@@ -237,43 +232,54 @@ def run():
         if not user or not password or not device:
             jdownloader_config(shared_state)
 
-        print("\n===== Notifications =====")
         discord_url = ""
         if arguments.discord:
             discord_webhook_pattern = r"^https://discord\.com/api/webhooks/\d+/[\w-]+$"
             if re.match(discord_webhook_pattern, arguments.discord):
                 shared_state.update("webhook", arguments.discord)
-                print("Using Discord Webhook URL for notifications.")
                 discord_url = arguments.discord
             else:
-                print(f"Invalid Discord Webhook URL provided: {arguments.discord}")
-        else:
-            print("No Discord Webhook URL provided")
+                error(f"Invalid Discord Webhook URL provided: {arguments.discord}")
         shared_state.update("discord", discord_url)
 
-        print("\n===== API Information =====")
         api_key = Config("API").get("key")
         if not api_key:
             api_key = shared_state.generate_api_key()
+            info("API-Key generated: <g>" + api_key + "</g>")
 
-        print(
-            'Setup instructions: "https://github.com/rix1337/Quasarr?tab=readme-ov-file#instructions"'
-        )
-        print(f'URL: "{shared_state.values["internal_address"]}"')
-        print(f'API Key: "{api_key}" (without quotes)')
+        print(f"\n===== Quasarr {log_level_names[get_log_level()]} Log =====")
 
-        if external_address != internal_address:
-            print(f'External URL: "{shared_state.values["external_address"]}"')
+        # Start Logging
+        info(f"Web UI: <blue>{shared_state.values['external_address']}</blue>")
+        debug(f'Config path: "{config_path}"')
 
-        print("\n===== Quasarr Info Log =====")
-        if os.getenv("DEBUG"):
-            print("=====    / Debug Log   =====")
+        # Hostnames log
+        hostnames_log = []
+        set_hostnames_count = 0
+        for key in supported_hostnames:
+            if key in hostnames:
+                hostnames_log.append(
+                    f"<bg green><black>{key.upper()}</black></bg green>"
+                )
+                set_hostnames_count += 1
+            else:
+                hostnames_log.append(
+                    f"<bg black><white>{key.upper()}</white></bg black>"
+                )
+
+        total_hostnames_count = len(supported_hostnames)
+        if set_hostnames_count == total_hostnames_count:
+            count_str = f"<g>{set_hostnames_count}</g>/<g>{total_hostnames_count}</g>"
+        else:
+            count_str = f"<y>{set_hostnames_count}</y>/<g>{total_hostnames_count}</g>"
+
+        info(f"Hostnames: [{' '.join(hostnames_log)}] {count_str} set")
 
         protected = shared_state.get_db("protected").retrieve_all_titles()
         if protected:
             package_count = len(protected)
             info(
-                f"CAPTCHA-Solution required for {package_count} package{'s' if package_count > 1 else ''} at: "
+                f"CAPTCHA-Solution required for <y>{package_count}</y> package{'s' if package_count > 1 else ''} at: "
                 f'"{shared_state.values["external_address"]}/captcha"!'
             )
 
@@ -329,21 +335,26 @@ def flaresolverr_checker(shared_state_dict, shared_state_lock):
                 "Some sites (AL) will not work without FlareSolverr. Configure it later in the web UI."
             )
         elif flaresolverr_url:
-            info(f'Checking FlareSolverr at URL: "{flaresolverr_url}"')
-            flaresolverr_check = check_flaresolverr(shared_state, flaresolverr_url)
-            if flaresolverr_check:
+            debug(f"Checking FlareSolverr at URL: <blue>{flaresolverr_url}</blue>")
+            flaresolverr_version_checked = check_flaresolverr(
+                shared_state, flaresolverr_url
+            )
+            if flaresolverr_version_checked:
                 info(
-                    f'FlareSolverr connection successful. Using User-Agent: "{shared_state.values["user_agent"]}"'
+                    f"FlareSolverr connection successful: <g>v.{flaresolverr_version_checked}</g>"
+                )
+                debug(
+                    f"Using Flaresolverr's User-Agent: <g>{shared_state.values['user_agent']}</g>"
                 )
             else:
-                info("FlareSolverr check failed - using fallback user agent")
+                error("FlareSolverr check failed - using fallback user agent")
                 # Fallback user agent is already set in main process, but we log it
                 info(f'User Agent (fallback): "{FALLBACK_USER_AGENT}"')
 
     except KeyboardInterrupt:
         pass
     except Exception as e:
-        info(f"An unexpected error occurred in FlareSolverr checker: {e}")
+        error(f"An unexpected error occurred in FlareSolverr checker: {e}")
 
 
 def update_checker(shared_state_dict, shared_state_lock):
@@ -359,8 +370,9 @@ def update_checker(shared_state_dict, shared_state_lock):
             try:
                 update_available = version.newer_version_available()
             except Exception as e:
-                info(f"Error getting latest version: {e}")
-                info(f'Please manually check: "{link}" for more information!')
+                error(
+                    f"Error getting latest version: {e}!\nPlease manually check: <blue>{link}</blue> for more information!"
+                )
                 update_available = None
 
             if (
@@ -392,27 +404,25 @@ def jdownloader_connection(shared_state_dict, shared_state_lock):
             device = shared_state.get_device()
 
             try:
-                info(
-                    f'Connection to JDownloader successful. Device name: "{device.name}"'
-                )
+                info(f"Connection to JDownloader successful: <g>{device.name}</g>")
             except Exception as e:
-                info(f"Error connecting to JDownloader: {e}! Stopping Quasarr...")
+                crit(f"Error connecting to JDownloader: {e}! Stopping Quasarr...")
                 sys.exit(1)
 
             try:
                 shared_state.set_device_settings()
             except Exception as e:
-                print(f"Error checking settings: {e}")
+                error(f"Error checking settings: {e}")
 
             try:
                 shared_state.update_jdownloader()
             except Exception as e:
-                print(f"Error updating JDownloader: {e}")
+                error(f"Error updating JDownloader: {e}")
 
             try:
                 shared_state.start_downloads()
             except Exception as e:
-                print(f"Error starting downloads: {e}")
+                error(f"Error starting downloads: {e}")
 
             while True:
                 time.sleep(300)
@@ -420,7 +430,7 @@ def jdownloader_connection(shared_state_dict, shared_state_lock):
                     shared_state.values.get("device")
                 )
                 if not device_state:
-                    info("Lost connection to JDownloader. Reconnecting...")
+                    error("Lost connection to JDownloader. Reconnecting...")
                     shared_state.update("device", False)
                     break
 

quasarr/api/__init__.py

@@ -34,8 +34,7 @@ def get_api(shared_state_dict, shared_state_lock):
     add_auth_routes(app)
     add_auth_hook(
         app,
-        whitelist_prefixes=["/api", "/api/", "/sponsors_helper/", "/download/"],
-        whitelist_suffixes=[".user.js"],
+        whitelist=["/api", "/api/", "/sponsors_helper/", "/download/", ".user.js"],
     )
 
     setup_arr_routes(app)

quasarr/api/arr/__init__.py

@@ -2,6 +2,7 @@
 # Quasarr
 # Project by https://github.com/rix1337
 
+import time
 import traceback
 import xml.sax.saxutils as sax_utils
 from base64 import urlsafe_b64decode
@@ -59,7 +60,8 @@ def setup_arr_routes(app):
     def check_user_agent():
         user_agent = request.headers.get("User-Agent") or ""
         if not any(
-            tool in user_agent.lower() for tool in ["radarr", "sonarr", "lazylibrarian"]
+            tool in user_agent.lower()
+            for tool in ["radarr", "sonarr", "lazylibrarian", "python-requests"]
         ):
             msg = f"Unsupported User-Agent: {user_agent}. Quasarr as a compatibility layer must be called by Radarr, Sonarr or LazyLibrarian directly."
             info(msg)
@@ -107,7 +109,7 @@ def setup_arr_routes(app):
             imdb_id = root.find(".//file").attrib.get("imdb_id")
             source_key = root.find(".//file").attrib.get("source_key") or None
 
-            info(f'Attempting download for "{title}"')
+            info(f"Attempting download for <y>{title}</y>")
             downloaded = download(
                 shared_state,
                 request_from,
@@ -125,12 +127,12 @@ def setup_arr_routes(app):
                 title = downloaded["title"]
 
                 if success:
-                    info(f'"{title}" added successfully!')
+                    info(f"<y>{title}</y> added successfully!")
                 else:
-                    info(f'"{title}" added unsuccessfully! See log for details.')
+                    info(f"<y>{title}</y> added unsuccessfully! See log for details.")
                 nzo_ids.append(package_id)
             except KeyError:
-                info(f'Failed to download "{title}" - no package_id returned')
+                info(f"Failed to download <y>{title}</y> - no package_id returned")
 
         return {"status": True, "nzo_ids": nzo_ids}
 
@@ -209,7 +211,7 @@ def setup_arr_routes(app):
                         abort(400, f"invalid payload format: {e}")
 
                     nzo_ids = []
-                    info(f'Attempting download for "{parsed_payload["title"]}"')
+                    info(f"Attempting download for <y>{parsed_payload['title']}</y>")
 
                     downloaded = download(
                         shared_state,
@@ -229,11 +231,9 @@ def setup_arr_routes(app):
                         title = downloaded.get("title", parsed_payload["title"])
 
                         if success:
-                            info(f'"{title}" added successfully!')
+                            info(f'"{title} added successfully!')
                         else:
-                            info(
-                                f'"{title}" added unsuccessfully! See log for details.'
-                            )
+                            info(f'"{title} added unsuccessfully! See log for details.')
                         nzo_ids.append(package_id)
                     except KeyError:
                         info(
@@ -304,69 +304,92 @@ def setup_arr_routes(app):
                                 </caps>"""
                 elif mode in ["movie", "tvsearch", "book", "search"]:
                     releases = []
+                    cache_key = None
 
                     try:
                         offset = int(getattr(request.query, "offset", 0))
-                    except (AttributeError, ValueError):
+                    except (AttributeError, ValueError) as e:
+                        debug(f"Error parsing offset parameter: {e}")
                         offset = 0
 
-                    if offset > 0:
-                        debug(
-                            f"Ignoring offset parameter: {offset} - it leads to redundant requests"
+                    try:
+                        limit = int(getattr(request.query, "limit", 100))
+                    except (AttributeError, ValueError) as e:
+                        debug(f"Error parsing limit parameter: {e}")
+                        limit = 100
+
+                    if mode == "movie":
+                        # supported params: imdbid
+                        imdb_id = getattr(request.query, "imdbid", "")
+
+                        if imdb_id != "":
+                            cache_key = f"{request_from}::{imdb_id}::${mirror}"
+
+                            if result := results_cache.get(cache_key, offset, limit):
+                                debug(
+                                    f"Returning offset {offset}, limit {limit} for {cache_key}"
+                                )
+                                return result
+
+                        releases = get_search_results(
+                            shared_state,
+                            request_from,
+                            imdb_id=imdb_id,
+                            mirror=mirror,
                         )
 
-                    else:
-                        if mode == "movie":
-                            # supported params: imdbid
-                            imdb_id = getattr(request.query, "imdbid", "")
+                    elif mode == "tvsearch":
+                        # supported params: imdbid, season, ep
+                        imdb_id = getattr(request.query, "imdbid", "")
+                        season = getattr(request.query, "season", None)
+                        episode = getattr(request.query, "ep", None)
 
-                            releases = get_search_results(
-                                shared_state,
-                                request_from,
-                                imdb_id=imdb_id,
-                                mirror=mirror,
-                            )
+                        if imdb_id != "":
+                            cache_key = f"{request_from}::{imdb_id}::${mirror}::{season}::{episode}"
 
-                        elif mode == "tvsearch":
-                            # supported params: imdbid, season, ep
-                            imdb_id = getattr(request.query, "imdbid", "")
-                            season = getattr(request.query, "season", None)
-                            episode = getattr(request.query, "ep", None)
-                            releases = get_search_results(
-                                shared_state,
-                                request_from,
-                                imdb_id=imdb_id,
-                                mirror=mirror,
-                                season=season,
-                                episode=episode,
-                            )
-                        elif mode == "book":
-                            author = getattr(request.query, "author", "")
-                            title = getattr(request.query, "title", "")
-                            search_phrase = " ".join(filter(None, [author, title]))
+                            if result := results_cache.get(cache_key, offset, limit):
+                                debug(
+                                    f"Returning offset {offset}, limit {limit} for {cache_key}"
+                                )
+                                return result
+
+                        releases = get_search_results(
+                            shared_state,
+                            request_from,
+                            imdb_id=imdb_id,
+                            mirror=mirror,
+                            season=season,
+                            episode=episode,
+                        )
+                    elif mode == "book":
+                        author = getattr(request.query, "author", "")
+                        title = getattr(request.query, "title", "")
+                        search_phrase = " ".join(filter(None, [author, title]))
+                        releases = get_search_results(
+                            shared_state,
+                            request_from,
+                            search_phrase=search_phrase,
+                            mirror=mirror,
+                        )
+
+                    elif mode == "search":
+                        if "lazylibrarian" in request_from.lower():
+                            search_phrase = getattr(request.query, "q", "")
                             releases = get_search_results(
                                 shared_state,
                                 request_from,
                                 search_phrase=search_phrase,
                                 mirror=mirror,
                             )
-
-                        elif mode == "search":
-                            if "lazylibrarian" in request_from.lower():
-                                search_phrase = getattr(request.query, "q", "")
-                                releases = get_search_results(
-                                    shared_state,
-                                    request_from,
-                                    search_phrase=search_phrase,
-                                    mirror=mirror,
-                                )
-                            else:
-                                # sonarr expects this but we will not support non-imdbid searches
-                                debug(
-                                    f"Ignoring search request from {request_from} - only imdbid searches are supported"
-                                )
+                        else:
+                            # sonarr expects this but we will not support non-imdbid searches
+                            debug(
+                                f"Ignoring search request from {request_from} - only imdbid searches are supported"
+                            )
 
                     items = ""
+                    items_amount = 0
+                    items_processed = 0
                     for release in releases:
                         release = release.get("details", {})
 
@@ -389,6 +412,43 @@ def setup_arr_routes(app):
                             <pubDate>{pub_date}</pubDate>
                             <enclosure url="{release.get("link", "")}" length="{release.get("size", 0)}" type="application/x-nzb" />
                         </item>'''
+                        items_amount += 1
+
+                        if cache_key and items_amount == limit:
+                            items_processed += items_amount
+                            debug(
+                                f"Processed {items_processed}/{len(releases)} releases"
+                            )
+                            results_cache.set(
+                                cache_key,
+                                f"""<?xml version="1.0" encoding="UTF-8"?>
+                                <rss>
+                                    <channel>
+                                        {items}
+                                    </channel>
+                                </rss>""",
+                                items_processed - items_amount,
+                                limit,
+                            )
+                            items = ""
+                            items_amount = 0
+
+                    if cache_key and items_amount > 0:
+                        items_processed += items_amount
+                        debug(f"Processed {items_processed}/{len(releases)} releases")
+                        results_cache.set(
+                            cache_key,
+                            f"""<?xml version="1.0" encoding="UTF-8"?>
+                                <rss>
+                                    <channel>
+                                        {items}
+                                    </channel>
+                                </rss>""",
+                            items_processed - items_amount,
+                            limit,
+                        )
+                        items = ""
+                        items_amount = 0
 
                     requires_placeholder_item = not getattr(
                         request.query, "imdbid", ""
@@ -404,6 +464,13 @@ def setup_arr_routes(app):
                             <enclosure url="https://github.com/rix1337/Quasarr" length="0" type="application/x-nzb" />
                         </item>"""
 
+                    if cache_key:
+                        if result := results_cache.get(cache_key, offset, limit):
+                            debug(
+                                f"Returning offset {offset}, limit {limit} for {cache_key}"
+                            )
+                            return result
+
                     return f"""<?xml version="1.0" encoding="UTF-8"?>
                                 <rss>
                                     <channel>
@@ -425,3 +492,39 @@ def setup_arr_routes(app):
 
         info(f"[ERROR] Unknown general request: {dict(request.query)}")
         return {"error": True}
+
+
+class ResultsCache:
+    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, offset, limit):
+        key = key + f"::{offset}::{limit}"
+        value, expiry = self.cache.get(key, (None, 0))
+        if time.time() < expiry:
+            return value
+
+        return None
+
+    def set(self, key, value, offset, limit, ttl=300):
+        now = time.time()
+        key = key + f"::{offset}::{limit}"
+        self.cache[key] = (value, now + ttl)
+        self.clean(now)
+
+
+results_cache = ResultsCache()