novel-downloader 1.3.3__py3-none-any.whl → 1.4.0__py3-none-any.whl

novel_downloader/core/requesters/qidian/broswer.py

@@ -1,307 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.requesters.qidian.broswer
------------------------------------------------
-
-This module defines the QidianRequester class for interacting with
-the Qidian website.
-It extends the BaseBrowser by adding methods for logging in and
-retrieving book information.
-"""
-
-import time
-from typing import Any
-
-from novel_downloader.config.models import RequesterConfig
-from novel_downloader.core.requesters.base import BaseBrowser
-from novel_downloader.utils.i18n import t
-
-
-class QidianBrowser(BaseBrowser):
-    """
-    QidianRequester provides methods for interacting with Qidian.com,
-    including checking login status and preparing book-related URLs.
-
-    Inherits base browser setup from BaseBrowser.
-    """
-
-    BOOKCASE_URL = "https://my.qidian.com/bookcase/"
-    BOOK_INFO_URL = "https://book.qidian.com/info/{book_id}/"
-    CHAPTER_URL = "https://www.qidian.com/chapter/{book_id}/{chapter_id}/"
-
-    def __init__(
-        self,
-        config: RequesterConfig,
-    ):
-        """
-        Initialize the QidianRequester with a browser configuration.
-
-        :param config: The RequesterConfig instance containing browser settings.
-        """
-        super().__init__(config)
-        self._logged_in: bool = False
-        self._retry_times = config.retry_times
-        self._retry_interval = config.backoff_factor
-        self._timeout = config.timeout
-
-    def login(
-        self,
-        username: str = "",
-        password: str = "",
-        manual_login: bool = False,
-        **kwargs: Any,
-    ) -> bool:
-        """
-        Attempt to log in to Qidian
-        """
-        if manual_login:
-            return self._login_manual()
-        else:
-            return self._login_auto()
-
-    def get_book_info(
-        self,
-        book_id: str,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Retrieve the HTML of a Qidian book info page.
-
-        :param book_id: The identifier of the book to fetch.
-        :return: The HTML content of the book info page, or an empty string on error.
-        """
-        url = self.book_info_url(book_id)
-        try:
-            # Navigate and fetch
-            self.page.get(url)
-            html = str(self.page.html)
-            self.logger.debug(
-                "[fetch] Fetched book info for ID %s from %s", book_id, url
-            )
-            return [html]
-        except Exception as e:
-            self.logger.warning(
-                "[fetch] Error fetching book info from '%s': %s", url, e
-            )
-        return []
-
-    def get_book_chapter(
-        self,
-        book_id: str,
-        chapter_id: str,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Retrieve the HTML content of a specific chapter.
-
-        Ensures the user is logged in, navigates to the chapter page
-
-        :param book_id: The identifier of the book.
-        :param chapter_id: The identifier of the chapter.
-        :return: The HTML content of the chapter page, or empty string on error.
-        """
-        url = self.chapter_url(book_id, chapter_id)
-        try:
-            # Navigate to chapter URL
-            self.page.get(url)
-            html = str(self.page.html)
-            self.logger.debug(
-                "[fetch] Fetched chapter %s for book %s", chapter_id, book_id
-            )
-            return [html]
-        except Exception as e:
-            self.logger.warning("[fetch] Error fetching chapter from '%s': %s", url, e)
-        return []
-
-    def get_bookcase(
-        self,
-        page: int = 1,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Retrieve the HTML content of the logged-in user's Qidian bookcase page.
-
-        :return: The HTML markup of the bookcase page, or empty string on error.
-        :raises RuntimeError: If the user is not logged in.
-        """
-        if not self._logged_in:
-            raise RuntimeError("User not logged in. Please call login() first.")
-
-        url = self.bookcase_url()
-        try:
-            # Navigate to the bookcase page
-            self.page.get(url)
-            html = str(self.page.html)
-            self.logger.debug("[fetch] Fetched bookcase HTML from %s", url)
-            return [html]
-        except Exception as e:
-            self.logger.warning("[fetch] Error fetching bookcase from '%s': %s", url, e)
-        return []
-
-    @classmethod
-    def book_info_url(cls, book_id: str) -> str:
-        """
-        Construct the URL for fetching a book's info page.
-
-        :param book_id: The identifier of the book.
-        :return: Fully qualified URL for the book info page.
-        """
-        return cls.BOOK_INFO_URL.format(book_id=book_id)
-
-    @classmethod
-    def chapter_url(cls, book_id: str, chapter_id: str) -> str:
-        """
-        Construct the URL for fetching a specific chapter.
-
-        :param book_id: The identifier of the book.
-        :param chapter_id: The identifier of the chapter.
-        :return: Fully qualified chapter URL.
-        """
-        return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
-
-    @classmethod
-    def bookcase_url(cls) -> str:
-        """
-        Construct the URL for the user's bookcase page.
-
-        :return: Fully qualified URL of the bookcase.
-        """
-        return cls.BOOKCASE_URL
-
-    def _login_auto(self, timeout: float = 5.0) -> bool:
-        """
-        Attempt to log in to Qidian by handling overlays and clicking the login button.
-
-        :return: True if login succeeds or is already in place; False otherwise.
-        """
-        try:
-            self.page.get("https://www.qidian.com/")
-            self.page.wait.eles_loaded("#login-box", timeout=timeout)
-        except Exception as e:
-            self.logger.warning("[auth] Failed to load login box: %s", e)
-            return False
-
-        for attempt in range(1, self._retry_times + 1):
-            if self._check_login_status():
-                self.logger.debug("[auth] Already logged in.")
-                break
-            self.logger.debug("[auth] Attempting login click (#%s).", attempt)
-            if self.click_button("@id=login-btn", timeout=timeout):
-                self.logger.debug("[auth] Login button clicked.")
-            else:
-                self.logger.debug("[auth] Login button not found.")
-            time.sleep(self._retry_interval)
-
-        self._logged_in = self._check_login_status()
-        if self._logged_in:
-            self.logger.info("[auth] Login successful.")
-        else:
-            self.logger.warning("[auth] Login failed after max retries.")
-
-        return self._logged_in
-
-    def _login_manual(self) -> bool:
-        """
-        Guide the user through an interactive manual login flow.
-
-        Steps:
-            1. If the browser is headless, shut it down and restart in headful mode.
-            2. Navigate to the Qidian homepage.
-            3. Prompt the user to complete login, retrying up to `max_retries` times.
-            4. Once logged in, restore original headless mode if needed.
-
-        :param max_retries: Number of times to check for login success.
-        :return: True if login was detected, False otherwise.
-        """
-        original_headless = self._headless
-
-        # 1. Switch to headful mode if needed
-        if self._disable_images_orig:
-            self.logger.debug("[auth] Temporarily enabling images for manual login.")
-            self._options.no_imgs(False)
-            self.restart_browser(headless=False)
-        elif original_headless:
-            self.restart_browser(headless=False)
-
-        # 2. Navigate to home page
-        try:
-            self.page.get("https://www.qidian.com/")
-        except Exception as e:
-            self.logger.warning(
-                "[auth] Failed to load homepage for manual login: %s", e
-            )
-            return False
-
-        # 3. Retry loop
-        for attempt in range(1, self._retry_times + 1):
-            if self._check_login_status():
-                self.logger.debug("[auth] Already logged in.")
-                self._logged_in = True
-                break
-            if attempt == 1:
-                print(t("login_prompt_intro"))
-            input(
-                t(
-                    "login_prompt_press_enter",
-                    attempt=attempt,
-                    max_retries=self._retry_times,
-                )
-            )
-        else:
-            self.logger.warning(
-                "[auth] Manual login failed after %d attempts.", self._retry_times
-            )
-            self._logged_in = False
-            return self._logged_in
-
-        # 4. Restore headless if changed, then re-establish session
-        if original_headless or self._disable_images_orig:
-            self.logger.debug("[auth] Restoring browser settings after manual login...")
-            self._options.no_imgs(self._disable_images_orig)
-            self.restart_browser(headless=original_headless)
-            self._logged_in = self._login_auto()
-            if self._logged_in:
-                self.logger.info(
-                    "[auth] Login session successfully carried over after restart."
-                )
-            else:
-                self.logger.warning(
-                    "[auth] Lost login session after restoring headless mode."
-                )
-
-        return self._logged_in
-
-    def _check_login_status(self) -> bool:
-        """
-        Check whether the user is currently logged in by inspecting
-        the visibility of the 'sign-in' element on the page.
-
-        :return: True if the user appears to be logged in, False otherwise.
-        """
-        try:
-            self._dismiss_overlay()
-            sign_in_elem = self.page.ele("@class=sign-in")
-            if sign_in_elem:
-                class_value = sign_in_elem.attr("class")
-                if class_value and "hidden" not in class_value:
-                    return True
-        except Exception as e:
-            self.logger.warning("[auth] Error while checking login status: %s", e)
-        return False
-
-    def _dismiss_overlay(self, timeout: float = 2.0) -> None:
-        """
-        Detect and close any full-page overlay mask that might block the login UI.
-        """
-        try:
-            mask = self.page.ele("@@tag()=div@@class=mask", timeout=timeout)
-            if not mask:
-                return
-            self.logger.debug("[auth] Overlay mask detected; attempting to close.")
-            iframe = self.get_frame("loginIfr")
-            if iframe is None:
-                self.logger.debug("[auth] Login iframe not found.")
-                return
-            self.click_button("@id=close", page=iframe)
-        except Exception as e:
-            self.logger.debug("[auth] Error handling overlay mask: %s", e)

novel_downloader/core/requesters/qidian/session.py

@@ -1,290 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.requesters.qidian.session
------------------------------------------------
-
-This module defines the QidianRequester class for interacting with
-the Qidian website.
-It extends the BaseSession by adding methods for logging in and
-retrieving book information.
-"""
-
-from __future__ import annotations
-
-import base64
-from http.cookies import SimpleCookie
-from typing import Any, ClassVar
-
-from requests import Response
-
-from novel_downloader.config.models import RequesterConfig
-from novel_downloader.core.requesters.base import BaseSession
-from novel_downloader.utils.crypto_utils import patch_qd_payload_token
-from novel_downloader.utils.i18n import t
-from novel_downloader.utils.state import state_mgr
-
-
-class QidianSession(BaseSession):
-    """
-    QidianRequester provides methods for interacting with Qidian.com,
-    including checking login status and preparing book-related URLs.
-
-    Inherits base session setup from BaseSession.
-    """
-
-    BOOKCASE_URL = "https://my.qidian.com/bookcase/"
-    BOOK_INFO_URL = "https://book.qidian.com/info/{book_id}/"
-    CHAPTER_URL = "https://www.qidian.com/chapter/{book_id}/{chapter_id}/"
-
-    _cookie_keys: ClassVar[list[str]] = [
-        "X2NzcmZUb2tlbg==",
-        "eXdndWlk",
-        "eXdvcGVuaWQ=",
-        "eXdrZXk=",
-        "d190c2Zw",
-    ]
-
-    def __init__(
-        self,
-        config: RequesterConfig,
-    ):
-        """
-        Initialize the QidianSession with a session configuration.
-
-        :param config: The RequesterConfig instance containing request settings.
-        """
-        super().__init__(config)
-        self._logged_in: bool = False
-        self._retry_times = config.retry_times
-        self._retry_interval = config.backoff_factor
-        self._timeout = config.timeout
-
-    def login(
-        self,
-        username: str = "",
-        password: str = "",
-        manual_login: bool = False,
-        **kwargs: Any,
-    ) -> bool:
-        """
-        Restore cookies persisted by the session-based workflow.
-        """
-        cookies: dict[str, str] = state_mgr.get_cookies("qidian")
-
-        # Merge cookies into both the internal cache and the live session
-        self.update_cookies(cookies)
-        for attempt in range(1, self._retry_times + 1):
-            if self._check_login_status():
-                self.logger.debug("[auth] Already logged in.")
-                self._logged_in = True
-                return True
-
-            if attempt == 1:
-                print(t("session_login_prompt_intro"))
-            cookie_str = input(
-                t(
-                    "session_login_prompt_paste_cookie",
-                    attempt=attempt,
-                    max_retries=self._retry_times,
-                )
-            ).strip()
-
-            cookies = self._parse_cookie_input(cookie_str)
-            if not self._check_cookies(cookies):
-                print(t("session_login_prompt_invalid_cookie"))
-                continue
-
-            self.update_cookies(cookies)
-        return self._check_login_status()
-
-    def get_book_info(
-        self,
-        book_id: str,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Fetch the raw HTML of the book info page.
-
-        :param book_id: The book identifier.
-        :return: The page content as a string.
-        """
-        url = self.book_info_url(book_id=book_id)
-        try:
-            resp = self.get(url, **kwargs)
-            resp.raise_for_status()
-            return [resp.text]
-        except Exception as exc:
-            self.logger.warning(
-                "[session] get_book_info(%s) failed: %s",
-                book_id,
-                exc,
-            )
-        return []
-
-    def get_book_chapter(
-        self,
-        book_id: str,
-        chapter_id: str,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Fetch the HTML of a single chapter.
-
-        :param book_id: The book identifier.
-        :param chapter_id: The chapter identifier.
-        :return: The chapter content as a string.
-        """
-        url = self.chapter_url(book_id=book_id, chapter_id=chapter_id)
-        try:
-            resp = self.get(url, **kwargs)
-            resp.raise_for_status()
-            return [resp.text]
-        except Exception as exc:
-            self.logger.warning(
-                "[session] get_book_chapter(%s) failed: %s",
-                book_id,
-                exc,
-            )
-        return []
-
-    def get_bookcase(
-        self,
-        page: int = 1,
-        **kwargs: Any,
-    ) -> list[str]:
-        """
-        Retrieve the user's *bookcase* page.
-
-        :return: The HTML markup of the bookcase page.
-        """
-        url = self.bookcase_url()
-        try:
-            resp = self.get(url, **kwargs)
-            resp.raise_for_status()
-            return [resp.text]
-        except Exception as exc:
-            self.logger.warning(
-                "[session] get_bookcase failed: %s",
-                exc,
-            )
-        return []
-
-    def get(
-        self,
-        url: str,
-        params: dict[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> Response:
-        """
-        Same as :py:meth:`BaseSession.get`, but transparently refreshes
-        a cookie-based token used for request validation.
-
-        The method:
-        1. Reads the existing cookie (if any);
-        2. Generates a new value tied to *url*;
-        3. Updates both the live ``requests.Session`` and the internal cache;
-        4. Delegates the actual request to ``super().get``.
-        """
-        if self._session is None:
-            raise RuntimeError("Session is not initialized or has been shut down.")
-
-        # ---- 1. refresh token cookie --------------------------------------
-        cookie_key = self._d("d190c2Zw")
-        old_token = self._session.cookies.get(cookie_key, "")
-
-        if old_token:
-            refreshed_token = patch_qd_payload_token(old_token, url)
-            self._session.cookies.set(cookie_key, refreshed_token)
-            self._cookies[cookie_key] = refreshed_token
-
-        # ---- 2. perform the real GET --------------------------------------------
-        resp: Response = super().get(url, params=params, **kwargs)
-
-        # ---- 3. persist any server-set cookies (optional) --------------
-        self.update_cookies(self._session.cookies.get_dict())
-        state_mgr.set_cookies("qidian", self._cookies)
-
-        return resp
-
-    @classmethod
-    def book_info_url(cls, book_id: str) -> str:
-        """
-        Construct the URL for fetching a book's info page.
-
-        :param book_id: The identifier of the book.
-        :return: Fully qualified URL for the book info page.
-        """
-        return cls.BOOK_INFO_URL.format(book_id=book_id)
-
-    @classmethod
-    def chapter_url(cls, book_id: str, chapter_id: str) -> str:
-        """
-        Construct the URL for fetching a specific chapter.
-
-        :param book_id: The identifier of the book.
-        :param chapter_id: The identifier of the chapter.
-        :return: Fully qualified chapter URL.
-        """
-        return cls.CHAPTER_URL.format(book_id=book_id, chapter_id=chapter_id)
-
-    @classmethod
-    def bookcase_url(cls) -> str:
-        """
-        Construct the URL for the user's bookcase page.
-
-        :return: Fully qualified URL of the bookcase.
-        """
-        return cls.BOOKCASE_URL
-
-    def _check_login_status(self) -> bool:
-        """
-        Check whether the user is currently logged in by
-        inspecting the bookcase page content.
-
-        :return: True if the user appears to be logged in, False otherwise.
-        """
-        keywords = [
-            'var buid = "fffffffffffffffffff"',
-            "C2WF946J0/probe.js",
-        ]
-        resp_text = self.get_bookcase()
-        if not resp_text:
-            return False
-        return not any(kw in resp_text[0] for kw in keywords)
-
-    @staticmethod
-    def _parse_cookie_input(cookie_str: str) -> dict[str, str]:
-        """
-        Parse a raw cookie string (e.g. from browser dev tools) into a dict.
-        Returns an empty dict if parsing fails.
-
-        :param cookie_str: The raw cookie header string.
-        :return: Parsed cookie dict.
-        """
-        filtered = "; ".join(pair for pair in cookie_str.split(";") if "=" in pair)
-        parsed = SimpleCookie()
-        try:
-            parsed.load(filtered)
-            return {k: v.value for k, v in parsed.items()}
-        except Exception:
-            return {}
-
-    def _check_cookies(self, cookies: dict[str, str]) -> bool:
-        """
-        Check if the provided cookies contain all required keys.
-
-        Logs any missing keys as warnings.
-
-        :param cookies: The cookie dictionary to validate.
-        :return: True if all required keys are present, False otherwise.
-        """
-        required = {self._d(k) for k in self._cookie_keys}
-        actual = set(cookies)
-        missing = required - actual
-        if missing:
-            self.logger.warning("Missing required cookies: %s", ", ".join(missing))
-        return not missing
-
-    @staticmethod
-    def _d(b: str) -> str:
-        return base64.b64decode(b).decode()

novel_downloader/core/requesters/sfacg/__init__.py

@@ -1,13 +0,0 @@
-"""
-novel_downloader.core.requesters.sfacg
---------------------------------------
-
-"""
-
-from .async_session import SfacgAsyncSession
-from .session import SfacgSession
-
-__all__ = [
-    "SfacgAsyncSession",
-    "SfacgSession",
-]