novel-downloader 2.0.0__py3-none-any.whl → 2.0.2__py3-none-any.whl

novel_downloader/core/parsers/qidian/chapter_router.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.chapter_router
----------------------------------------------------
-
-Routing logic for selecting the correct chapter parser for Qidian pages.
-"""
-
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING
-
-from novel_downloader.models import ChapterDict
-
-from .chapter_normal import parse_normal_chapter
-from .utils import (
-    can_view_chapter,
-    find_ssr_page_context,
-    is_encrypted,
-)
-
-if TYPE_CHECKING:
-    from .main_parser import QidianParser
-
-logger = logging.getLogger(__name__)
-
-
-def parse_chapter(
-    parser: QidianParser,
-    html_str: str,
-    chapter_id: str,
-) -> ChapterDict | None:
-    """
-    Extract and return the formatted textual content of chapter.
-
-    :param parser: Instance of QidianParser.
-    :param html_str: Raw HTML content of the chapter page.
-    :param chapter_id: Identifier of the chapter being parsed.
-    :return: Formatted chapter text or empty string if not parsable.
-    """
-    try:
-        ssr_data = find_ssr_page_context(html_str)
-
-        if not can_view_chapter(ssr_data):
-            logger.warning(
-                "[Parser] Chapter '%s' is not purchased or inaccessible.", chapter_id
-            )
-            return None
-
-        if is_encrypted(ssr_data):
-            if not parser._decode_font:
-                return None
-            try:
-                from .chapter_encrypted import parse_encrypted_chapter
-
-                return parse_encrypted_chapter(parser, html_str, chapter_id)
-            except ImportError:
-                logger.warning(
-                    "[Parser] Encrypted chapter '%s' requires extra dependencies.",
-                    chapter_id,
-                )
-                return None
-
-        return parse_normal_chapter(parser, html_str, chapter_id)
-    except Exception as e:
-        logger.warning("[Parser] parse error for chapter '%s': %s", chapter_id, e)
-    return None

novel_downloader/core/parsers/qidian/main_parser.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.main_parser
-------------------------------------------------
-
-Main parser class for handling Qidian HTML
-"""
-
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-from typing import Any
-
-from novel_downloader.core.parsers.base import BaseParser
-from novel_downloader.core.parsers.registry import register_parser
-from novel_downloader.models import (
-    BookInfoDict,
-    ChapterDict,
-    ParserConfig,
-)
-from novel_downloader.utils.constants import DATA_DIR
-from novel_downloader.utils.cookies import get_cookie_value
-
-from .book_info_parser import parse_book_info
-from .chapter_router import parse_chapter
-from .utils import is_encrypted
-
-logger = logging.getLogger(__name__)
-
-
-@register_parser(
-    site_keys=["qidian", "qd"],
-)
-class QidianParser(BaseParser):
-    """
-    Parser for 起点中文网 site.
-    """
-
-    def __init__(
-        self,
-        config: ParserConfig,
-        fuid: str = "",
-    ):
-        """
-        Initialize the QidianParser with the given configuration.
-
-        :param config: ParserConfig object controlling:
-        """
-        super().__init__(config)
-
-        self._fixed_font_dir: Path = self._base_cache_dir / "fixed_fonts"
-        self._fixed_font_dir.mkdir(parents=True, exist_ok=True)
-        self._debug_dir: Path = Path.cwd() / "debug"
-
-        state_files = [
-            DATA_DIR / "qidian" / "session_state.cookies",
-        ]
-        self._fuid: str = fuid or get_cookie_value(state_files, "ywguid")
-
-    def parse_book_info(
-        self,
-        html_list: list[str],
-        **kwargs: Any,
-    ) -> BookInfoDict | None:
-        """
-        Parse a book info page and extract metadata and chapter structure.
-
-        :param html_list: Raw HTML of the book info page.
-        :return: Parsed metadata and chapter structure as a dictionary.
-        """
-        if not html_list:
-            return None
-        return parse_book_info(html_list[0])
-
-    def parse_chapter(
-        self,
-        html_list: list[str],
-        chapter_id: str,
-        **kwargs: Any,
-    ) -> ChapterDict | None:
-        """
-        :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_list:
-            return None
-        return parse_chapter(self, html_list[0], chapter_id)
-
-    def is_encrypted(self, html_str: str) -> bool:
-        """
-        Return True if content is encrypted.
-
-        :param html: Raw HTML of the chapter page.
-        """
-        return is_encrypted(html_str)
-
-    @property
-    def save_font_debug(self) -> bool:
-        return self._config.save_font_debug

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

@@ -1,30 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.utils
-------------------------------------------
-
-Utility functions and helpers for parsing and decrypting Qidian novel pages
-"""
-
-__all__ = [
-    "find_ssr_page_context",
-    "extract_chapter_info",
-    "is_restricted_page",
-    "vip_status",
-    "can_view_chapter",
-    "is_encrypted",
-    "is_duplicated",
-    "QidianNodeDecryptor",
-    "get_decryptor",
-]
-
-from .helpers import (
-    can_view_chapter,
-    extract_chapter_info,
-    find_ssr_page_context,
-    is_duplicated,
-    is_encrypted,
-    is_restricted_page,
-    vip_status,
-)
-from .node_decryptor import QidianNodeDecryptor, get_decryptor

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

@@ -1,143 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.utils.fontmap_recover
-----------------------------------------------------------
-
-Tools for generating and applying font character mappings
-to recover obfuscated Qidian text.
-"""
-
-__all__ = [
-    "generate_font_map",
-    "apply_font_mapping",
-]
-
-import json
-import logging
-from pathlib import Path
-
-import numpy as np
-from fontTools.ttLib import TTFont
-from PIL import ImageFont
-
-logger = logging.getLogger(__name__)
-CHAR_FONT_SIZE = 52
-
-
-def generate_font_map(
-    fixed_font_path: Path,
-    random_font_path: Path,
-    char_set: set[str],
-    refl_set: set[str],
-    cache_dir: Path,
-    batch_size: int = 32,
-) -> dict[str, str]:
-    """
-    Build a mapping from scrambled font chars to real chars.
-
-    Uses OCR to compare rendered glyphs from a known (fixed) font and an
-    obfuscated (random) font. Results are cached in JSON so repeated runs
-    are faster.
-
-    :param fixed_font_path: fixed font file.
-    :param random_font_path: random font file.
-    :param char_set: Characters to match directly.
-    :param refl_set: Characters to match in flipped form.
-    :param cache_dir: Directory to save/load cached results.
-    :param batch_size: How many chars to OCR per batch.
-
-    :return: { obf_char: real_char, ... }
-    """
-    try:
-        from novel_downloader.utils.fontocr import get_font_ocr
-
-        font_ocr = get_font_ocr(batch_size=batch_size)
-    except ImportError:
-        logger.warning("[QidianParser] FontOCR not available, font decoding will skip")
-        return {}
-
-    mapping_result: dict[str, str] = {}
-    fixed_map_file = cache_dir / "fixed_font_map" / f"{Path(fixed_font_path).stem}.json"
-    fixed_map_file.parent.mkdir(parents=True, exist_ok=True)
-
-    # load existing cache
-    try:
-        with open(fixed_map_file, encoding="utf-8") as f:
-            fixed_map = json.load(f)
-        cached_chars = set(fixed_map.keys())
-        mapping_result.update({ch: fixed_map[ch] for ch in char_set if ch in fixed_map})
-        mapping_result.update({ch: fixed_map[ch] for ch in refl_set if ch in fixed_map})
-        char_set = set(char_set) - cached_chars
-        refl_set = set(refl_set) - cached_chars
-    except Exception:
-        fixed_map = {}
-        cached_chars = set()
-
-    # prepare font renderers and cmap sets
-    try:
-        fixed_ttf = TTFont(fixed_font_path)
-        fixed_chars = {chr(c) for c in fixed_ttf.getBestCmap()}
-        fixed_font = ImageFont.truetype(str(fixed_font_path), CHAR_FONT_SIZE)
-
-        random_ttf = TTFont(random_font_path)
-        random_chars = {chr(c) for c in random_ttf.getBestCmap()}
-        random_font = ImageFont.truetype(str(random_font_path), CHAR_FONT_SIZE)
-    except Exception as e:
-        logger.error("[FontOCR] Failed to load TTF fonts: %s", e)
-        return mapping_result
-
-    def _render_batch(chars: list[tuple[str, bool]]) -> list[tuple[str, np.ndarray]]:
-        out = []
-        for ch, reflect in chars:
-            if ch in fixed_chars:
-                font = fixed_font
-            elif ch in random_chars:
-                font = random_font
-            else:
-                continue
-            img = font_ocr.render_char_image_array(ch, font, reflect)
-            if img is not None:
-                out.append((ch, img))
-        return out
-
-    # process normal and reflected sets together
-    for chars, reflect in [(list(char_set), False), (list(refl_set), True)]:
-        for batch_chars in font_ocr._chunked(chars, font_ocr._batch_size):
-            # render all images in this batch
-            to_render = [(ch, reflect) for ch in batch_chars]
-            rendered = _render_batch(to_render)
-            if not rendered:
-                continue
-
-            # query OCR+vec simultaneously
-            imgs_to_query = [img for (ch, img) in rendered]
-            fused = font_ocr.predict(imgs_to_query, top_k=1)
-
-            # pick best per char, apply threshold + cache
-            for (ch, _), preds in zip(rendered, fused, strict=False):
-                if not preds:
-                    continue
-                real_char, _ = preds[0]
-                mapping_result[ch] = real_char
-                fixed_map[ch] = real_char
-
-    # persist updated fixed_map
-    try:
-        with open(fixed_map_file, "w", encoding="utf-8") as f:
-            json.dump(fixed_map, f, ensure_ascii=False, indent=2)
-    except Exception as e:
-        logger.error("[FontOCR] Failed to save fixed map: %s", e)
-
-    return mapping_result
-
-
-def apply_font_mapping(text: str, font_map: dict[str, str]) -> str:
-    """
-    Replace each character in `text` using `font_map`,
-    leaving unmapped characters unchanged.
-
-    :param text: The input string, possibly containing obfuscated font chars.
-    :param font_map: A dict mapping obfuscated chars to real chars.
-    :return: The de-obfuscated text.
-    """
-    return "".join(font_map.get(ch, ch) for ch in text)

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

@@ -1,110 +0,0 @@
-#!/usr/bin/env python3
-"""
-novel_downloader.core.parsers.qidian.utils.helpers
---------------------------------------------------
-
-Shared utility functions for parsing Qidian pages.
-"""
-
-import json
-import logging
-from typing import Any
-
-from lxml import html
-
-logger = logging.getLogger(__name__)
-
-
-def find_ssr_page_context(html_str: str) -> dict[str, Any]:
-    """
-    Extract SSR JSON from <script id="vite-plugin-ssr_pageContext">.
-    """
-    try:
-        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] 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:
-        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.
-    """
-    markers = ["这是VIP章节", "需要订阅", "订阅后才能阅读"]
-    return any(m in html_str for m in markers)
-
-
-def vip_status(ssr_data: dict[str, Any]) -> bool:
-    """
-    :return: True if VIP, False otherwise.
-    """
-    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(ssr_data: dict[str, Any]) -> bool:
-    """
-    A chapter is not viewable if it is marked as VIP
-    and has not been purchased.
-
-    :return: True if viewable, False otherwise.
-    """
-    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_duplicated(ssr_data: dict[str, Any]) -> bool:
-    """
-    Check if chapter is marked as duplicated (eFW = 1).
-    """
-    chapter_info = extract_chapter_info(ssr_data)
-    efw_flag = chapter_info.get("eFW", 0)
-    return bool(efw_flag == 1)
-
-
-def is_encrypted(content: str | dict[str, Any]) -> bool:
-    """
-    Return True if content is encrypted.
-
-    Chapter Encryption Status (cES):
-    - 0: 内容是'明文'
-    - 2: 字体加密
-
-    :param content: HTML content, either as a raw string or a BeautifulSoup object.
-    :return: True if encrypted marker is found, else False.
-    """
-    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

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

@@ -1,175 +0,0 @@
-#!/usr/bin/env python3
-"""
-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),
-and invokes a Node.js subprocess to decrypt Qidian chapter content.
-"""
-
-import json
-import logging
-import shutil
-import subprocess
-import uuid
-from pathlib import Path
-
-from novel_downloader.utils.constants import (
-    JS_SCRIPT_DIR,
-    QD_DECRYPT_SCRIPT_PATH,
-)
-
-from .decryptor_fetcher import ensure_decryptor
-
-logger = logging.getLogger(__name__)
-
-
-class QidianNodeDecryptor:
-    """
-    A decryptor that uses Node.js plus Qidian's Fock JavaScript module
-    to decrypt encrypted chapter payloads.
-
-    On initialization, this class will:
-      1. Verify that `node` is on PATH.
-      2. Copy our bundled `qidian_decrypt_node.js` into `JS_SCRIPT_DIR`.
-      3. Download the remote Fock module JS if not already present.
-
-    Calling `decrypt()` will:
-      - Write a temp JSON input file with [ciphertext, chapter_id, fkp, fuid].
-      - Spawn `node qidian_decrypt_node.js <in> <out>`.
-      - Read and return the decrypted text.
-      - Clean up the temp files.
-    """
-
-    QIDIAN_FOCK_JS_URL: str = (
-        "https://cococdn.qidian.com/coco/s12062024/4819793b.qeooxh.js"
-    )
-    QIDIAN_FOCK_JS_PATH: Path = JS_SCRIPT_DIR / "4819793b.qeooxh.js"
-    QIDIAN_DECRYPT_SCRIPT_FILE: str = "qidian_decrypt_node.js"
-    QIDIAN_DECRYPT_SCRIPT_PATH: Path = JS_SCRIPT_DIR / QIDIAN_DECRYPT_SCRIPT_FILE
-
-    def __init__(self) -> None:
-        """
-        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_cmd: list[str] | None = None
-        self._check_environment()
-
-    def _check_environment(self) -> None:
-        """
-        Decide which decryptor backend to use and make sure it is ready.
-        """
-        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
-
-                try:
-                    download(
-                        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:
-                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,
-        fkp: str,
-        fuid: str,
-    ) -> str:
-        """
-        Decrypt a chapter payload via our Node.js script.
-
-        :param ciphertext: Base64-encoded encrypted content (str or bytes).
-        :param chapter_id: The chapter's numeric ID.
-        :param fkp: Base64-encoded Fock key param from the page.
-        :param fuid: Fock user ID param from the page.
-        :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")
-            if isinstance(ciphertext, (bytes | bytearray))
-            else str(ciphertext)
-        )
-        chapter_str = str(chapter_id)
-
-        # Create unique temp file names
-        task_id = uuid.uuid4().hex
-        input_path = self.script_dir / f"input_{task_id}.json"
-        output_path = self.script_dir / f"output_{task_id}.txt"
-
-        try:
-            # Write arguments as JSON array
-            input_path.write_text(
-                json.dumps([cipher_str, chapter_str, fkp, fuid]),
-                encoding="utf-8",
-            )
-
-            cmd = self._script_cmd + [input_path.name, output_path.name]
-            proc = subprocess.run(
-                cmd,
-                capture_output=True,
-                text=True,
-                cwd=str(self.script_dir),
-            )
-
-            if proc.returncode != 0:
-                raise RuntimeError(f"Node error: {proc.stderr.strip()}")
-
-            # Return decrypted content
-            return output_path.read_text(encoding="utf-8").strip()
-
-        finally:
-            # 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