quasarr 1.20.6__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/dt.py

@@ -0,0 +1,265 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import datetime
+import html
+import re
+import time
+from base64 import urlsafe_b64encode
+from datetime import timezone, timedelta
+from urllib.parse import quote_plus
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.imdb_metadata import get_localized_title
+from quasarr.providers.log import info, debug
+
+hostname = "dt"
+supported_mirrors = ["rapidgator", "nitroflare", "ddownload"]
+
+
+def extract_size(text):
+    match = re.match(r"([\d\.]+)\s*([KMGT]B)", text, re.IGNORECASE)
+    if match:
+        size = match.group(1)
+        unit = match.group(2).upper()
+        return {"size": size, "sizeunit": unit}
+    else:
+        raise ValueError(f"Invalid size format: {text}")
+
+
+def parse_published_datetime(article):
+    date_box = article.find('div', class_='mr-2 shadow-sm1 text-center')
+    mon = date_box.find('small').text.strip()
+    day = date_box.find('h4').text.strip()
+    year = date_box.find('h6').text.strip()
+    month_num = datetime.datetime.strptime(mon, '%b').month
+
+    time_icon = article.select_one('i.fa-clock-o')
+    if time_icon:
+        # its parent <span> contains e.g. "19:12"
+        raw = time_icon.parent.get_text(strip=True)
+        m = re.search(r'(\d{1,2}:\d{2})', raw)
+        if m:
+            hh, mm = map(int, m.group(1).split(':'))
+        else:
+            hh, mm = 0, 0
+    else:
+        hh, mm = 0, 0
+
+    # this timezone is fixed to CET+1 and might be wrong
+    cet = timezone(timedelta(hours=1))
+    dt = datetime.datetime(int(year), month_num, int(day), hh, mm, tzinfo=cet)
+    return dt.isoformat()
+
+
+def dt_feed(shared_state, start_time, request_from, mirror=None):
+    releases = []
+    dt = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = dt
+
+    if "lazylibrarian" in request_from.lower():
+        feed_type = "learning/"
+    elif "radarr" in request_from.lower():
+        feed_type = "media/videos/"
+    else:
+        feed_type = "media/tv-show/"
+
+    if mirror and mirror not in supported_mirrors:
+        debug(f'Mirror "{mirror}" not supported by "{hostname.upper()}". Supported: {supported_mirrors}. Skipping!')
+        return releases
+
+    url = f'https://{dt}/{feed_type}'
+    headers = {'User-Agent': shared_state.values["user_agent"]}
+
+    try:
+        resp = requests.get(url, headers=headers, timeout=10).content
+        feed = BeautifulSoup(resp, "html.parser")
+
+        for article in feed.find_all('article'):
+            try:
+                link_tag = article.select_one('h4.font-weight-bold a')
+                if not link_tag:
+                    debug(f"Link tag not found in article: {article} at {hostname.upper()}")
+                    continue
+
+                source = link_tag['href']
+                title_raw = link_tag.text.strip()
+                title = title_raw.replace(' - ', '-').replace(' ', '.').replace('(', '').replace(')', '')
+
+                if 'lazylibrarian' in request_from.lower():
+                    # lazylibrarian can only detect specific date formats / issue numbering for magazines
+                    title = shared_state.normalize_magazine_title(title)
+
+                try:
+                    imdb_id = re.search(r'tt\d+', str(article)).group()
+                except:
+                    imdb_id = None
+
+                body_text = article.find('div', class_='card-body').get_text(" ")
+                size_match = re.search(r"(\d+(?:\.\d+)?\s*(?:GB|MB|KB|TB))", body_text, re.IGNORECASE)
+                if not size_match:
+                    debug(f"Size not found in article: {article} at {hostname.upper()}")
+                    continue
+                size_info = size_match.group(1).strip()
+                size_item = extract_size(size_info)
+                mb = shared_state.convert_to_mb(size_item)
+                size = mb * 1024 * 1024
+
+                published = parse_published_datetime(article)
+
+                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}"
+
+            except Exception as e:
+                info(f"Error parsing {hostname.upper()} feed: {e}")
+                continue
+
+            releases.append({
+                "details": {
+                    "title": title,
+                    "hostname": hostname.lower(),
+                    "imdb_id": imdb_id,
+                    "link": link,
+                    "mirror": mirror,
+                    "size": size,
+                    "date": published,
+                    "source": source
+                },
+                "type": "protected"
+            })
+
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} feed: {e}")
+
+    elapsed = time.time() - start_time
+    debug(f"Time taken: {elapsed:.2f}s ({hostname})")
+    return releases
+
+
+def dt_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
+    releases = []
+    dt = shared_state.values["config"]("Hostnames").get(hostname.lower())
+    password = dt
+
+    if "lazylibrarian" in request_from.lower():
+        cat_id = "100"
+    elif "radarr" in request_from.lower():
+        cat_id = "9"
+    else:
+        cat_id = "64"
+
+    if mirror and mirror not in supported_mirrors:
+        debug(f'Mirror "{mirror}" not supported by "{hostname.upper()}". Skipping search!')
+        return releases
+
+    try:
+        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)
+
+        q = quote_plus(search_string)
+
+        url = (
+            f"https://{dt}/index.php?"
+            f"do=search&"
+            f"subaction=search&"
+            f"search_start=0&"
+            f"full_search=1&"
+            f"story={q}&"
+            f"catlist%5B%5D={cat_id}&"
+            f"sortby=date&"
+            f"resorder=desc&"
+            f"titleonly=3&"
+            f"searchuser=&"
+            f"beforeafter=after&"
+            f"searchdate=0&"
+            f"replyless=0&"
+            f"replylimit=0&"
+            f"showposts=0"
+        )
+        headers = {"User-Agent": shared_state.values["user_agent"]}
+
+        resp = requests.get(url, headers=headers, timeout=10).content
+        page = BeautifulSoup(resp, "html.parser")
+
+        for article in page.find_all("article"):
+            try:
+                link_tag = article.select_one("h4.font-weight-bold a")
+                if not link_tag:
+                    debug(f"No title link in search-article: {article}")
+                    continue
+                source = link_tag["href"]
+                title_raw = link_tag.text.strip()
+                title = (title_raw.
+                         replace(' - ', '-').
+                         replace(' ', '.').
+                         replace('(', '').
+                         replace(')', '')
+                         )
+
+                if not shared_state.is_valid_release(title,
+                                                     request_from,
+                                                     search_string,
+                                                     season,
+                                                     episode):
+                    continue
+
+                if 'lazylibrarian' in request_from.lower():
+                    # lazylibrarian can only detect specific date formats / issue numbering for magazines
+                    title = shared_state.normalize_magazine_title(title)
+
+                try:
+                    imdb_id = re.search(r"tt\d+", str(article)).group()
+                except:
+                    imdb_id = None
+
+                body_text = article.find("div", class_="card-body").get_text(" ")
+                m = re.search(r"(\d+(?:\.\d+)?\s*(?:GB|MB|KB|TB))", body_text, re.IGNORECASE)
+                if not m:
+                    debug(f"Size not found in search-article: {title_raw}")
+                    continue
+                size_item = extract_size(m.group(1).strip())
+                mb = shared_state.convert_to_mb(size_item)
+                size = mb * 1024 * 1024
+
+                published = parse_published_datetime(article)
+
+                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}"
+
+            except Exception as e:
+                info(f"Error parsing {hostname.upper()} search item: {e}")
+                continue
+
+            releases.append({
+                "details": {
+                    "title": title,
+                    "hostname": hostname.lower(),
+                    "imdb_id": imdb_id,
+                    "link": link,
+                    "mirror": mirror,
+                    "size": size,
+                    "date": published,
+                    "source": source
+                },
+                "type": "protected"
+            })
+
+    except Exception as e:
+        info(f"Error loading {hostname.upper()} search page: {e}")
+
+    elapsed = time.time() - start_time
+    debug(f"Search time: {elapsed:.2f}s ({hostname})")
+    return releases