quasarr 1.20.6__py3-none-any.whl

quasarr/search/sources/sl.py

@@ -0,0 +1,246 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import datetime
+import html
+import re
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import xml.etree.ElementTree as ET
+from base64 import urlsafe_b64encode
+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 = "sl"
+supported_mirrors = ["nitroflare", "ddownload"]  # ignoring captcha-protected multiup/mirrorace for now
+
+
+def extract_size(text):
+    match = re.match(r"([\d\.]+)\s*([KMGT]B)", text, re.IGNORECASE)
+    if match:
+        size = match.group(1)
+        unit = match.group(2).upper()
+        return {"size": size, "sizeunit": unit}
+    else:
+        raise ValueError(f"Invalid size format: {text}")
+
+
+def parse_pubdate_to_iso(pubdate_str):
+    """
+    Parse an RFC-822 pubDate from RSS into an ISO8601 string with timezone.
+    """
+    dt = datetime.datetime.strptime(pubdate_str, '%a, %d %b %Y %H:%M:%S %z')
+    return dt.isoformat()
+
+
+def sl_feed(shared_state, start_time, request_from, mirror=None):
+    releases = []
+
+    sl = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = sl
+
+    if "lazylibrarian" in request_from.lower():
+        feed_type = "ebooks"
+    elif "radarr" in request_from.lower():
+        feed_type = "movies"
+    else:
+        feed_type = "tv-shows"
+
+    if mirror and mirror not in supported_mirrors:
+        debug(f'Mirror "{mirror}" not supported by "{hostname.upper()}". Supported: {supported_mirrors}. Skipping!')
+        return releases
+
+    url = f'https://{sl}/{feed_type}/feed/'
+    headers = {'User-Agent': shared_state.values['user_agent']}
+
+    try:
+        xml_text = requests.get(url, headers=headers, timeout=10).text
+        root = ET.fromstring(xml_text)
+
+        for item in root.find('channel').findall('item'):
+            try:
+                title = item.findtext('title').strip()
+                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 = item.findtext('link').strip()
+
+                desc = item.findtext('description') or ''
+
+                size_match = re.search(r"Size:\s*([\d\.]+\s*(?:GB|MB|KB|TB))", desc, re.IGNORECASE)
+                if not size_match:
+                    debug(f"Size not found in RSS item: {title}")
+                    continue
+                size_info = size_match.group(1).strip()
+                size_item = extract_size(size_info)
+                mb = shared_state.convert_to_mb(size_item)
+                size = mb * 1024 * 1024
+
+                pubdate = item.findtext('pubDate').strip()
+                published = parse_pubdate_to_iso(pubdate)
+
+                m = re.search(r"https?://www\.imdb\.com/title/(tt\d+)", desc)
+                imdb_id = m.group(1) if m else None
+
+                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}"
+
+                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 item: {e}")
+                continue
+
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} feed: {e}")
+
+    elapsed = time.time() - start_time
+    debug(f"Time taken: {elapsed:.2f}s ({hostname})")
+    return releases
+
+
+def sl_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
+    releases = []
+    sl = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = sl
+
+    if "lazylibrarian" in request_from.lower():
+        feed_type = "ebooks"
+    elif "radarr" in request_from.lower():
+        feed_type = "movies"
+    else:
+        feed_type = "tv-shows"
+
+    if mirror and mirror not in supported_mirrors:
+        debug(f'Mirror "{mirror}" not supported by "{hostname.upper()}". Supported: {supported_mirrors}. Skipping!')
+        return releases
+
+    try:
+        imdb_id = shared_state.is_imdb_id(search_string)
+        if imdb_id:
+            search_string = get_localized_title(shared_state, imdb_id, 'en') or ''
+            search_string = html.unescape(search_string)
+            if not search_string:
+                info(f"Could not extract title from IMDb-ID {imdb_id}")
+                return releases
+
+        # Build the list of URLs to search. For tv-shows also search the "foreign" section.
+        q = quote_plus(search_string)
+        urls = [f'https://{sl}/{feed_type}/?s={q}']
+        if feed_type == "tv-shows":
+            urls.append(f'https://{sl}/foreign/?s={q}')
+
+        headers = {"User-Agent": shared_state.values['user_agent']}
+
+        # Fetch pages in parallel (so we don't double the slow site latency)
+        def fetch(url):
+            try:
+                debug(f"Fetching {url} ({hostname})")
+                r = requests.get(url, headers=headers, timeout=10)
+                r.raise_for_status()
+                return r.text
+            except Exception as e:
+                info(f"Error fetching {hostname} url {url}: {e}")
+                return ''
+
+        html_texts = []
+        with ThreadPoolExecutor(max_workers=len(urls)) as tpe:
+            futures = {tpe.submit(fetch, u): u for u in urls}
+            for future in as_completed(futures):
+                try:
+                    html_texts.append(future.result())
+                except Exception as e:
+                    info(f"Error fetching {hostname} search page: {e}")
+
+        # Parse each result and collect unique releases (dedupe by source link)
+        seen_sources = set()
+        for html_text in html_texts:
+            if not html_text:
+                continue
+            try:
+                soup = BeautifulSoup(html_text, 'html.parser')
+                posts = soup.find_all('div', class_=lambda c: c and c.startswith('post-'))
+
+                for post in posts:
+                    try:
+                        a = post.find('h1').find('a')
+                        title = a.get_text(strip=True)
+
+                        if not shared_state.is_valid_release(title,
+                                                             request_from,
+                                                             search_string,
+                                                             season,
+                                                             episode):
+                            continue
+
+                        if 'lazylibrarian' in request_from.lower():
+                            title = shared_state.normalize_magazine_title(title)
+
+                        source = a['href']
+                        # dedupe
+                        if source in seen_sources:
+                            continue
+                        seen_sources.add(source)
+
+                        # Published date
+                        time_tag = post.find('span', {'class': 'localtime'})
+                        published = None
+                        if time_tag and time_tag.has_attr('data-lttime'):
+                            published = time_tag['data-lttime']
+                        published = published or datetime.datetime.utcnow().isoformat() + '+00:00'
+
+                        size = 0
+                        imdb_id = None
+
+                        payload = urlsafe_b64encode(
+                            f"{title}|{source}|{mirror}|0|{password}|{imdb_id}".encode('utf-8')
+                        ).decode('utf-8')
+                        link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+                        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 item: {e}")
+                        continue
+            except Exception as e:
+                info(f"Error parsing {hostname.upper()} search HTML: {e}")
+                continue
+
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} search page: {e}")
+
+    elapsed = time.time() - start_time
+    debug(f"Search time: {elapsed:.2f}s ({hostname})")
+    return releases

quasarr/search/sources/wd.py

@@ -0,0 +1,208 @@
+# -*- 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, 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 = "wd"
+supported_mirrors = ["rapidgator", "ddownload", "katfile", "fikper", "turbobit"]
+
+# regex to detect porn-tag .XXX. (case-insensitive, dots included)
+XXX_REGEX = re.compile(r"\.xxx\.", re.I)
+# regex to detect video resolution
+RESOLUTION_REGEX = re.compile(r"\d{3,4}p", re.I)
+# regex to detect video codec tags
+CODEC_REGEX = re.compile(r"x264|x265|h264|h265|hevc|avc", re.I)
+
+
+def convert_to_rss_date(date_str):
+    """
+    date_str comes in as "02.05.2025 - 09:04"
+    Return RFC‑822 style date with +0000 timezone.
+    """
+    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):
+    """
+    e.g. "8 GB" → {"size": "8", "sizeunit": "GB"}
+    """
+    match = re.match(r"(\d+(?:\.\d+)?)\s*([A-Za-z]+)", text)
+    if not match:
+        raise ValueError(f"Invalid size format: {text!r}")
+    return {"size": match.group(1), "sizeunit": match.group(2)}
+
+
+def _parse_rows(
+        soup,
+        shared_state,
+        url_base,
+        password,
+        mirror_filter,
+        request_from=None,
+        search_string=None,
+        season=None,
+        episode=None
+):
+    """
+    Walk the <table> rows, extract one release per row.
+    Only include rows with at least one supported mirror.
+    If mirror_filter provided, only include rows where mirror_filter is present.
+
+    Context detection:
+      - feed when search_string is None
+      - search when search_string is a str
+
+    Porn-filtering:
+      - feed: always drop .XXX.
+      - search: drop .XXX. unless 'xxx' in search_string (case-insensitive)
+
+    If in search context, also filter out non-video releases (ebooks, games).
+    """
+    releases = []
+    is_search = search_string is not None
+
+    one_hour_ago = (datetime.now() - timedelta(hours=1)).strftime('%Y-%m-%d %H:%M:%S')
+
+    for tr in soup.select("table.table tbody tr.lh-sm"):
+        try:
+            a = tr.find("a", class_="upload-link")
+            raw_href = a["href"]
+            href = quote(raw_href, safe="/?:=&")
+            source = f"https://{url_base}{href}"
+
+            preview_div = a.find("div", class_="preview-text")
+            date_txt = preview_div.get_text(strip=True) if preview_div else None
+            if preview_div:
+                preview_div.extract()
+
+            title = a.get_text(strip=True)
+
+            # search context contains non-video releases (ebooks, games, etc.)
+            if is_search:
+                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)
+                else:
+                    # 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
+
+            hoster_names = tr.find("span", class_="button-warezkorb")["data-hoster-names"]
+            mirrors = [m.strip().lower() for m in hoster_names.split(",")]
+            valid = [m for m in mirrors if m in supported_mirrors]
+            if not valid or (mirror_filter and mirror_filter not in valid):
+                continue
+
+            size_txt = tr.find("span", class_="element-size").get_text(strip=True)
+            sz = extract_size(size_txt)
+            mb = shared_state.convert_to_mb(sz)
+            size_bytes = mb * 1024 * 1024
+
+            imdb_id = None
+            published = convert_to_rss_date(date_txt) if date_txt else one_hour_ago
+
+            payload = urlsafe_b64encode(
+                f"{title}|{source}|{mirror_filter}|{mb}|{password}|{imdb_id}".encode()
+            ).decode()
+            download_link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+            releases.append({
+                "details": {
+                    "title": title,
+                    "hostname": hostname,
+                    "imdb_id": imdb_id,
+                    "link": download_link,
+                    "mirror": mirror_filter,
+                    "size": size_bytes,
+                    "date": published,
+                    "source": source
+                },
+                "type": "protected"
+            })
+        except Exception as e:
+            debug(f"Error parsing {hostname.upper()} row: {e}")
+            continue
+    return releases
+
+
+def wd_feed(shared_state, start_time, request_from, mirror=None):
+    wd = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = wd
+
+    if "lazylibrarian" in request_from.lower():
+        feed_type = "Ebooks"
+    elif "radarr" in request_from.lower():
+        feed_type = "Movies"
+    else:
+        feed_type = "Serien"
+
+    url = f"https://{wd}/{feed_type}"
+    headers = {'User-Agent': shared_state.values["user_agent"]}
+    try:
+        response = requests.get(url, headers=headers, timeout=10).content
+        soup = BeautifulSoup(response, "html.parser")
+        releases = _parse_rows(soup, shared_state, wd, password, 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 wd_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
+    releases = []
+    wd = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = wd
+
+    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)
+
+    q = quote_plus(search_string)
+    url = f"https://{wd}/search?q={q}"
+    headers = {'User-Agent': shared_state.values["user_agent"]}
+
+    try:
+        response = requests.get(url, headers=headers, timeout=10).content
+        soup = BeautifulSoup(response, "html.parser")
+        releases = _parse_rows(
+            soup, shared_state, wd, password, mirror,
+            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/storage/config.py

@@ -0,0 +1,163 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import base64
+import configparser
+import re
+import string
+
+from Cryptodome.Cipher import AES
+from Cryptodome.Random import get_random_bytes
+from Cryptodome.Util.Padding import pad
+
+from quasarr.providers import shared_state
+from quasarr.storage.sqlite_database import DataBase
+
+
+class Config(object):
+    _DEFAULT_CONFIG = {
+        'API': [
+            ("key", "secret", ""),
+        ],
+        'JDownloader': [
+            ("user", "secret", ""),
+            ("password", "secret", ""),
+            ("device", "str", ""),
+        ],
+        'Hostnames': [
+            ("al", "secret", ""),
+            ("by", "secret", ""),
+            ("dd", "secret", ""),
+            ("dj", "secret", ""),
+            ("dt", "secret", ""),
+            ("dw", "secret", ""),
+            ("fx", "secret", ""),
+            ("he", "secret", ""),
+            ("mb", "secret", ""),
+            ("nk", "secret", ""),
+            ("nx", "secret", ""),
+            ("sf", "secret", ""),
+            ("sj", "secret", ""),
+            ("sl", "secret", ""),
+            ("wd", "secret", "")
+        ],
+        'FlareSolverr': [
+            ("url", "str", ""),
+        ],
+        'AL': [
+            ("user", "secret", ""),
+            ("password", "secret", "")
+        ],
+        'DD': [
+            ("user", "secret", ""),
+            ("password", "secret", "")
+        ],
+        'NX': [
+            ("user", "secret", ""),
+            ("password", "secret", "")
+        ]
+    }
+    __config__ = []
+
+    def __init__(self, section):
+        self._configfile = shared_state.values["configfile"]
+        self._section = section
+        self._config = configparser.RawConfigParser()
+        try:
+            self._config.read(self._configfile)
+            self._config.has_section(
+                self._section) or self._set_default_config(self._section)
+            self.__config__ = self._read_config(self._section)
+        except configparser.DuplicateSectionError:
+            print('Duplicate Section in Config File')
+            raise
+        except Exception as e:
+            print(f'Unknown error while reading config file: {e}')
+            raise
+
+    def _set_default_config(self, section):
+        self._config.add_section(section)
+        for (key, key_type, value) in self._DEFAULT_CONFIG[section]:
+            self._config.set(section, key, value)
+        with open(self._configfile, 'w') as configfile:
+            self._config.write(configfile)
+
+    def _get_encryption_params(self):
+        crypt_key = DataBase('secrets').retrieve("key")
+        crypt_iv = DataBase('secrets').retrieve("iv")
+        if crypt_iv and crypt_key:
+            return base64.b64decode(crypt_key), base64.b64decode(crypt_iv)
+        else:
+            crypt_key = get_random_bytes(32)
+            crypt_iv = get_random_bytes(16)
+            DataBase('secrets').update_store("key", base64.b64encode(crypt_key).decode())
+            DataBase('secrets').update_store("iv", base64.b64encode(crypt_iv).decode())
+            return crypt_key, crypt_iv
+
+    def _set_to_config(self, section, key, value):
+        default_value_type = [param[1] for param in self._DEFAULT_CONFIG[section] if param[0] == key]
+        if default_value_type and default_value_type[0] == 'secret' and len(value):
+            crypt_key, crypt_iv = self._get_encryption_params()
+            cipher = AES.new(crypt_key, AES.MODE_CBC, crypt_iv)
+            value = base64.b64encode(cipher.encrypt(pad(value.encode(), AES.block_size)))
+            value = 'secret|' + value.decode()
+        self._config.set(section, key, value)
+        with open(self._configfile, 'w') as configfile:
+            self._config.write(configfile)
+
+    def _read_config(self, section):
+        return [(key, '', self._config.get(section, key)) for key in self._config.options(section)]
+
+    def _get_from_config(self, scope, key):
+        res = [param[2] for param in scope if param[0] == key]
+        if not res:
+            res = [param[2]
+                   for param in self._DEFAULT_CONFIG[self._section] if param[0] == key]
+        if [param for param in self._DEFAULT_CONFIG[self._section] if param[0] == key and param[1] == 'secret']:
+            value = res[0].strip('\'"')
+            if value.startswith("secret|"):
+                crypt_key, crypt_iv = self._get_encryption_params()
+                cipher = AES.new(crypt_key, AES.MODE_CBC, crypt_iv)
+                decrypted_payload = cipher.decrypt(base64.b64decode(value[7:])).decode("utf-8").strip()
+                final_payload = "".join(filter(lambda c: c in string.printable, decrypted_payload))
+                return final_payload
+            else:  ## Loaded value is not encrypted, return as is
+                if len(value) > 0:
+                    self.save(key, value)
+                return value
+        elif [param for param in self._DEFAULT_CONFIG[self._section] if param[0] == key and param[1] == 'bool']:
+            return True if len(res) and res[0].strip('\'"').lower() == 'true' else False
+        else:
+            return res[0].strip('\'"') if len(res) > 0 else False
+
+    def save(self, key, value):
+        self._set_to_config(self._section, key, value)
+        return
+
+    def get(self, key):
+        return self._get_from_config(self.__config__, key)
+
+
+def get_clean_hostnames(shared_state):
+    hostnames = Config('Hostnames')
+    set_hostnames = {}
+
+    def clean_up_hostname(host, strg, hostnames):
+        if strg and '/' in strg:
+            strg = strg.replace('https://', '').replace('http://', '')
+            strg = re.findall(r'([a-z-.]*\.[a-z]*)', strg)[0]
+            hostnames.save(host, strg)
+        if strg and re.match(r'.*[A-Z].*', strg):
+            hostnames.save(host, strg.lower())
+        if strg:
+            print(f'Using "{strg}" as hostname for "{host}"')
+        return strg
+
+    for name in shared_state.values["sites"]:
+        name = name.lower()
+        hostname = clean_up_hostname(name, hostnames.get(name), hostnames)
+        if hostname:
+            set_hostnames[name] = hostname
+
+    return set_hostnames