quasarr 1.20.7__py3-none-any.whl → 1.21.0__py3-none-any.whl

quasarr/search/sources/dl.py

@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+import time
+import warnings
+from base64 import urlsafe_b64encode
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+from html import unescape
+
+from bs4 import BeautifulSoup
+from bs4 import XMLParsedAsHTMLWarning
+
+from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.log import info, debug
+from quasarr.providers.sessions.dl import retrieve_and_validate_session, invalidate_session, fetch_via_requests_session
+
+warnings.filterwarnings("ignore", category=XMLParsedAsHTMLWarning)  # we dont want to use lxml
+
+hostname = "dl"
+supported_mirrors = []
+
+
+def normalize_title_for_sonarr(title):
+    """
+    Normalize title for Sonarr by replacing spaces with dots.
+    """
+    title = title.replace(' ', '.')
+    title = re.sub(r'\s*-\s*', '-', title)
+    title = re.sub(r'\.\-\.', '-', title)
+    title = re.sub(r'\.{2,}', '.', title)
+    title = title.strip('.')
+    return title
+
+
+def dl_feed(shared_state, start_time, request_from, mirror=None):
+    """
+    Parse the RSS feed and return releases.
+    """
+    releases = []
+    host = shared_state.values["config"]("Hostnames").get(hostname)
+
+    if not host:
+        debug(f"{hostname}: hostname not configured")
+        return releases
+
+    try:
+        sess = retrieve_and_validate_session(shared_state)
+        if not sess:
+            info(f"Could not retrieve valid session for {host}")
+            return releases
+
+        # Instead we should parse the HTML for the correct *arr client
+        rss_url = f'https://www.{host}/forums/-/index.rss'
+        response = sess.get(rss_url, timeout=30)
+
+        if response.status_code != 200:
+            info(f"{hostname}: RSS feed returned status {response.status_code}")
+            return releases
+
+        soup = BeautifulSoup(response.content, 'html.parser')
+        items = soup.find_all('item')
+
+        if not items:
+            debug(f"{hostname}: No entries found in RSS feed")
+            return releases
+
+        for item in items:
+            try:
+                title_tag = item.find('title')
+                if not title_tag:
+                    continue
+
+                title = title_tag.get_text(strip=True)
+                if not title:
+                    continue
+
+                title = unescape(title)
+                title = title.replace(']]>', '').replace('<![CDATA[', '')
+                title = normalize_title_for_sonarr(title)
+
+                item_text = item.get_text()
+                thread_url = None
+                match = re.search(r'https://[^\s]+/threads/[^\s]+', item_text)
+                if match:
+                    thread_url = match.group(0)
+                if not thread_url:
+                    continue
+
+                pub_date = item.find('pubdate')
+                if pub_date:
+                    date_str = pub_date.get_text(strip=True)
+                else:
+                    # Fallback: use current time if no pubDate found
+                    date_str = datetime.now().strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+                mb = 0
+                imdb_id = None
+                password = ""
+
+                payload = urlsafe_b64encode(
+                    f"{title}|{thread_url}|{mirror}|{mb}|{password}|{imdb_id or ''}".encode("utf-8")
+                ).decode("utf-8")
+                link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+                releases.append({
+                    "details": {
+                        "title": title,
+                        "hostname": hostname,
+                        "imdb_id": imdb_id,
+                        "link": link,
+                        "mirror": mirror,
+                        "size": mb * 1024 * 1024,
+                        "date": date_str,
+                        "source": thread_url
+                    },
+                    "type": "protected"
+                })
+
+            except Exception as e:
+                debug(f"{hostname}: error parsing RSS entry: {e}")
+                continue
+
+    except Exception as e:
+        info(f"{hostname}: RSS feed error: {e}")
+        invalidate_session(shared_state)
+
+    elapsed = time.time() - start_time
+    debug(f"Time taken: {elapsed:.2f}s ({hostname})")
+    return releases
+
+
+def _search_single_page(shared_state, host, search_string, search_id, page_num, imdb_id, mirror, request_from, season,
+                        episode):
+    """
+    Search a single page. This function is called in parallel for each page.
+    """
+    page_releases = []
+
+    try:
+        if page_num == 1:
+            search_params = {
+                'keywords': search_string,
+                'c[title_only]': 1
+            }
+            search_url = f'https://www.{host}/search/search'
+        else:
+            if not search_id:
+                return page_releases, None
+
+            search_params = {
+                'page': page_num,
+                'q': search_string,
+                'o': 'relevance'
+            }
+            search_url = f'https://www.{host}/search/{search_id}/'
+
+        search_response = fetch_via_requests_session(shared_state, method="GET",
+                                                     target_url=search_url,
+                                                     get_params=search_params,
+                                                     timeout=10)
+
+        if search_response.status_code != 200:
+            debug(f"{hostname}: [Page {page_num}] returned status {search_response.status_code}")
+            return page_releases, None
+
+        # Extract search ID from first page
+        extracted_search_id = None
+        if page_num == 1:
+            match = re.search(r'/search/(\d+)/', search_response.url)
+            if match:
+                extracted_search_id = match.group(1)
+                debug(f"{hostname}: [Page 1] Extracted search ID: {extracted_search_id}")
+
+        soup = BeautifulSoup(search_response.text, 'html.parser')
+        result_items = soup.select('li.block-row')
+
+        if not result_items:
+            debug(f"{hostname}: [Page {page_num}] found 0 results")
+            return page_releases, extracted_search_id
+
+        debug(f"{hostname}: [Page {page_num}] found {len(result_items)} results")
+
+        for item in result_items:
+            try:
+                title_elem = item.select_one('h3.contentRow-title a')
+                if not title_elem:
+                    continue
+
+                title = title_elem.get_text(separator=' ', strip=True)
+                title = re.sub(r'\s+', ' ', title)
+                title = unescape(title)
+                title_normalized = normalize_title_for_sonarr(title)
+
+                thread_url = title_elem.get('href')
+                if thread_url.startswith('/'):
+                    thread_url = f"https://www.{host}{thread_url}"
+
+                if not shared_state.is_valid_release(title_normalized, request_from, search_string, season, episode):
+                    continue
+
+                minor_info = item.select_one('div.contentRow-minor')
+                date_str = ""
+                if minor_info:
+                    date_elem = minor_info.select_one('time.u-dt')
+                    if date_elem:
+                        date_str = date_elem.get('datetime', '')
+
+                # Fallback: use current time if no date found
+                if not date_str:
+                    date_str = datetime.now().strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+                mb = 0
+                password = ""
+
+                payload = urlsafe_b64encode(
+                    f"{title_normalized}|{thread_url}|{mirror}|{mb}|{password}|{imdb_id or ''}".encode("utf-8")
+                ).decode("utf-8")
+                link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+                page_releases.append({
+                    "details": {
+                        "title": title_normalized,
+                        "hostname": hostname,
+                        "imdb_id": imdb_id,
+                        "link": link,
+                        "mirror": mirror,
+                        "size": mb * 1024 * 1024,
+                        "date": date_str,
+                        "source": thread_url
+                    },
+                    "type": "protected"
+                })
+
+            except Exception as e:
+                debug(f"{hostname}: [Page {page_num}] error parsing item: {e}")
+
+        return page_releases, extracted_search_id
+
+    except Exception as e:
+        info(f"{hostname}: [Page {page_num}] error: {e}")
+        return page_releases, None
+
+
+def dl_search(shared_state, start_time, request_from, search_string,
+              mirror=None, season=None, episode=None):
+    """
+    Search with parallel pagination (max 5 pages) to find best quality releases.
+    Requests are fired in parallel to minimize search time.
+    """
+    releases = []
+    host = shared_state.values["config"]("Hostnames").get(hostname)
+
+    imdb_id = shared_state.is_imdb_id(search_string)
+    if imdb_id:
+        title = get_localized_title(shared_state, imdb_id, 'de')
+        if not title:
+            info(f"{hostname}: no title for IMDb {imdb_id}")
+            return releases
+        search_string = title
+
+    search_string = unescape(search_string)
+    max_pages = 5
+
+    info(
+        f"{hostname}: Starting parallel paginated search for '{search_string}' (Season: {season}, Episode: {episode}) - up to {max_pages} pages")
+
+    try:
+        sess = retrieve_and_validate_session(shared_state)
+        if not sess:
+            info(f"Could not retrieve valid session for {host}")
+            return releases
+
+        # First, do page 1 to get the search ID
+        page_1_releases, search_id = _search_single_page(
+            shared_state, host, search_string, None, 1,
+            imdb_id, mirror, request_from, season, episode
+        )
+        releases.extend(page_1_releases)
+
+        if not search_id:
+            info(f"{hostname}: Could not extract search ID, stopping pagination")
+            return releases
+
+        # Now fire remaining pages in parallel
+        with ThreadPoolExecutor(max_workers=4) as executor:
+            futures = {}
+            for page_num in range(2, max_pages + 1):
+                future = executor.submit(
+                    _search_single_page,
+                    shared_state, host, search_string, search_id, page_num,
+                    imdb_id, mirror, request_from, season, episode
+                )
+                futures[future] = page_num
+
+            for future in as_completed(futures):
+                page_num = futures[future]
+                try:
+                    page_releases, _ = future.result()
+                    releases.extend(page_releases)
+                    debug(f"{hostname}: [Page {page_num}] completed with {len(page_releases)} valid releases")
+                except Exception as e:
+                    info(f"{hostname}: [Page {page_num}] failed: {e}")
+
+    except Exception as e:
+        info(f"{hostname}: search error: {e}")
+        invalidate_session(shared_state)
+
+    info(f"{hostname}: FINAL - Found {len(releases)} valid releases - providing to {request_from}")
+
+    elapsed = time.time() - start_time
+    debug(f"Time taken: {elapsed:.2f}s ({hostname})")
+
+    return releases

quasarr/search/sources/wx.py

@@ -0,0 +1,342 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import html
+import time
+import traceback
+import warnings
+from base64 import urlsafe_b64encode
+from datetime import datetime
+
+import requests
+from bs4 import BeautifulSoup
+from bs4 import XMLParsedAsHTMLWarning
+
+from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.log import info, debug
+
+warnings.filterwarnings("ignore", category=XMLParsedAsHTMLWarning)  # we dont want to use lxml
+
+hostname = "wx"
+supported_mirrors = []
+
+
+def wx_feed(shared_state, start_time, request_from, mirror=None):
+    """
+    Fetch latest releases from RSS feed.
+    """
+    releases = []
+    host = shared_state.values["config"]("Hostnames").get(hostname)
+
+    if "lazylibrarian" in request_from.lower():
+        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
+        return releases
+
+    rss_url = f'https://{host}/rss'
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+    }
+
+    try:
+        response = requests.get(rss_url, headers=headers, timeout=10)
+
+        if response.status_code != 200:
+            info(f"{hostname.upper()}: RSS feed returned status {response.status_code}")
+            return releases
+
+        soup = BeautifulSoup(response.content, 'html.parser')
+        items = soup.find_all('entry')
+
+        if not items:
+            items = soup.find_all('item')
+
+        if not items:
+            debug(f"{hostname.upper()}: No entries found in RSS feed")
+            return releases
+
+        max_releases = 100
+        if len(items) > max_releases:
+            debug(f"{hostname.upper()}: Found {len(items)} entries, limiting to {max_releases}")
+            items = items[:max_releases]
+        else:
+            debug(f"{hostname.upper()}: Found {len(items)} entries in RSS feed")
+
+        for item in items:
+            try:
+                title_tag = item.find('title')
+                if not title_tag:
+                    continue
+
+                title = title_tag.get_text(strip=True)
+                if not title:
+                    continue
+
+                title = html.unescape(title)
+                title = title.replace(']]>', '').replace('<![CDATA[', '')
+                title = title.replace(' ', '.')
+
+                link_tag = item.find('link', rel='alternate')
+                if link_tag and link_tag.has_attr('href'):
+                    source = link_tag['href']
+                else:
+                    link_tag = item.find('link')
+                    if not link_tag:
+                        continue
+                    source = link_tag.get_text(strip=True)
+
+                if not source:
+                    continue
+
+                pub_date = item.find('updated') or item.find('pubDate')
+                if pub_date:
+                    published = pub_date.get_text(strip=True)
+                else:
+                    # Fallback: use current time if no pubDate found
+                    published = datetime.now().strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+                mb = 0
+                size = 0
+                imdb_id = None
+                password = host.upper()
+
+                payload = urlsafe_b64encode(
+                    f"{title}|{source}|{mirror}|{mb}|{password}|{imdb_id or ''}".encode("utf-8")
+                ).decode("utf-8")
+                link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+                releases.append({
+                    "details": {
+                        "title": title,
+                        "hostname": hostname,
+                        "imdb_id": imdb_id,
+                        "link": link,
+                        "mirror": mirror,
+                        "size": size,
+                        "date": published,
+                        "source": source
+                    },
+                    "type": "protected"
+                })
+
+            except Exception as e:
+                debug(f"{hostname.upper()}: error parsing RSS entry: {e}")
+                continue
+
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} feed: {e}")
+        return releases
+
+    elapsed_time = time.time() - start_time
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
+
+    return releases
+
+
+def wx_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
+    """
+    Search using internal API.
+    """
+    releases = []
+    host = shared_state.values["config"]("Hostnames").get(hostname)
+
+    if "lazylibrarian" in request_from.lower():
+        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
+        return releases
+
+    imdb_id = shared_state.is_imdb_id(search_string)
+    if imdb_id:
+        info(f"{hostname.upper()}: Received IMDb ID: {imdb_id}")
+        title = get_localized_title(shared_state, imdb_id, 'de')
+        if not title:
+            info(f"{hostname.upper()}: no title for IMDb {imdb_id}")
+            return releases
+        info(f"{hostname.upper()}: Translated IMDb {imdb_id} to German title: '{title}'")
+        search_string = html.unescape(title)
+    else:
+        info(f"{hostname.upper()}: Using search string directly: '{search_string}'")
+
+    api_url = f'https://api.{host}/start/search'
+
+    headers = {
+        'User-Agent': shared_state.values["user_agent"],
+        'Accept': 'application/json, text/plain, */*',
+        'Referer': f'https://{host}/search'
+    }
+
+    params = {
+        '__LOAD_P': '',
+        'per_page': 50,
+        'q': search_string,
+        'selectedTypes': '',
+        'selectedGenres': '',
+        'types': 'movie,series,anime',
+        'genres': '',
+        'years': '',
+        'ratings': '',
+        'page': 1,
+        'sortBy': 'latest',
+        'sortOrder': 'desc'
+    }
+
+    if "sonarr" in request_from.lower():
+        params['types'] = 'series,anime'
+    elif "radarr" in request_from.lower():
+        params['types'] = 'movie'
+
+    info(f"{hostname.upper()}: Searching: '{search_string}'")
+
+    try:
+        response = requests.get(api_url, headers=headers, params=params, timeout=10)
+
+        if response.status_code != 200:
+            info(f"{hostname.upper()}: Search API returned status {response.status_code}")
+            return releases
+
+        data = response.json()
+
+        if 'items' in data and 'data' in data['items']:
+            items = data['items']['data']
+        elif 'data' in data:
+            items = data['data']
+        elif 'results' in data:
+            items = data['results']
+        else:
+            items = data if isinstance(data, list) else []
+
+        info(f"{hostname.upper()}: Found {len(items)} items in search results")
+
+        for item in items:
+            try:
+                uid = item.get('uid')
+                if not uid:
+                    debug(f"{hostname.upper()}: Item has no UID, skipping")
+                    continue
+
+                info(f"{hostname.upper()}: Fetching details for UID: {uid}")
+
+                detail_url = f'https://api.{host}/start/d/{uid}'
+                detail_response = requests.get(detail_url, headers=headers, timeout=10)
+
+                if detail_response.status_code != 200:
+                    debug(f"{hostname.upper()}: Detail API returned {detail_response.status_code} for {uid}")
+                    continue
+
+                detail_data = detail_response.json()
+
+                if 'item' in detail_data:
+                    detail_item = detail_data['item']
+                else:
+                    detail_item = detail_data
+
+                item_imdb_id = imdb_id
+                if not item_imdb_id:
+                    item_imdb_id = detail_item.get('imdb_id') or detail_item.get('imdbid')
+                    if not item_imdb_id and 'options' in detail_item:
+                        item_imdb_id = detail_item['options'].get('imdb_id')
+
+                source = f"https://{host}/detail/{uid}"
+
+                main_title = detail_item.get('fulltitle') or detail_item.get('title') or detail_item.get('name')
+                if main_title:
+                    title = html.unescape(main_title)
+                    title = title.replace(' ', '.')
+
+                    if shared_state.is_valid_release(title, request_from, search_string, season, episode):
+                        published = detail_item.get('updated_at') or detail_item.get('created_at')
+                        if not published:
+                            published = datetime.now().strftime("%a, %d %b %Y %H:%M:%S +0000")
+                        password = f"www.{host}"
+
+                        payload = urlsafe_b64encode(
+                            f"{title}|{source}|{mirror}|0|{password}|{item_imdb_id or ''}".encode("utf-8")
+                        ).decode("utf-8")
+                        link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+                        releases.append({
+                            "details": {
+                                "title": title,
+                                "hostname": hostname,
+                                "imdb_id": item_imdb_id,
+                                "link": link,
+                                "mirror": mirror,
+                                "size": 0,
+                                "date": published,
+                                "source": source
+                            },
+                            "type": "protected"
+                        })
+
+                if 'releases' in detail_item and isinstance(detail_item['releases'], list):
+                    info(f"{hostname.upper()}: Found {len(detail_item['releases'])} releases for {uid}")
+
+                    for release in detail_item['releases']:
+                        try:
+                            release_title = release.get('fulltitle')
+                            if not release_title:
+                                continue
+
+                            release_title = html.unescape(release_title)
+                            release_title = release_title.replace(' ', '.')
+
+                            if not shared_state.is_valid_release(release_title, request_from, search_string, season,
+                                                                 episode):
+                                debug(f"{hostname.upper()}: ✗ Release filtered out: {release_title}")
+                                continue
+
+                            release_uid = release.get('uid')
+                            if release_uid:
+                                release_source = f"https://{host}/detail/{uid}?release={release_uid}"
+                            else:
+                                release_source = source
+
+                            release_published = release.get('updated_at') or release.get(
+                                'created_at') or detail_item.get('updated_at')
+                            if not release_published:
+                                release_published = datetime.now().strftime("%a, %d %b %Y %H:%M:%S +0000")
+                            release_size = release.get('size', 0)
+                            password = f"www.{host}"
+
+                            payload = urlsafe_b64encode(
+                                f"{release_title}|{release_source}|{mirror}|{release_size}|{password}|{item_imdb_id or ''}".encode(
+                                    "utf-8")
+                            ).decode("utf-8")
+                            link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+                            releases.append({
+                                "details": {
+                                    "title": release_title,
+                                    "hostname": hostname,
+                                    "imdb_id": item_imdb_id,
+                                    "link": link,
+                                    "mirror": mirror,
+                                    "size": release_size,
+                                    "date": release_published,
+                                    "source": release_source
+                                },
+                                "type": "protected"
+                            })
+
+                        except Exception as e:
+                            debug(f"{hostname.upper()}: Error parsing release: {e}")
+                            continue
+                else:
+                    debug(f"{hostname.upper()}: No releases array found for {uid}")
+
+            except Exception as e:
+                debug(f"{hostname.upper()}: Error processing item: {e}")
+                debug(f"{hostname.upper()}: {traceback.format_exc()}")
+                continue
+
+        info(f"{hostname.upper()}: Returning {len(releases)} total releases")
+
+    except Exception as e:
+        info(f"Error in {hostname.upper()} search: {e}")
+
+        debug(f"{hostname.upper()}: {traceback.format_exc()}")
+        return releases
+
+    elapsed_time = time.time() - start_time
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
+
+    return releases

quasarr/storage/config.py

@@ -30,6 +30,7 @@ class Config(object):
             ("by", "secret", ""),
             ("dd", "secret", ""),
             ("dj", "secret", ""),
+            ("dl", "secret", ""),
             ("dt", "secret", ""),
             ("dw", "secret", ""),
             ("fx", "secret", ""),
@@ -40,7 +41,8 @@ class Config(object):
             ("sf", "secret", ""),
             ("sj", "secret", ""),
             ("sl", "secret", ""),
-            ("wd", "secret", "")
+            ("wd", "secret", ""),
+            ("wx", "secret", "")
         ],
         'FlareSolverr': [
             ("url", "str", ""),
@@ -53,6 +55,10 @@ class Config(object):
             ("user", "secret", ""),
             ("password", "secret", "")
         ],
+        'DL': [
+            ("user", "secret", ""),
+            ("password", "secret", "")
+        ],
         'NX': [
             ("user", "secret", ""),
             ("password", "secret", "")