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

quasarr/downloads/sources/by.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import concurrent.futures
+import re
+import time
+from urllib.parse import urlparse
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info, debug
+
+
+def get_by_download_links(shared_state, url, mirror, title):  # signature must align with other download link functions!
+    by = shared_state.values["config"]("Hostnames").get("by")
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    mirror_lower = mirror.lower() if mirror else None
+    links = []
+
+    try:
+        resp = requests.get(url, headers=headers, timeout=10)
+        page_content = resp.text
+        soup = BeautifulSoup(page_content, "html.parser")
+        frames = [iframe.get("src") for iframe in soup.find_all("iframe") if iframe.get("src")]
+
+        frame_urls = [src for src in frames if f'https://{by}' in src]
+        if not frame_urls:
+            debug(f"No iframe hosts found on {url} for {title}.")
+            return []
+
+        async_results = []
+
+        def fetch(url):
+            try:
+                r = requests.get(url, headers=headers, timeout=10)
+                return r.text, url
+            except Exception:
+                info(f"Error fetching iframe URL: {url}")
+                return None, url
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+            future_to_url = {executor.submit(fetch, url): url for url in frame_urls}
+            for future in concurrent.futures.as_completed(future_to_url):
+                content, source = future.result()
+                if content:
+                    async_results.append((content, source))
+
+        url_hosters = []
+        for content, source in async_results:
+            host_soup = BeautifulSoup(content, "html.parser")
+            link = host_soup.find("a", href=re.compile(
+                r"https?://(?:www\.)?(?:hide\.cx|filecrypt\.(?:cc|co|to))/container/"))
+
+            # Fallback to the old format
+            if not link:
+                link = host_soup.find("a", href=re.compile(r"/go\.php\?"))
+
+            if not link:
+                continue
+
+            href = link["href"]
+            hostname = link.text.strip().replace(" ", "")
+            hostname_lower = hostname.lower()
+
+            if mirror_lower and mirror_lower not in hostname_lower:
+                debug(f'Skipping link from "{hostname}" (not the desired mirror "{mirror}")!')
+                continue
+
+            url_hosters.append((href, hostname))
+
+        def resolve_redirect(href_hostname):
+            href, hostname = href_hostname
+            try:
+                r = requests.get(href, headers=headers, timeout=10, allow_redirects=True)
+                if "/404.html" in r.url:
+                    info(f"Link leads to 404 page for {hostname}: {r.url}")
+                    return None
+                time.sleep(1)
+                return r.url
+            except Exception as e:
+                info(f"Error resolving link for {hostname}: {e}")
+                return None
+
+        for pair in url_hosters:
+            resolved_url = resolve_redirect(pair)
+            hostname = pair[1]
+
+            if not hostname:
+                hostname = urlparse(resolved_url).hostname
+
+            if resolved_url and hostname and hostname.startswith(("ddownload", "rapidgator", "turbobit", "filecrypt")):
+                if "rapidgator" in hostname:
+                    links.insert(0, [resolved_url, hostname])
+                else:
+                    links.append([resolved_url, hostname])
+
+
+    except Exception as e:
+        info(f"Error loading BY download links: {e}")
+
+    return links

quasarr/downloads/sources/dd.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+from quasarr.providers.log import info, debug
+from quasarr.providers.sessions.dd import create_and_persist_session, retrieve_and_validate_session
+
+
+def get_dd_download_links(shared_state, url, mirror, title): # signature must align with other download link functions!
+    dd = shared_state.values["config"]("Hostnames").get("dd")
+
+    dd_session = retrieve_and_validate_session(shared_state)
+    if not dd_session:
+        info(f"Could not retrieve valid session for {dd}")
+        return []
+
+    links = []
+
+    qualities = [
+        "disk-480p",
+        "web-480p",
+        "movie-480p-x265",
+        "disk-1080p-x265",
+        "web-1080p",
+        "web-1080p-x265",
+        "web-2160p-x265-hdr",
+        "movie-1080p-x265",
+        "movie-2160p-webdl-x265-hdr"
+    ]
+
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    try:
+        release_list = []
+        for page in range(0, 100, 20):
+            url = f'https://{dd}/index/search/keyword/{title}/qualities/{','.join(qualities)}/from/{page}/search'
+
+            releases_on_page = dd_session.get(url, headers=headers, timeout=10).json()
+            if releases_on_page:
+                release_list.extend(releases_on_page)
+
+        for release in release_list:
+            try:
+                if release.get("fake"):
+                    debug(f"Release {release.get('release')} marked as fake. Invalidating DD session...")
+                    create_and_persist_session(shared_state)
+                    return []
+                elif release.get("release") == title:
+                    filtered_links = []
+                    for link in release["links"]:
+                        if mirror and mirror not in link["hostname"]:
+                            debug(f'Skipping link from "{link["hostname"]}" (not the desired mirror "{mirror}")!')
+                            continue
+
+                        if any(
+                                existing_link["hostname"] == link["hostname"] and
+                                existing_link["url"].endswith(".mkv") and
+                                link["url"].endswith(".mkv")
+                                for existing_link in filtered_links
+                        ):
+                            debug(f"Skipping duplicate `.mkv` link from {link['hostname']}")
+                            continue  # Skip adding duplicate `.mkv` links from the same hostname
+                        filtered_links.append(link)
+
+                    links = [link["url"] for link in filtered_links]
+                    break
+            except Exception as e:
+                info(f"Error parsing DD download: {e}")
+                continue
+
+    except Exception as e:
+        info(f"Error loading DD download: {e}")
+
+    return links

quasarr/downloads/sources/dj.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+
+def get_dj_download_links(shared_state, url, mirror, title):  # signature must align with other download link functions!
+    return [url]

quasarr/downloads/sources/dl.py

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info, debug
+from quasarr.providers.sessions.dl import retrieve_and_validate_session, fetch_via_requests_session, invalidate_session
+
+hostname = "dl"
+
+
+def extract_password_from_post(soup, host):
+    """
+    Extract password from forum post using multiple strategies.
+    Returns empty string if no password found or if explicitly marked as 'no password'.
+    """
+    # Get flattened text from the post - collapse whitespace to single spaces
+    post_text = soup.get_text()
+    post_text = re.sub(r'\s+', ' ', post_text).strip()
+
+    # Strategy 1: Look for password label followed by the password value
+    # Pattern: "Passwort:" followed by optional separators, then the password
+    password_pattern = r'(?:passwort|password|pass|pw)[\s:]+([a-zA-Z0-9._-]{2,50})'
+    match = re.search(password_pattern, post_text, re.IGNORECASE)
+
+    if match:
+        password = match.group(1).strip()
+        # Skip if it looks like a section header or common word
+        if not re.match(r'^(?:download|mirror|link|episode|info|mediainfo|spoiler|hier|click|klick|kein|none|no)',
+                        password, re.IGNORECASE):
+            debug(f"Found password: {password}")
+            return password
+
+    # Strategy 2: Look for explicit "no password" indicators (only if no valid password found)
+    no_password_patterns = [
+        r'(?:passwort|password|pass|pw)[\s:]*(?:kein(?:es)?|none|no|nicht|not|nein|-|–|—)',
+        r'(?:kein(?:es)?|none|no|nicht|not|nein)\s*(?:passwort|password|pass|pw)',
+    ]
+
+    for pattern in no_password_patterns:
+        if re.search(pattern, post_text, re.IGNORECASE):
+            debug("No password required (explicitly stated)")
+            return ""
+
+    # Strategy 3: Default to hostname-based password
+    default_password = f"www.{host}"
+    debug(f"No password found, using default: {default_password}")
+    return default_password
+
+
+def extract_mirror_name_from_link(link_element):
+    """
+    Extract the mirror/hoster name from the link text or nearby text.
+    Returns the extracted name or None.
+    """
+    # Get the link text
+    link_text = link_element.get_text(strip=True)
+
+    # Try to extract a meaningful name from the link text
+    # Look for text that looks like a hoster name (alphanumeric, may contain numbers/dashes)
+    # Filter out common non-hoster words
+    common_non_hosters = {'download', 'mirror', 'link', 'hier', 'click', 'klick', 'code', 'spoiler'}
+
+    # Clean and extract potential mirror name
+    if link_text and len(link_text) > 2:
+        # Remove common symbols and whitespace
+        cleaned = re.sub(r'[^\w\s-]', '', link_text).strip().lower()
+
+        # If it's a single word or hyphenated word and not in common non-hosters
+        if cleaned and cleaned not in common_non_hosters:
+            # Extract the main part (first word if multiple)
+            main_part = cleaned.split()[0] if ' ' in cleaned else cleaned
+            if len(main_part) > 2:  # Must be at least 3 characters
+                return main_part
+
+    # Check if there's a bold tag or nearby text in parent
+    parent = link_element.parent
+    if parent:
+        parent_text = parent.get_text(strip=True)
+        # Look for text before the link that might be the mirror name
+        for sibling in link_element.previous_siblings:
+            if hasattr(sibling, 'get_text'):
+                sibling_text = sibling.get_text(strip=True).lower()
+                if sibling_text and len(sibling_text) > 2 and sibling_text not in common_non_hosters:
+                    cleaned = re.sub(r'[^\w\s-]', '', sibling_text).strip()
+                    if cleaned:
+                        return cleaned.split()[0] if ' ' in cleaned else cleaned
+
+    return None
+
+
+def extract_links_and_password_from_post(post_content, host):
+    """
+    Extract download links and password from a forum post.
+    Only filecrypt and hide are supported - other link crypters will cause an error.
+
+    Returns:
+        tuple of (links, password) where:
+        - links: list of [url, mirror_name] pairs where mirror_name is the actual hoster
+        - password: extracted password string
+    """
+    links = []
+    soup = BeautifulSoup(post_content, 'html.parser')
+
+    for link in soup.find_all('a', href=True):
+        href = link.get('href')
+
+        # Skip internal forum links
+        if href.startswith('/') or host in href:
+            continue
+
+        # Check supported link crypters
+        if re.search(r'filecrypt\.', href, re.IGNORECASE):
+            crypter_type = "filecrypt"
+        elif re.search(r'hide\.', href, re.IGNORECASE):
+            crypter_type = "hide"
+        elif re.search(r'keeplinks\.', href, re.IGNORECASE):
+            crypter_type = "keeplinks"
+        elif re.search(r'tolink\.', href, re.IGNORECASE):
+            crypter_type = "tolink"
+        else:
+            debug(f"Unsupported link crypter/hoster found: {href}")
+            debug(f"Currently only filecrypt and hide are supported. Other crypters may be added later.")
+            continue
+
+        # Extract mirror name from link text or nearby context
+        mirror_name = extract_mirror_name_from_link(link)
+
+        # Use mirror name if found, otherwise fall back to crypter type
+        identifier = mirror_name if mirror_name else crypter_type
+
+        # Avoid duplicates
+        if [href, identifier] not in links:
+            links.append([href, identifier])
+            if mirror_name:
+                debug(f"Found {crypter_type} link for mirror: {mirror_name}")
+            else:
+                debug(f"Found {crypter_type} link (no mirror name detected)")
+
+    # Only extract password if we found links
+    password = ""
+    if links:
+        password = extract_password_from_post(soup, host)
+
+    return links, password
+
+
+def get_dl_download_links(shared_state, url, mirror, title):
+    """
+    Get download links from a thread.
+
+    Returns:
+        tuple of (links, password) where:
+        - links: list of [url, mirror_name] pairs
+        - password: extracted password string
+    """
+    host = shared_state.values["config"]("Hostnames").get(hostname)
+
+    sess = retrieve_and_validate_session(shared_state)
+    if not sess:
+        info(f"Could not retrieve valid session for {host}")
+        return [], ""
+
+    try:
+        response = fetch_via_requests_session(shared_state, method="GET", target_url=url, timeout=30)
+
+        if response.status_code != 200:
+            info(f"Failed to load thread page: {url} (Status: {response.status_code})")
+            return [], ""
+
+        soup = BeautifulSoup(response.text, 'html.parser')
+
+        first_post = soup.select_one('article.message--post')
+        if not first_post:
+            info(f"Could not find first post in thread: {url}")
+            return [], ""
+
+        post_content = first_post.select_one('div.bbWrapper')
+        if not post_content:
+            info(f"Could not find post content in thread: {url}")
+            return [], ""
+
+        # Extract both links and password from the same post content
+        links, password = extract_links_and_password_from_post(str(post_content), host)
+
+        if not links:
+            info(f"No supported download links found in thread: {url}")
+            return [], ""
+
+        debug(f"Found {len(links)} download link(s) for: {title} (password: {password})")
+        return links, password
+
+    except Exception as e:
+        info(f"Error extracting download links from {url}: {e}")
+        invalidate_session(shared_state)
+        return [], ""

quasarr/downloads/sources/dt.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+import requests
+from bs4 import BeautifulSoup
+from quasarr.providers.log import info
+
+
+def get_dt_download_links(shared_state, url, mirror, title): # signature must align with other download link functions!
+    headers = {"User-Agent": shared_state.values["user_agent"]}
+    session = requests.Session()
+
+    try:
+        resp = session.get(url, headers=headers, timeout=10)
+        soup = BeautifulSoup(resp.text, "html.parser")
+
+        article = soup.find("article")
+        if not article:
+            info(f"Could not find article block on DT page for {title}")
+            return False
+        body = article.find("div", class_="card-body")
+        if not body:
+            info(f"Could not find download section for {title}")
+            return False
+
+        # grab all <a href="…">
+        anchors = body.find_all("a", href=True)
+
+    except Exception as e:
+        info(f"DT site has been updated. Grabbing download links for {title} not possible! ({e})")
+        return False
+
+    # first do your normal filtering
+    filtered = []
+    for a in anchors:
+        href = a["href"].strip()
+
+        if not href.lower().startswith(("http://", "https://")):
+            continue
+        lower = href.lower()
+        if "imdb.com" in lower or "?ref=" in lower:
+            continue
+        if mirror and mirror not in href:
+            continue
+
+        filtered.append(href)
+
+    # if after filtering you got nothing, fall back to regex
+    if not filtered:
+        text = body.get_text(separator="\n")
+        urls = re.findall(r'https?://[^\s<>"\']+', text)
+        # de-dupe preserving order
+        seen = set()
+        for u in urls:
+            u = u.strip()
+            if u not in seen:
+                seen.add(u)
+                # apply same filters
+                low = u.lower()
+                if low.startswith(("http://", "https://")) and "imdb.com" not in low and "?ref=" not in low:
+                    if not mirror or mirror in u:
+                        filtered.append(u)
+
+    return filtered

quasarr/downloads/sources/dw.py

@@ -7,8 +7,10 @@ import re
 import requests
 from bs4 import BeautifulSoup
 
+from quasarr.providers.log import info, debug
 
-def get_dw_download_links(shared_state, url, title):
+
+def get_dw_download_links(shared_state, url, mirror, title): # signature must align with other download link functions!
     dw = shared_state.values["config"]("Hostnames").get("dw")
     ajax_url = "https://" + dw + "/wp-admin/admin-ajax.php"
 
@@ -19,11 +21,11 @@ def get_dw_download_links(shared_state, url, title):
     session = requests.Session()
 
     try:
-        request = session.get(url, headers=headers)
+        request = session.get(url, headers=headers, timeout=10)
         content = BeautifulSoup(request.text, "html.parser")
-        download_buttons = content.findAll("button", {"class": "show_link"})
+        download_buttons = content.find_all("button", {"class": "show_link"})
     except:
-        print(f"DW site has been updated. Grabbing download links for {title} not possible!")
+        info(f"DW site has been updated. Grabbing download links for {title} not possible!")
         return False
 
     download_links = []
@@ -35,9 +37,9 @@ def get_dw_download_links(shared_state, url, title):
                 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
             }
 
-            response = session.post(ajax_url, payload, headers=headers)
+            response = session.post(ajax_url, payload, headers=headers, timeout=10)
             if response.status_code != 200:
-                print(f"DW site has been updated. Grabbing download links for {title} not possible!")
+                info(f"DW site has been updated. Grabbing download links for {title} not possible!")
                 continue
             else:
                 response = response.json()
@@ -50,9 +52,14 @@ def get_dw_download_links(shared_state, url, title):
                                 f'.html{match.group(2) if match.group(2) else ""}')
 
                 hoster = button.nextSibling.img["src"].split("/")[-1].replace(".png", "")
+                hoster = f"1fichier" if hoster.startswith("fichier") else hoster  # align with expected mirror name
+                if mirror and mirror.lower() not in hoster.lower():
+                    debug(f'Skipping link from "{hoster}" (not the desired mirror "{mirror}")!')
+                    continue
+
                 download_links.append([link, hoster])
     except:
-        print(f"DW site has been updated. Parsing download links for {title} not possible!")
+        info(f"DW site has been updated. Parsing download links for {title} not possible!")
         pass
 
     return download_links

quasarr/downloads/sources/he.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+from urllib.parse import urlparse, urljoin
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info, debug
+
+hostname = "he"
+
+
+def get_he_download_links(shared_state, url, mirror, title):
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    session = requests.Session()
+
+    try:
+        resp = session.get(url, headers=headers, timeout=30)
+        soup = BeautifulSoup(resp.text, 'html.parser')
+    except Exception as e:
+        info(f"{hostname}: could not fetch release for {title}: {e}")
+        return False
+
+    imdb_id = None
+    try:
+        imdb_link = soup.find('a', href=re.compile(r"imdb\.com/title/tt\d+", re.IGNORECASE))
+        if imdb_link:
+            href = imdb_link['href'].strip()
+            m = re.search(r"(tt\d{4,7})", href)
+            if m:
+                imdb_id = m.group(1)
+            else:
+                debug(f"{hostname}: imdb_id not found for title {title} in link href.")
+        else:
+            debug(f"{hostname}: imdb_id link href not found for title {title}.")
+    except Exception:
+        debug(f"{hostname}: failed to extract imdb_id for title {title}.")
+
+    anchors = []
+    for retries in range(10):
+        form = soup.find('form', id=re.compile(r'content-protector-access-form'))
+        if not form:
+            return False
+
+        action = form.get('action') or url
+        action_url = urljoin(resp.url, action)
+
+        payload = {}
+        for inp in form.find_all('input'):
+            name = inp.get('name')
+            if not name:
+                continue
+            value = inp.get('value', '')
+            payload[name] = value
+
+        append_patt = re.compile(r"append\(\s*[\'\"](?P<key>[^\'\"]+)[\'\"]\s*,\s*[\'\"](?P<val>[^\'\"]+)[\'\"]\s*\)",
+                                 re.IGNORECASE)
+
+        for script in soup.find_all('script'):
+            txt = script.string if script.string is not None else script.get_text()
+            if not txt:
+                continue
+            for m in append_patt.finditer(txt):
+                payload[m.group('key')] = m.group('val')
+
+        post_headers = headers.copy()
+        post_headers.update({'Referer': resp.url})
+        try:
+            resp = session.post(action_url, data=payload, headers=post_headers, timeout=30)
+            soup = BeautifulSoup(resp.text, 'html.parser')
+        except Exception as e:
+            info(f"{hostname}: could not submit protector form for {title}: {e}")
+            break
+
+        unlocked = soup.select('.content-protector-access-form')
+        if unlocked:
+            for u in unlocked:
+                anchors.extend(u.find_all('a', href=True))
+
+        if anchors:
+            break
+
+    links = []
+    for a in anchors:
+        try:
+            href = a['href'].strip()
+
+            netloc = urlparse(href).netloc
+            hoster = netloc.split(':')[0].lower()
+            parts = hoster.split('.')
+            if len(parts) >= 2:
+                hoster = parts[-2]
+
+            links.append([href, hoster])
+        except Exception:
+            debug(f"{hostname}: could not resolve download link hoster for {title}")
+            continue
+
+    if not links:
+        info(f"No external download links found on {hostname} page for {title}")
+        return False
+
+    return {
+        "links": links,
+        "imdb_id": imdb_id,
+    }

quasarr/downloads/sources/mb.py

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info, debug
+
+
+def get_mb_download_links(shared_state, url, mirror, title): # signature must align with other download link functions!
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    try:
+        response = requests.get(url, headers=headers, timeout=10)
+        response.raise_for_status()
+    except Exception as e:
+        info(f"Failed to fetch page for {title or url}: {e}")
+        return False
+
+    soup = BeautifulSoup(response.text, "html.parser")
+
+    download_links = []
+
+    pattern = re.compile(r'https?://(?:www\.)?filecrypt\.[^/]+/Container/', re.IGNORECASE)
+    for a in soup.find_all('a', href=pattern):
+        try:
+            link = a['href']
+            hoster = a.get_text(strip=True).lower()
+
+            if mirror and mirror.lower() not in hoster.lower():
+                debug(f'Skipping link from "{hoster}" (not the desired mirror "{mirror}")!')
+                continue
+
+            download_links.append([link, hoster])
+        except Exception as e:
+            debug(f"Error parsing MB download links: {e}")
+
+    if not download_links:
+        info(f"No download links found for {title}. Site structure may have changed. - {url}")
+        return False
+
+    return download_links