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

quasarr/search/sources/fx.py

@@ -15,18 +15,6 @@ hostname = "fx"
 supported_mirrors = ["rapidgator"]
 
 
-def sanitize_title(title):
-    umlaut_map = {
-        "Ä": "Ae", "ä": "ae",
-        "Ö": "Oe", "ö": "oe",
-        "Ü": "Ue", "ü": "ue",
-        "ß": "ss"
-    }
-    for umlaut, replacement in umlaut_map.items():
-        title = title.replace(umlaut, replacement)
-    return title.encode("ascii", errors="ignore").decode().replace("/", "").replace(" ", ".").strip()
-
-
 def extract_size(text):
     match = re.match(r"(\d+)\s*([A-Za-z]+)", text)
     if match:
@@ -37,11 +25,16 @@ def extract_size(text):
         raise ValueError(f"Invalid size format: {text}")
 
 
-def fx_feed(shared_state, start_time, mirror=None):
+def fx_feed(shared_state, start_time, request_from, mirror=None):
     releases = []
 
     fx = shared_state.values["config"]("Hostnames").get(hostname.lower())
 
+    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.upper()}". Supported mirrors: {supported_mirrors}.'
               ' Skipping search!')
@@ -73,7 +66,7 @@ def fx_feed(shared_state, start_time, mirror=None):
                 i = 0
                 for title in titles:
                     link = title["href"]
-                    title = sanitize_title(title.text)
+                    title = shared_state.sanitize_title(title.text)
 
                     try:
                         imdb_link = article.find("a", href=re.compile(r"imdb\.com"))
@@ -118,22 +111,26 @@ def fx_feed(shared_state, start_time, 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 fx_search(shared_state, start_time, search_string, mirror=None):
+def fx_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
     releases = []
-
     fx = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = fx.split(".")[0]
+
+    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.upper()}". Supported mirrors: {supported_mirrors}.'
               ' Skipping search!')
         return releases
 
-    password = fx.split(".")[0]
     url = f'https://{fx}/?s={search_string}'
     headers = {
         'User-Agent': shared_state.values["user_agent"],
@@ -148,8 +145,6 @@ def fx_search(shared_state, start_time, search_string, mirror=None):
         info(f"Error loading {hostname.upper()} feed: {e}")
         return releases
 
-    imdb_id = shared_state.is_imdb_id(search_string)
-
     if results:
         for result in results:
             try:
@@ -171,17 +166,20 @@ def fx_search(shared_state, start_time, search_string, mirror=None):
                     i = 0
                     for title in titles:
                         link = title["href"]
-                        title = sanitize_title(title.text)
+                        title = shared_state.sanitize_title(title.text)
 
-                        if not imdb_id and 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 not imdb_id:
-                            try:
-                                imdb_link = article.find("a", href=re.compile(r"imdb\.com"))
-                                imdb_id = re.search(r'tt\d+', str(imdb_link)).group()
-                            except:
-                                imdb_id = None
+                        try:
+                            imdb_link = article.find("a", href=re.compile(r"imdb\.com"))
+                            imdb_id = re.search(r'tt\d+', str(imdb_link)).group()
+                        except:
+                            imdb_id = None
 
                         try:
                             size_info = article.find_all("strong", text=re.compile(r"(size|größe)", re.IGNORECASE))[
@@ -220,6 +218,6 @@ def fx_search(shared_state, start_time, 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/he.py

@@ -0,0 +1,196 @@
+# -*- 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
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.log import info, debug
+
+hostname = "he"
+supported_mirrors = ["rapidgator", "nitroflare"]
+
+
+def parse_posted_ago(txt):
+    try:
+        m = re.search(r"(\d+)\s*(sec|min|hour|day|week|month|year)s?", txt, re.IGNORECASE)
+        if not m:
+            return ''
+        value = int(m.group(1))
+        unit = m.group(2).lower()
+        now = datetime.utcnow()
+        if unit.startswith('sec'):
+            delta = timedelta(seconds=value)
+        elif unit.startswith('min'):
+            delta = timedelta(minutes=value)
+        elif unit.startswith('hour'):
+            delta = timedelta(hours=value)
+        elif unit.startswith('day'):
+            delta = timedelta(days=value)
+        elif unit.startswith('week'):
+            delta = timedelta(weeks=value)
+        elif unit.startswith('month'):
+            delta = timedelta(days=30 * value)
+        else:
+            delta = timedelta(days=365 * value)
+        return (datetime.utcnow() - delta).strftime("%a, %d %b %Y %H:%M:%S +0000")
+    except Exception:
+        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 he_feed(*args, **kwargs):
+    return he_search(*args, **kwargs)
+
+
+def he_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.lower():
+        tag = "movies"
+    else:
+        tag = "tv-shows"
+
+    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, 'en')
+            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}/tag/{tag}/'
+
+    headers = {"User-Agent": shared_state.values["user_agent"]}
+    params = {"s": source_search}
+
+    try:
+        r = requests.get(url, headers=headers, params=params, timeout=10)
+        soup = BeautifulSoup(r.content, 'html.parser')
+        results = soup.find_all('div', class_='item')
+    except Exception as e:
+        info(f"{hostname}: search load error: {e}")
+        return releases
+
+    if not results:
+        return releases
+
+    for result in results:
+        try:
+            data = result.find('div', class_='data')
+            if not data:
+                continue
+
+            headline = data.find('h5')
+            if not headline:
+                continue
+
+            a = headline.find('a', href=True)
+            if not a:
+                continue
+
+            source = a['href'].strip()
+
+            head_title = a.get_text(strip=True)
+            if not head_title:
+                continue
+
+            head_split = head_title.split(" – ")
+            title = head_split[0].strip()
+
+            if not shared_state.is_valid_release(title, request_from, search_string, season, episode):
+                continue
+
+            size_item = extract_size(head_split[1].strip())
+            mb = shared_state.convert_to_mb(size_item)
+
+            size = mb * 1024 * 1024
+
+            published = None
+            p_meta = data.find('p', class_='meta')
+            if p_meta:
+                posted_span = None
+                for sp in p_meta.find_all('span'):
+                    txt = sp.get_text(' ', strip=True)
+                    if txt.lower().startswith('posted') or 'ago' in txt.lower():
+                        posted_span = txt
+                        break
+
+                if posted_span:
+                    published = parse_posted_ago(posted_span)
+
+            if published is None:
+                continue
+
+            release_imdb_id = None
+            try:
+                r = requests.get(source, headers=headers, timeout=10)
+                soup = BeautifulSoup(r.content, 'html.parser')
+                imdb_link = soup.find('a', href=re.compile(r"imdb\.com/title/tt\d+", re.IGNORECASE))
+                if imdb_link:
+                    release_imdb_id = re.search(r'tt\d+', imdb_link['href']).group()
+                    if imdb_id and release_imdb_id != imdb_id:
+                        debug(f"{hostname}: IMDb ID mismatch: expected {imdb_id}, found {release_imdb_id}")
+                        continue
+                else:
+                    debug(f"{hostname}: imdb link not found for title {title}")
+            except Exception as e:
+                debug(f"{hostname}: failed to determine imdb_id for title {title}")
+                continue
+
+            password = None
+            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:
+            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/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