quasarr 1.20.6__py3-none-any.whl

quasarr/search/sources/mb.py

@@ -0,0 +1,195 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import html
+import re
+import time
+from base64 import urlsafe_b64encode
+from datetime import datetime, timedelta
+from urllib.parse import quote_plus
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.log import info, debug
+
+hostname = "mb"
+supported_mirrors = ["rapidgator", "ddownload"]
+XXX_REGEX = re.compile(r"\.xxx\.", re.I)
+RESOLUTION_REGEX = re.compile(r"\d{3,4}p", re.I)
+CODEC_REGEX = re.compile(r"x264|x265|h264|h265|hevc|avc", re.I)
+IMDB_REGEX = re.compile(r"imdb\.com/title/(tt\d+)")
+
+# map German month names to numbers
+GERMAN_MONTHS = {
+    'Januar': '01', 'Februar': '02', 'März': '03', 'April': '04', 'Mai': '05', 'Juni': '06',
+    'Juli': '07', 'August': '08', 'September': '09', 'Oktober': '10', 'November': '11', 'Dezember': '12'
+}
+
+
+def convert_to_rss_date(date_str):
+    parsed = datetime.strptime(date_str, "%d.%m.%Y - %H:%M")
+    return parsed.strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+
+def extract_size(text):
+    m = re.match(r"(\d+(?:\.\d+)?)\s*([A-Za-z]+)", text)
+    if not m:
+        raise ValueError(f"Invalid size format: {text!r}")
+    return {"size": m.group(1), "sizeunit": m.group(2)}
+
+
+def _parse_posts(soup, shared_state, password, mirror_filter,
+                 is_search=False, request_from=None, search_string=None,
+                 season=None, episode=None):
+    releases = []
+    one_hour_ago = (datetime.now() - timedelta(hours=1)).strftime('%Y-%m-%d %H:%M:%S')
+
+    for post in soup.select("div.post"):
+        try:
+            # title & source
+            h1 = post.find("h1")
+            a = h1.find("a")
+            source = a["href"].strip()
+            title = a.get_text(strip=True)
+
+            # parse date
+            date_p = post.find("p", class_="date_x")
+            date_txt = date_p.get_text(strip=True) if date_p else None
+            published = one_hour_ago
+            if date_txt:
+                m_date = re.search(r'(?:\w+, )?(\d{1,2})\.\s*(\w+)\s+(\d{4})\s+(\d{2}:\d{2})', date_txt)
+                if m_date:
+                    day, mon_name, year, hm = m_date.groups()
+                    mon = GERMAN_MONTHS.get(mon_name, '01')
+                    dt_obj = datetime.strptime(f"{day}.{mon}.{year} {hm}", "%d.%m.%Y %H:%M")
+                    published = dt_obj.strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+            if is_search:
+                if not shared_state.is_valid_release(title,
+                                                     request_from,
+                                                     search_string,
+                                                     season,
+                                                     episode):
+                    continue
+
+                # drop .XXX. unless user explicitly searched xxx
+                if XXX_REGEX.search(title) and 'xxx' not in search_string.lower():
+                    continue
+                # require resolution/codec
+                if not (RESOLUTION_REGEX.search(title) or CODEC_REGEX.search(title)):
+                    continue
+                # require no spaces in title
+                if " " in title:
+                    continue
+
+                # can't check for mirrors in search context
+                if mirror_filter and mirror_filter not in supported_mirrors:
+                    continue
+            else:
+                mirror_candidates = []
+                for strong in post.find_all('strong', string=re.compile(r'^Download', re.I)):
+                    link_tag = strong.find_next_sibling('a')
+                    if link_tag and link_tag.get_text(strip=True):
+                        host = link_tag.get_text(strip=True).split('.')[0].lower()
+                        mirror_candidates.append(host)
+                valid = [m for m in mirror_candidates if m in supported_mirrors]
+                if not valid or (mirror_filter and mirror_filter not in valid):
+                    continue
+
+            # extract IMDb ID
+            imdb_id = None
+            for tag in post.find_all('a', href=True):
+                m = IMDB_REGEX.search(tag['href'])
+                if m:
+                    imdb_id = m.group(1)
+                    break
+
+            # size extraction
+            mb = size_bytes = 0
+            size_match = re.search(r"Größe:\s*([\d\.]+)\s*([GMK]B)", post.get_text())
+            if size_match:
+                sz = {"size": size_match.group(1), "sizeunit": size_match.group(2)}
+                mb = shared_state.convert_to_mb(sz)
+                size_bytes = mb * 1024 * 1024
+
+            payload = urlsafe_b64encode(
+                f"{title}|{source}|{mirror_filter}|{mb}|{password}|{imdb_id}".encode()
+            ).decode()
+            link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+            releases.append({
+                "details": {
+                    "title": title,
+                    "hostname": hostname,
+                    "imdb_id": imdb_id,
+                    "link": link,
+                    "mirror": mirror_filter,
+                    "size": size_bytes,
+                    "date": published,
+                    "source": source
+                },
+                "type": "protected"
+            })
+        except Exception as e:
+            debug(f"Error parsing {hostname.upper()} post: {e}")
+            continue
+    return releases
+
+
+def mb_feed(shared_state, start_time, request_from, mirror=None):
+    mb = 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 []
+
+    password = mb
+    section = "neuerscheinungen" if "Radarr" in request_from else "serie"
+    url = f"https://{mb}/category/{section}/"
+    headers = {'User-Agent': shared_state.values["user_agent"]}
+    try:
+        html_doc = requests.get(url, headers=headers, timeout=10).content
+        soup = BeautifulSoup(html_doc, "html.parser")
+        releases = _parse_posts(soup, shared_state, password, mirror_filter=mirror)
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} feed: {e}")
+        releases = []
+    debug(f"Time taken: {time.time() - start_time:.2f}s ({hostname})")
+    return releases
+
+
+def mb_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
+    mb = 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 []
+
+    password = mb
+    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"Could not extract title from IMDb-ID {imdb_id}")
+            return []
+        search_string = html.unescape(title)
+
+    q = quote_plus(search_string)
+    url = f"https://{mb}/?s={q}&id=20&post_type=post"
+    headers = {'User-Agent': shared_state.values["user_agent"]}
+    try:
+        html_doc = requests.get(url, headers=headers, timeout=10).content
+        soup = BeautifulSoup(html_doc, "html.parser")
+        releases = _parse_posts(
+            soup, shared_state, password, mirror_filter=mirror,
+            is_search=True, request_from=request_from,
+            search_string=search_string, season=season, episode=episode
+        )
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} search: {e}")
+        releases = []
+    debug(f"Time taken: {time.time() - start_time:.2f}s ({hostname})")
+    return releases

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

@@ -0,0 +1,197 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import html
+import time
+from base64 import urlsafe_b64encode
+
+import requests
+
+from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.log import info, debug
+
+hostname = "nx"
+supported_mirrors = ["filer"]
+
+
+def nx_feed(shared_state, start_time, request_from, mirror=None):
+    releases = []
+    nx = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = nx
+
+    if "lazylibrarian" in request_from.lower():
+        category = "ebook"
+    elif "radarr" in request_from.lower():
+        category = "movie"
+    else:
+        category = "episode"
+
+    if mirror and mirror not in supported_mirrors:
+        debug(f'Mirror "{mirror}" not supported by "{hostname.upper()}". Supported mirrors: {supported_mirrors}.'
+              ' Skipping search!')
+        return releases
+
+    url = f'https://{nx}/api/frontend/releases/category/{category}/tag/all/1/51?sort=date'
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    try:
+        response = requests.get(url, headers, timeout=10)
+        feed = response.json()
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} feed: {e}")
+        return releases
+
+    items = feed['result']['list']
+    for item in items:
+        try:
+            title = item['name']
+
+            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)
+                    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}"
+                except:
+                    continue
+
+                try:
+                    size = mb * 1024 * 1024
+                except:
+                    continue
+
+                try:
+                    published = item['publishat']
+                except:
+                    continue
+
+                releases.append({
+                    "details": {
+                        "title": title,
+                        "hostname": hostname.lower(),
+                        "imdb_id": imdb_id,
+                        "link": link,
+                        "mirror": mirror,
+                        "size": size,
+                        "date": published,
+                        "source": source
+                    },
+                    "type": "protected"
+                })
+
+        except Exception as e:
+            info(f"Error parsing {hostname.upper()} feed: {e}")
+
+    elapsed_time = time.time() - start_time
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
+
+    return releases
+
+
+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 "lazylibrarian" in request_from.lower():
+        valid_type = "ebook"
+    elif "radarr" in request_from.lower():
+        valid_type = "movie"
+    else:
+        valid_type = "episode"
+
+    if mirror and mirror not in supported_mirrors:
+        debug(f'Mirror "{mirror}" not supported by "{hostname.upper()}". Supported mirrors: {supported_mirrors}.'
+              ' Skipping search!')
+        return releases
+
+    imdb_id = shared_state.is_imdb_id(search_string)
+    if imdb_id:
+        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)
+
+    url = f'https://{nx}/api/frontend/search/{search_string}'
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    try:
+        response = requests.get(url, headers, timeout=10)
+        feed = response.json()
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} search: {e}")
+        return releases
+
+    items = feed['result']['releases']
+    for item in items:
+        try:
+            if item['type'] == valid_type:
+                title = item['name']
+                if 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:
+                            imdb_id = item.get('_media', {}).get('imdbid', None)
+
+                        mb = shared_state.convert_to_mb(item)
+                        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}"
+                    except:
+                        continue
+
+                    try:
+                        size = mb * 1024 * 1024
+                    except:
+                        continue
+
+                    try:
+                        published = item['publishat']
+                    except:
+                        published = ""
+
+                    releases.append({
+                        "details": {
+                            "title": title,
+                            "hostname": hostname.lower(),
+                            "imdb_id": imdb_id,
+                            "link": link,
+                            "mirror": mirror,
+                            "size": size,
+                            "date": published,
+                            "source": source
+                        },
+                        "type": "protected"
+                    })
+
+        except Exception as e:
+            info(f"Error parsing {hostname.upper()} search: {e}")
+
+    elapsed_time = time.time() - start_time
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
+
+    return releases