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

quasarr/search/sources/dd.py

@@ -0,0 +1,135 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import html
+import time
+from base64 import urlsafe_b64encode
+from datetime import datetime, timezone
+
+from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.log import info, debug
+from quasarr.providers.sessions.dd import create_and_persist_session, retrieve_and_validate_session
+
+hostname = "dd"
+supported_mirrors = ["ironfiles", "rapidgator", "filefactory"]
+
+
+def convert_to_rss_date(unix_timestamp):
+    parsed_date = datetime.fromtimestamp(unix_timestamp, tz=timezone.utc)
+    rss_date = parsed_date.strftime('%a, %d %b %Y %H:%M:%S %z')
+
+    return rss_date
+
+
+def extract_size(size_in_bytes):
+    return {"size": size_in_bytes, "sizeunit": "B"}
+
+
+def dd_feed(*args, **kwargs):
+    return dd_search(*args, **kwargs)
+
+
+def dd_search(shared_state, start_time, request_from, search_string="", mirror=None, season=None, episode=None):
+    releases = []
+    dd = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = dd
+
+    if not "arr" in request_from.lower():
+        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
+        return releases
+
+    dd_session = retrieve_and_validate_session(shared_state)
+    if not dd_session:
+        info(f"Could not retrieve valid session for {dd}")
+        return releases
+
+    if mirror and mirror not in supported_mirrors:
+        debug(f'Mirror "{mirror}" not supported by "{hostname.upper()}". Supported mirrors: {supported_mirrors}.'
+              ' Skipping search!')
+        return releases
+
+    imdb_id = shared_state.is_imdb_id(search_string)
+    if imdb_id:
+        search_string = get_localized_title(shared_state, imdb_id, 'en')
+        if not search_string:
+            info(f"Could not extract title from IMDb-ID {imdb_id}")
+            return releases
+        search_string = html.unescape(search_string)
+
+    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/{search_string}/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 {hostname.upper()} session...")
+                    create_and_persist_session(shared_state)
+                    return []
+                else:
+                    title = release.get("release")
+
+                    if not shared_state.is_valid_release(title,
+                                                         request_from,
+                                                         search_string,
+                                                         season,
+                                                         episode):
+                        continue
+
+                    imdb_id = release.get("imdbid", None)
+
+                    source = f"https://{dd}/"
+                    size_item = extract_size(release.get("size"))
+                    mb = shared_state.convert_to_mb(size_item) * 1024 * 1024
+                    published = convert_to_rss_date(release.get("when"))
+                    payload = urlsafe_b64encode(
+                        f"{title}|{source}|{mirror}|{mb}|{password}|{imdb_id}".encode("utf-8")).decode("utf-8")
+                    link = f"{shared_state.values['internal_address']}/download/?payload={payload}"
+
+                    releases.append({
+                        "details": {
+                            "title": title,
+                            "hostname": hostname.lower(),
+                            "imdb_id": imdb_id,
+                            "link": link,
+                            "mirror": mirror,
+                            "size": mb,
+                            "date": published,
+                            "source": source
+                        },
+                        "type": "protected"
+                    })
+            except Exception as e:
+                info(f"Error parsing {hostname.upper()} feed: {e}")
+                continue
+
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} feed: {e}")
+
+    elapsed_time = time.time() - start_time
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
+
+    return releases

quasarr/search/sources/dj.py

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import json
+import re
+import time
+from base64 import urlsafe_b64encode
+from datetime import datetime, timedelta
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.log import info, debug
+
+hostname = "dj"
+
+
+def convert_to_rss_date(date_str):
+    try:
+        return datetime.fromisoformat(
+            date_str.replace("Z", "+00:00")
+        ).strftime("%a, %d %b %Y %H:%M:%S +0000")
+    except Exception:
+        return ""
+
+
+def dj_feed(shared_state, start_time, request_from, mirror=None):
+    releases = []
+
+    if "sonarr" not in request_from.lower():
+        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
+        return releases
+
+    sj_host = shared_state.values["config"]("Hostnames").get(hostname)
+    password = sj_host
+
+    url = f"https://{sj_host}/api/releases/latest/0"
+    headers = {"User-Agent": shared_state.values["user_agent"]}
+
+    try:
+        r = requests.get(url, headers=headers, timeout=10)
+        data = json.loads(r.content)
+    except Exception as e:
+        info(f"{hostname.upper()}: feed load error: {e}")
+        return releases
+
+    for release in data:
+        try:
+            title = release.get("name").rstrip(".")
+            if not title:
+                continue
+
+            published = convert_to_rss_date(release.get("createdAt"))
+            if not published:
+                continue
+
+            media = release.get("_media", {})
+            slug = media.get("slug")
+            if not slug:
+                continue
+
+            series_url = f"https://{sj_host}/serie/{slug}"
+
+            mb = 0
+            size = 0
+            imdb_id = None
+
+            payload = urlsafe_b64encode(
+                f"{title}|{series_url}|{mirror}|{mb}|{password}|{imdb_id}".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": series_url
+                },
+                "type": "protected"
+            })
+
+        except Exception as e:
+            debug(f"{hostname.upper()}: feed parse error: {e}")
+            continue
+
+    debug(f"Time taken: {time.time() - start_time:.2f}s ({hostname})")
+    return releases
+
+
+def dj_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
+    releases = []
+
+    if "sonarr" not in request_from.lower():
+        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
+        return releases
+
+    sj_host = shared_state.values["config"]("Hostnames").get(hostname)
+    password = sj_host
+
+    imdb_id = shared_state.is_imdb_id(search_string)
+    if not imdb_id:
+        return releases
+
+    localized_title = get_localized_title(shared_state, imdb_id, "de")
+    if not localized_title:
+        info(f"{hostname.upper()}: no localized title for IMDb {imdb_id}")
+        return releases
+
+    headers = {"User-Agent": shared_state.values["user_agent"]}
+    search_url = f"https://{sj_host}/serie/search"
+    params = {"q": localized_title}
+
+    try:
+        r = requests.get(search_url, headers=headers, params=params, timeout=10)
+        soup = BeautifulSoup(r.content, "html.parser")
+        results = soup.find_all("a", href=re.compile(r"^/serie/"))
+    except Exception as e:
+        info(f"{hostname.upper()}: search load error: {e}")
+        return releases
+
+    one_hour_ago = (datetime.now() - timedelta(hours=1)).strftime('%Y-%m-%d %H:%M:%S')
+    sanitized_search_string = shared_state.sanitize_string(localized_title)
+
+    for result in results:
+        try:
+            result_title = result.get_text(strip=True)
+
+            sanitized_title = shared_state.sanitize_string(result_title)
+
+            if not re.search(
+                    rf"\b{re.escape(sanitized_search_string)}\b",
+                    sanitized_title
+            ):
+                debug(
+                    f"Search string '{localized_title}' doesn't match '{result_title}'"
+                )
+                continue
+
+            debug(
+                f"Matched search string '{localized_title}' with result '{result_title}'"
+            )
+
+            series_url = f"https://{sj_host}{result['href']}"
+
+            r = requests.get(series_url, headers=headers, timeout=10)
+            media_id_match = re.search(r'data-mediaid="([^"]+)"', r.text)
+            if not media_id_match:
+                debug(f"{hostname.upper()}: no media id for {result_title}")
+                continue
+
+            media_id = media_id_match.group(1)
+            api_url = f"https://{sj_host}/api/media/{media_id}/releases"
+
+            r = requests.get(api_url, headers=headers, timeout=10)
+            data = json.loads(r.content)
+
+            for season_block in data.values():
+                for item in season_block.get("items", []):
+                    title = item.get("name").rstrip(".")
+                    if not title:
+                        continue
+
+                    if not shared_state.is_valid_release(
+                            title,
+                            request_from,
+                            search_string,
+                            season,
+                            episode
+                    ):
+                        continue
+
+                    published = convert_to_rss_date(item.get("createdAt"))
+                    if not published:
+                        debug(f"{hostname.upper()}: no published date for {title}")
+                        published = one_hour_ago
+
+                    mb = 0
+                    size = 0
+
+                    payload = urlsafe_b64encode(
+                        f"{title}|{series_url}|{mirror}|{mb}|{password}|{imdb_id}".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": series_url
+                        },
+                        "type": "protected"
+                    })
+
+        except Exception as e:
+            debug(f"{hostname.upper()}: search parse error: {e}")
+            continue
+
+    debug(f"Time taken: {time.time() - start_time:.2f}s ({hostname})")
+    return releases

quasarr/search/sources/dl.py

@@ -0,0 +1,354 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import re
+import time
+from base64 import urlsafe_b64encode
+from datetime import datetime
+from html import unescape
+
+from bs4 import BeautifulSoup
+
+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
+
+hostname = "dl"
+
+RESOLUTION_REGEX = re.compile(r"\d{3,4}p", re.I)
+CODEC_REGEX = re.compile(r"x264|x265|h264|h265|hevc|avc", re.I)
+XXX_REGEX = re.compile(r"\.xxx\.", re.I)
+
+
+def convert_to_rss_date(iso_date_str):
+    """
+    Convert ISO format datetime to RSS date format.
+    DL date format: '2025-12-15T20:43:06+0100'
+    Returns: 'Sun, 15 Dec 2025 20:43:06 +0100'
+    Falls back to current time if conversion fails.
+    """
+    if not iso_date_str:
+        return datetime.now().strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+    try:
+        dt_obj = datetime.fromisoformat(iso_date_str)
+        return dt_obj.strftime("%a, %d %b %Y %H:%M:%S %z")
+    except Exception:
+        return datetime.now().strftime("%a, %d %b %Y %H:%M:%S +0000")
+
+
+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 correct forum and return releases.
+    """
+    releases = []
+    host = shared_state.values["config"]("Hostnames").get(hostname)
+
+    if "lazylibrarian" in request_from.lower():
+        forum = "magazine-zeitschriften.72"
+    elif "radarr" in request_from.lower():
+        forum = "hd.8"
+    else:
+        forum = "hd.14"
+
+    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
+
+        forum_url = f'https://www.{host}/forums/{forum}/?order=post_date&direction=desc'
+        response = sess.get(forum_url, timeout=30)
+
+        if response.status_code != 200:
+            info(f"{hostname}: Forum request failed with {response.status_code}")
+            return releases
+
+        soup = BeautifulSoup(response.content, 'html.parser')
+
+        # Find all thread items in the forum
+        items = soup.select('div.structItem.structItem--thread')
+
+        if not items:
+            debug(f"{hostname}: No entries found in Forum")
+            return releases
+
+        for item in items:
+            try:
+                # Extract title from the thread
+                title_elem = item.select_one('div.structItem-title a')
+                if not title_elem:
+                    continue
+
+                title = title_elem.get_text(strip=True)
+                if not title:
+                    continue
+
+                title = unescape(title)
+                title = normalize_title_for_sonarr(title)
+
+                # Extract thread URL
+                thread_url = title_elem.get('href')
+                if not thread_url:
+                    continue
+
+                # Make sure URL is absolute
+                if thread_url.startswith('/'):
+                    thread_url = f"https://www.{host}{thread_url}"
+
+                # Extract date and convert to RFC 2822 format
+                date_elem = item.select_one('time.u-dt')
+                iso_date = date_elem.get('datetime', '') if date_elem else ''
+                published = convert_to_rss_date(iso_date)
+
+                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": published,
+                        "source": thread_url
+                    },
+                    "type": "protected"
+                })
+
+            except Exception as e:
+                debug(f"{hostname}: error parsing Forum item: {e}")
+                continue
+
+    except Exception as e:
+        info(f"{hostname}: Forum feed error: {e}")
+        invalidate_session(shared_state)
+
+    elapsed = time.time() - start_time
+    debug(f"Time taken: {elapsed:.2f}s ({hostname})")
+    return releases
+
+
+def _replace_umlauts(text):
+    replacements = {
+        'ä': 'ae',
+        'ö': 'oe',
+        'ü': 'ue',
+        'Ä': 'Ae',
+        'Ö': 'Oe',
+        'Ü': 'Ue',
+        'ß': 'ss'
+    }
+
+    for umlaut, replacement in replacements.items():
+        text = text.replace(umlaut, replacement)
+
+    return text
+
+
+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 = []
+
+    search_string = _replace_umlauts(search_string)
+
+    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)
+
+                # Filter: Skip if no resolution or codec info (unless LazyLibrarian)
+                if 'lazylibrarian' not in request_from.lower():
+                    if not (RESOLUTION_REGEX.search(title_normalized) or CODEC_REGEX.search(title_normalized)):
+                        continue
+
+                # Filter: Skip XXX content unless explicitly searched for
+                if XXX_REGEX.search(title_normalized) and 'xxx' not in search_string.lower():
+                    continue
+
+                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
+
+                # Extract date and convert to RFC 2822 format
+                date_elem = item.select_one('time.u-dt')
+                iso_date = date_elem.get('datetime', '') if date_elem else ''
+                published = convert_to_rss_date(iso_date)
+
+                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": published,
+                        "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 sequential pagination (max 5 pages) to find best quality releases.
+    Stops searching if a page returns 0 results.
+    """
+    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
+
+    debug(
+        f"{hostname}: Starting sequential 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
+
+        search_id = None
+
+        # Sequential search through pages
+        for page_num in range(1, max_pages + 1):
+            page_releases, extracted_search_id = _search_single_page(
+                shared_state, host, search_string, search_id, page_num,
+                imdb_id, mirror, request_from, season, episode
+            )
+
+            # Update search_id from first page
+            if page_num == 1:
+                search_id = extracted_search_id
+                if not search_id:
+                    info(f"{hostname}: Could not extract search ID, stopping pagination")
+                    break
+
+            # Add releases from this page
+            releases.extend(page_releases)
+            debug(f"{hostname}: [Page {page_num}] completed with {len(page_releases)} valid releases")
+
+            # Stop if this page returned 0 results
+            if len(page_releases) == 0:
+                debug(f"{hostname}: [Page {page_num}] returned 0 results, stopping pagination")
+                break
+
+    except Exception as e:
+        info(f"{hostname}: search error: {e}")
+        invalidate_session(shared_state)
+
+    debug(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