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

novel_downloader/core/parsers/qidian/{browser/main_parser.py → main_parser.py}

@@ -1,41 +1,40 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.parsers.qidian.browser.main_parser
---------------------------------------------------------
+novel_downloader.core.parsers.qidian.main_parser
+------------------------------------------------
 
-Main parser class for handling Qidian chapters rendered via a browser environment.
-
-This module defines `QidianBrowserParser`, a parser implementation that supports
-content extracted from dynamically rendered Qidian HTML pages.
+Main parser class for handling Qidian HTML
 """
 
 from __future__ import annotations
 
+import logging
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-from novel_downloader.config.models import ParserConfig
 from novel_downloader.core.parsers.base import BaseParser
-from novel_downloader.utils.chapter_storage import ChapterDict
+from novel_downloader.models import ChapterDict, ParserConfig
+from novel_downloader.utils.constants import DATA_DIR
+from novel_downloader.utils.cookies import find_cookie_value
 
-from ..shared import (
-    is_encrypted,
-    parse_book_info,
-)
+from .book_info_parser import parse_book_info
 from .chapter_router import parse_chapter
+from .utils import is_encrypted
+
+logger = logging.getLogger(__name__)
 
 if TYPE_CHECKING:
     from novel_downloader.utils.fontocr import FontOCR
 
 
-class QidianBrowserParser(BaseParser):
+class QidianParser(BaseParser):
     """
-    Parser for Qidian site using a browser-rendered HTML workflow.
+    Parser for Qidian site.
     """
 
     def __init__(self, config: ParserConfig):
         """
-        Initialize the QidianBrowserParser with the given configuration.
+        Initialize the QidianParser with the given configuration.
 
         :param config: ParserConfig object controlling:
         """
@@ -49,55 +48,65 @@ class QidianBrowserParser(BaseParser):
         self._fixed_font_dir.mkdir(parents=True, exist_ok=True)
         self._font_debug_dir: Path | None = None
 
+        state_files = [
+            DATA_DIR / "qidian" / "browser_state.cookies",
+            DATA_DIR / "qidian" / "session_state.cookies",
+        ]
+        self._fuid: str = find_cookie_value(state_files, "ywguid")
+
         self._font_ocr: FontOCR | None = None
         if self._decode_font:
-            from novel_downloader.utils.fontocr import FontOCR
-
-            self._font_ocr = FontOCR(
-                cache_dir=self._base_cache_dir,
-                use_freq=config.use_freq,
-                ocr_version=config.ocr_version,
-                use_ocr=config.use_ocr,
-                use_vec=config.use_vec,
-                batch_size=config.batch_size,
-                gpu_mem=config.gpu_mem,
-                gpu_id=config.gpu_id,
-                ocr_weight=config.ocr_weight,
-                vec_weight=config.vec_weight,
-                font_debug=config.save_font_debug,
-            )
-            self._font_debug_dir = self._base_cache_dir / "qidian" / "font_debug"
-            self._font_debug_dir.mkdir(parents=True, exist_ok=True)
+            try:
+                from novel_downloader.utils.fontocr import FontOCR
+            except ImportError:
+                logger.warning(
+                    "[QidianParser] FontOCR not available, font decoding will skip"
+                )
+            else:
+                self._font_ocr = FontOCR(
+                    cache_dir=self._base_cache_dir,
+                    use_freq=config.use_freq,
+                    use_ocr=config.use_ocr,
+                    use_vec=config.use_vec,
+                    batch_size=config.batch_size,
+                    gpu_mem=config.gpu_mem,
+                    gpu_id=config.gpu_id,
+                    ocr_weight=config.ocr_weight,
+                    vec_weight=config.vec_weight,
+                    font_debug=config.save_font_debug,
+                )
+                self._font_debug_dir = self._base_cache_dir / "qidian" / "font_debug"
+                self._font_debug_dir.mkdir(parents=True, exist_ok=True)
 
     def parse_book_info(
         self,
-        html_str: list[str],
+        html_list: list[str],
         **kwargs: Any,
     ) -> dict[str, Any]:
         """
         Parse a book info page and extract metadata and chapter structure.
 
-        :param html_str: Raw HTML of the book info page.
+        :param html_list: Raw HTML of the book info page.
         :return: Parsed metadata and chapter structure as a dictionary.
         """
-        if not html_str:
+        if not html_list:
             return {}
-        return parse_book_info(html_str[0])
+        return parse_book_info(html_list[0])
 
     def parse_chapter(
         self,
-        html_str: list[str],
+        html_list: list[str],
         chapter_id: str,
         **kwargs: Any,
     ) -> ChapterDict | None:
         """
-        :param html: Raw HTML of the chapter page.
+        :param html_list: Raw HTML of the chapter page.
         :param chapter_id: Identifier of the chapter being parsed.
         :return: Cleaned chapter content as plain text.
         """
-        if not html_str:
+        if not html_list:
             return None
-        return parse_chapter(self, html_str[0], chapter_id)
+        return parse_chapter(self, html_list[0], chapter_id)
 
     def is_encrypted(self, html_str: str) -> bool:
         """

novel_downloader/core/parsers/qidian/utils/__init__.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.parsers.qidian.utils
+------------------------------------------
+
+"""
+
+from .helpers import (
+    can_view_chapter,
+    extract_chapter_info,
+    find_ssr_page_context,
+    is_encrypted,
+    is_restricted_page,
+    vip_status,
+)
+from .node_decryptor import QidianNodeDecryptor, get_decryptor
+
+__all__ = [
+    "find_ssr_page_context",
+    "extract_chapter_info",
+    "is_restricted_page",
+    "vip_status",
+    "can_view_chapter",
+    "is_encrypted",
+    "QidianNodeDecryptor",
+    "get_decryptor",
+]

novel_downloader/core/parsers/qidian/utils/decryptor_fetcher.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+novel_downloader.core.parsers.qidian.utils.decryptor_fetcher
+------------------------------------------------------------
+
+Download and cache the *qidian-decryptor* executable from the project's
+GitHub releases.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import platform
+import stat
+from pathlib import Path
+from typing import Final
+
+import requests
+
+from novel_downloader.utils.constants import JS_SCRIPT_DIR
+
+DEST_ROOT: Final[Path] = JS_SCRIPT_DIR
+GITHUB_OWNER: Final = "BowenZ217"
+GITHUB_REPO: Final = "qidian-decryptor"
+RELEASE_VERSION: Final = "v1.0.1"
+BASE_URL: Final = f"https://github.com/{GITHUB_OWNER}/{GITHUB_REPO}/releases/download/{RELEASE_VERSION}"
+PLATFORM_BINARIES: Final[dict[str, str]] = {
+    "linux": "qidian-decryptor-linux",
+    "macos": "qidian-decryptor-macos",
+    "win": "qidian-decryptor-win.exe",
+}
+
+
+# --------------------------------------------------------------------------- #
+# API
+# --------------------------------------------------------------------------- #
+
+
+def ensure_decryptor(dest_root: Path | None = None) -> Path:
+    """
+    Ensure that the decryptor executable matching the current platform and
+    :data:`RELEASE_VERSION` exists locally; download it if necessary.
+
+    :param dest_root: Root directory used to cache the binary.
+                      If *None*, the global constant ``JS_SCRIPT_DIR`` is used.
+    :return: Path to the ready-to-use executable (inside the version sub-folder).
+    :raises RuntimeError: If the current platform is unsupported.
+    :raises ValueError: If the downloaded file fails SHA-256 verification.
+    """
+    dest_root = DEST_ROOT if dest_root is None else Path(dest_root).expanduser()
+    platform_key = _get_platform_key()
+
+    bin_name = PLATFORM_BINARIES[platform_key]
+    # 版本: /<version>/<binary>
+    version_dir = dest_root / RELEASE_VERSION.lstrip("v")
+    dest_path = version_dir / bin_name
+
+    if dest_path.exists():
+        return dest_path
+
+    version_dir.mkdir(parents=True, exist_ok=True)
+    _download_binary(platform_key, dest_path)
+    _make_executable(dest_path)
+
+    return dest_path
+
+
+# --------------------------------------------------------------------------- #
+# helper functions
+# --------------------------------------------------------------------------- #
+
+
+def _get_platform_key() -> str:
+    sys = platform.system().lower()
+    if "windows" in sys:
+        return "win"
+    if "linux" in sys:
+        return "linux"
+    if "darwin" in sys:
+        return "macos"
+    raise RuntimeError(f"Unsupported platform: {sys}")
+
+
+def _download_binary(platform_key: str, dest_path: Path) -> None:
+    """
+    Download the binary for *platform_key*, verify its SHA-256 checksum against
+    the release-wide ``SHA256SUMS`` manifest, and write it to *dest_path*.
+
+    :param platform_key: Key in :data:`PLATFORM_BINARIES` ("linux" | "macos" | "win").
+    :param dest_path: Target path where the binary will be saved.
+    :raises RuntimeError: If the checksum for the binary is missing in the manifest.
+    :raises ValueError: If the downloaded file fails SHA-256 verification.
+    """
+    bin_name = PLATFORM_BINARIES[platform_key]
+
+    manifest_url = f"{BASE_URL}/SHA256SUMS"
+    manifest_resp = requests.get(manifest_url, timeout=10)
+    manifest_resp.raise_for_status()
+
+    expected_hash: str | None = None
+    for line in manifest_resp.text.splitlines():
+        parts = line.strip().split()
+        if len(parts) == 2 and parts[1] == bin_name:
+            expected_hash = parts[0]
+            break
+
+    if expected_hash is None:
+        raise RuntimeError(f"Checksum for {bin_name!r} not found in SHA256SUMS")
+
+    file_url = f"{BASE_URL}/{bin_name}"
+    resp = requests.get(file_url, timeout=30)
+    resp.raise_for_status()
+    dest_path.write_bytes(resp.content)
+
+    if _sha256sum(dest_path) != expected_hash:
+        dest_path.unlink(missing_ok=True)
+        raise ValueError("SHA256 mismatch — download corrupted, file removed.")
+
+
+def _sha256sum(p: Path) -> str:
+    h = hashlib.sha256()
+    with p.open("rb") as f:
+        for chunk in iter(lambda: f.read(8192), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def _make_executable(p: Path) -> None:
+    """
+    Add executable permission bits on Unix-like systems; keep the file unchanged
+    on Windows. Any *PermissionError* raised by ``chmod`` is silently ignored.
+
+    :param p: Path to the downloaded binary that should be made executable.
+    """
+    try:
+        mode = p.stat().st_mode
+        p.chmod(mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+    except PermissionError:
+        pass
+
+
+__all__ = [
+    "ensure_decryptor",
+    "RELEASE_VERSION",
+]

novel_downloader/core/parsers/qidian/{shared → utils}/helpers.py

@@ -1,12 +1,11 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.parsers.qidian.shared.helpers
----------------------------------------------------
+novel_downloader.core.parsers.qidian.utils.helpers
+--------------------------------------------------
 
-Shared utility functions for parsing Qidian browser-rendered pages.
+Shared utility functions for parsing Qidian pages.
 
 This module provides reusable helpers to:
-- Convert HTML into BeautifulSoup objects with fallback.
 - Extract SSR-rendered JSON page context and structured chapter metadata.
 - Identify VIP chapters, encrypted content, and viewability conditions.
 """
@@ -15,28 +14,51 @@ import json
 import logging
 from typing import Any
 
-from bs4 import BeautifulSoup, Tag
+from lxml import html
 
 logger = logging.getLogger(__name__)
 
 
-def html_to_soup(html_str: str) -> BeautifulSoup:
+def find_ssr_page_context(html_str: str) -> dict[str, Any]:
     """
-    Convert an HTML string to a BeautifulSoup object with fallback.
-
-    :param html_str: Raw HTML string.
-    :return: Parsed BeautifulSoup object.
+    Extract SSR JSON from <script id="vite-plugin-ssr_pageContext">.
     """
     try:
-        return BeautifulSoup(html_str, "lxml")
+        tree = html.fromstring(html_str)
+        script = tree.xpath('//script[@id="vite-plugin-ssr_pageContext"]/text()')
+        if script:
+            data: dict[str, Any] = json.loads(script[0].strip())
+            return data
     except Exception as e:
-        logger.warning("[Parser] lxml parse failed, falling back: %s", e)
-        return BeautifulSoup(html_str, "html.parser")
+        logger.warning("[Parser] SSR JSON parse error: %s", e)
+    return {}
 
 
-def is_vip(html_str: str) -> bool:
+def extract_chapter_info(ssr_data: dict[str, Any]) -> dict[str, Any]:
     """
-    Return True if page indicates VIP‐only content.
+    Extract the 'chapterInfo' dictionary from the SSR page context.
+
+    This handles nested key access and returns an empty dict if missing.
+
+    :param ssr_data: The full SSR data object from _find_ssr_page_context().
+    :return: A dict with chapter metadata such as chapterName, authorSay, etc.
+    """
+    try:
+        page_context = ssr_data.get("pageContext", {})
+        page_props = page_context.get("pageProps", {})
+        page_data = page_props.get("pageData", {})
+        chapter_info = page_data.get("chapterInfo", {})
+
+        assert isinstance(chapter_info, dict)
+        return chapter_info
+    except Exception:
+        return {}
+
+
+def is_restricted_page(html_str: str) -> bool:
+    """
+    Return True if page content indicates access restriction
+    (e.g. not subscribed/purchased).
 
     :param html_str: Raw HTML string.
     """
@@ -44,38 +66,30 @@ def is_vip(html_str: str) -> bool:
     return any(m in html_str for m in markers)
 
 
-def vip_status(soup: BeautifulSoup) -> bool:
+def vip_status(ssr_data: dict[str, Any]) -> bool:
     """
-    :param soup: Parsed BeautifulSoup object of the HTML page.
     :return: True if VIP, False otherwise.
     """
-    ssr_data = find_ssr_page_context(soup)
     chapter_info = extract_chapter_info(ssr_data)
     vip_flag = chapter_info.get("vipStatus", 0)
     fens_flag = chapter_info.get("fEnS", 0)
     return bool(vip_flag == 1 and fens_flag != 0)
 
 
-def can_view_chapter(soup: BeautifulSoup) -> bool:
+def can_view_chapter(ssr_data: dict[str, Any]) -> bool:
     """
-    Return True if the chapter is viewable by the current user.
-
     A chapter is not viewable if it is marked as VIP
     and has not been purchased.
 
-    :param soup: Parsed BeautifulSoup object of the HTML page.
     :return: True if viewable, False otherwise.
     """
-    ssr_data = find_ssr_page_context(soup)
     chapter_info = extract_chapter_info(ssr_data)
-
     is_buy = chapter_info.get("isBuy", 0)
     vip_status = chapter_info.get("vipStatus", 0)
-
     return not (vip_status == 1 and is_buy == 0)
 
 
-def is_encrypted(content: str | BeautifulSoup) -> bool:
+def is_encrypted(content: str | dict[str, Any]) -> bool:
     """
     Return True if content is encrypted.
 
@@ -86,47 +100,6 @@ def is_encrypted(content: str | BeautifulSoup) -> bool:
     :param content: HTML content, either as a raw string or a BeautifulSoup object.
     :return: True if encrypted marker is found, else False.
     """
-    # main = soup.select_one("div#app div#reader-content main")
-    # return bool(main and "r-font-encrypt" in main.get("class", []))
-    # Normalize to BeautifulSoup
-    soup = html_to_soup(content) if isinstance(content, str) else content
-
-    ssr_data = find_ssr_page_context(soup)
+    ssr_data = find_ssr_page_context(content) if isinstance(content, str) else content
     chapter_info = extract_chapter_info(ssr_data)
     return int(chapter_info.get("cES", 0)) == 2
-
-
-def find_ssr_page_context(soup: BeautifulSoup) -> dict[str, Any]:
-    """
-    Extract SSR JSON from <script id="vite-plugin-ssr_pageContext">.
-    """
-    try:
-        tag = soup.find("script", id="vite-plugin-ssr_pageContext")
-        if isinstance(tag, Tag) and tag.string:
-            data: dict[str, Any] = json.loads(tag.string.strip())
-            return data
-    except Exception as e:
-        logger.warning("[Parser] SSR JSON parse error: %s", e)
-    return {}
-
-
-def extract_chapter_info(ssr_data: dict[str, Any]) -> dict[str, Any]:
-    """
-    Extract the 'chapterInfo' dictionary from the SSR page context.
-
-    This handles nested key access and returns an empty dict if missing.
-
-    :param ssr_data: The full SSR data object from _find_ssr_page_context().
-    :return: A dict with chapter metadata such as chapterName, authorSay, etc.
-    """
-    try:
-        page_context = ssr_data.get("pageContext", {})
-        page_props = page_context.get("pageProps", {})
-        page_data = page_props.get("pageData", {})
-        chapter_info = page_data.get("chapterInfo", {})
-
-        assert isinstance(chapter_info, dict)
-        return chapter_info
-    except Exception as e:
-        logger.warning("[Parser] Failed to extract chapterInfo: %s", e)
-        return {}

novel_downloader/core/parsers/qidian/{session → utils}/node_decryptor.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python3
 """
-novel_downloader.core.parsers.qidian.session.node_decryptor
------------------------------------------------------------
+novel_downloader.core.parsers.qidian.utils.node_decryptor
+---------------------------------------------------------
 
 Provides QidianNodeDecryptor, which ensures a Node.js environment,
 downloads or installs the required JS modules (Fock + decrypt script),
@@ -20,6 +20,8 @@ from novel_downloader.utils.constants import (
     QD_DECRYPT_SCRIPT_PATH,
 )
 
+from .decryptor_fetcher import ensure_decryptor
+
 logger = logging.getLogger(__name__)
 
 
@@ -49,59 +51,60 @@ class QidianNodeDecryptor:
 
     def __init__(self) -> None:
         """
-        Prepare the script directory and verify that both Node.js
-        and the necessary JS files are available.
+        Initialise the decryptor environment and decide which executable will be
+        used (`node` script or the pre-built binary).
         """
         self.script_dir: Path = JS_SCRIPT_DIR
         self.script_dir.mkdir(parents=True, exist_ok=True)
-        self.script_path: Path = self.QIDIAN_DECRYPT_SCRIPT_PATH
+
+        self._script_cmd: list[str] | None = None
         self._check_environment()
 
     def _check_environment(self) -> None:
         """
-        Ensure Node.js is installed, our decrypt script is copied from
-        package resources, and the Fock JS module is downloaded.
-
-        :raises EnvironmentError: if `node` is not on the system PATH.
+        Decide which decryptor backend to use and make sure it is ready.
         """
-        # 1) Check Node.js
-        if not shutil.which("node"):
-            raise OSError("Node.js is not installed or not in PATH.")
-
-        # 2) Copy bundled decrypt script into place if missing
-        if not self.QIDIAN_DECRYPT_SCRIPT_PATH.exists():
-            try:
-                resource = QD_DECRYPT_SCRIPT_PATH
-                shutil.copyfile(str(resource), str(self.QIDIAN_DECRYPT_SCRIPT_PATH))
-                logger.info(
-                    "[decryptor] Copied decrypt script to %s",
-                    self.QIDIAN_DECRYPT_SCRIPT_PATH,
-                )
-            except Exception as e:
-                logger.error("[decryptor] Failed to copy decrypt script: %s", e)
-                raise
-
-        # 3) Download the Fock JS module from Qidian CDN if missing
-        if not self.QIDIAN_FOCK_JS_PATH.exists():
-            from novel_downloader.utils.network import download_js_file
-
+        try:
+            # 1) Check Node.js
+            if not shutil.which("node"):
+                raise OSError("Node.js is not installed or not in PATH.")
+
+            # 2) Copy bundled decrypt script into place if missing
+            if not self.QIDIAN_DECRYPT_SCRIPT_PATH.exists():
+                try:
+                    resource = QD_DECRYPT_SCRIPT_PATH
+                    shutil.copyfile(str(resource), str(self.QIDIAN_DECRYPT_SCRIPT_PATH))
+                except Exception as e:
+                    logger.error("[decryptor] Failed to copy decrypt script: %s", e)
+                    raise
+
+            # 3) Download the Fock JS module from Qidian CDN if missing
+            if not self.QIDIAN_FOCK_JS_PATH.exists():
+                from novel_downloader.utils.network import download_js_file
+
+                try:
+                    download_js_file(
+                        self.QIDIAN_FOCK_JS_URL,
+                        self.script_dir,
+                        on_exist="overwrite",
+                    )
+                except Exception as e:
+                    logger.error("[decryptor] Failed to download Fock JS module: %s", e)
+                    raise
+            self._script_cmd = ["node", str(self.QIDIAN_DECRYPT_SCRIPT_PATH)]
+            return
+        except Exception:
             try:
-                download_js_file(
-                    self.QIDIAN_FOCK_JS_URL,
-                    self.script_dir,
-                    on_exist="overwrite",
-                )
-                logger.info(
-                    "[decryptor] Downloaded Fock module to %s", self.QIDIAN_FOCK_JS_PATH
-                )
-            except Exception as e:
-                logger.error("[decryptor] Failed to download Fock JS module: %s", e)
-                raise
+                self._script_cmd = [str(ensure_decryptor(self.script_dir))]
+            except Exception as exc:
+                raise OSError(
+                    "Neither Node.js nor fallback binary is available."
+                ) from exc
 
     def decrypt(
         self,
         ciphertext: str | bytes,
-        chapter_id: str | int,
+        chapter_id: str,
         fkp: str,
         fuid: str,
     ) -> str:
@@ -115,6 +118,10 @@ class QidianNodeDecryptor:
         :return: The decrypted plain-text content.
         :raises RuntimeError: if the Node.js subprocess exits with a non-zero code.
         """
+        if not self._script_cmd:
+            return ""
+        if not (ciphertext and chapter_id and fkp and fuid):
+            return ""
         # Normalize inputs
         cipher_str = (
             ciphertext.decode("utf-8")
@@ -135,15 +142,9 @@ class QidianNodeDecryptor:
                 encoding="utf-8",
             )
 
-            logger.debug(
-                "[decryptor] Invoking Node.js: node %s %s %s",
-                self.script_path.name,
-                input_path.name,
-                output_path.name,
-            )
-
+            cmd = self._script_cmd + [input_path.name, output_path.name]
             proc = subprocess.run(
-                ["node", self.script_path.name, input_path.name, output_path.name],
+                cmd,
                 capture_output=True,
                 text=True,
                 cwd=str(self.script_dir),
@@ -159,3 +160,16 @@ class QidianNodeDecryptor:
             # Clean up temp files
             input_path.unlink(missing_ok=True)
             output_path.unlink(missing_ok=True)
+
+
+_decryptor: QidianNodeDecryptor | None = None
+
+
+def get_decryptor() -> QidianNodeDecryptor:
+    """
+    Return the singleton QidianNodeDecryptor, initializing it on first use.
+    """
+    global _decryptor
+    if _decryptor is None:
+        _decryptor = QidianNodeDecryptor()
+    return _decryptor