novel-downloader 1.2.1__py3-none-any.whl → 1.3.0__py3-none-any.whl

novel_downloader/core/requesters/qidian/session.py

@@ -0,0 +1,287 @@
+#!/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 browser-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.")
+                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,
+    ) -> 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,
+    ) -> 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,
+    ) -> 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()
+        return not any(kw in resp_text 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/savers/__init__.py

@@ -1,5 +1,4 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
 novel_downloader.core.savers
 ----------------------------
@@ -7,14 +6,17 @@ novel_downloader.core.savers
 This module defines saver classes for different novel platforms.
 
 Currently supported platforms:
+- Biquge (笔趣阁)
 - Qidian (起点中文网)
 - CommonSaver (通用)
 """
 
-from .common_saver import CommonSaver
-from .qidian_saver import QidianSaver
+from .biquge import BiqugeSaver
+from .common import CommonSaver
+from .qidian import QidianSaver
 
 __all__ = [
+    "BiqugeSaver",
     "CommonSaver",
     "QidianSaver",
 ]

novel_downloader/core/savers/{base_saver.py → base.py}

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
-novel_downloader.core.savers.base_saver
----------------------------------------
+novel_downloader.core.savers.base
+---------------------------------
 
 This module provides an abstract base class `BaseSaver` that defines the
 common interface and reusable logic for saving assembled novel content
@@ -13,17 +12,15 @@ import abc
 import logging
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 
 from novel_downloader.config.models import SaverConfig
 from novel_downloader.core.interfaces import SaverProtocol
 
-logger = logging.getLogger(__name__)
 
-
-class SafeDict(Dict[str, Any]):
+class SafeDict(dict[str, Any]):
     def __missing__(self, key: str) -> str:
-        return "{{{}}}".format(key)
+        return f"{{{key}}}"
 
 
 class BaseSaver(SaverProtocol, abc.ABC):
@@ -49,6 +46,8 @@ class BaseSaver(SaverProtocol, abc.ABC):
 
         self._filename_template = config.filename_template
 
+        self.logger = logging.getLogger(f"{__name__}.{self.__class__.__name__}")
+
     def save(self, book_id: str) -> None:
         """
         Save the book in the formats specified in config.
@@ -67,23 +66,23 @@ class BaseSaver(SaverProtocol, abc.ABC):
         for flag_name, save_method in actions:
             if getattr(self._config, flag_name, False):
                 try:
-                    logger.info(
+                    self.logger.info(
                         "%s Attempting to save book_id '%s' as %s...",
                         TAG,
                         book_id,
                         flag_name,
                     )
                     save_method(book_id)
-                    logger.info("%s Successfully saved as %s.", TAG, flag_name)
+                    self.logger.info("%s Successfully saved as %s.", TAG, flag_name)
                 except NotImplementedError as e:
-                    logger.warning(
+                    self.logger.warning(
                         "%s Save method for %s not implemented: %s",
                         TAG,
                         flag_name,
                         str(e),
                     )
                 except Exception as e:
-                    logger.error(
+                    self.logger.error(
                         "%s Error while saving as %s: %s", TAG, flag_name, str(e)
                     )
         return
@@ -130,7 +129,7 @@ class BaseSaver(SaverProtocol, abc.ABC):
         self,
         *,
         title: str,
-        author: Optional[str] = None,
+        author: str | None = None,
         ext: str = "txt",
         **extra_fields: str,
     ) -> str:

novel_downloader/core/savers/biquge.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.savers.biquge
+-----------------------------------
+
+"""
+
+from novel_downloader.config.models import SaverConfig
+
+from .common import CommonSaver
+
+
+class BiqugeSaver(CommonSaver):
+    def __init__(
+        self,
+        config: SaverConfig,
+    ):
+        super().__init__(
+            config,
+            site="biquge",
+            chap_folders=["chapters"],
+        )
+
+
+__all__ = ["BiqugeSaver"]

novel_downloader/core/savers/{common_saver → common}/__init__.py

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
-novel_downloader.core.savers.common_saver
------------------------------------------
+novel_downloader.core.savers.common
+-----------------------------------
 
 This module provides the `CommonSaver` class for handling the saving process
 of novels.

novel_downloader/core/savers/{common_saver/common_epub.py → common/epub.py}

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
-novel_downloader.core.savers.common_saver.common_epub
------------------------------------------------------
+novel_downloader.core.savers.common.epub
+----------------------------------------
 
 Contains the logic for exporting novel content as a single `.epub` file.
 """
@@ -10,9 +9,8 @@ Contains the logic for exporting novel content as a single `.epub` file.
 from __future__ import annotations
 
 import json
-import logging
 from pathlib import Path
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING
 from urllib.parse import unquote, urlparse
 
 from ebooklib import epub
@@ -35,29 +33,6 @@ from novel_downloader.utils.text_utils import clean_chapter_title
 if TYPE_CHECKING:
     from .main_saver import CommonSaver
 
-logger = logging.getLogger(__name__)
-
-CHAPTER_FOLDERS: List[str] = [
-    "chapters",
-    "encrypted_chapters",
-]
-
-
-def _find_chapter_file(
-    raw_base: Path,
-    chapter_id: str,
-) -> Optional[Path]:
-    """
-    Search for `<chapter_id>.json` under each folder in CHAPTER_FOLDERS
-    inside raw_data_dir/site/book_id. Return the first existing Path,
-    or None if not found.
-    """
-    for folder in CHAPTER_FOLDERS:
-        candidate = raw_base / folder / f"{chapter_id}.json"
-        if candidate.exists():
-            return candidate
-    return None
-
 
 def _image_url_to_filename(url: str) -> str:
     """
@@ -114,15 +89,17 @@ def common_save_as_epub(
         info_text = info_path.read_text(encoding="utf-8")
         book_info = json.loads(info_text)
     except Exception as e:
-        logger.error("%s Failed to load %s: %s", TAG, info_path, e)
+        saver.logger.error("%s Failed to load %s: %s", TAG, info_path, e)
         return
 
     book_name = book_info.get("book_name", book_id)
-    logger.info("%s Starting EPUB generation: %s (ID: %s)", TAG, book_name, book_id)
+    saver.logger.info(
+        "%s Starting EPUB generation: %s (ID: %s)", TAG, book_name, book_id
+    )
 
     # --- Generate intro + cover ---
     intro_html = generate_book_intro_html(book_info)
-    cover_path: Optional[Path] = None
+    cover_path: Path | None = None
     if config.include_cover:
         cover_filename = _image_url_to_filename(book_info.get("cover_url", ""))
         if cover_filename:
@@ -147,7 +124,7 @@ def common_save_as_epub(
     for vol_index, vol in enumerate(volumes, start=1):
         raw_vol_name = vol.get("volume_name", "").strip()
         vol_name = clean_chapter_title(raw_vol_name) or f"Unknown Volume {vol_index}"
-        logger.info("Processing volume %d: %s", vol_index, vol_name)
+        saver.logger.info("Processing volume %d: %s", vol_index, vol_name)
 
         # Volume intro
         vol_intro = epub.EpubHtml(
@@ -165,18 +142,18 @@ def common_save_as_epub(
         spine.append(vol_intro)
 
         section = epub.Section(vol_name, vol_intro.file_name)
-        chapter_items: List[epub.EpubHtml] = []
+        chapter_items: list[epub.EpubHtml] = []
 
         for chap in vol.get("chapters", []):
             chap_id = chap.get("chapterId")
             chap_title = chap.get("title", "")
             if not chap_id:
-                logger.warning("%s Missing chapterId, skipping: %s", TAG, chap)
+                saver.logger.warning("%s Missing chapterId, skipping: %s", TAG, chap)
                 continue
 
-            json_path = _find_chapter_file(raw_base, chap_id)
-            if json_path is None:
-                logger.info(
+            chapter_data = saver._get_chapter(book_id, chap_id)
+            if not chapter_data:
+                saver.logger.info(
                     "%s Missing chapter file: %s (%s), skipping.",
                     TAG,
                     chap_title,
@@ -184,17 +161,12 @@ def common_save_as_epub(
                 )
                 continue
 
-            try:
-                data = json.loads(json_path.read_text(encoding="utf-8"))
-                title = clean_chapter_title(data.get("title", "")) or chap_id
-                chap_html = chapter_txt_to_html(
-                    chapter_title=title,
-                    chapter_text=data.get("content", ""),
-                    author_say=data.get("author_say", ""),
-                )
-            except Exception as e:
-                logger.error("%s Error parsing chapter %s: %s", TAG, json_path, e)
-                continue
+            title = clean_chapter_title(chapter_data.get("title", "")) or chap_id
+            chap_html = chapter_txt_to_html(
+                chapter_title=title,
+                chapter_text=chapter_data.get("content", ""),
+                author_say=chapter_data.get("author_say", ""),
+            )
 
             chap_path = f"{EPUB_TEXT_FOLDER}/{chap_id}.xhtml"
             item = epub.EpubHtml(title=chap_title, file_name=chap_path, lang="zh")
@@ -211,8 +183,8 @@ def common_save_as_epub(
         toc_list.append((section, chapter_items))
 
     # --- 5. Finalize EPUB ---
-    logger.info("%s Building TOC and spine...", TAG)
-    book.toc = tuple(toc_list)
+    saver.logger.info("%s Building TOC and spine...", TAG)
+    book.toc = toc_list
     book.spine = spine
     book.add_item(epub.EpubNcx())
     book.add_item(epub.EpubNav())
@@ -226,7 +198,7 @@ def common_save_as_epub(
 
     try:
         epub.write_epub(out_path, book, EPUB_OPTIONS)
-        logger.info("%s EPUB successfully written to %s", TAG, out_path)
+        saver.logger.info("%s EPUB successfully written to %s", TAG, out_path)
     except Exception as e:
-        logger.error("%s Failed to write EPUB to %s: %s", TAG, out_path, e)
+        saver.logger.error("%s Failed to write EPUB to %s: %s", TAG, out_path, e)
     return

novel_downloader/core/savers/{common_saver → common}/main_saver.py

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
-# -*- coding: utf-8 -*-
 """
-novel_downloader.core.savers.common_saver.main_saver
-----------------------------------------------------
+novel_downloader.core.savers.common.main_saver
+----------------------------------------------
 
 This module implements the `QidianSaver` class, a concrete saver for handling
 novel data from Qidian (起点中文网). It defines the logic to compile, structure,
@@ -10,10 +9,14 @@ and export novel content in plain text format based on the platform's metadata
 and chapter files.
 """
 
+from collections.abc import Mapping
+from typing import Any
+
 from novel_downloader.config.models import SaverConfig
+from novel_downloader.utils.chapter_storage import ChapterStorage
 
-from ..base_saver import BaseSaver
-from .common_txt import common_save_as_txt
+from ..base import BaseSaver
+from .txt import common_save_as_txt
 
 
 class CommonSaver(BaseSaver):
@@ -23,7 +26,12 @@ class CommonSaver(BaseSaver):
     logic for exporting full novels as plain text (.txt) files.
     """
 
-    def __init__(self, config: SaverConfig, site: str):
+    def __init__(
+        self,
+        config: SaverConfig,
+        site: str,
+        chap_folders: list[str] | None = None,
+    ):
         """
         Initialize the common saver with site information.
 
@@ -33,6 +41,8 @@ class CommonSaver(BaseSaver):
         """
         super().__init__(config)
         self._site = site
+        self._chapter_storage_cache: dict[str, list[ChapterStorage]] = {}
+        self._chap_folders: list[str] = chap_folders or ["chapters"]
 
     def save_as_txt(self, book_id: str) -> None:
         """
@@ -49,6 +59,7 @@ class CommonSaver(BaseSaver):
 
         :param book_id: The book identifier (used to locate raw data)
         """
+        self._init_chapter_storages(book_id)
         return common_save_as_txt(self, book_id)
 
     def save_as_epub(self, book_id: str) -> None:
@@ -59,12 +70,13 @@ class CommonSaver(BaseSaver):
         :raises NotImplementedError: If the method is not overridden.
         """
         try:
-            from .common_epub import common_save_as_epub
-        except ImportError:
+            from .epub import common_save_as_epub
+        except ImportError as err:
             raise NotImplementedError(
                 "EPUB export not supported. Please install 'ebooklib'"
-            )
+            ) from err
 
+        self._init_chapter_storages(book_id)
         return common_save_as_epub(self, book_id)
 
     @property
@@ -84,3 +96,25 @@ class CommonSaver(BaseSaver):
         :param value: New site string to set.
         """
         self._site = value
+
+    def _get_chapter(
+        self,
+        book_id: str,
+        chap_id: str,
+    ) -> Mapping[str, Any]:
+        for storage in self._chapter_storage_cache[book_id]:
+            data = storage.get(chap_id)
+            if data:
+                return data
+        return {}
+
+    def _init_chapter_storages(self, book_id: str) -> None:
+        raw_base = self.raw_data_dir / self._site / book_id
+        self._chapter_storage_cache[book_id] = [
+            ChapterStorage(
+                raw_base=raw_base,
+                namespace=ns,
+                backend_type=self._config.storage_backend,
+            )
+            for ns in self._chap_folders
+        ]