quasarr 1.4.1__py3-none-any.whl → 1.20.4__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

@@ -2,83 +2,11 @@
 # Quasarr
 # Project by https://github.com/rix1337
 
-import base64
-import pickle
-
-import requests
-
 from quasarr.providers.log import info, debug
+from quasarr.providers.sessions.dd import create_and_persist_session, retrieve_and_validate_session
 
 
-def create_and_persist_session(shared_state):
-    dd = shared_state.values["config"]("Hostnames").get("dd")
-
-    dd_session = requests.Session()
-
-    cookies = {}
-    headers = {
-        'User-Agent': shared_state.values["user_agent"],
-    }
-
-    data = {
-        'username': shared_state.values["config"]("DD").get("user"),
-        'password': shared_state.values["config"]("DD").get("password"),
-        'ajax': 'true',
-        'Login': 'true',
-    }
-
-    dd_response = dd_session.post(f'https://{dd}/index/index',
-                                  cookies=cookies, headers=headers, data=data, timeout=10)
-
-    error = False
-    if dd_response.status_code == 200:
-        try:
-            response_data = dd_response.json()
-            if not response_data.get('loggedin'):
-                info("DD rejected login.")
-                raise ValueError
-            session_id = dd_response.cookies.get("PHPSESSID")
-            if session_id:
-                dd_session.cookies.set('PHPSESSID', session_id, domain=dd)
-            else:
-                info("Invalid DD response on login.")
-                error = True
-        except ValueError:
-            info("Could not parse DD response on login.")
-            error = True
-
-        if error:
-            shared_state.values["config"]("DD").save("user", "")
-            shared_state.values["config"]("DD").save("password", "")
-            return None
-
-        serialized_session = pickle.dumps(dd_session)
-        session_string = base64.b64encode(serialized_session).decode('utf-8')
-        shared_state.values["database"]("sessions").update_store("dd", session_string)
-        return dd_session
-    else:
-        info("Could not create DD session")
-        return None
-
-
-def retrieve_and_validate_session(shared_state):
-    session_string = shared_state.values["database"]("sessions").retrieve("dd")
-    if not session_string:
-        dd_session = create_and_persist_session(shared_state)
-    else:
-        try:
-            serialized_session = base64.b64decode(session_string.encode('utf-8'))
-            dd_session = pickle.loads(serialized_session)
-            if not isinstance(dd_session, requests.Session):
-                raise ValueError("Retrieved object is not a valid requests.Session instance.")
-        except Exception as e:
-            info(f"Session retrieval failed: {e}")
-            dd_session = create_and_persist_session(shared_state)
-
-    return dd_session
-
-
-def get_dd_download_links(shared_state, mirror, search_string):
+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)
@@ -107,7 +35,7 @@ def get_dd_download_links(shared_state, mirror, search_string):
     try:
         release_list = []
         for page in range(0, 100, 20):
-            url = f'https://{dd}/index/search/keyword/{search_string}/qualities/{','.join(qualities)}/from/{page}/search'
+            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:
@@ -119,7 +47,7 @@ def get_dd_download_links(shared_state, mirror, search_string):
                     debug(f"Release {release.get('release')} marked as fake. Invalidating DD session...")
                     create_and_persist_session(shared_state)
                     return []
-                elif release.get("release") == search_string:
+                elif release.get("release") == title:
                     filtered_links = []
                     for link in release["links"]:
                         if mirror and mirror not in link["hostname"]:
@@ -139,10 +67,10 @@ def get_dd_download_links(shared_state, mirror, search_string):
                     links = [link["url"] for link in filtered_links]
                     break
             except Exception as e:
-                info(f"Error parsing DD feed: {e}")
+                info(f"Error parsing DD download: {e}")
                 continue
 
     except Exception as e:
-        info(f"Error loading DD feed: {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/dt.py

@@ -8,7 +8,7 @@ from bs4 import BeautifulSoup
 from quasarr.providers.log import info
 
 
-def get_dt_download_links(shared_state, url, mirror, title):
+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()
 

quasarr/downloads/sources/dw.py

@@ -10,7 +10,7 @@ from bs4 import BeautifulSoup
 from quasarr.providers.log import info, debug
 
 
-def get_dw_download_links(shared_state, url, mirror, 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"
 
@@ -53,7 +53,7 @@ def get_dw_download_links(shared_state, url, mirror, title):
 
                 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 not in hoster:
+                if mirror and mirror.lower() not in hoster.lower():
                     debug(f'Skipping link from "{hoster}" (not the desired mirror "{mirror}")!')
                     continue
 

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

quasarr/downloads/sources/nk.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info
+
+hostname = "nk"
+
+
+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:
+
+        href = a.get('href', '').strip()
+        hoster = href.split('/')[3].lower()
+        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
+
+        if hoster == 'ddl.to':
+            hoster = 'ddownload'
+
+        candidates.append([href, hoster])
+
+    if not candidates:
+        info(f"No external download links found on {hostname} page for {title}")
+
+    return candidates

quasarr/downloads/sources/nx.py

@@ -2,104 +2,53 @@
 # 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,
-                                  timeout=10)
+        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:
-                info("Invalid NX credentials provided.")
-                error = True
-            elif response_data.get('user').get('username') != shared_state.values["config"]("NX").get("user"):
-                info("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:
-            info("Could not parse NX response on login.")
-            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:
-        info("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:
-            info(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, timeout=10)
-        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:
@@ -134,11 +83,17 @@ def get_nx_download_links(shared_state, url, title):
             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