quasarr 2.4.7__py3-none-any.whl → 2.4.9__py3-none-any.whl

quasarr/providers/sessions/al.py

@@ -10,20 +10,22 @@ import urllib.parse
 
 import requests
 from bs4 import BeautifulSoup
-from requests.exceptions import Timeout, RequestException
+from requests.exceptions import RequestException, Timeout
 
-from quasarr.providers.hostname_issues import mark_hostname_issue, clear_hostname_issue
-from quasarr.providers.log import info, debug
-from quasarr.providers.utils import is_site_usable, is_flaresolverr_available
+from quasarr.providers.hostname_issues import clear_hostname_issue, mark_hostname_issue
+from quasarr.providers.log import debug, info
+from quasarr.providers.utils import is_flaresolverr_available, is_site_usable
 
 
 class SkippedSiteError(Exception):
     """Raised when a site is skipped due to missing credentials or login being skipped."""
+
     pass
 
 
 class FlareSolverrNotAvailableError(Exception):
     """Raised when FlareSolverr is required but not available."""
+
     pass
 
 
@@ -35,9 +37,13 @@ SESSION_MAX_AGE_SECONDS = 24 * 60 * 60  # 24 hours
 def create_and_persist_session(shared_state):
     # AL requires FlareSolverr - check availability first
     if not is_flaresolverr_available(shared_state):
-        info(f'"{hostname.upper()}" requires FlareSolverr which is not configured. '
-             f'Please configure FlareSolverr in the web UI to use this site.')
-        mark_hostname_issue(hostname, "session", "FlareSolverr required but not configured")
+        info(
+            f'"{hostname.upper()}" requires FlareSolverr which is not configured. '
+            f"Please configure FlareSolverr in the web UI to use this site."
+        )
+        mark_hostname_issue(
+            hostname, "session", "FlareSolverr required but not configured"
+        )
         return None
 
     cfg = shared_state.values["config"]("Hostnames")
@@ -46,7 +52,7 @@ def create_and_persist_session(shared_state):
     user = credentials_cfg.get("user")
     pw = credentials_cfg.get("password")
 
-    flaresolverr_url = shared_state.values["config"]('FlareSolverr').get('url')
+    flaresolverr_url = shared_state.values["config"]("FlareSolverr").get("url")
 
     sess = requests.Session()
 
@@ -57,11 +63,13 @@ def create_and_persist_session(shared_state):
         fs_payload = {
             "cmd": "request.get",
             "url": f"https://www.{host}/",
-            "maxTimeout": 60000
+            "maxTimeout": 60000,
         }
 
         try:
-            fs_resp = requests.post(flaresolverr_url, headers=fs_headers, json=fs_payload, timeout=30)
+            fs_resp = requests.post(
+                flaresolverr_url, headers=fs_headers, json=fs_payload, timeout=30
+            )
             fs_resp.raise_for_status()
         except Timeout:
             info(f"{hostname}: FlareSolverr request timed out")
@@ -77,14 +85,16 @@ def create_and_persist_session(shared_state):
         # Check if FlareSolverr actually solved the challenge
         if fs_json.get("status") != "ok" or "solution" not in fs_json:
             info(f"{hostname}: FlareSolverr did not return a valid solution")
-            mark_hostname_issue(hostname, "session", "FlareSolverr did not return a valid solution")
+            mark_hostname_issue(
+                hostname, "session", "FlareSolverr did not return a valid solution"
+            )
             return None
 
         solution = fs_json["solution"]
         # store FlareSolverr's UA into our requests.Session
         fl_ua = solution.get("userAgent")
         if fl_ua:
-            sess.headers.update({'User-Agent': fl_ua})
+            sess.headers.update({"User-Agent": fl_ua})
 
         # Extract any cookies returned by FlareSolverr and add them into our session
         for ck in solution.get("cookies", []):
@@ -101,21 +111,17 @@ def create_and_persist_session(shared_state):
         return None
 
     if user and pw:
-        data = {
-            "identity": user,
-            "password": pw,
-            "remember": "1"
-        }
+        data = {"identity": user, "password": pw, "remember": "1"}
         encoded_data = urllib.parse.urlencode(data)
 
-        login_headers = {
-            "Content-Type": "application/x-www-form-urlencoded"
-        }
+        login_headers = {"Content-Type": "application/x-www-form-urlencoded"}
 
-        r = sess.post(f'https://www.{host}/auth/signin',
-                      data=encoded_data,
-                      headers=login_headers,
-                      timeout=30)
+        r = sess.post(
+            f"https://www.{host}/auth/signin",
+            data=encoded_data,
+            headers=login_headers,
+            timeout=30,
+        )
 
         if r.status_code != 200 or "invalid" in r.text.lower():
             info(f'Login failed: "{hostname}" - {r.status_code} - {r.text}')
@@ -194,10 +200,7 @@ def _persist_session_to_db(shared_state, sess):
     """
     blob = pickle.dumps(sess)
     token = base64.b64encode(blob).decode("utf-8")
-    session_data = json.dumps({
-        "token": token,
-        "created_at": time.time()
-    })
+    session_data = json.dumps({"token": token, "created_at": time.time()})
     shared_state.values["database"]("sessions").update_store(hostname, session_data)
 
 
@@ -207,12 +210,14 @@ def _load_session_cookies_for_flaresolverr(sess):
     """
     cookie_list = []
     for ck in sess.cookies:
-        cookie_list.append({
-            "name": ck.name,
-            "value": ck.value,
-            "domain": ck.domain,
-            "path": ck.path or "/",
-        })
+        cookie_list.append(
+            {
+                "name": ck.name,
+                "value": ck.value,
+                "domain": ck.domain,
+                "path": ck.path or "/",
+            }
+        )
     return cookie_list
 
 
@@ -232,11 +237,13 @@ def unwrap_flaresolverr_body(raw_text: str) -> str:
     return text
 
 
-def fetch_via_flaresolverr(shared_state,
-                           method: str,
-                           target_url: str,
-                           post_data: dict = None,
-                           timeout: int = 60):
+def fetch_via_flaresolverr(
+    shared_state,
+    method: str,
+    target_url: str,
+    post_data: dict = None,
+    timeout: int = 60,
+):
     """
     Load (or recreate) the requests.Session from DB.
     Package its cookies into FlareSolverr payload.
@@ -251,18 +258,20 @@ def fetch_via_flaresolverr(shared_state,
     """
     # Check if FlareSolverr is available
     if not is_flaresolverr_available(shared_state):
-        info(f'"{hostname.upper()}" requires FlareSolverr which is not configured. '
-             f'Please configure FlareSolverr in the web UI.')
+        info(
+            f'"{hostname.upper()}" requires FlareSolverr which is not configured. '
+            f"Please configure FlareSolverr in the web UI."
+        )
         return {
             "status_code": None,
             "headers": {},
             "json": None,
             "text": "",
             "cookies": [],
-            "error": "FlareSolverr is not configured"
+            "error": "FlareSolverr is not configured",
         }
 
-    flaresolverr_url = shared_state.values["config"]('FlareSolverr').get('url')
+    flaresolverr_url = shared_state.values["config"]("FlareSolverr").get("url")
 
     sess = retrieve_and_validate_session(shared_state)
     if not sess:
@@ -273,7 +282,7 @@ def fetch_via_flaresolverr(shared_state,
             "json": None,
             "text": "",
             "cookies": [],
-            "error": f"Site '{hostname}' is not usable (login skipped or no credentials)"
+            "error": f"Site '{hostname}' is not usable (login skipped or no credentials)",
         }
 
     cmd = "request.get" if method.upper() == "GET" else "request.post"
@@ -282,7 +291,7 @@ def fetch_via_flaresolverr(shared_state,
         "url": target_url,
         "maxTimeout": timeout * 1000,
         # Inject every cookie from our Python session into FlareSolverr
-        "cookies": _load_session_cookies_for_flaresolverr(sess)
+        "cookies": _load_session_cookies_for_flaresolverr(sess),
     }
 
     if method.upper() == "POST":
@@ -294,10 +303,7 @@ def fetch_via_flaresolverr(shared_state,
     fs_headers = {"Content-Type": "application/json"}
     try:
         resp = requests.post(
-            flaresolverr_url,
-            headers=fs_headers,
-            json=fs_payload,
-            timeout=timeout + 10
+            flaresolverr_url, headers=fs_headers, json=fs_payload, timeout=timeout + 10
         )
     except requests.exceptions.RequestException as e:
         info(f"Could not reach FlareSolverr: {e}")
@@ -308,7 +314,7 @@ def fetch_via_flaresolverr(shared_state,
             "json": None,
             "text": "",
             "cookies": [],
-            "error": f"FlareSolverr request failed: {e}"
+            "error": f"FlareSolverr request failed: {e}",
         }
     except Exception as e:
         raise RuntimeError(f"Could not reach FlareSolverr: {e}")
@@ -319,7 +325,9 @@ def fetch_via_flaresolverr(shared_state,
 
     fs_json = resp.json()
     if fs_json.get("status") != "ok" or "solution" not in fs_json:
-        raise RuntimeError(f"FlareSolverr did not return a valid solution: {fs_json.get('message', '<no message>')}")
+        raise RuntimeError(
+            f"FlareSolverr did not return a valid solution: {fs_json.get('message', '<no message>')}"
+        )
 
     solution = fs_json["solution"]
 
@@ -341,7 +349,7 @@ def fetch_via_flaresolverr(shared_state,
             ck.get("name"),
             ck.get("value"),
             domain=ck.get("domain"),
-            path=ck.get("path", "/")
+            path=ck.get("path", "/"),
         )
 
     # Persist the updated Session back into your DB
@@ -353,11 +361,17 @@ def fetch_via_flaresolverr(shared_state,
         "headers": solution.get("headers", {}),
         "json": parsed_json,
         "text": raw_body,
-        "cookies": solution.get("cookies", [])
+        "cookies": solution.get("cookies", []),
     }
 
 
-def fetch_via_requests_session(shared_state, method: str, target_url: str, post_data: dict = None, timeout: int = 30):
+def fetch_via_requests_session(
+    shared_state,
+    method: str,
+    target_url: str,
+    post_data: dict = None,
+    timeout: int = 30,
+):
     """
     - method: "GET" or "POST"
     - post_data: for POST only (will be sent as form-data unless you explicitly JSON-encode)
@@ -365,7 +379,9 @@ def fetch_via_requests_session(shared_state, method: str, target_url: str, post_
     """
     sess = retrieve_and_validate_session(shared_state)
     if not sess:
-        raise SkippedSiteError(f"{hostname}: site not usable (login skipped or no credentials)")
+        raise SkippedSiteError(
+            f"{hostname}: site not usable (login skipped or no credentials)"
+        )
 
     # Execute request
     if method.upper() == "GET":

quasarr/providers/sessions/dd.py

@@ -7,8 +7,8 @@ import pickle
 
 import requests
 
-from quasarr.providers.hostname_issues import mark_hostname_issue, clear_hostname_issue
-from quasarr.providers.log import info, debug
+from quasarr.providers.hostname_issues import clear_hostname_issue, mark_hostname_issue
+from quasarr.providers.log import debug, info
 from quasarr.providers.utils import is_site_usable
 
 hostname = "dd"
@@ -21,31 +21,36 @@ def create_and_persist_session(shared_state):
 
     cookies = {}
     headers = {
-        'User-Agent': shared_state.values["user_agent"],
+        "User-Agent": shared_state.values["user_agent"],
     }
 
     data = {
-        'username': shared_state.values["config"]("DD").get("user"),
-        'password': shared_state.values["config"]("DD").get("password"),
-        'ajax': 'true',
-        'Login': 'true',
+        "username": shared_state.values["config"]("DD").get("user"),
+        "password": shared_state.values["config"]("DD").get("password"),
+        "ajax": "true",
+        "Login": "true",
     }
 
-    r = dd_session.post(f'https://{dd}/index/index',
-                        cookies=cookies, headers=headers, data=data, timeout=10)
+    r = dd_session.post(
+        f"https://{dd}/index/index",
+        cookies=cookies,
+        headers=headers,
+        data=data,
+        timeout=10,
+    )
     r.raise_for_status()
 
     error = False
     if r.status_code == 200:
         try:
             response_data = r.json()
-            if not response_data.get('loggedin'):
+            if not response_data.get("loggedin"):
                 info("DD rejected login.")
                 mark_hostname_issue(hostname, "session", "Login rejected")
                 raise ValueError
             session_id = r.cookies.get("PHPSESSID")
             if session_id:
-                dd_session.cookies.set('PHPSESSID', session_id, domain=dd)
+                dd_session.cookies.set("PHPSESSID", session_id, domain=dd)
             else:
                 info("Invalid DD response on login.")
                 mark_hostname_issue(hostname, "session", "Invalid login response")
@@ -61,7 +66,7 @@ def create_and_persist_session(shared_state):
             return None
 
         serialized_session = pickle.dumps(dd_session)
-        session_string = base64.b64encode(serialized_session).decode('utf-8')
+        session_string = base64.b64encode(serialized_session).decode("utf-8")
         shared_state.values["database"]("sessions").update_store("dd", session_string)
         clear_hostname_issue(hostname)
         return dd_session
@@ -81,10 +86,12 @@ def retrieve_and_validate_session(shared_state):
         dd_session = create_and_persist_session(shared_state)
     else:
         try:
-            serialized_session = base64.b64decode(session_string.encode('utf-8'))
+            serialized_session = base64.b64decode(session_string.encode("utf-8"))
             dd_session = pickle.loads(serialized_session)
             if not isinstance(dd_session, requests.Session):
-                raise ValueError("Retrieved object is not a valid requests.Session instance.")
+                raise ValueError(
+                    "Retrieved object is not a valid requests.Session instance."
+                )
         except Exception as e:
             info(f"Session retrieval failed: {e}")
             mark_hostname_issue(hostname, "session", str(e))

quasarr/providers/sessions/dl.py

@@ -8,13 +8,14 @@ import pickle
 import requests
 from bs4 import BeautifulSoup
 
-from quasarr.providers.hostname_issues import mark_hostname_issue, clear_hostname_issue
-from quasarr.providers.log import info, debug
+from quasarr.providers.hostname_issues import clear_hostname_issue, mark_hostname_issue
+from quasarr.providers.log import debug, info
 from quasarr.providers.utils import is_site_usable
 
 
 class SkippedSiteError(Exception):
     """Raised when a site is skipped due to missing credentials or login being skipped."""
+
     pass
 
 
@@ -47,46 +48,48 @@ def create_and_persist_session(shared_state):
 
     # Set user agent
     ua = shared_state.values["user_agent"]
-    sess.headers.update({'User-Agent': ua})
+    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_url = f"https://www.{host}/login/"
         login_r = sess.get(login_page_url, timeout=30)
 
         login_r.raise_for_status()
 
         # Extract CSRF token from login form
-        soup = BeautifulSoup(login_r.text, 'html.parser')
-        csrf_input = soup.find('input', {'name': '_xfToken'})
+        soup = BeautifulSoup(login_r.text, "html.parser")
+        csrf_input = soup.find("input", {"name": "_xfToken"})
 
-        if not csrf_input or not csrf_input.get('value'):
+        if not csrf_input or not csrf_input.get("value"):
             info(f'Could not find CSRF token on login page for: "{hostname}"')
             mark_hostname_issue(hostname, "session", "Could not find CSRF token")
             return None
 
-        csrf_token = csrf_input['value']
+        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": user,
+            "password": password,
+            "_xfToken": csrf_token,
+            "remember": "1",
+            "_xfRedirect": f"https://www.{host}/",
         }
 
-        login_url = f'https://www.{host}/login/login'
+        login_url = f"https://www.{host}/login/login"
         submit_r = sess.post(login_url, data=login_data, timeout=30)
         submit_r.raise_for_status()
 
         # Step 3: Verify login success
         # Check if we're logged in by accessing the main page
-        verify_r = sess.get(f'https://www.{host}/', timeout=30)
+        verify_r = sess.get(f"https://www.{host}/", timeout=30)
         verify_r.raise_for_status()
 
         if 'data-logged-in="true"' not in verify_r.text:
-            info(f'Login verification failed for: "{hostname}" - invalid credentials or login failed')
+            info(
+                f'Login verification failed for: "{hostname}" - invalid credentials or login failed'
+            )
             mark_hostname_issue(hostname, "session", "Login verification failed")
             return None
 
@@ -160,8 +163,14 @@ def _persist_session_to_db(shared_state, sess):
     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):
+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.
 
@@ -178,7 +187,9 @@ def fetch_via_requests_session(shared_state, method: str, target_url: str, post_
     """
     sess = retrieve_and_validate_session(shared_state)
     if not sess:
-        raise SkippedSiteError(f"{hostname}: site not usable (login skipped or no credentials)")
+        raise SkippedSiteError(
+            f"{hostname}: site not usable (login skipped or no credentials)"
+        )
 
     # Execute request
     if method.upper() == "GET":

quasarr/providers/sessions/nx.py

@@ -7,8 +7,8 @@ import pickle
 
 import requests
 
-from quasarr.providers.hostname_issues import mark_hostname_issue, clear_hostname_issue
-from quasarr.providers.log import info, debug
+from quasarr.providers.hostname_issues import clear_hostname_issue, mark_hostname_issue
+from quasarr.providers.log import debug, info
 from quasarr.providers.utils import is_site_usable
 
 hostname = "nx"
@@ -21,33 +21,40 @@ def create_and_persist_session(shared_state):
 
     cookies = {}
     headers = {
-        'User-Agent': shared_state.values["user_agent"],
+        "User-Agent": shared_state.values["user_agent"],
     }
 
     json_data = {
-        'username': shared_state.values["config"]("NX").get("user"),
-        'password': shared_state.values["config"]("NX").get("password")
+        "username": shared_state.values["config"]("NX").get("user"),
+        "password": shared_state.values["config"]("NX").get("password"),
     }
 
-    r = nx_session.post(f'https://{nx}/api/user/auth', cookies=cookies, headers=headers, json=json_data,
-                        timeout=10)
+    r = nx_session.post(
+        f"https://{nx}/api/user/auth",
+        cookies=cookies,
+        headers=headers,
+        json=json_data,
+        timeout=10,
+    )
     r.raise_for_status()
 
     error = False
     if r.status_code == 200:
         try:
             response_data = r.json()
-            if response_data.get('err', {}).get('status') == 403:
+            if response_data.get("err", {}).get("status") == 403:
                 info("Invalid NX credentials provided.")
                 mark_hostname_issue(hostname, "session", "Invalid credentials")
                 error = True
-            elif response_data.get('user').get('username') != shared_state.values["config"]("NX").get("user"):
+            elif response_data.get("user").get("username") != shared_state.values[
+                "config"
+            ]("NX").get("user"):
                 info("Invalid NX response on login.")
                 mark_hostname_issue(hostname, "session", "Invalid login response")
                 error = True
             else:
-                sessiontoken = response_data.get('user').get('sessiontoken')
-                nx_session.cookies.set('sessiontoken', sessiontoken, domain=nx)
+                sessiontoken = response_data.get("user").get("sessiontoken")
+                nx_session.cookies.set("sessiontoken", sessiontoken, domain=nx)
         except ValueError:
             info("Could not parse NX response on login.")
             mark_hostname_issue(hostname, "session", "Could not parse login response")
@@ -59,7 +66,7 @@ def create_and_persist_session(shared_state):
             return None
 
         serialized_session = pickle.dumps(nx_session)
-        session_string = base64.b64encode(serialized_session).decode('utf-8')
+        session_string = base64.b64encode(serialized_session).decode("utf-8")
         shared_state.values["database"]("sessions").update_store("nx", session_string)
         clear_hostname_issue(hostname)
         return nx_session
@@ -79,10 +86,12 @@ def retrieve_and_validate_session(shared_state):
         nx_session = create_and_persist_session(shared_state)
     else:
         try:
-            serialized_session = base64.b64decode(session_string.encode('utf-8'))
+            serialized_session = base64.b64decode(session_string.encode("utf-8"))
             nx_session = pickle.loads(serialized_session)
             if not isinstance(nx_session, requests.Session):
-                raise ValueError("Retrieved object is not a valid requests.Session instance.")
+                raise ValueError(
+                    "Retrieved object is not a valid requests.Session instance."
+                )
         except Exception as e:
             info(f"Session retrieval failed: {e}")
             mark_hostname_issue(hostname, "session", str(e))