quasarr 0.1.6__py3-none-any.whl → 1.23.0__py3-none-any.whl

quasarr/providers/statistics.py

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+from typing import Dict, Any
+
+
+class StatsHelper:
+    """
+    Multiprocessing-safe stats helper using separate rows.
+    Uses shared_state for database access across processes.
+    """
+
+    def __init__(self, shared_state):
+        self.shared_state = shared_state
+        self._ensure_stats_exist()
+
+    def _get_db(self):
+        """Get database interface through shared_state"""
+        return self.shared_state.values["database"]("statistics")
+
+    def _ensure_stats_exist(self):
+        """Initialize stats if they don't exist"""
+        default_stats = {
+            "packages_downloaded": 0,
+            "links_processed": 0,
+            "captcha_decryptions_automatic": 0,
+            "captcha_decryptions_manual": 0,
+            "failed_downloads": 0,
+            "failed_decryptions_automatic": 0,
+            "failed_decryptions_manual": 0
+        }
+
+        db = self._get_db()
+        for key, default_value in default_stats.items():
+            if db.retrieve(key) is None:
+                db.store(key, str(default_value))
+
+    def _get_stat(self, key: str, default: int = 0) -> int:
+        """Get a single stat value"""
+        try:
+            db = self._get_db()
+            value = db.retrieve(key)
+            return int(value) if value is not None else default
+        except (ValueError, TypeError):
+            return default
+
+    def _increment_stat(self, key: str, count: int = 1):
+        """Process-safe increment of a single stat"""
+        db = self._get_db()
+        current = self._get_stat(key, 0)
+        db.update_store(key, str(current + count))
+
+    def increment_package_with_links(self, links):
+        """Increment package downloaded and links processed for one package, or failed download if no links
+
+        Args:
+            links: Can be:
+                - list/array: counts the length
+                - int: uses the value directly  
+                - None/False/empty: treats as failed download
+        """
+        # Handle different input types
+        if links is None or links is False:
+            link_count = 0
+        elif isinstance(links, (list, tuple)):
+            link_count = len(links)
+        elif isinstance(links, int):
+            link_count = links
+        else:
+            # Handle other falsy values or unexpected types
+            try:
+                link_count = int(links) if links else 0
+            except (ValueError, TypeError):
+                link_count = 0
+
+        # Now handle the actual increment logic
+        if link_count == 0:
+            self._increment_stat("failed_downloads", 1)
+        else:
+            self._increment_stat("packages_downloaded", 1)
+            self._increment_stat("links_processed", link_count)
+
+    def increment_captcha_decryptions_automatic(self):
+        """Increment automatic captcha decryptions counter"""
+        self._increment_stat("captcha_decryptions_automatic", 1)
+
+    def increment_captcha_decryptions_manual(self):
+        """Increment manual captcha decryptions counter"""
+        self._increment_stat("captcha_decryptions_manual", 1)
+
+    def increment_failed_downloads(self):
+        """Increment failed downloads counter"""
+        self._increment_stat("failed_downloads", 1)
+
+    def increment_failed_decryptions_automatic(self):
+        """Increment failed automatic decryptions counter"""
+        self._increment_stat("failed_decryptions_automatic", 1)
+
+    def increment_failed_decryptions_manual(self):
+        """Increment failed manual decryptions counter"""
+        self._increment_stat("failed_decryptions_manual", 1)
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get all current statistics"""
+        stats = {
+            "packages_downloaded": self._get_stat("packages_downloaded", 0),
+            "links_processed": self._get_stat("links_processed", 0),
+            "captcha_decryptions_automatic": self._get_stat("captcha_decryptions_automatic", 0),
+            "captcha_decryptions_manual": self._get_stat("captcha_decryptions_manual", 0),
+            "failed_downloads": self._get_stat("failed_downloads", 0),
+            "failed_decryptions_automatic": self._get_stat("failed_decryptions_automatic", 0),
+            "failed_decryptions_manual": self._get_stat("failed_decryptions_manual", 0)
+        }
+
+        # Calculate totals and rates
+        total_captcha_decryptions = stats["captcha_decryptions_automatic"] + stats["captcha_decryptions_manual"]
+        total_failed_decryptions = stats["failed_decryptions_automatic"] + stats["failed_decryptions_manual"]
+        total_download_attempts = stats["packages_downloaded"] + stats["failed_downloads"]
+        total_decryption_attempts = total_captcha_decryptions + total_failed_decryptions
+        total_automatic_attempts = stats["captcha_decryptions_automatic"] + stats["failed_decryptions_automatic"]
+        total_manual_attempts = stats["captcha_decryptions_manual"] + stats["failed_decryptions_manual"]
+
+        # Add calculated fields
+        stats.update({
+            "total_captcha_decryptions": total_captcha_decryptions,
+            "total_failed_decryptions": total_failed_decryptions,
+            "total_download_attempts": total_download_attempts,
+            "total_decryption_attempts": total_decryption_attempts,
+            "total_automatic_attempts": total_automatic_attempts,
+            "total_manual_attempts": total_manual_attempts,
+            "download_success_rate": (
+                (stats["packages_downloaded"] / total_download_attempts * 100)
+                if total_download_attempts > 0 else 0
+            ),
+            "decryption_success_rate": (
+                (total_captcha_decryptions / total_decryption_attempts * 100)
+                if total_decryption_attempts > 0 else 0
+            ),
+            "automatic_decryption_success_rate": (
+                (stats["captcha_decryptions_automatic"] / total_automatic_attempts * 100)
+                if total_automatic_attempts > 0 else 0
+            ),
+            "manual_decryption_success_rate": (
+                (stats["captcha_decryptions_manual"] / total_manual_attempts * 100)
+                if total_manual_attempts > 0 else 0
+            ),
+            "average_links_per_package": (
+                stats["links_processed"] / stats["packages_downloaded"]
+                if stats["packages_downloaded"] > 0 else 0
+            )
+        })
+
+        return stats

quasarr/providers/version.py

@@ -4,9 +4,68 @@
 
 import re
 
+import requests
+
 
 def get_version():
-    return "0.1.6"
+    return "1.23.0"
+
+
+def get_latest_version():
+    """
+    Query GitHub API for the latest release of the Quasarr repository.
+    Returns the tag name string (e.g. "1.5.0" or "1.4.2a1").
+    Raises RuntimeError on HTTP errors.
+    """
+    api_url = "https://api.github.com/repos/rix1337/Quasarr/releases/latest"
+    resp = requests.get(api_url, headers={"Accept": "application/vnd.github.v3+json"})
+    if resp.status_code != 200:
+        raise RuntimeError(f"GitHub API error: {resp.status_code} {resp.text}")
+    data = resp.json()
+    tag = data.get("tag_name") or data.get("name")
+    if not tag:
+        raise RuntimeError("Could not find tag_name in GitHub response")
+    return tag
+
+
+def _version_key(v):
+    """
+    Normalize a version string into a tuple for comparisons.
+    E.g. "1.4.2a3" -> (1, 4, 2, 'a', 3), "1.4.2" -> (1, 4, 2, '', 0)
+    """
+    m = re.match(r"^([0-9]+(?:\.[0-9]+)*)([a-z]?)([0-9]*)$", v)
+    if not m:
+        clean = re.sub(r"[^\d.]", "", v)
+        parts = clean.split(".")
+        nums = tuple(int(x) for x in parts if x.isdigit())
+        return nums + ("", 0)
+    base, alpha, num = m.groups()
+    nums = tuple(int(x) for x in base.split("."))
+    suffix_num = int(num) if num.isdigit() else 0
+    return nums + (alpha or "", suffix_num)
+
+
+def is_newer(latest, current):
+    """
+    Return True if latest > current using semantic+alpha comparison.
+    """
+    return _version_key(latest) > _version_key(current)
+
+
+def newer_version_available():
+    """
+    Check local vs. GitHub latest version.
+    Returns the latest version string if a newer release is available,
+    otherwise returns None.
+    """
+    try:
+        current = get_version()
+        latest = get_latest_version()
+    except:
+        raise
+    if is_newer(latest, current):
+        return latest
+    return None
 
 
 def create_version_file():

quasarr/providers/web_server.py

@@ -24,7 +24,7 @@ class Server:
         self.listen = listen
         self.port = port
         self.server = make_server(self.listen, self.port, self.wsgi_app,
-                                  ThreadingWSGIServer)
+                                  ThreadingWSGIServer, handler_class=NoLoggingWSGIRequestHandler)
 
     def serve_temporarily(self):
         global temp_server_success

quasarr/search/__init__.py

@@ -2,32 +2,161 @@
 # Quasarr
 # Project by https://github.com/rix1337
 
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from quasarr.providers.log import info, debug
+from quasarr.search.sources.al import al_feed, al_search
+from quasarr.search.sources.by import by_feed, by_search
+from quasarr.search.sources.dd import dd_search, dd_feed
+from quasarr.search.sources.dj import dj_search, dj_feed
+from quasarr.search.sources.dl import dl_search, dl_feed
+from quasarr.search.sources.dt import dt_feed, dt_search
 from quasarr.search.sources.dw import dw_feed, dw_search
 from quasarr.search.sources.fx import fx_feed, fx_search
+from quasarr.search.sources.he import he_feed, he_search
+from quasarr.search.sources.mb import mb_feed, mb_search
+from quasarr.search.sources.nk import nk_feed, nk_search
 from quasarr.search.sources.nx import nx_feed, nx_search
+from quasarr.search.sources.sf import sf_feed, sf_search
+from quasarr.search.sources.sj import sj_search, sj_feed
+from quasarr.search.sources.sl import sl_feed, sl_search
+from quasarr.search.sources.wd import wd_feed, wd_search
+from quasarr.search.sources.wx import wx_feed, wx_search
 
 
-def get_search_results(shared_state, request_from, imdb_id=None):
+def get_search_results(shared_state, request_from, imdb_id="", search_phrase="", mirror=None, season="", episode=""):
     results = []
 
+    if imdb_id and not imdb_id.startswith('tt'):
+        imdb_id = f'tt{imdb_id}'
+
+    docs_search = "lazylibrarian" in request_from.lower()
+
+    al = shared_state.values["config"]("Hostnames").get("al")
+    by = shared_state.values["config"]("Hostnames").get("by")
+    dd = shared_state.values["config"]("Hostnames").get("dd")
+    dl = shared_state.values["config"]("Hostnames").get("dl")
+    dt = shared_state.values["config"]("Hostnames").get("dt")
+    dj = shared_state.values["config"]("Hostnames").get("dj")
     dw = shared_state.values["config"]("Hostnames").get("dw")
     fx = shared_state.values["config"]("Hostnames").get("fx")
+    he = shared_state.values["config"]("Hostnames").get("he")
+    mb = shared_state.values["config"]("Hostnames").get("mb")
+    nk = shared_state.values["config"]("Hostnames").get("nk")
     nx = shared_state.values["config"]("Hostnames").get("nx")
+    sf = shared_state.values["config"]("Hostnames").get("sf")
+    sj = shared_state.values["config"]("Hostnames").get("sj")
+    sl = shared_state.values["config"]("Hostnames").get("sl")
+    wd = shared_state.values["config"]("Hostnames").get("wd")
+    wx = shared_state.values["config"]("Hostnames").get("wx")
+
+    start_time = time.time()
+
+    functions = []
+
+    # Radarr/Sonarr use imdb_id for searches
+    imdb_map = [
+        (al, al_search),
+        (by, by_search),
+        (dd, dd_search),
+        (dl, dl_search),
+        (dt, dt_search),
+        (dj, dj_search),
+        (dw, dw_search),
+        (fx, fx_search),
+        (he, he_search),
+        (mb, mb_search),
+        (nk, nk_search),
+        (nx, nx_search),
+        (sf, sf_search),
+        (sj, sj_search),
+        (sl, sl_search),
+        (wd, wd_search),
+        (wx, wx_search),
+    ]
+
+    # LazyLibrarian uses search_phrase for searches
+    phrase_map = [
+        (by, by_search),
+        (dl, dl_search),
+        (dt, dt_search),
+        (nx, nx_search),
+        (sl, sl_search),
+        (wd, wd_search),
+    ]
+
+    # Feed searches omit imdb_id and search_phrase
+    feed_map = [
+        (al, al_feed),
+        (by, by_feed),
+        (dd, dd_feed),
+        (dj, dj_feed),
+        (dl, dl_feed),
+        (dt, dt_feed),
+        (dw, dw_feed),
+        (fx, fx_feed),
+        (he, he_feed),
+        (mb, mb_feed),
+        (nk, nk_feed),
+        (nx, nx_feed),
+        (sf, sf_feed),
+        (sj, sj_feed),
+        (sl, sl_feed),
+        (wd, wd_feed),
+        (wx, wx_feed),
+    ]
+
+    if imdb_id:  # only Radarr/Sonarr are using imdb_id
+        args, kwargs = (
+            (shared_state, start_time, request_from, imdb_id),
+            {'mirror': mirror, 'season': season, 'episode': episode}
+        )
+        for flag, func in imdb_map:
+            if flag:
+                functions.append(lambda f=func, a=args, kw=kwargs: f(*a, **kw))
+
+    elif search_phrase and docs_search:  # only LazyLibrarian is allowed to use search_phrase
+        args, kwargs = (
+            (shared_state, start_time, request_from, search_phrase),
+            {'mirror': mirror, 'season': season, 'episode': episode}
+        )
+        for flag, func in phrase_map:
+            if flag:
+                functions.append(lambda f=func, a=args, kw=kwargs: f(*a, **kw))
+
+    elif search_phrase:
+        debug(
+            f"Search phrase '{search_phrase}' is not supported for {request_from}. Only LazyLibrarian can use search phrases.")
+
+    else:
+        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))
 
     if imdb_id:
-        if dw:
-            results.extend(dw_search(shared_state, request_from, imdb_id))
-        if fx:
-            results.extend(fx_search(shared_state, imdb_id))
-        if nx:
-            results.extend(nx_search(shared_state, request_from, imdb_id))
+        stype = f'IMDb-ID "{imdb_id}"'
+    elif search_phrase:
+        stype = f'Search-Phrase "{search_phrase}"'
     else:
-        if dw:
-            results.extend(dw_feed(shared_state, request_from))
-        if fx:
-            results.extend(fx_feed(shared_state))
-        if nx:
-            results.extend(nx_feed(shared_state, request_from))
-
-    print(f"Providing {len(results)} releases to {request_from}")
+        stype = "feed search"
+
+    info(f'Starting {len(functions)} search functions for {stype}... This may take some time.')
+
+    with ThreadPoolExecutor() as executor:
+        futures = [executor.submit(func) for func in functions]
+        for future in as_completed(futures):
+            try:
+                result = future.result()
+                results.extend(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")
+
     return results