quasarr 0.1.6__py3-none-any.whl → 1.23.0__py3-none-any.whl

quasarr/search/sources/fx.py

@@ -3,14 +3,20 @@
 # Project by https://github.com/rix1337
 
 import re
+import time
 from base64 import urlsafe_b64encode
 
 import requests
 from bs4 import BeautifulSoup
 
+from quasarr.providers.log import info, debug
+
+hostname = "fx"
+supported_mirrors = ["rapidgator"]
+
 
 def extract_size(text):
-    match = re.match(r"(\d+)([A-Za-z]+)", text)
+    match = re.match(r"(\d+)\s*([A-Za-z]+)", text)
     if match:
         size = match.group(1)
         unit = match.group(2)
@@ -19,10 +25,20 @@ def extract_size(text):
         raise ValueError(f"Invalid size format: {text}")
 
 
-def fx_feed(shared_state):
+def fx_feed(shared_state, start_time, request_from, mirror=None):
     releases = []
 
-    fx = shared_state.values["config"]("Hostnames").get("fx")
+    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!')
+        return releases
 
     password = fx.split(".")[0]
     url = f'https://{fx}/'
@@ -31,11 +47,11 @@ def fx_feed(shared_state):
     }
 
     try:
-        request = requests.get(url, headers=headers).content
+        request = requests.get(url, headers=headers, timeout=10).content
         feed = BeautifulSoup(request, "html.parser")
-        items = feed.findAll("article")
+        items = feed.find_all("article")
     except Exception as e:
-        print(f"Error loading FX feed: {e}")
+        info(f"Error loading {hostname.upper()} feed: {e}")
         return releases
 
     if items:
@@ -44,28 +60,34 @@ def fx_feed(shared_state):
                 article = BeautifulSoup(str(item), "html.parser")
                 try:
                     source = article.find('h2', class_='entry-title').a["href"]
-                    titles = article.findAll("a", href=re.compile("(filecrypt|safe." + fx + ")"))
+                    titles = article.find_all("a", href=re.compile("(filecrypt|safe." + fx + ")"))
                 except:
                     continue
                 i = 0
                 for title in titles:
                     link = title["href"]
-                    title = (title.text.encode("ascii", errors="ignore").decode().
-                             replace("/", "").replace(" ", ".").strip())
+                    title = shared_state.sanitize_title(title.text)
+
+                    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.findAll("strong", text=re.compile(r"(size|größe)", re.IGNORECASE))[
+                        size_info = article.find_all("strong", text=re.compile(r"(size|größe)", re.IGNORECASE))[
                             i].next.next.text.replace("|", "").strip()
                         size_item = extract_size(size_info)
                         mb = shared_state.convert_to_mb(size_item)
                         size = mb * 1024 * 1024
-                        payload = urlsafe_b64encode(f"{title}|{link}|{mb}|{password}".encode("utf-8")).decode("utf-8")
+                        payload = urlsafe_b64encode(
+                            f"{title}|{link}|{mirror}|{mb}|{password}|{imdb_id}".encode("utf-8")).decode("utf-8")
                         link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
                     except:
                         continue
 
                     try:
-                        dates = article.findAll("time")
+                        dates = article.find_all("time")
                         for date in dates:
                             published = date["datetime"]
                     except:
@@ -73,8 +95,11 @@ def fx_feed(shared_state):
 
                     releases.append({
                         "details": {
-                            "title": f"[FX] {title}",
+                            "title": title,
+                            "hostname": hostname.lower(),
+                            "imdb_id": imdb_id,
                             "link": link,
+                            "mirror": mirror,
                             "size": size,
                             "date": published,
                             "source": source
@@ -83,68 +108,93 @@ def fx_feed(shared_state):
                     })
 
             except Exception as e:
-                print(f"Error parsing FX feed: {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 fx_search(shared_state, imdb_id):
+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]
 
-    fx = shared_state.values["config"]("Hostnames").get("fx")
+    if not "arr" in request_from.lower():
+        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
+        return releases
 
-    password = fx.split(".")[0]
-    url = f'https://{fx}/?s={imdb_id}'
+
+    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://{fx}/?s={search_string}'
     headers = {
         'User-Agent': shared_state.values["user_agent"],
     }
 
     try:
-        request = requests.get(url, headers=headers).content
+        request = requests.get(url, headers=headers, timeout=10).content
         search = BeautifulSoup(request, "html.parser")
         results = search.find('h2', class_='entry-title')
 
     except Exception as e:
-        print(f"Error loading FX feed: {e}")
+        info(f"Error loading {hostname.upper()} feed: {e}")
         return releases
 
     if results:
         for result in results:
-            result_source = result["href"]
             try:
-                request = requests.get(result_source, headers=headers).content
+                result_source = result["href"]
+                request = requests.get(result_source, headers=headers, timeout=10).content
                 feed = BeautifulSoup(request, "html.parser")
-                items = feed.findAll("article")
+                items = feed.find_all("article")
             except Exception as e:
-                print(f"Error loading FX feed: {e}")
+                info(f"Error loading {hostname.upper()} feed: {e}")
                 return releases
 
             for item in items:
                 try:
                     article = BeautifulSoup(str(item), "html.parser")
                     try:
-                        titles = article.findAll("a", href=re.compile("(filecrypt|safe." + fx + ")"))
+                        titles = article.find_all("a", href=re.compile(r"filecrypt\."))
                     except:
                         continue
                     i = 0
                     for title in titles:
                         link = title["href"]
-                        title = (title.text.encode("ascii", errors="ignore").decode().
-                                 replace("/", "").replace(" ", ".").strip())
+                        title = shared_state.sanitize_title(title.text)
+
+                        if not shared_state.is_valid_release(title,
+                                                             request_from,
+                                                             search_string,
+                                                             season,
+                                                             episode):
+                            continue
+
+                        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.findAll("strong", text=re.compile(r"(size|größe)", re.IGNORECASE))[
+                            size_info = article.find_all("strong", text=re.compile(r"(size|größe)", re.IGNORECASE))[
                                 i].next.next.text.replace("|", "").strip()
                             size_item = extract_size(size_info)
                             mb = shared_state.convert_to_mb(size_item)
                             size = mb * 1024 * 1024
-                            payload = urlsafe_b64encode(f"{title}|{link}|{mb}|{password}".encode("utf-8")).decode(
-                                "utf-8")
+                            payload = urlsafe_b64encode(
+                                f"{title}|{link}|{mirror}|{mb}|{password}|{imdb_id}".encode("utf-8")).decode("utf-8")
                             link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
                         except:
                             continue
 
                         try:
-                            dates = article.findAll("time")
+                            dates = article.find_all("time")
                             for date in dates:
                                 published = date["datetime"]
                         except:
@@ -152,8 +202,11 @@ def fx_search(shared_state, imdb_id):
 
                         releases.append({
                             "details": {
-                                "title": f"[FX] {title}",
+                                "title": title,
+                                "hostname": hostname.lower(),
+                                "imdb_id": imdb_id,
                                 "link": link,
+                                "mirror": mirror,
                                 "size": size,
                                 "date": published,
                                 "source": result_source
@@ -162,6 +215,9 @@ def fx_search(shared_state, imdb_id):
                         })
 
                 except Exception as e:
-                    print(f"Error parsing FX search: {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

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