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

quasarr/downloads/sources/nk.py

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info
+
+hostname = "nk"
+supported_mirrors = ["rapidgator", "ddownload"]
+
+
+def get_nk_download_links(shared_state, url, mirror, title):
+    host = shared_state.values["config"]("Hostnames").get(hostname)
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    session = requests.Session()
+
+    try:
+        resp = session.get(url, headers=headers, timeout=20)
+        soup = BeautifulSoup(resp.text, 'html.parser')
+    except Exception as e:
+        info(f"{hostname}: could not fetch release page for {title}: {e}")
+        return False
+
+    anchors = soup.select('a.btn-orange')
+    candidates = []
+    for a in anchors:
+        mirror = a.text.strip().lower()
+        if mirror == 'ddl.to':
+            mirror = 'ddownload'
+
+        if mirror not in supported_mirrors:
+            continue
+
+        href = a.get('href', '').strip()
+        if not href.lower().startswith(('http://', 'https://')):
+            href = 'https://' + host + href
+
+        try:
+            href = requests.head(href, headers=headers, allow_redirects=True, timeout=20).url
+        except Exception as e:
+            info(f"{hostname}: could not resolve download link for {title}: {e}")
+            continue
+
+        candidates.append([href, mirror])
+
+    if not candidates:
+        info(f"No external download links found on {hostname} page for {title}")
+
+    return candidates

quasarr/downloads/sources/nx.py

@@ -2,109 +2,61 @@
 # Quasarr
 # Project by https://github.com/rix1337
 
-import base64
-import pickle
 import re
 
 import requests
 from bs4 import BeautifulSoup
 
+from quasarr.providers.log import info
+from quasarr.providers.sessions.nx import retrieve_and_validate_session
 
-def create_and_persist_session(shared_state):
-    nx = shared_state.values["config"]("Hostnames").get("nx")
 
-    nx_session = requests.Session()
+def get_filer_folder_links_via_api(shared_state, url):
+    try:
+        headers = {
+            'User-Agent': shared_state.values["user_agent"],
+            'Referer': url
+        }
 
-    cookies = {}
-    headers = {
-        'User-Agent': shared_state.values["user_agent"],
-    }
+        m = re.search(r"/folder/([A-Za-z0-9]+)", url)
+        if not m:
+            return url  # not a folder URL
 
-    json_data = {
-        'username': shared_state.values["config"]("NX").get("user"),
-        'password': shared_state.values["config"]("NX").get("password")
-    }
+        folder_hash = m.group(1)
+        api_url = f"https://filer.net/api/folder/{folder_hash}"
 
-    nx_response = nx_session.post(f'https://{nx}/api/user/auth', cookies=cookies, headers=headers, json=json_data)
+        response = requests.get(api_url, headers=headers, timeout=10)
+        if not response or response.status_code != 200:
+            return url
 
-    error = False
-    if nx_response.status_code == 200:
-        try:
-            response_data = nx_response.json()
-            if response_data.get('err', {}).get('status') == 403:
-                print("Invalid NX credentials provided.")
-                error = True
-            elif response_data.get('user').get('username') != shared_state.values["config"]("NX").get("user"):
-                print("Invalid NX response on login.")
-                error = True
-            else:
-                sessiontoken = response_data.get('user').get('sessiontoken')
-                nx_session.cookies.set('sessiontoken', sessiontoken, domain=nx)
-        except ValueError:
-            print("Could not parse response.")
-            error = True
-
-        if error:
-            shared_state.values["config"]("NX").save("user", "")
-            shared_state.values["config"]("NX").save("password", "")
-            return None
-
-        serialized_session = pickle.dumps(nx_session)
-        session_string = base64.b64encode(serialized_session).decode('utf-8')
-        shared_state.values["database"]("sessions").update_store("nx", session_string)
-        return nx_session
-    else:
-        print("Could not create NX session")
-        return None
-
-
-def retrieve_and_validate_session(shared_state):
-    session_string = shared_state.values["database"]("sessions").retrieve("nx")
-    if not session_string:
-        nx_session = create_and_persist_session(shared_state)
-    else:
-        try:
-            serialized_session = base64.b64decode(session_string.encode('utf-8'))
-            nx_session = pickle.loads(serialized_session)
-            if not isinstance(nx_session, requests.Session):
-                raise ValueError("Retrieved object is not a valid requests.Session instance.")
-        except Exception as e:
-            print(f"Session retrieval failed: {e}")
-            nx_session = create_and_persist_session(shared_state)
+        data = response.json()
+        files = data.get("files", [])
+        links = []
 
-    return nx_session
+        # Build download URLs from their file hashes
+        for f in files:
+            file_hash = f.get("hash")
+            if not file_hash:
+                continue
+            dl_url = f"https://filer.net/get/{file_hash}"
+            links.append(dl_url)
 
+        # Return extracted links or fallback
+        return links if links else url
 
-def get_filer_folder_links(shared_state, url):
-    try:
-        headers = {
-            'User-Agent': shared_state.values["user_agent"],
-            'Referer': url
-        }
-        response = requests.get(url, headers=headers)
-        links = []
-        if response:
-            soup = BeautifulSoup(response.content, 'html.parser')
-            folder_links = soup.find_all('a', href=re.compile("/get/"))
-            for link in folder_links:
-                link = "https://filer.net" + link.get('href')
-                if link not in links:
-                    links.append(link)
-        return links
     except:
-        pass
-    return url
+        return url
 
 
-def get_nx_download_links(shared_state, url, title):
+def get_nx_download_links(shared_state, url, mirror, title): # signature must align with other download link functions!
     nx = shared_state.values["config"]("Hostnames").get("nx")
 
     if f"{nx}/release/" not in url:
-        print("Link is not a Release link, could not proceed:" + url)
+        info("Link is not a Release link, could not proceed:" + url)
 
     nx_session = retrieve_and_validate_session(shared_state)
     if not nx_session:
-        print(f"Could not retrieve valid session for {nx}")
+        info(f"Could not retrieve valid session for {nx}")
         return []
 
     headers = {
@@ -120,27 +72,34 @@ def get_nx_download_links(shared_state, url, title):
     payload = nx_session.post(payload_url,
                               headers=headers,
                               json=json_data,
+                              timeout=10
                               )
 
     if payload.status_code == 200:
         try:
             payload = payload.json()
         except:
-            print("Invalid response decrypting " + str(title) + " URL: " + str(url))
+            info("Invalid response decrypting " + str(title) + " URL: " + str(url))
             shared_state.values["database"]("sessions").delete("nx")
             return []
 
+    if payload and any(key in payload for key in ("err", "error")):
+        error_msg = payload.get("err") or payload.get("error")
+        info(f"Error decrypting {title!r} URL: {url!r} - {error_msg}")
+        shared_state.values["database"]("sessions").delete("nx")
+        return []
+
     try:
         decrypted_url = payload['link'][0]['url']
         if decrypted_url:
             if "filer.net/folder/" in decrypted_url:
-                urls = get_filer_folder_links(shared_state, decrypted_url)
+                urls = get_filer_folder_links_via_api(shared_state, decrypted_url)
             else:
                 urls = [decrypted_url]
             return urls
     except:
         pass
 
-    print("Something went wrong decrypting " + str(title) + " URL: " + str(url))
+    info("Something went wrong decrypting " + str(title) + " URL: " + str(url))
     shared_state.values["database"]("sessions").delete("nx")
     return []

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,
+    }