quasarr 1.4.1__py3-none-any.whl → 1.20.4__py3-none-any.whl

quasarr/search/__init__.py

@@ -5,61 +5,137 @@
 import time
 from concurrent.futures import ThreadPoolExecutor, as_completed
 
-from quasarr.providers.log import info
-from quasarr.search.sources.dd import dd_search
-from quasarr.search.sources.dw import dw_feed, dw_search
+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.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
 
 
-def get_search_results(shared_state, request_from, search_string="", 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}'
+
+    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")
     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")
 
     start_time = time.time()
 
     functions = []
-    if search_string:
-        if season and episode:
-            search_string = f"{search_string} S{int(season):02}E{int(episode):02}"
-        elif season:
-            search_string = f"{search_string} S{int(season):02}"
-
-        if dd:
-            functions.append(lambda: dd_search(shared_state, start_time, search_string, mirror=mirror))
-        if dw:
-            functions.append(lambda: dw_search(shared_state, start_time, request_from, search_string, mirror=mirror))
-        if dt:
-            functions.append(lambda: dt_search(shared_state, start_time, request_from, search_string, mirror=mirror))
-        if fx:
-            functions.append(lambda: fx_search(shared_state, start_time, search_string, mirror=mirror))
-        if nx:
-            functions.append(lambda: nx_search(shared_state, start_time, request_from, search_string, mirror=mirror))
-        if sf:
-            functions.append(lambda: sf_search(shared_state, start_time, request_from, search_string, mirror=mirror))
+
+    # Radarr/Sonarr use imdb_id for searches
+    imdb_map = [
+        (al, al_search),
+        (by, by_search),
+        (dd, dd_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),
+    ]
+
+    # LazyLibrarian uses search_phrase for searches
+    phrase_map = [
+        (by, by_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),
+        (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),
+    ]
+
+    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:
-        if dd:
-            functions.append(lambda: dd_search(shared_state, start_time, mirror=mirror))
-        if dt:
-            functions.append(lambda: dt_feed(shared_state, start_time, request_from, mirror=mirror))
-        if dw:
-            functions.append(lambda: dw_feed(shared_state, start_time, request_from, mirror=mirror))
-        if fx:
-            functions.append(lambda: fx_feed(shared_state, start_time, mirror=mirror))
-        if nx:
-            functions.append(lambda: nx_feed(shared_state, start_time, request_from, mirror=mirror))
-        if sf:
-            functions.append(lambda: sf_feed(shared_state, start_time, request_from, mirror=mirror))
-
-    stype = f'search phrase "{search_string}"' if search_string else "feed search"
+        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:
+        stype = f'IMDb-ID "{imdb_id}"'
+    elif search_phrase:
+        stype = f'Search-Phrase "{search_phrase}"'
+    else:
+        stype = "feed search"
+
     info(f'Starting {len(functions)} search functions for {stype}... This may take some time.')
 
     with ThreadPoolExecutor() as executor:

quasarr/search/sources/al.py

@@ -0,0 +1,448 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+import time
+from base64 import urlsafe_b64encode
+from datetime import datetime, timedelta
+from html import unescape
+from urllib.parse import urljoin, quote_plus
+
+from bs4 import BeautifulSoup
+
+from quasarr.downloads.sources.al import (guess_title,
+                                          parse_info_from_feed_entry, parse_info_from_download_item)
+from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.log import info, debug
+from quasarr.providers.sessions.al import invalidate_session, fetch_via_requests_session
+
+hostname = "al"
+supported_mirrors = ["rapidgator", "ddownload"]
+
+
+def convert_to_rss_date(date_str: str) -> str:
+    parsed = datetime.strptime(date_str, "%d.%m.%Y - %H:%M")
+    return parsed.strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+
+import re
+from datetime import datetime, timedelta
+
+
+def convert_to_rss_date(date_str: str) -> str:
+    # First try to parse relative dates (German and English)
+    parsed_date = parse_relative_date(date_str)
+    if parsed_date:
+        return parsed_date.strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+    # Fall back to absolute date parsing
+    try:
+        parsed = datetime.strptime(date_str, "%d.%m.%Y - %H:%M")
+        return parsed.strftime("%a, %d %b %Y %H:%M:%S +0000")
+    except ValueError:
+        # If parsing fails, return the original string or handle as needed
+        raise ValueError(f"Could not parse date: {date_str}")
+
+
+def parse_relative_date(raw: str) -> datetime | None:
+    # German pattern: "vor X Einheit(en)"
+    german_match = re.match(r"vor\s+(\d+)\s+(\w+)", raw, re.IGNORECASE)
+    if german_match:
+        num = int(german_match.group(1))
+        unit = german_match.group(2).lower()
+
+        if unit.startswith("sekunde"):
+            delta = timedelta(seconds=num)
+        elif unit.startswith("minute"):
+            delta = timedelta(minutes=num)
+        elif unit.startswith("stunde"):
+            delta = timedelta(hours=num)
+        elif unit.startswith("tag"):
+            delta = timedelta(days=num)
+        elif unit.startswith("woche"):
+            delta = timedelta(weeks=num)
+        elif unit.startswith("monat"):
+            delta = timedelta(days=30 * num)
+        elif unit.startswith("jahr"):
+            delta = timedelta(days=365 * num)
+        else:
+            return None
+
+        return datetime.utcnow() - delta
+
+    # English pattern: "X Unit(s) ago"
+    english_match = re.match(r"(\d+)\s+(\w+)\s+ago", raw, re.IGNORECASE)
+    if english_match:
+        num = int(english_match.group(1))
+        unit = english_match.group(2).lower()
+
+        # Remove plural 's' if present
+        if unit.endswith('s'):
+            unit = unit[:-1]
+
+        if unit.startswith("second"):
+            delta = timedelta(seconds=num)
+        elif unit.startswith("minute"):
+            delta = timedelta(minutes=num)
+        elif unit.startswith("hour"):
+            delta = timedelta(hours=num)
+        elif unit.startswith("day"):
+            delta = timedelta(days=num)
+        elif unit.startswith("week"):
+            delta = timedelta(weeks=num)
+        elif unit.startswith("month"):
+            delta = timedelta(days=30 * num)
+        elif unit.startswith("year"):
+            delta = timedelta(days=365 * num)
+        else:
+            return None
+
+        return datetime.utcnow() - delta
+
+    return None
+
+
+def extract_size(text):
+    match = re.match(r"(\d+(\.\d+)?) ([A-Za-z]+)", text)
+    if match:
+        size = match.group(1)
+        unit = match.group(3)
+        return {"size": size, "sizeunit": unit}
+    else:
+        raise ValueError(f"Invalid size format: {text}")
+
+
+def get_release_id(tag):
+    match = re.search(r"release\s+(\d+):", tag.get_text(strip=True), re.IGNORECASE)
+    if match:
+        return int(match.group(1))
+    return 0
+
+
+def al_feed(shared_state, start_time, request_from, mirror=None):
+    releases = []
+    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)!')
+        return releases
+
+    if "Radarr" in request_from:
+        wanted_type = "movie"
+    else:
+        wanted_type = "series"
+
+    if mirror and mirror not in supported_mirrors:
+        debug(f'Mirror "{mirror}" not supported by {hostname}.')
+        return releases
+
+    try:
+        r = fetch_via_requests_session(shared_state, method="GET", target_url=f'https://www.{host}/', timeout=10)
+        r.raise_for_status()
+    except Exception as e:
+        info(f"{hostname}: could not fetch feed: {e}")
+        invalidate_session(shared_state)
+        return releases
+
+    soup = BeautifulSoup(r.content, 'html.parser')
+
+    # 1) New “Releases”
+    release_rows = soup.select("#releases_updates_list table tbody tr")
+    # 2) New “Episodes”
+    episode_rows = soup.select("#episodes_updates_list table tbody tr")
+    # 3) “Upgrades” Releases
+    upgrade_rows = soup.select("#releases_modified_updates_list table tbody tr")
+
+    for tr in release_rows + episode_rows + upgrade_rows:
+        try:
+            p_tag = tr.find("p")
+            if not p_tag:
+                continue
+            a_tag = p_tag.find("a", href=True)
+            if not a_tag:
+                continue
+
+            url = a_tag["href"].strip()
+            # Prefer data-original-title, fall back to title, then to inner text
+            if a_tag.get("data-original-title"):
+                raw_base_title = a_tag["data-original-title"]
+            elif a_tag.get("title"):
+                raw_base_title = a_tag["title"]
+            else:
+                raw_base_title = a_tag.get_text(strip=True)
+
+            release_type = None
+            label_div = tr.find("div", class_="label-group")
+            if label_div:
+                for lbl in label_div.find_all("a", href=True):
+                    href = lbl["href"].rstrip("/").lower()
+                    if href.endswith("/anime-series"):
+                        release_type = "series"
+                        break
+                    elif href.endswith("/anime-movies"):
+                        release_type = "movie"
+                        break
+
+            if release_type is None or release_type != wanted_type:
+                continue
+
+            date_converted = ""
+            small_tag = tr.find("small", class_="text-muted")
+            if small_tag:
+                raw_date_str = small_tag.get_text(strip=True)
+                if raw_date_str.startswith("vor"):
+                    dt = parse_relative_date(raw_date_str)
+                    if dt:
+                        date_converted = dt.strftime("%a, %d %b %Y %H:%M:%S +0000")
+                else:
+                    try:
+                        date_converted = convert_to_rss_date(raw_date_str)
+                    except Exception as e:
+                        debug(f"{hostname}: could not parse date '{raw_date_str}': {e}")
+
+            # Each of these signifies an individual release block
+            mt_blocks = tr.find_all("div", class_="mt10")
+            for block in mt_blocks:
+                release_id = get_release_id(block)
+                release_info = parse_info_from_feed_entry(block, raw_base_title, release_type)
+                final_title = guess_title(shared_state, raw_base_title, release_info)
+
+                # Build payload using final_title
+                mb = 0  # size not available in feed
+                raw = f"{final_title}|{url}|{mirror}|{mb}|{release_id}|".encode("utf-8")
+                payload = urlsafe_b64encode(raw).decode("utf-8")
+                link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+                # Append only unique releases
+                if final_title not in [r["details"]["title"] for r in releases]:
+                    releases.append({
+                        "details": {
+                            "title": final_title,
+                            "hostname": hostname,
+                            "imdb_id": None,
+                            "link": link,
+                            "mirror": mirror,
+                            "size": mb * 1024 * 1024,
+                            "date": date_converted,
+                            "source": url
+                        },
+                        "type": "protected"
+                    })
+
+        except Exception as e:
+            info(f"{hostname}: error parsing feed item: {e}")
+
+    elapsed = time.time() - start_time
+    debug(f"Time taken: {elapsed:.2f}s ({hostname})")
+    return releases
+
+
+def extract_season(title: str) -> int | None:
+    match = re.search(r'(?i)(?:^|[^a-zA-Z0-9])S(\d{1,4})(?!\d)', title)
+    if match:
+        return int(match.group(1))
+    return None
+
+
+def al_search(shared_state, start_time, request_from, search_string,
+              mirror=None, season=None, episode=None):
+    releases = []
+    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)!')
+        return releases
+
+    if "Radarr" in request_from:
+        valid_type = "movie"
+    else:
+        valid_type = "series"
+
+    if mirror and mirror not in supported_mirrors:
+        debug(f'Mirror "{mirror}" not supported by {hostname}.')
+        return releases
+
+    imdb_id = shared_state.is_imdb_id(search_string)
+    if imdb_id:
+        title = get_localized_title(shared_state, imdb_id, 'de')
+        if not title:
+            info(f"{hostname}: no title for IMDb {imdb_id}")
+            return releases
+        search_string = title
+
+    search_string = unescape(search_string)
+
+    encoded_search_string = quote_plus(search_string)
+
+    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)
+        r.raise_for_status()
+    except Exception as e:
+        info(f"{hostname}: search load error: {e}")
+        invalidate_session(shared_state)
+        return releases
+
+    if r.history:
+        # If just one valid search result exists, AL skips the search result page
+        last_redirect = r.history[-1]
+        redirect_location = last_redirect.headers['Location']
+        absolute_redirect_url = urljoin(last_redirect.url, redirect_location)  # in case of relative URL
+        debug(f"{search_string} redirected to {absolute_redirect_url} instead of search results page")
+
+        try:
+            soup = BeautifulSoup(r.text, "html.parser")
+            page_title = soup.title.string
+        except:
+            page_title = ""
+
+        results = [{"url": absolute_redirect_url, "title": page_title}]
+    else:
+        soup = BeautifulSoup(r.text, 'html.parser')
+        results = []
+
+        for panel in soup.select('div.panel.panel-default'):
+            body = panel.find('div', class_='panel-body')
+            if not body:
+                continue
+
+            title_tag = body.select_one('h4.title-list a[href]')
+            if not title_tag:
+                continue
+            url = title_tag['href'].strip()
+            name = title_tag.get_text(strip=True)
+
+            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}'")
+                continue
+            debug(f"Matched search string '{search_string}' with result '{name}'")
+
+            type_label = None
+            for lbl in body.select('div.label-group a[href]'):
+                href = lbl['href']
+                if '/anime-series' in href:
+                    type_label = 'series'
+                    break
+                if '/anime-movies' in href:
+                    type_label = 'movie'
+                    break
+
+            if not type_label or type_label != valid_type:
+                continue
+
+            results.append({"url": url, "title": name})
+
+    for result in results:
+        try:
+            url = result["url"]
+            title = result.get("title") or ""
+
+            context = "recents_al"
+            threshold = 60
+            recently_searched = shared_state.get_recently_searched(shared_state, context, threshold)
+            entry = recently_searched.get(url, {})
+            ts = entry.get("timestamp")
+            use_cache = ts and ts > datetime.now() - timedelta(seconds=threshold)
+
+            if use_cache and entry.get("html"):
+                debug(f"Using cached content for '{url}'")
+                data_html = entry["html"]
+            else:
+                entry = {"timestamp": datetime.now()}
+                data_html = fetch_via_requests_session(shared_state, method="GET", target_url=url, timeout=10).text
+
+            entry["html"] = data_html
+            recently_searched[url] = entry
+            shared_state.update(context, recently_searched)
+
+            content = BeautifulSoup(data_html, "html.parser")
+
+            # Find each download‐table and process it
+            release_id = 0
+            download_tabs = content.select("div[id^=download_]")
+            for tab in download_tabs:
+                release_id += 1
+
+                release_info = parse_info_from_download_item(tab, content, page_title=title,
+                                                             release_type=valid_type, requested_episode=episode)
+
+                # Parse date
+                date_td = tab.select_one("tr:has(th>i.fa-calendar-alt) td.modified")
+                if date_td:
+                    raw_date = date_td.get_text(strip=True)
+                    try:
+                        dt = datetime.strptime(raw_date, "%d.%m.%Y %H:%M")
+                        date_str = dt.strftime("%a, %d %b %Y %H:%M:%S +0000")
+                    except Exception:
+                        date_str = ""
+                else:
+                    date_str = (datetime.utcnow() - timedelta(hours=1)) \
+                        .strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+                # Parse filesize from the <tr> with <i class="fa-hdd">
+                size_td = tab.select_one("tr:has(th>i.fa-hdd) td")
+                mb = 0
+                if size_td:
+                    size_text = size_td.get_text(strip=True)
+                    candidates = re.findall(r'(\d+(\.\d+)?\s*[A-Za-z]+)', size_text)
+                    if candidates:
+                        size_string = candidates[-1][0]
+                        try:
+                            size_item = extract_size(size_string)
+                            mb = shared_state.convert_to_mb(size_item)
+                        except Exception as e:
+                            debug(f"Error extracting size for {title}: {e}")
+
+                if episode:
+                    try:
+                        total_episodes = release_info.episode_max
+                        if total_episodes:
+                            if mb > 0:
+                                mb = int(mb / total_episodes)
+                            # Overwrite values so guessing the title only applies the requested episode
+                            release_info.episode_min = int(episode)
+                            release_info.episode_max = int(episode)
+                        else:  # if no total episode count - assume the requested episode is missing in the release
+                            continue
+                    except ValueError:
+                        pass
+
+                # If no valid title was grabbed from Release Notes, guess the title
+                if release_info.release_title:
+                    release_title = release_info.release_title
+                else:
+                    release_title = guess_title(shared_state, title, release_info)
+
+                if season and release_info.season != int(season):
+                    debug(f"Excluding {release_title} due to season mismatch: {release_info.season} != {season}")
+                    continue
+
+                payload = urlsafe_b64encode(
+                    f"{release_title}|{url}|{mirror}|{mb}|{release_id}|{imdb_id or ''}"
+                    .encode("utf-8")
+                ).decode("utf-8")
+                link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+                releases.append({
+                    "details": {
+                        "title": release_title,
+                        "hostname": hostname,
+                        "imdb_id": imdb_id,
+                        "link": link,
+                        "mirror": mirror,
+                        "size": mb * 1024 * 1024,
+                        "date": date_str,
+                        "source": f"{url}#download_{release_id}"
+                    },
+                    "type": "protected"
+                })
+
+        except Exception as e:
+            info(f"{hostname}: error parsing search item: {e}")
+
+    elapsed = time.time() - start_time
+    debug(f"Time taken: {elapsed:.2f}s ({hostname})")
+    return releases