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

quasarr/search/__init__.py

@@ -16,6 +16,7 @@ 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.hs import hs_feed, hs_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
@@ -35,8 +36,6 @@ def get_search_results(
     season="",
     episode="",
 ):
-    results = []
-
     if imdb_id and not imdb_id.startswith("tt"):
         imdb_id = f"tt{imdb_id}"
 
@@ -55,6 +54,7 @@ def get_search_results(
     dw = shared_state.values["config"]("Hostnames").get("dw")
     fx = shared_state.values["config"]("Hostnames").get("fx")
     he = shared_state.values["config"]("Hostnames").get("he")
+    hs = shared_state.values["config"]("Hostnames").get("hs")
     mb = shared_state.values["config"]("Hostnames").get("mb")
     nk = shared_state.values["config"]("Hostnames").get("nk")
     nx = shared_state.values["config"]("Hostnames").get("nx")
@@ -66,7 +66,7 @@ def get_search_results(
 
     start_time = time.time()
 
-    functions = []
+    search_executor = SearchExecutor()
 
     # Radarr/Sonarr use imdb_id for searches
     imdb_map = [
@@ -79,6 +79,7 @@ def get_search_results(
         (dw, dw_search),
         (fx, fx_search),
         (he, he_search),
+        (hs, hs_search),
         (mb, mb_search),
         (nk, nk_search),
         (nx, nx_search),
@@ -110,6 +111,7 @@ def get_search_results(
         (dw, dw_feed),
         (fx, fx_feed),
         (he, he_feed),
+        (hs, hs_feed),
         (mb, mb_feed),
         (nk, nk_feed),
         (nx, nx_feed),
@@ -127,7 +129,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 +140,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 +151,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 +161,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()

quasarr/search/sources/al.py

@@ -15,7 +15,7 @@ from quasarr.downloads.sources.al import (
     parse_info_from_feed_entry,
 )
 from quasarr.providers.hostname_issues import clear_hostname_issue, mark_hostname_issue
-from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.imdb_metadata import get_localized_title, get_year
 from quasarr.providers.log import debug, info
 from quasarr.providers.sessions.al import fetch_via_requests_session, invalidate_session
 
@@ -122,9 +122,7 @@ def al_feed(shared_state, start_time, request_from, mirror=None):
     host = shared_state.values["config"]("Hostnames").get(hostname)
 
     if not "arr" in request_from.lower():
-        debug(
-            f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!'
-        )
+        debug(f"{hostname}: Skipping {request_from} search (unsupported media type)!")
         return releases
 
     if "Radarr" in request_from:
@@ -274,9 +272,7 @@ def al_search(
     host = shared_state.values["config"]("Hostnames").get(hostname)
 
     if not "arr" in request_from.lower():
-        debug(
-            f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!'
-        )
+        debug(f"{hostname}: Skipping {request_from} search (unsupported media type)!")
         return releases
 
     if "Radarr" in request_from:
@@ -285,7 +281,7 @@ def al_search(
         valid_type = "series"
 
     if mirror and mirror not in supported_mirrors:
-        debug(f'Mirror "{mirror}" not supported by {hostname}.')
+        debug(f'{hostname}: Mirror "{mirror}" not supported.')
         return releases
 
     imdb_id = shared_state.is_imdb_id(search_string)
@@ -303,7 +299,11 @@ def al_search(
     try:
         url = f"https://www.{host}/search?q={encoded_search_string}"
         r = fetch_via_requests_session(
-            shared_state, method="GET", target_url=url, timeout=10
+            shared_state,
+            method="GET",
+            target_url=url,
+            timeout=10,
+            year=get_year(imdb_id) if imdb_id else None,
         )
         r.raise_for_status()
     except Exception as e:
@@ -322,7 +322,7 @@ def al_search(
             last_redirect.url, redirect_location
         )  # in case of relative URL
         debug(
-            f"{search_string} redirected to {absolute_redirect_url} instead of search results page"
+            f"{hostname}: {search_string} redirected to {absolute_redirect_url} instead of search results page"
         )
 
         try:
@@ -350,9 +350,13 @@ def al_search(
             sanitized_search_string = shared_state.sanitize_string(search_string)
             sanitized_title = shared_state.sanitize_string(name)
             if not sanitized_search_string in sanitized_title:
-                debug(f"Search string '{search_string}' doesn't match '{name}'")
+                debug(
+                    f"{hostname}: Search string '{search_string}' doesn't match '{name}'"
+                )
                 continue
-            debug(f"Matched search string '{search_string}' with result '{name}'")
+            debug(
+                f"{hostname}: Matched search string '{search_string}' with result '{name}'"
+            )
 
             type_label = None
             for lbl in body.select("div.label-group a[href]"):
@@ -384,7 +388,7 @@ def al_search(
             use_cache = ts and ts > datetime.now() - timedelta(seconds=threshold)
 
             if use_cache and entry.get("html"):
-                debug(f"Using cached content for '{url}'")
+                debug(f"{hostname}: Using cached content for '{url}'")
                 data_html = entry["html"]
             else:
                 entry = {"timestamp": datetime.now()}

quasarr/search/sources/by.py

@@ -13,7 +13,7 @@ import requests
 from bs4 import BeautifulSoup
 
 from quasarr.providers.hostname_issues import clear_hostname_issue, mark_hostname_issue
-from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.imdb_metadata import get_localized_title, get_year
 from quasarr.providers.log import debug, info
 
 hostname = "by"
@@ -232,6 +232,9 @@ def by_search(
             info(f"Could not extract title from IMDb-ID {imdb_id}")
             return []
         search_string = html.unescape(title)
+        if not season:
+            if year := get_year(imdb_id):
+                search_string += f" {year}"
 
     base_url = f"https://{by}"
     q = quote_plus(search_string)

quasarr/search/sources/dd.py

@@ -8,7 +8,7 @@ from base64 import urlsafe_b64encode
 from datetime import datetime, timezone
 
 from quasarr.providers.hostname_issues import clear_hostname_issue, mark_hostname_issue
-from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.imdb_metadata import get_localized_title, get_year
 from quasarr.providers.log import debug, info
 from quasarr.providers.sessions.dd import (
     create_and_persist_session,
@@ -77,6 +77,13 @@ def dd_search(
             info(f"Could not extract title from IMDb-ID {imdb_id}")
             return releases
         search_string = html.unescape(search_string)
+        if season:
+            search_string += f" S{int(season):02d}"
+            if episode:
+                search_string += f"E{int(episode):02d}"
+        else:
+            if year := get_year(imdb_id):
+                search_string += f" {year}"
 
     if not search_string:
         search_type = "feed"
@@ -116,7 +123,7 @@ def dd_search(
             try:
                 if release.get("fake"):
                     debug(
-                        f"Release {release.get('release')} marked as fake. Invalidating {hostname.upper()} session..."
+                        f"{hostname}: Release {release.get('release')} marked as fake. Invalidating {hostname.upper()} session..."
                     )
                     create_and_persist_session(shared_state)
                     return []
@@ -128,14 +135,19 @@ def dd_search(
                     ):
                         continue
 
-                    imdb_id = release.get("imdbid", None)
+                    release_imdb = release.get("imdbid", None)
+                    if release_imdb and imdb_id and imdb_id != release_imdb:
+                        debug(
+                            f"{hostname}: Release {title} IMDb-ID mismatch ({imdb_id} != {release.get('imdbid', None)})"
+                        )
+                        continue
 
                     source = f"https://{dd}/"
                     size_item = extract_size(release.get("size"))
                     mb = shared_state.convert_to_mb(size_item) * 1024 * 1024
                     published = convert_to_rss_date(release.get("when"))
                     payload = urlsafe_b64encode(
-                        f"{title}|{source}|{mirror}|{mb}|{password}|{imdb_id}|{hostname}".encode(
+                        f"{title}|{source}|{mirror}|{mb}|{password}|{release_imdb}|{hostname}".encode(
                             "utf-8"
                         )
                     ).decode("utf-8")

quasarr/search/sources/dl.py

@@ -11,7 +11,7 @@ from html import unescape
 from bs4 import BeautifulSoup
 
 from quasarr.providers.hostname_issues import clear_hostname_issue, mark_hostname_issue
-from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.imdb_metadata import get_localized_title, get_year
 from quasarr.providers.log import debug, info
 from quasarr.providers.sessions.dl import (
     fetch_via_requests_session,
@@ -354,6 +354,9 @@ def dl_search(
             info(f"{hostname}: no title for IMDb {imdb_id}")
             return releases
         search_string = title
+        if not season:
+            if year := get_year(imdb_id):
+                search_string += f" {year}"
 
     search_string = unescape(search_string)
     max_search_duration = 7
@@ -371,6 +374,7 @@ def dl_search(
         search_id = None
         page_num = 0
         search_start_time = time.time()
+        release_titles_per_page = set()
 
         # Sequential search through pages until timeout or no results
         while (time.time() - search_start_time) < max_search_duration:
@@ -389,6 +393,14 @@ def dl_search(
                 episode,
             )
 
+            page_release_titles = tuple(pr["details"]["title"] for pr in page_releases)
+            if page_release_titles in release_titles_per_page:
+                debug(
+                    f"{hostname}: [Page {page_num}] duplicate page detected, stopping"
+                )
+                break
+            release_titles_per_page.add(page_release_titles)
+
             # Update search_id from first page
             if page_num == 1:
                 search_id = extracted_search_id