quasarr 1.20.6__py3-none-any.whl

quasarr/search/sources/dw.py

@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import datetime
+import re
+import time
+from base64 import urlsafe_b64encode
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info, debug
+
+hostname = "dw"
+supported_mirrors = ["1fichier", "rapidgator", "ddownload", "katfile"]
+
+
+def convert_to_rss_date(date_str):
+    german_months = ["Januar", "Februar", "März", "April", "Mai", "Juni",
+                     "Juli", "August", "September", "Oktober", "November", "Dezember"]
+    english_months = ["January", "February", "March", "April", "May", "June",
+                      "July", "August", "September", "October", "November", "December"]
+
+    for german, english in zip(german_months, english_months):
+        if german in date_str:
+            date_str = date_str.replace(german, english)
+            break
+
+    parsed_date = datetime.datetime.strptime(date_str, '%d. %B %Y / %H:%M')
+    rss_date = parsed_date.strftime('%a, %d %b %Y %H:%M:%S %z')
+
+    return rss_date
+
+
+def extract_size(text):
+    # First try the normal pattern: number + space + unit (e.g., "1024 MB")
+    match = re.match(r"(\d+)\s+([A-Za-z]+)", text)
+    if match:
+        size = match.group(1)
+        unit = match.group(2)
+        return {"size": size, "sizeunit": unit}
+
+    # If that fails, try pattern with just unit (e.g., "MB")
+    unit_match = re.match(r"([A-Za-z]+)", text.strip())
+    if unit_match:
+        unit = unit_match.group(1)
+        # Fall back to 0 when size is missing
+        return {"size": "0", "sizeunit": unit}
+
+    # If neither pattern matches, raise the original error
+    raise ValueError(f"Invalid size format: {text}")
+
+
+def dw_feed(shared_state, start_time, request_from, mirror=None):
+    releases = []
+    dw = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = dw
+
+    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:
+        feed_type = "videos/filme/"
+    else:
+        feed_type = "videos/serien/"
+
+    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://{dw}/{feed_type}'
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    try:
+        request = requests.get(url, headers=headers, timeout=10).content
+        feed = BeautifulSoup(request, "html.parser")
+        articles = feed.find_all('h4')
+
+        for article in articles:
+            try:
+                source = article.a["href"]
+                title = article.a.text.strip()
+
+                try:
+                    imdb_id = re.search(r'tt\d+', str(article)).group()
+                except:
+                    imdb_id = None
+
+                size_info = article.find("span").text.strip()
+                size_item = extract_size(size_info)
+                mb = shared_state.convert_to_mb(size_item)
+                size = mb * 1024 * 1024
+                date = article.parent.parent.find("span", {"class": "date updated"}).text.strip()
+                published = convert_to_rss_date(date)
+                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 Exception as e:
+                info(f"Error parsing {hostname.upper()} feed: {e}")
+                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 loading {hostname.upper()} feed: {e}")
+
+    elapsed_time = time.time() - start_time
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
+
+    return releases
+
+
+def dw_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
+    releases = []
+    dw = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = dw
+
+    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:
+        search_type = "videocategory=filme"
+    else:
+        search_type = "videocategory=serien"
+
+    if mirror and mirror not in ["1fichier", "rapidgator", "ddownload", "katfile"]:
+        debug(f'Mirror "{mirror}" not not supported by {hostname.upper()}. Skipping search!')
+        return releases
+
+    url = f'https://{dw}/?s={search_string}&{search_type}'
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    try:
+        request = requests.get(url, headers=headers, timeout=10).content
+        search = BeautifulSoup(request, "html.parser")
+        results = search.find_all('h4')
+
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} search feed: {e}")
+        return releases
+
+    imdb_id = shared_state.is_imdb_id(search_string)
+
+    if results:
+        for result in results:
+            try:
+                title = result.a.text.strip()
+
+                if not shared_state.is_valid_release(title,
+                                                                     request_from,
+                                                                     search_string,
+                                                                     season,
+                                                                     episode):
+                    continue
+
+                if not imdb_id:
+                    try:
+                        imdb_id = re.search(r'tt\d+', str(result)).group()
+                    except:
+                        imdb_id = None
+
+                source = result.a["href"]
+                size_info = result.find("span").text.strip()
+                size_item = extract_size(size_info)
+                mb = shared_state.convert_to_mb(size_item)
+                size = mb * 1024 * 1024
+                date = result.parent.parent.find("span", {"class": "date updated"}).text.strip()
+                published = convert_to_rss_date(date)
+                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 Exception as e:
+                info(f"Error parsing {hostname.upper()} search: {e}")
+                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"
+            })
+
+    elapsed_time = time.time() - start_time
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
+
+    return releases

quasarr/search/sources/fx.py

@@ -0,0 +1,223 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# 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+)\s*([A-Za-z]+)", text)
+    if match:
+        size = match.group(1)
+        unit = match.group(2)
+        return {"size": size, "sizeunit": unit}
+    else:
+        raise ValueError(f"Invalid size format: {text}")
+
+
+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!')
+        return releases
+
+    password = fx.split(".")[0]
+    url = f'https://{fx}/'
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    try:
+        request = requests.get(url, headers=headers, timeout=10).content
+        feed = BeautifulSoup(request, "html.parser")
+        items = feed.find_all("article")
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} feed: {e}")
+        return releases
+
+    if items:
+        for item in items:
+            try:
+                article = BeautifulSoup(str(item), "html.parser")
+                try:
+                    source = article.find('h2', class_='entry-title').a["href"]
+                    titles = article.find_all("a", href=re.compile("(filecrypt|safe." + fx + ")"))
+                except:
+                    continue
+                i = 0
+                for title in titles:
+                    link = title["href"]
+                    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.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}|{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.find_all("time")
+                        for date in dates:
+                            published = date["datetime"]
+                    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 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
+
+    url = f'https://{fx}/?s={search_string}'
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    try:
+        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:
+        info(f"Error loading {hostname.upper()} feed: {e}")
+        return releases
+
+    if results:
+        for result in results:
+            try:
+                result_source = result["href"]
+                request = requests.get(result_source, headers=headers, timeout=10).content
+                feed = BeautifulSoup(request, "html.parser")
+                items = feed.find_all("article")
+            except Exception as 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.find_all("a", href=re.compile(r"filecrypt\."))
+                    except:
+                        continue
+                    i = 0
+                    for title in titles:
+                        link = title["href"]
+                        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.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}|{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.find_all("time")
+                            for date in dates:
+                                published = date["datetime"]
+                        except:
+                            continue
+
+                        releases.append({
+                            "details": {
+                                "title": title,
+                                "hostname": hostname.lower(),
+                                "imdb_id": imdb_id,
+                                "link": link,
+                                "mirror": mirror,
+                                "size": size,
+                                "date": published,
+                                "source": result_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

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