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

quasarr/providers/sessions/al.py

@@ -0,0 +1,286 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import base64
+import json
+import pickle
+import urllib.parse
+
+import requests
+from bs4 import BeautifulSoup
+from requests.exceptions import Timeout, RequestException
+
+from quasarr.providers.log import info, debug
+
+hostname = "al"
+
+
+def create_and_persist_session(shared_state):
+    cfg = shared_state.values["config"]("Hostnames")
+    host = cfg.get(hostname)
+    credentials_cfg = shared_state.values["config"](hostname.upper())
+    user = credentials_cfg.get("user")
+    pw = credentials_cfg.get("password")
+
+    flaresolverr_url = shared_state.values["config"]('FlareSolverr').get('url')
+
+    sess = requests.Session()
+
+    # Prime cookies via FlareSolverr
+    try:
+        info(f'Priming "{hostname}" session via FlareSolverr...')
+        fs_headers = {"Content-Type": "application/json"}
+        fs_payload = {
+            "cmd": "request.get",
+            "url": f"https://www.{host}/",
+            "maxTimeout": 60000
+        }
+
+        try:
+            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")
+            return None
+        except RequestException as e:
+            # This covers HTTP errors and connection issues *other than* timeout
+            info(f"{hostname}: FlareSolverr server error: {e}")
+            return None
+
+        fs_json = fs_resp.json()
+        # 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")
+            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})
+
+        # Extract any cookies returned by FlareSolverr and add them into our session
+        for ck in solution.get("cookies", []):
+            name = ck.get("name")
+            value = ck.get("value")
+            domain = ck.get("domain")
+            path = ck.get("path", "/")
+            # Set cookie on the session (ignoring expires/secure/httpOnly)
+            sess.cookies.set(name, value, domain=domain, path=path)
+
+    except Exception as e:
+        debug(f'Could not prime "{hostname}" session via FlareSolverr: {e}')
+        return None
+
+    if user and pw:
+        data = {
+            "identity": user,
+            "password": pw,
+            "remember": "1"
+        }
+        encoded_data = urllib.parse.urlencode(data)
+
+        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)
+
+        if r.status_code != 200 or "invalid" in r.text.lower():
+            info(f'Login failed: "{hostname}" - {r.status_code} - {r.text}')
+            return None
+        info(f'Login successful: "{hostname}"')
+    else:
+        info(f'Missing credentials for: "{hostname}" - skipping login')
+        return None
+
+    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):
+    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):
+    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`.
+    """
+    blob = pickle.dumps(sess)
+    token = base64.b64encode(blob).decode("utf-8")
+    shared_state.values["database"]("sessions").update_store(hostname, token)
+
+
+def _load_session_cookies_for_flaresolverr(sess):
+    """
+    Convert a requests.Session's cookies into FlareSolverr‐style list of dicts.
+    """
+    cookie_list = []
+    for ck in sess.cookies:
+        cookie_list.append({
+            "name": ck.name,
+            "value": ck.value,
+            "domain": ck.domain,
+            "path": ck.path or "/",
+        })
+    return cookie_list
+
+
+def unwrap_flaresolverr_body(raw_text: str) -> str:
+    """
+    Use BeautifulSoup to remove any HTML tags and return the raw text.
+    If raw_text is:
+        <html><body>{"foo":123}</body></html>
+    or:
+        <html><body><pre>[...array...]</pre></body></html>
+    or even just:
+        {"foo":123}
+    this will return the inner JSON string in all cases.
+    """
+    soup = BeautifulSoup(raw_text, "html.parser")
+    text = soup.get_text().strip()
+    return text
+
+
+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.
+    Ask FlareSolverr to do a request.get or request.post on target_url.
+    Replace the Session’s cookies with FlareSolverr’s new cookies.
+    Re-persist the updated session to the DB.
+    Return a dict with “status_code”, “headers”, “json” (parsed - if available), “text” and “cookies”.
+
+    – method: "GET" or "POST"
+    – post_data: dict of form‐fields if method=="POST"
+    – timeout: seconds (FlareSolverr’s internal maxTimeout = timeout*1000 ms)
+    """
+    flaresolverr_url = shared_state.values["config"]('FlareSolverr').get('url')
+
+    sess = retrieve_and_validate_session(shared_state)
+
+    cmd = "request.get" if method.upper() == "GET" else "request.post"
+    fs_payload = {
+        "cmd": cmd,
+        "url": target_url,
+        "maxTimeout": timeout * 1000,
+        # Inject every cookie from our Python session into FlareSolverr
+        "cookies": _load_session_cookies_for_flaresolverr(sess)
+    }
+
+    if method.upper() == "POST":
+        # FlareSolverr expects postData as urlencoded string
+        encoded = urllib.parse.urlencode(post_data or {})
+        fs_payload["postData"] = encoded
+
+    # Send the JSON request to FlareSolverr
+    fs_headers = {"Content-Type": "application/json"}
+    try:
+        resp = requests.post(
+            flaresolverr_url,
+            headers=fs_headers,
+            json=fs_payload,
+            timeout=timeout + 10
+        )
+        resp.raise_for_status()
+    except requests.exceptions.RequestException as e:
+        info(f"Could not reach FlareSolverr: {e}")
+        return {
+            "status_code": None,
+            "headers": {},
+            "json": None,
+            "text": "",
+            "cookies": [],
+            "error": f"FlareSolverr request failed: {e}"
+        }
+    except Exception as e:
+        raise RuntimeError(f"Could not reach FlareSolverr: {e}")
+
+    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>')}")
+
+    solution = fs_json["solution"]
+
+    # Extract the raw HTML/JSON body that FlareSolverr fetched
+    raw_body = solution.get("response", "")
+    # Get raw body as text, since it might contain JSON
+    unwrapped = unwrap_flaresolverr_body(raw_body)
+
+    # Attempt to parse it as JSON
+    try:
+        parsed_json = json.loads(unwrapped)
+    except ValueError:
+        parsed_json = None
+
+    # Replace our requests.Session cookies with whatever FlareSolverr solved
+    sess.cookies.clear()
+    for ck in solution.get("cookies", []):
+        sess.cookies.set(
+            ck.get("name"),
+            ck.get("value"),
+            domain=ck.get("domain"),
+            path=ck.get("path", "/")
+        )
+
+    # Persist the updated Session back into your DB
+    _persist_session_to_db(shared_state, sess)
+
+    # Return a small dict containing status, headers, parsed JSON, and cookie list
+    return {
+        "status_code": solution.get("status"),
+        "headers": solution.get("headers", {}),
+        "json": parsed_json,
+        "text": raw_body,
+        "cookies": solution.get("cookies", [])
+    }
+
+
+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)
+    – timeout: seconds
+    """
+    sess = retrieve_and_validate_session(shared_state)
+
+    # Execute request
+    if method.upper() == "GET":
+        resp = sess.get(target_url, 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/sessions/dd.py

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import base64
+import pickle
+
+import requests
+
+from quasarr.providers.log import info
+
+
+def create_and_persist_session(shared_state):
+    dd = shared_state.values["config"]("Hostnames").get("dd")
+
+    dd_session = requests.Session()
+
+    cookies = {}
+    headers = {
+        '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',
+    }
+
+    dd_response = dd_session.post(f'https://{dd}/index/index',
+                                  cookies=cookies, headers=headers, data=data, timeout=10)
+
+    error = False
+    if dd_response.status_code == 200:
+        try:
+            response_data = dd_response.json()
+            if not response_data.get('loggedin'):
+                info("DD rejected login.")
+                raise ValueError
+            session_id = dd_response.cookies.get("PHPSESSID")
+            if session_id:
+                dd_session.cookies.set('PHPSESSID', session_id, domain=dd)
+            else:
+                info("Invalid DD response on login.")
+                error = True
+        except ValueError:
+            info("Could not parse DD response on login.")
+            error = True
+
+        if error:
+            shared_state.values["config"]("DD").save("user", "")
+            shared_state.values["config"]("DD").save("password", "")
+            return None
+
+        serialized_session = pickle.dumps(dd_session)
+        session_string = base64.b64encode(serialized_session).decode('utf-8')
+        shared_state.values["database"]("sessions").update_store("dd", session_string)
+        return dd_session
+    else:
+        info("Could not create DD session")
+        return None
+
+
+def retrieve_and_validate_session(shared_state):
+    session_string = shared_state.values["database"]("sessions").retrieve("dd")
+    if not session_string:
+        dd_session = create_and_persist_session(shared_state)
+    else:
+        try:
+            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.")
+        except Exception as e:
+            info(f"Session retrieval failed: {e}")
+            dd_session = create_and_persist_session(shared_state)
+
+    return dd_session

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/sessions/nx.py

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+# Quasarr
+# Project by https://github.com/rix1337
+
+import base64
+import pickle
+
+import requests
+
+from quasarr.providers.log import info
+
+
+def create_and_persist_session(shared_state):
+    nx = shared_state.values["config"]("Hostnames").get("nx")
+
+    nx_session = requests.Session()
+
+    cookies = {}
+    headers = {
+        '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")
+    }
+
+    nx_response = nx_session.post(f'https://{nx}/api/user/auth', cookies=cookies, headers=headers, json=json_data,
+                                  timeout=10)
+
+    error = False
+    if nx_response.status_code == 200:
+        try:
+            response_data = nx_response.json()
+            if response_data.get('err', {}).get('status') == 403:
+                info("Invalid NX credentials provided.")
+                error = True
+            elif response_data.get('user').get('username') != shared_state.values["config"]("NX").get("user"):
+                info("Invalid NX response on login.")
+                error = True
+            else:
+                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.")
+            error = True
+
+        if error:
+            shared_state.values["config"]("NX").save("user", "")
+            shared_state.values["config"]("NX").save("password", "")
+            return None
+
+        serialized_session = pickle.dumps(nx_session)
+        session_string = base64.b64encode(serialized_session).decode('utf-8')
+        shared_state.values["database"]("sessions").update_store("nx", session_string)
+        return nx_session
+    else:
+        info("Could not create NX session")
+        return None
+
+
+def retrieve_and_validate_session(shared_state):
+    session_string = shared_state.values["database"]("sessions").retrieve("nx")
+    if not session_string:
+        nx_session = create_and_persist_session(shared_state)
+    else:
+        try:
+            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.")
+        except Exception as e:
+            info(f"Session retrieval failed: {e}")
+            nx_session = create_and_persist_session(shared_state)
+
+    return nx_session