quasarr 1.3.5__py3-none-any.whl → 1.20.4__py3-none-any.whl

quasarr/providers/shared_state.py

@@ -6,7 +6,8 @@ import json
 import os
 import re
 import time
-from datetime import datetime, timedelta
+import traceback
+from datetime import datetime, timedelta, date
 from urllib import parse
 
 import quasarr
@@ -18,6 +19,26 @@ from quasarr.storage.sqlite_database import DataBase
 values = {}
 lock = None
 
+# regex to detect season/episode tags for series filtering during search
+SEASON_EP_REGEX = re.compile(r"(?i)(?:S\d{1,3}(?:E\d{1,3}(?:-\d{1,3})?)?|S\d{1,3}-\d{1,3})")
+# regex to filter out season/episode tags for movies
+MOVIE_REGEX = re.compile(r"^(?!.*(?:S\d{1,3}(?:E\d{1,3}(?:-\d{1,3})?)?|S\d{1,3}-\d{1,3})).*$", re.IGNORECASE)
+# List of known file hosters that should not be used as search/feed sites
+SHARE_HOSTERS = {
+    "rapidgator",
+    "ddownload",
+    "keep2share",
+    "1fichier",
+    "katfile",
+    "filer",
+    "turbobit",
+    "nitroflare",
+    "filefactory",
+    "uptobox",
+    "mediafire",
+    "mega",
+}
+
 
 def set_state(manager_dict, manager_lock):
     global values
@@ -50,30 +71,44 @@ def set_files(config_path):
 
 
 def generate_api_key():
-    api_key = os.urandom(24).hex()
+    api_key = os.urandom(32).hex()
     Config('API').save("key", api_key)
     info(f'API key replaced with: "{api_key}!"')
     return api_key
 
 
 def extract_valid_hostname(url, shorthand):
-    # Check if both characters from the shorthand appear in the url
     try:
         if '://' not in url:
             url = 'http://' + url
         result = parse.urlparse(url)
         domain = result.netloc
+        parts = domain.split('.')
+
+        if domain.startswith(".") or domain.endswith(".") or "." not in domain[1:-1]:
+            message = f'Error: "{domain}" must contain a "." somewhere in the middle – you need to provide a full domain name!'
+            domain = None
+
+        elif any(hoster in parts for hoster in SHARE_HOSTERS):
+            offending = next(host for host in parts if host in SHARE_HOSTERS)
+            message = (
+                f'Error: "{domain}" is a file‑hosting domain and cannot be used here directly! '
+                f'Instead please provide a valid hostname that serves direct file links (including "{offending}").'
+            )
+            domain = None
+
+        elif all(char in domain for char in shorthand):
+            message = f'"{domain}" contains both characters from shorthand "{shorthand}". Continuing...'
 
-        # Check if both characters in the shorthand are in the domain
-        if all(char in domain for char in shorthand):
-            print(f'"{domain}" matches both characters from "{shorthand}". Continuing...')
-            return domain
         else:
-            print(f'Invalid domain "{domain}": Does not contain both characters from shorthand "{shorthand}"')
-            return None
+            message = f'Error: "{domain}" does not contain both characters from shorthand "{shorthand}".'
+            domain = None
     except Exception as e:
-        print(f"Error parsing URL {url}: {e}")
-        return None
+        message = f"Error: {e}. Please provide a valid URL."
+        domain = None
+
+    print(message)
+    return {"domain": domain, "message": message}
 
 
 def connect_to_jd(jd, user, password, device_name):
@@ -240,12 +275,30 @@ def set_device_settings():
             "setting": "DeleteArchiveDownloadlinksAfterExtraction",
             "expected_value": False,  # Links must be kept after extraction for Quasarr to work
         },
+        {
+            "namespace": "org.jdownloader.gui.views.linkgrabber.addlinksdialog.LinkgrabberSettings",
+            "storage": None,
+            "setting": "OfflinePackageEnabled",
+            "expected_value": False,  # Don't move offline links to extra package
+        },
         {
             "namespace": "org.jdownloader.gui.views.linkgrabber.addlinksdialog.LinkgrabberSettings",
             "storage": None,
             "setting": "HandleOfflineOnConfirmLatestSelection",
-            "expected_value": "EXCLUDE_OFFLINE_AND_REMOVE",  # Prevents popup starting download with offline mirrors
-        }
+            "expected_value": "INCLUDE_OFFLINE",  # Offline links must always be kept for Quasarr to handle packages
+        },
+        {
+            "namespace": "org.jdownloader.gui.views.linkgrabber.addlinksdialog.LinkgrabberSettings",
+            "storage": None,
+            "setting": "AutoConfirmManagerHandleOffline",
+            "expected_value": "INCLUDE_OFFLINE",  # Offline links must always be kept for Quasarr to handle packages
+        },
+        {
+            "namespace": "org.jdownloader.gui.views.linkgrabber.addlinksdialog.LinkgrabberSettings",
+            "storage": None,
+            "setting": "DefaultOnAddedOfflineLinksAction",
+            "expected_value": "INCLUDE_OFFLINE",  # Offline links must always be kept for Quasarr to handle packages
+        },
     ]
 
     for setting in settings_to_enforce:
@@ -293,7 +346,7 @@ def set_device_settings():
                  'filenameFilter': {
                      'enabled': True,
                      'matchType': 'CONTAINS',
-                     'regex': '.*\\.(sfv|jpe?g|idx|sub|srt|nfo|bat|txt|exe)',
+                     'regex': '.*\\.(sfv|jpe?g|idx|srt|nfo|bat|txt|exe)',
                      'useRegex': True
                  },
                  'filesizeFilter': {'enabled': False, 'from': 0, 'matchType': 'BETWEEN', 'to': 0},
@@ -401,12 +454,39 @@ def convert_to_mb(item):
     return int(size_mb)
 
 
+def sanitize_title(title: str) -> str:
+    umlaut_map = {
+        "Ä": "Ae", "ä": "ae",
+        "Ö": "Oe", "ö": "oe",
+        "Ü": "Ue", "ü": "ue",
+        "ß": "ss"
+    }
+    for umlaut, replacement in umlaut_map.items():
+        title = title.replace(umlaut, replacement)
+
+    title = title.encode("ascii", errors="ignore").decode()
+
+    # Replace slashes and spaces with dots
+    title = title.replace("/", "").replace(" ", ".")
+    title = title.strip(".")  # no leading/trailing dots
+    title = title.replace(".-.", "-")  # .-. → -
+
+    # Finally, drop any chars except letters, digits, dots, hyphens, ampersands
+    title = re.sub(r"[^A-Za-z0-9.\-&]", "", title)
+
+    # remove any repeated dots
+    title = re.sub(r"\.{2,}", ".", title)
+    return title
+
+
 def sanitize_string(s):
     s = s.lower()
 
     # Remove dots / pluses
     s = s.replace('.', ' ')
     s = s.replace('+', ' ')
+    s = s.replace('_', ' ')
+    s = s.replace('-', ' ')
 
     # Umlauts
     s = re.sub(r'ä', 'ae', s)
@@ -433,13 +513,6 @@ def sanitize_string(s):
     return s
 
 
-def is_imdb_id(search_string):
-    if bool(re.fullmatch(r"tt\d{7,}", search_string)):
-        return search_string
-    else:
-        return None
-
-
 def search_string_in_sanitized_title(search_string, title):
     sanitized_search_string = sanitize_string(search_string)
     sanitized_title = sanitize_string(title)
@@ -453,12 +526,284 @@ def search_string_in_sanitized_title(search_string, title):
         return False
 
 
+def is_imdb_id(search_string):
+    if bool(re.fullmatch(r"tt\d{7,}", search_string)):
+        return search_string
+    else:
+        return None
+
+
+def match_in_title(title: str, season: int = None, episode: int = None) -> bool:
+    # ensure season/episode are ints (or None)
+    if isinstance(season, str):
+        try:
+            season = int(season)
+        except ValueError:
+            season = None
+    if isinstance(episode, str):
+        try:
+            episode = int(episode)
+        except ValueError:
+            episode = None
+
+    pattern = re.compile(
+        r"(?i)(?:\.|^)[sS](\d+)(?:-(\d+))?"  # season or season‑range
+        r"(?:[eE](\d+)(?:-(?:[eE]?)(\d+))?)?"  # episode or episode‑range
+        r"(?=[\.-]|$)"
+    )
+
+    matches = pattern.findall(title)
+    if not matches:
+        return False
+
+    for s_start, s_end, e_start, e_end in matches:
+        se_start, se_end = int(s_start), int(s_end or s_start)
+
+        # if a season was requested, ensure it falls in the range
+        if season is not None and not (se_start <= season <= se_end):
+            continue
+
+        # if no episode requested, only accept if the title itself had no episode tag
+        if episode is None:
+            if not e_start:
+                return True
+            else:
+                # title did specify an episode — skip this match
+                continue
+
+        # episode was requested, so title must supply one
+        if not e_start:
+            continue
+
+        ep_start, ep_end = int(e_start), int(e_end or e_start)
+        if ep_start <= episode <= ep_end:
+            return True
+
+    return False
+
+
+def is_valid_release(title: str,
+                     request_from: str,
+                     search_string: str,
+                     season: int = None,
+                     episode: int = None) -> bool:
+    """
+    Return True if the given release title is valid for the given search parameters.
+    - title: the release title to test
+    - request_from: user agent, contains 'Radarr' for movie searches or 'Sonarr' for TV searches
+    - search_string: the original search phrase (could be an IMDb id or plain text)
+    - season: desired season number (or None)
+    - episode: desired episode number (or None)
+    """
+    try:
+        # Determine whether this is a movie or TV search
+        rf = request_from.lower()
+        is_movie_search = 'radarr' in rf
+        is_tv_search = 'sonarr' in rf
+        is_docs_search = 'lazylibrarian' in rf
+
+        # if search string is NOT an imdb id check search_string_in_sanitized_title - if not match, its not valid
+        if not is_docs_search and not is_imdb_id(search_string):
+            if not search_string_in_sanitized_title(search_string, title):
+                debug(f"Skipping {title!r} as it doesn't match sanitized search string: {search_string!r}")
+                return False
+
+
+        # if it's a movie search, don't allow any TV show titles (check for NO season or episode tags in the title)
+        if is_movie_search:
+            if not MOVIE_REGEX.match(title):
+                debug(f"Skipping {title!r} as title doesn't match movie regex: {MOVIE_REGEX.pattern}")
+                return False
+            return True
+
+        # if it's a TV show search, don't allow any movies (check for season or episode tags in the title)
+        if is_tv_search:
+            # must have some S/E tag present
+            if not SEASON_EP_REGEX.search(title):
+                debug(f"Skipping {title!r} as title doesn't match TV show regex: {SEASON_EP_REGEX.pattern}")
+                return False
+            # if caller specified a season or episode, double‑check the match
+            if season is not None or episode is not None:
+                if not match_in_title(title, season, episode):
+                    debug(f"Skipping {title!r} as it doesn't match season {season} and episode {episode}")
+                    return False
+            return True
+
+        # if it's a document search, it should not contain Movie or TV show tags
+        if is_docs_search:
+            # must NOT have any S/E tag present
+            if SEASON_EP_REGEX.search(title):
+                debug(f"Skipping {title!r} as title matches TV show regex: {SEASON_EP_REGEX.pattern}")
+                return False
+            return True
+
+        # unknown search source — reject by default
+        debug(f"Skipping {title!r} as search source is unknown: {request_from!r}")
+        return False
+
+    except Exception as e:
+        # log exception message and short stack trace
+        tb = traceback.format_exc()
+        debug(f"Exception in is_valid_release: {e!r}\n{tb}"
+              f"is_valid_release called with "
+              f"title={title!r}, request_from={request_from!r}, "
+              f"search_string={search_string!r}, season={season!r}, episode={episode!r}")
+        return False
+
+
+def normalize_magazine_title(title: str) -> str:
+    """
+    Massage magazine titles so LazyLibrarian's parser can pick up dates reliably:
+    - Convert date-like patterns into space-delimited numeric tokens (YYYY MM DD or YYYY MM).
+    - Handle malformed "DD.YYYY.YYYY" cases (e.g., 04.2006.2025 → 2025 06 04).
+    - Convert two-part month-year like "3.25" into YYYY MM.
+    - Convert "No/Nr/Sonderheft X.YYYY" when X≤12 into YYYY MM.
+    - Preserve pure issue/volume prefixes and other digit runs untouched.
+    """
+    title = title.strip()
+
+    # 0) Bug: DD.YYYY.YYYY -> treat second YYYY's last two digits as month
+    def repl_bug(match):
+        d = int(match.group(1))
+        m_hint = match.group(2)
+        y = int(match.group(3))
+        m = int(m_hint[-2:])
+        try:
+            date(y, m, d)
+            return f"{y:04d} {m:02d} {d:02d}"
+        except ValueError:
+            return match.group(0)
+
+    title = re.sub(r"\b(\d{1,2})\.(20\d{2})\.(20\d{2})\b", repl_bug, title)
+
+    # 1) DD.MM.YYYY -> "YYYY MM DD"
+    def repl_dmy(match):
+        d, m, y = map(int, match.groups())
+        try:
+            date(y, m, d)
+            return f"{y:04d} {m:02d} {d:02d}"
+        except ValueError:
+            return match.group(0)
+
+    title = re.sub(r"\b(\d{1,2})\.(\d{1,2})\.(\d{4})\b", repl_dmy, title)
+
+    # 2) DD[.]? MonthName YYYY (optional 'vom') -> "YYYY MM DD"
+    def repl_dmony(match):
+        d = int(match.group(1))
+        name = match.group(2)
+        y = int(match.group(3))
+        mm = _month_num(name)
+        if mm:
+            try:
+                date(y, mm, d)
+                return f"{y:04d} {mm:02d} {d:02d}"
+            except ValueError:
+                pass
+        return match.group(0)
+
+    title = re.sub(
+        r"\b(?:vom\s*)?(\d{1,2})\.?\s+([A-Za-zÄÖÜäöüß]+)\s+(\d{4})\b",
+        repl_dmony,
+        title,
+        flags=re.IGNORECASE
+    )
+
+    # 3) MonthName YYYY -> "YYYY MM"
+    def repl_mony(match):
+        name = match.group(1)
+        y = int(match.group(2))
+        mm = _month_num(name)
+        if mm:
+            try:
+                date(y, mm, 1)
+                return f"{y:04d} {mm:02d}"
+            except ValueError:
+                pass
+        return match.group(0)
+
+    title = re.sub(r"\b([A-Za-zÄÖÜäöüß]+)\s+(\d{4})\b", repl_mony, title, flags=re.IGNORECASE)
+
+    # 4) YYYYMMDD -> "YYYY MM DD"
+    def repl_ymd(match):
+        y = int(match.group(1))
+        m = int(match.group(2))
+        d = int(match.group(3))
+        try:
+            date(y, m, d)
+            return f"{y:04d} {m:02d} {d:02d}"
+        except ValueError:
+            return match.group(0)
+
+    title = re.sub(r"\b(20\d{2})(0[1-9]|1[0-2])(0[1-9]|[12]\d|3[01])\b", repl_ymd, title)
+
+    # 5) YYYYMM -> "YYYY MM"
+    def repl_ym(match):
+        y = int(match.group(1))
+        m = int(match.group(2))
+        try:
+            date(y, m, 1)
+            return f"{y:04d} {m:02d}"
+        except ValueError:
+            return match.group(0)
+
+    title = re.sub(r"\b(20\d{2})(0[1-9]|1[0-2])\b", repl_ym, title)
+
+    # 6) X.YY (month.two-digit-year) -> "YYYY MM" (e.g., 3.25 -> 2025 03)
+    def repl_my2(match):
+        mm = int(match.group(1))
+        yy = int(match.group(2))
+        y = 2000 + yy
+        if 1 <= mm <= 12:
+            try:
+                date(y, mm, 1)
+                return f"{y:04d} {mm:02d}"
+            except ValueError:
+                pass
+        return match.group(0)
+
+    title = re.sub(r"\b([1-9]|1[0-2])\.(\d{2})\b", repl_my2, title)
+
+    # 7) No/Nr/Sonderheft <1-12>.<YYYY> -> "YYYY MM"
+    def repl_nmy(match):
+        num = int(match.group(1))
+        y = int(match.group(2))
+        if 1 <= num <= 12:
+            try:
+                date(y, num, 1)
+                return f"{y:04d} {num:02d}"
+            except ValueError:
+                pass
+        return match.group(0)
+
+    title = re.sub(
+        r"\b(?:No|Nr|Sonderheft)\s*(\d{1,2})\.(\d{4})\b",
+        repl_nmy,
+        title,
+        flags=re.IGNORECASE
+    )
+
+    return title
+
+
+# Helper for month name mapping
+def _month_num(name: str) -> int:
+    name = name.lower()
+    mmap = {
+        'januar': 1, 'jan': 1, 'februar': 2, 'feb': 2, 'märz': 3, 'maerz': 3, 'mär': 3, 'mrz': 3, 'mae': 3,
+        'april': 4, 'apr': 4, 'mai': 5, 'juni': 6, 'jun': 6, 'juli': 7, 'jul': 7, 'august': 8, 'aug': 8,
+        'september': 9, 'sep': 9, 'oktober': 10, 'okt': 10, 'november': 11, 'nov': 11, 'dezember': 12, 'dez': 12,
+        'january': 1, 'february': 2, 'march': 3, 'april': 4, 'may': 5, 'june': 6, 'july': 7, 'august': 8,
+        'september': 9, 'october': 10, 'november': 11, 'december': 12
+    }
+    return mmap.get(name)
+
+
 def get_recently_searched(shared_state, context, timeout_seconds):
     recently_searched = shared_state.values.get(context, {})
     threshold = datetime.now() - timedelta(seconds=timeout_seconds)
     keys_to_remove = [key for key, value in recently_searched.items() if value["timestamp"] <= threshold]
     for key in keys_to_remove:
-        debug(f"Removing '/{key}' from recently searched memory ({context})...")
+        debug(f"Removing '{key}' from recently searched memory ({context})...")
         del recently_searched[key]
     return recently_searched
 
@@ -467,7 +812,7 @@ def download_package(links, title, password, package_id):
     device = get_device()
     downloaded = device.linkgrabber.add_links(params=[
         {
-            "autostart": True,
+            "autostart": False,
             "links": json.dumps(links),
             "packageName": title,
             "extractPassword": password,

quasarr/providers/statistics.py

@@ -0,0 +1,154 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+from typing import Dict, Any
+
+
+class StatsHelper:
+    """
+    Multiprocessing-safe stats helper using separate rows.
+    Uses shared_state for database access across processes.
+    """
+
+    def __init__(self, shared_state):
+        self.shared_state = shared_state
+        self._ensure_stats_exist()
+
+    def _get_db(self):
+        """Get database interface through shared_state"""
+        return self.shared_state.values["database"]("statistics")
+
+    def _ensure_stats_exist(self):
+        """Initialize stats if they don't exist"""
+        default_stats = {
+            "packages_downloaded": 0,
+            "links_processed": 0,
+            "captcha_decryptions_automatic": 0,
+            "captcha_decryptions_manual": 0,
+            "failed_downloads": 0,
+            "failed_decryptions_automatic": 0,
+            "failed_decryptions_manual": 0
+        }
+
+        db = self._get_db()
+        for key, default_value in default_stats.items():
+            if db.retrieve(key) is None:
+                db.store(key, str(default_value))
+
+    def _get_stat(self, key: str, default: int = 0) -> int:
+        """Get a single stat value"""
+        try:
+            db = self._get_db()
+            value = db.retrieve(key)
+            return int(value) if value is not None else default
+        except (ValueError, TypeError):
+            return default
+
+    def _increment_stat(self, key: str, count: int = 1):
+        """Process-safe increment of a single stat"""
+        db = self._get_db()
+        current = self._get_stat(key, 0)
+        db.update_store(key, str(current + count))
+
+    def increment_package_with_links(self, links):
+        """Increment package downloaded and links processed for one package, or failed download if no links
+
+        Args:
+            links: Can be:
+                - list/array: counts the length
+                - int: uses the value directly  
+                - None/False/empty: treats as failed download
+        """
+        # Handle different input types
+        if links is None or links is False:
+            link_count = 0
+        elif isinstance(links, (list, tuple)):
+            link_count = len(links)
+        elif isinstance(links, int):
+            link_count = links
+        else:
+            # Handle other falsy values or unexpected types
+            try:
+                link_count = int(links) if links else 0
+            except (ValueError, TypeError):
+                link_count = 0
+
+        # Now handle the actual increment logic
+        if link_count == 0:
+            self._increment_stat("failed_downloads", 1)
+        else:
+            self._increment_stat("packages_downloaded", 1)
+            self._increment_stat("links_processed", link_count)
+
+    def increment_captcha_decryptions_automatic(self):
+        """Increment automatic captcha decryptions counter"""
+        self._increment_stat("captcha_decryptions_automatic", 1)
+
+    def increment_captcha_decryptions_manual(self):
+        """Increment manual captcha decryptions counter"""
+        self._increment_stat("captcha_decryptions_manual", 1)
+
+    def increment_failed_downloads(self):
+        """Increment failed downloads counter"""
+        self._increment_stat("failed_downloads", 1)
+
+    def increment_failed_decryptions_automatic(self):
+        """Increment failed automatic decryptions counter"""
+        self._increment_stat("failed_decryptions_automatic", 1)
+
+    def increment_failed_decryptions_manual(self):
+        """Increment failed manual decryptions counter"""
+        self._increment_stat("failed_decryptions_manual", 1)
+
+    def get_stats(self) -> Dict[str, Any]:
+        """Get all current statistics"""
+        stats = {
+            "packages_downloaded": self._get_stat("packages_downloaded", 0),
+            "links_processed": self._get_stat("links_processed", 0),
+            "captcha_decryptions_automatic": self._get_stat("captcha_decryptions_automatic", 0),
+            "captcha_decryptions_manual": self._get_stat("captcha_decryptions_manual", 0),
+            "failed_downloads": self._get_stat("failed_downloads", 0),
+            "failed_decryptions_automatic": self._get_stat("failed_decryptions_automatic", 0),
+            "failed_decryptions_manual": self._get_stat("failed_decryptions_manual", 0)
+        }
+
+        # Calculate totals and rates
+        total_captcha_decryptions = stats["captcha_decryptions_automatic"] + stats["captcha_decryptions_manual"]
+        total_failed_decryptions = stats["failed_decryptions_automatic"] + stats["failed_decryptions_manual"]
+        total_download_attempts = stats["packages_downloaded"] + stats["failed_downloads"]
+        total_decryption_attempts = total_captcha_decryptions + total_failed_decryptions
+        total_automatic_attempts = stats["captcha_decryptions_automatic"] + stats["failed_decryptions_automatic"]
+        total_manual_attempts = stats["captcha_decryptions_manual"] + stats["failed_decryptions_manual"]
+
+        # Add calculated fields
+        stats.update({
+            "total_captcha_decryptions": total_captcha_decryptions,
+            "total_failed_decryptions": total_failed_decryptions,
+            "total_download_attempts": total_download_attempts,
+            "total_decryption_attempts": total_decryption_attempts,
+            "total_automatic_attempts": total_automatic_attempts,
+            "total_manual_attempts": total_manual_attempts,
+            "download_success_rate": (
+                (stats["packages_downloaded"] / total_download_attempts * 100)
+                if total_download_attempts > 0 else 0
+            ),
+            "decryption_success_rate": (
+                (total_captcha_decryptions / total_decryption_attempts * 100)
+                if total_decryption_attempts > 0 else 0
+            ),
+            "automatic_decryption_success_rate": (
+                (stats["captcha_decryptions_automatic"] / total_automatic_attempts * 100)
+                if total_automatic_attempts > 0 else 0
+            ),
+            "manual_decryption_success_rate": (
+                (stats["captcha_decryptions_manual"] / total_manual_attempts * 100)
+                if total_manual_attempts > 0 else 0
+            ),
+            "average_links_per_package": (
+                stats["links_processed"] / stats["packages_downloaded"]
+                if stats["packages_downloaded"] > 0 else 0
+            )
+        })
+
+        return stats