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

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

quasarr/search/sources/dw.py

@@ -4,11 +4,17 @@
 
 import datetime
 import re
+import time
 from base64 import urlsafe_b64encode
 
 import requests
 from bs4 import BeautifulSoup
 
+from quasarr.providers.log import info, debug
+
+hostname = "dw"
+supported_mirrors = ["1fichier", "rapidgator", "ddownload", "katfile"]
+
 
 def convert_to_rss_date(date_str):
     german_months = ["Januar", "Februar", "März", "April", "Mai", "Juni",
@@ -28,98 +34,84 @@ def convert_to_rss_date(date_str):
 
 
 def extract_size(text):
-    match = re.match(r"(\d+) ([A-Za-z]+)", text)
+    # First try the normal pattern: number + space + unit (e.g., "1024 MB")
+    match = re.match(r"(\d+)\s+([A-Za-z]+)", text)
     if match:
         size = match.group(1)
         unit = match.group(2)
         return {"size": size, "sizeunit": unit}
-    else:
-        raise ValueError(f"Invalid size format: {text}")
-
-
-def dw_get_download_links(shared_state, content, title):
-    try:
-        try:
-            content = BeautifulSoup(content, "html.parser")
-        except:
-            content = BeautifulSoup(str(content), "html.parser")
-        download_buttons = content.findAll("button", {"class": "show_link"})
-    except:
-        print("DW hat die Detail-Seite angepasst. Parsen von Download-Links für " + title + " nicht möglich!")
-        return False
-
-    dw = shared_state.values["config"]("Hostnames").get("dw")
-    ajax_url = "https://" + dw + "/wp-admin/admin-ajax.php"
-
-    download_links = []
-    try:
-        for button in download_buttons:
-            payload = "action=show_link&link_id=" + button["value"]
-
-            headers = {
-                'User-Agent': shared_state.values["user_agent"],
-            }
 
-            response = requests.post(ajax_url, payload, headers=headers).json()
-            if response["success"]:
-                link = response["data"].split(",")[0]
+    # If that fails, try pattern with just unit (e.g., "MB")
+    unit_match = re.match(r"([A-Za-z]+)", text.strip())
+    if unit_match:
+        unit = unit_match.group(1)
+        # Fall back to 0 when size is missing
+        return {"size": "0", "sizeunit": unit}
 
-                if dw in link:
-                    match = re.search(r'https://' + dw + r'/azn/af\.php\?v=([A-Z0-9]+)(#.*)?', link)
-                    if match:
-                        link = (f'https://filecrypt.cc/Container/{match.group(1)}'
-                                f'.html{match.group(2) if match.group(2) else ""}')
+    # If neither pattern matches, raise the original error
+    raise ValueError(f"Invalid size format: {text}")
 
-                hoster = button.nextSibling.img["src"].split("/")[-1].replace(".png", "")
-                download_links.append([link, hoster])
-    except:
-        print("DW site has been updated. Parsing download links not possible!")
-        pass
 
-    return download_links
-
-
-def dw_feed(shared_state, request_from):
+def dw_feed(shared_state, start_time, request_from, mirror=None):
     releases = []
-    dw = shared_state.values["config"]("Hostnames").get("dw")
+    dw = shared_state.values["config"]("Hostnames").get(hostname.lower())
     password = dw
 
+    if not "arr" in request_from.lower():
+        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
+        return releases
+
     if "Radarr" in request_from:
         feed_type = "videos/filme/"
     else:
         feed_type = "videos/serien/"
 
+    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
+
     url = f'https://{dw}/{feed_type}'
     headers = {
         'User-Agent': shared_state.values["user_agent"],
     }
 
     try:
-        request = requests.get(url, headers=headers).content
+        request = requests.get(url, headers=headers, timeout=10).content
         feed = BeautifulSoup(request, "html.parser")
-        articles = feed.findAll('h4')
+        articles = feed.find_all('h4')
 
         for article in articles:
             try:
                 source = article.a["href"]
                 title = article.a.text.strip()
+
+                try:
+                    imdb_id = re.search(r'tt\d+', str(article)).group()
+                except:
+                    imdb_id = None
+
                 size_info = article.find("span").text.strip()
                 size_item = extract_size(size_info)
-                mb = shared_state.convert_to_mb(size_item) * 1024 * 1024
+                mb = shared_state.convert_to_mb(size_item)
+                size = mb * 1024 * 1024
                 date = article.parent.parent.find("span", {"class": "date updated"}).text.strip()
                 published = convert_to_rss_date(date)
-                payload = urlsafe_b64encode(f"{title}|{source}|{mb}|{password}".encode("utf-8")).decode(
-                    "utf-8")
+                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:
-                print(f"Error parsing DW feed: {e}")
+                info(f"Error parsing {hostname.upper()} feed: {e}")
                 continue
 
             releases.append({
                 "details": {
-                    "title": f"[DW] {title}",
+                    "title": title,
+                    "hostname": hostname.lower(),
+                    "imdb_id": imdb_id,
                     "link": link,
-                    "size": mb,
+                    "mirror": mirror,
+                    "size": size,
                     "date": published,
                     "source": source
                 },
@@ -127,61 +119,96 @@ def dw_feed(shared_state, request_from):
             })
 
     except Exception as e:
-        print(f"Error loading DW feed: {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
 
 
-def dw_search(shared_state, request_from, imdb_id):
+def dw_search(shared_state, start_time, request_from, search_string, mirror=None, season=None, episode=None):
     releases = []
-    dw = shared_state.values["config"]("Hostnames").get("dw")
+    dw = shared_state.values["config"]("Hostnames").get(hostname.lower())
     password = dw
 
+    if not "arr" in request_from.lower():
+        debug(f'Skipping {request_from} search on "{hostname.upper()}" (unsupported media type)!')
+        return releases
+
+
     if "Radarr" in request_from:
         search_type = "videocategory=filme"
     else:
         search_type = "videocategory=serien"
 
-    url = f'https://{dw}/?s={imdb_id}&{search_type}'
+    if mirror and mirror not in ["1fichier", "rapidgator", "ddownload", "katfile"]:
+        debug(f'Mirror "{mirror}" not not supported by {hostname.upper()}. Skipping search!')
+        return releases
+
+    url = f'https://{dw}/?s={search_string}&{search_type}'
     headers = {
         'User-Agent': shared_state.values["user_agent"],
     }
 
     try:
-        request = requests.get(url, headers=headers).content
+        request = requests.get(url, headers=headers, timeout=10).content
         search = BeautifulSoup(request, "html.parser")
-        results = search.findAll('h4')
+        results = search.find_all('h4')
 
     except Exception as e:
-        print(f"Error loading DW search feed: {e}")
+        info(f"Error loading {hostname.upper()} search feed: {e}")
         return releases
 
+    imdb_id = shared_state.is_imdb_id(search_string)
+
     if results:
         for result in results:
             try:
-                source = result.a["href"]
                 title = result.a.text.strip()
+
+                if not shared_state.is_valid_release(title,
+                                                                     request_from,
+                                                                     search_string,
+                                                                     season,
+                                                                     episode):
+                    continue
+
+                if not imdb_id:
+                    try:
+                        imdb_id = re.search(r'tt\d+', str(result)).group()
+                    except:
+                        imdb_id = None
+
+                source = result.a["href"]
                 size_info = result.find("span").text.strip()
                 size_item = extract_size(size_info)
-                mb = shared_state.convert_to_mb(size_item) * 1024 * 1024
+                mb = shared_state.convert_to_mb(size_item)
+                size = mb * 1024 * 1024
                 date = result.parent.parent.find("span", {"class": "date updated"}).text.strip()
                 published = convert_to_rss_date(date)
-                payload = urlsafe_b64encode(f"{title}|{source}|{mb}|{password}".encode("utf-8")).decode(
-                    "utf-8")
+                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:
-                print(f"Error parsing DW search: {e}")
+                info(f"Error parsing {hostname.upper()} search: {e}")
                 continue
 
             releases.append({
                 "details": {
-                    "title": f"[DW] {title}",
+                    "title": title,
+                    "hostname": hostname.lower(),
+                    "imdb_id": imdb_id,
                     "link": link,
-                    "size": mb,
+                    "mirror": mirror,
+                    "size": size,
                     "date": published,
                     "source": source
                 },
                 "type": "protected"
             })
 
+    elapsed_time = time.time() - start_time
+    debug(f"Time taken: {elapsed_time:.2f}s ({hostname})")
+
     return releases