quasarr 2.4.7__py3-none-any.whl → 2.4.9__py3-none-any.whl

quasarr/providers/statistics.py

@@ -3,7 +3,7 @@
 # Project by https://github.com/rix1337
 
 from json import loads
-from typing import Dict, Any
+from typing import Any, Dict
 
 
 class StatsHelper:
@@ -29,7 +29,7 @@ class StatsHelper:
             "captcha_decryptions_manual": 0,
             "failed_downloads": 0,
             "failed_decryptions_automatic": 0,
-            "failed_decryptions_manual": 0
+            "failed_decryptions_manual": 0,
         }
 
         db = self._get_db()
@@ -58,7 +58,7 @@ class StatsHelper:
         Args:
             links: Can be:
                 - list/array: counts the length
-                - int: uses the value directly  
+                - int: uses the value directly
                 - None/False/empty: treats as failed download
         """
         # Handle different input types
@@ -127,7 +127,11 @@ class StatsHelper:
                     if data.get("poster_link"):
                         with_poster += 1
 
-                    if data.get("localized") and isinstance(data["localized"], dict) and len(data["localized"]) > 0:
+                    if (
+                        data.get("localized")
+                        and isinstance(data["localized"], dict)
+                        and len(data["localized"]) > 0
+                    ):
                         with_localized += 1
 
                 except (ValueError, TypeError):
@@ -137,14 +141,14 @@ class StatsHelper:
                 "imdb_total_cached": total_cached,
                 "imdb_with_title": with_title,
                 "imdb_with_poster": with_poster,
-                "imdb_with_localized": with_localized
+                "imdb_with_localized": with_localized,
             }
         except Exception:
             return {
                 "imdb_total_cached": 0,
                 "imdb_with_title": 0,
                 "imdb_with_poster": 0,
-                "imdb_with_localized": 0
+                "imdb_with_localized": 0,
             }
 
     def get_stats(self) -> Dict[str, Any]:
@@ -152,50 +156,78 @@ class StatsHelper:
         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),
+            "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)
+            "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_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"]
+        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
-            )
-        })
+        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
+                ),
+            }
+        )
 
         # Add IMDb cache stats
         stats.update(self.get_imdb_cache_stats())

quasarr/providers/utils.py

@@ -62,7 +62,7 @@ def extract_kv_pairs(input_text, allowed_keys):
     """
     kv_pattern = re.compile(rf"^({'|'.join(map(re.escape, allowed_keys))})\s*=\s*(.*)$")
     kv_pairs = {}
-    debug = os.getenv('DEBUG')
+    debug = os.getenv("DEBUG")
 
     for line in input_text.splitlines():
         match = kv_pattern.match(line.strip())
@@ -73,7 +73,9 @@ def extract_kv_pairs(input_text, allowed_keys):
             pass
         else:
             if debug:
-                print(f"Skipping line because it does not contain any supported hostname: {line}")
+                print(
+                    f"Skipping line because it does not contain any supported hostname: {line}"
+                )
 
     return kv_pairs
 
@@ -81,10 +83,10 @@ def extract_kv_pairs(input_text, allowed_keys):
 def check_ip():
     s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
     try:
-        s.connect(('10.255.255.255', 0))
+        s.connect(("10.255.255.255", 0))
         ip = s.getsockname()[0]
     except:
-        ip = '127.0.0.1'
+        ip = "127.0.0.1"
     finally:
         s.close()
     return ip
@@ -98,14 +100,12 @@ def check_flaresolverr(shared_state, flaresolverr_url):
 
     # Try sending a simple test request
     headers = {"Content-Type": "application/json"}
-    data = {
-        "cmd": "request.get",
-        "url": "http://www.google.com/",
-        "maxTimeout": 10000
-    }
+    data = {"cmd": "request.get", "url": "http://www.google.com/", "maxTimeout": 10000}
 
     try:
-        response = requests.post(flaresolverr_url, headers=headers, json=data, timeout=10)
+        response = requests.post(
+            flaresolverr_url, headers=headers, json=data, timeout=10
+        )
         response.raise_for_status()
         json_data = response.json()
 
@@ -132,7 +132,8 @@ def validate_address(address, name):
     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}.")
+            f"Error: {name} '{address}' is invalid. It must contain 1 or 2 colons, but it has {colon_count}."
+        )
 
 
 def is_flaresolverr_available(shared_state):
@@ -147,7 +148,7 @@ def is_flaresolverr_available(shared_state):
         return False
 
     # Check if FlareSolverr URL is configured
-    flaresolverr_url = shared_state.values["config"]('FlareSolverr').get('url')
+    flaresolverr_url = shared_state.values["config"]("FlareSolverr").get("url")
     if not flaresolverr_url:
         return False
 
@@ -172,11 +173,11 @@ def is_site_usable(shared_state, shorthand):
     shorthand = shorthand.lower()
 
     # Check if hostname is set
-    hostname = shared_state.values["config"]('Hostnames').get(shorthand)
+    hostname = shared_state.values["config"]("Hostnames").get(shorthand)
     if not hostname:
         return False
 
-    login_required_sites = ['al', 'dd', 'dl', 'nx']
+    login_required_sites = ["al", "dd", "dl", "nx"]
     if shorthand not in login_required_sites:
         return True  # No login needed, hostname is enough
 
@@ -186,8 +187,8 @@ def is_site_usable(shared_state, shorthand):
 
     # Check for credentials
     config = shared_state.values["config"](shorthand.upper())
-    user = config.get('user')
-    password = config.get('password')
+    user = config.get("user")
+    password = config.get("password")
 
     return bool(user and password)
 
@@ -196,6 +197,7 @@ def is_site_usable(shared_state, shorthand):
 # LINK STATUS CHECKING
 # =============================================================================
 
+
 def generate_status_url(href, crypter_type):
     """
     Generate a status URL for crypters that support it.
@@ -203,14 +205,16 @@ def generate_status_url(href, crypter_type):
     """
     if crypter_type == "hide":
         # hide.cx links: https://hide.cx/folder/{UUID} or /container/{UUID} → https://hide.cx/state/{UUID}
-        match = re.search(r'hide\.cx/(?:folder/|container/)?([a-f0-9-]{36})', href, re.IGNORECASE)
+        match = re.search(
+            r"hide\.cx/(?:folder/|container/)?([a-f0-9-]{36})", href, re.IGNORECASE
+        )
         if match:
             uuid = match.group(1)
             return f"https://hide.cx/state/{uuid}"
 
     elif crypter_type == "tolink":
         # tolink links: https://tolink.to/f/{ID} → https://tolink.to/f/{ID}/s/status.png
-        match = re.search(r'tolink\.to/f/([a-zA-Z0-9]+)', href, re.IGNORECASE)
+        match = re.search(r"tolink\.to/f/([a-zA-Z0-9]+)", href, re.IGNORECASE)
         if match:
             link_id = match.group(1)
             return f"https://tolink.to/f/{link_id}/s/status.png"
@@ -221,13 +225,13 @@ def generate_status_url(href, crypter_type):
 def detect_crypter_type(url):
     """Detect crypter type from URL for status checking."""
     url_lower = url.lower()
-    if 'hide.' in url_lower:
+    if "hide." in url_lower:
         return "hide"
-    elif 'tolink.' in url_lower:
+    elif "tolink." in url_lower:
         return "tolink"
-    elif 'filecrypt.' in url_lower:
+    elif "filecrypt." in url_lower:
         return "filecrypt"
-    elif 'keeplinks.' in url_lower:
+    elif "keeplinks." in url_lower:
         return "keeplinks"
     return None
 
@@ -240,9 +244,9 @@ def image_has_green(image_data):
     try:
         img = Image.open(BytesIO(image_data))
         # Convert palette images with transparency to RGBA first to avoid warning
-        if img.mode == 'P' and 'transparency' in img.info:
-            img = img.convert('RGBA')
-        img = img.convert('RGB')
+        if img.mode == "P" and "transparency" in img.info:
+            img = img.convert("RGBA")
+        img = img.convert("RGB")
 
         pixels = list(img.getdata())
 
@@ -297,9 +301,11 @@ def check_links_online_status(links_with_status, shared_state=None):
 
     batch_size = 10
     for i in range(0, len(status_urls), batch_size):
-        batch = status_urls[i:i + batch_size]
+        batch = status_urls[i : i + batch_size]
         with ThreadPoolExecutor(max_workers=batch_size) as executor:
-            futures = [executor.submit(fetch_status_image, url, shared_state) for url in batch]
+            futures = [
+                executor.submit(fetch_status_image, url, shared_state) for url in batch
+            ]
             for future in as_completed(futures):
                 try:
                     status_url, image_data = future.result()

quasarr/providers/version.py

@@ -5,7 +5,7 @@
 import re
 import sys
 
-__version__ = "2.4.7"
+__version__ = "2.4.9"
 
 
 def get_version():
@@ -76,7 +76,7 @@ def newer_version_available():
 
 def create_version_file():
     version = get_version()
-    version_clean = re.sub(r'[^\d.]', '', version)
+    version_clean = re.sub(r"[^\d.]", "", version)
     if "a" in version:
         suffix = version.split("a")[1]
     else:
@@ -85,10 +85,24 @@ def create_version_file():
     version_info = [
         "VSVersionInfo(",
         "  ffi=FixedFileInfo(",
-        "    filevers=(" + str(int(version_split[0])) + ", " + str(int(version_split[1])) + ", " + str(
-            int(version_split[2])) + ", " + str(int(suffix)) + "),",
-        "    prodvers=(" + str(int(version_split[0])) + ", " + str(int(version_split[1])) + ", " + str(
-            int(version_split[2])) + ", " + str(int(suffix)) + "),",
+        "    filevers=("
+        + str(int(version_split[0]))
+        + ", "
+        + str(int(version_split[1]))
+        + ", "
+        + str(int(version_split[2]))
+        + ", "
+        + str(int(suffix))
+        + "),",
+        "    prodvers=("
+        + str(int(version_split[0]))
+        + ", "
+        + str(int(version_split[1]))
+        + ", "
+        + str(int(version_split[2]))
+        + ", "
+        + str(int(suffix))
+        + "),",
         "    mask=0x3f,",
         "    flags=0x0,",
         "    OS=0x4,",
@@ -103,24 +117,41 @@ def create_version_file():
         "        u'040704b0',",
         "        [StringStruct(u'CompanyName', u'RiX'),",
         "        StringStruct(u'FileDescription', u'Quasarr'),",
-        "        StringStruct(u'FileVersion', u'" + str(int(version_split[0])) + "." + str(
-            int(version_split[1])) + "." + str(int(version_split[2])) + "." + str(int(suffix)) + "'),",
+        "        StringStruct(u'FileVersion', u'"
+        + str(int(version_split[0]))
+        + "."
+        + str(int(version_split[1]))
+        + "."
+        + str(int(version_split[2]))
+        + "."
+        + str(int(suffix))
+        + "'),",
         "        StringStruct(u'InternalName', u'Quasarr'),",
         "        StringStruct(u'LegalCopyright', u'Copyright © RiX'),",
         "        StringStruct(u'OriginalFilename', u'Quasarr.exe'),",
         "        StringStruct(u'ProductName', u'Quasarr'),",
-        "        StringStruct(u'ProductVersion', u'" + str(int(version_split[0])) + "." + str(
-            int(version_split[1])) + "." + str(int(version_split[2])) + "." + str(int(suffix)) + "')])",
+        "        StringStruct(u'ProductVersion', u'"
+        + str(int(version_split[0]))
+        + "."
+        + str(int(version_split[1]))
+        + "."
+        + str(int(version_split[2]))
+        + "."
+        + str(int(suffix))
+        + "')])",
         "      ]),",
         "    VarFileInfo([VarStruct(u'Translation', [1031, 1200])])",
         "  ]",
-        ")"
+        ")",
     ]
-    print("\n".join(version_info), file=open('file_version_info.txt', 'w', encoding='utf-8'))
+    print(
+        "\n".join(version_info),
+        file=open("file_version_info.txt", "w", encoding="utf-8"),
+    )
 
 
-if __name__ == '__main__':
-    if len(sys.argv) > 1 and sys.argv[1] == '--create-version-file':
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "--create-version-file":
         create_version_file()
     else:
         print(get_version())

quasarr/providers/web_server.py

@@ -3,8 +3,8 @@
 # Project by https://github.com/rix1337
 
 import time
-from socketserver import ThreadingMixIn, TCPServer
-from wsgiref.simple_server import WSGIServer, WSGIRequestHandler, make_server
+from socketserver import TCPServer, ThreadingMixIn
+from wsgiref.simple_server import WSGIRequestHandler, WSGIServer, make_server
 
 temp_server_success = False
 
@@ -26,12 +26,17 @@ class NoLoggingWSGIRequestHandler(WSGIRequestHandler):
 
 
 class Server:
-    def __init__(self, wsgi_app, listen='127.0.0.1', port=8080):
+    def __init__(self, wsgi_app, listen="127.0.0.1", port=8080):
         self.wsgi_app = wsgi_app
         self.listen = listen
         self.port = port
-        self.server = make_server(self.listen, self.port, self.wsgi_app,
-                                  ThreadingWSGIServer, handler_class=NoLoggingWSGIRequestHandler)
+        self.server = make_server(
+            self.listen,
+            self.port,
+            self.wsgi_app,
+            ThreadingWSGIServer,
+            handler_class=NoLoggingWSGIRequestHandler,
+        )
 
     def serve_temporarily(self):
         global temp_server_success

quasarr/search/__init__.py

@@ -6,12 +6,12 @@ import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
 from quasarr.providers.imdb_metadata import get_imdb_metadata
-from quasarr.providers.log import info, debug
+from quasarr.providers.log import debug, info
 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.dd import dd_feed, dd_search
+from quasarr.search.sources.dj import dj_feed, dj_search
+from quasarr.search.sources.dl import dl_feed, dl_search
 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
@@ -20,17 +20,25 @@ 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.sj import sj_feed, sj_search
 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="", search_phrase="", mirror=None, season="", episode=""):
+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}'
+    if imdb_id and not imdb_id.startswith("tt"):
+        imdb_id = f"tt{imdb_id}"
 
     # Pre-populate IMDb metadata cache to avoid API hammering by search threads
     if imdb_id:
@@ -115,16 +123,18 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
     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}
+            {"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
+    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}
+            {"mirror": mirror, "season": season, "episode": episode},
         )
         for flag, func in phrase_map:
             if flag:
@@ -132,13 +142,11 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
 
     elif search_phrase:
         debug(
-            f"Search phrase '{search_phrase}' is not supported for {request_from}. Only LazyLibrarian can use search phrases.")
+            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}
-        )
+        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))
@@ -150,7 +158,9 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
     else:
         stype = "feed search"
 
-    info(f'Starting {len(functions)} search functions for {stype}... This may take some time.')
+    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]
@@ -162,6 +172,8 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
                 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")
+    info(
+        f"Providing {len(results)} releases to {request_from} for {stype}. Time taken: {elapsed_time:.2f} seconds"
+    )
 
     return results