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

quasarr/search/sources/nk.py

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+import time
+from base64 import urlsafe_b64encode
+from datetime import datetime
+from html import unescape
+from urllib.parse import urljoin
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.log import info, debug
+
+hostname = "nk"
+supported_mirrors = ["rapidgator", "ddownload"]
+
+
+def convert_to_rss_date(date_str: str) -> str:
+    date_str = date_str.strip()
+    for fmt in ("%d. %B %Y / %H:%M", "%d.%m.%Y / %H:%M", "%d.%m.%Y - %H:%M", "%Y-%m-%d %H:%M"):
+        try:
+            dt = datetime.strptime(date_str, fmt)
+            return dt.strftime("%a, %d %b %Y %H:%M:%S +0000")
+        except Exception:
+            continue
+    return ""
+
+
+def extract_size(text: str) -> dict:
+    match = re.search(r"(\d+(?:[\.,]\d+)?)\s*([A-Za-z]+)", text)
+    if match:
+        size = match.group(1).replace(',', '.')
+        unit = match.group(2)
+        return {"size": size, "sizeunit": unit}
+    return {"size": "0", "sizeunit": "MB"}
+
+
+def get_release_field(res, label):
+    for li in res.select('ul.release-infos li'):
+        sp = li.find('span')
+        if not sp:
+            return ''
+        if sp.get_text(strip=True).lower() == label.lower():
+            txt = li.get_text(' ', strip=True)
+            return txt[len(sp.get_text(strip=True)):].strip()
+    return ''
+
+
+def nk_feed(*args, **kwargs):
+    return nk_search(*args, **kwargs)
+
+
+def nk_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 mirror and mirror not in supported_mirrors:
+        debug(f'Mirror "{mirror}" not supported by {hostname}.')
+        return releases
+
+    source_search = ""
+    if search_string != "":
+        imdb_id = shared_state.is_imdb_id(search_string)
+        if imdb_id:
+            local_title = get_localized_title(shared_state, imdb_id, 'de')
+            if not local_title:
+                info(f"{hostname}: no title for IMDb {imdb_id}")
+                return releases
+            source_search = local_title
+        else:
+            return releases
+        source_search = unescape(source_search)
+    else:
+        imdb_id = None
+
+    url = f'https://{host}/search'
+    headers = {"User-Agent": shared_state.values["user_agent"]}
+    data = {"search": source_search}
+
+    try:
+        r = requests.post(url, headers=headers, data=data, timeout=20)
+        soup = BeautifulSoup(r.content, 'html.parser')
+        results = soup.find_all('div', class_='article-right')
+    except Exception as e:
+        info(f"{hostname}: search load error: {e}")
+        return releases
+
+    if not results:
+        return releases
+
+    for result in results:
+        try:
+            imdb_a = result.select_one('a.imdb')
+            if imdb_a and imdb_a.get('href'):
+                try:
+                    release_imdb_id = re.search(r'tt\d+', imdb_a['href']).group()
+                    if imdb_id:
+                        if release_imdb_id != imdb_id:
+                            debug(f"{hostname}: IMDb ID mismatch: expected {imdb_id}, found {release_imdb_id}")
+                            continue
+                except Exception:
+                    debug(f"{hostname}: could not extract IMDb ID")
+                    continue
+            else:
+                debug(f"{hostname}: could not extract IMDb ID")
+                continue
+
+            a = result.find('a', class_='release-details', href=True)
+            if not a:
+                continue
+
+            sub_title = result.find('span', class_='subtitle')
+            if sub_title:
+                title = sub_title.get_text(strip=True)
+            else:
+                continue
+
+            if not shared_state.is_valid_release(title, request_from, search_string, season, episode):
+                continue
+
+            source = urljoin(f'https://{host}', a['href'])
+
+            mb = 0
+            size_text = get_release_field(result, 'Größe')
+            if size_text:
+                size_item = extract_size(size_text)
+                mb = shared_state.convert_to_mb(size_item)
+
+            if season != "" and episode == "":
+                mb = 0  # Size unknown for season packs
+
+            size = mb * 1024 * 1024
+
+            password = ''
+            mirrors_p = result.find('p', class_='mirrors')
+            if mirrors_p:
+                strong = mirrors_p.find('strong')
+                if strong and strong.get_text(strip=True).lower().startswith('passwort'):
+                    nxt = strong.next_sibling
+                    if nxt:
+                        val = str(nxt).strip()
+                        if val:
+                            password = val.split()[0]
+
+            date_text = ''
+            p_meta = result.find('p', class_='meta')
+            if p_meta:
+                spans = p_meta.find_all('span')
+                if len(spans) >= 2:
+                    date_part = spans[0].get_text(strip=True)
+                    time_part = spans[1].get_text(strip=True).replace('Uhr', '').strip()
+                    date_text = f"{date_part} / {time_part}"
+
+            published = convert_to_rss_date(date_text) if date_text else ""
+
+            payload = urlsafe_b64encode(
+                f"{title}|{source}|{mirror}|{mb}|{password}|{release_imdb_id}".encode("utf-8")).decode()
+            link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+            releases.append({
+                "details": {
+                    "title": title,
+                    "hostname": hostname,
+                    "imdb_id": release_imdb_id,
+                    "link": link,
+                    "mirror": mirror,
+                    "size": size,
+                    "date": published,
+                    "source": source
+                },
+                "type": "protected"
+            })
+        except Exception as e:
+            info(e)
+            debug(f"{hostname}: error parsing search result: {e}")
+            continue
+
+    elapsed = time.time() - start_time
+    debug(f"Time taken: {elapsed:.2f}s ({hostname})")
+    return releases

quasarr/search/sources/nx.py

@@ -20,7 +20,9 @@ def nx_feed(shared_state, start_time, request_from, mirror=None):
     nx = shared_state.values["config"]("Hostnames").get(hostname.lower())
     password = nx
 
-    if "Radarr" in request_from:
+    if "lazylibrarian" in request_from.lower():
+        category = "ebook"
+    elif "radarr" in request_from.lower():
         category = "movie"
     else:
         category = "episode"
@@ -49,6 +51,10 @@ def nx_feed(shared_state, start_time, request_from, mirror=None):
 
             if title:
                 try:
+                    if 'lazylibrarian' in request_from.lower():
+                        # lazylibrarian can only detect specific date formats / issue numbering for magazines
+                        title = shared_state.normalize_magazine_title(title)
+
                     source = f"https://{nx}/release/{item['slug']}"
                     imdb_id = item.get('_media', {}).get('imdbid', None)
                     mb = shared_state.convert_to_mb(item)
@@ -87,17 +93,19 @@ def nx_feed(shared_state, start_time, request_from, mirror=None):
             info(f"Error parsing {hostname.upper()} feed: {e}")
 
     elapsed_time = time.time() - start_time
-    debug(f"Time taken: {elapsed_time:.2f} seconds ({hostname.lower()})")
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
 
     return releases
 
 
-def nx_search(shared_state, start_time, request_from, search_string, mirror=None):
+def nx_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
     releases = []
     nx = shared_state.values["config"]("Hostnames").get(hostname.lower())
     password = nx
 
-    if "Radarr" in request_from:
+    if "lazylibrarian" in request_from.lower():
+        valid_type = "ebook"
+    elif "radarr" in request_from.lower():
         valid_type = "movie"
     else:
         valid_type = "episode"
@@ -133,9 +141,17 @@ def nx_search(shared_state, start_time, request_from, search_string, mirror=None
             if item['type'] == valid_type:
                 title = item['name']
                 if title:
-                    if not shared_state.search_string_in_sanitized_title(search_string, title):
+                    if not shared_state.is_valid_release(title,
+                                                         request_from,
+                                                         search_string,
+                                                         season,
+                                                         episode):
                         continue
 
+                    if 'lazylibrarian' in request_from.lower():
+                        # lazylibrarian can only detect specific date formats / issue numbering for magazines
+                        title = shared_state.normalize_magazine_title(title)
+
                     try:
                         source = f"https://{nx}/release/{item['slug']}"
                         if not imdb_id:
@@ -176,6 +192,6 @@ def nx_search(shared_state, start_time, request_from, search_string, mirror=None
             info(f"Error parsing {hostname.upper()} search: {e}")
 
     elapsed_time = time.time() - start_time
-    debug(f"Time taken: {elapsed_time:.2f} seconds ({hostname.lower()})")
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
 
     return releases

quasarr/search/sources/sf.py

@@ -18,6 +18,11 @@ supported_mirrors = ["1fichier", "ddownload", "katfile", "rapidgator", "turbobit
 
 from bs4 import BeautifulSoup
 
+check = lambda s: s.replace(
+    ''.join(chr((ord(c) - 97 - 7) % 26 + 97) for c in "ylhr"),
+    ''.join(chr((ord(c) - 97 - 7) % 26 + 97) for c in "hu")
+)
+
 
 def parse_mirrors(base_url, entry):
     """
@@ -29,7 +34,6 @@ def parse_mirrors(base_url, entry):
     """
 
     mirrors = {}
-
     try:
         host_map = {
             '1F': '1fichier',
@@ -94,10 +98,10 @@ def parse_mirrors(base_url, entry):
 def sf_feed(shared_state, start_time, request_from, mirror=None):
     releases = []
     sf = shared_state.values["config"]("Hostnames").get(hostname.lower())
-    password = sf
+    password = check(sf)
 
-    if "Radarr" in request_from:
-        debug(f'Skipping Radarr search on "{hostname.upper()}" (unsupported media type at hostname)!')
+    if not "sonarr" in request_from.lower():
+        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
         return releases
 
     if mirror and mirror not in supported_mirrors:
@@ -172,23 +176,11 @@ def sf_feed(shared_state, start_time, request_from, mirror=None):
                 info(f"Error parsing {hostname.upper()} feed: {e}")
 
     elapsed_time = time.time() - start_time
-    debug(f"Time taken: {elapsed_time:.2f} seconds ({hostname.lower()})")
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
 
     return releases
 
 
-def extract_season_episode(search_string):
-    try:
-        match = re.search(r'(.*?)(S\d{1,3})(?:E(\d{1,3}))?', search_string, re.IGNORECASE)
-        if match:
-            season = int(match.group(2)[1:])
-            episode = int(match.group(3)) if match.group(3) else None
-            return season, episode
-    except Exception as e:
-        debug(f"Error extracting season / episode from {search_string}: {e}")
-    return None, None
-
-
 def extract_size(text):
     match = re.match(r"(\d+(\.\d+)?) ([A-Za-z]+)", text)
     if match:
@@ -199,184 +191,184 @@ def extract_size(text):
         raise ValueError(f"Invalid size format: {text}")
 
 
-def sf_search(shared_state, start_time, request_from, search_string, mirror=None):
+def sf_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
     releases = []
     sf = shared_state.values["config"]("Hostnames").get(hostname.lower())
-    password = sf
+    password = check(sf)
 
-    season, episode = extract_season_episode(search_string)
+    imdb_id_in_search = shared_state.is_imdb_id(search_string)
+    if imdb_id_in_search:
+        search_string = get_localized_title(shared_state, imdb_id_in_search, 'de')
+        if not search_string:
+            info(f"Could not extract title from IMDb-ID {imdb_id_in_search}")
+            return releases
+        search_string = html.unescape(search_string)
 
-    if "Radarr" in request_from:
-        debug(f'Skipping Radarr search on "{hostname.upper()}" (unsupported media type at hostname)!')
+    if not "sonarr" in request_from.lower():
+        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
         return releases
 
     if mirror and mirror not in supported_mirrors:
-        debug(f'Mirror "{mirror}" not supported by "{hostname.upper()}". Supported mirrors: {supported_mirrors}.'
-              ' Skipping search!')
+        debug(f'Mirror "{mirror}" not supported by "{hostname.upper()}". Supported: {supported_mirrors}.')
         return releases
 
-    if re.match(r'^tt\d{7,8}$', search_string):
-        imdb_id = search_string
-        search_string = get_localized_title(shared_state, imdb_id, 'de')
-        if not search_string:
-            info(f"Could not extract title from IMDb-ID {imdb_id}")
-            return releases
-        search_string = html.unescape(search_string)
-
     one_hour_ago = (datetime.now() - timedelta(hours=1)).strftime('%Y-%m-%d %H:%M:%S')
 
+    # search API
     url = f'https://{sf}/api/v2/search?q={search_string}&ql=DE'
-    headers = {
-        'User-Agent': shared_state.values["user_agent"],
-    }
+    headers = {'User-Agent': shared_state.values["user_agent"]}
 
     try:
-        response = requests.get(url, headers, timeout=10)
+        response = requests.get(url, headers=headers, timeout=10)
         feed = response.json()
     except Exception as e:
         info(f"Error loading {hostname.upper()} search: {e}")
         return releases
 
-    results = feed['result']
+    results = feed.get('result', [])
     for result in results:
         sanitized_search_string = shared_state.sanitize_string(search_string)
-        sanitized_title = shared_state.sanitize_string(result["title"])
+        sanitized_title = shared_state.sanitize_string(result.get("title", ""))
+        if not re.search(rf'\b{re.escape(sanitized_search_string)}\b', sanitized_title):
+            debug(f"Search string '{search_string}' doesn't match '{result.get('title')}'")
+            continue
+        debug(f"Matched search string '{search_string}' with result '{result.get('title')}'")
+
+        series_id = result.get("url_id")
+        context = "recents_sf"
+        threshold = 60
+        recently_searched = shared_state.get_recently_searched(shared_state, context, threshold)
+        entry = recently_searched.get(series_id, {})
+        ts = entry.get("timestamp")
+        use_cache = ts and ts > datetime.now() - timedelta(seconds=threshold)
+
+        if use_cache and entry.get("content"):
+            debug(f"Using cached content for '/{series_id}'")
+            data_html = entry["content"]
+            imdb_cached = entry.get("imdb_id")
+            if imdb_cached:
+                imdb_id = imdb_cached
+            content = BeautifulSoup(data_html, "html.parser")
+        else:
+            # fresh fetch: record timestamp
+            entry = {"timestamp": datetime.now()}
 
-        # Use word boundaries to ensure full word/phrase match
-        if re.search(rf'\b{re.escape(sanitized_search_string)}\b', sanitized_title):
-            debug(f"Matched search string '{search_string}' with result '{result['title']}'")
+            # load series page
+            series_url = f"https://{sf}/{series_id}"
             try:
-                try:
-                    if not season:
-                        season = "ALL"
-
-                    series_id = result["url_id"]
-                    threshold = 15  # this should cut down duplicates in case Sonarr is searching variants of a title
-                    context = "recents_sf"
-                    recently_searched = shared_state.get_recently_searched(shared_state, context, threshold)
-                    if series_id in recently_searched:
-                        if recently_searched[series_id]["timestamp"] > datetime.now() - timedelta(seconds=threshold):
-                            debug(f"'/{series_id}' - requested within the last {threshold} seconds! Skipping...")
-                            continue
-
-                    recently_searched[series_id] = {"timestamp": datetime.now()}
-                    shared_state.update(context, recently_searched)
-
-                    series_url = f"https://{sf}/{series_id}"
-                    series_page = requests.get(series_url, headers, timeout=10).text
-                    try:
-                        imdb_link = (BeautifulSoup(series_page, "html.parser").
-                                     find("a", href=re.compile(r"imdb\.com")))
-                        imdb_id = re.search(r'tt\d+', str(imdb_link)).group()
-                    except:
-                        imdb_id = None
-
-                    season_id = re.findall(r"initSeason\('(.+?)\',", series_page)[0]
-                    epoch = str(datetime.now().timestamp()).replace('.', '')[:-3]
-                    api_url = 'https://' + sf + '/api/v1/' + season_id + f'/season/{season}?lang=ALL&_=' + epoch
-
-                    response = requests.get(api_url, headers=headers, timeout=10)
-                    data = response.json()["html"]
-                    content = BeautifulSoup(data, "html.parser")
+                series_page = requests.get(series_url, headers=headers, timeout=10).text
+                imdb_link = BeautifulSoup(series_page, "html.parser").find("a", href=re.compile(r"imdb\.com"))
+                imdb_id = re.search(r'tt\d+', str(imdb_link)).group() if imdb_link else None
+                season_id = re.findall(r"initSeason\('(.+?)\',", series_page)[0]
+            except Exception:
+                debug(f"Failed to load or parse series page for {series_id}")
+                continue
 
-                    items = content.find_all("h3")
-                except:
+            # fetch API HTML
+            epoch = str(datetime.now().timestamp()).replace('.', '')[:-3]
+            api_url = f'https://{sf}/api/v1/{season_id}/season/ALL?lang=ALL&_={epoch}'
+            debug(f"Requesting SF API URL: {api_url}")
+            try:
+                api_resp = requests.get(api_url, headers=headers, timeout=10)
+                resp_json = api_resp.json()
+                if resp_json.get('error'):
+                    info(f"SF API error for series '{series_id}' at URL {api_url}: {resp_json.get('message')}")
                     continue
+                data_html = resp_json.get("html", "")
+            except Exception as e:
+                info(f"Error loading SF API for {series_id} at {api_url}: {e}")
+                continue
 
-                for item in items:
-                    try:
-                        details = item.parent.parent.parent
-                        title = details.find("small").text.strip()
-
-                        if not shared_state.search_string_in_sanitized_title(search_string, title):
-                            continue
-
-                        size_string = item.find("span", {"class": "morespec"}).text.split("|")[1].strip()
-                        size_item = extract_size(size_string)
-                        mirrors = parse_mirrors(f"https://{sf}", details)
-
-                        if mirror:
-                            if mirror not in mirrors["season"]:
-                                continue
-                            source = mirrors["season"][mirror]
-                            if not source:
-                                info(f"Could not find mirror '{mirror}' for '{title}'")
-                        else:
-                            source = next(iter(mirrors["season"].values()))
-                    except:
-                        debug(f"Could not find link for '{search_string}'")
-                        continue
+            # cache content and imdb_id
+            entry["content"] = data_html
+            entry["imdb_id"] = imdb_id
+            recently_searched[series_id] = entry
+            shared_state.update(context, recently_searched)
+            content = BeautifulSoup(data_html, "html.parser")
 
-                    mb = shared_state.convert_to_mb(size_item)
+        # parse episodes/releases
+        for item in content.find_all("h3"):
+            try:
+                details = item.parent.parent.parent
+                title = details.find("small").text.strip()
 
-                    if episode:
-                        mb = 0
-                        try:
-                            if not re.search(r'S\d{1,3}E\d{1,3}', title):
-                                title = re.sub(r'(S\d{1,3})', rf'\1E{episode:02d}', title)
+                mirrors = parse_mirrors(f"https://{sf}", details)
+                source = mirror and mirrors["season"].get(mirror) or next(iter(mirrors["season"].values()), None)
+                if not source:
+                    debug(f"No source mirror found for {title}")
+                    continue
 
-                                # Count episodes
-                                episodes_in_release = len(mirrors["episodes"])
+                try:
+                    size_string = item.find("span", {"class": "morespec"}).text.split("|")[1].strip()
+                    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}")
+                    mb = 0
 
-                                # Get the correct episode entry (episode numbers are 1-based, list index is 0-based)
-                                episode_data = next((e for e in mirrors["episodes"] if e["number"] == int(episode)),
-                                                    None)
+                if episode:
+                    try:
+                        if not re.search(r'S\d{1,3}E\d{1,3}', title):
+                            episodes_in_release = len(mirrors["episodes"])
 
-                                if episode_data:
-                                    if mirror:
-                                        if mirror not in episode_data["links"]:
-                                            debug(
-                                                f"Mirror '{mirror}' does not exist for '{title}' episode {episode}'")
-                                        else:
-                                            source = episode_data["links"][mirror]
+                            # Get the correct episode entry (episode numbers are 1-based, list index is 0-based)
+                            episode_data = next((e for e in mirrors["episodes"] if e["number"] == int(episode)),
+                                                None)
 
+                            if episode_data:
+                                title = re.sub(r'(S\d{1,3})', rf'\1E{episode:02d}', title)
+                                if mirror:
+                                    if mirror not in episode_data["links"]:
+                                        debug(
+                                            f"Mirror '{mirror}' does not exist for '{title}' episode {episode}'")
                                     else:
-                                        source = next(iter(episode_data["links"].values()))
+                                        source = episode_data["links"][mirror]
+
                                 else:
-                                    debug(f"Episode '{episode}' data not found in mirrors for '{title}'")
+                                    source = next(iter(episode_data["links"].values()))
+                            else:
+                                debug(f"Episode '{episode}' data not found in mirrors for '{title}'")
 
-                                if episodes_in_release:
+                            if episodes_in_release:
+                                try:
                                     mb = shared_state.convert_to_mb({
                                         "size": float(size_item["size"]) // episodes_in_release,
                                         "sizeunit": size_item["sizeunit"]
                                     })
-                        except:
-                            continue
-
-                    payload = urlsafe_b64encode(f"{title}|{source}|{mirror}|{mb}|{password}|{imdb_id}".
-                                                encode("utf-8")).decode("utf-8")
-                    link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
-
-                    try:
-                        size = mb * 1024 * 1024
-                    except:
-                        continue
-
-                    try:
-                        published = one_hour_ago  # release date is missing here
+                                except Exception as e:
+                                    debug(f"Error calculating size for {title}: {e}")
+                                    mb = 0
                     except:
                         continue
 
-                    releases.append({
-                        "details": {
-                            "title": title,
-                            "hostname": hostname.lower(),
-                            "imdb_id": imdb_id,
-                            "link": link,
-                            "mirror": mirror,
-                            "size": size,
-                            "date": published,
-                            "source": f"{series_url}/{season}" if season else series_url
-                        },
-                        "type": "protected"
-                    })
+                # check down here on purpose, because the title may be modified at episode stage
+                if not shared_state.is_valid_release(title,
+                                                     request_from,
+                                                     search_string,
+                                                     season,
+                                                     episode):
+                    continue
 
+                payload = urlsafe_b64encode(f"{title}|{source}|{mirror}|{mb}|{password}|{imdb_id}".encode()).decode()
+                link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+                size_bytes = mb * 1024 * 1024
+
+                releases.append({
+                    "details": {
+                        "title": title,
+                        "hostname": hostname.lower(),
+                        "imdb_id": imdb_id,
+                        "link": link,
+                        "mirror": mirror,
+                        "size": size_bytes,
+                        "date": one_hour_ago,
+                        "source": f"https://{sf}/{series_id}/{season}" if season else f"https://{sf}/{series_id}"
+                    },
+                    "type": "protected"
+                })
             except Exception as e:
-                info(f"Error parsing {hostname.upper()} search: {e}")
-        else:
-            debug(f"Search string '{search_string}' does not match result '{result['title']}'")
+                debug(f"Error parsing item for '{search_string}': {e}")
 
     elapsed_time = time.time() - start_time
-    debug(f"Time taken: {elapsed_time:.2f} seconds ({hostname.lower()})")
-
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
     return releases