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

quasarr/providers/myjd_api.py

@@ -38,7 +38,7 @@ import requests
 import urllib3
 from Cryptodome.Cipher import AES
 
-from quasarr.providers.log import debug
+from quasarr.providers.log import info, debug
 from quasarr.providers.version import get_version
 
 urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
@@ -569,6 +569,8 @@ class Myjdapi:
     Main class for connecting to JD API.
 
     """
+    # Class variable to track connection failures across all instances
+    _connection_failed_at = None
 
     def __init__(self):
         """
@@ -708,6 +710,15 @@ class Myjdapi:
         :returns: boolean -- True if succesful, False if there was any error.
 
         """
+        # Check if we're in cooldown period (5 minutes = 300 seconds)
+        if Myjdapi._connection_failed_at is not None:
+            time_since_failure = time.time() - Myjdapi._connection_failed_at
+            if time_since_failure < 300:
+                # Silently return False during cooldown - don't log anything
+                return False
+            # Cooldown expired, reset for retry
+            Myjdapi._connection_failed_at = None
+
         self.update_request_id()
         self.__login_secret = None
         self.__device_secret = None
@@ -723,6 +734,15 @@ class Myjdapi:
         response = self.request_api("/my/connect", "GET", [("email", email),
                                                            ("appkey",
                                                             self.__app_key)])
+
+        if response is None:
+            # Log and set failure timestamp
+            info("JDownloader API is currently unavailable! Stopping connection attempts for 5 minutes.")
+            Myjdapi._connection_failed_at = time.time()
+            return False
+
+        # Connection successful, reset failure timestamp
+        Myjdapi._connection_failed_at = None
         self.__connected = True
         self.update_request_id()
         self.__session_token = response["sessiontoken"]
@@ -826,9 +846,16 @@ class Myjdapi:
             }
             try:
                 encrypted_response = requests.get(api + query, timeout=timeout, headers=headers)
+            except requests.exceptions.ConnectionError:
+                return None
             except Exception:
-                encrypted_response = requests.get(api + query, timeout=timeout, headers=headers, verify=False)
-                debug("Could not establish secure connection to JDownloader.")
+                try:
+                    encrypted_response = requests.get(api + query, timeout=timeout, headers=headers, verify=False)
+                    debug("Could not establish secure connection to JDownloader. Is your time / timezone correct?")
+                except requests.exceptions.ConnectionError:
+                    return None
+                except Exception:
+                    return None
         else:
             params_request = []
             if params is not None:
@@ -863,6 +890,8 @@ class Myjdapi:
                     data=encrypted_data,
                     timeout=timeout
                 )
+            except requests.exceptions.ConnectionError:
+                return None
             except Exception:
                 try:
                     encrypted_response = requests.post(
@@ -875,7 +904,9 @@ class Myjdapi:
                         timeout=timeout,
                         verify=False
                     )
-                    debug("Could not establish secure connection to JDownloader.")
+                    debug("Could not establish secure connection to JDownloader. Is your time / timezone correct?")
+                except requests.exceptions.ConnectionError:
+                    return None
                 except Exception:
                     return None
         if encrypted_response.status_code == 403:

quasarr/providers/sessions/dl.py

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import base64
+import pickle
+
+import requests
+from bs4 import BeautifulSoup
+
+from quasarr.providers.log import info, debug
+
+hostname = "dl"
+
+
+def create_and_persist_session(shared_state):
+    """
+    Create and persist a session using user and password.
+    
+    Args:
+        shared_state: Shared state object
+    
+    Returns:
+        requests.Session or None
+    """
+    cfg = shared_state.values["config"]("Hostnames")
+    host = cfg.get(hostname)
+    credentials_cfg = shared_state.values["config"](hostname.upper())
+    
+    user = credentials_cfg.get("user")
+    password = credentials_cfg.get("password")
+
+    if not user or not password:
+        info(f'Missing credentials for: "{hostname}" - user and password are required')
+        return None
+
+    sess = requests.Session()
+    
+    # Set user agent
+    ua = shared_state.values["user_agent"]
+    sess.headers.update({'User-Agent': ua})
+    
+    try:
+        # Step 1: Get login page to retrieve CSRF token
+        login_page_url = f'https://www.{host}/login/'
+        login_page = sess.get(login_page_url, timeout=30)
+        
+        if login_page.status_code != 200:
+            info(f'Failed to load login page for: "{hostname}" - Status {login_page.status_code}')
+            return None
+        
+        # Extract CSRF token from login form
+        soup = BeautifulSoup(login_page.text, 'html.parser')
+        csrf_input = soup.find('input', {'name': '_xfToken'})
+        
+        if not csrf_input or not csrf_input.get('value'):
+            info(f'Could not find CSRF token on login page for: "{hostname}"')
+            return None
+        
+        csrf_token = csrf_input['value']
+        
+        # Step 2: Submit login form
+        login_data = {
+            'login': user,
+            'password': password,
+            '_xfToken': csrf_token,
+            'remember': '1',
+            '_xfRedirect': f'https://www.{host}/'
+        }
+        
+        login_url = f'https://www.{host}/login/login'
+        login_response = sess.post(login_url, data=login_data, timeout=30)
+        
+        # Step 3: Verify login success
+        # Check if we're logged in by accessing the main page
+        verify_response = sess.get(f'https://www.{host}/', timeout=30)
+        
+        if 'data-logged-in="true"' not in verify_response.text:
+            info(f'Login verification failed for: "{hostname}" - invalid credentials or login failed')
+            return None
+        
+        info(f'Session successfully created for: "{hostname}" using user/password')
+    except Exception as e:
+        info(f'Failed to create session for: "{hostname}" - {e}')
+        return None
+
+    # Persist session to database
+    blob = pickle.dumps(sess)
+    token = base64.b64encode(blob).decode("utf-8")
+    shared_state.values["database"]("sessions").update_store(hostname, token)
+    
+    return sess
+
+
+def retrieve_and_validate_session(shared_state):
+    """
+    Retrieve session from database or create a new one.
+    
+    Args:
+        shared_state: Shared state object
+    
+    Returns:
+        requests.Session or None
+    """
+    db = shared_state.values["database"]("sessions")
+    token = db.retrieve(hostname)
+    if not token:
+        return create_and_persist_session(shared_state)
+
+    try:
+        blob = base64.b64decode(token.encode("utf-8"))
+        sess = pickle.loads(blob)
+        if not isinstance(sess, requests.Session):
+            raise ValueError("Not a Session")
+    except Exception as e:
+        debug(f"{hostname}: session load failed: {e}")
+        return create_and_persist_session(shared_state)
+
+    return sess
+
+
+def invalidate_session(shared_state):
+    """
+    Invalidate the current session.
+    
+    Args:
+        shared_state: Shared state object
+    """
+    db = shared_state.values["database"]("sessions")
+    db.delete(hostname)
+    debug(f'Session for "{hostname}" marked as invalid!')
+
+
+def _persist_session_to_db(shared_state, sess):
+    """
+    Serialize & store the given requests.Session into the database under `hostname`.
+    
+    Args:
+        shared_state: Shared state object
+        sess: requests.Session to persist
+    """
+    blob = pickle.dumps(sess)
+    token = base64.b64encode(blob).decode("utf-8")
+    shared_state.values["database"]("sessions").update_store(hostname, token)
+
+
+def fetch_via_requests_session(shared_state, method: str, target_url: str, post_data: dict = None, get_params: dict = None, timeout: int = 30):
+    """
+    Execute request using the session.
+    
+    Args:
+        shared_state: Shared state object
+        method: "GET" or "POST"
+        target_url: URL to fetch
+        post_data: POST data (for POST requests)
+        get_params: URL parameters (for GET requests)
+        timeout: Request timeout in seconds
+    
+    Returns:
+        Response object
+    """
+    sess = retrieve_and_validate_session(shared_state)
+    if not sess:
+        raise Exception(f"Could not retrieve valid session for {hostname}")
+
+    # Execute request
+    if method.upper() == "GET":
+        resp = sess.get(target_url, params=get_params, timeout=timeout)
+    else:  # POST
+        resp = sess.post(target_url, data=post_data, timeout=timeout)
+
+    # Re-persist cookies, since the site might have modified them during the request
+    _persist_session_to_db(shared_state, sess)
+
+    return resp

quasarr/providers/shared_state.py

@@ -188,6 +188,7 @@ def connect_device():
 
 def get_device():
     attempts = 0
+    last_backoff_change = 0  # Track when we last changed backoff strategy
 
     while True:
         try:
@@ -199,14 +200,30 @@ def get_device():
 
         update("device", False)
 
-        if attempts % 10 == 0:
-            info(
-                f"WARNING: {attempts} consecutive JDownloader connection errors. Please check your credentials!")
-        time.sleep(3)
+        # Determine sleep time based on failure count
+        if attempts <= 10:
+            # First 10 failures: 3 seconds
+            sleep_time = 3
+            if attempts == 10:
+                info(f"WARNING: {attempts} consecutive JDownloader connection errors. Switching to 1-minute intervals.")
+        elif attempts <= 15:
+            # Next 5 failures (11-15): 1 minute
+            sleep_time = 60
+            if attempts % 10 == 0:
+                info(f"WARNING: {attempts} consecutive JDownloader connection errors. Please check your credentials!")
+            if attempts == 15:
+                info(f"WARNING: Still failing after {attempts} attempts. Switching to 5-minute intervals.")
+        else:
+            # After 15 failures: 5 minutes
+            sleep_time = 300
+            if attempts % 10 == 0:
+                info(f"WARNING: {attempts} consecutive JDownloader connection errors. Please check your credentials!")
 
         if connect_device():
             break
 
+        time.sleep(sleep_time)
+
     return values["device"]
 
 
@@ -608,7 +625,6 @@ def is_valid_release(title: str,
                 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):

quasarr/providers/version.py

@@ -8,7 +8,7 @@ import requests
 
 
 def get_version():
-    return "1.20.7"
+    return "1.21.0"
 
 
 def get_latest_version():

quasarr/search/__init__.py

@@ -10,6 +10,7 @@ from quasarr.search.sources.al import al_feed, al_search
 from quasarr.search.sources.by import by_feed, by_search
 from quasarr.search.sources.dd import dd_search, dd_feed
 from quasarr.search.sources.dj import dj_search, dj_feed
+from quasarr.search.sources.dl import dl_search, dl_feed
 from quasarr.search.sources.dt import dt_feed, dt_search
 from quasarr.search.sources.dw import dw_feed, dw_search
 from quasarr.search.sources.fx import fx_feed, fx_search
@@ -21,6 +22,7 @@ from quasarr.search.sources.sf import sf_feed, sf_search
 from quasarr.search.sources.sj import sj_search, sj_feed
 from quasarr.search.sources.sl import sl_feed, sl_search
 from quasarr.search.sources.wd import wd_feed, wd_search
+from quasarr.search.sources.wx import wx_feed, wx_search
 
 
 def get_search_results(shared_state, request_from, imdb_id="", search_phrase="", mirror=None, season="", episode=""):
@@ -34,6 +36,7 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
     al = shared_state.values["config"]("Hostnames").get("al")
     by = shared_state.values["config"]("Hostnames").get("by")
     dd = shared_state.values["config"]("Hostnames").get("dd")
+    dl = shared_state.values["config"]("Hostnames").get("dl")
     dt = shared_state.values["config"]("Hostnames").get("dt")
     dj = shared_state.values["config"]("Hostnames").get("dj")
     dw = shared_state.values["config"]("Hostnames").get("dw")
@@ -46,6 +49,7 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
     sj = shared_state.values["config"]("Hostnames").get("sj")
     sl = shared_state.values["config"]("Hostnames").get("sl")
     wd = shared_state.values["config"]("Hostnames").get("wd")
+    wx = shared_state.values["config"]("Hostnames").get("wx")
 
     start_time = time.time()
 
@@ -56,6 +60,7 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
         (al, al_search),
         (by, by_search),
         (dd, dd_search),
+        (dl, dl_search),
         (dt, dt_search),
         (dj, dj_search),
         (dw, dw_search),
@@ -68,11 +73,13 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
         (sj, sj_search),
         (sl, sl_search),
         (wd, wd_search),
+        (wx, wx_search),
     ]
 
     # LazyLibrarian uses search_phrase for searches
     phrase_map = [
         (by, by_search),
+        (dl, dl_search),
         (dt, dt_search),
         (nx, nx_search),
         (sl, sl_search),
@@ -85,6 +92,7 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
         (by, by_feed),
         (dd, dd_feed),
         (dj, dj_feed),
+        (dl, dl_feed),
         (dt, dt_feed),
         (dw, dw_feed),
         (fx, fx_feed),
@@ -96,6 +104,7 @@ def get_search_results(shared_state, request_from, imdb_id="", search_phrase="",
         (sj, sj_feed),
         (sl, sl_feed),
         (wd, wd_feed),
+        (wx, wx_feed),
     ]
 
     if imdb_id:  # only Radarr/Sonarr are using imdb_id