quasarr 1.20.6__py3-none-any.whl

quasarr/downloads/sources/sf.py

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info, debug
+from quasarr.search.sources.sf import parse_mirrors
+
+
+def is_last_section_integer(url):
+    last_section = url.rstrip('/').split('/')[-1]
+    if last_section.isdigit() and len(last_section) <= 3:
+        return int(last_section)
+    return None
+
+
+def get_sf_download_links(shared_state, url, mirror, title):  # signature must align with other download link functions!
+    release_pattern = re.compile(
+        r'''
+          ^                                   # start of string
+          (?P<name>.+?)\.                     # show name (dots in name) up to the dot before “S”
+          S(?P<season>\d+)                    # “S” + season number
+          (?:E\d+(?:-E\d+)?)?                 # optional “E##” or “E##-E##”
+          \.                                  # literal dot
+          .*?\.                               # anything (e.g. language/codec) up to next dot
+          (?P<resolution>\d+p)                # resolution “720p”, “1080p”, etc.
+          \..+?                               # dot + more junk (e.g. “.WEB.h264”)
+          -(?P<group>\w+)                     # dash + release group at end
+          $                                   # end of string
+        ''',
+        re.IGNORECASE | re.VERBOSE
+    )
+
+    release_match = release_pattern.match(title)
+
+    if not release_match:
+        return {
+            "real_url": None,
+            "imdb_id": None,
+        }
+
+    release_parts = release_match.groupdict()
+
+    season = is_last_section_integer(url)
+    try:
+        if not season:
+            season = "ALL"
+
+        sf = shared_state.values["config"]("Hostnames").get("sf")
+        headers = {
+            'User-Agent': shared_state.values["user_agent"],
+        }
+
+        series_page = requests.get(url, headers=headers, timeout=10).text
+
+        soup = BeautifulSoup(series_page, "html.parser")
+        # extract IMDb id if present
+        imdb_id = None
+        a_imdb = soup.find("a", href=re.compile(r"imdb\.com/title/tt\d+"))
+        if a_imdb:
+            m = re.search(r"(tt\d+)", a_imdb["href"])
+            if m:
+                imdb_id = m.group(1)
+                debug(f"Found IMDb id: {imdb_id}")
+
+        season_id = re.findall(r"initSeason\('(.+?)\',", series_page)[0]
+        epoch = str(datetime.now().timestamp()).replace('.', '')[:-3]
+        api_url = 'https://' + sf + '/api/v1/' + season_id + f'/season/{season}?lang=ALL&_=' + epoch
+
+        response = requests.get(api_url, headers=headers, timeout=10)
+        try:
+            data = response.json()["html"]
+        except ValueError:
+            epoch = str(datetime.now().timestamp()).replace('.', '')[:-3]
+            api_url = 'https://' + sf + '/api/v1/' + season_id + f'/season/ALL?lang=ALL&_=' + epoch
+            response = requests.get(api_url, headers=headers, timeout=10)
+            data = response.json()["html"]
+
+        content = BeautifulSoup(data, "html.parser")
+
+        items = content.find_all("h3")
+
+        for item in items:
+            try:
+                details = item.parent.parent.parent
+                name = details.find("small").text.strip()
+
+                result_pattern = re.compile(
+                    r'^(?P<name>.+?)\.S(?P<season>\d+)(?:E\d+)?\..*?(?P<resolution>\d+p)\..+?-(?P<group>[\w/-]+)$',
+                    re.IGNORECASE
+                )
+                result_match = result_pattern.match(name)
+
+                if not result_match:
+                    continue
+
+                result_parts = result_match.groupdict()
+
+                # Normalize all relevant fields for case-insensitive comparison
+                name_match = release_parts['name'].lower() == result_parts['name'].lower()
+                season_match = release_parts['season'] == result_parts['season']  # Numbers are case-insensitive
+                resolution_match = release_parts['resolution'].lower() == result_parts['resolution'].lower()
+
+                # Handle multiple groups and case-insensitive matching
+                result_groups = {g.lower() for g in result_parts['group'].split('/')}
+                release_groups = {g.lower() for g in release_parts['group'].split('/')}
+                group_match = not result_groups.isdisjoint(release_groups)  # Checks if any group matches
+
+                if name_match and season_match and resolution_match and group_match:
+                    info(f'Release "{name}" found on SF at: {url}')
+
+                    mirrors = parse_mirrors(f"https://{sf}", details)
+
+                    if mirror:
+                        if mirror not in mirrors["season"]:
+                            continue
+                        release_url = mirrors["season"][mirror]
+                        if not release_url:
+                            info(f"Could not find mirror '{mirror}' for '{title}'")
+                    else:
+                        release_url = next(iter(mirrors["season"].values()))
+
+                    real_url = resolve_sf_redirect(release_url, shared_state.values["user_agent"])
+                    return {
+                        "real_url": real_url,
+                        "imdb_id": imdb_id,
+                    }
+            except:
+                continue
+    except:
+        pass
+
+    return {
+        "real_url": None,
+        "imdb_id": None,
+    }
+
+
+def resolve_sf_redirect(url, user_agent):
+    try:
+        response = requests.get(url, allow_redirects=True, timeout=10,
+                                headers={'User-Agent': user_agent})
+        if response.history:
+            for resp in response.history:
+                debug(f"Redirected from {resp.url} to {response.url}")
+            if "/404.html" in response.url:
+                info(f"SF link redirected to 404 page: {response.url}")
+                return None
+            return response.url
+        else:
+            info(f"SF blocked attempt to resolve {url}. Your IP may be banned. Try again later.")
+    except Exception as e:
+        info(f"Error fetching redirected URL for {url}: {e}")
+    return None

quasarr/downloads/sources/sj.py

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

quasarr/downloads/sources/sl.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+from urllib.parse import urlparse
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info, debug
+
+supported_mirrors = ["nitroflare", "ddownload"]  # ignoring captcha-protected multiup/mirrorace for now
+
+
+def get_sl_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")
+
+        entry = soup.find("div", class_="entry")
+        if not entry:
+            info(f"Could not find main content section for {title}")
+            return False
+
+        # extract IMDb id if present
+        imdb_id = None
+        a_imdb = soup.find("a", href=re.compile(r"imdb\.com/title/tt\d+"))
+        if a_imdb:
+            m = re.search(r"(tt\d+)", a_imdb["href"])
+            if m:
+                imdb_id = m.group(1)
+                debug(f"Found IMDb id: {imdb_id}")
+
+        download_h2 = entry.find(
+            lambda t: t.name == "h2" and "download" in t.get_text(strip=True).lower()
+        )
+        if download_h2:
+            anchors = []
+            for sib in download_h2.next_siblings:
+                if getattr(sib, "name", None) == "h2":
+                    break
+                if hasattr(sib, "find_all"):
+                    anchors += sib.find_all("a", href=True)
+        else:
+            anchors = entry.find_all("a", href=True)
+
+    except Exception as e:
+        info(f"SL site has been updated. Grabbing download links for {title} not possible! ({e})")
+        return False
+
+    filtered = []
+    for a in anchors:
+        href = a["href"].strip()
+        if not href.lower().startswith(("http://", "https://")):
+            continue
+
+        host = (urlparse(href).hostname or "").lower()
+        # require host to start with one of supported_mirrors + "."
+        if not any(host.startswith(m + ".") for m in supported_mirrors):
+            continue
+
+        if not mirror or mirror in href:
+            filtered.append(href)
+
+    # regex‐fallback if still empty
+    if not filtered:
+        text = "".join(str(x) for x in anchors)
+        urls = re.findall(r"https?://[^\s<>'\"]+", text)
+        seen = set()
+        for u in urls:
+            u = u.strip()
+            if u in seen:
+                continue
+            seen.add(u)
+
+            host = (urlparse(u).hostname or "").lower()
+            if not any(host.startswith(m + ".") for m in supported_mirrors):
+                continue
+
+            if not mirror or mirror in u:
+                filtered.append(u)
+
+    return {
+        "links": filtered,
+        "imdb_id": imdb_id,
+    }

quasarr/downloads/sources/wd.py

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+from urllib.parse import urljoin
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.cloudflare import flaresolverr_get, is_cloudflare_challenge
+from quasarr.providers.log import info, debug
+
+
+def resolve_wd_redirect(url, user_agent):
+    """
+    Follow redirects for a WD mirror URL and return the final destination.
+    """
+    try:
+        response = requests.get(
+            url,
+            allow_redirects=True,
+            timeout=10,
+            headers={"User-Agent": user_agent},
+        )
+        if response.history:
+            for resp in response.history:
+                debug(f"Redirected from {resp.url} to {response.url}")
+            return response.url
+        else:
+            info(f"WD blocked attempt to resolve {url}. Your IP may be banned. Try again later.")
+    except Exception as e:
+        info(f"Error fetching redirected URL for {url}: {e}")
+    return None
+
+
+def get_wd_download_links(shared_state, url, mirror, title):  # signature must align with other download link functions!
+    wd = shared_state.values["config"]("Hostnames").get("wd")
+    user_agent = shared_state.values["user_agent"]
+
+    try:
+        output = requests.get(url)
+        if output.status_code == 403 or is_cloudflare_challenge(output.text):
+            info("WD is protected by Cloudflare. Using FlareSolverr to bypass protection.")
+            output = flaresolverr_get(shared_state, url)
+
+        soup = BeautifulSoup(output.text, "html.parser")
+
+        # extract IMDb id if present
+        imdb_id = None
+        a_imdb = soup.find("a", href=re.compile(r"imdb\.com/title/tt\d+"))
+        if a_imdb:
+            m = re.search(r"(tt\d+)", a_imdb["href"])
+            if m:
+                imdb_id = m.group(1)
+                debug(f"Found IMDb id: {imdb_id}")
+
+        # find Downloads card
+        header = soup.find(
+            "div",
+            class_="card-header",
+            string=re.compile(r"^\s*Downloads\s*$", re.IGNORECASE),
+        )
+        if not header:
+            info(f"WD Downloads section not found. Grabbing download links for {title} not possible!")
+            return False
+
+        card = header.find_parent("div", class_="card")
+        body = card.find("div", class_="card-body")
+        link_tags = body.find_all(
+            "a", href=True, class_=lambda c: c and "background-" in c
+        )
+    except Exception:
+        info(f"WD site has been updated. Grabbing download links for {title} not possible!")
+        return False
+
+    results = []
+    try:
+        for a in link_tags:
+            raw_href = a["href"]
+            full_link = urljoin(f"https://{wd}", raw_href)
+
+            # resolve any redirects
+            resolved = resolve_wd_redirect(full_link, user_agent)
+
+            if resolved:
+                if resolved.endswith("/404.html"):
+                    info(f"Link {resolved} is dead!")
+                    continue
+
+                # determine hoster
+                hoster = a.get_text(strip=True) or None
+                if not hoster:
+                    for cls in a.get("class", []):
+                        if cls.startswith("background-"):
+                            hoster = cls.split("-", 1)[1]
+                            break
+
+                if mirror and mirror.lower() not in hoster.lower():
+                    debug(f'Skipping link from "{hoster}" (not the desired mirror "{mirror}")!')
+                    continue
+
+                results.append([resolved, hoster])
+    except Exception:
+        info(f"WD site has been updated. Parsing download links for {title} not possible!")
+
+    return {
+        "links": results,
+        "imdb_id": imdb_id,
+    }

quasarr/providers/cloudflare.py

@@ -0,0 +1,204 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import requests
+from bs4 import BeautifulSoup
+
+
+def is_cloudflare_challenge(html: str) -> bool:
+    soup = BeautifulSoup(html, "html.parser")
+
+    # Check <title>
+    title = (soup.title.string or "").strip().lower() if soup.title else ""
+    if "just a moment" in title or "attention required" in title:
+        return True
+
+    # Check known Cloudflare elements
+    if soup.find(id="challenge-form"):
+        return True
+    if soup.find("div", {"class": "cf-browser-verification"}):
+        return True
+    if soup.find("div", {"id": "cf-challenge-running"}):
+        return True
+
+    # Check scripts referencing Cloudflare
+    for script in soup.find_all("script", src=True):
+        if "cdn-cgi/challenge-platform" in script["src"]:
+            return True
+
+    # Optional: look for Cloudflare comment or beacon
+    if "data-cf-beacon" in html or "<!-- cloudflare -->" in html.lower():
+        return True
+
+    return False
+
+
+def update_session_via_flaresolverr(info,
+                                    shared_state,
+                                    sess,
+                                    target_url: str,
+                                    timeout: int = 60):
+    flaresolverr_url = shared_state.values["config"]('FlareSolverr').get('url')
+    if not flaresolverr_url:
+        info("Cannot proceed without FlareSolverr. Please set it up to try again!")
+        return False
+
+    fs_payload = {
+        "cmd": "request.get",
+        "url": target_url,
+        "maxTimeout": timeout * 1000,
+    }
+
+    # Send the JSON request to FlareSolverr
+    fs_headers = {"Content-Type": "application/json"}
+    try:
+        resp = requests.post(
+            flaresolverr_url,
+            headers=fs_headers,
+            json=fs_payload,
+            timeout=timeout + 10
+        )
+        resp.raise_for_status()
+    except requests.exceptions.RequestException as e:
+        info(f"Could not reach FlareSolverr: {e}")
+        return {
+            "status_code": None,
+            "headers": {},
+            "json": None,
+            "text": "",
+            "cookies": [],
+            "error": f"FlareSolverr request failed: {e}"
+        }
+    except Exception as e:
+        raise RuntimeError(f"Could not reach FlareSolverr: {e}")
+
+    fs_json = resp.json()
+    if fs_json.get("status") != "ok" or "solution" not in fs_json:
+        raise RuntimeError(f"FlareSolverr did not return a valid solution: {fs_json.get('message', '<no message>')}")
+
+    solution = fs_json["solution"]
+
+    # Replace our requests.Session cookies with whatever FlareSolverr solved
+    sess.cookies.clear()
+    for ck in solution.get("cookies", []):
+        sess.cookies.set(
+            ck.get("name"),
+            ck.get("value"),
+            domain=ck.get("domain"),
+            path=ck.get("path", "/")
+        )
+    return {"session": sess, "user_agent": solution.get("userAgent", None)}
+
+
+def ensure_session_cf_bypassed(info, shared_state, session, url, headers):
+    """
+    Performs a GET and, if Cloudflare challenge or 403 is present, tries FlareSolverr.
+    Returns tuple: (session, headers, response) or (None, None, None) on failure.
+    """
+    try:
+        resp = session.get(url, headers=headers, timeout=30)
+    except requests.RequestException as e:
+        info(f"Initial GET failed: {e}")
+        return None, None, None
+
+    # If page is protected, try FlareSolverr
+    if resp.status_code == 403 or is_cloudflare_challenge(resp.text):
+        info("Encountered Cloudflare protection. Solving challenge with FlareSolverr...")
+        flaresolverr_result = update_session_via_flaresolverr(info, shared_state, session, url)
+        if not flaresolverr_result:
+            info("FlareSolverr did not return a result.")
+            return None, None, None
+
+        # update session and possibly user-agent
+        session = flaresolverr_result.get("session", session)
+        user_agent = flaresolverr_result.get("user_agent")
+        if user_agent and user_agent != shared_state.values.get("user_agent"):
+            info("Updating User-Agent from FlareSolverr solution: " + user_agent)
+            shared_state.update("user_agent", user_agent)
+            headers = {'User-Agent': shared_state.values["user_agent"]}
+
+        # re-fetch using the new session/headers
+        try:
+            resp = session.get(url, headers=headers, timeout=30)
+        except requests.RequestException as e:
+            info(f"GET after FlareSolverr failed: {e}")
+            return None, None, None
+
+        if resp.status_code == 403 or is_cloudflare_challenge(resp.text):
+            info("Could not bypass Cloudflare protection with FlareSolverr!")
+            return None, None, None
+
+    return session, headers, resp
+
+
+class FlareSolverrResponse:
+    """
+    Minimal Response-like object so it behaves like requests.Response.
+    """
+
+    def __init__(self, url, status_code, headers, text):
+        self.url = url
+        self.status_code = status_code
+        self.headers = headers or {}
+        self.text = text or ""
+        self.content = self.text.encode("utf-8")
+
+        # Cloudflare cookies are irrelevant here, but keep attribute for compatibility
+        self.cookies = requests.cookies.RequestsCookieJar()
+
+    def raise_for_status(self):
+        if 400 <= self.status_code:
+            raise requests.HTTPError(f"{self.status_code} Error for URL: {self.url}")
+
+
+def flaresolverr_get(shared_state, url, timeout=60):
+    """
+    Core function for performing a GET request via FlareSolverr only.
+    Used internally by FlareSolverrSession.get()
+    """
+    flaresolverr_url = shared_state.values["config"]('FlareSolverr').get('url')
+    if not flaresolverr_url:
+        raise RuntimeError("FlareSolverr URL not configured in shared_state.")
+
+    payload = {
+        "cmd": "request.get",
+        "url": url,
+        "maxTimeout": timeout * 1000
+    }
+
+    try:
+        resp = requests.post(
+            flaresolverr_url,
+            json=payload,
+            headers={"Content-Type": "application/json"},
+            timeout=timeout + 10
+        )
+        resp.raise_for_status()
+    except Exception as e:
+        raise RuntimeError(f"Error communicating with FlareSolverr: {e}")
+
+    data = resp.json()
+
+    if data.get("status") != "ok":
+        raise RuntimeError(f"FlareSolverr returned error: {data.get('message')}")
+
+    solution = data.get("solution", {})
+    html = solution.get("response", "")
+    status_code = solution.get("status", 200)
+    url = solution.get("url", url)
+
+    # headers → convert list-of-keyvals to dict
+    fs_headers = {h["name"]: h["value"] for h in solution.get("headers", [])}
+
+    # Update global UA if provided
+    user_agent = solution.get("userAgent")
+    if user_agent and user_agent != shared_state.values.get("user_agent"):
+        shared_state.update("user_agent", user_agent)
+
+    return FlareSolverrResponse(
+        url=url,
+        status_code=status_code,
+        headers=fs_headers,
+        text=html
+    )